试用 Microsoft Fabric 中的数据工厂 ，这是一种适用于企业的一站式分析解决方案。 Microsoft Fabric 涵盖了从数据移动到数据科学、实时分析、商业智能和报告的所有内容。 了解如何免费 开始新的试用 ！

数据流在 Azure 数据工厂和 Azure Synapse 管道中均可用。 本文适用于映射数据流。 如果不熟悉转换，请参阅介绍性文章 使用映射数据流转换数据 。

以下文章详细介绍了映射数据流中 Azure 数据工厂和 Azure Synapse Analytics 所支持的所有表达式和函数使用情况。 要简单了解所支持的各种函数类型，请参阅以下文章：

缓存的 lookup 函数

日期和时间函数

表达式函数

按字母顺序列出所有函数

下面按字母顺序列出了在映射数据流中可用的所有函数。

abs( <value1> : number) => number

数字的绝对值。

abs(-20) -> 20

abs(10) -> 10

acos( <value1> : number) => double

计算反余弦值。

acos(1) -> 0.0

add( <value1> : any, <value2> : any) => any

添加一对字符串或数字。 将日期添加到日期数。 将持续时间添加到时间戳。 将类似类型的数组追加到另一个数组。 与 + 运算符相同。

add(10, 20) -> 30

10 + 20 -> 30

add('ice', 'cream') -> 'icecream'

'ice' + 'cream' + ' cone' -> 'icecream cone'

add(toDate('2012-12-12'), 3) -> toDate('2012-12-15')

toDate('2012-12-12') + 3 -> toDate('2012-12-15')

[10, 20] + [30, 40] -> [10, 20, 30, 40]

toTimestamp('2019-02-03 05:19:28.871', 'yyyy-MM-dd HH:mm:ss.SSS') + (days(1) + hours(2) - seconds(10)) -> toTimestamp('2019-02-04 07:19:18.871', 'yyyy-MM-dd HH:mm:ss.SSS')

addDays

addDays( <date/timestamp> : datetime, <days to add> : integral) => datetime

将日期添加到日期或时间戳。 与日期的 + 运算符相同。

addDays(toDate('2016-08-08'), 1) -> toDate('2016-08-09')

addMonths

addMonths( <date/timestamp> : datetime, <months to add> : integral, [ <value3> : string]) => datetime

将月份添加到日期或时间戳。 可以选择性地传递时区。

addMonths(toDate('2016-08-31'), 1) -> toDate('2016-09-30')

addMonths(toTimestamp('2016-09-30 10:10:10'), -1) -> toTimestamp('2016-08-31 10:10:10')

and( <value1> : boolean, <value2> : boolean) => boolean

“逻辑与”运算符。 与 && 相同。

and(true, false) -> false

true && false -> false

approxDistinctCount

approxDistinctCount( <value1> : any, [ <value2> : double ]) => long

获取列的相异值的近似聚合计数。 可选的第二个参数用于控制估计误差。

approxDistinctCount(ProductID, .05) => long

array

array([ <value1> : any], ...) => array

创建项的数组。 所有项应属于同一类型。 如果未指定任何项，则默认值为空字符串数组。 与 [] 创建运算符相同。

array('Seattle', 'Washington')

['Seattle', 'Washington']

['Seattle', 'Washington'][1]

'Washington'

ascii

ascii( <Input> : string) => number

返回输入字符的数值。 如果输入字符串具有多个字符，则返回第一个字符的数值

ascii('A') -> 65

ascii('a') -> 97

asin( <value1> : number) => double

计算反正弦值。

asin(0) -> 0.0

assertErrorMessages

assertErrorMessages() => map

为将断言 ID 作为键的行返回所有错误消息的映射。

assertErrorMessages() => ['assert1': 'This row failed on assert1.', 'assert2': 'This row failed on assert2.']. In this example, at(assertErrorMessages(), 'assert1') would return 'This row failed on assert1.'

associate

reassociate( <value1> : map, <value2> : binaryFunction) => map

创建键/值的映射。 所有键和值应属于同一类型。 如果未指定任何项，则默认为字符串到字符串类型的映射。 与 [ -> ] 创建运算符相同。 键和值应该相互交替。

associate('fruit', 'apple', 'vegetable', 'carrot' )=> ['fruit' -> 'apple', 'vegetable' -> 'carrot']

at( <value1> : array/map, <value2> : integer/key type) => array

查找数组索引处的元素。 索引从 1 开始。 如果索引超出界限，则返回 null 值。 在给定了键的情况下，在映射中查找值。 如果未找到该键，则返回 NULL。

at(['apples', 'pears'], 1) => 'apples'

at(['fruit' -> 'apples', 'vegetable' -> 'carrot'], 'fruit') => 'apples'

atan( <value1> : number) => double

计算反正切值。

atan(0) -> 0.0

atan2

atan2( <value1> : number, <value2> : number) => double

返回平面正 X 轴与给定坐标点之间的弧角。

atan2(0, 0) -> 0.0

avg( <value1> : number) => number

获取列值的平均值。

avg(sales)

avgIf

avgIf( <value1> : boolean, <value2> : number) => number

根据条件获取列值的平均值。

avgIf(region == 'West', sales)

between

between( <value1> : any, <value2> : any, <value3> : any) => boolean

检查第一个值是否在两个其他值之间（含这两个值）。 可以比较数字、字符串和日期值

between(10, 5, 24)

between(currentDate(), currentDate() + 10, currentDate() + 20)

false

bitwiseAnd

bitwiseAnd( <value1> : integral, <value2> : integral) => integral

跨整数类型的位和运算符。 与 & 运算符相同

bitwiseAnd(0xf4, 0xef)

(0xf4 & 0xef)

bitwiseOr

bitwiseOr( <value1> : integral, <value2> : integral) => integral

跨整数类型的位或运算符。 与 | 运算符相同

bitwiseOr(0xf4, 0xef)

(0xf4 | 0xef)

bitwiseXor

bitwiseXor( <value1> : any, <value2> : any) => any

跨整数类型的位或运算符。 与 | 运算符相同

bitwiseXor(0xf4, 0xef)

(0xf4 ^ 0xef)

(true ^ false)

(true ^ true)

false

blake2b

blake2b( <value1> : integer, <value2> : any, ...) => string

如果位长度只能介于 8 到 512 之间，且是 8 的倍数，请为不同基元数据类型的列集计算 Blake2 摘要。 它可用于计算行的指纹

blake2b(256, 'gunchus', 8.2, 'bojjus', true, toDate('2010-4-4'))

'c9521a5080d8da30dffb430c50ce253c345cc4c4effc315dab2162dac974711d'

blake2bBinary

blake2bBinary( <value1> : integer, <value2> : any, ...) => binary

如果位长度只能介于 8 到 512 之间，且是 8 的倍数，请为不同基元数据类型的列集计算 Blake2 摘要。 它可用于计算行的指纹

blake2bBinary(256, 'gunchus', 8.2, 'bojjus', true, toDate('2010-4-4'))

unHex('c9521a5080d8da30dffb430c50ce253c345cc4c4effc315dab2162dac974711d')

byItem

byItem( <parent column> : any, <column name> : string) => any

在结构或结构的数组中查找子项。 如果有多个匹配项，则返回第一个匹配项。 如果没有匹配项，则返回 NULL 值。 返回的值必须是由某一种类型转换操作（? date、? string ...）转换的类型。在设计时已知的列名应该只按它们的名称进行寻址。 不支持计算输入，但可以使用参数替换

byItem( byName('customer'), 'orderItems') ? (itemName as string, itemQty as integer)

byItem( byItem( byName('customer'), 'orderItems'), 'itemName') ? string

byName

byName( <column name> : string, [ <stream name> : string]) => any

在流中按名称选择列值。 可以将可选流名称作为第二个参数传递。 如果有多个匹配项，则返回第一个匹配项。 如果没有匹配项，则返回 NULL 值。 返回的值必须是由某种类型转换函数（TO_DATE、TO_STRING...）转换的类型。设计时已知的列名应该只按名称进行寻址。 不支持计算输入，但可以使用参数替换。

toString(byName('parent'))

toLong(byName('income'))

toBoolean(byName('foster'))

toLong(byName($debtCol))

toString(byName('Bogus Column'))

toString(byName('Bogus Column', 'DeriveStream'))

byNames

byNames( <column names> : array, [ <stream name> : string]) => any

在流中按名称选择列的数组。 可以将可选流名称作为第二个参数传递。 如果有多个匹配项，则返回第一个匹配项。 如果列没有匹配项，则整个输出为 NULL 值。 返回值需要类型转换函数（toDate、toString...）。在设计时已知的列名应仅按名称进行寻址。 不支持计算输入，但可以使用参数替换。

toString(byNames(['parent', 'child']))

byNames(['parent']) ? string

toLong(byNames(['income']))

byNames(['income']) ? long

toBoolean(byNames(['foster']))

toLong(byNames($debtCols))

toString(byNames(['a Column']))

toString(byNames(['a Column'], 'DeriveStream'))

byNames(['orderItem']) ? (itemName as string, itemQty as integer)

byOrigin

byOrigin( <column name> : string, [ <origin stream name> : string]) => any

在源流中按名称选择列值。 第二个参数是源流名称。 如果有多个匹配项，则返回第一个匹配项。 如果没有匹配项，则返回 NULL 值。 返回的值必须是由某种类型转换函数（TO_DATE、TO_STRING...）转换的类型。设计时已知的列名应该只按名称进行寻址。 不支持计算输入，但可以使用参数替换。

toString(byOrigin('ancestor', 'ancestorStream'))

byOrigins

byOrigins( <column names> : array, [ <origin stream name> : string]) => any

在流中按名称选择列的数组。 第二个参数是其源流。 如果有多个匹配项，则返回第一个匹配项。 如果没有匹配项，则返回 NULL 值。 返回的值必须是由某种类型转换函数（TO_DATE、TO_STRING…）转换的类型设计时已知的列名应该只按名称进行寻址。 不支持计算输入，但可以使用参数替换。

toString(byOrigins(['ancestor1', 'ancestor2'], 'ancestorStream'))

byPath

byPath( <value1> : string, [ <streamName> : string]) => any

在流中按名称查找分层路径。 可以将可选流名称作为第二个参数传递。 如果找不到此类路径，则返回 NULL。 设计时已知的列名/路径应该仅通过其名称或点表示法路径来寻址。 不支持计算输入，但可以使用参数替换。

byPath('grandpa.parent.child') => column

byPosition

byPosition( <position> : integer) => any

根据列在流中的相对位置（从 1 开始）选择列值。 如果位置超出界限，则返回 NULL 值。 返回值必须是由类型转换函数之一转换的类型（TO_DATE，TO_STRING...）。不支持计算输入，但可以使用参数替换。

toString(byPosition(1))

toDecimal(byPosition(2), 10, 2)

toBoolean(byName(4))

toString(byName($colName))

toString(byPosition(1234))

case( <condition> : boolean, <true_expression> : any, <false_expression> : any, ...) => any

根据备用条件应用一个值或另一个值。 如果输入的数字是偶数，对于最后一个条件，另一个值将默认为 NULL。

case(10 + 20 == 30, 'dumbo', 'gumbo') -> 'dumbo'

case(10 + 20 == 25, 'bojjus', 'do' < 'go', 'gunchus') -> 'gunchus'

isNull(case(10 + 20 == 25, 'bojjus', 'do' > 'go', 'gunchus')) -> true

case(10 + 20 == 25, 'bojjus', 'do' > 'go', 'gunchus', 'dumbo') -> 'dumbo'

cbrt( <value1> : number) => double

计算一个数的立方根。

cbrt(8) -> 2.0

ceil( <value1> : number) => number

返回不小于该数字的最小整数。

ceil(-0.1) -> 0

char( <Input> : number) => string

返回由输入数字表示的 ascii 字符。 如果数字大于 256，则结果等效于 char(number % 256)

char(65) -> 'A'

char(97) -> 'a'

coalesce

coalesce( <value1> : any, ...) => any

返回一组输入中的第一个非 NULL 值。 所有输入应属于同一类型。

coalesce(10, 20) -> 10

coalesce(toString(null), toString(null), 'dumbo', 'bo', 'go') -> 'dumbo'

collect

collect( <value1> : any) => array

将聚合组中表达式的所有值收集到一个数组中。 在此过程中，可以收集结构并将其转换为备用结构。 项目数将等于该组中的行数，并且可以包含 NULL 值。 收集的项目数应较小。

collect(salesPerson)

collect(firstName + lastName))

collect(@(name = salesPerson, sales = salesAmount) )

collectUnique

collectUnique( <value1> : any) => array

将聚合组中表达式的所有值收集到一个唯一的数组中。 在此过程中，可以收集结构并将其转换为备用结构。 项目数将等于该组中的行数，并且可以包含 NULL 值。 收集的项目数应较小。

collect(salesPerson)

collect(firstName + lastName))

collect(@(name = salesPerson, sales = salesAmount) )

columnNames

columnNames( <value1> columnNames( : string, i><value1> : boolean) => array

获取流的所有输出列的名称。 可以传递一个可选的流名称来作为第一个参数。 第二个参数也是可选的，其默认值为 false。 如果将第二个参数设置为 true() ，则 ADF 将只返回通过架构偏差偏移的列。

columnNames()

columnNames('DeriveStream')

columnNames('DeriveStream', true())

columnNames('', true())

columns

columns([ <stream name> : string]) => any

获取流的所有输出列的值。 可以将可选流名称作为第二个参数传递。

columns()

columns('DeriveStream')

compare

compare( <value1> : any, <value2> : any) => integer

比较同一类型的两个值。 如果 value1 < value2，则返回负整数；如果 value1 == value2，则返回 0；如果 value1 > value2，则返回正值。

(compare(12, 24) < 1) -> true

(compare('dumbo', 'dum') > 0) -> true

concat

concat( <this> : string, <that> : string, ...) => string

将字符串的可变数字连接在一起。 与包含字符串的 + 运算符相同。

concat('dataflow', 'is', 'awesome') -> 'dataflowisawesome'

'dataflow' + 'is' + 'awesome' -> 'dataflowisawesome'

isNull('sql' + null) -> true

concatWS

concatWS( <separator> : string, <this> : string, <that> : string, ...) => string

使用分隔符将字符串的可变数字连接在一起。 第一个参数是分隔符。

concatWS(' ', 'dataflow', 'is', 'awesome') -> 'dataflow is awesome'

isNull(concatWS(null, 'dataflow', 'is', 'awesome')) -> true

concatWS(' is ', 'dataflow', 'awesome') -> 'dataflow is awesome'

contains

contains( <value1> : array, <value2> : unaryfunction) => boolean

如果所提供的数组中的任何元素在提供的谓词中计算结果为 true，则返回 true。 Contains 需要引用谓词函数中的一个元素作为 #item。

contains([1, 2, 3, 4], #item == 3) -> true

contains([1, 2, 3, 4], #item > 5) -> false

cos( <value1> : number) => double

计算余弦值。

cos(10) -> -0.8390715290764524

cosh( <value1> : number) => double

计算某个值的双曲余弦值。

cosh(0) -> 1.0

count

count([ <value1> : any]) => long

获取值的聚合计数。 如果指定了可选的列，则忽略计数中的 NULL 值。

count(custId)

count(custId, custName)

count()

count(iif(isNull(custId), 1, NULL))

countAll

countAll([ <value1> : any]) => long

获取包含 null 的值的聚合计数。

countAll(custId)

countAll()

countDistinct

countDistinct( <value1> : any, [ <value2> : any], ...) => long

获取列集的非重复值的聚合计数。

countDistinct(custId, custName)

countAllDistinct

countAllDistinct( <value1> : any, [ <value2> : any], ...) => long

获取包括 null 在内一组列的非重复值的聚合计数。

countAllDistinct(custId, custName)

countIf

countIf( <value1> : boolean, [ <value2> : any]) => long

根据条件获取值的聚合计数。 如果指定了可选的列，则忽略计数中的 NULL 值。

countIf(state == 'CA' && commission < 10000, name)

covariancePopulation

covariancePopulation( <value1> : number, <value2> : number) => double

获取两个列之间的总体协方差。

covariancePopulation(sales, profit)

covariancePopulationIf

covariancePopulationIf( <value1> : boolean, <value2> : number, <value3> : number) => double

根据条件获取两个列的总体协方差。

covariancePopulationIf(region == 'West', sales)

covarianceSample

covarianceSample( <value1> : number, <value2> : number) => double

获取两个列的样本协方差。

covarianceSample(sales, profit)

covarianceSampleIf

covarianceSampleIf( <value1> : boolean, <value2> : number, <value3> : number) => double

根据条件获取两个列的样本协方差。

covarianceSampleIf(region == 'West', sales, profit)

crc32

crc32( <value1> : any, ...) => long

根据位长度为不同基元数据类型的列集计算 CRC32 哈希（值只能为 0(256)、224、256、384、512）。 它可用于计算行的指纹。

crc32(256, 'gunchus', 8.2, 'bojjus', true, toDate('2010-4-4')) -> 3630253689L

cumeDist

cumeDist() => integer

CumeDist 函数计算某个值相对于分区中所有值的位置。 结果是前面的行数，或者等于当前行在分区中的顺序除以窗口分区中的总行数。 顺序中的任何关联值将计算为相同的位置。

cumeDist()

currentDate

currentDate([ <value1> : string]) => date

当此作业开始运行时获取当前日期。 可以“GMT”、“PST”、“UTC”、“America/Cayman”格式传递可选的时区。 使用数据工厂的数据中心/区域的本地时区作为默认时区。 请参阅 Java 的 SimpleDateFormat 类，了解可用格式。 https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html .

currentDate() == toDate('2250-12-31') -> false

currentDate('PST') == toDate('2250-12-31') -> false

currentDate('America/New_York') == toDate('2250-12-31') -> false

currentTimestamp

currentTimestamp() => timestamp

当作业开始运行时，获取采用当地时区的当前时间戳。

currentTimestamp() == toTimestamp('2250-12-31 12:12:12') -> false

currentUTC

currentUTC([ <value1> : string]) => timestamp

获取 UTC 格式的当前时间戳。 如果希望在与群集时区不同的时区中解释当前时间，则可以采用“GMT”、“PST”、“UTC”或“America/Cayman”格式传递一个可选时区。 默认使用当前时区。 请参阅 Java 的 SimpleDateFormat 类，了解可用格式。 https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html . 若要将 UTC 时间转换为其他时区，请使用 fromUTC() 。

currentUTC() == toTimestamp('2050-12-12 19:18:12') -> false

currentUTC() != toTimestamp('2050-12-12 19:18:12') -> true

fromUTC(currentUTC(), 'Asia/Seoul') != toTimestamp('2050-12-12 19:18:12') -> true

dayOfMonth

dayOfMonth( <value1> : datetime) => integer

获取给定日期的月份日期。

dayOfMonth(toDate('2018-06-08')) -> 8

dayOfWeek

dayOfWeek( <value1> : datetime) => integer

获取给定日期的星期日期。 1 - 星期日，2 - 星期一…7 - 星期六。

dayOfWeek(toDate('2018-06-08')) -> 6

dayOfYear

dayOfYear( <value1> : datetime) => integer

获取给定日期的年份日期。

dayOfYear(toDate('2016-04-09')) -> 100

days( <value1> : integer) => long

天数的持续时间（以毫秒为单位）。

days(2) -> 172800000L

decode

decode( <Input> : any, <Charset> : string) => binary

根据给定的字符集，将编码的输入数据解码为字符串。 第二个（可选）参数可用于指定要使用的字符集 -“US-ASCII”、“ISO-8859-1”、“UTF-8”（默认）、“UTF-16BE”、“UTF-16LE”、“UTF-16”

decode(array(toByte(97),toByte(98),toByte(99)), 'US-ASCII') -> abc

degrees

degrees( <value1> : number) => double

将弧度转换为度。

degrees(3.141592653589793) -> 180

denseRank

denseRank() => integer

计算在窗口的 order by 子句中指定的一组值中的值排名。 结果是 1 加上前面的行数，或者等于当前行在分区中的顺序。 这些值不会在序列中生成间隔。 即使数据未排序，也能进行密集排名，并且会查找值的变化。

denseRank()

distinct

distinct( <value1> : array) => array

返回数组中的相异项集。

distinct([10, 20, 30, 10]) => [10, 20, 30]

divide

divide( <value1> : any, <value2> : any) => any

将数字对相除。 与 / 运算符相同。

divide(20, 10) -> 2

20 / 10 -> 2

dropLeft

dropLeft( <value1> : string, <value2> : integer) => string

删除字符串左侧任意数目的字符。 如果请求删除的字符数超过了该字符串的长度，则返回空字符串。

dropLeft('bojjus', 2) => 'jjus'

dropLeft('cake', 10) => ''

dropRight

dropRight( <value1> : string, <value2> : integer) => string

删除字符串右侧任意数目的字符。 如果请求删除的字符数超过了该字符串的长度，则返回空字符串。

dropRight('bojjus', 2) => 'bojj'

dropRight('cake', 10) => ''

encode

encode( <Input> : string, <Charset> : string) => binary

根据字符集将输入字符串数据编码为二进制。 第二个（可选）参数可用于指定要使用的字符集 -“US-ASCII”、“ISO-8859-1”、“UTF-8”（默认）、“UTF-16BE”、“UTF-16LE”、“UTF-16”

encode('abc', 'US-ASCII') -> array(toByte(97),toByte(98),toByte(99))

输入字符串：string, Charset: string) => binary

endsWith

endsWith( <string> : string, <substring to check> : string) => boolean

检查字符串是否以提供的字符串结尾。

endsWith('dumbo', 'mbo') -> true

equals

equals( <value1> : any, <value2> : any) => boolean

“等于”比较运算符。 与 == 运算符相同。

equals(12, 24) -> false

12 == 24 -> false

'bad' == 'bad' -> true

isNull('good' == toString(null)) -> true

isNull(null == null) -> true

equalsIgnoreCase

equalsIgnoreCase( <value1> : string, <value2> : string) => boolean

忽略大小写的“等于”比较运算符。 与 <=> 运算符相同。

'abc'<=>'Abc' -> true

equalsIgnoreCase('abc', 'Abc') -> true

escape

escape( <string_to_escape> : string, <format> : string) => string

根据格式转义字符串。 可接受的格式的文本值为 "json"、"xml"、"ecmascript"、"html"、"java"。

except

except( <value1> : array, <value2> : array) => array

从另一组删除重复项中返回一个数组的差异集。

except([10, 20, 30], [20, 40]) => [10, 30]

expr( <expr> : string) => any

通过字符串生成一个表达式。 这与在非文本窗体中编写此表达式的效果一样。 这可以用来以字符串表示形式传递参数。

expr('price * discount') => any

factorial

factorial( <value1> : number) => long

计算一个数的阶乘。

factorial(5) -> 120

false

false() => boolean

始终返回 false 值。 如果存在名为“false”的列，请使用函数 syntax(false()) 。

(10 + 20 > 30) -> false

(10 + 20 > 30) -> false()

filter

filter( <value1> : array, <value2> : unaryfunction) => array

筛选数组中不符合所提供谓词的元素。 Filter 需要引用谓词函数中的一个元素作为 #item。

filter([1, 2, 3, 4], #item > 2) -> [3, 4]

filter(['a', 'b', 'c', 'd'], #item == 'a' || #item == 'b') -> ['a', 'b']

find( <value1> : array, <value2> : unaryfunction) => any

从与条件匹配的数组中查找第一项。 它采用筛选器函数，你可以在其中将数组中的项作为 #item 进行寻址。 对于深层嵌套的映射，可使用 #item_n(#item_1, #item_2...) 表示法引用父映射。

find([10, 20, 30], #item > 10) -> 20

find(['azure', 'data', 'factory'], length(#item) > 4) -> 'azure'

find([ @( name = 'Daniel', types = [ @(mood = 'jovial', behavior = 'terrific'), @(mood = 'grumpy', behavior = 'bad') ] ), @( name = 'Mark', types = [ @(mood = 'happy', behavior = 'awesome'), @(mood = 'calm', behavior = 'reclusive') ] ) ], contains(#item.types, #item.mood=='happy') /*Filter out the happy kid*/ )

@( name = 'Mark', types = [ @(mood = 'happy', behavior = 'awesome'), @(mood = 'calm', behavior = 'reclusive') ] )

first

first( <value1> : any, [ <value2> : boolean]) => any

获取列组的第一个值。 如果省略第二个参数 ignoreNulls，则假定为 false。

first(sales)

first(sales, false)

flatten

flatten( <array> : array, <value2> : array ..., <value2> : boolean) => array

将一个或多个数组平展成单个数组。 原子项数组将按原样返回。 最后一个参数是可选的，默认为 false，表示以递归方式平展多个层。

flatten([['bojjus', 'girl'], ['gunchus', 'boy']]) => ['bojjus', 'girl', 'gunchus', 'boy']

flatten([[['bojjus', 'gunchus']]] , true) => ['bojjus', 'gunchus']

floor

floor( <value1> : number) => number

返回不大于该数字的最大整数。

floor(-0.1) -> -1

fromBase64

fromBase64( <value1> : string, <encoding type> : string) => string

对给定的 base64 编码的字符串进行解码。 你可以选择传递编码类型。

fromBase64('Z3VuY2h1cw==') -> 'gunchus'

fromBase64('SGVsbG8gV29ybGQ=', 'Windows-1252') -> 'Hello World'

fromUTC

fromUTC( <value1> : timestamp, [ <value2> : string]) => timestamp

转换为 UTC 格式的时间戳。 可以选择以“GMT”、“PST”、“UTC”、“America/Cayman”格式传递时区。 默认使用当前时区。 请参阅 Java 的 SimpleDateFormat 类，了解可用格式。 https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html .

fromUTC(currentTimestamp()) == toTimestamp('2050-12-12 19:18:12') -> false

fromUTC(currentTimestamp(), 'Asia/Seoul') != toTimestamp('2050-12-12 19:18:12') -> true

greater

greater( <value1> : any, <value2> : any) => boolean

“大于”比较运算符。 与 > 运算符相同。

greater(12, 24) -> false

('dumbo' > 'dum') -> true

(toTimestamp('2019-02-05 08:21:34.890', 'yyyy-MM-dd HH:mm:ss.SSS') > toTimestamp('2019-02-03 05:19:28.871', 'yyyy-MM-dd HH:mm:ss.SSS')) -> true

greaterOrEqual

greaterOrEqual( <value1> : any, <value2> : any) => boolean

“大于等于”比较运算符。 与 >= 运算符相同。

greaterOrEqual(12, 12) -> true

('dumbo' >= 'dum') -> true

greatest

greatest( <value1> : any, ...) => any

返回输入值列表中的最大值，跳过 NULL 值。 如果所有输入均为 NULL，则返回 NULL。

greatest(10, 30, 15, 20) -> 30

greatest(10, toInteger(null), 20) -> 20

greatest(toDate('2010-12-12'), toDate('2011-12-12'), toDate('2000-12-12')) -> toDate('2011-12-12')

greatest(toTimestamp('2019-02-03 05:19:28.871', 'yyyy-MM-dd HH:mm:ss.SSS'), toTimestamp('2019-02-05 08:21:34.890', 'yyyy-MM-dd HH:mm:ss.SSS')) -> toTimestamp('2019-02-05 08:21:34.890', 'yyyy-MM-dd HH:mm:ss.SSS')

hasColumn

hasColumn( <column name> : string, [ <stream name> : string]) => boolean

在流中按名称检查列值。 可以将可选流名称作为第二个参数传递。 设计时已知的列名应该只按名称进行寻址。 不支持计算输入，但可以使用参数替换。

hasColumn('parent')

hasError

hasError([ <value1> : string]) => boolean

检查具有所提供 ID 的断言是否标记为错误。

hasError('assert1')

hasError('assert2')

hasPath

hasPath( <value1> : string, [ <streamName> : string]) => boolean

按名称检查流中是否存在某个分层路径。 可以将可选流名称作为第二个参数传递。 设计时已知的列名/路径应该仅通过其名称或点表示法路径来寻址。 不支持计算输入，但可以使用参数替换。

hasPath('grandpa.parent.child') => boolean

hex( <value1> : binary) => string

返回二进制值的十六进制字符串表示形式

hex(toBinary([toByte(0x1f), toByte(0xad), toByte(0xbe)])) -> '1fadbe'

hour( <value1> : timestamp, [ <value2> : string]) => integer

获取时间戳的小时值。 可以“GMT”、“PST”、“UTC”、“America/Cayman”格式传递可选的时区。 当地时区用作默认值。 请参阅 Java 的 SimpleDateFormat 类，了解可用格式。 https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html .

hour(toTimestamp('2009-07-30 12:58:59')) -> 12

hour(toTimestamp('2009-07-30 12:58:59'), 'PST') -> 12

hours

hours( <value1> : integer) => long

小时数的持续时间（以毫秒为单位）。

hours(2) -> 7200000L

iif( <condition> : boolean, <true_expression> : any, [ <false_expression> : any]) => any

根据条件应用一个值或另一个值。 如果未指定，则将其视为 NULL。 这两个值必须兼容（数字、字符串…）。

iif(10 + 20 == 30, 'dumbo', 'gumbo') -> 'dumbo'

iif(10 > 30, 'dumbo', 'gumbo') -> 'gumbo'

iif(month(toDate('2018-12-01')) == 12, 345.12, 102.67) -> 345.12

iifNull

iifNull( <value1> : any, [ <value2> : any], ...) => any

如果有两个或更多个输入，则返回第一个非 null 项。 此函数等效于联合。

iifNull(10, 20) -> 10

iifNull(null, 20, 40) -> 20

iifNull('azure', 'data', 'factory') -> 'azure'

iifNull(null, 'data', 'factory') -> 'data'

in( <array of items> : array, <item to find> : any) => boolean

检查某个项是否在数组中。

in([10, 20, 30], 10) -> true

in(['good', 'kid'], 'bad') -> false

initCap

initCap( <value1> : string) => string

将每个单词的第一个字母转换为大写。 通过空格分隔符识别单词。

initCap('cool iceCREAM') -> 'Cool Icecream'

instr

instr( <string> : string, <substring to find> : string) => integer

在字符串中查找子字符串的位置（从 1 开始）。 如果未找到，则返回 0。

instr('dumbo', 'mbo') -> 3

instr('microsoft', 'o') -> 5

instr('good', 'bad') -> 0

intersect

intersect( <value1> : array, <value2> : array) => array

返回 2 个数组中不同项的交集。

intersect([10, 20, 30], [20, 40]) => [20]

isBitSet

isBitSet ( <value1> : array, <value2> :integer ) => boolean

检查是否在此位集中设置了位的位置

isBitSet(toBitSet([10, 32, 98]), 10) => true

isBoolean

isBoolean( <value1> : string) => boolean

根据 toBoolean() 规则检查 string 值是否是 boolean 值

isBoolean('true') -> true

isBoolean('no') -> true

isBoolean('microsoft') -> false

isByte

isByte( <value1> : string) => boolean

根据 toByte() 规则检查 string 值是否是给定可选格式的 byte 值

isByte('123') -> true

isByte('chocolate') -> false

isDate

isDate ( <value1> : string, [<format>: string]) => boolean

使用可选输入日期格式检查输入日期字符串是否为日期。 有关可用格式，请参阅 Java 的 SimpleDateFormat。 如果省略输入日期格式，则默认格式为 yyyy-[M]M-[d]d 。 接受的格式为 [ yyyy, yyyy-[M]M, yyyy-[M]M-[d]d, yyyy-[M]M-[d]dT* ]

isDate('2012-8-18') -> true

isDate('12/18--234234' -> 'MM/dd/yyyy') -> false

isDecimal

isDecimal ( <value1> : string) => boolean

根据 toDecimal() 规则检查给定可选格式的字符串值是否为十进制值

isDecimal('123.45') -> true

isDecimal('12/12/2000') -> false

isDelete

isDelete([ <value1> : integer]) => boolean

检查该行是否标记为删除。 对于采用多个输入流的转换，可以传递流的（从 1 开始）索引。 流索引应为 1 或 2，默认值为 1。

isDelete()

isDelete(1)

isDistinct

isDistinct( <value1> : any , <value1> : any) => boolean

确定一列或一组列是否是非重复值。 它不会将 NULL 计为非重复值

isDistinct(custId, custName) => boolean

isDouble

isDouble ( <value1> : string, [<format>: string]) => boolean

根据 toDouble() 规则检查给定可选格式的字符串值是否为双精度值

isDouble('123') -> true

isDouble('$123.45' -> '$###.00') -> true

isDouble('icecream') -> false

isError

isError([ <value1> : integer]) => boolean

检查该行是否标记为错误。 对于采用多个输入流的转换，可以传递流的（从 1 开始）索引。 流索引应为 1 或 2，默认值为 1。

isError()

isError(1)

isFloat

isFloat ( <value1> : string, [<format>: string]) => boolean

根据 toFloat() 规则检查给定可选格式的字符串值是否为浮点值

isFloat('123') -> true

isFloat('$123.45' -> '$###.00') -> true

isFloat('icecream') -> false

isIgnore

isIgnore([ <value1> : integer]) => boolean

检查该行是否标记为忽略。 对于采用多个输入流的转换，可以传递流的（从 1 开始）索引。 流索引应为 1 或 2，默认值为 1。

isIgnore()

isIgnore(1)

isInsert

isInsert([ <value1> : integer]) => boolean

检查该行是否标记为插入。 对于采用多个输入流的转换，可以传递流的（从 1 开始）索引。 流索引应为 1 或 2，默认值为 1。

isInsert()

isInsert(1)

isInteger

isInteger ( <value1> : string, [<format>: string]) => boolean

根据 toInteger() 规则检查给定可选格式的字符串值是否为整数

isInteger('123') -> true

isInteger('$123' -> '$###') -> true

isInteger('microsoft') -> false

isLong

isLong ( <value1> : string, [<format>: string]) => boolean

根据 toLong() 规则检查给定可选格式的字符串值是否过长

isLong('123') -> true

isLong('$123' -> '$###') -> true

isLong('gunchus') -> false

isMatch

isMatch([ <value1> : integer]) => boolean

检查查找时是否匹配该行。 对于采用多个输入流的转换，可以传递流的（从 1 开始）索引。 流索引应为 1 或 2，默认值为 1。

isMatch()

isMatch(1)

isNan

isNan ( <value1> : integral) => boolean

检查这不是数字。

isNan(10.2) => false

isNull

isNull( <value1> : any) => boolean

检查值是否为 NULL。

isNull(NULL()) -> true

isNull('') -> false

isShort

isShort ( <value1> : string, [<format>: string]) => boolean

根据 toShort() 规则检查给定可选格式的字符串值是否过短

isShort('123') -> true

isShort('$123' -> '$###') -> true

isShort('microsoft') -> false

isTimestamp

isTimestamp ( <value1> : string, [<format>: string]) => boolean

使用可选输入时间戳格式检查输入日期字符串是否为时间戳。 有关可用格式，请参阅 Java 的 SimpleDateFormat。 如果省略时间戳，则使用默认模式 yyyy-[M]M-[d]d hh:mm:ss[.f...] 。 可以“GMT”、“PST”、“UTC”、“America/Cayman”格式传递可选的时区。 时间戳最多支持毫秒准确度，值为 999。有关可用格式，请参阅 Java 的 SimpleDateFormat。

isTimestamp('2016-12-31 00:12:00') -> true

isTimestamp('2016-12-31T00:12:00' -> 'yyyy-MM-dd\\'T\\'HH:mm:ss' -> 'PST') -> true

isTimestamp('2012-8222.18') -> false

isUpdate

isUpdate([ <value1> : integer]) => boolean

检查该行是否标记为更新。 对于采用多个输入流的转换，可以传递流的（从 1 开始）索引。 流索引应为 1 或 2，默认值为 1。

isUpdate()

isUpdate(1)

isUpsert

isUpsert([ <value1> : integer]) => boolean

检查该行是否标记为插入。 对于采用多个输入流的转换，可以传递流的（从 1 开始）索引。 流索引应为 1 或 2，默认值为 1。

isUpsert()

isUpsert(1)

jaroWinkler

jaroWinkler( <value1> : string, <value2> : string) => double

获取两个字符串之间的 JaroWinkler 距离。

jaroWinkler('frog', 'frog') => 1.0

keyValues

keyValues( <value1> : array, <value2> : array) => map

创建键/值的映射。 第一个参数是键数组，第二个参数是值数组。 这两个数组的长度应相等。

keyValues(['bojjus', 'appa'], ['gunchus', 'ammi']) => ['bojjus' -> 'gunchus', 'appa' -> 'ammi']

kurtosis

kurtosis( <value1> : number) => double

获取列的峰度。

kurtosis(sales)

kurtosisIf

kurtosisIf( <value1> : boolean, <value2> : number) => double

根据条件获取列的峰度。

kurtosisIf(region == 'West', sales)

lag( <value> : any, [ <number of rows to look before> : number], [ <default value> : any]) => any

获取当前行之前由第一个参数计算的 n 行的值。 第二个参数是要反向查找的行数，默认值为 1。 如果没有太多行数，则返回 NULL 值，除非指定了默认值。

lag(amount, 2)

lag(amount, 2000, 100)

last( <value1> : any, [ <value2> : boolean]) => any

获取列组的最后一个值。 如果省略第二个参数 ignoreNulls，则假定为 false。

last(sales)

last(sales, false)

lastDayOfMonth

lastDayOfMonth( <value1> : datetime) => date

获取给定日期的最后一个月份日期。

lastDayOfMonth(toDate('2009-01-12')) -> toDate('2009-01-31')

lead( <value> : any, [ <number of rows to look after> : number], [ <default value> : any]) => any

获取当前行之后由第一个参数计算的 n 行的值。 第二个参数是要正向查找的行数，默认值为 1。 如果没有太多行数，则返回 NULL 值，除非指定了默认值。

lead(amount, 2)

lead(amount, 2000, 100)

least

least( <value1> : any, ...) => any

“小于等于”比较运算符。 与 <= 运算符相同。

least(10, 30, 15, 20) -> 10

least(toDate('2010-12-12'), toDate('2011-12-12'), toDate('2000-12-12')) -> toDate('2000-12-12')

left( <string to subset> : string, <number of characters> : integral) => string

从索引 1 处开始提取包含字符数的子字符串。 与 SUBSTRING(str, 1, n) 相同。

left('bojjus', 2) -> 'bo'

left('bojjus', 20) -> 'bojjus'

length

length( <value1> : string) => integer

返回字符串的长度。

length('dumbo') -> 5

lesser

lesser( <value1> : any, <value2> : any) => boolean

“小于”比较运算符。 与 < 运算符相同。

lesser(12, 24) -> true

('abcd' < 'abc') -> false

(toTimestamp('2019-02-03 05:19:28.871', 'yyyy-MM-dd HH:mm:ss.SSS') < toTimestamp('2019-02-05 08:21:34.890', 'yyyy-MM-dd HH:mm:ss.SSS')) -> true

lesserOrEqual

lesserOrEqual( <value1> : any, <value2> : any) => boolean

“小于等于”比较运算符。 与 <= 运算符相同。

lesserOrEqual(12, 12) -> true

('dumbo' <= 'dum') -> false

levenshtein

levenshtein( <from string> : string, <to string> : string) => integer

获取两个字符串之间的 levenshtein 距离。

levenshtein('boys', 'girls') -> 4

like( <string> : string, <pattern match> : string) => boolean

模式是按原义匹配的字符串。 以下特殊符号除外：_ 匹配输入中的任何一个字符（类似于 posix 正则表达式中的 .）。% 匹配输入中的零个或多个字符（类似于 posix 正则表达式中的 .*）。 转义字符为 ''。 如果转义字符的之前带有特殊符号或其他转义字符，则在字面上匹配后面的字符。 转义其他任何字符的操作无效。

like('icecream', 'ice%') -> true

locate

locate( <substring to find> : string, <string> : string, [ <from index - 1-based> : integral]) => integer

从特定的位置开始，在字符串中查找子字符串的位置（从 1 开始）。 如果省略位置，则考虑字符串的开头。 如果未找到，则返回 0。

locate('mbo', 'dumbo') -> 3

locate('o', 'microsoft', 6) -> 7

locate('bad', 'good') -> 0

log( <value1> : number, [ <value2> : number]) => double

计算对数值。 可以提供可选的底，否则使用欧拉数。

log(100, 10) -> 2

log10

log10( <value1> : number) => double

以 10 为底计算对数值。

log10(100) -> 2

lookup

lookup(key, key2, ...) => complex[]

使用与缓存接收器中的键匹配的指定键查找缓存接收器中的第一行。

cacheSink#lookup(movieId)

lower

lower( <value1> : string) => string

将字符串小写。

lower('GunChus') -> 'gunchus'

lpad( <string to pad> : string, <final padded length> : integral, <padding> : string) => string

在左侧使用提供的填充内容填充字符串，直到达到特定的长度。 如果字符串等于或大于长度，则将其剪裁至该长度。

lpad('dumbo', 10, '-') -> '-----dumbo'

lpad('dumbo', 4, '-') -> 'dumb'

ltrim

ltrim( <string to trim> : string, [ <trim characters> : string]) => string

在左侧裁剪掉前导和尾随字符的字符串。 如果未指定第二个参数，则裁剪掉空格。 否则，剪裁掉第二个参数中指定的任何字符。

ltrim(' dumbo ') -> 'dumbo '

ltrim('!--!du!mbo!', '-!') -> 'du!mbo!'

map( <value1> : array, <value2> : unaryfunction) => any

使用提供的表达式将数组的每个元素映射到新元素。 Map 需要引用表达式函数中的一个元素作为 #item。

map([1, 2, 3, 4], #item + 2) -> [3, 4, 5, 6]

map(['a', 'b', 'c', 'd'], #item + '_processed') -> ['a_processed', 'b_processed', 'c_processed', 'd_processed']

mapAssociation

mapAssociation( <value1> : map, <value2> : binaryFunction) => array

通过将键关联到新值来转换映射。 返回数组。 它采用映射函数，可在其中将项处理为 #key，并将当前值处理为 #value。

mapAssociation(['bojjus' -> 'gunchus', 'appa' -> 'ammi'], @(key = #key, value = #value)) => [@(key = 'bojjus', value = 'gunchus'), @(key = 'appa', value = 'ammi')]

mapIf

mapIf ( <value1> : array, <value2> : binaryfunction, <value3>: binaryFunction) => any

有条件地将数组映射到长度相同或更短的另一个数组。 这些值可以是任何数据类型，包括 structTypes。 它采用一个映射函数，在其中可以将数组中的项作为 #item 进行寻址，将当前索引作为 #index 进行寻址。 对于深层嵌套的映射，可使用 #item_[n](#item_1, #index_1...) 表示法引用父映射。

mapIf([10, 20, 30], #item > 10, #item + 5) -> [25, 35]

mapIf(['icecream', 'cake', 'soda'], length(#item) > 4, upper(#item)) -> ['ICECREAM', 'CAKE']

mapIndex

mapIndex( <value1> : array, <value2> : binaryfunction) => any

使用提供的表达式将数组的每个元素映射到新元素。 Map 需要引用表达式函数中的一个元素作为 #item，并需要引用元素索引作为 #index。

mapIndex([1, 2, 3, 4], #item + 2 + #index) -> [4, 6, 8, 10]

mapLoop

mapLoop( <value1> : integer, <value2> : unaryfunction) => any

从 1 到某个长度进行循环，以创建具有该长度的数组。 它采用一个映射函数，在其中可以将数组中的索引作为 #index 进行寻址。 对于深层嵌套的映射，可使用 #index_n(#index_1, #index_2...) 表示法引用父映射。

mapLoop(3, #index * 10) -> [10, 20, 30]

max( <value1> : any) => any

获取列的最大值。

max(sales)

maxIf

maxIf( <value1> : boolean, <value2> : any) => any

根据条件获取列的最大值。

maxIf(region == 'West', sales)

md5( <value1> : any, ...) => string

为不同基元数据类型的列集计算 MD5 摘要，并返回 32 字符的十六进制字符串。 它可用于计算行的指纹。

md5(5, 'gunchus', 8.2, 'bojjus', true, toDate('2010-4-4')) -> '4ce8a880bd621a1ffad0bca905e1bc5a'

mean( <value1> : number) => number

获取列值的中间值。 与 AVG 相同。

mean(sales)

meanIf

meanIf( <value1> : boolean, <value2> : number) => number

根据条件获取列值的中间值。 与 avgIf 相同。

meanIf(region == 'West', sales)

millisecond

millisecond( <value1> : timestamp, [ <value2> : string]) => integer

获取日期的毫秒值。 可以“GMT”、“PST”、“UTC”、“America/Cayman”格式传递可选的时区。 当地时区用作默认值。 请参阅 Java 的 SimpleDateFormat 类，了解可用格式。 https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html .

millisecond(toTimestamp('2009-07-30 12:58:59.871', 'yyyy-MM-dd HH:mm:ss.SSS')) -> 871

milliseconds

milliseconds( <value1> : integer) => long

毫秒数的持续时间（以毫秒为单位）。

milliseconds(2) -> 2L

min( <value1> : any) => any

获取列的最小值。

min(sales)

minIf

minIf( <value1> : boolean, <value2> : any) => any

根据条件获取列的最小值。

minIf(region == 'West', sales)

minus

minus( <value1> : any, <value2> : any) => any

减去数字。 从日期数中减去日期。 从时间戳中减去持续时间。 减去两个时间戳以获取差异（以毫秒为单位）。 与 - 运算符相同。

minus(20, 10) -> 10

20 - 10 -> 10

minus(toDate('2012-12-15'), 3) -> toDate('2012-12-12')

toDate('2012-12-15') - 3 -> toDate('2012-12-12')

toTimestamp('2019-02-03 05:19:28.871', 'yyyy-MM-dd HH:mm:ss.SSS') + (days(1) + hours(2) - seconds(10)) -> toTimestamp('2019-02-04 07:19:18.871', 'yyyy-MM-dd HH:mm:ss.SSS')

toTimestamp('2019-02-03 05:21:34.851', 'yyyy-MM-dd HH:mm:ss.SSS') - toTimestamp('2019-02-03 05:21:36.923', 'yyyy-MM-dd HH:mm:ss.SSS') -> -2072

minute

minute( <value1> : timestamp, [ <value2> : string]) => integer

获取时间戳的分钟值。 可以“GMT”、“PST”、“UTC”、“America/Cayman”格式传递可选的时区。 当地时区用作默认值。 请参阅 Java 的 SimpleDateFormat 类，了解可用格式。 https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html .

minute(toTimestamp('2009-07-30 12:58:59')) -> 58

minute(toTimestamp('2009-07-30 12:58:59'), 'PST') -> 58

minutes

minutes( <value1> : integer) => long

分钟数的持续时间（以毫秒为单位）。

minutes(2) -> 120000L

mlookup

mlookup(key, key2, ...) => complex[]

使用与缓存接收器中的键匹配的指定键查找缓存接收器中的所有匹配行。

cacheSink#mlookup(movieId)

mod( <value1> : any, <value2> : any) => any

将数字对取模。 与 % 运算符相同。

mod(20, 8) -> 4

20 % 8 -> 4

month

month( <value1> : datetime) => integer

获取日期或时间戳的月份值。

month(toDate('2012-8-8')) -> 8

monthsBetween

monthsBetween( <from date/timestamp> : datetime, <to date/timestamp> : datetime, [ <roundoff> : boolean], [ <time zone> : string]) => double

获取两个日期之间的月数。 你可以采用四舍五入计算法。 可以“GMT”、“PST”、“UTC”、“America/Cayman”格式传递可选的时区。 当地时区用作默认值。 请参阅 Java 的 SimpleDateFormat 类，了解可用格式。 https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html .

monthsBetween(toTimestamp('1997-02-28 10:30:00'), toDate('1996-10-30')) -> 3.94959677

multiply

multiply( <value1> : any, <value2> : any) => any

将数字对相乘。 与 * 运算符相同。

multiply(20, 10) -> 200

20 * 10 -> 200

negate

negate( <value1> : number) => number

对数字求反。 将正数转换为负数，或反之。

negate(13) -> -13

nextSequence

nextSequence() => long

返回下一个唯一序列。 该数字仅在分区中是连续的，带有 partitionId 前缀。

nextSequence() == 12313112 -> false

normalize

normalize( <String to normalize> : string) => string

规范化字符串值以分隔重音的 unicode 字符。

regexReplace(normalize('bo²s'), `\p{M}`, '') -> 'boys'

not( <value1> : boolean) => boolean

逻辑求反运算符。

not(true) -> false

not(10 == 20) -> true

notEquals

notEquals( <value1> : any, <value2> : any) => boolean

“不等于”比较运算符。 与 != 运算符相同。

12 != 24 -> true

'bojjus' != 'bo' + 'jjus' -> false

nTile

nTile([ <value1> : integer]) => integer

NTile 函数将每个窗口分区的行分割为从 1 到 n 的 n 桶。 桶值最大相差 1。 如果分区中的行数未均匀划分为存储桶数，则从第一个存储桶开始，每个存储桶应分布一个余数值。 NTile 函数适合用于计算 tertiles 、四分位数、十分位数和其他常见的摘要统计数据。 在初始化期间，该函数将计算两个变量：常规桶的大小将额外添加一行。 这两个变量都以当前分区的大小为基础。 在计算过程中，该函数将跟踪当前行号、当前桶号，以及发生桶更改的行号 (bucketThreshold)。 如果当前行号达到桶的阈值，则桶值将会加 1，阈值将按桶大小增加（如果当前桶已填充，则额外加 1）。

nTile()

nTile(numOfBuckets)

null() => null

返回 NULL 值。 如果存在名为“NULL”的列，请使用函数 syntax(null()) 。 使用该函数的任何操作将导致 NULL。

isNull('dumbo' + null) -> true

isNull(10 * null) -> true

isNull('') -> false

isNull(10 + 20) -> false

isNull(10/0) -> true

or( <value1> : boolean, <value2> : boolean) => boolean

“逻辑或”运算符。 与 || 相同。

or(true, false) -> true

true || false -> true

originColumns

originColumns( <streamName> : string) => any

获取在其中创建列的源流的所有输出列。 必须包含在另一个函数中。

array(toString(originColumns('source1')))

output

output() => any

返回缓存接收器结果的第一行

cacheSink#output()

outputs

output() => any

返回缓存接收器结果的整个输出行集

cacheSink#outputs()

partitionId

partitionId() => integer

返回输入行所在的当前分区 ID。

partitionId()

pMod( <value1> : any, <value2> : any) => any

将数字对正数取模。

pmod(-20, 8) -> 4

power

power( <value1> : number, <value2> : number) => double

以一个数为底、另一数为幂求值。

power(10, 2) -> 100

radians

radians( <value1> : number) => double

将度数转换成弧度

radians(180) => 3.141592653589793

random

random( <value1> : integral) => long

返回给定分区内的可选种子的随机数。 种子应为固定值，应与 partitionId 一起用于生成随机值

random(1) == 1 -> false

rank() => integer

计算在窗口的 order by 子句中指定的一组值中的值排名。 结果是 1 加上前面的行数，或者等于当前行在分区中的顺序。 值将在序列中生成空隙。 即使数据未排序，也能进行排名，并且会查找值的变化。

rank()

reassociate

reassociate( <value1> : map, <value2> : binaryFunction) => map

通过将键关联到新值来转换映射。 它采用映射函数，可在其中将项处理为 #key，并将当前值处理为 #value。

reassociate(['fruit' -> 'apple', 'vegetable' -> 'tomato'], substring(#key, 1, 1) + substring(#value, 1, 1)) => ['fruit' -> 'fa', 'vegetable' -> 'vt']

reduce

reduce( <value1> : array, <value2> : any, <value3> : binaryfunction, <value4> : unaryfunction) => any

累积数组中的元素。 Reduce 需要引用第一个表达式函数中的累加器和一个元素作为 #acc 和 #item，并且需要在第二个表达式函数中使用生成值作为 #result。

toString(reduce(['1', '2', '3', '4'], '0', #acc + #item, #result)) -> '01234'

regexExtract

regexExtract( <string> : string, <regex to find> : string, [ <match group 1-based index> : integral]) => string

提取给定正则表达式模式的匹配子字符串。 最后一个参数标识匹配组，如果省略，则默认为 1。 使用 <regex> （反引号）匹配字符串且不进行转义。 索引 0 返回所有匹配项。 如果没有匹配组，索引 1 及以上索引将不会返回任何结果。

regexExtract('Cost is between 600 and 800 dollars', '(\\d+) and (\\d+)', 2) -> '800'

regexExtract('Cost is between 600 and 800 dollars', `(\d+) and (\d+)`, 2) -> '800'

regexMatch

regexMatch( <string> : string, <regex to match> : string) => boolean

检查字符串是否与给定的正则表达式模式相匹配。 使用 <regex> （反引号）匹配字符串且不进行转义。

regexMatch('200.50', '(\\d+).(\\d+)') -> true

regexMatch('200.50', `(\d+).(\d+)`) -> true

regexReplace

regexReplace( <string> : string, <regex to find> : string, <substring to replace> : string) => string

将给定字符串中出现的正则表达式模式全部替换为另一个子字符串。使用 <regex> （反引号）匹配字符串且不进行转义。

regexReplace('100 and 200', '(\\d+)', 'bojjus') -> 'bojjus and bojjus'

regexReplace('100 and 200', `(\d+)`, 'gunchus') -> 'gunchus and gunchus'

regexSplit

regexSplit( <string to split> : string, <regex expression> : string) => array

基于分隔符和正则表达式拆分字符串，并返回字符串数组。

regexSplit('bojjusAgunchusBdumbo', `[CAB]`) -> ['bojjus', 'gunchus', 'dumbo']

regexSplit('bojjusAgunchusBdumboC', `[CAB]`) -> ['bojjus', 'gunchus', 'dumbo', '']

(regexSplit('bojjusAgunchusBdumboC', `[CAB]`)[1]) -> 'bojjus'

isNull(regexSplit('bojjusAgunchusBdumboC', `[CAB]`)[20]) -> true

replace

replace( <string> : string, <substring to find> : string, [ <substring to replace> : string]) => string

将给定字符串中出现的一个子字符串全部替换为另一个子字符串。 如果省略最后一个参数，则默认为空字符串。

replace('doggie dog', 'dog', 'cat') -> 'catgie cat'

replace('doggie dog', 'dog', '') -> 'gie '

replace('doggie dog', 'dog') -> 'gie '

reverse

reverse( <value1> : string) => string

反转字符串。

reverse('gunchus') -> 'suhcnug'

right

right( <string to subset> : string, <number of characters> : integral) => string

从右侧提取包含字符数的子字符串。 与 SUBSTRING(str, LENGTH(str) - n, n) 相同。

right('bojjus', 2) -> 'us'

right('bojjus', 20) -> 'bojjus'

rlike

rlike( <string> : string, <pattern match> : string) => boolean

检查字符串是否与给定的正则表达式模式相匹配。

rlike('200.50', `(\d+).(\d+)`) -> true

rlike('bogus', `M[0-9]+.*`) -> false

round

round( <number> : number, [ <scale to round> : number], [ <rounding option> : integral]) => double

根据可选的小数位数和可选的舍入模式将数字四舍五入。 如果省略小数位，则默认为 0。 如果省略模式，则默认为 ROUND_HALF_UP(5)。 用于舍入的值包括

ROUND_UP - 此舍入模式朝远离零的方向进行舍入。

ROUND_DOWN - 此舍入模式朝靠近零的方向进行舍入。

ROUND_CEILING - 此舍入模式朝正无穷大方向进行舍入。 [如果输入为正，则与 ROUND_UP 相同。 如果输入为负，则行为与 ROUND_DOWN 相同。 Ex = -1.1 采用 ROUND_CEILING 模式时将为 -1.0，采用 ROUND_UP 模式时将为 -2。]

ROUND_FLOOR - 此舍入模式朝负无穷大方向进行舍入。 [如果输入为正，则与 ROUND_DOWN 相同。 如果输入为负，则行为与 ROUND_UP 相同]

ROUND_HALF_UP - 此舍入模式朝“最近的邻居”进行舍入，除非与两个邻居等距，在这种情况下将采用 ROUND_UP 模式。 [对于数据流，这是最常见且默认的舍入模式]。

ROUND_HALF_DOWN - 此舍入模式朝“最近的邻居”进行舍入，除非与两个邻居等距，在这种情况下将采用 ROUND_DOWN 模式。

ROUND_HALF_EVEN - 此舍入模式朝“最近的邻居”进行舍入，除非与两个邻居等距，在这种情况下将朝偶数邻居进行舍入。

ROUND_UNNECESSARY - 此舍入模式断言舍入操作具有确切结果，因此无需舍入。

round(100.123) -> 100.0

round(2.5, 0) -> 3.0

round(5.3999999999999995, 2, 7) -> 5.40

rowNumber

rowNumber() => integer

为窗口中的行分配一个顺序行号，从 1 开始。

rowNumber()

rpad( <string to pad> : string, <final padded length> : integral, <padding> : string) => string

在右侧使用提供的填充内容填充字符串，直到达到特定的长度。 如果字符串等于或大于长度，则将其剪裁至该长度。

rpad('dumbo', 10, '-') -> 'dumbo-----'

rpad('dumbo', 4, '-') -> 'dumb'

rpad('dumbo', 8, '<>') -> 'dumbo<><'

rtrim

rtrim( <string to trim> : string, [ <trim characters> : string]) => string

在右侧裁剪掉尾随字符的字符串。 如果未指定第二个参数，则裁剪掉空格。 否则，剪裁掉第二个参数中指定的任何字符。

rtrim(' dumbo ') -> ' dumbo'

rtrim('!--!du!mbo!', '-!') -> '!--!du!mbo'

second

second( <value1> : timestamp, [ <value2> : string]) => integer

获取日期的秒值。 可以“GMT”、“PST”、“UTC”、“America/Cayman”格式传递可选的时区。 当地时区用作默认值。 请参阅 Java 的 SimpleDateFormat 类，了解可用格式。 https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html .

second(toTimestamp('2009-07-30 12:58:59')) -> 59

seconds

seconds( <value1> : integer) => long

秒数的持续时间（以毫秒为单位）。

seconds(2) -> 2000L

setBitSet

setBitSet ( <value1> : array, <value2> :array) => array

在此位集中设置位的位置

setBitSet(toBitSet([10, 32]), [98]) => [4294968320L, 17179869184L]

sha1( <value1> : any, ...) => string

为不同基元数据类型的列集计算 SHA-1 摘要，并返回 40 字符的十六进制字符串。 它可用于计算行的指纹。

sha1(5, 'gunchus', 8.2, 'bojjus', true, toDate('2010-4-4')) -> '46d3b478e8ec4e1f3b453ac3d8e59d5854e282bb'

sha2( <value1> : integer, <value2> : any, ...) => string

根据位长度计算不同基元数据类型的列集的 SHA-2 摘要，值只能为 0(256)、224、256、384、512。 它可用于计算行的指纹。

sha2(256, 'gunchus', 8.2, 'bojjus', true, toDate('2010-4-4')) -> 'afe8a553b1761c67d76f8c31ceef7f71b66a1ee6f4e6d3b5478bf68b47d06bd3'

sin( <value1> : number) => double

计算正弦值。

sin(2) -> 0.9092974268256817

sinh( <value1> : number) => double

计算双曲正弦值。

sinh(0) -> 0.0

size( <value1> : any) => integer

查找数组或映射类型的大小

size(['element1', 'element2']) -> 2

size([1,2,3]) -> 3

skewness

skewness( <value1> : number) => double

获取列的偏度。

skewness(sales)

skewnessIf

skewnessIf( <value1> : boolean, <value2> : number) => double

根据条件获取列的偏度。

skewnessIf(region == 'West', sales)

slice

slice( <array to slice> : array, <from 1-based index> : integral, [ <number of items> : integral]) => array

从位置提取数组的子集。 位置从 1 开始。 如果省略长度，则默认为字符串的末尾。

slice([10, 20, 30, 40], 1, 2) -> [10, 20]

slice([10, 20, 30, 40], 2) -> [20, 30, 40]

slice([10, 20, 30, 40], 2)[1] -> 20

isNull(slice([10, 20, 30, 40], 2)[0]) -> true

isNull(slice([10, 20, 30, 40], 2)[20]) -> true

slice(['a', 'b', 'c', 'd'], 8) -> []

sort( <value1> : array, <value2> : binaryfunction) => array

使用提供的谓词函数对数组进行排序。 Sort 需要引用表达式函数中的两个连续元素作为 #item1 和 #item2。

sort([4, 8, 2, 3], compare(#item1, #item2)) -> [2, 3, 4, 8]

sort(['a3', 'b2', 'c1'], iif(right(#item1, 1) >= right(#item2, 1), 1, -1)) -> ['c1', 'b2', 'a3']

soundex

soundex( <value1> : string) => string

获取字符串的 soundex 代码。

soundex('genius') -> 'G520'

split

split( <string to split> : string, <split characters> : string) => array

基于分隔符拆分字符串，并返回字符串数组。

split('bojjus,guchus,dumbo', ',') -> ['bojjus', 'guchus', 'dumbo']

split('bojjus,guchus,dumbo', '|') -> ['bojjus,guchus,dumbo']

split('bojjus, guchus, dumbo', ', ') -> ['bojjus', 'guchus', 'dumbo']

split('bojjus, guchus, dumbo', ', ')[1] -> 'bojjus'

isNull(split('bojjus, guchus, dumbo', ', ')[0]) -> true

isNull(split('bojjus, guchus, dumbo', ', ')[20]) -> true

split('bojjusguchusdumbo', ',') -> ['bojjusguchusdumbo']

sqrt( <value1> : number) => double

计算一个数的平方根。

sqrt(9) -> 3

startsWith

startsWith( <string> : string, <substring to check> : string) => boolean

检查字符串是否以提供的字符串开头。

startsWith('dumbo', 'du') -> true

stddev

stddev( <value1> : number) => double

获取列的标准偏差。

stdDev(sales)

stddevIf

stddevIf( <value1> : boolean, <value2> : number) => double

根据条件获取列的标准偏差。

stddevIf(region == 'West', sales)

stddevPopulation

stddevPopulation( <value1> : number) => double

获取列的总体标准偏差。

stddevPopulation(sales)

stddevPopulationIf

stddevPopulationIf( <value1> : boolean, <value2> : number) => double

根据条件获取列的总体标准偏差。

stddevPopulationIf(region == 'West', sales)

stddevSample

stddevSample( <value1> : number) => double

获取列的样本标准偏差。

stddevSample(sales)

stddevSampleIf

stddevSampleIf( <value1> : boolean, <value2> : number) => double

根据条件获取列的样本标准偏差。

stddevSampleIf(region == 'West', sales)

subDays

subDays( <date/timestamp> : datetime, <days to subtract> : integral) => datetime

从日期或时间戳中减去天数。 与日期的 - 运算符相同。

subDays(toDate('2016-08-08'), 1) -> toDate('2016-08-07')

subMonths

subMonths( <date/timestamp> : datetime, <months to subtract> : integral) => datetime

从日期或时间戳中减去月份。

subMonths(toDate('2016-09-30'), 1) -> toDate('2016-08-31')

substring

substring( <string to subset> : string, <from 1-based index> : integral, [ <number of characters> : integral]) => string

从某个位置提取特定长度的子字符串。 位置从 1 开始。 如果省略长度，则默认为字符串的末尾。

substring('Cat in the hat', 5, 2) -> 'in'

substring('Cat in the hat', 5, 100) -> 'in the hat'

substring('Cat in the hat', 5) -> 'in the hat'

substring('Cat in the hat', 100, 100) -> ''

substringIndex

substringIndex( <string to subset> <delimiter> substringIndex( : string, : string, <count of delimiter occurences> : integral]) => string

提取第 count 次出现的分隔符之前的子字符串。 如果 count 为正，则返回最终的分隔符左侧的所有内容（从左侧开始计算）。 如果 count 为负，则返回最终的分隔符右侧的所有内容（从右侧开始计算）。

substringIndex('111-222-333', '-', 1) -> '111'

substringIndex('111-222-333', '-', 2) -> '111-222'

substringIndex('111-222-333', '-', -1) -> '333'

substringIndex('111-222-333', '-', -2) -> '222-333'

sum( <value1> : number) => number

获取数字列的聚合总数。

sum(col)

sumDistinct

sumDistinct( <value1> : number) => number

获取数字列的非重复值的聚合总数。

sumDistinct(col)

sumDistinctIf

sumDistinctIf( <value1> : boolean, <value2> : number) => number

根据条件获取数字列的聚合总数。 条件可以基于任何列。

sumDistinctIf(state == 'CA' && commission < 10000, sales)

sumDistinctIf(true, sales)

sumIf

sumIf( <value1> : boolean, <value2> : number) => number

根据条件获取数字列的聚合总数。 条件可以基于任何列。

sumIf(state == 'CA' && commission < 10000, sales)

sumIf(true, sales)

tan( <value1> : number) => double

计算正切值。

tan(0) -> 0.0

tanh( <value1> : number) => double

计算双曲正切值。

tanh(0) -> 0.0

toBase64

toBase64( <value1> : string, <encoding type> : string]) => string

以 base64 编码给定字符串。 你可以选择传递编码类型

toBase64('bojjus') -> 'Ym9qanVz'

toBase64('± 25000, € 5.000,- |', 'Windows-1252') -> 'sSAyNTAwMCwggCA1LjAwMCwtIHw='

toBinary

toBinary( <value1> : any) => binary

将任何数字/日期/时间戳/字符串转换为二进制表示形式。

toBinary(3) -> [0x11]

toBoolean

toBoolean( <value1> : string) => boolean

可将 ('t', 'true', 'y', 'yes', '1') 值转换为 true，将 ('f', 'false', 'n', 'no', '0') 值转换为 false，将其他任何值转换为 NULL。

toBoolean('true') -> true

toBoolean('n') -> false

isNull(toBoolean('truthy')) -> true

toByte

toByte( <value> : any, [ <format> : string], [ <locale> : string]) => byte

将任何数字或字符串转换为字节值。 可以使用可选的 Java 十进制格式进行转换。

toByte(123)

toByte(0xFF)

toByte('123')

toDate

toDate( <string> : any, [ <date format> : string]) => date

使用可选输入日期格式将输入日期字符串转换为日期。 请参阅 Java 的 SimpleDateFormat 类，了解可用格式。 如果省略输入日期格式，则默认格式为 yyyy-[M]M-[d]d。 接受的格式包括：[ yyyy、yyyy-[M]M、yyyy-[M]M-[d]d、yyyy-[M]M-[d]dT* ]。

toDate('2012-8-18') -> toDate('2012-08-18')

toDate('12/18/2012', 'MM/dd/yyyy') -> toDate('2012-12-18')

toDecimal

toDecimal( <value> : any, [ <precision> : integral], [ <scale> : integral], [ <format> : string], [ <locale> : string]) => decimal(10,0)

将任何数字或字符串转换为小数值。 如果未指定精度和小数位，则默认使用 (10,2)。 可以使用可选的 Java 十进制格式进行转换。 采用 BCP47 语言形式（如 en-US、de、zh-CN）的可选区域设置格式。

toDecimal(123.45) -> 123.45

toDecimal('123.45', 8, 4) -> 123.4500

toDecimal('$123.45', 8, 4,'$###.00') -> 123.4500

toDecimal('Ç123,45', 10, 2, 'Ç###,##', 'de') -> 123.45

toDouble

toDouble( <value> : any, [ <format> : string], [ <locale> : string]) => double

将任何数字或字符串转换为双精度值。 可以使用可选的 Java 十进制格式进行转换。 采用 BCP47 语言形式（如 en-US、de、zh-CN）的可选区域设置格式。

toDouble(123.45) -> 123.45

toDouble('123.45') -> 123.45

toDouble('$123.45', '$###.00') -> 123.45

toDouble('Ç123,45', 'Ç###,##', 'de') -> 123.45

toFloat

toFloat( <value> : any, [ <format> : string], [ <locale> : string]) => float

将任何数字或字符串转换为浮点值。 可以使用可选的 Java 十进制格式进行转换。 截断任何双精度数。

toFloat(123.45) -> 123.45f

toFloat('123.45') -> 123.45f

toFloat('$123.45', '$###.00') -> 123.45f

toInteger

toInteger( <value> : any, [ <format> : string], [ <locale> : string]) => integer

将任何数字或字符串转换为整数值。 可以使用可选的 Java 十进制格式进行转换。 截断任何长整型数、浮点数、双精度数。

toInteger(123) -> 123

toInteger('123') -> 123

toInteger('$123', '$###') -> 123

toLong

toLong( <value> : any, [ <format> : string], [ <locale> : string]) => long

将任何数字或字符串转换为长值。 可以使用可选的 Java 十进制格式进行转换。 截断任何浮点数、双精度数。

toLong(123) -> 123

toLong('123') -> 123

toLong('$123', '$###') -> 123

topN( <column/expression> : any, <count> : long, <n> : integer) => array

根据 count 自变量获取此列的前 N 个值。

topN(custId, count, 5)

topN(productId, num_sales, 10)

toShort

toShort( <value> : any, [ <format> : string], [ <locale> : string]) => short

将任何数字或字符串转换为短值。 可以使用可选的 Java 十进制格式进行转换。 截断任何整数、长整型数、浮点数、双精度数。

toShort(123) -> 123

toShort('123') -> 123

toShort('$123', '$###') -> 123

toString

toString( <value> : any, [ <number format/date format> : string], [ <date locale> : string]) => string

将基元数据类型转换为字符串。 对于数字和日期，可以指定格式。 如果未指定，则选择系统默认值。对数字使用 Java 十进制格式。 有关所有可能的日期格式，请参阅 Java SimpleDateFormat；默认格式为 yyyy-MM-dd。 可以选择为日期或时间戳指定区域设置。

toString(10) -> '10'

toString('engineer') -> 'engineer'

toString(123456.789, '##,###.##') -> '123,456.79'

toString(123.78, '000000.000') -> '000123.780'

toString(12345, '##0.#####E0') -> '12.345E3'

toString(toDate('2018-12-31')) -> '2018-12-31'

isNull(toString(toDate('2018-12-31', 'MM/dd/yy'))) -> true

toString(4 == 20) -> 'false'

toString(toDate('12/31/18', 'MM/dd/yy', 'es-ES'), 'MM/dd/yy', 'de-DE')

toTimestamp

toTimestamp( <string> : any, [ <timestamp format> : string], [ <time zone> : string]) => timestamp

根据可选的时间戳格式将字符串转换为时间戳。 如果省略时间戳，则使用默认模式 yyyy-[M]M-[d]d hh:mm:ss[.f...]。 可以“GMT”、“PST”、“UTC”、“America/Cayman”格式传递可选的时区。 时间戳支持高达 999 毫秒的精度值。 请参阅 Java 的 SimpleDateFormat 类，了解可用格式。 https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html .

toTimestamp('2016-12-31 00:12:00') -> toTimestamp('2016-12-31 00:12:00')

toTimestamp('2016-12-31T00:12:00', 'yyyy-MM-dd\'T\'HH:mm:ss', 'PST') -> toTimestamp('2016-12-31 00:12:00')

toTimestamp('12/31/2016T00:12:00', 'MM/dd/yyyy\'T\'HH:mm:ss') -> toTimestamp('2016-12-31 00:12:00')

millisecond(toTimestamp('2019-02-03 05:19:28.871', 'yyyy-MM-dd HH:mm:ss.SSS')) -> 871

toUTC

toUTC( <value1> : timestamp, [ <value2> : string]) => timestamp

将时间戳转换为 UTC。 可以“GMT”、“PST”、“UTC”、“America/Cayman”格式传递可选的时区。 默认使用当前时区。 请参阅 Java 的 SimpleDateFormat 类，了解可用格式。 https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html .

toUTC(currentTimestamp()) == toTimestamp('2050-12-12 19:18:12') -> false

toUTC(currentTimestamp(), 'Asia/Seoul') != toTimestamp('2050-12-12 19:18:12') -> true

translate

translate( <string to translate> : string, <lookup characters> : string, <replace characters> : string) => string

将字符串中的一组字符替换为另一组字符。 对字符进行 1 对 1 的替换.

translate('(bojjus)', '()', '[]') -> '[bojjus]'

translate('(gunchus)', '()', '[') -> '[gunchus'

trim( <string to trim> : string, [ <trim characters> : string]) => string

裁剪掉前导和尾随字符的字符串。 如果未指定第二个参数，则裁剪掉空格。 否则，剪裁掉第二个参数中指定的任何字符。

trim(' dumbo ') -> 'dumbo'

trim('!--!du!mbo!', '-!') -> 'dumbo'

true() => boolean

始终返回 true 值。 如果存在名为“true”的列，请使用函数 syntax(true()) 。

(10 + 20 == 30) -> true

(10 + 20 == 30) -> true()

typeMatch

typeMatch( <type> : string, <base type> : string) => boolean

匹配列的类型。 只可在模式表达式中使用。number 匹配短整型数、整数、长整型数、双精度数、浮点数或小数，integral 匹配短整型数、整数、长整型数，fractional 匹配双精度数、浮点数、小数，datetime 匹配日期或时间戳类型。

typeMatch(type, 'number')

typeMatch('date', 'datetime')

unescape

unescape( <string_to_escape> : string, <format> : string) => string

根据格式取消转义字符串。 可接受的格式的文本值为 "json"、"xml"、"ecmascript"、"html"、"java"。

unescape('{\\\\\"value\\\\\": 10}', 'json')

'{\\\"value\\\": 10}'

unfold

unfold ( <value1> : array) => any

将数组展开为一组行并在每行中重复剩余列的值。

unfold(addresses) => any

unfold( @(name = salesPerson, sales = salesAmount) ) => any

unhex

unhex( <value1> : string) => binary

对字符串表示形式的二进制值进行反向十六进制转换。 这可与 sha2、md5 一起用于从字符串转换为二进制表示法

unhex('1fadbe') -> toBinary([toByte(0x1f), toByte(0xad), toByte(0xbe)])

unhex(md5(5, 'gunchus', 8.2, 'bojjus', true, toDate('2010-4-4'))) -> toBinary([toByte(0x4c),toByte(0xe8),toByte(0xa8),toByte(0x80),toByte(0xbd),toByte(0x62),toByte(0x1a),toByte(0x1f),toByte(0xfa),toByte(0xd0),toByte(0xbc),toByte(0xa9),toByte(0x05),toByte(0xe1),toByte(0xbc),toByte(0x5a)])

union

union( <value1> : array, <value2> : array) => array

返回 2 个数组中不同项的并集。

union([10, 20, 30], [20, 40]) => [10, 20, 30, 40]

upper

upper( <value1> : string) => string

将字符串大写。

upper('bojjus') -> 'BOJJUS'

uuid() => string

返回生成的 UUID。

uuid()

variance

variance( <value1> : number) => double

获取列的方差。

variance(sales)

varianceIf

varianceIf( <value1> : boolean, <value2> : number) => double

根据条件获取列的方差。

varianceIf(region == 'West', sales)

variancePopulation

variancePopulation( <value1> : number) => double

获取列的总体方差。

variancePopulation(sales)

variancePopulationIf

variancePopulationIf( <value1> : boolean, <value2> : number) => double

根据条件获取列的总体方差。

variancePopulationIf(region == 'West', sales)

varianceSample

varianceSample( <value1> : number) => double

获取列的无偏方差。

varianceSample(sales)

varianceSampleIf

varianceSampleIf( <value1> : boolean, <value2> : number) => double

根据条件获取列的无偏方差。

varianceSampleIf(region == 'West', sales)

weekOfYear

weekOfYear( <value1> : datetime) => integer

获取给定日期的年份周次。

weekOfYear(toDate('2008-02-20')) -> 8

weeks

weeks( <value1> : integer) => long

周数的持续时间（以毫秒为单位）。

weeks(2) -> 1209600000L

xor( <value1> : boolean, <value2> : boolean) => boolean

逻辑 XOR 运算符。 与 ^ 运算符相同。

xor(true, false) -> true

xor(true, true) -> false

true ^ false -> true

year( <value1> : datetime) => integer

获取日期的年份值。

year(toDate('2012-8-8')) -> 2012

所有 聚合函数 的列表。

所有 数组函数 的列表。

所有 高速缓存的查找函数 的列表。

所有 转换函数 的列表。

所有 日期和时间函数 的列表。

所有 表达式函数 的列表。

所有 地图函数 的列表。

所有 元函数 的列表。

所有 窗口函数 的列表。

了解如何使用表达式生成器 。