映射数据流中的数据转换表达式用法
适用于: 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
相关内容