映射数据流中的数据转换表达式使用情况

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

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

endsWith

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

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

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

equals

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

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

• equals(12, 24) -> false
• 12 == 24 -> false
• 'bad' == 'bad' -> true
• isNull('good' == toString(null)) -> true
• isNull(null == null) -> true

equalsIgnoreCase

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

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

• 'abc'<=>'Abc' -> true
• equalsIgnoreCase('abc', 'Abc') -> true

escape

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

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

except

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

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

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

expr

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

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

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

isBitSet

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

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

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

isBoolean

isBoolean(<value1>: string) => boolean

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

• isBoolean('true') -> true
• isBoolean('no') -> true
• isBoolean('microsoft') -> false

isByte

isByte(<value1> : string) => boolean

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

• isByte('123') -> true
• isByte('chocolate') -> false

isDate

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

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

• isDate('2012-8-18') -> true
• isDate('12/18--234234' -> 'MM/dd/yyyy') -> false

isDecimal

isDecimal (<value1> : string) => boolean

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

• isDecimal('123.45') -> true
• isDecimal('12/12/2000') -> false

isDelete

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

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

• isDelete()
• isDelete(1)

isDistinct

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

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

• isDistinct(custId, custName) => boolean

isDouble

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

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

• isDouble('123') -> true
• isDouble('$123.45' -> '$###.00') -> true
• isDouble('icecream') -> false

isError

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

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

• isError()
• isError(1)

isFloat

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

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

• isFloat('123') -> true
• isFloat('$123.45' -> '$###.00') -> true
• isFloat('icecream') -> false

isIgnore

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

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

• isIgnore()
• isIgnore(1)

isInsert

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

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

• isInsert()
• isInsert(1)

isInteger

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

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

• isInteger('123') -> true
• isInteger('$123' -> '$###') -> true
• isInteger('microsoft') -> false

isLong

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

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

• isLong('123') -> true
• isLong('$123' -> '$###') -> true
• isLong('gunchus') -> false

isMatch

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

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

• isMatch()
• isMatch(1)

isNan

isNan (<value1> : integral) => boolean

检查这不是数字。

• isNan(10.2) => false

isNull

isNull(<value1> : any) => boolean

检查值是否为 NULL。

• isNull(NULL()) -> true
• isNull('') -> false

isShort

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

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

• isShort('123') -> true
• isShort('$123' -> '$###') -> true
• isShort('microsoft') -> false

isTimestamp

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

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

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

isUpdate

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

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

• isUpdate()
• isUpdate(1)

isUpsert

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

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

• isUpsert()
• isUpsert(1)

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)。 用于舍入的值包括

1. ROUND_UP - 此舍入模式朝远离零的方向进行舍入。
2. ROUND_DOWN - 此舍入模式朝靠近零的方向进行舍入。
3. ROUND_CEILING - 此舍入模式朝正无穷大方向进行舍入。 [如果输入为正，则与 ROUND_UP 相同。 如果输入为负，则行为与 ROUND_DOWN 相同。 Ex = -1.1 采用 ROUND_CEILING 模式时将为 -1.0，采用 ROUND_UP 模式时将为 -2。]
4. ROUND_FLOOR - 此舍入模式朝负无穷大方向进行舍入。 [如果输入为正，则与 ROUND_DOWN 相同。 如果输入为负，则行为与 ROUND_UP 相同]
5. ROUND_HALF_UP - 此舍入模式朝“最近的邻居”进行舍入，除非与两个邻居等距，在这种情况下将采用 ROUND_UP 模式。 [对于数据流，这是最常见且默认的舍入模式]。
6. ROUND_HALF_DOWN - 此舍入模式朝“最近的邻居”进行舍入，除非与两个邻居等距，在这种情况下将采用 ROUND_DOWN 模式。
7. ROUND_HALF_EVEN - 此舍入模式朝“最近的邻居”进行舍入，除非与两个邻居等距，在这种情况下将朝偶数邻居进行舍入。
8. 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 为负，则返回最终的分隔符右侧的所有内容（从右侧开始计算）。