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

• 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。 Th 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传递可选时区：、PSTUTC或America/Cayman。 数据工厂数据中心/区域的本地时区用作默认值。 有关可用格式，请参阅 Java 的 SimpleDateFormat 类。

• 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传递可选时区：或PSTUTCAmerica/Cayman。 它默认为当前时区。 有关可用格式，请参阅 Java 的 SimpleDateFormat 类。 若要将 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 函数也能正常工作。

• 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 值。 如果某列的名称是syntax(false())，请使用函数false。

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

filter

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

筛选数组中不符合所提供谓词的元素。 筛选器期望谓词函数中一个元素的引用作为 #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_1， #item_2...） 表示法来引用父映射 #item_n 。

• 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 类。

• 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 的资产是否被标记为错误状态。

Examples

• 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传递可选时区：、PSTUTC或America/Cayman。 本地时区用作默认值。 有关可用格式，请参阅 Java 的 SimpleDateFormat 类。

• 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 项。 此函数等效于函数 coalesce 。

• 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()检查字符串值是否为布尔值。

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

isByte

isByte(<value1> : string) => boolean

当给定一个可选格式时，根据toByte()的规则检查字符串值是否为字节值。

• 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为基点）。 流索引应为或 12，默认值为 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 开始计数的）索引。 流索引应为或 12，默认值为 1。

• isIgnore()
• isIgnore(1)

isInsert

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

检查该行是否标记为插入。 对于涉及多个输入流的转换，可以传递流的（从 1 开始计数的）索引。 流索引应为或 12，默认值为 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 开始计数的）索引。 流索引应为或 12，默认值为 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传递可选时区：、PSTUTC或America/Cayman。 该 timestamp 函数支持高达毫秒的准确性，值为 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 开始计数的）索引。 流索引应为或 12，默认值为 1。

• isUpdate()
• isUpdate(1)

isUpsert

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

检查该行是否标记为插入。 对于涉及多个输入流的转换，可以传递流的（从 1 开始计数的）索引。 流索引应为或 12，默认值为 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

计算日志值。 可以使用可选基数，或者提供 Euler 编号（如果已使用）。

• 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传递可选时区：、PSTUTC或America/Cayman。 本地时区用作默认值。 有关可用格式，请参阅 Java 的 SimpleDateFormat 类。

• 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传递可选时区：、PSTUTC或America/Cayman。 本地时区用作默认值。 有关可用格式，请参阅 Java 的 SimpleDateFormat 类。

• 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传递可选时区：、PSTUTC或America/Cayman。 本地时区用作默认值。 有关可用格式，请参阅 Java 的 SimpleDateFormat 类。

• 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

返回下一个唯一序列。 该数字仅在分区内连续，并且以分区 ID 为前缀。

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

• nTile()
• nTile(numOfBuckets)

null

null() => null

返回一个 NULL 值。 如果某列的名称是syntax(null())，请使用函数null。 使用 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 运算符。 与 ||相同。

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

当在分区中给定种子时返回一个随机数。 种子应为固定值，并与分区 ID 一起使用，以在范围（0.0-1.0）中生成随机值。

• random(1) == 1 -> false

rank

rank() => integer

计算在窗口的 order by 子句中指定的一组值中的值排名。 结果是 1 加上前面的行数，或者等于当前行在分区中的顺序。 这些值在序列中产生间隙。 即使未对数据进行排序并查找值更改，该 rank 函数也能正常工作。

• 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。例如，-1.1 会转换为 -1.0，使用ROUND_CEILING和-2使用ROUND_UP。）
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传递可选时区：、PSTUTC或America/Cayman。 本地时区用作默认值。 有关可用格式，请参阅 Java 的 SimpleDateFormat 类。

• 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( <字符串到子集><分隔符>substringIndex( : string, : string, <分隔符出现次数> : integral]) => string

在分隔符的计数发生之前提取子字符串。 如果计数为正数，则返回最终分隔符左侧的所有内容（从左开始计数）。 如果计数为负数，则返回最终分隔符右侧的所有内容（从右侧计数）。