dolphindb 2.0.600 → 2.0.601

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 (12) hide show
  1. package/browser.d.ts +8 -1
  2. package/browser.js +62 -1
  3. package/browser.js.map +1 -1
  4. package/docs.en.json +858 -129
  5. package/docs.zh.json +3080 -256
  6. package/index.d.ts +3 -0
  7. package/index.js +61 -0
  8. package/index.js.map +1 -1
  9. package/language.d.ts +1 -1
  10. package/language.js +0 -2
  11. package/language.js.map +1 -1
  12. package/package.json +1 -1
package/docs.zh.json CHANGED
@@ -2542,7 +2542,7 @@
2542
2542
  "value": [
2543
2543
  "`X` 是有时间类型索引的矩阵（由 :doc:`../s/setIndexedMatrix!` 创建）或序列（由 :doc:`../s/setIndexedSeries!` 创建）。",
2544
2544
  "",
2545
- "`Y` 可以是一个字符串，可取以下值，亦可为一个时间类型的向量。",
2545
+ "`rule` 可以是一个字符串，可取以下值，亦可为一个时间类型的向量。",
2546
2546
  "",
2547
2547
  "============ =================",
2548
2548
  "Y参数取值 对应DolphinDB函数",
@@ -2561,10 +2561,12 @@
2561
2561
  "\"QS\" quarterBegin",
2562
2562
  "\"BQ\" businessQuarterEnd",
2563
2563
  "\"BQS\" businessQuarterBegin",
2564
+ "\"REQ\" FY5253Quarter",
2564
2565
  "\"A\" yearEnd",
2565
2566
  "\"AS\" yearBegin",
2566
2567
  "\"BA\" businessYearEnd",
2567
2568
  "\"BAS\" businessYearBegin",
2569
+ "\"RE\" FY5253",
2568
2570
  "\"D\" date",
2569
2571
  "\"H\" hourOfDay",
2570
2572
  "\"min\" minuteOfHour",
@@ -2574,7 +2576,7 @@
2574
2576
  "\"N\" nanosecond",
2575
2577
  "============ =================",
2576
2578
  "",
2577
- "参数 *Y* 字符串亦可配合使用数字，例如\"2M\"表示频率为每两个月。",
2579
+ "参数 *rule* 字符串亦可配合使用数字，例如\"2M\"表示频率为每两个月。",
2578
2580
  "",
2579
2581
  "`closed` 字符串，表示分组区间哪一个边界是闭合的。",
2580
2582
  "",
@@ -6468,7 +6470,7 @@
6468
6470
  {
6469
6471
  "type": "text",
6470
6472
  "value": [
6471
- "取消已经提交但尚未完成的批处理作业。"
6473
+ "取消已经提交但尚未完成的批处理作业。1.30.19 / 2.00.7 版本后，若执行 cancelJob 时，发现某个 jobId 不存在，系统不再抛出异常，而是将包含 jobId 的报错信息输出到日志。"
6472
6474
  ]
6473
6475
  }
6474
6476
  ]
@@ -6502,6 +6504,26 @@
6502
6504
  " $ submitJob(myJobId,\"write data to dfs table\",writeData,120);",
6503
6505
  " $ cancelJob(myJobId);",
6504
6506
  "",
6507
+ ""
6508
+ ]
6509
+ },
6510
+ {
6511
+ "type": "text",
6512
+ "value": [
6513
+ "取消集群中所有未完成的 job。",
6514
+ ""
6515
+ ]
6516
+ },
6517
+ {
6518
+ "type": "code",
6519
+ "language": "console",
6520
+ "value": [
6521
+ "",
6522
+ " $ def cancelAllBatchJob(){",
6523
+ " $ jobids=exec jobid from getRecentJobs() where endTime=NULL",
6524
+ " $ cancelJob(jobids)\t",
6525
+ " $ }",
6526
+ " $ pnodeRun(cancelAllBatchJob)",
6505
6527
  "",
6506
6528
  ""
6507
6529
  ]
@@ -10774,7 +10796,7 @@
10774
10796
  "value": [
10775
10797
  "把源节点上的一个或多个chunk的副本复制到目标节点。如果目标节点上已经存在该chunk，那么系统将忽略本次操作。该命令只能由管理员在控制节点上执行。",
10776
10798
  "",
10777
- "通过 *getRecoveryTaskStatus* 函数可以查看任务状态。"
10799
+ "通过 :doc:`/FunctionsandCommands/FunctionReferences/g/getRecoveryTaskStatus` 函数可以查看任务状态。"
10778
10800
  ]
10779
10801
  }
10780
10802
  ]
@@ -11718,7 +11740,12 @@
11718
11740
  "",
11719
11741
  "\\(3) 最后为计算结果列，可为多列。",
11720
11742
  "",
11721
- "`metrics` 必选参数，以元代码的格式表示计算指标。可以是一个或多个表达式、系统内置或用户自定义函数，但不能是聚合函数。*metrics* 内支持调用具有多个返回值的函数，且必须指定列名，例如 <func(price) as \\`col1\\`col2>。有关元代码的更多信息可参考 :doc:`/Objects/Metaprogramming`。",
11743
+ "`metrics` 以元代码的格式表示计算指标，支持输入元组。有关元代码的更多信息可参考 :doc:`/Objects/Metaprogramming`。",
11744
+ "",
11745
+ "* 计算指标可以是一个或多个表达式、系统内置或用户自定义函数，但不能是聚合函数。",
11746
+ "* *metrics* 内支持调用具有多个返回值的函数，且必须指定列名，例如 <func(price) as \\`col1\\`col2>。",
11747
+ "",
11748
+ "请注意，若 *metrics* 中指定了左右表列名相同的时间列或者连接列，默认取左表中的列。如果需要取右表中的列，在列前加上右表名。例如：*matchingColumn* = \\`sym, *timeColumn* = \\`timestamp，则 *metrics* = <[rightTable.sym, rightTable.timestamp, price, val, price*val]> 指定 *metrics* 中输出右表的 sym 列和 timestamp 列。",
11722
11749
  "",
11723
11750
  "`matchingColumn` 表示连接列的字符串标量/向量/tuple，支持 Integral, Temproal 或 Literal（UUID 除外）类型。",
11724
11751
  "",
@@ -12170,7 +12197,7 @@
12170
12197
  "",
12171
12198
  "`mergeSessionEnd` 为可选参数，是一个布尔值，表示每一个区间的计算是否包括其结束时刻（规整后的时刻）的数据。默认值为 false。",
12172
12199
  "",
12173
- "`forceTriggerSessionEndTime` 可选参数，是正整数，单位为秒。若 *sessionEnd* 时刻对应的窗口数据未计算输出，通过该参数设置系统经过多少时间后触发计算并输出。若不指定 *fill* ，未包含在该窗口内的分组不会输出结果；若指定了 *fill* ，未包含在该窗口内的分组会按照 *fill* 指定的方式输出结果。",
12200
+ "`forceTriggerSessionEndTime` 可选参数，是正整数，单位与 *timeColumn* 的时间精度一致。若 *sessionEnd* 时刻对应的窗口数据未计算输出，通过该参数设置系统经过多少时间后触发计算并输出。若不指定 *fill* ，未包含在该窗口内的分组不会输出结果；若指定了 *fill* ，未包含在该窗口内的分组会按照 *fill* 指定的方式输出结果。",
12174
12201
  "",
12175
12202
  "注：",
12176
12203
  "",
@@ -12487,6 +12514,133 @@
12487
12514
  }
12488
12515
  ]
12489
12516
  },
12517
+ "createDualOwnershipReactiveStateEngine": {
12518
+ "title": "createDualOwnershipReactiveStateEngine",
12519
+ "type": "function",
12520
+ "children": [
12521
+ {
12522
+ "title": "语法",
12523
+ "type": "grammer",
12524
+ "children": [
12525
+ {
12526
+ "type": "text",
12527
+ "value": [
12528
+ "createDualOwnershipReactiveStateEngine(name, metrics1, metrics2, dummyTable, outputTable, keyColumn1, keyColumn2, [snapshotDir], [snapshotIntervalInMsgCount], [keyPurgeFilter1], [keyPurgeFilter2], [keyPurgeFreqInSecond=0], [raftGroup])"
12529
+ ]
12530
+ }
12531
+ ]
12532
+ },
12533
+ {
12534
+ "title": "参数",
12535
+ "type": "parameters",
12536
+ "children": [
12537
+ {
12538
+ "type": "text",
12539
+ "value": [
12540
+ "``createDualOwnershipReactiveStateEngine`` 与 :doc:`createReactiveStateEngine` 参数基本一致，这里仅介绍有区别的参数：",
12541
+ "",
12542
+ "对 keyColumn1 分组后的数据按照 metrics1 进行计算，分组数据的清条件则由参数 keyPurgeFilter1 设置。",
12543
+ "",
12544
+ "对 keyColumn2 分组后的数据按照 metrics2 进行计算，分组数据的清条件则由参数 keyPurgeFilter2 设置。",
12545
+ "",
12546
+ "`outputTable` 结果的输出表，可以是内存表或者分布式表。使用 ``createDualOwnershipReactiveStateEngine`` 函数之前，需要将输出表预先设立为一个空表，并指定各列列名以及数据类型。",
12547
+ "",
12548
+ "输出表的各列的顺序为：分组列，计算结果列。",
12549
+ "",
12550
+ "其中：",
12551
+ "",
12552
+ "(1) 输出表的前几列为 keyColumn1 和 keyColumn2 的公共列，然后依次为 keyColumn1 的非公共列和 keyColumn2 的非公共列。",
12553
+ "",
12554
+ "(2) 其后为 metrics1 的计算结果列，metrics2 的计算结果列。"
12555
+ ]
12556
+ }
12557
+ ]
12558
+ },
12559
+ {
12560
+ "title": "详情",
12561
+ "type": "detail",
12562
+ "children": [
12563
+ {
12564
+ "type": "text",
12565
+ "value": [
12566
+ "Dual Ownership Reactive State Engine 是对响应式状态引擎的扩展，支持对同一张流数据表指定两种不同的分组方式分别应用不同的指标进行并行计算。与响应式状态级联实现相比，调用该函数进行计算极大地提升了计算性能。",
12567
+ "",
12568
+ "注意：该引擎输出和输入顺序保持一致，即内部强制使 keepOrder = True。"
12569
+ ]
12570
+ }
12571
+ ]
12572
+ },
12573
+ {
12574
+ "title": "例子",
12575
+ "type": "example",
12576
+ "children": [
12577
+ {
12578
+ "type": "code",
12579
+ "language": "console",
12580
+ "value": [
12581
+ " ",
12582
+ " $ share streamTable(1:0, `date`time`sym`market`price`qty, [DATE, TIME, SYMBOL, CHAR, DOUBLE, INT]) as trades",
12583
+ " $ outputTable = table(100:0, `date`sym`market`factor1`factor2, [DATE, SYMBOL, CHAR, DOUBLE, DOUBLE])",
12584
+ " $ dors = createDualOwnershipReactiveStateEngine(name=\"test\", metrics1=<mfirst(price, 3)>, metrics2=<mmax(price, 3)>, dummyTable=trades, outputTable=outputTable, keyColumn1=`date`sym, keyColumn2=`date`market)",
12585
+ " $ tmp = table(1:0, `date`time`sym`market`price`qty, [DATE, TIME, SYMBOL, CHAR, DOUBLE, INT]) ",
12586
+ " $ subscribeTable(tableName=`trades, actionName=\"test\",msgAsTable=true, handler=tableInsert{dors})",
12587
+ " $ insert into tmp values(2012.01.01, 09:00:00.030, `a, 'B', 10.65, 1500)",
12588
+ " $ insert into tmp values(2012.01.01, 09:00:00.030, `a, 'B', 10.59, 2500)",
12589
+ " $ insert into tmp values(2012.01.01, 09:00:00.031, `b, 'A', 10.59, 2500)",
12590
+ " $ insert into tmp values(2012.01.01, 09:00:00.031, `a, 'B', 10.65, 1500)",
12591
+ " $ insert into tmp values(2012.01.01, 09:00:00.031, `a, 'A', 10.59, 2500)",
12592
+ " $ insert into tmp values(2012.01.01, 09:00:00.033, `b, 'B', 10.59, 2500)",
12593
+ " $ insert into tmp values(2012.01.01, 09:00:00.033, `a, 'A', 10.59, 2500)",
12594
+ " $ insert into tmp values(2012.01.01, 09:00:00.034, `b, 'A', 10.59, 2500)",
12595
+ " $ insert into tmp values(2012.01.01, 09:00:00.034, `b, 'A', 10.22, 1200)",
12596
+ " $ insert into tmp values(2012.01.01, 09:00:00.035, `a, 'A', 11.0, 2500)",
12597
+ " $ insert into tmp values(2012.01.02, 09:00:00.031, `b, 'A', 10.22, 1200)",
12598
+ " $ insert into tmp values(2012.01.02, 09:00:00.032, `a, 'B', 11.0, 2500)",
12599
+ " $ insert into tmp values(2012.01.02, 09:00:00.032, `b, 'B', 15.6, 1300)",
12600
+ " $ insert into tmp values(2012.01.02, 09:00:00.040, `c, 'B', 13.2, 2000)",
12601
+ " $ trades.append!(tmp)",
12602
+ " $ select * from outputTable",
12603
+ ""
12604
+ ]
12605
+ },
12606
+ {
12607
+ "type": "text",
12608
+ "value": [
12609
+ "========== ==== ======= ======== ========",
12610
+ "date sym market factor1 factor2",
12611
+ "========== ==== ======= ======== ========",
12612
+ "2012.01.01 a 'B' ",
12613
+ "2012.01.01 a 'B' ",
12614
+ "2012.01.01 b 'A' ",
12615
+ "2012.01.01 a 'B' 10.65 10.65",
12616
+ "2012.01.01 a 'A' 10.59 ",
12617
+ "2012.01.01 b 'B' 10.65",
12618
+ "2012.01.01 a 'A' 10.65 10.59",
12619
+ "2012.01.01 b 'A' 10.59 10.59",
12620
+ "2012.01.01 b 'A' 10.59 10.59",
12621
+ "2012.01.01 a 'A' 10.59 11",
12622
+ "2012.01.02 b 'A' ",
12623
+ "2012.01.02 a 'B' ",
12624
+ "2012.01.02 b 'B' ",
12625
+ "2012.01.02 c 'B' 15.6",
12626
+ "========== ==== ======= ======== ========",
12627
+ ""
12628
+ ]
12629
+ },
12630
+ {
12631
+ "type": "code",
12632
+ "language": "console",
12633
+ "value": [
12634
+ "",
12635
+ " $ unsubscribeTable(tableName=`trades, actionName=\"dors\")",
12636
+ " $ undef(`trades,SHARED)",
12637
+ " $ dropStreamEngine(\"dors\")"
12638
+ ]
12639
+ }
12640
+ ]
12641
+ }
12642
+ ]
12643
+ },
12490
12644
  "createEqualJoinEngine": {
12491
12645
  "title": "createEqualJoinEngine",
12492
12646
  "type": "function",
@@ -12694,6 +12848,100 @@
12694
12848
  }
12695
12849
  ]
12696
12850
  },
12851
+ "createIPCInMemoryTable": {
12852
+ "title": "createIPCInMemoryTable",
12853
+ "type": "function",
12854
+ "children": [
12855
+ {
12856
+ "title": "语法",
12857
+ "type": "grammer",
12858
+ "children": [
12859
+ {
12860
+ "type": "text",
12861
+ "value": [
12862
+ "createIPCInMemoryTable(size, tableName, columnNames, columnTypes)"
12863
+ ]
12864
+ }
12865
+ ]
12866
+ },
12867
+ {
12868
+ "title": "参数",
12869
+ "type": "parameters",
12870
+ "children": [
12871
+ {
12872
+ "type": "text",
12873
+ "value": [
12874
+ "`size` 整数，表示 table 能缓存的记录数。该值必须大于 1,000,000，否则系统自动取 1,000,000。",
12875
+ "",
12876
+ "`tableName` 字符串，表示跨进程共享内存表的名称。",
12877
+ "",
12878
+ "`columnNames` 字符串向量，用于指定表的列名。",
12879
+ "",
12880
+ "`columnTypes` 向量，表示每列的数据类型。可使用表示数据类型的系统保留字或相应的字符串。"
12881
+ ]
12882
+ }
12883
+ ]
12884
+ },
12885
+ {
12886
+ "title": "详情",
12887
+ "type": "detail",
12888
+ "children": [
12889
+ {
12890
+ "type": "text",
12891
+ "value": [
12892
+ "创建一个跨进程共享内存表的句柄。",
12893
+ "",
12894
+ "跨进程共享内存表通过共享内存（由操作系统管理）进行跨进程通信。系统允许不同进程对该内存并发写入（暂不支持并发读），或者不同进程对该内存同时读写。注意：共享内存表仅支持在同一物理机内共享，不支持在集群不同物理节点间进行共享。",
12895
+ "",
12896
+ "跨进程共享内存表支持读写，但不支持对跨进程共享内存表的表结构进行修改。向跨进程共享内存表写数据的方法，与普通内存表一致。但对于跨进程共享内存表，既可以通过表的句柄插入数据，亦可通过与表名同名的表对象插入数据。若一次性插入的数据量大于共享内存，系统会抛出异常。"
12897
+ ]
12898
+ }
12899
+ ]
12900
+ },
12901
+ {
12902
+ "title": "读写机制：",
12903
+ "children": []
12904
+ },
12905
+ {
12906
+ "title": "场景：",
12907
+ "children": []
12908
+ },
12909
+ {
12910
+ "title": "例子",
12911
+ "type": "example",
12912
+ "children": [
12913
+ {
12914
+ "type": "text",
12915
+ "value": [
12916
+ "创建一个跨进程共享内存表，并作为流数据订阅的输出表。",
12917
+ ""
12918
+ ]
12919
+ },
12920
+ {
12921
+ "type": "code",
12922
+ "language": "console",
12923
+ "value": [
12924
+ " ",
12925
+ " $ share streamTable(10000:0,`timestamp`temperature, [TIMESTAMP,DOUBLE]) as pubTable",
12926
+ " $ ipc_t = createIPCInMemoryTable(1000000, \"ipc_table\", `timestamp`temperature, [TIMESTAMP, DOUBLE])",
12927
+ " $ def shm_append(mutable table, msg) {",
12928
+ " $ \ttable.append!(msg)",
12929
+ " $ }",
12930
+ " $ subscribeTable(tableName=\"pubTable\", actionName=\"act3\", offset=0, handler=shm_append{ipc_t}, msgAsTable=true)",
12931
+ " // 写入数据",
12932
+ "",
12933
+ " $ n = 200 ",
12934
+ " $ timestamp = 2022.01.01T09:00:00.000 + 1..n",
12935
+ " $ temp = 30 + rand(5.0,n)",
12936
+ " $ tableInsert(shm_test,timestamp,temp)",
12937
+ "",
12938
+ " $ tableInsert(pubTable,timestamp,temp)"
12939
+ ]
12940
+ }
12941
+ ]
12942
+ }
12943
+ ]
12944
+ },
12697
12945
  "createLookupJoinEngine": {
12698
12946
  "title": "createLookupJoinEngine",
12699
12947
  "type": "function",
@@ -12753,7 +13001,13 @@
12753
13001
  "",
12754
13002
  "\\(2) 最后为计算结果列，可为多列。",
12755
13003
  "",
12756
- "`metrics` 必选参数，以元代码的格式表示计算指标。可以是一个或多个表达式、系统内置或用户自定义函数，但不能是聚合函数。*metrics* 内支持调用具有多个返回值的函数，且必须指定列名，例如 <func(price) as \\`col1\\`col2>。有关元代码的更多信息可参考 :doc:`/Objects/Metaprogramming`。",
13004
+ "`metrics` 以元代码的格式表示计算指标，支持输入元组。有关元代码的更多信息可参考 :doc:`/Objects/Metaprogramming`。",
13005
+ "",
13006
+ "* 计算指标可以是一个或多个表达式、系统内置或用户自定义函数，但不能是聚合函数。",
13007
+ "* *metrics* 内支持调用具有多个返回值的函数，且必须指定列名，例如 <func(price) as \\`col1\\`col2>。",
13008
+ "",
13009
+ "请注意，若 *metrics* 中指定了时间列或者连接列，需要在连接列或时间列前加上表名来指定该列所属的表，若不加表名，则默认取左表的列。例如：*matchingColumn* = \\`sym, *timeColumn* = \\`timestamp，则 *metrics* = <[rightTable.sym, rightTable.timestamp, price, val, price*val]> 指定 *metrics* 中输出右表的 sym 列和 timestamp 列。",
13010
+ "",
12757
13011
  "",
12758
13012
  "`matchingColumn` 表示连接列的字符串标量/向量或字符串向量组成的 tuple，支持 Integral, Temproal 或 Literal(UUID 除外)类型。",
12759
13013
  "",
@@ -13300,15 +13554,28 @@
13300
13554
  "value": [
13301
13555
  "`name` 一个字符串，表示响应式状态引擎的名称，是其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。",
13302
13556
  "",
13303
- "`metrics` 以元代码的形式表示计算公式。有关元代码的详情可参考 :doc:`/Objects/Metaprogramming`。若需使用用户自定义函数，需在定义前添加声明 \"@state\"。",
13557
+ "`metrics` 以元代码的形式表示计算公式。有关元代码的详情可参考 :doc:`/Objects/Metaprogramming`。若需使用用户自定义函数，请注意以下两点：",
13558
+ "",
13559
+ "1. 需在定义前添加声明 \"@state\"。状态函数只能包含赋值语句和 return 语句。",
13560
+ "",
13561
+ "2. 若赋值语句的右值是一个多返回值的函数，则需要将多个返回值同时赋予多个变量。例如：两个返回值的函数 linearTimeTrend 应用于自定义状态函数中，正确写法为：",
13562
+ "",
13563
+ ".. code-block:: console",
13564
+ "",
13565
+ " $ @state",
13566
+ " $ def forcast2(S, N){",
13567
+ " $ linearregIntercept, linearregSlope = linearTimeTrend(S, N)",
13568
+ " $ return (N - 1) * linearregSlope + linearregIntercept",
13569
+ " $ }",
13304
13570
  "",
13305
13571
  "下列状态函数在 DolphinDB 的响应式状态引擎中的实现均得到了优化。目前，状态引擎不允许使用未经优化的状态函数。应避免使用聚合函数。",
13306
13572
  "",
13307
- "* 累计窗口函数：cumavg, cumsum, cumprod, cumcount, cummin, cummax, cumvar, cumvarp, cumstd, cumstdp, cumcorr, cumcovar, cumbeta, cumwsum, cumwavg, cumfirstNot, cumlastNot, cummed, cumpercentile ",
13573
+ "* 累计窗口函数：cumavg, cumsum, cumprod, cumcount, cummin, cummax, cumvar, cumvarp, cumstd, cumstdp, cumcorr, cumcovar, cumbeta, cumwsum, cumwavg, cumfirstNot, cumlastNot, cummed, cumpercentile, cumPositiveStreak",
13308
13574
  "* 滑动窗口函数：ema, mavg, msum, mcount, mprod, mvar, mvarp, mstd, mstdp, mskew, mkurtosis, mmin, mmax, mimin, mimax, mmed, mpercentile, mrank, mcorr, mcovar, mbeta, mwsum, mwavg, mmad, mfirst, mlast, mslr, tmove, tmfirst, tmlast, tmsum, tmavg, tmcount, tmvar, tmvarp, tmstd, tmstdp, tmprod, tmskew, tmkurtosis, tmmin, tmmax, tmmed, tmpercentile, tmrank, tmcovar, tmbeta, tmcorr, tmwavg, tmwsum, tmoving, moving, sma,wma, dema, tema, trima, linearTimeTrend, talib, t3, ma",
13309
- "* 序列相关函数：deltas, ratios, ffill, move, prev, iterate, ewmMean, ewmVar, ewmStd, ewmCov, ewmCorr",
13575
+ "* 序列相关函数：deltas, ratios, ffill, move, prev, iterate, ewmMean, ewmVar, ewmStd, ewmCov, ewmCorr, prevState",
13310
13576
  "* topN相关函数：msumTopN, mavgTopN, mstdpTopN, mstdTopN, mvarpTopN, mvarTopN, mcorrTopN, mbetaTopN, mcovarTopN, mwsumTopN",
13311
- "* 其他函数：talibNull, dynamicGroupCumsum, dynamicGroupCumcount",
13577
+ "* 高阶函数：segmentBy(参数 func 暂支持 cumsum, cummax, cummin, cumcount, cumavg, cumstd, cumvar, cumstdp, cumvarp)",
13578
+ "* 其他函数：talibNull, dynamicGroupCumsum, dynamicGroupCumcount, topRange, lowRange",
13312
13579
  "",
13313
13580
  "注意，:doc:`/Functionalprogramming/TemplateFunctions/talib` 作为状态函数时，第一个参数 `func` 只能是响应式状态引擎支持的状态函数。",
13314
13581
  "",
@@ -13478,7 +13745,7 @@
13478
13745
  {
13479
13746
  "type": "text",
13480
13747
  "value": [
13481
- "createSessionWindowEngine(name, sessionGap, metrics, dummyTable, outputTable, [timeColumn], [useSystemTime=false], [keyColumn], [updateTime], [useSessionStartTime=true], [snapshotDir], [snapshotIntervalInMsgCount], [raftGroup])"
13748
+ "createSessionWindowEngine(name, sessionGap, metrics, dummyTable, outputTable, [timeColumn], [useSystemTime=false], [keyColumn], [updateTime], [useSessionStartTime=true], [snapshotDir], [snapshotIntervalInMsgCount], [raftGroup], [forceTriggerTime])"
13482
13749
  ]
13483
13750
  }
13484
13751
  ]
@@ -13494,13 +13761,9 @@
13494
13761
  "",
13495
13762
  "`sessionGap` 必选参数，是一个正整数，表示会话窗口之间的时间间隔。此参数的时间单位由 *useSystemTime* 参数决定。",
13496
13763
  "",
13497
- "`useSystemTime`: 可选参数，表示窗口以何种方式确定。",
13764
+ "`useSessionStartTime`: 可选参数，是一个布尔值，默认值为 true，表示输出表中的时刻是否为数据窗口起始时刻，即每个窗口中第一条数据的时刻。若设置为 false，则表示输出表中的时刻为数据窗口结束时刻，即每个窗口中最后一条数据的时刻+ *sessionGap*。如果指定 *updateTime*，*useSessionStartTime* 必须为 true。",
13498
13765
  "",
13499
- "* 当 *useSystemTime* = true时，按照数据进入引擎的时刻（毫秒精度的本地系统时间，与数据中的时间列无关）确定窗口。",
13500
- "",
13501
- "* 当 *useSystemTime* = false（缺省值）时，根据 *timeColumn* 列中数据来决定数据窗口。",
13502
- "",
13503
- "`useSessionStartTime`: 可选参数，是一个布尔值，默认值为 true，表示输出表中的时刻是否为数据窗口起始时刻，即每个窗口中第一条数据的时刻。若设置为 false，则表示输出表中的时刻为数据窗口结束时刻，即每个窗口中最后一条数据的时刻+ *sessionGap*。如果指定 *updateTime*，*useSessionStartTime* 必须为 true。"
13766
+ "`forceTriggerTime` 可选参数，非负整数，单位与 *timeColumn* 的时间精度一致。该参数仅在设置 *useSystemTime* = false 时起效。当系统收到最后一条数据后，经过 *forceTriggerTime* 时间，将强制触发未计算的窗口进行计算。请注意，若设置了 *keyColumn*，则各分组内进行上述操作。"
13504
13767
  ]
13505
13768
  }
13506
13769
  ]
@@ -13528,77 +13791,84 @@
13528
13791
  "language": "console",
13529
13792
  "value": [
13530
13793
  " ",
13531
- " $ share streamTable(1000:0, `time`volume, [TIMESTAMP, INT]) as trades",
13532
- " $ output1 = keyedTable(`time,10000:0, `time`sumVolume, [TIMESTAMP, INT])",
13533
- " $ engine_sw = createSessionWindowEngine(name = \"engine_sw\", sessionGap = 5, metrics = <sum(volume)>, dummyTable = trades, outputTable = output1, timeColumn = `time)",
13794
+ " $ share streamTable(1000:0, `time`sym`volume, [TIMESTAMP, SYMBOL, INT]) as trades",
13795
+ " $ output1 = table(10000:0, `time`sym`sumVolume, [TIMESTAMP, SYMBOL, INT])",
13796
+ " $ engine_sw = createSessionWindowEngine(name = \"engine_sw\", sessionGap = 5, metrics = <sum(volume)>, dummyTable = trades, outputTable = output1, timeColumn = `time, keyColumn=`sym)",
13534
13797
  " $ subscribeTable(tableName=\"trades\", actionName=\"append_engine_sw\", offset=0, handler=append!{engine_sw}, msgAsTable=true)",
13535
- " ",
13798
+ "",
13536
13799
  " $ n = 5",
13537
13800
  " $ timev = 2018.10.12T10:01:00.000 + (1..n)",
13801
+ " $ symv=take(`A`B`C,n)",
13538
13802
  " $ volumev = (1..n)%1000",
13539
- " $ insert into trades values(timev, volumev)",
13803
+ " $ insert into trades values(timev, symv, volumev)",
13540
13804
  " ",
13541
13805
  " $ n = 5",
13542
13806
  " $ timev = 2018.10.12T10:01:00.010 + (1..n)",
13543
13807
  " $ volumev = (1..n)%1000",
13544
- " $ insert into trades values(timev, volumev)",
13808
+ " $ symv=take(`A`B`C,n)",
13809
+ " $ insert into trades values(timev, symv, volumev)",
13545
13810
  " ",
13546
- " $ n = 3",
13547
- " $ timev = 2018.10.12T10:01:00.020 + (1..n)",
13811
+ " $ n = 6",
13812
+ " $ timev = 2018.10.12T10:01:00.020 + 1 2 3 8 14 20",
13548
13813
  " $ volumev = (1..n)%1000",
13549
- " $ timev.append!(2018.10.12T10:01:00.027 + (1..n))",
13550
- " $ volumev.append!((1..n)%1000)",
13551
- " $ insert into trades values(timev, volumev)",
13814
+ " $ symv=take(`A`B`C,n)",
13815
+ " $ insert into trades values(timev, symv, volumev)",
13552
13816
  "",
13553
- " $ select * from trades;",
13817
+ " $ select * from output1;",
13554
13818
  ""
13555
13819
  ]
13556
13820
  },
13557
13821
  {
13558
13822
  "type": "text",
13559
13823
  "value": [
13560
- "======================== ========",
13561
- "time volume",
13562
- "======================== ========",
13563
- "2018.10.12T10:01:00.001 1",
13564
- "2018.10.12T10:01:00.002 2",
13565
- "2018.10.12T10:01:00.003 3",
13566
- "2018.10.12T10:01:00.004 4",
13567
- "2018.10.12T10:01:00.005 5",
13568
- "2018.10.12T10:01:00.011 1",
13569
- "2018.10.12T10:01:00.012 2",
13570
- "2018.10.12T10:01:00.013 3",
13571
- "2018.10.12T10:01:00.014 4",
13572
- "2018.10.12T10:01:00.015 5",
13573
- "2018.10.12T10:01:00.021 1",
13574
- "2018.10.12T10:01:00.022 2",
13575
- "2018.10.12T10:01:00.023 3",
13576
- "2018.10.12T10:01:00.028 1",
13577
- "2018.10.12T10:01:00.029 2",
13578
- "2018.10.12T10:01:00.030 3",
13579
- "======================== ========",
13824
+ "======================== ==== ========",
13825
+ "time sym volume",
13826
+ "======================== ==== ========",
13827
+ "2018.10.12T10:01:00.001 A 5",
13828
+ "2018.10.12T10:01:00.002 B 7",
13829
+ "2018.10.12T10:01:00.003 C 3",
13830
+ "2018.10.12T10:01:00.011 A 5",
13831
+ "2018.10.12T10:01:00.012 B 7",
13832
+ "2018.10.12T10:01:00.013 C 3",
13833
+ "2018.10.12T10:01:00.021 A 1",
13834
+ "2018.10.12T10:01:00.022 B 2",
13835
+ "2018.10.12T10:01:00.023 C 3",
13836
+ "======================== ==== ========",
13837
+ "",
13838
+ "指定 forceTriggerTime 为1000ms，收到最后一条消息后，经过1000ms，触发所有分组数据计算输出。用以下代码替换上述引擎创建部分的代码。",
13580
13839
  ""
13581
13840
  ]
13582
13841
  },
13583
13842
  {
13584
13843
  "type": "code",
13585
- "language": "sql",
13844
+ "language": "console",
13586
13845
  "value": [
13587
- " ",
13588
- " select * from output1;",
13846
+ "",
13847
+ " $ engine_sw = createSessionWindowEngine(name = \"engine_sw\", sessionGap = 5, metrics = <sum(volume)>, dummyTable = trades, outputTable = output1, timeColumn = `time, keyColumn=`sym, forceTriggerTime=1000)",
13589
13848
  ""
13590
13849
  ]
13591
13850
  },
13592
13851
  {
13593
13852
  "type": "text",
13594
13853
  "value": [
13595
- "======================== ==========",
13596
- "time sumVolume",
13597
- "======================== ==========",
13598
- "2018.10.12T10:01:00.001 15",
13599
- "2018.10.12T10:01:00.011 15",
13600
- "2018.10.12T10:01:00.021 6",
13601
- "======================== =========="
13854
+ "再次查询输出表，可以得到以下结果：",
13855
+ "",
13856
+ "======================== ==== ========",
13857
+ "time sym volume",
13858
+ "======================== ==== ========",
13859
+ "2018.10.12T10:01:00.001 A 5",
13860
+ "2018.10.12T10:01:00.002 B 7",
13861
+ "2018.10.12T10:01:00.003 C 3",
13862
+ "2018.10.12T10:01:00.011 A 5",
13863
+ "2018.10.12T10:01:00.012 B 7",
13864
+ "2018.10.12T10:01:00.013 C 3",
13865
+ "2018.10.12T10:01:00.021 A 1",
13866
+ "2018.10.12T10:01:00.022 B 2",
13867
+ "2018.10.12T10:01:00.023 C 3",
13868
+ "2018.10.12T10:01:00.028 A 4",
13869
+ "2018.10.12T10:01:00.034 B 5",
13870
+ "2018.10.12T10:01:00.040 C 6",
13871
+ "======================== ==== ========"
13602
13872
  ]
13603
13873
  }
13604
13874
  ]
@@ -14406,7 +14676,12 @@
14406
14676
  "",
14407
14677
  "`window` 必选参数，表示滑动窗口区间的整型或 DURATION 数据对，其中左右边界都包含在内。",
14408
14678
  "",
14409
- "`metrics` 必选参数，以元代码的格式表示计算指标。该参数可以是一个或多个表达式、系统内置或用户自定义函数，可以是聚合函数或非聚合函数。*metrics* 内支持调用具有多个返回值的函数，且必须指定列名，例如 <func(price) as \\`col1\\`col2>。有关元代码的更多信息可参考 :doc:`/Objects/Metaprogramming`。",
14679
+ "`metrics` 以元代码的格式表示计算指标，支持输入元组。有关元代码的更多信息可参考 :doc:`/Objects/Metaprogramming`。",
14680
+ "",
14681
+ "* 计算指标可以是一个或多个表达式、系统内置或用户自定义函数，但不能是聚合函数。",
14682
+ "* *metrics* 内支持调用具有多个返回值的函数，且必须指定列名，例如 <func(price) as \\`col1\\`col2>。",
14683
+ "",
14684
+ "请注意，若 *metrics* 中指定了时间列或者连接列，需要在连接列或时间列前加上表名来指定该列所属的表，若不加表名，则默认取左表的列。例如：*matchingColumn* = \\`sym, *timeColumn* = \\`timestamp，则 *metrics* = <[rightTable.sym, rightTable.timestamp, price, val, price*val]> 指定 *metrics* 中输出右表的 sym 列和 timestamp 列。",
14410
14685
  "",
14411
14686
  "当以下函数只计算 *rightTable* 中的数据列时，window join 引擎对它们进行了优化：sum, sum2, avg, std, var, corr, covar, wavg, wsum, beta, max, min, last, first, med, percentile。",
14412
14687
  "",
@@ -17434,7 +17709,7 @@
17434
17709
  " $ ID=rand(10, n)",
17435
17710
  " $ x=rand(1.0, n)",
17436
17711
  " $ t=table(ID, x);",
17437
- " $ db=database(directory=\"C:/DolphinDB/Data/rangedb\", partitionType=RANGE, partitionScheme=0 5 10)",
17712
+ " $ db=database(directory=\"dfs://rangedb\", partitionType=RANGE, partitionScheme=0 5 10)",
17438
17713
  " $ pt = db.createPartitionedTable(t, `pt, `ID);",
17439
17714
  " $ pt.append!(t);",
17440
17715
  "",
@@ -17472,7 +17747,7 @@
17472
17747
  " $ t=table(ID, x);",
17473
17748
  " $ saveText(t, \"C:/DolphinDB/Data/t.txt\");",
17474
17749
  " ",
17475
- " $ db=database(directory=\"C:/DolphinDB/Data/rangedb\", partitionType=RANGE, partitionScheme=0 5 10)",
17750
+ " $ db=database(directory=\"dfs://rangedb\", partitionType=RANGE, partitionScheme=0 5 10)",
17476
17751
  " $ pt = loadTextEx(db, `pt, `ID, \"C:/DolphinDB/Data/t.txt\");",
17477
17752
  ""
17478
17753
  ]
@@ -17553,7 +17828,7 @@
17553
17828
  " $ x=rand(1.0, n);",
17554
17829
  " $ t=table(month, x);",
17555
17830
  " ",
17556
- " $ db=database(directory=\"C:/DolphinDB/Data/valuedb\", partitionType=VALUE, partitionScheme=2000.01M..2016.12M)",
17831
+ " $ db=database(directory=\"dfs://valuedb\", partitionType=VALUE, partitionScheme=2000.01M..2016.12M)",
17557
17832
  " $ pt = db.createPartitionedTable(t, `pt, `month);",
17558
17833
  " $ pt.append!(t);",
17559
17834
  " ",
@@ -17589,7 +17864,7 @@
17589
17864
  " $ x=rand(1.0, n);",
17590
17865
  " $ t=table(ticker, x);",
17591
17866
  " ",
17592
- " $ db=database(directory=\"C:/DolphinDB/Data/listdb\", partitionType=LIST, partitionScheme=[`IBM`ORCL`MSFT, `GOOG`FB])",
17867
+ " $ db=database(directory=\"dfs://listdb\", partitionType=LIST, partitionScheme=[`IBM`ORCL`MSFT, `GOOG`FB])",
17593
17868
  " $ pt = db.createPartitionedTable(t, `pt, `ticker)",
17594
17869
  " $ pt.append!(t);",
17595
17870
  " ",
@@ -17735,7 +18010,7 @@
17735
18010
  " $ x=rand(1.0, n)",
17736
18011
  " $ t=table(ID, x);",
17737
18012
  " ",
17738
- " $ db=database(directory=\"C:/DolphinDB/Data/rangedb5\", partitionType=RANGE, partitionScheme=0 5 10, locations=[`node1`node2, `node3])",
18013
+ " $ db=database(directory=\"dfs://rangedb5\", partitionType=RANGE, partitionScheme=0 5 10, locations=[`node1`node2, `node3])",
17739
18014
  " $ pt = db.createPartitionedTable(t, `pt, `ID);",
17740
18015
  " $ pt.append!(t);",
17741
18016
  ""
@@ -17771,7 +18046,7 @@
17771
18046
  "language": "console",
17772
18047
  "value": [
17773
18048
  " ",
17774
- " $ db=database(directory=\"C:/DolphinDB/Data/rangedb6\", partitionType=RANGE, partitionScheme=0 5 10, locations=[[\"111.222.3.4:8080\", \"111.222.3.5:8080\"], \"111.222.3.6:8080\"])",
18049
+ " $ db=database(directory=\"dfs://rangedb6\", partitionType=RANGE, partitionScheme=0 5 10, locations=[[\"111.222.3.4:8080\", \"111.222.3.5:8080\"], \"111.222.3.6:8080\"])",
17775
18050
  ""
17776
18051
  ]
17777
18052
  },
@@ -20350,6 +20625,52 @@
20350
20625
  }
20351
20626
  ]
20352
20627
  },
20628
+ "disableQueryMonitor": {
20629
+ "title": "disableQueryMonitor",
20630
+ "type": "command",
20631
+ "children": [
20632
+ {
20633
+ "title": "语法",
20634
+ "type": "grammer",
20635
+ "children": [
20636
+ {
20637
+ "type": "text",
20638
+ "value": [
20639
+ "disableQueryMonitor()"
20640
+ ]
20641
+ }
20642
+ ]
20643
+ },
20644
+ {
20645
+ "title": "参数",
20646
+ "type": "parameters",
20647
+ "children": [
20648
+ {
20649
+ "type": "text",
20650
+ "value": [
20651
+ "无"
20652
+ ]
20653
+ }
20654
+ ]
20655
+ },
20656
+ {
20657
+ "title": "详情",
20658
+ "type": "detail",
20659
+ "children": [
20660
+ {
20661
+ "type": "text",
20662
+ "value": [
20663
+ "关闭监控查询任务状态的功能。",
20664
+ "",
20665
+ "由于监控查询任务状态具有一定的内存开销，内存资源紧张时，可以关闭该功能。注意：调用该命令后，用户将无法调用 :doc:`/FunctionsandCommands/FunctionReferences/g/getQueryStatus` 函数获取查询任务的状态。",
20666
+ "",
20667
+ "相关函数： :doc:`../e/enableQueryMonitor`"
20668
+ ]
20669
+ }
20670
+ ]
20671
+ }
20672
+ ]
20673
+ },
20353
20674
  "disableTablePersistence": {
20354
20675
  "title": "disableTablePersistence",
20355
20676
  "type": "command",
@@ -21570,6 +21891,72 @@
21570
21891
  }
21571
21892
  ]
21572
21893
  },
21894
+ "dropIPCInMemoryTable": {
21895
+ "title": "dropIPCInMemoryTable",
21896
+ "type": "function",
21897
+ "children": [
21898
+ {
21899
+ "title": "语法",
21900
+ "type": "grammer",
21901
+ "children": [
21902
+ {
21903
+ "type": "text",
21904
+ "value": [
21905
+ "dropIPCInMemoryTable(tableName)"
21906
+ ]
21907
+ }
21908
+ ]
21909
+ },
21910
+ {
21911
+ "title": "参数",
21912
+ "type": "parameters",
21913
+ "children": [
21914
+ {
21915
+ "type": "text",
21916
+ "value": [
21917
+ "`tableName` 字符串，表示跨进程共享内存表的名称。"
21918
+ ]
21919
+ }
21920
+ ]
21921
+ },
21922
+ {
21923
+ "title": "详情",
21924
+ "type": "detail",
21925
+ "children": [
21926
+ {
21927
+ "type": "text",
21928
+ "value": [
21929
+ "删除跨进程共享内存表。",
21930
+ "",
21931
+ "注意：server 关机并不能删除跨进程共享内存表，仍然需要通过 ``dropIPCInMemoryTable`` 进行删除。"
21932
+ ]
21933
+ }
21934
+ ]
21935
+ },
21936
+ {
21937
+ "title": "例子",
21938
+ "type": "example",
21939
+ "children": [
21940
+ {
21941
+ "type": "text",
21942
+ "value": [
21943
+ "删除函数 ``createIPCInMemoryTable`` 例子中创建的表 ipc_table。",
21944
+ ""
21945
+ ]
21946
+ },
21947
+ {
21948
+ "type": "code",
21949
+ "language": "console",
21950
+ "value": [
21951
+ " ",
21952
+ " $ dropIPCInMemoryTable(`ipc_table)",
21953
+ " ipc_table"
21954
+ ]
21955
+ }
21956
+ ]
21957
+ }
21958
+ ]
21959
+ },
21573
21960
  "dropPartition": {
21574
21961
  "title": "dropPartition",
21575
21962
  "type": "command",
@@ -21903,7 +22290,7 @@
21903
22290
  {
21904
22291
  "type": "text",
21905
22292
  "value": [
21906
- "`name` 是一个字符串，表示一个流数据引擎的名称。",
22293
+ "`name` 字符串，表示一个流数据引擎的名称。需指定为已创建的引擎名称，否则会抛出异常。通过 :doc:`../../FunctionReferences/g/getStreamEngineStat` 可查看已创建的引擎名称。",
21907
22294
  "",
21908
22295
  "详情",
21909
22296
  "",
@@ -23147,6 +23534,50 @@
23147
23534
  }
23148
23535
  ]
23149
23536
  },
23537
+ "enableQueryMonitor": {
23538
+ "title": "enableQueryMonitor",
23539
+ "type": "command",
23540
+ "children": [
23541
+ {
23542
+ "title": "语法",
23543
+ "type": "grammer",
23544
+ "children": [
23545
+ {
23546
+ "type": "text",
23547
+ "value": [
23548
+ "enableQueryMonitor()"
23549
+ ]
23550
+ }
23551
+ ]
23552
+ },
23553
+ {
23554
+ "title": "参数",
23555
+ "type": "parameters",
23556
+ "children": [
23557
+ {
23558
+ "type": "text",
23559
+ "value": [
23560
+ "无"
23561
+ ]
23562
+ }
23563
+ ]
23564
+ },
23565
+ {
23566
+ "title": "详情",
23567
+ "type": "detail",
23568
+ "children": [
23569
+ {
23570
+ "type": "text",
23571
+ "value": [
23572
+ "启用监控查询任务状态的功能。系统默认会开启该功能。",
23573
+ "",
23574
+ "相关函数： :doc:`../d/disableQueryMonitor`"
23575
+ ]
23576
+ }
23577
+ ]
23578
+ }
23579
+ ]
23580
+ },
23150
23581
  "enableTablePersistence": {
23151
23582
  "title": "enableTablePersistence",
23152
23583
  "type": "command",
@@ -24933,7 +25364,7 @@
24933
25364
  {
24934
25365
  "type": "text",
24935
25366
  "value": [
24936
- "existsPartition(path)"
25367
+ "existsPartition(path, [tableName])"
24937
25368
  ]
24938
25369
  }
24939
25370
  ]
@@ -24945,7 +25376,15 @@
24945
25376
  {
24946
25377
  "type": "text",
24947
25378
  "value": [
24948
- "`path` 是分区文件夹的路径，它是一个字符串。"
25379
+ "`path` 字符串，表示分区文件夹的路径。",
25380
+ "",
25381
+ "`tableName` 字符串，表示表名。",
25382
+ "",
25383
+ "* 若分区粒度为数据库级（ :doc:`../d/database` : *chunkGranularity* = 'DATABASE'），可以不指定该参数。",
25384
+ "* 若分区粒度为表级（ :doc:`../d/database` : *chunkGranularity* = 'TABLE'）",
25385
+ "",
25386
+ " * *path* 指定的路径包含了物理索引（通过函数 :doc:`../l/listTables` 获取），可以不指定该参数。",
25387
+ " * 否则，必须指定该参数。"
24949
25388
  ]
24950
25389
  }
24951
25390
  ]
@@ -25012,6 +25451,10 @@
25012
25451
  " $ existsPartition(\"dfs://valueDB/20170807/s\");",
25013
25452
  " true",
25014
25453
  "",
25454
+ " //表级分区时，path 不包含物理索引，检查分区时需指定表名，否则查找不到分区信息",
25455
+ " $ existsPartition(\"dfs://valueDB/20170807\", `pt) ",
25456
+ " true",
25457
+ "",
25015
25458
  " $ existsPartition(\"dfs://valueDB/20170807\");",
25016
25459
  " false",
25017
25460
  "",
@@ -28593,6 +29036,8 @@
28593
29036
  "",
28594
29037
  "`partition` 是字符串，表示分区在数据库内的路径，例如 \"/20190101/GOOG\"。",
28595
29038
  "",
29039
+ "请注意：若使用 1.30.16/2.00.4 ~ 1.30.18/2.00.6 版本 server，对表级分区数据进行备份和恢复时，该参数必须指定路径到物理索引（可通过函数 :doc:`/FunctionsandCommands/FunctionReferences/l/listTables` 获取），例如分区 \"/compoDB/20170807/0_50\" 下表的物理索引为8，则 partition 需指定为 \"/compoDB/20170807/0_50/8\"。",
29040
+ "",
28596
29041
  "`tableName` 是字符串，表示数据库中表的名称。"
28597
29042
  ]
28598
29043
  }
@@ -28735,6 +29180,84 @@
28735
29180
  }
28736
29181
  ]
28737
29182
  },
29183
+ "getCacheEngineStat": {
29184
+ "title": "getCacheEngineStat",
29185
+ "type": "function",
29186
+ "children": [
29187
+ {
29188
+ "title": "语法",
29189
+ "type": "grammer",
29190
+ "children": [
29191
+ {
29192
+ "type": "text",
29193
+ "value": [
29194
+ "getCacheEngineStat()"
29195
+ ]
29196
+ }
29197
+ ]
29198
+ },
29199
+ {
29200
+ "title": "参数",
29201
+ "type": "parameters",
29202
+ "children": [
29203
+ {
29204
+ "type": "text",
29205
+ "value": [
29206
+ "无"
29207
+ ]
29208
+ }
29209
+ ]
29210
+ },
29211
+ {
29212
+ "title": "详情",
29213
+ "type": "detail",
29214
+ "children": [
29215
+ {
29216
+ "type": "text",
29217
+ "value": [
29218
+ "获取当前节点下 OLAP 引擎 cache engine 的状态信息。该函数只能在数据节点调用。",
29219
+ "",
29220
+ "返回一个表对象，包含以下几列: ",
29221
+ "",
29222
+ "* chunkId: chunk 的唯一标识。",
29223
+ "* physicalName: chunk 所属表的物理表名。",
29224
+ "* timeSinceLastWrite: 距离最后一次写入经过的时间，单位为毫秒。",
29225
+ "* cachedRowsOfCompletedTxn: 当前缓存的已完成事务的记录数。",
29226
+ "* cachedRowsOfUncompletedTxn: 当前缓存的未完成事务的记录数。注意: 每个 chunk 最多只有最后一个事务是未完成的。",
29227
+ "* cachedMemOfCompletedTxn: cachedRowsOfCompletedTxn 占用的内存，单位为字节。",
29228
+ "* cachedMemOfUncompletedTxn: cachedRowsOfUncompletedTxn 占用的内存，单位为字节。",
29229
+ "* cachedTids: 当前缓存的事务 id 列表。"
29230
+ ]
29231
+ }
29232
+ ]
29233
+ },
29234
+ {
29235
+ "title": "例子",
29236
+ "type": "example",
29237
+ "children": [
29238
+ {
29239
+ "type": "code",
29240
+ "language": "console",
29241
+ "value": [
29242
+ "",
29243
+ " $ getCacheEngineStat()",
29244
+ ""
29245
+ ]
29246
+ },
29247
+ {
29248
+ "type": "text",
29249
+ "value": [
29250
+ "======================================== ============= =================== ========================== =========================== ======================== =========================== ==============",
29251
+ "chunkId physicalName timeSinceLastWrite cachedRowsOfCompletedTxn cachedRowsOfUncompletedTxn cachedMemOfCompletedTxn cachedMemOfUncompletedTxn cachedTids",
29252
+ "======================================== ============= =================== ========================== =========================== ======================== =========================== ==============",
29253
+ "e4558d3c-fa41-52b5-418b-94e26cb70a75 pt_2 1056 222,386 0 3,558,176 0 2052",
29254
+ "======================================== ============= =================== ========================== =========================== ======================== =========================== =============="
29255
+ ]
29256
+ }
29257
+ ]
29258
+ }
29259
+ ]
29260
+ },
28738
29261
  "getChunkPath": {
28739
29262
  "title": "getChunkPath",
28740
29263
  "type": "function",
@@ -29157,9 +29680,51 @@
29157
29680
  {
29158
29681
  "type": "text",
29159
29682
  "value": [
29160
- "返回每个节点的多个配置和性能监控度量值。它只能在控制节点上执行。 ",
29683
+ "获取每个节点的多个配置和性能监控度量值。它只能在控制节点上执行。 注意：代理节点的 `connectionNum` 是一个随机值，可以忽略。",
29684
+ "",
29685
+ "返回一个表对象，包含以下几列：",
29161
29686
  "",
29162
- "注意：代理节点的 `connectionNum` 是一个随机值，可以忽略。",
29687
+ "* host：节点的主机名。",
29688
+ "* port：节点的端口号。",
29689
+ "* site：节点的局域网信息。",
29690
+ "* mode：节点的类型。0 表示集群的数据节点，1 表示集群的代理节点，2 表示集群的控制节点，3 表示 single mode 的节点。",
29691
+ "* state：节点是否存活。",
29692
+ "* agentSite：当前节点的代理节点信息。",
29693
+ "* maxConnections：最多可以从多少个外部 GUI ，API 或其它节点连接到本地节点。",
29694
+ "* maxMemSize：当前节点的内存空间上限（单位：GB）。",
29695
+ "* workerNum：常规作业的工作线程的数量。默认值是 CPU 的内核数。",
29696
+ "* executorNum：本地执行线程的数量。默认值是 CPU 内核数减1。",
29697
+ "* connectionNum：连接到本地节点的连接数。",
29698
+ "* name：节点别名。",
29699
+ "* memoryUsed：节点的内存占用量（单位：字节）。",
29700
+ "* memoryAlloc：系统已分配给当前节点的内存（单位：字节）。",
29701
+ "* cpuUsage：CPU 使用率。",
29702
+ "* avgLoad：CPU 平均负载。",
29703
+ "* medLast10QueryTime：前 10 个完成的查询执行所耗费时间的中间值（单位：毫秒）。",
29704
+ "* maxLast10QueryTime：前 10 个完成的查询执行所耗费时间的最大值（单位：毫秒）。",
29705
+ "* medLast100QueryTime：前 100 个完成的查询执行所耗费时间的中间值（单位：毫秒）。",
29706
+ "* maxLast100QueryTime：前100个完成的查询执行所耗费时间的最大值（单位：毫秒）。",
29707
+ "* maxRunningQueryTime：当前正在执行的查询的耗费时间的最大值（单位：毫秒）。",
29708
+ "* runningJobs：正在执行中的 Job 个数。",
29709
+ "* queuedJobs：队列中的 Job 个数。",
29710
+ "* runningTasks：正在执行中的 Task 个数。",
29711
+ "* queuedTasks：队列中的 Task 个数。",
29712
+ "* jobLoad：作业负载。",
29713
+ "* diskCapacity：磁盘容量（单位：字节）。",
29714
+ "* diskFreeSpace：磁盘剩余空间（单位：字节）。",
29715
+ "* diskFreeSpaceRatio：磁盘可用空间占比。",
29716
+ "* diskWriteRate：磁盘写速率 （单位：字节/秒）。",
29717
+ "* diskReadRate：磁盘读速率（单位：字节/秒）。",
29718
+ "* lastMinuteWriteVolume：前一分钟写磁盘容量（单位：字节）。",
29719
+ "* lastMinuteReadVolume：前一分钟读磁盘容量（单位：字节）。",
29720
+ "* networkSendRate：网络发送速率（单位：字节/秒）。",
29721
+ "* networkRecvRate：网络接收速率（单位：字节/秒）。",
29722
+ "* lastMinuteNetworkSend：前一分钟网络发送字节数（单位：字节）。",
29723
+ "* lastMinuteNetworkRecv：前一分钟网络接收字节数 （单位：字节）。",
29724
+ "* publicName：若为控制节点，且配置了 publicName，则显示 publicName；否则显示控制节点所在服务器的 网卡地址。若为数据节点或代理节点，则显示数据节点或代理节点所在服务器的网卡地址。",
29725
+ "* lastMsgLatency：前一批消息的延时（单位：毫秒）。",
29726
+ "* cumMsgLatency：所有消息的平均延时（单位：毫秒）。",
29727
+ "* isLeader：是否是 raft 组的 leader，该字段仅在配置了控制节点高可用时才生效。请注意，若 raft 组存在宕机的节点，则该节点的 isLeader 将返回空值。",
29163
29728
  ""
29164
29729
  ]
29165
29730
  }
@@ -29202,8 +29767,41 @@
29202
29767
  " $ rpc(getControllerAlias(), getClusterPerf).keys()",
29203
29768
  " [\"host\",\"port\",\"site\",\"mode\",\"state\",\"agentSite\",\"maxConnections\",\"maxMemSize\",\"workerNum\",\"executorNum\",\"connectionNum\",\"name\",\"memoryUsed\",\"memoryAlloc\",\"cpuUsage\",\"avgLoad\",\"medLast10QueryTime\",\"maxLast10QueryTime\",\"medLast100QueryTime\",\"maxLast100QueryTime\",\"maxRunningQueryTime\",\"runningJobs\",\"queuedJobs\",\"runningTasks\",\"queuedTasks\",\"jobLoad\",\"diskCapacity\",\"diskFreeSpace\",\"diskFreeSpaceRatio\",\"diskWriteRate\",\"diskReadRate\",\"lastMinuteWriteVolume\",\"lastMinuteReadVolume\",\"networkSendRate\",\"networkRecvRate\",\"lastMinuteNetworkSend\",\"lastMinuteNetworkRecv\",\"publicName\",\"lastMsgLatency\",\"cumMsgLatency\"]",
29204
29769
  "",
29770
+ ""
29771
+ ]
29772
+ },
29773
+ {
29774
+ "type": "text",
29775
+ "value": [
29776
+ "集群高可用环境下执行：",
29777
+ ""
29778
+ ]
29779
+ },
29780
+ {
29781
+ "type": "code",
29782
+ "language": "console",
29783
+ "value": [
29205
29784
  "",
29206
- " "
29785
+ " $ rpc(getControllerAlias(true), getClusterPerf)",
29786
+ ""
29787
+ ]
29788
+ },
29789
+ {
29790
+ "type": "text",
29791
+ "value": [
29792
+ "=================== =========== ========================================== ====== ======= ===================================== ================ ============ =========== ============= =============== ===================== ============ ============= ========== ========= ==================== ==================== ===================== ===================== ===================== ============= ============ ============== ============= ========= ===================== ======================= ==================== =============== ============== ======================= ====================== ================= ================= ======================= ======================= =============================================== ================ =============== ================",
29793
+ "host port site mode state agentSite maxConnections maxMemSize workerNum executorNum connectionNum name memoryUsed memoryAlloc cpuUsage avgLoad medLast10QueryTime maxLast10QueryTime medLast100QueryTime maxLast100QueryTime maxRunningQueryTime runningJobs queuedJobs runningTasks queuedTasks jobLoad diskCapacity diskFreeSpace diskFreeSpaceRatio diskWriteRate diskReadRate lastMinuteWriteVolume lastMinuteReadVolume networkSendRate networkRecvRate lastMinuteNetworkSend lastMinuteNetworkRecv publicName lastMsgLatency cumMsgLatency isLeader",
29794
+ "=================== =========== ========================================== ====== ======= ===================================== ================ ============ =========== ============= =============== ===================== ============ ============= ========== ========= ==================== ==================== ===================== ===================== ===================== ============= ============ ============== ============= ========= ===================== ======================= ==================== =============== ============== ======================= ====================== ================= ================= ======================= ======================= =============================================== ================ =============== ================",
29795
+ "192.168.100.10 17,000 192.168.100.10:17000:master3 2 1 512 16 64 3 1 master3 23,449,272 24,133,632 0.7788 0.0037 0 0 0 0 0 0 0 0 0 0 0 0 0 0 4,658 2,736 102,468 59,193 78,351 8,012,182 2,378,846 192.198.1.10;172.17.0.1;10.244.5.0;10.244.5.1 0 0 false",
29796
+ "192.168.100.11 17,000 192.168.100.11:17000:master2 2 1 512 16 64 3 2 master2 23,527,872 24,133,632 11.5625 0.3219 0 0 0 0 0 0 0 0 0 0 0 0 0 0 4,670 2,785 116,733 62,402 56,160 1,366,293 1,398,238 192.198.1.11;172.17.0.1;10.244.4.0;10.244.4.1 0 0 false",
29797
+ "192.168.100.12 17,000 192.168.100.12:17000:master1 2 1 512 16 64 3 20 master1 25,002,792 46,538,752 14.0406 0.1136 0 0 0 0 0 0 0 0 0 0 0 0 0 0 4,671 13,546,528 19,964,606 53,206 56,891 22,543,771 8,226,278 192.198.1.12;172.17.0.1;10.244.3.0;10.244.3.1 0 0 true",
29798
+ "192.168.100.12 17,102 192.168.100.12:17102:server19-datanode1 0 1 192.168.100.12:17101:server19-agent1 254 120 5 31 1 server19-datanode1 23,118,960 24,133,632 13.928 0.1136 0 0 0 0 0 0 0 0 0 0 17,790,585,659,392 16,826,060,464,128 0.9458 0 4,687 1,289 23,477 44,197 55,104 352,258 6,163,159 192.198.1.12;172.17.0.1;10.244.3.0;10.244.3.1 0 0 ",
29799
+ "192.168.100.11 17,102 192.168.100.11:17102:server18-datanode1 0 1 192.168.100.11:17101:server18-agent1 254 120 5 31 1 server18-datanode1 23,111,912 24,133,632 14.1066 0.3219 0 0 0 0 0 0 0 0 0 0 17,790,585,659,392 16,714,392,956,928 0.9395 0 4,698 1,989 23,530 40,896 50,706 243,008 250,727 192.198.1.11;172.17.0.1;10.244.4.0;10.244.4.1 0 0 ",
29800
+ "192.168.100.11 17,101 192.168.100.11:17101:server18-agent1 1 1 192.168.100.11:17101:server18-agent1 304 4 4 63 0 server18-agent1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 192.198.1.11;172.17.0.1;10.244.4.0;10.244.4.1 0 0",
29801
+ "192.168.100.10 17,102 192.168.100.10:17102:server17-datanode1 0 1 192.168.100.10:17101:server17-agent1 254 120 5 31 1 server17-datanode1 40,872,496 52,445,184 0.7788 0.0037 0 0 0 0 0 0 0 0 0 0 53,783,736,754,176 50,336,934,432,768 0.9359 0 4,699 13,900,218 18,835 118,935 109,862 6,170,512 408,018 192.198.1.10;172.17.0.1;10.244.5.0;10.244.5.1 0 0",
29802
+ "192.168.100.12 17,101 192.168.100.12:17101:server19-agent1 1 1 192.168.100.12:17101:server19-agent1 304 4 4 63 0 server19-agent1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 192.198.1.12;172.17.0.1;10.244.3.0;10.244.3.1 0 0",
29803
+ "192.168.100.10 17,101 192.168.100.10:17101:server17-agent1 1 1 192.168.100.10:17101:server17-agent1 304 4 4 63 0 server17-agent1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 192.198.1.10;172.17.0.1;10.244.5.0;10.244.5.1 0 0",
29804
+ "=================== =========== ========================================== ====== ======= ===================================== ================ ============ =========== ============= =============== ===================== ============ ============= ========== ========= ==================== ==================== ===================== ===================== ===================== ============= ============ ============== ============= ========= ===================== ======================= ==================== =============== ============== ======================= ====================== ================= ================= ======================= ======================= =============================================== ================ =============== ================"
29207
29805
  ]
29208
29806
  }
29209
29807
  ]
@@ -30924,8 +31522,8 @@
30924
31522
  }
30925
31523
  ]
30926
31524
  },
30927
- "getMemoryStat": {
30928
- "title": "getMemoryStat",
31525
+ "getMemLimitOfQueryResult": {
31526
+ "title": "getMemLimitOfQueryResult",
30929
31527
  "type": "function",
30930
31528
  "children": [
30931
31529
  {
@@ -30935,7 +31533,7 @@
30935
31533
  {
30936
31534
  "type": "text",
30937
31535
  "value": [
30938
- "getMemoryStat()"
31536
+ "getMemLimitOfQueryResult()"
30939
31537
  ]
30940
31538
  }
30941
31539
  ]
@@ -30959,7 +31557,7 @@
30959
31557
  {
30960
31558
  "type": "text",
30961
31559
  "value": [
30962
- "返回当前节点已分配的内存和未使用的内存。"
31560
+ "获取单次查询结果占用的内存上限（单位为字节），返回一个 DOUBLE 类型数据。"
30963
31561
  ]
30964
31562
  }
30965
31563
  ]
@@ -30973,76 +31571,24 @@
30973
31571
  "language": "console",
30974
31572
  "value": [
30975
31573
  " ",
30976
- " $ getMemoryStat();",
30977
- "",
30978
- " freeBytes->6430128",
30979
- " allocatedBytes->35463168"
30980
- ]
30981
- }
30982
- ]
30983
- }
30984
- ]
30985
- },
30986
- "getNodeAlias": {
30987
- "title": "getNodeAlias",
30988
- "type": "function",
30989
- "children": [
30990
- {
30991
- "title": "语法",
30992
- "type": "grammer",
30993
- "children": [
30994
- {
30995
- "type": "text",
30996
- "value": [
30997
- "getNodeAlias()"
30998
- ]
30999
- }
31000
- ]
31001
- },
31002
- {
31003
- "title": "参数",
31004
- "type": "parameters",
31005
- "children": [
31006
- {
31007
- "type": "text",
31008
- "value": [
31009
- "无"
31574
+ " $ setMemLimitOfQueryResult(0.2)",
31575
+ " $ getMemLimitOfQueryResult() / 1024 / 1024 / 1024",
31576
+ " 0.2",
31577
+ ""
31010
31578
  ]
31011
- }
31012
- ]
31013
- },
31014
- {
31015
- "title": "详情",
31016
- "type": "detail",
31017
- "children": [
31579
+ },
31018
31580
  {
31019
31581
  "type": "text",
31020
31582
  "value": [
31021
- "获取本地节点的别名。该别名定义在配置文件 dolphindb.cfg 中。"
31022
- ]
31023
- }
31024
- ]
31025
- },
31026
- {
31027
- "title": "例子",
31028
- "type": "example",
31029
- "children": [
31030
- {
31031
- "type": "code",
31032
- "language": "console",
31033
- "value": [
31034
- " ",
31035
- " $ getNodeAlias();",
31036
- "",
31037
- " controller2"
31583
+ "相关函数：:doc:`/FunctionsandCommands/CommandsReferences/s/setMemLimitOfQueryResult`"
31038
31584
  ]
31039
31585
  }
31040
31586
  ]
31041
31587
  }
31042
31588
  ]
31043
31589
  },
31044
- "getNodeHost": {
31045
- "title": "getNodeHost",
31590
+ "getMemLimitOfTaskGroupResult": {
31591
+ "title": "getMemLimitOfTaskGroupResult",
31046
31592
  "type": "function",
31047
31593
  "children": [
31048
31594
  {
@@ -31052,7 +31598,7 @@
31052
31598
  {
31053
31599
  "type": "text",
31054
31600
  "value": [
31055
- "getNodeHost()"
31601
+ "getMemLimitOfTaskGroupResult()"
31056
31602
  ]
31057
31603
  }
31058
31604
  ]
@@ -31076,7 +31622,7 @@
31076
31622
  {
31077
31623
  "type": "text",
31078
31624
  "value": [
31079
- "获取本地节点的主机名。该名称定义在配置文件 dolphindb.cfg 中。"
31625
+ "获取当前节点发送的批量子查询占用的内存上限（单位为字节），返回一个 DOUBLE 类型数据。"
31080
31626
  ]
31081
31627
  }
31082
31628
  ]
@@ -31090,17 +31636,24 @@
31090
31636
  "language": "console",
31091
31637
  "value": [
31092
31638
  " ",
31093
- " $ getNodeHost();",
31094
- "",
31095
- " 10.6.0.6"
31639
+ " $ setMemLimitOfTaskGroupResult(10)",
31640
+ " $ getMemLimitOfTaskGroupResult() / 1024 / 1024 / 1024",
31641
+ " 10",
31642
+ ""
31643
+ ]
31644
+ },
31645
+ {
31646
+ "type": "text",
31647
+ "value": [
31648
+ "相关函数：:doc:`/FunctionsandCommands/CommandsReferences/s/setMemLimitOfTaskGroupResult`"
31096
31649
  ]
31097
31650
  }
31098
31651
  ]
31099
31652
  }
31100
31653
  ]
31101
31654
  },
31102
- "getNodePort": {
31103
- "title": "getNodePort",
31655
+ "getMemoryStat": {
31656
+ "title": "getMemoryStat",
31104
31657
  "type": "function",
31105
31658
  "children": [
31106
31659
  {
@@ -31110,7 +31663,7 @@
31110
31663
  {
31111
31664
  "type": "text",
31112
31665
  "value": [
31113
- "getNodePort()"
31666
+ "getMemoryStat()"
31114
31667
  ]
31115
31668
  }
31116
31669
  ]
@@ -31134,7 +31687,7 @@
31134
31687
  {
31135
31688
  "type": "text",
31136
31689
  "value": [
31137
- "获取节点使用的端口号。该端口号定义在配置文件dolphindb.cfg 中。"
31690
+ "返回当前节点已分配的内存和未使用的内存。"
31138
31691
  ]
31139
31692
  }
31140
31693
  ]
@@ -31148,17 +31701,18 @@
31148
31701
  "language": "console",
31149
31702
  "value": [
31150
31703
  " ",
31151
- " $ getNodePort();",
31704
+ " $ getMemoryStat();",
31152
31705
  "",
31153
- " 8888"
31706
+ " freeBytes->6430128",
31707
+ " allocatedBytes->35463168"
31154
31708
  ]
31155
31709
  }
31156
31710
  ]
31157
31711
  }
31158
31712
  ]
31159
31713
  },
31160
- "getNodeType": {
31161
- "title": "getNodeType",
31714
+ "getNodeAlias": {
31715
+ "title": "getNodeAlias",
31162
31716
  "type": "function",
31163
31717
  "children": [
31164
31718
  {
@@ -31168,7 +31722,7 @@
31168
31722
  {
31169
31723
  "type": "text",
31170
31724
  "value": [
31171
- "getNodeType()"
31725
+ "getNodeAlias()"
31172
31726
  ]
31173
31727
  }
31174
31728
  ]
@@ -31192,7 +31746,7 @@
31192
31746
  {
31193
31747
  "type": "text",
31194
31748
  "value": [
31195
- "返回节点的类型。0表示数据节点；1表示代理节点；2表示控制器节点；3表示单节点模式；4表示计算节点。"
31749
+ "获取本地节点的别名。该别名定义在配置文件 dolphindb.cfg 中。"
31196
31750
  ]
31197
31751
  }
31198
31752
  ]
@@ -31206,17 +31760,17 @@
31206
31760
  "language": "console",
31207
31761
  "value": [
31208
31762
  " ",
31209
- " $ getNodeType();",
31763
+ " $ getNodeAlias();",
31210
31764
  "",
31211
- " 2"
31765
+ " controller2"
31212
31766
  ]
31213
31767
  }
31214
31768
  ]
31215
31769
  }
31216
31770
  ]
31217
31771
  },
31218
- "getOS": {
31219
- "title": "getOS",
31772
+ "getNodeHost": {
31773
+ "title": "getNodeHost",
31220
31774
  "type": "function",
31221
31775
  "children": [
31222
31776
  {
@@ -31226,7 +31780,7 @@
31226
31780
  {
31227
31781
  "type": "text",
31228
31782
  "value": [
31229
- "getOS()"
31783
+ "getNodeHost()"
31230
31784
  ]
31231
31785
  }
31232
31786
  ]
@@ -31250,7 +31804,7 @@
31250
31804
  {
31251
31805
  "type": "text",
31252
31806
  "value": [
31253
- "返回DolphinDB server所在操作系统的类型。"
31807
+ "获取本地节点的主机名。该名称定义在配置文件 dolphindb.cfg 中。"
31254
31808
  ]
31255
31809
  }
31256
31810
  ]
@@ -31264,17 +31818,17 @@
31264
31818
  "language": "console",
31265
31819
  "value": [
31266
31820
  " ",
31267
- " $ getOS();",
31821
+ " $ getNodeHost();",
31268
31822
  "",
31269
- " linux"
31823
+ " 10.6.0.6"
31270
31824
  ]
31271
31825
  }
31272
31826
  ]
31273
31827
  }
31274
31828
  ]
31275
31829
  },
31276
- "getOSBit": {
31277
- "title": "getOSBit",
31830
+ "getNodePort": {
31831
+ "title": "getNodePort",
31278
31832
  "type": "function",
31279
31833
  "children": [
31280
31834
  {
@@ -31284,7 +31838,7 @@
31284
31838
  {
31285
31839
  "type": "text",
31286
31840
  "value": [
31287
- "getOSBit()"
31841
+ "getNodePort()"
31288
31842
  ]
31289
31843
  }
31290
31844
  ]
@@ -31308,7 +31862,7 @@
31308
31862
  {
31309
31863
  "type": "text",
31310
31864
  "value": [
31311
- "返回DolphinDB server所在操作系统的位数。"
31865
+ "获取节点使用的端口号。该端口号定义在配置文件dolphindb.cfg 中。"
31312
31866
  ]
31313
31867
  }
31314
31868
  ]
@@ -31322,17 +31876,17 @@
31322
31876
  "language": "console",
31323
31877
  "value": [
31324
31878
  " ",
31325
- " $ getOSBit();",
31879
+ " $ getNodePort();",
31326
31880
  "",
31327
- " 64"
31881
+ " 8888"
31328
31882
  ]
31329
31883
  }
31330
31884
  ]
31331
31885
  }
31332
31886
  ]
31333
31887
  },
31334
- "getPerf": {
31335
- "title": "getPerf",
31888
+ "getNodeType": {
31889
+ "title": "getNodeType",
31336
31890
  "type": "function",
31337
31891
  "children": [
31338
31892
  {
@@ -31342,7 +31896,181 @@
31342
31896
  {
31343
31897
  "type": "text",
31344
31898
  "value": [
31345
- "getPerf()"
31899
+ "getNodeType()"
31900
+ ]
31901
+ }
31902
+ ]
31903
+ },
31904
+ {
31905
+ "title": "参数",
31906
+ "type": "parameters",
31907
+ "children": [
31908
+ {
31909
+ "type": "text",
31910
+ "value": [
31911
+ "无"
31912
+ ]
31913
+ }
31914
+ ]
31915
+ },
31916
+ {
31917
+ "title": "详情",
31918
+ "type": "detail",
31919
+ "children": [
31920
+ {
31921
+ "type": "text",
31922
+ "value": [
31923
+ "返回节点的类型。0表示数据节点；1表示代理节点；2表示控制器节点；3表示单节点模式；4表示计算节点。"
31924
+ ]
31925
+ }
31926
+ ]
31927
+ },
31928
+ {
31929
+ "title": "例子",
31930
+ "type": "example",
31931
+ "children": [
31932
+ {
31933
+ "type": "code",
31934
+ "language": "console",
31935
+ "value": [
31936
+ " ",
31937
+ " $ getNodeType();",
31938
+ "",
31939
+ " 2"
31940
+ ]
31941
+ }
31942
+ ]
31943
+ }
31944
+ ]
31945
+ },
31946
+ "getOS": {
31947
+ "title": "getOS",
31948
+ "type": "function",
31949
+ "children": [
31950
+ {
31951
+ "title": "语法",
31952
+ "type": "grammer",
31953
+ "children": [
31954
+ {
31955
+ "type": "text",
31956
+ "value": [
31957
+ "getOS()"
31958
+ ]
31959
+ }
31960
+ ]
31961
+ },
31962
+ {
31963
+ "title": "参数",
31964
+ "type": "parameters",
31965
+ "children": [
31966
+ {
31967
+ "type": "text",
31968
+ "value": [
31969
+ "无"
31970
+ ]
31971
+ }
31972
+ ]
31973
+ },
31974
+ {
31975
+ "title": "详情",
31976
+ "type": "detail",
31977
+ "children": [
31978
+ {
31979
+ "type": "text",
31980
+ "value": [
31981
+ "返回DolphinDB server所在操作系统的类型。"
31982
+ ]
31983
+ }
31984
+ ]
31985
+ },
31986
+ {
31987
+ "title": "例子",
31988
+ "type": "example",
31989
+ "children": [
31990
+ {
31991
+ "type": "code",
31992
+ "language": "console",
31993
+ "value": [
31994
+ " ",
31995
+ " $ getOS();",
31996
+ "",
31997
+ " linux"
31998
+ ]
31999
+ }
32000
+ ]
32001
+ }
32002
+ ]
32003
+ },
32004
+ "getOSBit": {
32005
+ "title": "getOSBit",
32006
+ "type": "function",
32007
+ "children": [
32008
+ {
32009
+ "title": "语法",
32010
+ "type": "grammer",
32011
+ "children": [
32012
+ {
32013
+ "type": "text",
32014
+ "value": [
32015
+ "getOSBit()"
32016
+ ]
32017
+ }
32018
+ ]
32019
+ },
32020
+ {
32021
+ "title": "参数",
32022
+ "type": "parameters",
32023
+ "children": [
32024
+ {
32025
+ "type": "text",
32026
+ "value": [
32027
+ "无"
32028
+ ]
32029
+ }
32030
+ ]
32031
+ },
32032
+ {
32033
+ "title": "详情",
32034
+ "type": "detail",
32035
+ "children": [
32036
+ {
32037
+ "type": "text",
32038
+ "value": [
32039
+ "返回DolphinDB server所在操作系统的位数。"
32040
+ ]
32041
+ }
32042
+ ]
32043
+ },
32044
+ {
32045
+ "title": "例子",
32046
+ "type": "example",
32047
+ "children": [
32048
+ {
32049
+ "type": "code",
32050
+ "language": "console",
32051
+ "value": [
32052
+ " ",
32053
+ " $ getOSBit();",
32054
+ "",
32055
+ " 64"
32056
+ ]
32057
+ }
32058
+ ]
32059
+ }
32060
+ ]
32061
+ },
32062
+ "getPerf": {
32063
+ "title": "getPerf",
32064
+ "type": "function",
32065
+ "children": [
32066
+ {
32067
+ "title": "语法",
32068
+ "type": "grammer",
32069
+ "children": [
32070
+ {
32071
+ "type": "text",
32072
+ "value": [
32073
+ "getPerf()"
31346
32074
  ]
31347
32075
  }
31348
32076
  ]
@@ -31510,6 +32238,86 @@
31510
32238
  }
31511
32239
  ]
31512
32240
  },
32241
+ "getQueryStatus": {
32242
+ "title": "getQueryStatus",
32243
+ "type": "function",
32244
+ "children": [
32245
+ {
32246
+ "title": "语法",
32247
+ "type": "grammer",
32248
+ "children": [
32249
+ {
32250
+ "type": "text",
32251
+ "value": [
32252
+ "getQueryStatus()"
32253
+ ]
32254
+ }
32255
+ ]
32256
+ },
32257
+ {
32258
+ "title": "参数",
32259
+ "type": "parameters",
32260
+ "children": [
32261
+ {
32262
+ "type": "text",
32263
+ "value": [
32264
+ "无"
32265
+ ]
32266
+ }
32267
+ ]
32268
+ },
32269
+ {
32270
+ "title": "详情",
32271
+ "type": "detail",
32272
+ "children": [
32273
+ {
32274
+ "type": "text",
32275
+ "value": [
32276
+ "获取由当前节点发起且正在执行的查询任务状态，返回一个表对象，包含以下几列：",
32277
+ "",
32278
+ "* id：表示到该查询任务为止，系统已执行的查询任务总数。",
32279
+ "* sessionId：任务发起会话的 id。请注意，无法获取通过 submitJob 提交的查询任务的 sessionId。",
32280
+ "* userId：任务发起会话的用户名。",
32281
+ "* query：原始查询语句中主要的查询信息。",
32282
+ "* startTime：查询任务开始的时间戳。",
32283
+ "* elapsedTimeInMs：查询任务已经经过的时间，单位为毫秒。",
32284
+ "* memoryUsage：查询过程中变量和结果所占用的内存空间，单位为字节。",
32285
+ "* totalTaskCount：查询子任务总数。",
32286
+ "* completedTaskCount：已完成的查询子任务数。",
32287
+ "* percentComplete：已完成的查询子任务占比。",
32288
+ "",
32289
+ "该函数只能在任务发起节点上调用。"
32290
+ ]
32291
+ }
32292
+ ]
32293
+ },
32294
+ {
32295
+ "title": "例子",
32296
+ "type": "example",
32297
+ "children": [
32298
+ {
32299
+ "type": "code",
32300
+ "language": "console",
32301
+ "value": [
32302
+ "",
32303
+ " getQueryStatus();",
32304
+ ""
32305
+ ]
32306
+ },
32307
+ {
32308
+ "type": "text",
32309
+ "value": [
32310
+ "=== ========== ======== =============================== ========================= ================ ============ =============== =================== ================",
32311
+ "id sessionId userId query startTime elapsedTimeInMs memoryUsage totalTaskCount completedTaskCount percentComplete",
32312
+ "=== ========== ======== =============================== ========================= ================ ============ =============== =================== ================",
32313
+ "2 1166953221 admin select ticker, id, x from pt 2022.06.14 08:15:00.606 1052 184550000 4 1 0.25",
32314
+ "=== ========== ======== =============================== ========================= ================ ============ =============== =================== ================"
32315
+ ]
32316
+ }
32317
+ ]
32318
+ }
32319
+ ]
32320
+ },
31513
32321
  "getRaftElectionTick": {
31514
32322
  "title": "getRaftElectionTick",
31515
32323
  "type": "function",
@@ -31694,11 +32502,13 @@
31694
32502
  "* DeleteSource: 是否删除源节点的数据。当 TaskType 是 ChunkRecovery 时，只能返回 false；当 TaskType 是 LoadRebalance 时，可以返回 true 或 false。",
31695
32503
  "* StartTime: 创建恢复任务的时间。",
31696
32504
  "* LastDequeueTime: 任务最后一次从任务队列出队的时间。",
31697
- "* LastStartTime：最后一次开始执行任务的时间。",
32505
+ "* LastStartTime: 最后一次开始执行任务的时间。",
31698
32506
  "* FinishTime: 任务结束的时间。",
31699
32507
  "* IsIncrementalRecovery: 是否启用增量复制。",
31700
- "* IsAsyncRecovery：是否启用异步复制。",
31701
- "* ChangeFromIncrementalToFull: 是否成功从增量恢复转为全量复制。"
32508
+ "* IsAsyncRecovery: 是否启用异步复制。",
32509
+ "* ChangeFromIncrementalToFull: 是否从增量恢复转为全量恢复。系统多次尝试增量恢复失败会自动转换成全量恢复。",
32510
+ "* ChangeToSyncTime: 节点在线恢复时，从异步恢复阶段转为同步恢复阶段的时刻。",
32511
+ "* FailureReason：recovery 任务失败的原因。"
31702
32512
  ]
31703
32513
  }
31704
32514
  ]
@@ -31721,7 +32531,7 @@
31721
32531
  },
31722
32532
  "getRecoveryWorkerNum": {
31723
32533
  "title": "getRecoveryWorkerNum",
31724
- "type": "command",
32534
+ "type": "function",
31725
32535
  "children": [
31726
32536
  {
31727
32537
  "title": "语法",
@@ -31777,7 +32587,82 @@
31777
32587
  {
31778
32588
  "type": "text",
31779
32589
  "value": [
31780
- "相关函数：:doc:`../r/resetRecoveryWorkerNum`"
32590
+ "相关函数：:doc:`/FunctionsandCommands/CommandsReferences/r/resetRecoveryWorkerNum`"
32591
+ ]
32592
+ }
32593
+ ]
32594
+ }
32595
+ ]
32596
+ },
32597
+ "getRedoLogGCStat": {
32598
+ "title": "getRedoLogGCStat",
32599
+ "type": "function",
32600
+ "children": [
32601
+ {
32602
+ "title": "语法",
32603
+ "type": "grammer",
32604
+ "children": [
32605
+ {
32606
+ "type": "text",
32607
+ "value": [
32608
+ "getRedoLogGCStat()"
32609
+ ]
32610
+ }
32611
+ ]
32612
+ },
32613
+ {
32614
+ "title": "参数",
32615
+ "type": "parameters",
32616
+ "children": [
32617
+ {
32618
+ "type": "text",
32619
+ "value": [
32620
+ "无"
32621
+ ]
32622
+ }
32623
+ ]
32624
+ },
32625
+ {
32626
+ "title": "详情",
32627
+ "type": "detail",
32628
+ "children": [
32629
+ {
32630
+ "type": "text",
32631
+ "value": [
32632
+ "获取 redo log 垃圾回收的状态。返回一个表对象，包含以下几列：",
32633
+ "",
32634
+ "* physicalName：物理表名，格式为 \"/数据库名/物理表名\"",
32635
+ "* txnCount：redo log 尚未回收的事务数。",
32636
+ "* numOfTxnPendingGC：等待回收的事务数。",
32637
+ "* minTidPendingGC：等待回收的事务的最小 tid。",
32638
+ "* numOfTxnPendingFlush：等待刷盘的事务数。",
32639
+ "* minTidPendingFlush：等待刷盘的事务的最小 tid。"
32640
+ ]
32641
+ }
32642
+ ]
32643
+ },
32644
+ {
32645
+ "title": "例子",
32646
+ "type": "example",
32647
+ "children": [
32648
+ {
32649
+ "type": "code",
32650
+ "language": "console",
32651
+ "value": [
32652
+ " ",
32653
+ " $ getRedoLogGCStat();",
32654
+ ""
32655
+ ]
32656
+ },
32657
+ {
32658
+ "type": "text",
32659
+ "value": [
32660
+ "============== ============ ==================== ================== ===================== ====================",
32661
+ "physicalName txnCount numOfTxnPendingGC minTidPendingGC numOfTxnPendingFlush minTidPendingFlush",
32662
+ "============== ============ ==================== ================== ===================== ====================",
32663
+ "/test/pt_2 2 0 2 1031",
32664
+ "/listdb/pt_2 1 1 1033 0",
32665
+ "============== ============ ==================== ================== ===================== ===================="
31781
32666
  ]
31782
32667
  }
31783
32668
  ]
@@ -32683,7 +33568,7 @@
32683
33568
  {
32684
33569
  "type": "text",
32685
33570
  "value": [
32686
- "监控流计算的状态。返回的结果是一个字典，包含以下4个表：",
33571
+ "监控流计算的状态。返回的结果是一个字典，包含以下5个表：",
32687
33572
  "",
32688
33573
  "* 表pubConns监控本地发布节点和它的所有订阅节点之间的连接状态。每一行表示一个订阅节点。它包含以下列：",
32689
33574
  "",
@@ -32796,6 +33681,7 @@
32796
33681
  "value": [
32797
33682
  " $ getStreamingStat().pubConns;",
32798
33683
  " $ getStreamingStat().subConns;",
33684
+ " $ getStreamingStat().pubTables;",
32799
33685
  " $ getStreamingStat().persistWorkers;",
32800
33686
  " $ getStreamingStat().subWorkers;"
32801
33687
  ]
@@ -32878,6 +33764,102 @@
32878
33764
  }
32879
33765
  ]
32880
33766
  },
33767
+ "getSupportBundle": {
33768
+ "title": "getSupportBundle",
33769
+ "type": "function",
33770
+ "children": [
33771
+ {
33772
+ "title": "语法",
33773
+ "type": "grammer",
33774
+ "children": [
33775
+ {
33776
+ "type": "text",
33777
+ "value": [
33778
+ "getSupportBundle([dir])"
33779
+ ]
33780
+ }
33781
+ ]
33782
+ },
33783
+ {
33784
+ "title": "参数",
33785
+ "type": "parameters",
33786
+ "children": [
33787
+ {
33788
+ "type": "text",
33789
+ "value": [
33790
+ "`dir` 可选参数，用于指定存储路径。若不指定该参数，单节点环境下默认存储至 <HomeDir>（可通过 :doc:`getHomeDir` 查看 <HomeDir>）；集群环境下默认存储至 <HomeDir> 同级目录。"
33791
+ ]
33792
+ }
33793
+ ]
33794
+ },
33795
+ {
33796
+ "title": "详情",
33797
+ "type": "detail",
33798
+ "children": [
33799
+ {
33800
+ "type": "text",
33801
+ "value": [
33802
+ "生成一个包含所有配置信息的文件，并返回文件路径。该函数只能在数据节点/计算节点调用。",
33803
+ "",
33804
+ "配置文件包含以下信息：",
33805
+ "",
33806
+ "",
33807
+ "+----------------------+--------------------------------------------------------------------------------+-----------------------------------------+",
33808
+ "| 模块名 | 含义 | 信息来源 |",
33809
+ "+======================+================================================================================+=========================================+",
33810
+ "| VERSION | server 的版本信息。 | ``version()`` |",
33811
+ "+----------------------+--------------------------------------------------------------------------------+-----------------------------------------+",
33812
+ "| CONFIGS | 配置信息。单机环境下，返回单节点的配置信息；集群环境下，包含集群、控制节点、 | 单机: dolphindb.cfg |",
33813
+ "| | 和数据节点/计算节点的配置。 | 集群: cluster.cfg, |",
33814
+ "| | | cluster.nodes, controller.cfg |",
33815
+ "+----------------------+--------------------------------------------------------------------------------+-----------------------------------------+",
33816
+ "| DB AND TABLE SCHEMA | 所有数据库和表的结构。 | ``schema`` |",
33817
+ "+----------------------+--------------------------------------------------------------------------------+-----------------------------------------+",
33818
+ "| LICENSE AND MACHINE | license、机器核数和内存信息。 | 许可证: dolphindb.lic |",
33819
+ "| INFO | | |",
33820
+ "+----------------------+--------------------------------------------------------------------------------+-----------------------------------------+",
33821
+ "| OLAP CACHE ENGINE | OLAP 引擎 cache Engine 的状态信息，包含各节点的内存信息以及当前节点的状态表。 | ``pnodeRun(getCacheEngineMemSize)`` |",
33822
+ "| STATUS | | ``pnodeRun(getCacheEngineStat)`` |",
33823
+ "+----------------------+--------------------------------------------------------------------------------+-----------------------------------------+",
33824
+ "| TSDB META | 获取 TSDB 引擎下所有 chunk 的元数据。 | ``pnodeRun(getTSDBMetaData)`` |",
33825
+ "+----------------------+--------------------------------------------------------------------------------+-----------------------------------------+",
33826
+ "| REDO LOG GC STATUS | 获取事务 redo log 回收的状态。 | ``pnodeRun(getRedoLogGCStat)`` |",
33827
+ "+----------------------+--------------------------------------------------------------------------------+-----------------------------------------+",
33828
+ "| TRANSACTION STATUS | 获取事务的状态。 | ``pnodeRun(getTransactionStatus)`` |",
33829
+ "+----------------------+--------------------------------------------------------------------------------+-----------------------------------------+",
33830
+ "| TABLETS META | 返回集群中行数最多的前100个 chunk 的元数据信息。 | select top 100 \\* from pnodeRun(getTable|",
33831
+ "| | | tsMeta{\"%\",\"%\",false,-1}) order by |",
33832
+ "| | | rowNum desc |",
33833
+ "+----------------------+--------------------------------------------------------------------------------+-----------------------------------------+",
33834
+ "|ANOMALOUS CHUNK STATUS| 获取处于异常状态的 chunk 信息。异常状态包含处于 recovery 状态，版本号不一致， | ``getClusterChunksStatus()`` |",
33835
+ "|(only in cluster mode)| 副本数不一致等。 | |",
33836
+ "+----------------------+--------------------------------------------------------------------------------+-----------------------------------------+",
33837
+ ""
33838
+ ]
33839
+ }
33840
+ ]
33841
+ },
33842
+ {
33843
+ "title": "例子",
33844
+ "type": "example",
33845
+ "children": [
33846
+ {
33847
+ "type": "code",
33848
+ "language": "console",
33849
+ "value": [
33850
+ "",
33851
+ " $ getSupportBundle()",
33852
+ " /home/dolphindb/server/getSupportBundle.1655869793424",
33853
+ "",
33854
+ " $ getSupportBundle(\"/home/dolphindb/sup\")",
33855
+ " /home/dolphindb/sup/getSupportBundle.1655869853178",
33856
+ " "
33857
+ ]
33858
+ }
33859
+ ]
33860
+ }
33861
+ ]
33862
+ },
32881
33863
  "getSystemCpuUsage": {
32882
33864
  "title": "getSystemCpuUsage",
32883
33865
  "type": "function",
@@ -33376,6 +34358,82 @@
33376
34358
  }
33377
34359
  ]
33378
34360
  },
34361
+ "getTransactionStatus": {
34362
+ "title": "getTransactionStatus",
34363
+ "type": "function",
34364
+ "children": [
34365
+ {
34366
+ "title": "语法",
34367
+ "type": "grammer",
34368
+ "children": [
34369
+ {
34370
+ "type": "text",
34371
+ "value": [
34372
+ "getTransactionStatus()"
34373
+ ]
34374
+ }
34375
+ ]
34376
+ },
34377
+ {
34378
+ "title": "参数",
34379
+ "type": "parameters",
34380
+ "children": [
34381
+ {
34382
+ "type": "text",
34383
+ "value": [
34384
+ "无"
34385
+ ]
34386
+ }
34387
+ ]
34388
+ },
34389
+ {
34390
+ "title": "详情",
34391
+ "type": "detail",
34392
+ "children": [
34393
+ {
34394
+ "type": "text",
34395
+ "value": [
34396
+ "获取事务的状态，该函数只能在数据节点/计算节点执行。返回一个表，包含以下列：",
34397
+ "",
34398
+ "* tid ：事务的 id。",
34399
+ "* startTime：事务开始的时间。",
34400
+ "* type：事务涉及到的操作类型，包括 APPEND, DROP, SQLUPDATE, SQLUPSERT, SQLDELETE, FILEOPERATE 和 UNKNOWN。",
34401
+ "* status：事务当前的状态，包括 BEGIN, COMMIT, COMPLETE, ROLLBACK。",
34402
+ "* partitionCount：事务涉及到的分区数量。",
34403
+ "* endTime：事务结束的时间。",
34404
+ "* elapsedTime：事务持续的时间。"
34405
+ ]
34406
+ }
34407
+ ]
34408
+ },
34409
+ {
34410
+ "title": "例子",
34411
+ "type": "example",
34412
+ "children": [
34413
+ {
34414
+ "type": "code",
34415
+ "language": "console",
34416
+ "value": [
34417
+ "",
34418
+ " getTransactionStatus() ",
34419
+ ""
34420
+ ]
34421
+ },
34422
+ {
34423
+ "type": "text",
34424
+ "value": [
34425
+ "============= ========================== ======= ====== ============== ============================ ============",
34426
+ "tid startTime type status partitionCount endTime elapsedTime",
34427
+ "============= ========================== ======= ====== ============== ============================ ============",
34428
+ "3135 2022.06.07 16:19:48.477 APPEND BEGIN 4 584",
34429
+ "3143 2022.06.07 16:11:27.489 APPEND COMMIT 4 \t2022.06.07 16:11:33.100 484",
34430
+ "============= ========================== ======= ====== ============== ============================ ============"
34431
+ ]
34432
+ }
34433
+ ]
34434
+ }
34435
+ ]
34436
+ },
33379
34437
  "getUserAccess": {
33380
34438
  "title": "getUserAccess",
33381
34439
  "type": "function",
@@ -33746,6 +34804,107 @@
33746
34804
  }
33747
34805
  ]
33748
34806
  },
34807
+ "gmm": {
34808
+ "title": "gmm",
34809
+ "type": "function",
34810
+ "children": [
34811
+ {
34812
+ "title": "语法",
34813
+ "type": "grammer",
34814
+ "children": [
34815
+ {
34816
+ "type": "text",
34817
+ "value": [
34818
+ "gmm(X, k, [maxIter=300], [tolerance=1e-4], [randomSeed], [mean], [sigma])"
34819
+ ]
34820
+ }
34821
+ ]
34822
+ },
34823
+ {
34824
+ "title": "参数",
34825
+ "type": "parameters",
34826
+ "children": [
34827
+ {
34828
+ "type": "text",
34829
+ "value": [
34830
+ "`X` 训练数据集。若为一元数据，则 *X* 是一个向量；若为多元数据，则 *X* 是一个矩阵或表，矩阵的每列代表一个样本数据。",
34831
+ "",
34832
+ "`k` 正整数。表示混合模型中子模型的数量。",
34833
+ "",
34834
+ "`maxlter` 正整数，表示最大的迭代次数。默认为 300。",
34835
+ "",
34836
+ "`tolerance` 浮点数，表示 EM 迭代中止的边界差值。如果相邻两次迭代的对数似然函数值的差值小于 *tolerance*，则停止迭代。默认为 1e-4。",
34837
+ "",
34838
+ "`randomSeed` 随机数种子。",
34839
+ "",
34840
+ "`mean` 可选参数，向量/矩阵。表示模型初始化的均值。若 *X* 为一元数据，则 *mean* 是元素个数为 *k* 的向量；若 *X* 为多元数据，则 *mean* 是列数为 *k*，行数与 *X* 的元数相同的矩阵。若不指定，系统随机从 *X* 中选择 *k* 个值作为模型的初始化均值。",
34841
+ "",
34842
+ "`sigma` 可选参数，向量/元组，元素个数为 *k*。若 *X* 为一元数据，表示每个子模型初始化的方差；若 *X* 为多元数据，表示每个子模型初始化的协方差矩阵。若不指定，系统使用元素值为 1 的向量或单位矩阵。",
34843
+ ""
34844
+ ]
34845
+ }
34846
+ ]
34847
+ },
34848
+ {
34849
+ "title": "详情",
34850
+ "type": "detail",
34851
+ "children": [
34852
+ {
34853
+ "type": "text",
34854
+ "value": [
34855
+ "通过数据集训练 GMM（高斯混合模型）。返回一个字典，包含以下键值：",
34856
+ "",
34857
+ "* modelName：字符串 \"Gaussian Mixture Model\"",
34858
+ "* prior：观测数据属于各子模型的先验概率。",
34859
+ "* mean：训练获得的每个子模型的期望。",
34860
+ "* sigma：若 *X* 为 一元数据，表示训练获得的每个子模型的方差；若 *X* 为多元数据，表示训练获得的每个子模型的协方差矩阵。"
34861
+ ]
34862
+ }
34863
+ ]
34864
+ },
34865
+ {
34866
+ "title": "例子",
34867
+ "type": "example",
34868
+ "children": [
34869
+ {
34870
+ "type": "code",
34871
+ "language": "console",
34872
+ "value": [
34873
+ "",
34874
+ " $ dataT = 6.8 7.2 5.3 9.4 6.5 11.2 25.6 0.6 8.9 4.3 2.2 1.9 8.7 0.2 1.5",
34875
+ " $ mean = [2, 2]",
34876
+ " $ re = gmm(dataT, 2, 300, 1e-4, 42, mean)",
34877
+ " $ re",
34878
+ "",
34879
+ " sigma->[36.759822,36.759822]",
34880
+ " modelName->Gaussian Mixture Model",
34881
+ " prior->[0.5,0.5]",
34882
+ " mean->[6.686667,6.686667]",
34883
+ "",
34884
+ " $ dataT = transpose(matrix(3.2 1.5 2.6 7.8 6.3 4.2 5.1 8.9 11.2 25.8, 25.6 4.6 8.9 4.3 2.2 1.9 8.7 0.2 1.5 9.3))",
34885
+ " $ mean = transpose(matrix([1, 0], [0, 1]))",
34886
+ " $ re = gmm(dataT, 2, 300, 1e-4, 42, mean)",
34887
+ " $ re",
34888
+ "",
34889
+ " sigma->(#0 #1 ",
34890
+ " 51.001369 18.273032",
34891
+ " 18.273032 9.34789 ",
34892
+ " ,#0 #1 ",
34893
+ " 1.718475 0.629584 ",
34894
+ " 0.629584 67.713701",
34895
+ " )",
34896
+ " modelName->Gaussian Mixture Model",
34897
+ " prior->[0.558683,0.441317]",
34898
+ " mean->",
34899
+ " #0 #1 ",
34900
+ " 11.152841 3.238262 ",
34901
+ " 3.341493 10.996997"
34902
+ ]
34903
+ }
34904
+ ]
34905
+ }
34906
+ ]
34907
+ },
33749
34908
  "gmtime": {
33750
34909
  "title": "gmtime",
33751
34910
  "type": "function",
@@ -39468,6 +40627,128 @@
39468
40627
  }
39469
40628
  ]
39470
40629
  },
40630
+ "isPeak": {
40631
+ "title": "isPeak",
40632
+ "type": "function",
40633
+ "children": [
40634
+ {
40635
+ "title": "语法",
40636
+ "type": "grammer",
40637
+ "children": [
40638
+ {
40639
+ "type": "text",
40640
+ "value": [
40641
+ "isPeak(X, [strict=true])"
40642
+ ]
40643
+ }
40644
+ ]
40645
+ },
40646
+ {
40647
+ "title": "参数",
40648
+ "type": "parameters",
40649
+ "children": [
40650
+ {
40651
+ "type": "text",
40652
+ "value": [
40653
+ "`X` 数值型向量/矩阵/表。",
40654
+ "",
40655
+ "`strict` 布尔值，表示是否取严格的峰值点。默认值为 true。"
40656
+ ]
40657
+ }
40658
+ ]
40659
+ },
40660
+ {
40661
+ "title": "详情",
40662
+ "type": "detail",
40663
+ "children": [
40664
+ {
40665
+ "type": "text",
40666
+ "value": [
40667
+ "若 *X* 为向量，计算 *X* 中的每个元素是否为峰值点，若是则返回 true，否则返回 false。",
40668
+ "",
40669
+ "判断规则为：",
40670
+ "",
40671
+ "* 若 *strict* = true，相邻元素不为空且严格小于该元素；",
40672
+ "* 若 *strict* = false，相邻元素不为空且小于等于该元素；",
40673
+ "",
40674
+ "若 *X* 为矩阵，在每列进行上述计算，返回值一个同 X 维度相同的矩阵。若 *X* 为表，则只对数值型的列进行上述计算。"
40675
+ ]
40676
+ }
40677
+ ]
40678
+ },
40679
+ {
40680
+ "title": "例子",
40681
+ "type": "example",
40682
+ "children": [
40683
+ {
40684
+ "type": "code",
40685
+ "language": "console",
40686
+ "value": [
40687
+ "",
40688
+ " $ v = [1, 2.2, 2.2, 2.2, 2.3, 1, 1.2]",
40689
+ " $ isPeak(v)",
40690
+ " [0,0,0,0,1,0,0]",
40691
+ "",
40692
+ " $ v = [1, 2.2, 2.2, 2.2, 1.6, 1, 1.2]",
40693
+ " $ isPeak(v)",
40694
+ " [0,0,0,0,0,0,0]",
40695
+ " $ isPeak(v, false)",
40696
+ " [0,1,1,1,0,0,0]",
40697
+ "",
40698
+ " // 矩阵在每列单独计算",
40699
+ " $ m = matrix(3.3 2.8 5.6 NULL 2.5 1.2, 4.5 3.5 4.6 2.8 3.9 NULL)",
40700
+ " $ isPeak(m)",
40701
+ ""
40702
+ ]
40703
+ },
40704
+ {
40705
+ "type": "text",
40706
+ "value": [
40707
+ "== ==",
40708
+ "#0 #1",
40709
+ "== ==",
40710
+ "0 0 ",
40711
+ "0 0 ",
40712
+ "0 1 ",
40713
+ "0 0 ",
40714
+ "0 0 ",
40715
+ "0 0 ",
40716
+ "== ==",
40717
+ ""
40718
+ ]
40719
+ },
40720
+ {
40721
+ "type": "code",
40722
+ "language": "console",
40723
+ "value": [
40724
+ "",
40725
+ " // 表只在数值列进行计算",
40726
+ " $ t = table(`01`01`00`01`02`00 as id, 2022.01.01 + 1..6 as date, 388.3 390.6 390.8 390.6 390.3 391.5 as price)",
40727
+ " $ isPeak(t)",
40728
+ ""
40729
+ ]
40730
+ },
40731
+ {
40732
+ "type": "text",
40733
+ "value": [
40734
+ "== ========== =====",
40735
+ "id date price",
40736
+ "== ========== =====",
40737
+ "01 2022.01.02 0 ",
40738
+ "01 2022.01.03 0 ",
40739
+ "00 2022.01.04 1 ",
40740
+ "01 2022.01.05 0 ",
40741
+ "02 2022.01.06 0 ",
40742
+ "00 2022.01.07 0",
40743
+ "== ========== =====",
40744
+ "",
40745
+ "相关函数：:doc:`isValley`"
40746
+ ]
40747
+ }
40748
+ ]
40749
+ }
40750
+ ]
40751
+ },
39471
40752
  "isQuarterEnd": {
39472
40753
  "title": "isQuarterEnd",
39473
40754
  "type": "function",
@@ -39944,6 +41225,128 @@
39944
41225
  }
39945
41226
  ]
39946
41227
  },
41228
+ "isValley": {
41229
+ "title": "isValley",
41230
+ "type": "function",
41231
+ "children": [
41232
+ {
41233
+ "title": "语法",
41234
+ "type": "grammer",
41235
+ "children": [
41236
+ {
41237
+ "type": "text",
41238
+ "value": [
41239
+ "isValley(X, [strict=true])"
41240
+ ]
41241
+ }
41242
+ ]
41243
+ },
41244
+ {
41245
+ "title": "参数",
41246
+ "type": "parameters",
41247
+ "children": [
41248
+ {
41249
+ "type": "text",
41250
+ "value": [
41251
+ "`X` 数值型向量/矩阵/表。",
41252
+ "",
41253
+ "`strict` 布尔值，表示是否取严格的谷值点。默认值为 true。"
41254
+ ]
41255
+ }
41256
+ ]
41257
+ },
41258
+ {
41259
+ "title": "详情",
41260
+ "type": "detail",
41261
+ "children": [
41262
+ {
41263
+ "type": "text",
41264
+ "value": [
41265
+ "若 *X* 为向量，计算 *X* 中的每个元素是否为谷值点，若是则返回 true，否则返回 false。",
41266
+ "",
41267
+ "判断规则为：",
41268
+ "",
41269
+ "* 若 *strict* = true，相邻元素不为空且严格大于该元素；",
41270
+ "* 若 *strict* = false，相邻元素不为空且大于等于该元素；",
41271
+ "",
41272
+ "若 *X* 为矩阵，在每列进行上述计算，返回值一个同 X 维度相同的矩阵。若 *X* 为表，则只对数值型的列进行上述计算。"
41273
+ ]
41274
+ }
41275
+ ]
41276
+ },
41277
+ {
41278
+ "title": "例子",
41279
+ "type": "example",
41280
+ "children": [
41281
+ {
41282
+ "type": "code",
41283
+ "language": "console",
41284
+ "value": [
41285
+ "",
41286
+ " $ v = [3.1, 2.2, 2.2, 2.2, 1.3, 2.1, 1.2]",
41287
+ " $ isValley(v)",
41288
+ " [0,0,0,0,1,0,0]",
41289
+ "",
41290
+ " $ v = [3.1, 2.2, 2.2, 2.2, 2.6, 1, 1.2]",
41291
+ " $ isValley(v)",
41292
+ " [0,0,0,0,0,1,0]",
41293
+ " $ isValley(v, false)",
41294
+ " [0,1,1,1,0,1,0]",
41295
+ "",
41296
+ " // 矩阵在每列单独计算",
41297
+ " $ m = matrix(5.3 5.8 5.6 NULL 5.7 1.2, 4.5 3.5 4.6 2.8 3.9 NULL)",
41298
+ " $ isValley(m)",
41299
+ ""
41300
+ ]
41301
+ },
41302
+ {
41303
+ "type": "text",
41304
+ "value": [
41305
+ "== ==",
41306
+ "#0 #1",
41307
+ "== ==",
41308
+ "0 0 ",
41309
+ "0 1 ",
41310
+ "0 0 ",
41311
+ "0 1 ",
41312
+ "0 0 ",
41313
+ "0 0 ",
41314
+ "== ==",
41315
+ ""
41316
+ ]
41317
+ },
41318
+ {
41319
+ "type": "code",
41320
+ "language": "console",
41321
+ "value": [
41322
+ "",
41323
+ " // 表只在数值列进行计算",
41324
+ " $ t = table(`01`01`00`01`02`00 as id, 2022.01.01 + 1..6 as date, 388.3 390.6 390.8 390.6 390.3 391.5 as price)",
41325
+ " $ isValley(t)",
41326
+ ""
41327
+ ]
41328
+ },
41329
+ {
41330
+ "type": "text",
41331
+ "value": [
41332
+ "== ========== =====",
41333
+ "id date price",
41334
+ "== ========== =====",
41335
+ "01 2022.01.02 0 ",
41336
+ "01 2022.01.03 0 ",
41337
+ "00 2022.01.04 0 ",
41338
+ "01 2022.01.05 0 ",
41339
+ "02 2022.01.06 1 ",
41340
+ "00 2022.01.07 0",
41341
+ "== ========== =====",
41342
+ "",
41343
+ "相关函数：:doc:`isPeak`"
41344
+ ]
41345
+ }
41346
+ ]
41347
+ }
41348
+ ]
41349
+ },
39947
41350
  "isVoid": {
39948
41351
  "title": "isVoid",
39949
41352
  "type": "function",
@@ -43429,7 +44832,7 @@
43429
44832
  {
43430
44833
  "type": "text",
43431
44834
  "value": [
43432
- "`dbUrl` 是一个字符串，表示本地磁盘数据库或分布式数据库的路径。"
44835
+ "`dbUrl` 是一个字符串，表示分布式数据库的路径。"
43433
44836
  ]
43434
44837
  }
43435
44838
  ]
@@ -43515,6 +44918,8 @@
43515
44918
  "",
43516
44919
  "`partition` 是字符串，表示分区在数据库内的路径，例如 \"/20190101/GOOG\"。",
43517
44920
  "",
44921
+ "请注意：若使用 1.30.16/2.00.4 ~ 1.30.18/2.00.6 版本 server，对表级分区数据进行备份和恢复时，该参数必须指定路径到物理索引（可通过函数 :doc:`/FunctionsandCommands/FunctionReferences/l/listTables` 获取），例如分区 \"/compoDB/20170807/0_50\" 下表的物理索引为8，则 partition 需指定为 \"/compoDB/20170807/0_50/8\"。",
44922
+ "",
43518
44923
  "`tableName` 是字符串，表示分布式表的名称。"
43519
44924
  ]
43520
44925
  }
@@ -43634,6 +45039,71 @@
43634
45039
  }
43635
45040
  ]
43636
45041
  },
45042
+ "loadIPCInMemoryTable": {
45043
+ "title": "loadIPCInMemoryTable",
45044
+ "type": "function",
45045
+ "children": [
45046
+ {
45047
+ "title": "语法",
45048
+ "type": "grammer",
45049
+ "children": [
45050
+ {
45051
+ "type": "text",
45052
+ "value": [
45053
+ "loadIPCInMemoryTable(tableName)"
45054
+ ]
45055
+ }
45056
+ ]
45057
+ },
45058
+ {
45059
+ "title": "参数",
45060
+ "type": "parameters",
45061
+ "children": [
45062
+ {
45063
+ "type": "text",
45064
+ "value": [
45065
+ "`tableName` 字符串，表示跨进程共享内存表的名称。"
45066
+ ]
45067
+ }
45068
+ ]
45069
+ },
45070
+ {
45071
+ "title": "详情",
45072
+ "type": "detail",
45073
+ "children": [
45074
+ {
45075
+ "type": "text",
45076
+ "value": [
45077
+ "加载跨进程共享内存表，并返回该表的句柄。"
45078
+ ]
45079
+ }
45080
+ ]
45081
+ },
45082
+ {
45083
+ "title": "例子",
45084
+ "type": "example",
45085
+ "children": [
45086
+ {
45087
+ "type": "text",
45088
+ "value": [
45089
+ "加载函数 ``createIPCInMemoryTable`` 例子中创建的表 ipc_table。",
45090
+ ""
45091
+ ]
45092
+ },
45093
+ {
45094
+ "type": "code",
45095
+ "language": "console",
45096
+ "value": [
45097
+ " ",
45098
+ " $ ipc_t = loadIPCInMemoryTable(\"ipc_table\")",
45099
+ " $ ipc_t",
45100
+ " timestamp temperature"
45101
+ ]
45102
+ }
45103
+ ]
45104
+ }
45105
+ ]
45106
+ },
43637
45107
  "loadModel": {
43638
45108
  "title": "loadModel",
43639
45109
  "type": "function",
@@ -46025,6 +47495,117 @@
46025
47495
  }
46026
47496
  ]
46027
47497
  },
47498
+ "lowRange": {
47499
+ "title": "lowRange",
47500
+ "type": "function",
47501
+ "children": [
47502
+ {
47503
+ "title": "语法",
47504
+ "type": "grammer",
47505
+ "children": [
47506
+ {
47507
+ "type": "text",
47508
+ "value": [
47509
+ "lowRange(X)"
47510
+ ]
47511
+ }
47512
+ ]
47513
+ },
47514
+ {
47515
+ "title": "参数",
47516
+ "type": "parameters",
47517
+ "children": [
47518
+ {
47519
+ "type": "text",
47520
+ "value": [
47521
+ "`X` 向量/元组/矩阵/表。"
47522
+ ]
47523
+ }
47524
+ ]
47525
+ },
47526
+ {
47527
+ "title": "详情",
47528
+ "type": "detail",
47529
+ "children": [
47530
+ {
47531
+ "type": "text",
47532
+ "value": [
47533
+ "对于 *X* 中的每个元素 *Xi*，统计 *Xi* 左侧相邻且连续小于它的元素个数。",
47534
+ "",
47535
+ "该函数常用于统计一个序列的当前值是前多少周期（日或分钟等）内的最小值。例如某只股票创几日新低等。"
47536
+ ]
47537
+ }
47538
+ ]
47539
+ },
47540
+ {
47541
+ "title": "例子",
47542
+ "type": "example",
47543
+ "children": [
47544
+ {
47545
+ "type": "code",
47546
+ "language": "console",
47547
+ "value": [
47548
+ "",
47549
+ " $ lowRange([13.5, 13.6, 13.4, 13.3, 13.5, 13.9, 13.1, 20.1, 20.2, 20.3])",
47550
+ " [0,0,2,3,0,0,6,0,0,0]",
47551
+ "",
47552
+ " $ m = matrix(1.5 2.6 3.2 1.4 2.5 2.2 3.7 2.0, 1.6 2.3 4.2 5.6 4.1 3.2 4.4 6.9)",
47553
+ " $ lowRange(m)",
47554
+ ""
47555
+ ]
47556
+ },
47557
+ {
47558
+ "type": "text",
47559
+ "value": [
47560
+ "== ==",
47561
+ "#0 #1",
47562
+ "== ==",
47563
+ "0 0 ",
47564
+ "0 0 ",
47565
+ "0 0 ",
47566
+ "3 0 ",
47567
+ "0 2 ",
47568
+ "1 3 ",
47569
+ "0 0 ",
47570
+ "3 0 ",
47571
+ "== ==",
47572
+ ""
47573
+ ]
47574
+ },
47575
+ {
47576
+ "type": "code",
47577
+ "language": "console",
47578
+ "value": [
47579
+ "",
47580
+ " //模拟股票 A 8天的股价,使用 topRange 计算股票 A 每日股价创几日新高",
47581
+ " $ trades = table(take(`A, 8) as sym, 2022.01.01 + 1..8 as date, 39.70 39.72 39.80 39.78 39.83 39.92 40.00 40.03 as price)",
47582
+ " $ select *, lowRange(price) from trades",
47583
+ ""
47584
+ ]
47585
+ },
47586
+ {
47587
+ "type": "text",
47588
+ "value": [
47589
+ "=== ========== ======== ===============",
47590
+ "id date price lowRange_price",
47591
+ "=== ========== ======== ===============",
47592
+ "A 2022.01.02 39.7 0",
47593
+ "A 2022.01.03 39.72 0",
47594
+ "A 2022.01.04 39.8 0",
47595
+ "A 2022.01.05 39.78 1",
47596
+ "A 2022.01.06 39.83 0",
47597
+ "A 2022.01.07 39.92 0",
47598
+ "A 2022.01.08 40 0",
47599
+ "A 2022.01.09 40.03 0",
47600
+ "=== ========== ======== ===============",
47601
+ "",
47602
+ "相关函数：:doc:`../t/topRange`"
47603
+ ]
47604
+ }
47605
+ ]
47606
+ }
47607
+ ]
47608
+ },
46028
47609
  "lower": {
46029
47610
  "title": "lower",
46030
47611
  "type": "function",
@@ -54252,6 +55833,89 @@
54252
55833
  }
54253
55834
  ]
54254
55835
  },
55836
+ "msum2": {
55837
+ "title": "msum2",
55838
+ "type": "function",
55839
+ "children": [
55840
+ {
55841
+ "title": "语法",
55842
+ "type": "grammer",
55843
+ "children": [
55844
+ {
55845
+ "type": "text",
55846
+ "value": [
55847
+ "msum2(X, window, [minPeriods])",
55848
+ "",
55849
+ "参数说明和窗口计算规则请参考: :doc:`/FunctionsandCommands/SeriesOfFunctions/mFunctions`"
55850
+ ]
55851
+ }
55852
+ ]
55853
+ },
55854
+ {
55855
+ "title": "详情",
55856
+ "type": "detail",
55857
+ "children": [
55858
+ {
55859
+ "type": "text",
55860
+ "value": [
55861
+ "在给定长度（以元素个数或时间长度衡量）的滑动窗口内计算 *X* 元素的平方和。请注意，该函数的返回值是 DOUBLE 类型。"
55862
+ ]
55863
+ }
55864
+ ]
55865
+ },
55866
+ {
55867
+ "title": "例子",
55868
+ "type": "example",
55869
+ "children": [
55870
+ {
55871
+ "type": "code",
55872
+ "language": "console",
55873
+ "value": [
55874
+ "",
55875
+ " $ X = 2 1 3 7 6 5 4",
55876
+ " $ Y = 2 1 3 NULL 6 5 4",
55877
+ "",
55878
+ " $ msum2(X, 3)",
55879
+ " [,,14,59,94,110,77]",
55880
+ "",
55881
+ " $ msum2(Y, 3)",
55882
+ " [,,14,10,45,61,77]",
55883
+ "",
55884
+ " $ msum2(Y, 3, minPeriods=1)",
55885
+ " [4,5,14,10,45,61,77]",
55886
+ "",
55887
+ " $ m = matrix(1 NULL 4 NULL 8 6 , 9 NULL NULL 10 NULL 2)",
55888
+ " $ m.rename!(date(2021.08.16)+1..6, `col1`col2)",
55889
+ " $ m.setIndexedMatrix!()",
55890
+ " $ msum2(m, 3d) // 等价于 msum2(m, 3)",
55891
+ ""
55892
+ ]
55893
+ },
55894
+ {
55895
+ "type": "text",
55896
+ "value": [
55897
+ "========== ===== =====",
55898
+ "label col1 col2",
55899
+ "========== ===== =====",
55900
+ "2021.08.17 1 81",
55901
+ "2021.08.18 1 81",
55902
+ "2021.08.19 17 81",
55903
+ "2021.08.20 16 100",
55904
+ "2021.08.21 80 100",
55905
+ "2021.08.22 100 104",
55906
+ "========== ===== =====",
55907
+ "",
55908
+ "",
55909
+ "相关函数：:doc:`../s/sum2`",
55910
+ "",
55911
+ ".. meta:: ",
55912
+ " :keywords: sum"
55913
+ ]
55914
+ }
55915
+ ]
55916
+ }
55917
+ ]
55918
+ },
54255
55919
  "msumTopN": {
54256
55920
  "title": "msumTopN",
54257
55921
  "type": "function",
@@ -56563,6 +58227,101 @@
56563
58227
  }
56564
58228
  ]
56565
58229
  },
58230
+ "nextState": {
58231
+ "title": "nextState",
58232
+ "type": "function",
58233
+ "children": [
58234
+ {
58235
+ "title": "语法",
58236
+ "type": "grammer",
58237
+ "children": [
58238
+ {
58239
+ "type": "text",
58240
+ "value": [
58241
+ "nextState(X)"
58242
+ ]
58243
+ }
58244
+ ]
58245
+ },
58246
+ {
58247
+ "title": "参数",
58248
+ "type": "parameters",
58249
+ "children": [
58250
+ {
58251
+ "type": "text",
58252
+ "value": [
58253
+ "`X` 时间类型，布尔类型或者数值型的向量/矩阵。"
58254
+ ]
58255
+ }
58256
+ ]
58257
+ },
58258
+ {
58259
+ "title": "详情",
58260
+ "type": "detail",
58261
+ "children": [
58262
+ {
58263
+ "type": "text",
58264
+ "value": [
58265
+ "*X* 中连续且值相同的元素具有相同的状态，该函数返回与当前元素状态不同的后一个临近元素值。",
58266
+ "",
58267
+ "*X* 是向量时：",
58268
+ "",
58269
+ "* 若当前元素为空值，返回后项最邻近的一个非空值。",
58270
+ "* 若当前元素为非空值，寻找后项最邻近且状态不同的元素 N：",
58271
+ " ",
58272
+ " * 若 N 为非空值，则返回 N。",
58273
+ " * 若 N 为空值，则返回 N 之后最邻近的一个非空值。",
58274
+ " ",
58275
+ "* 若找不到符合上述条件的值，则返回空值。",
58276
+ "",
58277
+ "*X* 是矩阵时，则在矩阵每一列进行上述计算。"
58278
+ ]
58279
+ }
58280
+ ]
58281
+ },
58282
+ {
58283
+ "title": "例子",
58284
+ "type": "example",
58285
+ "children": [
58286
+ {
58287
+ "type": "code",
58288
+ "language": "console",
58289
+ "value": [
58290
+ "",
58291
+ " $ X = [1, 2.2, NULL, 2.2, 2.3, 1, 1.2]",
58292
+ " $ next(X)",
58293
+ " [2.2,,2.2,2.3,1,1.2,]",
58294
+ " ",
58295
+ " $ nextState(X)",
58296
+ " [2.2,2.2,2.2,2.3,1,1.2,]",
58297
+ "",
58298
+ " $ X = matrix([1.0, 1.1, 1.0, 0.9], [NULL, 1.3, 2.5, 5.5], [5.5, 4.2, 1.6, 1.8])",
58299
+ " $ nextState(X)",
58300
+ ""
58301
+ ]
58302
+ },
58303
+ {
58304
+ "type": "text",
58305
+ "value": [
58306
+ "+---+---+---+",
58307
+ "|#0 |#1 |#2 |",
58308
+ "+===+===+===+",
58309
+ "|1.1|1.3|4.2|",
58310
+ "+---+---+---+",
58311
+ "|1 |2.5|1.6| ",
58312
+ "+---+---+---+ ",
58313
+ "|0.9|5.5|1.8|",
58314
+ "+---+---+---+",
58315
+ "| | | |",
58316
+ "+---+---+---+",
58317
+ "",
58318
+ "相关函数： :doc:`../p/prevState`"
58319
+ ]
58320
+ }
58321
+ ]
58322
+ }
58323
+ ]
58324
+ },
56566
58325
  "norm": {
56567
58326
  "title": "norm",
56568
58327
  "type": "function",
@@ -57418,7 +59177,10 @@
57418
59177
  {
57419
59178
  "type": "text",
57420
59179
  "value": [
57421
- "`shared` 是一个布尔值变量。当它为false时，函数返回内存中变量的表；当它为true时，函数还会返回在其他会话共享的表。默认值为false。"
59180
+ "`shared` 布尔值，默认为 false。",
59181
+ "",
59182
+ "* false：返回当前会话中所有变量的信息；",
59183
+ "* true：返回当前会话中所有变量的信息以及所有会话共享的变量信息；"
57422
59184
  ]
57423
59185
  }
57424
59186
  ]
@@ -57430,7 +59192,26 @@
57430
59192
  {
57431
59193
  "type": "text",
57432
59194
  "value": [
57433
- "返回内存中的变量的表。注意该函数不返回函数定义。我们应该用 :doc:`../d/defs` 检查函数定义。"
59195
+ "用于获取内存中缓存的各变量的内存占用情况等信息。返回一个表，它具有以下几列：",
59196
+ "",
59197
+ "* name: 变量名。",
59198
+ "* type: 变量的数据类型。",
59199
+ "* form: 变量的数据形式。",
59200
+ "* rows:",
59201
+ "",
59202
+ " * 若 form 为向量/字典/集合，则返回所有元素（包含NULL）的个数",
59203
+ " * 若 form 为矩阵/表，则返回它们的行数",
59204
+ "",
59205
+ "* columns:",
59206
+ "",
59207
+ " * 若 form 为向量/字典/集合，则返回 1",
59208
+ " * 若 form 为矩阵/表，则返回它们的列数",
59209
+ "",
59210
+ "* bytes: 变量占用的内存大小，单位为字节",
59211
+ "* shared: 是否为共享变量",
59212
+ "* extra: 分布式表的逻辑路径，格式为 \"dfs://dbName/tableName\"",
59213
+ "",
59214
+ "注意，该函数不返回函数定义。我们应该用 defs 检查函数定义，或通过 :doc:`../m/memSize` 查看函数定义的内存占用。"
57434
59215
  ]
57435
59216
  }
57436
59217
  ]
@@ -57444,19 +59225,39 @@
57444
59225
  "language": "console",
57445
59226
  "value": [
57446
59227
  "",
57447
- " $ objs();",
57448
- ""
57449
- ]
57450
- },
57451
- {
57452
- "type": "text",
57453
- "value": [
57454
- "===== ====== ====== ===== ======== ====== ======= ======= ",
57455
- "name type form rows columns bytes shared extra",
57456
- "===== ====== ====== ===== ======== ====== ======= ======= ",
57457
- "t BASIC TABLE 10 4 618 0",
57458
- "===== ====== ====== ===== ======== ====== ======= ======= ",
59228
+ " //创建分布式数据库",
59229
+ " $ if(existsDatabase(\"dfs://listdb\")){",
59230
+ " $ dropDatabase(\"dfs://listdb\")",
59231
+ " $ }",
59232
+ " $ n=1000000",
59233
+ " $ ticker = rand(`MSFT`GOOG`FB`ORCL`IBM,n);",
59234
+ " $ ticker[0..5]",
59235
+ " $ x=rand(1.0, n)",
59236
+ " $ t=table(ticker, x)",
59237
+ " $ db=database(directory=\"dfs://listdb\", partitionType=HASH, partitionScheme=[STRING, 5])",
59238
+ " $ pt=db.createPartitionedTable(t, `pt, `ticker)",
59239
+ " $ pt.append!(t)",
59240
+ "",
59241
+ " // 共享内存表",
59242
+ " $ time = take(2021.08.20 00:00:00..2021.08.30 00:00:00, 40);",
59243
+ " $ id = 0..39;",
59244
+ " $ value = rand(100, 40);",
59245
+ " $ tmp = table(time, id, value);",
59246
+ " $ share tmp as st",
59247
+ "",
59248
+ " // 创建 set",
59249
+ " $ s = set([1,2,3,4,5])",
59250
+ "",
59251
+ " // 创建 dict",
59252
+ " $ x=1 2 3",
59253
+ " $ y=4.5 7.8 4.3",
59254
+ " $ z=dict(x,y);",
59255
+ "",
59256
+ " // 创建 matrix",
59257
+ " $ m = matrix(1 2 3, 4 5 6)",
57459
59258
  "",
59259
+ " // 创建 pair",
59260
+ " $ p = 1:2",
57460
59261
  ""
57461
59262
  ]
57462
59263
  },
@@ -57465,21 +59266,33 @@
57465
59266
  "language": "console",
57466
59267
  "value": [
57467
59268
  "",
57468
- " $ share t as st;",
57469
- " $ objs(true);",
59269
+ " $ objs(true)",
57470
59270
  ""
57471
59271
  ]
57472
59272
  },
57473
59273
  {
57474
59274
  "type": "text",
57475
59275
  "value": [
57476
- "+------+----------+------+------+----------+------+------+----------+",
57477
- "| name | type | form | rows |columns |bytes |shared|extra |",
57478
- "+======+==========+======+======+==========+======+======+==========+",
57479
- "| t | BASIC | TABLE|10 | 4 | 618 | 0 | |",
57480
- "+------+----------+------+------+----------+------+------+----------+",
57481
- "| st | BASIC | TABLE|10 | 4 | 618 | 1 | |",
57482
- "+------+----------+------+------+----------+------+------+----------+"
59276
+ "======= ======== ============ ========== ======= ========== ======= =================",
59277
+ "name type form rows columns bytes shared extra",
59278
+ "======= ======== ============ ========== ======= ========== ======= =================",
59279
+ "n INT SCALAR 1 1 16 false ",
59280
+ "ticker SYMBOL VECTOR 1,000,000 1 4,000,000 false ",
59281
+ "x INT VECTOR 3 1 12 false ",
59282
+ "t BASIC TABLE 1,000,000 2 12,000,312 false ",
59283
+ "db HANDLE SCALAR 1 1 24 false ",
59284
+ "pt ALIAS TABLE 0 2 12,000,000 false dfs://listdb/pt",
59285
+ "time DATETIME VECTOR 40 1 160 false ",
59286
+ "id INT VECTOR 40 1 160 false ",
59287
+ "value INT VECTOR 40 1 160 false ",
59288
+ "tmp BASIC TABLE 40 3 832 false ",
59289
+ "s INT SET 5 1 28 false ",
59290
+ "y DOUBLE VECTOR 3 1 24 false ",
59291
+ "z DOUBLE DICTIONARY 3 1 199 false ",
59292
+ "m INT MATRIX 3 2 24 false ",
59293
+ "p INT PAIR 2 1 8 false ",
59294
+ "st BASIC TABLE 40 3 832 true",
59295
+ "======= ======== ============ ========== ======= ========== ======= ================="
57483
59296
  ]
57484
59297
  }
57485
59298
  ]
@@ -60177,6 +61990,102 @@
60177
61990
  }
60178
61991
  ]
60179
61992
  },
61993
+ "prevState": {
61994
+ "title": "prevState",
61995
+ "type": "function",
61996
+ "children": [
61997
+ {
61998
+ "title": "语法",
61999
+ "type": "grammer",
62000
+ "children": [
62001
+ {
62002
+ "type": "text",
62003
+ "value": [
62004
+ "prevState(X)"
62005
+ ]
62006
+ }
62007
+ ]
62008
+ },
62009
+ {
62010
+ "title": "参数",
62011
+ "type": "parameters",
62012
+ "children": [
62013
+ {
62014
+ "type": "text",
62015
+ "value": [
62016
+ "`X` 时间类型，布尔类型或者数值型的向量/矩阵。"
62017
+ ]
62018
+ }
62019
+ ]
62020
+ },
62021
+ {
62022
+ "title": "详情",
62023
+ "type": "detail",
62024
+ "children": [
62025
+ {
62026
+ "type": "text",
62027
+ "value": [
62028
+ "*X* 中连续且值相同的元素具有相同的状态，该函数返回与当前元素状态不同的前一个临近元素值。",
62029
+ "",
62030
+ "*X* 是向量时：",
62031
+ "",
62032
+ "* 若当前元素为空值，返回前项最邻近的一个非空值。",
62033
+ "* 若当前元素为非空值，寻找前项最邻近且状态不同的元素 P：",
62034
+ " ",
62035
+ " * 若 P 为非空值，则返回 P。",
62036
+ " * 若 P 为空值，则返回 P 之前最邻近的一个非空值。",
62037
+ " ",
62038
+ "* 若找不到符合上述条件的值，则返回空值。",
62039
+ "",
62040
+ "*X* 是矩阵时，则在矩阵每一列进行上述计算。"
62041
+ ]
62042
+ }
62043
+ ]
62044
+ },
62045
+ {
62046
+ "title": "例子",
62047
+ "type": "example",
62048
+ "children": [
62049
+ {
62050
+ "type": "code",
62051
+ "language": "console",
62052
+ "value": [
62053
+ "",
62054
+ " $ X = [1, 2.2, NULL, 2.2, 2.3, 1, 1.2]",
62055
+ " $ prev(X)",
62056
+ " [,1,2.2,,2.2,2.3,1]",
62057
+ " ",
62058
+ " $ prevState(X)",
62059
+ " [,1,2.2,2.2,2.2,2.3,1]",
62060
+ "",
62061
+ " $ X = matrix([1.0, 1.1, 1.0, 0.9], [NULL, 1.3, 2.5, 5.5], [5.5, 4.2, 1.6, 1.8])",
62062
+ " $ prevState(X)",
62063
+ ""
62064
+ ]
62065
+ },
62066
+ {
62067
+ "type": "text",
62068
+ "value": [
62069
+ "+---+---+---+",
62070
+ "|#0 |#1 |#2 |",
62071
+ "+===+===+===+",
62072
+ "| | | |",
62073
+ "+---+---+---+",
62074
+ "|1 | |5.5|",
62075
+ "+---+---+---+",
62076
+ "|1.1|1.3|4.2|",
62077
+ "+---+---+---+",
62078
+ "|1 |2.5|1.6|",
62079
+ "+---+---+---+ ",
62080
+ "",
62081
+ "",
62082
+ "相关函数： :doc:`../n/nextState`"
62083
+ ]
62084
+ }
62085
+ ]
62086
+ }
62087
+ ]
62088
+ },
60180
62089
  "print": {
60181
62090
  "title": "print",
60182
62091
  "type": "command",
@@ -62867,7 +64776,8 @@
62867
64776
  ]
62868
64777
  },
62869
64778
  {
62870
- "title": " 参数 ",
64779
+ "title": "参数",
64780
+ "type": "parameters",
62871
64781
  "children": [
62872
64782
  {
62873
64783
  "type": "text",
@@ -62900,6 +64810,7 @@
62900
64810
  "* 如果指定了 *groupNum*，则将排序后的 *X* 分成 *groupNum* 个组。返回 *X* 中每个元素对应的组编号（从0开始编号）。",
62901
64811
  "",
62902
64812
  " 请注意：",
64813
+ " ",
62903
64814
  " * 若 *X* 不能被均分，多余元素优先存入编号较小的组内。",
62904
64815
  " * 若 *X* 中相同元素分别属于不同的组，则所有相同元素返回最小的组号。",
62905
64816
  "* 如果 *ignoreNA* = true，则 NULL 值不参与排序，结果中 NULL 值的排名为空。",
@@ -66180,50 +68091,59 @@
66180
68091
  "",
66181
68092
  "",
66182
68093
  "例3. 异构回放",
68094
+ ""
68095
+ ]
68096
+ },
68097
+ {
68098
+ "type": "code",
68099
+ "language": "console",
68100
+ "value": [
68101
+ ""
68102
+ ]
68103
+ },
68104
+ {
68105
+ "type": "text",
68106
+ "value": [
68107
+ " $ n=1000",
68108
+ " $ sym = take(take(`IBM,n).join(take(`GS,n)), n)",
68109
+ " $ myDate=take(2021.01.02..2021.01.06, n).sort!()",
68110
+ " $ myTime=take(09:30:00..15:59:59,n)",
68111
+ " $ vol = rand(100, n)",
68112
+ " $ t=table(sym,myDate,myTime,vol)",
66183
68113
  "",
66184
- ".. code-block:: console",
66185
- " :emphasize-lines: 40",
66186
- "",
66187
- " $ n=1000",
66188
- " $ sym = take(take(`IBM,n).join(take(`GS,n)), n)",
66189
- " $ myDate=take(2021.01.02..2021.01.06, n).sort!()",
66190
- " $ myTime=take(09:30:00..15:59:59,n)",
66191
- " $ vol = rand(100, n)",
66192
- " $ t=table(sym,myDate,myTime,vol)",
66193
- "",
66194
- "",
66195
- " $ n=1000",
66196
- " $ sym = take(take(`IBM,n).join(take(`GS,n)), n)",
66197
- " $ date=take(2021.01.02..2021.01.06, n).sort!()",
66198
- " $ time=take(09:30:00..15:59:59,n)",
66199
- " $ vol = rand(100, n)",
66200
- " $ t1=table(sym, date,time,vol)",
66201
68114
  "",
66202
- " $ if(existsDatabase(\"dfs://test_stock\")){",
66203
- " dropDatabase(\"dfs://test_stock\")",
66204
- " }",
66205
- " $ db1=database(\"\",RANGE, 2021.01.01..2021.01.12)",
66206
- " $ db2=database(\"\",VALUE,`IBM`GS)",
66207
- " $ db=database(\"dfs://test_stock\",COMPO,[db1, db2])",
66208
- " $ trades=db.createPartitionedTable(t,`trades,`myDate`sym)",
66209
- " $ trades.append!(t);",
66210
- " $ trades1=db.createPartitionedTable(t1,`trades1,`date`sym)",
66211
- " $ trades1.append!(t1);",
68115
+ " $ n=1000",
68116
+ " $ sym = take(take(`IBM,n).join(take(`GS,n)), n)",
68117
+ " $ date=take(2021.01.02..2021.01.06, n).sort!()",
68118
+ " $ time=take(09:30:00..15:59:59,n)",
68119
+ " $ vol = rand(100, n)",
68120
+ " $ t1=table(sym, date,time,vol)",
68121
+ "",
68122
+ " $ if(existsDatabase(\"dfs://test_stock\")){",
68123
+ " $ dropDatabase(\"dfs://test_stock\")",
68124
+ " $ }",
68125
+ " $ db1=database(\"\",RANGE, 2021.01.01..2021.01.12)",
68126
+ " $ db2=database(\"\",VALUE,`IBM`GS)",
68127
+ " $ db=database(\"dfs://test_stock\",COMPO,[db1, db2])",
68128
+ " $ trades=db.createPartitionedTable(t,`trades,`myDate`sym)",
68129
+ " $ trades.append!(t);",
68130
+ " $ trades1=db.createPartitionedTable(t1,`trades1,`date`sym)",
68131
+ " $ trades1.append!(t1);",
66212
68132
  "",
66213
- " //获取数据源",
68133
+ " //获取数据源",
66214
68134
  "",
66215
- " $ ds = replayDS(sqlObj=<select * from loadTable(db, `trades)>, dateColumn=`myDate, timeColumn=`myTime)",
66216
- " $ ds.size();",
68135
+ " $ ds = replayDS(sqlObj=<select * from loadTable(db, `trades)>, dateColumn=`myDate, timeColumn=`myTime)",
68136
+ " $ ds.size();",
66217
68137
  "",
66218
- " $ ds1 = replayDS(sqlObj=<select * from loadTable(db, `trades1)>, dateColumn=`date, timeColumn=`time)",
66219
- " $ ds1.size();",
68138
+ " $ ds1 = replayDS(sqlObj=<select * from loadTable(db, `trades1)>, dateColumn=`date, timeColumn=`time)",
68139
+ " $ ds1.size();",
66220
68140
  "",
66221
- " $ input_dict = dict([\"msg1\", \"msg2\"], [ds, ds1])",
66222
- " $ date_dict = dict([\"msg1\", \"msg2\"], [`myDate, `date])",
66223
- " $ time_dict = dict([\"msg1\", \"msg2\"], [`myTime, `time])",
66224
- " $ opt = streamTable(100:0,`timestamp`sym`blob`vol, [DATETIME,SYMBOL, BLOB, INT])",
66225
- " $ replay(inputTables=input_dict, outputTables=opt, dateColumn = date_dict, timeColumn=time_dict, replayRate=1000, absoluteRate=false);",
66226
- " $ select top 10 * from opt;"
68141
+ " $ input_dict = dict([\"msg1\", \"msg2\"], [ds, ds1])",
68142
+ " $ date_dict = dict([\"msg1\", \"msg2\"], [`myDate, `date])",
68143
+ " $ time_dict = dict([\"msg1\", \"msg2\"], [`myTime, `time])",
68144
+ " $ opt = streamTable(100:0,`timestamp`sym`blob`vol, [DATETIME,SYMBOL, BLOB, INT])",
68145
+ " $ replay(inputTables=input_dict, outputTables=opt, dateColumn = date_dict, timeColumn=time_dict, replayRate=1000, absoluteRate=false);",
68146
+ " $ select top 10 * from opt;"
66227
68147
  ]
66228
68148
  }
66229
68149
  ]
@@ -66466,11 +68386,13 @@
66466
68386
  "\"Q\" quarterEnd",
66467
68387
  "\"QS\" quarterBegin",
66468
68388
  "\"BQ\" businessQuarterEnd",
66469
- "\"BQS\" businessQuarterBegin",
68389
+ "\"BQS\" businessQuarterBegin ",
68390
+ "\"REQ\" FY5253Quarter",
66470
68391
  "\"A\" yearEnd",
66471
68392
  "\"AS\" yearBegin",
66472
68393
  "\"BA\" businessYearEnd",
66473
68394
  "\"BAS\" businessYearBegin",
68395
+ "\"RE\" FY5253 ",
66474
68396
  "\"D\" date",
66475
68397
  "\"H\" hourOfDay",
66476
68398
  "\"U\" microsecond",
@@ -66790,7 +68712,14 @@
66790
68712
  "language": "console",
66791
68713
  "value": [
66792
68714
  "",
66793
- " $ resetRecoveryWorkerNum(2)"
68715
+ " $ resetRecoveryWorkerNum(2)",
68716
+ ""
68717
+ ]
68718
+ },
68719
+ {
68720
+ "type": "text",
68721
+ "value": [
68722
+ "相关函数：:doc:`/FunctionsandCommands/FunctionReferences/g/getRecoveryWorkerNum`"
66794
68723
  ]
66795
68724
  }
66796
68725
  ]
@@ -67045,6 +68974,9 @@
67045
68974
  "`partition` 是字符串，表示要恢复的分区的相对路径。分区路径可以包含通配符(\"%\"和\"?\"), \"?\"表示单个字符，\"%\"表示0，1或多个字符。",
67046
68975
  "",
67047
68976
  "* 若仅备份某个分区，输入分区的相对路径或者\"%/\"+”分区名称”。举例：要恢复\"dfs://compoDB\"下的分区”20170810/50_100”,输入\"/compoDB/20170807/0_50\"或者\"%/20170807/0_50\"。",
68977
+ " ",
68978
+ " 请注意：若使用 1.30.16/2.00.4 ~ 1.30.18/2.00.6 版本 server，对表级分区数据进行备份和恢复时，该参数必须指定路径到物理索引（可通过函数 :doc:`/FunctionsandCommands/FunctionReferences/l/listTables` 获取），例如分区 \"/compoDB/20170807/0_50\" 下表的物理索引为8，则 partition 需指定为 \"/compoDB/20170807/0_50/8\"。",
68979
+ " ",
67048
68980
  "* 若需要备份所有分区，直接输入\"%\"。",
67049
68981
  "",
67050
68982
  "`force` 是布尔值，表示是否强制恢复。默认值为false，表示只有元数据与备份数据元数据不一致的分区，才会恢复。",
@@ -67186,6 +69118,86 @@
67186
69118
  }
67187
69119
  ]
67188
69120
  },
69121
+ "restoreDislocatedTablet": {
69122
+ "title": "restoreDislocatedTablet",
69123
+ "type": "function",
69124
+ "children": [
69125
+ {
69126
+ "title": "语法",
69127
+ "type": "grammer",
69128
+ "children": [
69129
+ {
69130
+ "type": "text",
69131
+ "value": [
69132
+ "restoreDislocatedTablet()"
69133
+ ]
69134
+ }
69135
+ ]
69136
+ },
69137
+ {
69138
+ "title": "参数",
69139
+ "type": "parameters",
69140
+ "children": [
69141
+ {
69142
+ "type": "text",
69143
+ "value": [
69144
+ "无"
69145
+ ]
69146
+ }
69147
+ ]
69148
+ },
69149
+ {
69150
+ "title": "详情",
69151
+ "type": "detail",
69152
+ "children": [
69153
+ {
69154
+ "type": "text",
69155
+ "value": [
69156
+ "当配置分区粒度为表级分区时（详见 :doc:`/DatabaseandDistributedComputing/Configuration/StandaloneMode` *enableChunkGranularityConfig* 参数），同一个分区的所有表将分布在相同的节点下。当调用函数 :doc:`/FunctionsandCommands/FunctionReferences/r/rebalanceChunksAmongDataNodes` 进行数据平衡时，若出现节点宕机或离线，可能出现同一个分区里部分表的数据转移成功，部分表的数据转移失败的情况，即同一个分区下的不同表会分布在不同的节点。该函数可以修复此问题，将同一个分区里的表转移到同一个节点下。",
69157
+ "",
69158
+ "返回一个表，包含以下列：",
69159
+ "",
69160
+ "================== =================================================",
69161
+ "列名 含义",
69162
+ "================== =================================================",
69163
+ "chunkId chunk 的唯一标识",
69164
+ "srcNode 源节点的别名",
69165
+ "destNode 目标节点的别名",
69166
+ "================== =================================================",
69167
+ "",
69168
+ "调用该函数后，可以在进行数据平衡的数据节点上执行 :doc:`/FunctionsandCommands/FunctionReferences/g/getRecoveryTaskStatus` 查看任务执行的状态。"
69169
+ ]
69170
+ }
69171
+ ]
69172
+ },
69173
+ {
69174
+ "title": "例子",
69175
+ "type": "example",
69176
+ "children": [
69177
+ {
69178
+ "type": "code",
69179
+ "language": "console",
69180
+ "value": [
69181
+ "",
69182
+ " $ restoreDislocatedTablet()",
69183
+ ""
69184
+ ]
69185
+ },
69186
+ {
69187
+ "type": "text",
69188
+ "value": [
69189
+ "==================================== ======= ========",
69190
+ "ChunkId srcNode destNode",
69191
+ "==================================== ======= ========",
69192
+ "99279094-ca12-3b87-48b6-520cbb986f39 node1 node2",
69193
+ "45f612b8-42f5-aebd-4cef-e522b6ae1fc8 node1 node2\t",
69194
+ "==================================== ======= ========"
69195
+ ]
69196
+ }
69197
+ ]
69198
+ }
69199
+ ]
69200
+ },
67189
69201
  "resumeRecovery": {
67190
69202
  "title": "resumeRecovery",
67191
69203
  "type": "command",
@@ -68293,6 +70305,80 @@
68293
70305
  }
68294
70306
  ]
68295
70307
  },
70308
+ "rowAt": {
70309
+ "title": "rowAt",
70310
+ "type": "function",
70311
+ "children": [
70312
+ {
70313
+ "title": "语法",
70314
+ "type": "grammer",
70315
+ "children": [
70316
+ {
70317
+ "type": "text",
70318
+ "value": [
70319
+ "rowAt(X, Y)",
70320
+ "",
70321
+ "row 系列函数通用参数说明和计算规则请参考: :doc:`/FunctionsandCommands/SeriesOfFunctions/rowFunctions`"
70322
+ ]
70323
+ }
70324
+ ]
70325
+ },
70326
+ {
70327
+ "title": "详情",
70328
+ "type": "detail",
70329
+ "children": [
70330
+ {
70331
+ "type": "text",
70332
+ "value": [
70333
+ "以 *Y* 的元素为 *X* 每行的列索引，逐行取出 *X* 中对应索引的元素，返回一个长度与输入参数行数相同的向量。"
70334
+ ]
70335
+ }
70336
+ ]
70337
+ },
70338
+ {
70339
+ "title": "例子",
70340
+ "type": "example",
70341
+ "children": [
70342
+ {
70343
+ "type": "code",
70344
+ "language": "console",
70345
+ "value": [
70346
+ "",
70347
+ " $ m = matrix(3.1 4.5 2.2, 4.2 4.3 5.1, 6.2 7.1 2.2, 1.8 6.1 5.3, 7.1 8.4 3.5)",
70348
+ " $ index = 4 0 2",
70349
+ " $ rowAt(m, index)",
70350
+ " [7.1,4.5,2.2]",
70351
+ "",
70352
+ " $ 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])",
70353
+ " $ 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)",
70354
+ " $ 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)",
70355
+ " $ 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)",
70356
+ " $ 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)",
70357
+ " $ 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)",
70358
+ " $ 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",
70359
+ ""
70360
+ ]
70361
+ },
70362
+ {
70363
+ "type": "text",
70364
+ "value": [
70365
+ "====== =======",
70366
+ "price1\tprice2",
70367
+ "====== =======",
70368
+ "33.8\t33.3",
70369
+ "34.3\t32.8",
70370
+ "35.3\t31.2",
70371
+ "34.1\t30.2",
70372
+ "33.8\t33.1",
70373
+ "====== =======",
70374
+ "",
70375
+ "相关函数: :doc:`../a/at`"
70376
+ ]
70377
+ }
70378
+ ]
70379
+ }
70380
+ ]
70381
+ },
68296
70382
  "rowAvg": {
68297
70383
  "title": "rowAvg",
68298
70384
  "type": "function",
@@ -68797,6 +70883,171 @@
68797
70883
  }
68798
70884
  ]
68799
70885
  },
70886
+ "rowImax": {
70887
+ "title": "rowImax",
70888
+ "type": "function",
70889
+ "children": [
70890
+ {
70891
+ "title": "语法",
70892
+ "type": "grammer",
70893
+ "children": [
70894
+ {
70895
+ "type": "text",
70896
+ "value": [
70897
+ "rowImax(args...)",
70898
+ "",
70899
+ "row 系列函数通用参数说明和计算规则请参考: :doc:`/FunctionsandCommands/SeriesOfFunctions/rowFunctions`",
70900
+ ""
70901
+ ]
70902
+ }
70903
+ ]
70904
+ },
70905
+ {
70906
+ "title": "详情",
70907
+ "type": "detail",
70908
+ "children": [
70909
+ {
70910
+ "type": "text",
70911
+ "value": [
70912
+ "返回每行元素中最大元素的索引。如果有多个相同的最大值，返回左起第一个最大值的索引。结果为一个长度与输入参数行数相同的向量。",
70913
+ ""
70914
+ ]
70915
+ }
70916
+ ]
70917
+ },
70918
+ {
70919
+ "title": "例子",
70920
+ "type": "example",
70921
+ "children": [
70922
+ {
70923
+ "type": "code",
70924
+ "language": "console",
70925
+ "value": [
70926
+ "",
70927
+ " $ m=matrix([4.5 2.6 1.5 3.2, 1.5 4.8 5.9 1.7, 4.9 2.0 NULL 5.5])",
70928
+ " $ print rowImax(m)",
70929
+ " [2,1,1,2]",
70930
+ "",
70931
+ " $ 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])",
70932
+ " $ 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)",
70933
+ " $ 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)",
70934
+ " $ 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)",
70935
+ " $ 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)",
70936
+ " $ 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)",
70937
+ " $ select rowAt(matrix(p1, p2, p3, p4, p5), rowImin(vol1, vol2, vol3, vol4, vol5)) as price from trades",
70938
+ ""
70939
+ ]
70940
+ },
70941
+ {
70942
+ "type": "text",
70943
+ "value": [
70944
+ "+-----+",
70945
+ "|price|",
70946
+ "+=====+",
70947
+ "|33.3 |",
70948
+ "+-----+",
70949
+ "|32.8 |",
70950
+ "+-----+",
70951
+ "|31.2 |",
70952
+ "+-----+",
70953
+ "|30.2 |",
70954
+ "+-----+",
70955
+ "|33.1 |",
70956
+ "+-----+",
70957
+ "",
70958
+ "相关函数：:doc:`../i/imax`",
70959
+ "",
70960
+ ".. meta:: ",
70961
+ " :keywords: row"
70962
+ ]
70963
+ }
70964
+ ]
70965
+ }
70966
+ ]
70967
+ },
70968
+ "rowImin": {
70969
+ "title": "rowImin",
70970
+ "type": "function",
70971
+ "children": [
70972
+ {
70973
+ "title": "语法",
70974
+ "type": "grammer",
70975
+ "children": [
70976
+ {
70977
+ "type": "text",
70978
+ "value": [
70979
+ "rowImin(args...)",
70980
+ "",
70981
+ "row 系列函数通用参数说明和计算规则请参考: :doc:`/FunctionsandCommands/SeriesOfFunctions/rowFunctions`",
70982
+ ""
70983
+ ]
70984
+ }
70985
+ ]
70986
+ },
70987
+ {
70988
+ "title": "详情",
70989
+ "type": "detail",
70990
+ "children": [
70991
+ {
70992
+ "type": "text",
70993
+ "value": [
70994
+ "返回每行元素中最小元素的索引。如果有多个相同的最小值，返回左起第一个最小值的索引。结果为一个长度与输入参数行数相同的向量。"
70995
+ ]
70996
+ }
70997
+ ]
70998
+ },
70999
+ {
71000
+ "title": "例子",
71001
+ "type": "example",
71002
+ "children": [
71003
+ {
71004
+ "type": "code",
71005
+ "language": "console",
71006
+ "value": [
71007
+ "",
71008
+ " $ m=matrix([4.5 2.6 1.5 3.2, 1.5 4.8 5.9 1.7, 4.9 2.0 NULL 5.5])",
71009
+ " $ rowImin(m)",
71010
+ " [1,2,0,1]",
71011
+ " ",
71012
+ " ",
71013
+ " $ 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])",
71014
+ " $ 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)",
71015
+ " $ 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)",
71016
+ " $ 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)",
71017
+ " $ 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)",
71018
+ " $ 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)",
71019
+ "",
71020
+ " $ select rowAt(matrix(p1, p2, p3, p4, p5), rowImin(vol1, vol2, vol3, vol4, vol5)) as price from trades",
71021
+ ""
71022
+ ]
71023
+ },
71024
+ {
71025
+ "type": "text",
71026
+ "value": [
71027
+ "+-----+",
71028
+ "|price|",
71029
+ "+=====+",
71030
+ "|33.8 |",
71031
+ "+-----+",
71032
+ "|34.3 |",
71033
+ "+-----+",
71034
+ "|35.3 |",
71035
+ "+-----+",
71036
+ "|34.1 |",
71037
+ "+-----+",
71038
+ "|33.8 |",
71039
+ "+-----+",
71040
+ "",
71041
+ "相关函数：:doc:`../i/imin`",
71042
+ "",
71043
+ ".. meta:: ",
71044
+ " :keywords: row"
71045
+ ]
71046
+ }
71047
+ ]
71048
+ }
71049
+ ]
71050
+ },
68800
71051
  "rowKurtosis": {
68801
71052
  "title": "rowKurtosis",
68802
71053
  "type": "function",
@@ -73782,6 +76033,48 @@
73782
76033
  }
73783
76034
  ]
73784
76035
  },
76036
+ "setLogLevel": {
76037
+ "title": "setLogLevel",
76038
+ "type": "command",
76039
+ "children": [
76040
+ {
76041
+ "title": "语法",
76042
+ "type": "grammer",
76043
+ "children": [
76044
+ {
76045
+ "type": "text",
76046
+ "value": [
76047
+ "setLogLevel(logLevel)"
76048
+ ]
76049
+ }
76050
+ ]
76051
+ },
76052
+ {
76053
+ "title": "参数",
76054
+ "type": "parameters",
76055
+ "children": [
76056
+ {
76057
+ "type": "text",
76058
+ "value": [
76059
+ "`logLevel` 日志等级，从低到高可选值为：DEBUG, INFO, WARNING, ERROR。"
76060
+ ]
76061
+ }
76062
+ ]
76063
+ },
76064
+ {
76065
+ "title": "详情",
76066
+ "type": "detail",
76067
+ "children": [
76068
+ {
76069
+ "type": "text",
76070
+ "value": [
76071
+ "在线设置当前节点的日志文件的等级。设置后，系统只打印当前 logLevel 及以上级别的日志。该命令只能由管理员调用。"
76072
+ ]
76073
+ }
76074
+ ]
76075
+ }
76076
+ ]
76077
+ },
73785
76078
  "setMaxBlockSizeForReservedMemory": {
73786
76079
  "title": "setMaxBlockSizeForReservedMemory",
73787
76080
  "type": "command",
@@ -74030,6 +76323,94 @@
74030
76323
  }
74031
76324
  ]
74032
76325
  },
76326
+ "setMemLimitOfQueryResult": {
76327
+ "title": "setMemLimitOfQueryResult",
76328
+ "type": "command",
76329
+ "children": [
76330
+ {
76331
+ "title": "语法",
76332
+ "type": "grammer",
76333
+ "children": [
76334
+ {
76335
+ "type": "text",
76336
+ "value": [
76337
+ "setMemLimitOfQueryResult(memLimit)"
76338
+ ]
76339
+ }
76340
+ ]
76341
+ },
76342
+ {
76343
+ "title": "参数",
76344
+ "type": "parameters",
76345
+ "children": [
76346
+ {
76347
+ "type": "text",
76348
+ "value": [
76349
+ "`memLimit` 数值类型标量，表示内存上限，单位为 GB。该值必须小于 80% * maxMemSize。"
76350
+ ]
76351
+ }
76352
+ ]
76353
+ },
76354
+ {
76355
+ "title": "详情",
76356
+ "type": "detail",
76357
+ "children": [
76358
+ {
76359
+ "type": "text",
76360
+ "value": [
76361
+ "在线修改单次查询结果占用的最大内存上限。该命令只能由管理员在数据节点/计算节点执行。",
76362
+ "",
76363
+ "相关函数： :doc:`/FunctionsandCommands/FunctionReferences/g/getMemLimitOfTaskGroupResult`"
76364
+ ]
76365
+ }
76366
+ ]
76367
+ }
76368
+ ]
76369
+ },
76370
+ "setMemLimitOfTaskGroupResult": {
76371
+ "title": "setMemLimitOfTaskGroupResult",
76372
+ "type": "command",
76373
+ "children": [
76374
+ {
76375
+ "title": "语法",
76376
+ "type": "grammer",
76377
+ "children": [
76378
+ {
76379
+ "type": "text",
76380
+ "value": [
76381
+ "setMemLimitOfTaskGroupResult(memLimit)"
76382
+ ]
76383
+ }
76384
+ ]
76385
+ },
76386
+ {
76387
+ "title": "参数",
76388
+ "type": "parameters",
76389
+ "children": [
76390
+ {
76391
+ "type": "text",
76392
+ "value": [
76393
+ "`memLimit` 数值类型标量，表示内存上限。单位为 GB。"
76394
+ ]
76395
+ }
76396
+ ]
76397
+ },
76398
+ {
76399
+ "title": "详情",
76400
+ "type": "detail",
76401
+ "children": [
76402
+ {
76403
+ "type": "text",
76404
+ "value": [
76405
+ "在线修改当前节点发送的批量子查询占用的内存上限。该命令只能由管理员在数据节点/计算节点执行。",
76406
+ "",
76407
+ "相关函数： :doc:`/FunctionsandCommands/FunctionReferences/g/getMemLimitOfQueryResult`"
76408
+ ]
76409
+ }
76410
+ ]
76411
+ }
76412
+ ]
76413
+ },
74033
76414
  "setRaftElectionTick": {
74034
76415
  "title": "setRaftElectionTick",
74035
76416
  "type": "command",
@@ -78869,7 +81250,7 @@
78869
81250
  "* 'condition'：表示过滤条件。",
78870
81251
  "",
78871
81252
  " * 若分发异构流表，则 'condition' 是一个字符串，且必须是 replay 参数 *inputTables* 的键值（表的标识）。用于过滤出异构表中具有 *condition* 标识的数据。",
78872
- " * 若分发普通流表，则 'condition' 是一个字符串标量或向量，且必须是 `conditionColumn` 指定列的元素。用于过滤出表 *conditionColumn* 列中满足 *condition* 的数据。",
81253
+ " * 若分发普通流表，则 'condition' 可以是一个表示列名的字符串标量或/向量，或者是包含一个或多个布尔表达式的元代码，且表达式中不能调用函数。请注意，若 'condition' 指定为字符串标量/向量，必须为 *conditionColumn* 指定列的元素。",
78873
81254
  "",
78874
81255
  "* 'handler'：一元函数或表对象（包括流数据引擎返回的表对象）。",
78875
81256
  "",
@@ -79019,11 +81400,11 @@
79019
81400
  "type": "text",
79020
81401
  "value": [
79021
81402
  " $ n=20",
79022
- " $ sym = symbol(rand(`A`B`C,n))",
81403
+ " $ sym = symbol(take(`A`B`C,n))",
79023
81404
  " $ name = string(rand(1..10,n))",
79024
81405
  " $ date = temporalAdd(2012.12.06,0..(n-1),'d')",
79025
81406
  " $ time = temporalAdd(09:30:00.000,0..(n-1),'ms')",
79026
- " $ vol = rand(100,n)",
81407
+ " $ vol = 100+take(1..8,20)",
79027
81408
  " $ t = table(date,time,sym,name,vol)",
79028
81409
  "",
79029
81410
  " //定义两个流数据引擎，作为分发引擎 handler",
@@ -79036,11 +81417,11 @@
79036
81417
  " $ share streamTable(100:0,`time`avg_vol,[TIME,INT]) as output2",
79037
81418
  " $ engine1=createTimeSeriesEngine(name=\"timeEngine\", windowSize=3, step=3, metrics=<[sum(vol)]>, dummyTable=st3, outputTable=output1, timeColumn=`time, useSystemTime=false, keyColumn=`sym, garbageSize=50)",
79038
81419
  " $ engine2=createReactiveStateEngine(name=\"reactiveEngine\", metrics=<[mavg(vol, 3)]>, dummyTable=st1, outputTable=output2, keyColumn=`sym)",
79039
- " ",
81420
+ "",
79040
81421
  " //需要注入分发引擎的流表",
79041
81422
  " $ share streamTable(100:0,`date`time`sym`name`vol,[DATE,TIME,SYMBOL,STRING,INT]) as trades",
79042
81423
  "",
79043
- " //设置第一个过滤条件，将 trades表 中 sy m列对应元素为 A 且时间在09:30:00.001:09:30:00.010和09:29:00.000:09:30:00.000的数据输入状态引擎进行处理",
81424
+ " //设置第一个过滤条件，将 trades 表中 sym 列对应元素为 A 且时间在09:30:00.001:09:30:00.010和09:29:00.000:09:30:00.000的数据输入状态引擎进行处理",
79044
81425
  " $ filter1 = dict(STRING,ANY)",
79045
81426
  " $ filter1['condition']=`A",
79046
81427
  " $ filter1['handler']=engine2",
@@ -79078,14 +81459,17 @@
79078
81459
  "============ ===== ========",
79079
81460
  "time sym sum_vol",
79080
81461
  "============ ===== ========",
79081
- "09:30:00.003 A 64",
79082
- "09:30:00.003 C 92",
79083
- "09:30:00.006 A 22",
79084
- "09:30:00.006 C 5",
79085
- "09:30:00.009 A 38",
79086
- "09:30:00.012 A 38",
79087
- "09:30:00.012 C 113",
79088
- "09:30:00.015 A 76",
81462
+ "09:30:00.003 A 101",
81463
+ "09:30:00.003 C 103",
81464
+ "09:30:00.006 A 104",
81465
+ "09:30:00.006 C 106",
81466
+ "09:30:00.009 A 107",
81467
+ "09:30:00.009 C 101",
81468
+ "09:30:00.012 A 102",
81469
+ "09:30:00.012 C 104",
81470
+ "09:30:00.015 A 105",
81471
+ "09:30:00.015 C 107",
81472
+ "09:30:00.018 A 108",
79089
81473
  "============ ===== ========",
79090
81474
  ""
79091
81475
  ]
@@ -79109,10 +81493,65 @@
79109
81493
  "+-------------+--------+",
79110
81494
  "|00:00:00.001 | |",
79111
81495
  "+-------------+--------+",
79112
- "|00:00:00.001 | 41 |",
81496
+ "|00:00:00.001 | 104 |",
81497
+ "+-------------+--------+",
81498
+ "|00:00:00.001 | 104 |",
79113
81499
  "+-------------+--------+",
79114
- "|00:00:00.001 | 33 |",
79115
- "+-------------+--------+"
81500
+ ""
81501
+ ]
81502
+ },
81503
+ {
81504
+ "type": "code",
81505
+ "language": "console",
81506
+ "value": [
81507
+ ""
81508
+ ]
81509
+ },
81510
+ {
81511
+ "type": "text",
81512
+ "value": [
81513
+ " $ select * from st2",
81514
+ "",
81515
+ "============ ============= === ==== ====",
81516
+ "date time sym name vol",
81517
+ "============ ============= === ==== ====",
81518
+ "2012.12.08 09:30:00.002 C 6 103",
81519
+ "2012.12.09 09:30:00.003 A 8 104",
81520
+ "2012.12.10 09:30:00.004 B 10 105",
81521
+ "2012.12.11 09:30:00.005 C 10 106",
81522
+ "2012.12.12 09:30:00.006 A 10 107",
81523
+ "2012.12.13 09:30:00.007 B 1 108",
81524
+ "2012.12.14 09:30:00.008 C 3 101",
81525
+ "2012.12.15 09:30:00.009 A 4 102",
81526
+ "2012.12.16 09:30:00.010 B 9 103",
81527
+ "============ ============= === ==== ====",
81528
+ "",
81529
+ "可以为 condition 指定表达式，以支持更复杂的过滤逻辑，将上例中 filter2 的 *condition* 指定为条件表达式，同时对 vol 和 date 列进行过滤。",
81530
+ ""
81531
+ ]
81532
+ },
81533
+ {
81534
+ "type": "code",
81535
+ "language": "console",
81536
+ "value": [
81537
+ ""
81538
+ ]
81539
+ },
81540
+ {
81541
+ "type": "text",
81542
+ "value": [
81543
+ " $ filter2 = dict(STRING,ANY)",
81544
+ " $ filter2['condition'] = <sym==`A and 101<vol<105 and date<2012.12.15>",
81545
+ " $ filter2['handler'] = st2",
81546
+ " $ filter2['timeRange'] = 09:30:00.002:09:30:00.010",
81547
+ " ",
81548
+ " $ select * from st2",
81549
+ "",
81550
+ "=========== ============ === ==== ====",
81551
+ "date time sym name\tvol",
81552
+ "=========== ============ === ==== ====",
81553
+ "2012.12.09 09:30:00.003 A 7 104",
81554
+ "=========== ============ === ==== ===="
79116
81555
  ]
79117
81556
  }
79118
81557
  ]
@@ -79198,6 +81637,88 @@
79198
81637
  }
79199
81638
  ]
79200
81639
  },
81640
+ "stretch": {
81641
+ "title": "stretch",
81642
+ "type": "function",
81643
+ "children": [
81644
+ {
81645
+ "title": "语法",
81646
+ "type": "grammer",
81647
+ "children": [
81648
+ {
81649
+ "type": "text",
81650
+ "value": [
81651
+ "stretch(X, n)"
81652
+ ]
81653
+ }
81654
+ ]
81655
+ },
81656
+ {
81657
+ "title": "参数",
81658
+ "type": "parameters",
81659
+ "children": [
81660
+ {
81661
+ "type": "text",
81662
+ "value": [
81663
+ "`X` 向量/元组。",
81664
+ "",
81665
+ "`n` 非负整数。"
81666
+ ]
81667
+ }
81668
+ ]
81669
+ },
81670
+ {
81671
+ "title": "详情",
81672
+ "type": "detail",
81673
+ "children": [
81674
+ {
81675
+ "type": "text",
81676
+ "value": [
81677
+ "将 *X* 均匀拉伸为长度为 n 的向量。",
81678
+ "",
81679
+ "该函数与 :doc:`../t/take` 的区别为：",
81680
+ "",
81681
+ "* take 是对向量整体进行循环拼接，而 stretch 则是对向量的每一个元素进行复制达到拉伸的效果。"
81682
+ ]
81683
+ }
81684
+ ]
81685
+ },
81686
+ {
81687
+ "title": "例子",
81688
+ "type": "example",
81689
+ "children": [
81690
+ {
81691
+ "type": "code",
81692
+ "language": "console",
81693
+ "value": [
81694
+ "",
81695
+ " $ X = 1 NULL 2 3",
81696
+ " $ print stretch(X, 11)",
81697
+ " [1,1,1,,,,2,2,3,3]",
81698
+ "",
81699
+ " $ print stretch(X, 11)",
81700
+ " [1,1,1,,,,2,2,2,3,3]",
81701
+ "",
81702
+ " $ print stretch(X, 12)",
81703
+ " [1,1,1,,,,2,2,2,3,3,3]",
81704
+ "",
81705
+ " $ print take(X, 10)",
81706
+ " [1,,2,3,1,,2,3,1,]",
81707
+ "",
81708
+ "",
81709
+ "",
81710
+ "",
81711
+ "",
81712
+ "",
81713
+ "",
81714
+ "",
81715
+ ""
81716
+ ]
81717
+ }
81718
+ ]
81719
+ }
81720
+ ]
81721
+ },
79201
81722
  "string": {
79202
81723
  "title": "string",
79203
81724
  "type": "function",
@@ -85972,6 +88493,68 @@
85972
88493
  }
85973
88494
  ]
85974
88495
  },
88496
+ "tmsum2": {
88497
+ "title": "tmsum2",
88498
+ "type": "function",
88499
+ "children": [
88500
+ {
88501
+ "title": "语法",
88502
+ "type": "grammer",
88503
+ "children": [
88504
+ {
88505
+ "type": "text",
88506
+ "value": [
88507
+ "tmsum2(T, X, window)",
88508
+ "",
88509
+ "参数说明和窗口计算规则请参考: :doc:`/FunctionsandCommands/SeriesOfFunctions/tmFunctions`"
88510
+ ]
88511
+ }
88512
+ ]
88513
+ },
88514
+ {
88515
+ "title": "详情",
88516
+ "type": "detail",
88517
+ "children": [
88518
+ {
88519
+ "type": "text",
88520
+ "value": [
88521
+ "在给定长度（以时间 *T* 衡量）的滑动窗口内计算 *X* 元素的平方和。请注意，该函数的返回值是 DOUBLE 类型。"
88522
+ ]
88523
+ }
88524
+ ]
88525
+ },
88526
+ {
88527
+ "title": "例子",
88528
+ "type": "example",
88529
+ "children": [
88530
+ {
88531
+ "type": "code",
88532
+ "language": "console",
88533
+ "value": [
88534
+ "",
88535
+ " $ tmsum2(1 1 3 5 8 15 15 20, 5 2 4 1 2 8 9 10, 3)",
88536
+ " [25,29,45,17,4,64,145,100]",
88537
+ "",
88538
+ " $ index = take(datehour(2019.06.13 13:30:10),4) join (datehour(2019.06.13 13:30:10)+1..6)",
88539
+ " $ data = 1 NULL 3 4 5 NULL 3 NULL 5 3",
88540
+ " $ tmsum2(index, data, 4h)",
88541
+ " [1,1,10,26,51,51,60,34,34,43]",
88542
+ "",
88543
+ " $ tmsum2(index, data, 1d)",
88544
+ " [1,1,10,26,51,51,60,60,85,94]",
88545
+ ""
88546
+ ]
88547
+ },
88548
+ {
88549
+ "type": "text",
88550
+ "value": [
88551
+ "相关函数：:doc:`../m/msum2`, :doc:`../s/sum2`"
88552
+ ]
88553
+ }
88554
+ ]
88555
+ }
88556
+ ]
88557
+ },
85975
88558
  "tmvar": {
85976
88559
  "title": "tmvar",
85977
88560
  "type": "function",
@@ -86871,6 +89454,117 @@
86871
89454
  }
86872
89455
  ]
86873
89456
  },
89457
+ "topRange": {
89458
+ "title": "topRange",
89459
+ "type": "function",
89460
+ "children": [
89461
+ {
89462
+ "title": "语法",
89463
+ "type": "grammer",
89464
+ "children": [
89465
+ {
89466
+ "type": "text",
89467
+ "value": [
89468
+ "topRange(X)"
89469
+ ]
89470
+ }
89471
+ ]
89472
+ },
89473
+ {
89474
+ "title": "参数",
89475
+ "type": "parameters",
89476
+ "children": [
89477
+ {
89478
+ "type": "text",
89479
+ "value": [
89480
+ "`X` 向量/元组/矩阵/表。"
89481
+ ]
89482
+ }
89483
+ ]
89484
+ },
89485
+ {
89486
+ "title": "详情",
89487
+ "type": "detail",
89488
+ "children": [
89489
+ {
89490
+ "type": "text",
89491
+ "value": [
89492
+ "对于 *X* 中的每个元素 *Xi*，统计 *Xi* 左侧相邻且连续大于它的元素个数。",
89493
+ "",
89494
+ "该函数常用于统计一个序列的当前值是前多少周期（日或分钟等）内的最大值。例如某只股票创几日新高等。"
89495
+ ]
89496
+ }
89497
+ ]
89498
+ },
89499
+ {
89500
+ "title": "例子",
89501
+ "type": "example",
89502
+ "children": [
89503
+ {
89504
+ "type": "code",
89505
+ "language": "console",
89506
+ "value": [
89507
+ "",
89508
+ " $ topRange([13.5, 13.6, 13.4, 13.3, 13.5, 13.9, 13.1, 20.1, 20.2, 20.3])",
89509
+ " [0,1,0,0,2,5,0,7,8,9]",
89510
+ "",
89511
+ " $ m = matrix(1.5 2.6 3.2 1.4 2.5 2.2 3.7 2.0, 1.6 2.3 4.2 5.6 4.1 3.2 4.4 6.9)",
89512
+ " $ topRange(m)",
89513
+ ""
89514
+ ]
89515
+ },
89516
+ {
89517
+ "type": "text",
89518
+ "value": [
89519
+ "== ==",
89520
+ "#0 #1",
89521
+ "== ==",
89522
+ "0 0 ",
89523
+ "1 1 ",
89524
+ "2 2 ",
89525
+ "0 3 ",
89526
+ "1 0 ",
89527
+ "0 0 ",
89528
+ "6 2 ",
89529
+ "0 7 ",
89530
+ "== ==",
89531
+ ""
89532
+ ]
89533
+ },
89534
+ {
89535
+ "type": "code",
89536
+ "language": "console",
89537
+ "value": [
89538
+ "",
89539
+ " //模拟股票 A 8天的股价,使用 topRange 计算股票 A 每日股价创几日新高",
89540
+ " $ trades = table(take(`A, 8) as sym, 2022.01.01 + 1..8 as date, 39.70 39.72 39.80 39.78 39.83 39.92 40.00 40.03 as price)",
89541
+ " $ select *, topRange(price) from trades",
89542
+ ""
89543
+ ]
89544
+ },
89545
+ {
89546
+ "type": "text",
89547
+ "value": [
89548
+ "=== ========== ======== ===============",
89549
+ "id date price topRange_price",
89550
+ "=== ========== ======== ===============",
89551
+ "A 2022.01.02 39.7 0",
89552
+ "A 2022.01.03 39.72 1",
89553
+ "A 2022.01.04 39.8 2",
89554
+ "A 2022.01.05 39.78 0",
89555
+ "A 2022.01.06 39.83 4",
89556
+ "A 2022.01.07 39.92 5",
89557
+ "A 2022.01.08 40 6",
89558
+ "A 2022.01.09 40.03 7",
89559
+ "=== ========== ======== ===============",
89560
+ "",
89561
+ "相关函数：:doc:`../l/lowRange`"
89562
+ ]
89563
+ }
89564
+ ]
89565
+ }
89566
+ ]
89567
+ },
86874
89568
  "transDS!": {
86875
89569
  "title": "transDS!",
86876
89570
  "type": "function",
@@ -89668,6 +92362,136 @@
89668
92362
  }
89669
92363
  ]
89670
92364
  },
92365
+ "valueChanged": {
92366
+ "title": "valueChanged",
92367
+ "type": "function",
92368
+ "children": [
92369
+ {
92370
+ "title": "语法",
92371
+ "type": "grammer",
92372
+ "children": [
92373
+ {
92374
+ "type": "text",
92375
+ "value": [
92376
+ "valueChanged(X, [mode=”prev“])"
92377
+ ]
92378
+ }
92379
+ ]
92380
+ },
92381
+ {
92382
+ "title": "参数",
92383
+ "type": "parameters",
92384
+ "children": [
92385
+ {
92386
+ "type": "text",
92387
+ "value": [
92388
+ "`X` 字符串、布尔、时间或数值类型的向量/矩阵/表/元组。",
92389
+ "",
92390
+ "`mode` 字符串，可选值为：\"prev\", \"next\", \"any\" 和 \"all\"，默认值为 \"prev\"。",
92391
+ "",
92392
+ "* \"prev\": 前一个元素。",
92393
+ "* \"next\": 后一个元素。",
92394
+ "* \"any\": 前一个元素或后一个元素。",
92395
+ "* \"all\": 前一个元素和后一个元素值。"
92396
+ ]
92397
+ }
92398
+ ]
92399
+ },
92400
+ {
92401
+ "title": "详情",
92402
+ "type": "detail",
92403
+ "children": [
92404
+ {
92405
+ "type": "text",
92406
+ "value": [
92407
+ "*X* 中每个元素较 *mode* 是否发生变化，若当前元素值发生变化，则返回 true，否则返回 false。若比较对象不存在，则返回 false。例如：valueChanged(X, [mode=”prev“]) 的第一个元素返回 false；valueChanged(X, [mode=”next“]) 的最后一个元素返回 false。",
92408
+ "",
92409
+ "若 *X* 为矩阵/表，在每列内进行上述操作，返回一个矩阵/表。"
92410
+ ]
92411
+ }
92412
+ ]
92413
+ },
92414
+ {
92415
+ "title": "例子",
92416
+ "type": "example",
92417
+ "children": [
92418
+ {
92419
+ "type": "code",
92420
+ "language": "console",
92421
+ "value": [
92422
+ "",
92423
+ " $ x= 1 2 2 2 2 3 NULL 3 4 8",
92424
+ " $ valueChanged(x)",
92425
+ " [false,true,false,false,false,true,true,true,true,true]",
92426
+ " ",
92427
+ " $ valueChanged(x,\"next\")",
92428
+ " [true,false,false,false,true,true,true,true,true,false]",
92429
+ " ",
92430
+ " $ valueChanged(x,\"any\")",
92431
+ " [true,true,false,false,true,true,true,true,true,true]",
92432
+ " ",
92433
+ " $ valueChanged(x,\"all\")",
92434
+ " [false,false,false,false,false,true,true,true,true,false]",
92435
+ "",
92436
+ " $ tup=(1 2 3, `A`A`B`C, 2021.10.12+1 2 2)",
92437
+ " $ valueChanged(tup)",
92438
+ " ([false,true,true],[false,false,true,true],[false,true,false])",
92439
+ "",
92440
+ " $ m=matrix(1 2 3, 1 2 3, 1 3 3)",
92441
+ " $ valueChanged(m)",
92442
+ ""
92443
+ ]
92444
+ },
92445
+ {
92446
+ "type": "text",
92447
+ "value": [
92448
+ "====== ======= =======",
92449
+ "col1\tcol2\tcol3",
92450
+ "====== ======= =======",
92451
+ "false\tfalse\tfalse",
92452
+ "true\ttrue\ttrue",
92453
+ "true\ttrue\tfalse",
92454
+ "====== ======= =======",
92455
+ ""
92456
+ ]
92457
+ },
92458
+ {
92459
+ "type": "code",
92460
+ "language": "console",
92461
+ "value": [
92462
+ "",
92463
+ " $ id= 1 2 2 2 2 3 3 4 8",
92464
+ " $ sym=`A + string(1 2 2 2 2 3 3 4 8)",
92465
+ " $ val=83.8 92.8 8.1 61.4 40.7 67.2 15.2 20.6 96.5",
92466
+ " $ t=table(id, sym, val)",
92467
+ " $ valueChanged(t)",
92468
+ ""
92469
+ ]
92470
+ },
92471
+ {
92472
+ "type": "text",
92473
+ "value": [
92474
+ "======= ====== =======",
92475
+ "id sym val",
92476
+ "======= ====== =======",
92477
+ "false\tfalse\tfalse",
92478
+ "true\ttrue\ttrue",
92479
+ "false\tfalse\ttrue",
92480
+ "false\tfalse\ttrue",
92481
+ "false\tfalse\ttrue",
92482
+ "true\ttrue\ttrue",
92483
+ "false\tfalse\ttrue",
92484
+ "true\ttrue\ttrue",
92485
+ "true\ttrue\ttrue",
92486
+ "======= ====== =======",
92487
+ "",
92488
+ "相关函数：:doc:`../k/keys`"
92489
+ ]
92490
+ }
92491
+ ]
92492
+ }
92493
+ ]
92494
+ },
89671
92495
  "values": {
89672
92496
  "title": "values",
89673
92497
  "type": "function",