# TS-SQL 函数补录

这些条目来自旧 TSL language basic 文档中的 TS-SQL 函数页。

## `Slopeandinterceptof(exp1, exp2, bool_condition_exp, n, moving_first, cache_id)`

回归斜率和截距的聚集函数

旧定义：`Slopeandinterceptof([DISTINCT]Exp1;Exp2: Expression[;BoolConditionExp:Exp [;N[;MovingFirst [;CacheId]]]])`

来源：TSL语言基础 > SQL基础到TS-SQL > TS-SQL语法 > SELECT查询语句 > 聚集函数 > 双序列统计聚集函数

Source ID：30109

| 参数                 | 类型        | 说明                                                                                                                                                                           |
| -------------------- | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `exp1`               | TExpression | 字段或表达式                                                                                                                                                                   |
| `exp2`               | TExpression | 字段或表达式                                                                                                                                                                   |
| `bool_condition_exp` | TExpression | 条件表达式，bool值(默认为真)                                                                                                                                                   |
| `n`                  | integer     | 移动数据长度（没有值时取统计所有数据，否则统计对象为满足条件的从当前行起往前总共的N条记录，如果为负数，则为从当前起往后总共\|N\|行。）                                         |
| `moving_first`       | Boolean     | 布尔型，为真表示统计内容为最近N条内符合BoolConditionExp条件的，为假表示统计内容为最近N条符合BoolConditionExp条件的。省略的时候具体默认值由SelectOpt来决定，参见:参考ID 30025。 |
| `cache_id`           | String      | 字符串型，缓存标识串，参见:[SQL时间序列统计缓存标志与性能加速](http://www.tinysoft.com.cn/tsdn/helpdoc/SearchContent.tsl?KeyWord=SQL时间序列统计缓存标志与性能加速)            |

返回：Array,TableArray，回归斜率和截距，一维数组，长度为2，分别表示回归斜率和截距

## `Steyxof(exp1, exp2, bool_condition_exp, n, moving_first, cache_id)`

相对标准偏差的聚集函数

旧定义：`Steyxof([DISTINCT] Exp1;Exp2: Expression[;BoolConditionExp:Exp [;N[;MovingFirst [;CacheId]]]])`

来源：TSL语言基础 > SQL基础到TS-SQL > TS-SQL语法 > SELECT查询语句 > 聚集函数 > 双序列统计聚集函数

Source ID：30108

| 参数                 | 类型        | 说明                                                                                                                                                                           |
| -------------------- | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `exp1`               | TExpression | 字段或表达式                                                                                                                                                                   |
| `exp2`               | TExpression | 字段或表达式                                                                                                                                                                   |
| `bool_condition_exp` | TExpression | 条件表达式，bool值(默认为真)                                                                                                                                                   |
| `n`                  | integer     | 移动数据长度（没有值时取统计所有数据，否则统计对象为满足条件的从当前行起往前总共的N条记录，如果为负数，则为从当前起往后总共\|N\|行。）                                         |
| `moving_first`       | Boolean     | 布尔型，为真表示统计内容为最近N条内符合BoolConditionExp条件的，为假表示统计内容为最近N条符合BoolConditionExp条件的。省略的时候具体默认值由SelectOpt来决定，参见:参考ID 30025。 |
| `cache_id`           | String      | 字符串型，缓存标识串，参见:[SQL时间序列统计缓存标志与性能加速](http://www.tinysoft.com.cn/tsdn/helpdoc/SearchContent.tsl?KeyWord=SQL时间序列统计缓存标志与性能加速)            |

返回：real，相对标准偏差，实数

## `Rsqof(exp1, exp2, bool_condition_exp, n, moving_first, cache_id)`

乘积矩相关系数平方的聚集函数

旧定义：`Rsqof([DISTINCT]Exp1;Exp2: Expression[;BoolConditionExp:Exp [;N[;MovingFirst ;CacheId]]]])`

来源：TSL语言基础 > SQL基础到TS-SQL > TS-SQL语法 > SELECT查询语句 > 聚集函数 > 双序列统计聚集函数

Source ID：30107

| 参数                 | 类型        | 说明                                                                                                                                                                           |
| -------------------- | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `exp1`               | TExpression | 字段或表达式                                                                                                                                                                   |
| `exp2`               | TExpression | 字段或表达式                                                                                                                                                                   |
| `bool_condition_exp` | TExpression | 条件表达式，bool值(默认为真)                                                                                                                                                   |
| `n`                  | integer     | 移动数据长度（没有值时取统计所有数据，否则统计对象为满足条件的从当前行起往前总共的N条记录，如果为负数，则为从当前起往后总共\|N\|行。）                                         |
| `moving_first`       | Boolean     | 布尔型，为真表示统计内容为最近N条内符合BoolConditionExp条件的，为假表示统计内容为最近N条符合BoolConditionExp条件的。省略的时候具体默认值由SelectOpt来决定，参见:参考ID 30025。 |
| `cache_id`           | String      | 字符串型，缓存标识串，参见:[SQL时间序列统计缓存标志与性能加速](http://www.tinysoft.com.cn/tsdn/helpdoc/SearchContent.tsl?KeyWord=SQL时间序列统计缓存标志与性能加速)            |

返回：real，乘积矩相关系数的平方，实数

## `Interceptof(exp1, exp2, bool_condition_exp, n, moving_first, cache_id)`

回归截距的聚集函数

旧定义：`Interceptof([DISTINCT]Exp1;Exp2: Expression [;BoolConditionExp:Exp[ ;N[;MovingFirst [;CacheId]]]])`

来源：TSL语言基础 > SQL基础到TS-SQL > TS-SQL语法 > SELECT查询语句 > 聚集函数 > 双序列统计聚集函数

Source ID：30106

| 参数                 | 类型        | 说明                                                                                                                                                                           |
| -------------------- | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `exp1`               | TExpression | 字段或表达式                                                                                                                                                                   |
| `exp2`               | TExpression | 字段或表达式                                                                                                                                                                   |
| `bool_condition_exp` | TExpression | 条件表达式，bool值(默认为真)                                                                                                                                                   |
| `n`                  | integer     | 移动数据长度（没有值时取统计所有数据，否则统计对象为满足条件的从当前行起往前总共的N条记录，如果为负数，则为从当前起往后总共\|N\|行。）                                         |
| `moving_first`       | Boolean     | 布尔型，为真表示统计内容为最近N条内符合BoolConditionExp条件的，为假表示统计内容为最近N条符合BoolConditionExp条件的。省略的时候具体默认值由SelectOpt来决定，参见:参考ID 30025。 |
| `cache_id`           | String      | 字符串型，缓存标识串，参见:[SQL时间序列统计缓存标志与性能加速](http://www.tinysoft.com.cn/tsdn/helpdoc/SearchContent.tsl?KeyWord=SQL时间序列统计缓存标志与性能加速)            |

返回：any，回归截距，实数

## `Slopeof(exp1, exp2, bool_condition_exp, n, moving_first, cache_id)`

回归斜率的聚集函数

旧定义：`Slopeof([DISTINCT]Exp1;Exp2: Expression[;BoolConditionExp:Exp [;N[;MovingFirst [;CacheId]]]] )`

来源：TSL语言基础 > SQL基础到TS-SQL > TS-SQL语法 > SELECT查询语句 > 聚集函数 > 双序列统计聚集函数

Source ID：30105

| 参数                 | 类型        | 说明                                                                                                                                                                           |
| -------------------- | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `exp1`               | TExpression | 字段或表达式                                                                                                                                                                   |
| `exp2`               | TExpression | 字段或表达式                                                                                                                                                                   |
| `bool_condition_exp` | TExpression | 条件表达式，bool值(默认为真)                                                                                                                                                   |
| `n`                  | integer     | 移动数据长度（没有值时取统计所有数据，否则统计对象为满足条件的从当前行起往前总共的N条记录，如果为负数，则为从当前起往后总共\|N\|行。）                                         |
| `moving_first`       | Boolean     | 布尔型，为真表示统计内容为最近N条内符合BoolConditionExp条件的，为假表示统计内容为最近N条符合BoolConditionExp条件的。省略的时候具体默认值由SelectOpt来决定，参见:参考ID 30025。 |
| `cache_id`           | String      | 字符串型，缓存标识串，参见:[SQL时间序列统计缓存标志与性能加速](http://www.tinysoft.com.cn/tsdn/helpdoc/SearchContent.tsl?KeyWord=SQL时间序列统计缓存标志与性能加速)            |

返回：integer，数据的回归斜率，实数

## `Covof(exp1, exp2, bool_condition_exp, n, moving_first, cache_id)`

协方差的聚集函数

旧定义：`Covof([DISTINCT]Exp1;Exp2: Expression [;BoolConditionExp:Exp[;N[;MovingFirst [;CacheId]]]])`

来源：TSL语言基础 > SQL基础到TS-SQL > TS-SQL语法 > SELECT查询语句 > 聚集函数 > 双序列统计聚集函数

Source ID：30104

| 参数                 | 类型        | 说明                                                                                                                                                                           |
| -------------------- | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `exp1`               | TExpression | 字段或表达式                                                                                                                                                                   |
| `exp2`               | TExpression | 字段或表达式                                                                                                                                                                   |
| `bool_condition_exp` | TExpression | 条件表达式，bool值(默认为真)                                                                                                                                                   |
| `n`                  | integer     | 移动数据长度（没有值时取统计所有数据，否则统计对象为满足条件的从当前行起往前总共的N条记录，如果为负数，则为从当前起往后总共\|N\|行。）                                         |
| `moving_first`       | Boolean     | 布尔型，为真表示统计内容为最近N条内符合BoolConditionExp条件的，为假表示统计内容为最近N条符合BoolConditionExp条件的。省略的时候具体默认值由SelectOpt来决定，参见:参考ID 30025。 |
| `cache_id`           | String      | 字符串型，缓存标识串，参见:[SQL时间序列统计缓存标志与性能加速](http://www.tinysoft.com.cn/tsdn/helpdoc/SearchContent.tsl?KeyWord=SQL时间序列统计缓存标志与性能加速)            |

返回：real，数据间的协方差，实数

## `Correlof(exp1, exp2, bool_condition_exp, n, moving_first, cache_id)`

相关系数的聚集函数

旧定义：`Correlof([DISTINCT]Exp1;Exp2: Expression [;BoolConditionExp:Exp[ ;N[;MovingFirst [;CacheId]]]]);`

来源：TSL语言基础 > SQL基础到TS-SQL > TS-SQL语法 > SELECT查询语句 > 聚集函数 > 双序列统计聚集函数

Source ID：30103

| 参数                 | 类型        | 说明                                                                                                                                                                           |
| -------------------- | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `exp1`               | TExpression | 字段或表达式                                                                                                                                                                   |
| `exp2`               | TExpression | 字段或表达式                                                                                                                                                                   |
| `bool_condition_exp` | TExpression | 条件表达式，bool值(默认为真)                                                                                                                                                   |
| `n`                  | integer     | 移动数据长度（没有值时取统计所有数据，否则统计对象为满足条件的从当前行起往前总共的N条记录，如果为负数，则为从当前起往后总共\|N\|行。）                                         |
| `moving_first`       | Boolean     | 布尔型，为真表示统计内容为最近N条内符合BoolConditionExp条件的，为假表示统计内容为最近N条符合BoolConditionExp条件的。省略的时候具体默认值由SelectOpt来决定，参见:参考ID 30025。 |
| `cache_id`           | String      | 字符串型，缓存标识串，参见:[SQL时间序列统计缓存标志与性能加速](http://www.tinysoft.com.cn/tsdn/helpdoc/SearchContent.tsl?KeyWord=SQL时间序列统计缓存标志与性能加速)            |

返回：real，数据的相关系数，实数

## `AGGOF(name_str, expression, bool_condition_exp, n, moving_first, cache_id)`

返回给定表达式（自定义聚集函数）中所有值的填充利用回调函数计算聚集的值。

旧定义：`AGGOf( name_str:TExpression; Expression:TExpression[;BoolConditionExp:TExpression[;N:Integer[;MovingFirst:Bool[;CacheId:String]]]]):any`

来源：TSL语言基础 > SQL基础到TS-SQL > TS-SQL语法 > SELECT查询语句 > 聚集函数

Source ID：30100

| 参数                 | 类型        | 说明                                                                                                                                                                                           |
| -------------------- | ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `name_str`           | TExpression | 字符串表达式，扩展聚集函数的名称。                                                                                                                                                             |
| `expression`         | TExpression | 任意类型表达式。参见多字段聚集。可在表达式前加关键字DISTINCT，表示不管该值出现了多少次，只使用每个值的唯一实例。不添加即统计所有。                                                             |
| `bool_condition_exp` | TExpression | 布尔型表达式，如果存在该参数，则统计内容为该表达式为真的行，否则统计所有。                                                                                                                     |
| `n`                  | integer     | 整数，如果没有N参数，则统计对象为全部，否则统计对象为满足条件的从当前行起往前总共的N条记录, 如果为负数，则为从当前起往后总共\|N\|行。                                                          |
| `moving_first`       | Boolean     | 布尔型，为真表示统计内容为最近N条内符合BoolConditionExp条件的，为假表示统计内容为最近N条符合BoolConditionExp条件的。默认为假，此省略模式可以通过SelectOpt(64)进行变换，具体参见:参考ID 30025。 |
| `cache_id`           | String      | 字符串型，缓存标识串，参见:参考ID 30110                                                                                                                                                        |

返回：any，由扩展聚集函数的返回决定

## `CHECKSUM_AGGOF(expression, bool_condition_exp, n, moving_first, cache_id)`

返回给定表达式中所有值的填充的校验和。

旧定义：`CHECKSUM_AGGOf(Expression:TExpression[;BoolConditionExp:TExpression[;N:Integer[;MovingFirst:Bool[;CacheId:String]]]]): Integer`

来源：TSL语言基础 > SQL基础到TS-SQL > TS-SQL语法 > SELECT查询语句 > 聚集函数

Source ID：30099

| 参数                 | 类型        | 说明                                                                                                                                                                                           |
| -------------------- | ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `expression`         | TExpression | 任意类型表达式。参见多字段聚集。可在表达式前加关键字DISTINCT，表示不管该值出现了多少次，只使用每个值的唯一实例。不添加即统计所有。                                                             |
| `bool_condition_exp` | TExpression | 布尔型表达式，如果存在该参数，则统计内容为该表达式为真的行，否则统计所有。                                                                                                                     |
| `n`                  | integer     | 整数，如果没有N参数，则统计对象为全部，否则统计对象为满足条件的从当前行起往前总共的N条记录, 如果为负数，则为从当前起往后总共\|N\|行。                                                          |
| `moving_first`       | Boolean     | 布尔型，为真表示统计内容为最近N条内符合BoolConditionExp条件的，为假表示统计内容为最近N条符合BoolConditionExp条件的。默认为假，此省略模式可以通过SelectOpt(64)进行变换，具体参见:参考ID 30025。 |
| `cache_id`           | String      | 字符串型，缓存标识串，参见:参考ID 30110                                                                                                                                                        |

返回：integer，Integer

## `ProductOf(expression, bool_condition_exp, n, moving_first, cache_id)`

返回累乘值。 ProductOf 可只用于数字列。空值将被忽略。

旧定义：`ProductOf(Expression:TExpression;[;BoolConditionExp:TExpression[;N:Integer[;MovingFirst:Bool[;CacheId:String]]]]):real`

来源：TSL语言基础 > SQL基础到TS-SQL > TS-SQL语法 > SELECT查询语句 > 聚集函数

Source ID：30097

| 参数                 | 类型        | 说明                                                                                                                                                                                           |
| -------------------- | ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `expression`         | TExpression | 数字数据类型表达式。参见多字段聚集。可在表达式前加关键字DISTINCT，表示不管该值出现了多少次，只使用每个值的唯一实例。不添加即统计所有。                                                         |
| `bool_condition_exp` | TExpression | 布尔型表达式，如果存在该参数，则统计内容为该表达式为真的行，否则统计所有。                                                                                                                     |
| `n`                  | integer     | 整数，如果没有N参数，则统计对象为全部，否则统计对象为满足条件的从当前行起往前总共的N条记录, 如果为负数，则为从当前起往后总共\|N\|行。                                                          |
| `moving_first`       | Boolean     | 布尔型，为真表示统计内容为最近N条内符合BoolConditionExp条件的，为假表示统计内容为最近N条符合BoolConditionExp条件的。默认为假，此省略模式可以通过SelectOpt(64)进行变换，具体参见:参考ID 30025。 |
| `cache_id`           | String      | 字符串型，缓存标识串，参见:参考ID 30110                                                                                                                                                        |

返回：real，Real

## `FrequencyOf(expression, calc_array, bool_condition_exp, n, moving_first, cache_id)`

返回数值区间在数据集中出现的频率。 FrequencyOf 可只用于数字列。空值将被忽略。

旧定义：`FrequencyOf(Expression:TExpression;calc_array:array[;BoolConditionExp:TExpression [;N:Integer[;MovingFirst:Bool[;CacheId:String]]]]):real`

来源：TSL语言基础 > SQL基础到TS-SQL > TS-SQL语法 > SELECT查询语句 > 聚集函数

Source ID：30096

| 参数                 | 类型             | 说明                                                                                                                                                                                           |
| -------------------- | ---------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `expression`         | TExpression      | 数字数据类型表达式。参见多字段聚集。可在表达式前加关键字DISTINCT，表示不管该值出现了多少次，只使用每个值的唯一实例。不添加即统计所有。                                                         |
| `calc_array`         | Array,TableArray | 计算的数值区间，例如array(2,3,5)则计算<=2和>2 <=3以及>3<=5以及>5的区间出现频率假如数据集为1,2,4，则返回的结果为2,0,1,0。返回的结果比数据区间的值个数多1                                        |
| `bool_condition_exp` | TExpression      | 布尔型表达式，如果存在该参数，则统计内容为该表达式为真的行，否则统计所有。                                                                                                                     |
| `n`                  | integer          | 整数，如果没有N参数，则统计对象为全部，否则统计对象为满足条件的从当前行起往前总共的N条记录, 如果为负数，则为从当前起往后总共\|N\|行。                                                          |
| `moving_first`       | Boolean          | 布尔型，为真表示统计内容为最近N条内符合BoolConditionExp条件的，为假表示统计内容为最近N条符合BoolConditionExp条件的。默认为假，此省略模式可以通过SelectOpt(64)进行变换，具体参见:参考ID 30025。 |
| `cache_id`           | String           | 字符串型，缓存标识串，参见:参考ID 30110                                                                                                                                                        |

返回：real，Real

## `TrimMeanOf(expression, k, bool_condition_exp, n, moving_first, cache_id)`

返回数据集中的内部平均值，从头尾去掉指定百分比的数据点，再求平均值。 TrimMeanOf 可只用于数字列。空值将被忽略。

旧定义：`TrimMeanOf(Expression:TExpression;K:Real[;BoolConditionExp:TExpression[;N:Integer[;MovingFirst:Bool[;CacheId:String]]]]] ):real`

来源：TSL语言基础 > SQL基础到TS-SQL > TS-SQL语法 > SELECT查询语句 > 聚集函数

Source ID：30095

| 参数                 | 类型        | 说明                                                                                                                                                                                           |
| -------------------- | ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `expression`         | TExpression | 数字数据类型表达式。参见多字段聚集。可在表达式前加关键字DISTINCT，表示不管该值出现了多少次，只使用每个值的唯一实例。不添加即统计所有。                                                         |
| `k`                  | real        | 0到1之间，如果为0.2表示头尾去掉10%，也就是在20个数据点中头尾各去掉2个。                                                                                                                        |
| `bool_condition_exp` | TExpression | 布尔型表达式，如果存在该参数，则统计内容为该表达式为真的行，否则统计所有。                                                                                                                     |
| `n`                  | integer     | 整数，如果没有N参数，则统计对象为全部，否则统计对象为满足条件的从当前行起往前总共的N条记录, 如果为负数，则为从当前起往后总共\|N\|行。                                                          |
| `moving_first`       | Boolean     | 布尔型，为真表示统计内容为最近N条内符合BoolConditionExp条件的，为假表示统计内容为最近N条符合BoolConditionExp条件的。默认为假，此省略模式可以通过SelectOpt(64)进行变换，具体参见:参考ID 30025。 |
| `cache_id`           | String      | 字符串型，缓存标识串，参见:参考ID 30110                                                                                                                                                        |

返回：real，Real

## `QuartileOf(expression, k, bool_condition_exp, n, moving_first, cache_id)`

返回数据集中四分位的值。 QuartileOf 可只用于数字列。空值将被忽略。

旧定义：`QuartileOf(Expression:TExpression;K:Integer[;BoolConditionExp:TExpression[;N:Integer[;MovingFirst:Bool[;CacheId:String]]]]):real`

来源：TSL语言基础 > SQL基础到TS-SQL > TS-SQL语法 > SELECT查询语句 > 聚集函数

Source ID：30093

| 参数                 | 类型        | 说明                                                                                                                                                                                           |
| -------------------- | ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `expression`         | TExpression | 数字数据类型表达式。参见多字段聚集。可在表达式前加关键字DISTINCT，表示不管该值出现了多少次，只使用每个值的唯一实例。不添加即统计所有。                                                         |
| `k`                  | integer     | 四分位，取值为0,1,2,3,4 中的任意值0最小值，4为最大值，1为25个百分点，2为中位数，3为75个百分点                                                                                                  |
| `bool_condition_exp` | TExpression | 布尔型表达式，如果存在该参数，则统计内容为该表达式为真的行，否则统计所有。                                                                                                                     |
| `n`                  | integer     | 整数，如果没有N参数，则统计对象为全部，否则统计对象为满足条件的从当前行起往前总共的N条记录, 如果为负数，则为从当前起往后总共\|N\|行。                                                          |
| `moving_first`       | Boolean     | 布尔型，为真表示统计内容为最近N条内符合BoolConditionExp条件的，为假表示统计内容为最近N条符合BoolConditionExp条件的。默认为假，此省略模式可以通过SelectOpt(64)进行变换，具体参见:参考ID 30025。 |
| `cache_id`           | String      | 字符串型，缓存标识串，参见:参考ID 30110                                                                                                                                                        |

返回：real，四分位值

## `PercentRankOf(expression, x, bool_condition_exp, n, moving_first, cache_id)`

返回数据集中X排位的百分点。 返回数据集中数字的百分比。先对数据进行排序，计算指定数值value（如果没有value值，则找比value小且最接近的值）所处的排序后的位置比例。最大的是1，最小的是0

旧定义：`PercentRankOf(Expression:TExpression;X:Real:Real[;BoolConditionExp:TExpression[;N:Integer[;MovingFirst:Bool[;CacheId:String]]]]):real`

来源：TSL语言基础 > SQL基础到TS-SQL > TS-SQL语法 > SELECT查询语句 > 聚集函数

Source ID：30092

| 参数                 | 类型        | 说明                                                                                                                                                                                           |
| -------------------- | ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `expression`         | TExpression | 数字数据类型表达式。参见多字段聚集。可在表达式前加关键字DISTINCT，表示不管该值出现了多少次，只使用每个值的唯一实例。不添加即统计所有。                                                         |
| `x`                  | real        | 排位的值                                                                                                                                                                                       |
| `bool_condition_exp` | TExpression | 布尔型表达式，如果存在该参数，则统计内容为该表达式为真的行，否则统计所有。                                                                                                                     |
| `n`                  | integer     | 整数，如果没有N参数，则统计对象为全部，否则统计对象为满足条件的从当前行起往前总共的N条记录, 如果为负数，则为从当前起往后总共\|N\|行。                                                          |
| `moving_first`       | Boolean     | 布尔型，为真表示统计内容为最近N条内符合BoolConditionExp条件的，为假表示统计内容为最近N条符合BoolConditionExp条件的。默认为假，此省略模式可以通过SelectOpt(64)进行变换，具体参见:参考ID 30025。 |
| `cache_id`           | String      | 字符串型，缓存标识串，参见:参考ID 30110                                                                                                                                                        |

返回：real，Real

## `Percentileof(expression, k, bool_condition_exp, n, moving_first, cache_id)`

返回数据集中第 k 个百分点的值。 PercentileOf 可只用于数字列。空值将被忽略。

旧定义：`PercentileOf(Expression:TExpression;K:Real[;BoolConditionExp:TExpression[;N:Integer[;MovingFirst:Bool[;CacheId:String]]]]):real`

来源：TSL语言基础 > SQL基础到TS-SQL > TS-SQL语法 > SELECT查询语句 > 聚集函数

Source ID：30091

| 参数                 | 类型        | 说明                                                                                                                                                                                           |
| -------------------- | ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `expression`         | TExpression | 数字数据类型表达式。参见多字段聚集。可在表达式前加关键字DISTINCT，表示不管该值出现了多少次，只使用每个值的唯一实例。不添加即统计所有。                                                         |
| `k`                  | integer     | 0到1之间的实数，包含0和1                                                                                                                                                                       |
| `bool_condition_exp` | TExpression | 布尔型表达式，如果存在该参数，则统计内容为该表达式为真的行，否则统计所有。                                                                                                                     |
| `n`                  | integer     | 整数，如果没有N参数，则统计对象为全部，否则统计对象为满足条件的从当前行起往前总共的N条记录, 如果为负数，则为从当前起往后总共\|N\|行。                                                          |
| `moving_first`       | Boolean     | 布尔型，为真表示统计内容为最近N条内符合BoolConditionExp条件的，为假表示统计内容为最近N条符合BoolConditionExp条件的。默认为假，此省略模式可以通过SelectOpt(64)进行变换，具体参见:参考ID 30025。 |
| `cache_id`           | String      | 字符串型，缓存标识串，参见:参考ID 30110                                                                                                                                                        |

返回：real，Real

## `Smallof(expression, k, bool_condition_exp, n, moving_first, cache_id)`

返回数据集中第 k 个最小值。 SmallOf 可只用于数字列。空值将被忽略。

旧定义：`SmallOf(Expression:TExpression;K:Integer[;BoolConditionExp:TExpression[;N:Integer[;MovingFirst:Bool[;CacheId:String]]]]):real`

来源：TSL语言基础 > SQL基础到TS-SQL > TS-SQL语法 > SELECT查询语句 > 聚集函数

Source ID：30090

| 参数                 | 类型        | 说明                                                                                                                                                                                           |
| -------------------- | ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `expression`         | TExpression | 数字数据类型表达式。参见多字段聚集。可在表达式前加关键字DISTINCT，表示不管该值出现了多少次，只使用每个值的唯一实例。不添加即统计所有。                                                         |
| `k`                  | integer     | 大于或者等于1的整数，为需要返回的排位号                                                                                                                                                        |
| `bool_condition_exp` | TExpression | 布尔型表达式，如果存在该参数，则统计内容为该表达式为真的行，否则统计所有。                                                                                                                     |
| `n`                  | integer     | 整数，如果没有N参数，则统计对象为全部，否则统计对象为满足条件的从当前行起往前总共的N条记录, 如果为负数，则为从当前起往后总共\|N\|行。                                                          |
| `moving_first`       | Boolean     | 布尔型，为真表示统计内容为最近N条内符合BoolConditionExp条件的，为假表示统计内容为最近N条符合BoolConditionExp条件的。默认为假，此省略模式可以通过SelectOpt(64)进行变换，具体参见:参考ID 30025。 |
| `cache_id`           | String      | 字符串型，缓存标识串，参见:参考ID 30110                                                                                                                                                        |

返回：real，Real

## `Largeof(expression, k, bool_condition_exp, n, moving_first, cache_id)`

返回数据集中第 k 个最大值。 LargeOf可只用于数字列。空值将被忽略。

旧定义：`LargeOf(Expression:TExpression;K:Integer[;BoolConditionExp:TExpression[;N:Integer[;MovingFirst:Bool[;CacheId:String]]]]):real`

来源：TSL语言基础 > SQL基础到TS-SQL > TS-SQL语法 > SELECT查询语句 > 聚集函数

Source ID：30089

| 参数                 | 类型        | 说明                                                                                                                                                                                           |
| -------------------- | ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `expression`         | TExpression | 数字数据类型表达式。参见多字段聚集。可在表达式前加关键字DISTINCT，表示不管该值出现了多少次，只使用每个值的唯一实例。不添加即统计所有。                                                         |
| `k`                  | integer     | 大于或者等于1的整数，为需要返回的排位号                                                                                                                                                        |
| `bool_condition_exp` | TExpression | 布尔型表达式，如果存在该参数，则统计内容为该表达式为真的行，否则统计所有。                                                                                                                     |
| `n`                  | integer     | 整数，如果没有N参数，则统计对象为全部，否则统计对象为满足条件的从当前行起往前总共的N条记录, 如果为负数，则为从当前起往后总共\|N\|行。                                                          |
| `moving_first`       | Boolean     | 布尔型，为真表示统计内容为最近N条内符合BoolConditionExp条件的，为假表示统计内容为最近N条符合BoolConditionExp条件的。默认为假，此省略模式可以通过SelectOpt(64)进行变换，具体参见:参考ID 30025。 |
| `cache_id`           | String      | 字符串型，缓存标识串，参见:参考ID 30110                                                                                                                                                        |

返回：real，Real

## `KURTOSIS2OF(expression, bool_condition_exp, n, moving_first, cache_id)`

返回给定表达式中所有值的填充的峰度，反映数据集中的程度。算法与矩阵计算软件兼容。 KURTOSIS2OF 可只用于数字列。空值将被忽略。

旧定义：`Kurtosis2Of(Expression:TExpression[;BoolConditionExp:TExpression[;N:Integer[;MovingFirst:Bool[;CacheId:String]]]]):real`

来源：TSL语言基础 > SQL基础到TS-SQL > TS-SQL语法 > SELECT查询语句 > 聚集函数

Source ID：30088

| 参数                 | 类型        | 说明                                                                                                                                                                                           |
| -------------------- | ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `expression`         | TExpression | 数字数据类型表达式。参见多字段聚集。可在表达式前加关键字DISTINCT，表示不管该值出现了多少次，只使用每个值的唯一实例。不添加即统计所有。                                                         |
| `bool_condition_exp` | TExpression | 布尔型表达式，如果存在该参数，则统计内容为该表达式为真的行，否则统计所有。                                                                                                                     |
| `n`                  |             | 整数，如果没有N参数，则统计对象为全部，否则统计对象为满足条件的从当前行起往前总共的N条记录, 如果为负数，则为从当前起往后总共\|N\|行。                                                          |
| `moving_first`       |             | 布尔型，为真表示统计内容为最近N条内符合BoolConditionExp条件的，为假表示统计内容为最近N条符合BoolConditionExp条件的。默认为假，此省略模式可以通过SelectOpt(64)进行变换，具体参见:参考ID 30025。 |
| `cache_id`           | String      | 字符串型，缓存标识串，参见:参考ID 30110                                                                                                                                                        |

返回：real，Real

## `KURTOSISOF(expression, bool_condition_exp, n, moving_first, cache_id)`

返回给定表达式中所有值的填充的峰度，反映数据集中的程度。算法与表格计算软件兼容。 KURTOSISOF 可只用于数字列。空值将被忽略。

旧定义：`KurtosisOf(Expression:TExpression[;BoolConditionExp:TExpression[;N:Integer[;MovingFirst:Bool[;CacheId:String]]]]] ):real`

来源：TSL语言基础 > SQL基础到TS-SQL > TS-SQL语法 > SELECT查询语句 > 聚集函数

Source ID：30087

| 参数                 | 类型        | 说明                                                                                                                                                                                           |
| -------------------- | ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `expression`         | TExpression | 数字数据类型表达式。参见多字段聚集。可在表达式前加关键字DISTINCT，表示不管该值出现了多少次，只使用每个值的唯一实例。不添加即统计所有。                                                         |
| `bool_condition_exp` | TExpression | 布尔型表达式，如果存在该参数，则统计内容为该表达式为真的行，否则统计所有。                                                                                                                     |
| `n`                  | integer     | 整数，如果没有N参数，则统计对象为全部，否则统计对象为满足条件的从当前行起往前总共的N条记录, 如果为负数，则为从当前起往后总共\|N\|行。                                                          |
| `moving_first`       | Boolean     | 布尔型，为真表示统计内容为最近N条内符合BoolConditionExp条件的，为假表示统计内容为最近N条符合BoolConditionExp条件的。默认为假，此省略模式可以通过SelectOpt(64)进行变换，具体参见:参考ID 30025。 |
| `cache_id`           | String      | 字符串型，缓存标识串，参见:参考ID 30110                                                                                                                                                        |

返回：real，Real

## `SKEW2OF(expression, bool_condition_exp, n, moving_first, cache_id)`

返回给定表达式中所有值的填充的偏度，反映数据不对称的程度。算法与矩阵计算软件兼容。 SKEW2OF 可只用于数字列。空值将被忽略。

旧定义：`SKEW2OF (Expression:TExpression[;BoolConditionExp:TExpression[;N:Integer[;MovingFirst:Bool[;CacheId:String]]]]):real`

来源：TSL语言基础 > SQL基础到TS-SQL > TS-SQL语法 > SELECT查询语句 > 聚集函数

Source ID：30086

| 参数                 | 类型        | 说明                                                                                                                                                                                           |
| -------------------- | ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `expression`         | TExpression | 数字数据类型表达式。参见多字段聚集。可在表达式前加关键字DISTINCT，表示不管该值出现了多少次，只使用每个值的唯一实例。不添加即统计所有。                                                         |
| `bool_condition_exp` | TExpression | 布尔型表达式，如果存在该参数，则统计内容为该表达式为真的行，否则统计所有。                                                                                                                     |
| `n`                  | integer     | 整数，如果没有N参数，则统计对象为全部，否则统计对象为满足条件的从当前行起往前总共的N条记录, 如果为负数，则为从当前起往后总共\|N\|行。                                                          |
| `moving_first`       | Boolean     | 布尔型，为真表示统计内容为最近N条内符合BoolConditionExp条件的，为假表示统计内容为最近N条符合BoolConditionExp条件的。默认为假，此省略模式可以通过SelectOpt(64)进行变换，具体参见:参考ID 30025。 |
| `cache_id`           | String      | 字符串型，缓存标识串，参见:参考ID 30110                                                                                                                                                        |

返回：real，Real

## `SKEWOF(expression, bool_condition_exp, n, moving_first, cache_id)`

返回给定表达式中所有值的填充的偏度，反映数据不对称的程度。算法与表格计算软件兼容。 SKEWOF 可只用于数字列。空值将被忽略。

旧定义：`SKEWOF ( [ DISTINCT ]Expression:TExpression[;BoolConditionExp:TExpression[;N:Integer[;MovingFirst:Bool[;CacheId:String]]]]):real`

来源：TSL语言基础 > SQL基础到TS-SQL > TS-SQL语法 > SELECT查询语句 > 聚集函数

Source ID：30085

| 参数                 | 类型        | 说明                                                                                                                                                                                           |
| -------------------- | ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `expression`         |             | 数字数据类型表达式。参见多字段聚集。可在表达式前加关键字DISTINCT，表示不管该值出现了多少次，只使用每个值的唯一实例。不添加即统计所有。                                                         |
| `bool_condition_exp` | TExpression | 布尔型表达式，如果存在该参数，则统计内容为该表达式为真的行，否则统计所有。                                                                                                                     |
| `n`                  | integer     | 整数，如果没有N参数，则统计对象为全部，否则统计对象为满足条件的从当前行起往前总共的N条记录, 如果为负数，则为从当前起往后总共\|N\|行。                                                          |
| `moving_first`       | Boolean     | 布尔型，为真表示统计内容为最近N条内符合BoolConditionExp条件的，为假表示统计内容为最近N条符合BoolConditionExp条件的。默认为假，此省略模式可以通过SelectOpt(64)进行变换，具体参见:参考ID 30025。 |
| `cache_id`           | String      | 字符串型，缓存标识串，参见:参考ID 30110                                                                                                                                                        |

返回：real，Real

## `NORMOF(expression, bool_condition_exp, n, moving_first, cache_id)`

返回给定表达式中所有值的填充的平方和的平方根。 NORMOF 可只用于数字列。空值将被忽略。

旧定义：`NORMOF (Expression:TExpression[;BoolConditionExp:TExpression[;N:Integer[;MovingFirst:Bool[;CacheId:String]]]]):real`

来源：TSL语言基础 > SQL基础到TS-SQL > TS-SQL语法 > SELECT查询语句 > 聚集函数

Source ID：30084

| 参数                 | 类型        | 说明                                                                                                                                                                                           |
| -------------------- | ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `expression`         | TExpression | 数字数据类型表达式。参见多字段聚集。可在表达式前加关键字DISTINCT，表示不管该值出现了多少次，只使用每个值的唯一实例。不添加即统计所有。                                                         |
| `bool_condition_exp` | TExpression | 布尔型表达式，如果存在该参数，则统计内容为该表达式为真的行，否则统计所有。                                                                                                                     |
| `n`                  | integer     | 整数，如果没有N参数，则统计对象为全部，否则统计对象为满足条件的从当前行起往前总共的N条记录, 如果为负数，则为从当前起往后总共\|N\|行。                                                          |
| `moving_first`       | Boolean     | 布尔型，为真表示统计内容为最近N条内符合BoolConditionExp条件的，为假表示统计内容为最近N条符合BoolConditionExp条件的。默认为假，此省略模式可以通过SelectOpt(64)进行变换，具体参见:参考ID 30025。 |
| `cache_id`           | String      | 字符串型，缓存标识串，参见:参考ID 30110                                                                                                                                                        |

返回：real，Real

## `DEVSQOF(expression, bool_condition_exp, n, moving_first, cache_id)`

返回给定表达式中所有值的样本平均值偏差的平方和。 DEVSQOF 可只用于数字列。空值将被忽略。

旧定义：`DEVSQOF (Expression:TExpression[;BoolConditionExp:TExpression[;N:Integer[;MovingFirst:Bool[;CacheId:String]]]]):real`

来源：TSL语言基础 > SQL基础到TS-SQL > TS-SQL语法 > SELECT查询语句 > 聚集函数

Source ID：30083

| 参数                 | 类型        | 说明                                                                                                                                                                                           |
| -------------------- | ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `expression`         | TExpression | 数字数据类型表达式。参见多字段聚集。可在表达式前加关键字DISTINCT，表示不管该值出现了多少次，只使用每个值的唯一实例。不添加即统计所有。                                                         |
| `bool_condition_exp` | TExpression | 布尔型表达式，如果存在该参数，则统计内容为该表达式为真的行，否则统计所有。                                                                                                                     |
| `n`                  | integer     | 整数，如果没有N参数，则统计对象为全部，否则统计对象为满足条件的从当前行起往前总共的N条记录, 如果为负数，则为从当前起往后总共\|N\|行。                                                          |
| `moving_first`       | Boolean     | 布尔型，为真表示统计内容为最近N条内符合BoolConditionExp条件的，为假表示统计内容为最近N条符合BoolConditionExp条件的。默认为假，此省略模式可以通过SelectOpt(64)进行变换，具体参见:参考ID 30025。 |
| `cache_id`           | String      | 字符串型，缓存标识串，参见:参考ID 30110                                                                                                                                                        |

返回：real，Real

## `AvedevOF(expression, bool_condition_exp, n, moving_first, cache_id)`

返回给定表达式中所有值的与其均值的绝对偏差的平均值，ADEDEVOF 用于评测这组数据的离散度。 AVEDEVOF 可只用于数字列。空值将被忽略。

旧定义：`AvedevOF ( Expression:TExpression[;BoolConditionExp:TExpression[;N:Integer[;MovingFirst:Bool[;CacheId:String]]]]):real`

来源：TSL语言基础 > SQL基础到TS-SQL > TS-SQL语法 > SELECT查询语句 > 聚集函数

Source ID：30082

| 参数                 | 类型        | 说明                                                                                                                                                                                           |
| -------------------- | ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `expression`         | TExpression | 数字数据类型表达式。参见多字段聚集。                                                                                                                                                           |
| `bool_condition_exp` | TExpression | 布尔型表达式，如果存在该参数，则统计内容为该表达式为真的行，否则统计所有。                                                                                                                     |
| `n`                  | integer     | 整数，如果没有N参数，则统计对象为全部，否则统计对象为满足条件的从当前行起往前总共的N条记录, 如果为负数，则为从当前起往后总共\|N\|行。                                                          |
| `moving_first`       | Boolean     | 布尔型，为真表示统计内容为最近N条内符合BoolConditionExp条件的，为假表示统计内容为最近N条符合BoolConditionExp条件的。默认为假，此省略模式可以通过SelectOpt(64)进行变换，具体参见:参考ID 30025。 |
| `cache_id`           | String      | 字符串型，缓存标识串，参见:参考ID 30110                                                                                                                                                        |

返回：real，real

## `TotalVarOf(expression, bool_condition_exp, n, moving_first, cache_id)`

返回给定表达式中所有值总方差。 TotalVarOf只用于数字列。空值将被忽略。

旧定义：`TotalVarOf (Expression:TExpression[;BoolConditionExp:TExpression[;N:Integer[;MovingFirst:Bool[;CacheId:String]]]]):real`

来源：TSL语言基础 > SQL基础到TS-SQL > TS-SQL语法 > SELECT查询语句 > 聚集函数

Source ID：30081

| 参数                 | 类型        | 说明                                                                                                                                                                                           |
| -------------------- | ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `expression`         | TExpression | 数字数据类型表达式。参见多字段聚集。可在表达式前加关键字DISTINCT，表示不管该值出现了多少次，只使用每个值的唯一实例。不添加即统计所有。                                                         |
| `bool_condition_exp` | TExpression | 布尔型表达式，如果存在该参数，则统计内容为该表达式为真的行，否则统计所有。                                                                                                                     |
| `n`                  | integer     | 整数，如果没有N参数，则统计对象为全部，否则统计对象为满足条件的从当前行起往前总共的N条记录, 如果为负数，则为从当前起往后总共\|N\|行。                                                          |
| `moving_first`       | Boolean     | 布尔型，为真表示统计内容为最近N条内符合BoolConditionExp条件的，为假表示统计内容为最近N条符合BoolConditionExp条件的。默认为假，此省略模式可以通过SelectOpt(64)进行变换，具体参见:参考ID 30025。 |
| `cache_id`           | String      | 字符串型，缓存标识串，参见:参考ID 30110                                                                                                                                                        |

返回：real，Real

## `VarpOf(expression, bool_condition_exp, n, moving_first, cache_id)`

返回给定表达式中所有值的填充统计方差(总体方差)。 VARPOF 只用于数字列。空值将被忽略。

旧定义：`VARPOF (Expression:TExpression[;BoolConditionExp:TExpression[;N:Integer[;MovingFirst:Bool[;CacheId:String]]]]):real`

来源：TSL语言基础 > SQL基础到TS-SQL > TS-SQL语法 > SELECT查询语句 > 聚集函数

Source ID：30080

| 参数                 | 类型        | 说明                                                                                                                                                                                           |
| -------------------- | ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `expression`         | TExpression | 数字数据类型表达式。参见多字段聚集。                                                                                                                                                           |
| `bool_condition_exp` | TExpression | 布尔型表达式，如果存在该参数，则统计内容为该表达式为真的行，否则统计所有。                                                                                                                     |
| `n`                  | integer     | 整数，如果没有N参数，则统计对象为全部，否则统计对象为满足条件的从当前行起往前总共的N条记录, 如果为负数，则为从当前起往后总共\|N\|行。                                                          |
| `moving_first`       | Boolean     | 布尔型，为真表示统计内容为最近N条内符合BoolConditionExp条件的，为假表示统计内容为最近N条符合BoolConditionExp条件的。默认为假，此省略模式可以通过SelectOpt(64)进行变换，具体参见:参考ID 30025。 |
| `cache_id`           | String      | 字符串型，缓存标识串，参见:参考ID 30110                                                                                                                                                        |

返回：real，Real

## `VarOf(expression, bool_condition_exp, n, moving_first, cache_id)`

返回给定表达式中所有值的统计方差（样本方差）。 VAROF 只用于数字列。空值将被忽略。

旧定义：`VAROF(Expression:TExpression[;BoolConditionExp:TExpression[;N:Integer[;MovingFirst:Bool[;CacheId:String]]]]):real`

来源：TSL语言基础 > SQL基础到TS-SQL > TS-SQL语法 > SELECT查询语句 > 聚集函数

Source ID：30079

| 参数                 | 类型        | 说明                                                                                                                                                                                           |
| -------------------- | ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `expression`         | TExpression | 数字数据类型表达式。参见多字段聚集。可在表达式前加关键字DISTINCT，表示不管该值出现了多少次，只使用每个值的唯一实例。不添加即统计所有。                                                         |
| `bool_condition_exp` | TExpression | 布尔型表达式，如果存在该参数，则统计内容为该表达式为真的行，否则统计所有。                                                                                                                     |
| `n`                  | integer     | 整数，如果没有N参数，则统计对象为全部，否则统计对象为满足条件的从当前行起往前总共的N条记录, 如果为负数，则为从当前起往后总共\|N\|行。                                                          |
| `moving_first`       | Boolean     | 布尔型，为真表示统计内容为最近N条内符合BoolConditionExp条件的，为假表示统计内容为最近N条符合BoolConditionExp条件的。默认为假，此省略模式可以通过SelectOpt(64)进行变换，具体参见:参考ID 30025。 |
| `cache_id`           | String      | 字符串型，缓存标识串，参见:参考ID 30110                                                                                                                                                        |

返回：real，Real

## `STDEVPOF(expression, bool_condition_exp, n, moving_first, cache_id)`

返回给定表达式中所有值的填充统计标准偏差(总体标准差)。 STDEVPOF 只能用于数字列。空值将被忽略。

旧定义：`STDEVPOF (Expression:TExpression[;BoolConditionExp:TExpression[;N:Integer[;MovingFirst:Bool[;CacheId:String]]]]) :real`

来源：TSL语言基础 > SQL基础到TS-SQL > TS-SQL语法 > SELECT查询语句 > 聚集函数

Source ID：30078

| 参数                 | 类型        | 说明                                                                                                                                                                                           |
| -------------------- | ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `expression`         | TExpression | 是数字表达式。参见多字段聚集。可在表达式前加关键字DISTINCT，表示不管该值出现了多少次，只使用每个值的唯一实例。不添加即统计所有。                                                               |
| `bool_condition_exp` | TExpression | 布尔型表达式，如果存在该参数，则统计内容为该表达式为真的行，否则统计所有。                                                                                                                     |
| `n`                  | integer     | 整数，如果没有N参数，则统计对象为全部，否则统计对象为满足条件的从当前行起往前总共的N条记录, 如果为负数，则为从当前起往后总共\|N\|行。                                                          |
| `moving_first`       | Boolean     | 布尔型，为真表示统计内容为最近N条内符合BoolConditionExp条件的，为假表示统计内容为最近N条符合BoolConditionExp条件的。默认为假，此省略模式可以通过SelectOpt(64)进行变换，具体参见:参考ID 30025。 |
| `cache_id`           | String      | 字符串型，缓存标识串，参见:参考ID 30110                                                                                                                                                        |

返回：real，Real

## `MEDIANOF(expression, bool_condition_exp, n, moving_first, cache_id)`

返回表达式中所有值的中值,中值是在一组数据中居于中间的数，即在这组数据中，有一半的数据比它大，有一半的数据比它小。如果参数集合中包含偶数个数字，函数 MEDIANOF 将返回位于中间的两个数的平均值。

旧定义：`MEDIANOF (Expression:TExpression[;BoolConditionExp:TExpression[;N:Integer[;MovingFirst:Bool[;CacheId:String]]]]] ) :real`

来源：TSL语言基础 > SQL基础到TS-SQL > TS-SQL语法 > SELECT查询语句 > 聚集函数

Source ID：30076

| 参数                 | 类型        | 说明                                                                                                                                                                                           |
| -------------------- | ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `expression`         | TExpression | Expression 是数字类型的表达式。参见多字段聚集。可在表达式前加关键字DISTINCT，表示不管该值出现了多少次，只使用每个值的唯一实例。不添加即统计所有。                                              |
| `bool_condition_exp` | TExpression | 布尔型表达式，如果存在该参数，则统计内容为该表达式为真的行，否则统计所有。                                                                                                                     |
| `n`                  | integer     | 整数，如果没有N参数，则统计对象为全部，否则统计对象为满足条件的从当前行起往前总共的N条记录, 如果为负数，则为从当前起往后总共\|N\|行。                                                          |
| `moving_first`       | Boolean     | 布尔型，为真表示统计内容为最近N条内符合BoolConditionExp条件的，为假表示统计内容为最近N条符合BoolConditionExp条件的。默认为假，此省略模式可以通过SelectOpt(64)进行变换，具体参见:参考ID 30025。 |
| `cache_id`           | String      | 字符串型，缓存标识串，参见:参考ID 30110                                                                                                                                                        |

返回：real，Real。

## `MODEOF(expression, bool_condition_exp, n, moving_first, cache_id)`

返回表达式中所有值的众数。 在一组数值中，众数是出现频率最高的数值，而中位数是位于中间的值，平均数是平均后的值，所有这些求中函数都不能单独地完全描绘所有数据。 例如，假设数据分布在三个区域中，其中一半分布在一个较小数值区中，另外一半分布在两个较大数值区中。函数 AVGOF 和函数 MEDIANOF 可能会返回位于数据点稀疏处的中间值；而函数 MODEOF 则会返回位于数据点密集处的较小值。

旧定义：`MODEOF ( Expression:TExpression[;BoolConditionExp:TExpression[;N:Integer[;MovingFirst:Bool[;CacheId:String]]]]) :real`

来源：TSL语言基础 > SQL基础到TS-SQL > TS-SQL语法 > SELECT查询语句 > 聚集函数

Source ID：30075

| 参数                 | 类型        | 说明                                                                                                                                                                                           |
| -------------------- | ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `expression`         | TExpression | Expression 是数字类型的表达式。参见多字段聚集。                                                                                                                                                |
| `bool_condition_exp` | TExpression | 布尔型表达式，如果存在该参数，则统计内容为该表达式为真的行，否则统计所有。                                                                                                                     |
| `n`                  | integer     | 整数，如果没有N参数，则统计对象为全部，否则统计对象为满足条件的从当前行起往前总共的N条记录, 如果为负数，则为从当前起往后总共\|N\|行。                                                          |
| `moving_first`       | Boolean     | 布尔型，为真表示统计内容为最近N条内符合BoolConditionExp条件的，为假表示统计内容为最近N条符合BoolConditionExp条件的。默认为假，此省略模式可以通过SelectOpt(64)进行变换，具体参见:参考ID 30025。 |
| `cache_id`           | String      | 字符串型，缓存标识串，参见: 参考ID 30110                                                                                                                                                       |

返回：real，Real。

## `RefMaxOf(expression, id_string)`

引用MaxOf最大值所在行。

旧定义：`RefMaxOF ( Expression:TExpression[;IdString:String] ) :Integer`

来源：TSL语言基础 > SQL基础到TS-SQL > TS-SQL语法 > SELECT查询语句 > 聚集函数

Source ID：30074

| 参数         | 类型        | 说明                                                                                                                                                                                                                                                                                                           |
| ------------ | ----------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `expression` | TExpression | Expression 数字类型的表达式。                                                                                                                                                                                                                                                                                  |
| `id_string`  | String      | 字符串型，标识串， 当使用MaxOf的时候，会查找到最大值，RefMaxOf则可以访问到最大值所在的行。一旦在同一条SQL里使用到多条MaxOf的时候，就需要用到标志串。该标志串在MaxOf的CacheId里设定，当CacheId以<MAXMIN=IdString/>开头，则表明IdString为指定的标志串。在RefMaxOf中用该串来定位该MaxOf所查找到的最大值所在的行。 |

返回：Integer，MaxOf最大值所在行。

## `RefMinOf(expression, id_string)`

引用MinOf最小值所在行。

旧定义：`RefMinOF ( Expression:TExpression[;IdString:String] ) :Integer`

来源：TSL语言基础 > SQL基础到TS-SQL > TS-SQL语法 > SELECT查询语句 > 聚集函数

Source ID：30073

| 参数         | 类型        | 说明                                                                                                                                                                                                                                                                                                           |
| ------------ | ----------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `expression` | TExpression | Expression 数字类型的表达式。                                                                                                                                                                                                                                                                                  |
| `id_string`  | String      | 字符串型，标识串， 当使用MinOf的时候，会查找到最小值，RefMinOf则可以访问到最小值所在的行。一旦在同一条SQL里使用到多条MinOf的时候，就需要用到标志串。该标志串在MinOf的CacheId里设定，当CacheId以<MAXMIN=IdString/>开头，则表明IdString为指定的标志串。在RefMinOf中用该串来定位该MinOf所查找到的最小值所在的行。 |

返回：Integer，MinOf最小值所在行。

## `MAXOF(expression, bool_condition_exp, n, moving_first, cache_id)`

返回表达式中所有值的最大值。

旧定义：`MAXOF (Expression:TExpression [;BoolConditionExp:TExpression[;N:Integer[;MovingFirst:Bool[;CacheId:String]]]]) :real`

来源：TSL语言基础 > SQL基础到TS-SQL > TS-SQL语法 > SELECT查询语句 > 聚集函数

Source ID：30072

| 参数                 | 类型        | 说明                                                                                                                                                                                           |
| -------------------- | ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `expression`         | TExpression | Expression 数字类型的表达式。参见多字段聚集。                                                                                                                                                  |
| `bool_condition_exp` | TExpression | 布尔型表达式，如果存在该参数，则统计内容为该表达式为真的行，否则统计所有。                                                                                                                     |
| `n`                  | integer     | 整数，如果没有N参数，则统计对象为全部，否则统计对象为满足条件的从当前行起往前总共的N条记录, 如果为负数，则为从当前起往后总共\|N\|行。                                                          |
| `moving_first`       | Boolean     | 布尔型，为真表示统计内容为最近N条内符合BoolConditionExp条件的，为假表示统计内容为最近N条符合BoolConditionExp条件的。默认为假，此省略模式可以通过SelectOpt(64)进行变换，具体参见:参考ID 30025。 |
| `cache_id`           | String      | 字符串型，缓存标识串，参见:参考ID 30110                                                                                                                                                        |

返回：real，Real。

## `MINOF(expression, bool_condition_exp, n, moving_first, cache_id)`

返回表达式中所有值的最小值。

旧定义：`MINOF (Expression:TExpression [;BoolConditionExp:TExpression[;N:Integer[;MovingFirst:Bool[;CacheId:String]]]] ) :real`

来源：TSL语言基础 > SQL基础到TS-SQL > TS-SQL语法 > SELECT查询语句 > 聚集函数

Source ID：30071

| 参数                 | 类型        | 说明                                                                                                                                                                                           |
| -------------------- | ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `expression`         | TExpression | Expression 数字类型的表达式。参见多字段聚集。                                                                                                                                                  |
| `bool_condition_exp` | TExpression | 布尔型表达式，如果存在该参数，则统计内容为该表达式为真的行，否则统计所有。                                                                                                                     |
| `n`                  | integer     | 整数，如果没有N参数，则统计对象为全部，否则统计对象为满足条件的从当前行起往前总共的N条记录, 如果为负数，则为从当前起往后总共\|N\|行。                                                          |
| `moving_first`       | Boolean     | 布尔型，为真表示统计内容为最近N条内符合BoolConditionExp条件的，为假表示统计内容为最近N条符合BoolConditionExp条件的。默认为假，此省略模式可以通过SelectOpt(64)进行变换，具体参见:参考ID 30025。 |
| `cache_id`           | String      | 字符串型，缓存标识串，参见:参考ID 30110                                                                                                                                                        |

返回：real，Real。

## `GEOMEANOF(expression, bool_condition_exp, n, moving_first, cache_id)`

返回组中值的几何平均值。空值将被忽略。调和平均值总小于几何平均值，而几何平均值总小于算术平均值。

旧定义：`GEOMEANOF (Expression:TExpression [;BoolConditionExp:TExpression[;N:Integer[;MovingFirst:Bool[;CacheId:String]]]] ) :real`

来源：TSL语言基础 > SQL基础到TS-SQL > TS-SQL语法 > SELECT查询语句 > 聚集函数

Source ID：30069

| 参数                 | 类型        | 说明                                                                                                                                                                                           |
| -------------------- | ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `expression`         | TExpression | 数字数据类型类别的表达式。参见多字段聚集。可在表达式前加关键字DISTINCT，表示不管该值出现了多少次，只使用每个值的唯一实例。不添加即统计所有。                                                   |
| `bool_condition_exp` | TExpression | 布尔型表达式，如果存在该参数，则统计内容为该表达式为真的行，否则统计所有。                                                                                                                     |
| `n`                  | integer     | 整数，如果没有N参数，则统计对象为全部，否则统计对象为满足条件的从当前行起往前总共的N条记录, 如果为负数，则为从当前起往后总共\|N\|行。                                                          |
| `moving_first`       | Boolean     | 布尔型，为真表示统计内容为最近N条内符合BoolConditionExp条件的，为假表示统计内容为最近N条符合BoolConditionExp条件的。默认为假，此省略模式可以通过SelectOpt(64)进行变换，具体参见:参考ID 30025。 |
| `cache_id`           | String      | 字符串型，缓存标识串，参见:参考ID 30110                                                                                                                                                        |

返回：real，Real。

## `HARMEANOF(expression, bool_condition_exp, n, moving_first, cache_id)`

返回组中值的调和平均值, 调和平均值与倒数的算术平均值互为倒数。空值将被忽略。调和平均值总小于几何平均值，而几何平均值总小于算术平均值。

旧定义：`HARMEANOF (Expression:TExpression [;BoolConditionExp:TExpression[;N:Integer[;MovingFirst:Bool[;CacheId:String]]]] ) :real`

来源：TSL语言基础 > SQL基础到TS-SQL > TS-SQL语法 > SELECT查询语句 > 聚集函数

Source ID：30068

| 参数                 | 类型        | 说明                                                                                                                                                                                           |
| -------------------- | ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `expression`         | TExpression | 数字数据类型类别的表达式。参见多字段聚集。可在表达式前加关键字DISTINCT，表示不管该值出现了多少次，只使用每个值的唯一实例。不添加即统计所有。                                                   |
| `bool_condition_exp` | TExpression | 布尔型表达式，如果存在该参数，则统计内容为该表达式为真的行，否则统计所有。                                                                                                                     |
| `n`                  | integer     | 整数，如果没有N参数，则统计对象为全部，否则统计对象为满足条件的从当前行起往前总共的N条记录, 如果为负数，则为从当前起往后总共\|N\|行。                                                          |
| `moving_first`       | Boolean     | 布尔型，为真表示统计内容为最近N条内符合BoolConditionExp条件的，为假表示统计内容为最近N条符合BoolConditionExp条件的。默认为假，此省略模式可以通过SelectOpt(64)进行变换，具体参见:参考ID 30025。 |
| `cache_id`           | String      | 字符串型，缓存标识串，参见:参考ID 30110                                                                                                                                                        |

返回：real，Real。

## `SMAOF(expression, m, bool_condition_exp, n, moving_first, cache_id)`

返回组中值的平滑移动平均值。不支持空值。

旧定义：`SMAOF (Expression:TExpression;M:Integer;BoolConditionExp:TExpression;N:Integer[;MovingFirst:Bool[;CacheId:String]] ) :real`

来源：TSL语言基础 > SQL基础到TS-SQL > TS-SQL语法 > SELECT查询语句 > 聚集函数

Source ID：30067

| 参数                 | 类型        | 说明                                                    |
| -------------------- | ----------- | ------------------------------------------------------- |
| `expression`         | TExpression | 数字数据类型类别的表达式。参见多字段聚集。              |
| `m`                  | integer     | 整数，权重。M必须小于N。                                |
| `bool_condition_exp` | TExpression | 布尔型表达式，统计内容为该表达式为真的行。              |
| `n`                  | integer     | 整数，统计对象为满足条件的从当前行起往前总共的N条记录。 |
| `moving_first`       | Boolean     | 布尔型，暂不支持，需设置为0或nil。                      |
| `cache_id`           | String      | 字符串型，缓存标识串，参见:参考ID 30110                 |

返回：real，Real。

## `EMAOF(expression, bool_condition_exp, n, moving_first, cache_id)`

返回组中值的指数平滑移动平均值。不支持空值。

旧定义：`EMAOF (Expression:TExpression;BoolConditionExp:TExpression;N:Integer[;MovingFirst:Bool[;CacheId:String]] ) :real`

来源：TSL语言基础 > SQL基础到TS-SQL > TS-SQL语法 > SELECT查询语句 > 聚集函数

Source ID：30066

| 参数                 | 类型        | 说明                                                                                             |
| -------------------- | ----------- | ------------------------------------------------------------------------------------------------ |
| `expression`         | TExpression | 数字数据类型类别的表达式。参见多字段聚集。                                                       |
| `bool_condition_exp` | TExpression | 布尔型表达式，统计内容为该表达式为真的行。                                                       |
| `n`                  | integer     | 整数，统计对象为满足条件的从当前行起往前总共的N条记录, 如果为负数，则为从当前起往后总共\|N\|行。 |
| `moving_first`       | Boolean     | 布尔型，暂不支持，需设置为0或nil。                                                               |
| `cache_id`           | String      | 字符串型，缓存标识串，参见:参考ID 30110                                                          |

返回：real，Real。

## `COUNTIFOF(expression, n, moving_first, cache_id)`

返回组中符合条件的数量。

旧定义：`COUNTIFOF (Expression:TExpression [;N:Integer][;MovingFirst:Bool][;CacheId:String]):Integer`

来源：TSL语言基础 > SQL基础到TS-SQL > TS-SQL语法 > SELECT查询语句 > 聚集函数

Source ID：30064

| 参数           | 类型        | 说明                                                                                                                        |
| -------------- | ----------- | --------------------------------------------------------------------------------------------------------------------------- |
| `expression`   | TExpression | 一个表达式，统计该表达式为真的个数。                                                                                        |
| `n`            | integer     | 整数，如果没有N参数，则统计对象为全部，否则统计对象为从当前行起往前总共的N条记录, 如果为负数，则为从当前起往后总共\|N\|行。 |
| `moving_first` | Boolean     | 布尔型，暂时无效。                                                                                                          |
| `cache_id`     | String      | String，缓存标识串，参见:参考ID 30110                                                                                       |

返回：integer，integer

## `REFOF(expression, n, bool_condition_exp)`

返回上一行的值。

旧定义：`REFOF (Expression: TExpression;N:Integer;[ BoolConditionExp:TExpression]):any`

来源：TSL语言基础 > SQL基础到TS-SQL > TS-SQL语法 > SELECT查询语句 > 聚集函数

Source ID：30063

| 参数                 | 类型        | 说明                                                                                                         |
| -------------------- | ----------- | ------------------------------------------------------------------------------------------------------------ |
| `expression`         | TExpression | 任意类型的表达式。                                                                                           |
| `n`                  | Integer     | 整数，在当前行前的第N条记录，如果为负数，则为后第\|N\|行。当N为0时，返回结果为本行，与BoolConditionExp无关。 |
| `bool_condition_exp` | TExpression | 布尔型表达式，如果存在该参数，则为满足该表达式为真的前第N行。                                                |

返回：any，Expression的计算结果类型决定。

## `COUNTOF(expression, arg)`

返回组中项目的数量。 COUNTOF( \* ) COUNTOF()返回组中项目的数量，这些项目包括 NULL 值和副本。 COUNTOF(Expression) 对组中的每一行都计算 Expression 并返回非空值的数量。 COUNTOF(DISTINCT Expression) 对组中的每一行都计算 Expression 并返回唯一非空值的数量。

旧定义：`COUNTOF (Expression \| * : TExpression]):Integer`

来源：TSL语言基础 > SQL基础到TS-SQL > TS-SQL语法 > SELECT查询语句 > 聚集函数

Source ID：30062

| 参数         | 类型        | 说明                                                                                                                                                                                                                                                                                                                  |
| ------------ | ----------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `expression` | TExpression | 一个表达式，计算其非空值的个数。可在表达式前加关键字DISTINCT，表示不管该值出现了多少次，只使用每个值的唯一实例。不添加即统计所有。                                                                                                                                                                                    |
| `arg`        | TExpression | 指定应该计算所有行以返回表中行的总数。COUNTOF(`_`) 不需要任何参数，而且不能与 DISTINCT 一起使用。COUNTOF(`_`) 不需要 Expression 参数，因为根据定义，该函数不使用有关任何特定列的信息。COUNTOF(`_`) 返回指定表中行的数量而不消除副本。它对每行分别进行计数，包括含有空值的行。如果不带任何参数的话，等同于COUNTOF(`_`) |

返回：integer，整型，非空值的数量
