매핑 데이터 흐름에서 데이터 변환 식 사용

• 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

0(256), 224, 256, 384, 512 값의 지정된 비트 길이를 갖는 다양한 기본 데이터 형식의 열 세트에서 CRC32 해시를 계산합니다. 행의 지문을 계산하는 데 사용할 수 있습니다.

• 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

지정된 값 그룹에서 값의 순위는 절에 따른 창 순서로 계산됩니다. 결과는 파티션 순서에서 현재 행보다 앞에 있거나 같은 위치에 있는 행의 수에 1을 더한 것입니다. 해당 값은 시퀀스에 갭을 생성하지 않습니다. Dense Rank는 데이터가 정렬되지 않은 경우에도 작동하며 값의 변화를 찾습니다.

• 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

입력 문자열 데이터를 charset에 따라 이진 파일로 인코딩합니다. 두 번째(선택 사항) 인수는 ‘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

제공된 조건자를 충족하지 않는 배열에서 요소를 필터링합니다. 필터는 조건자 함수의 한 요소에 대한 참조를 #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가 생략되면 Data Factory는 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

이진 값을 16진 문자열 표현으로 반환합니다.

• 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() 규칙에 따라 부울 값인지 확인합니다.

• 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() 규칙에 따라 지정된 선택적 형식의 decimal 값인지 검사합니다.

• 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() 규칙에 따라 지정된 선택적 형식의 double 값인지 검사합니다.

• 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() 규칙에 따라 지정된 선택적 형식의 float 값인지 검사합니다.

• 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() 규칙에 따라 지정된 선택적 형식의 integer 값인지 검사합니다.

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

isLong

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

문자열 값이 toLong() 규칙에 따라 지정된 선택적 형식의 long 값인지 검사합니다.

• 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() 규칙에 따라 지정된 선택적 형식의 short 값인지 검사합니다.

• 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 정규식의 .과 유사). %는 입력의 0개 이상의 문자와 일치합니다(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

제공된 식을 사용하여 배열의 각 요소를 새 요소에 매핑합니다. 맵에는 #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

제공된 식을 사용하여 배열의 각 요소를 새 요소에 매핑합니다. 맵에는 #item으로 식 함수에서 하나의 요소에 대한 참조가 필요하며 #index로 요소 색인에 대한 참조가 필요합니다.

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

mapLoop

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

1에서 length까지 반복하여 해당 길이의 배열을 만듭니다. 배열의 인덱스를 #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자의 16진수 문자열을 반환합니다. 행의 지문을 계산하는 데 사용할 수 있습니다.

• 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

악센트 기호가 있는 유니코드 문자를 구분하기 위해 문자열 값을 정규화합니다.

• 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씩 커지고, 임계값은 버킷 크기만큼 커집니다(현재 버킷이 채워질 경우 하나씩 추가).

• 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 연산자입니다. ||과 같습니다.

• 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

지정된 값 그룹에서 값의 순위는 절에 따른 창 순서로 계산됩니다. 결과는 파티션 순서에서 현재 행보다 앞에 있거나 같은 위치에 있는 행의 수에 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

한 정규식 패턴이 나오는 모든 경우를 지정된 문자열의 다른 substring으로 바꿉니다. 이스케이프 없이 문자열을 일치시키려면 <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 - 0에서 먼 쪽으로 반올림하는 모드입니다.
2. ROUND_DOWN - 반올림 모드를 0으로 반올림합니다.
3. ROUND_CEILING - 양의 무한대에 가까운 쪽으로 반올림하는 모드입니다. [입력이 양수인 경우 ROUND_UP과 동일합니다. 음수인 경우 ROUND_DOWN처럼 동작합니다. 예 = -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자의 16진수 문자열을 반환합니다. 행의 지문을 계산하는 데 사용할 수 있습니다.

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

sha2

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

0(256), 224, 256, 384, 512 값의 지정된 비트 길이를 갖는 다양한 기본 데이터 형식의 열 세트에서 SHA-2 다이제스트를 계산합니다. 행의 지문을 계산하는 데 사용할 수 있습니다.

• 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

제공된 조건자 함수를 사용하여 배열을 정렬합니다. 정렬에는 #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가 음수이면 마지막 구분 기호의 오른쪽에 있는 모든 항목(오른쪽부터 계산)이 반환됩니다.