你当前正在访问 Microsoft Azure Global Edition 技术文档网站。如果需要访问由世纪互联运营的 Microsoft Azure 中国技术文档网站，请访问 https://docs.azure.cn。

映射数据流中的数据转换表达式用法

项目
09/25/2024

适用于： Azure 数据工厂 Azure Synapse Analytics

提示

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

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

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

按字母顺序列出所有函数

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

A

`abs`

abs(<value1> : number) => number

数字的绝对值。

abs(-20) -> 20
abs(10) -> 10

`acos`

acos(<value1> : number) => double

计算反余弦值。

acos(1) -> 0.0

`add`

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`

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`

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`

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`

atan(<value1> : number) => double

计算反正切值。

atan(0) -> 0.0

`atan2`

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

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

atan2(0, 0) -> 0.0

`avg`

avg(<value1> : number) => number

获取列值的平均值。

avg(sales)

`avgIf`

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

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

avgIf(region == 'West', sales)

B

`between`

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

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

between(10, 5, 24)
true
between(currentDate(), currentDate() + 10, currentDate() + 20)
false

`bitwiseAnd`

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

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

bitwiseAnd(0xf4, 0xef)
0xe4
(0xf4 & 0xef)
0xe4

`bitwiseOr`

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

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

bitwiseOr(0xf4, 0xef)
0xff
(0xf4 | 0xef)
0xff

`bitwiseXor`

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

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

bitwiseXor(0xf4, 0xef)
0x1b
(0xf4 ^ 0xef)
0x1b
(true ^ false)
true
(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))

C

`case`

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`

cbrt(<value1> : number) => double

计算一个数的立方根。

cbrt(8) -> 2.0

`ceil`

ceil(<value1> : number) => number

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

ceil(-0.1) -> 0

`char`

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()，则数据工厂只返回通过架构偏差偏移的列。



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
cos(<value1> : number) => double


计算余弦值。

cos(10) -> -0.8390715290764524



cosh
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


D

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
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) => ''


E

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))



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(<expr> : string) => any


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

expr('price * discount') => any


F

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
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


G

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')


H

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
hex(<value1>: binary) => string


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

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



hour
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


I

iif
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
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


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

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)


J

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


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

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


K

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)


L

lag
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
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
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
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
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
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
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!'


M

map
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
max(<value1> : any) => any


获取列的最大值。

max(sales)



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


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

maxIf(region == 'West', sales)



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


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

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



mean
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
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
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


N

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
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 值。 如果存在名为“NULL”的列，请使用函数 syntax(null())。 使用该函数的任何操作将导致 NULL。

isNull('dumbo' + null) -> true
isNull(10 * null) -> true
isNull('') -> false
isNull(10 + 20) -> false
isNull(10/0) -> true


O

or
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()


P

partitionId
partitionId() => integer


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

partitionId()



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


将数字对正数取模。

pmod(-20, 8) -> 4



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


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

power(10, 2) -> 100


R

radians
radians(<value1> : number) => double


将度数转换成弧度

radians(180) => 3.141592653589793



random
random(<value1> : integral) => long


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

random(1) == 1 -> false



rank
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
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'


S

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
sha1(<value1> : any, ...) => string


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

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



sha2
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
sin(<value1> : number) => double


计算正弦值。

sin(2) -> 0.9092974268256817



sinh
sinh(<value1> : number) => double


计算双曲正弦值。

sinh(0) -> 0.0



size
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
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
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
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)


T

tan
tan(<value1> : number) => double


计算正切值。

tan(0) -> 0.0



tanh
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)
123
toByte(0xFF)
-1
toByte('123')
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
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
trim(<string to trim> : string, [<trim characters> : string]) => string


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

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



true
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')


U

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
uuid() => string


返回生成的 UUID。

uuid()


V

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)


W

weekOfYear
weekOfYear(<value1> : datetime) => integer


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

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



weeks
weeks(<value1> : integer) => long


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

weeks(2) -> 1209600000L


X

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


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

xor(true, false) -> true
xor(true, true) -> false
true ^ false -> true


Y

year
year(<value1> : datetime) => integer


获取日期的年份值。

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

相关内容

所有聚合函数的列表。
所有数组函数的列表。
所有高速缓存的查找函数的列表。
所有转换函数的列表。
所有 日期和时间函数的列表。
所有表达式函数的列表。
所有 地图函数的列表。
所有元函数的列表。
所有窗口函数的列表。
了解如何使用表达式生成器。