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

적용 대상: Azure Data Factory Azure Synapse Analytics

Tip

기업용 올인원 분석 솔루션인 Microsoft Fabric의 Data Factory를 사용해 보세요. Microsoft Fabric은 데이터 이동부터 데이터 과학, 실시간 분석, 비즈니스 인텔리전스 및 보고에 이르기까지 모든 것을 다룹니다. 무료로 새 평가판을 시작하는 방법을 알아보세요!

데이터 흐름은 Azure Data Factory 파이프라인과 Azure Synapse Analytics 파이프라인 모두에서 사용할 수 있습니다. 이 문서는 매핑 데이터 흐름에 적용됩니다. 변환을 접하는 경우 매핑 데이터 흐름을 사용하여 데이터 변환 소개 문서를 참조하세요.

이 문서에서는 매핑 데이터 흐름에서 Azure Data Factory 및 Azure Synapse Analytics에서 지원하는 모든 식 및 함수를 사용하는 방법에 대해 자세히 설명합니다. 지원되는 각 함수 형식에 대한 요약은 다음 문서를 참조하세요.

모든 함수의 사전순 목록

다음 사전순 목록에는 매핑 데이터 흐름에서 사용할 수 있는 모든 함수가 포함됩니다.

A

`abs`

abs(<value1> : number) => number

숫자의 절대 값을 반환합니다.

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

`acos`

acos(<value1> : number) => double

역코사인 값을 계산합니다.

acos(1) -> 0.0

`add`

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

문자열 또는 숫자의 쌍을 추가합니다. 여러 날짜에 날짜를 추가합니다. 시간 스탬프에 기간을 추가합니다. 비슷한 형식의 배열을 다른 배열에 추가합니다. + 연산자와 같습니다.

add(10, 20) -> 30
10 + 20 -> 30
add('ice', 'cream') -> 'icecream'
'ice' + 'cream' + ' cone' -> 'icecream cone'
add(toDate('2012-12-12'), 3) -> toDate('2012-12-15')
toDate('2012-12-12') + 3 -> toDate('2012-12-15')
[10, 20] + [30, 40] -> [10, 20, 30, 40]
toTimestamp('2019-02-03 05:19:28.871', 'yyyy-MM-dd HH:mm:ss.SSS') + (days(1) + hours(2) - seconds(10)) -> toTimestamp('2019-02-04 07:19:18.871', 'yyyy-MM-dd HH:mm:ss.SSS')

`addDays`

addDays(<date/timestamp> : datetime, <days to add> : integral) => datetime

날짜나 타임스탬프에 특정한 날짜 수를 더합니다. 날짜에 대한 + 연산자와 동일합니다.

addDays(toDate('2016-08-08'), 1) -> toDate('2016-08-09')

`addMonths`

addMonths(<date/timestamp> : datetime, <months to add> : integral, [<value3> : string]) => datetime

날짜 또는 타임스탬프에 달을 추가합니다. 필요에 따라 표준 시간대를 전달할 수 있습니다.

addMonths(toDate('2016-08-31'), 1) -> toDate('2016-09-30')
addMonths(toTimestamp('2016-09-30 10:10:10'), -1) -> toTimestamp('2016-08-31 10:10:10')

`and`

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

논리 AND 연산자를 사용합니다. &&와 동일합니다.

and(true, false) -> false
true && false -> false

`approxDistinctCount`

approxDistinctCount(<value1> : any, [ <value2> : double ]) => long

열에 대한 고유 값의 대략적인 집계 수를 가져옵니다. 선택적 두 번째 매개 변수는 예측 오류를 제어하는 것입니다.

approxDistinctCount(ProductID, .05) => long

`array`

array([<value1> : any], ...) => array

항목의 배열을 만듭니다. 모든 항목은 동일한 형식이어야 합니다. 항목을 지정하지 않으면 빈 문자열 배열이 기본값으로 지정됩니다. [] 생성 연산자와 동일합니다.

array('Seattle', 'Washington')
['Seattle', 'Washington']
['Seattle', 'Washington'][1]
'Washington'

`ascii`

ascii(<Input> : string) => number

입력 문자의 숫자 값을 반환합니다. 입력 문자열에 둘 이상의 문자가 있는 경우 첫 번째 문자의 숫자 값이 반환됩니다.

ascii('A') -> 65
ascii('a') -> 97

`asin`

asin(<value1> : number) => double

역사인 값을 계산합니다.

asin(0) -> 0.0

`assertErrorMessages`

assertErrorMessages() => map

어설션 ID를 키로 사용하여 행에 대한 모든 오류 메시지의 맵을 반환합니다.

Examples

assertErrorMessages() => ['assert1': 'This row failed on assert1.', 'assert2': 'This row failed on assert2.']. In this example, at(assertErrorMessages(), 'assert1') would return 'This row failed on assert1.'

`associate`

reassociate(<value1> : map, <value2> : binaryFunction) => map

키/값의 맵을 만듭니다. 모든 키와 값은 동일한 형식이어야 합니다. 지정된 항목이 없으면 문자열 형식에 대한 문자열 맵으로 기본 설정됩니다. [ -> ] 생성 연산자와 동일합니다. 키와 값은 서로 대체되어야 합니다.

associate('fruit', 'apple', 'vegetable', 'carrot' )=> ['fruit' -> 'apple', 'vegetable' -> 'carrot']

`at`

at(<value1> : array/map, <value2> : integer/key type) => array

배열 인덱스에서 요소를 찾습니다. 인덱스는 1부터입니다. 범위를 벗어난 인덱스는 null 값을 생성합니다. 키가 지정되면 맵에서 값을 찾습니다. 키를 찾을 수 없으면 null 값을 반환합니다.

at(['apples', 'pears'], 1) => 'apples'
at(['fruit' -> 'apples', 'vegetable' -> 'carrot'], 'fruit') => 'apples'

`atan`

atan(<value1> : number) => double

역탄젠트 값을 계산합니다.

atan(0) -> 0.0

`atan2`

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

평면의 양의 x축과 좌표로 지정된 점 사이의 라디안 각도를 반환합니다.

atan2(0, 0) -> 0.0

`avg`

avg(<value1> : number) => number

열 값의 평균을 구합니다.

avg(sales)

`avgIf`

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

조건에 따라 열 값의 평균을 가져옵니다.

avgIf(region == 'West', sales)

B

`between`

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

첫 번째 값이 다른 두 값 사이에 있는지 확인합니다. 숫자, 문자열 및 datetime 값을 비교할 수 있습니다.

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

`bitwiseAnd`

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

정수 계열 형식에서 비트 And 연산자를 사용합니다. & 연산자와 같습니다.

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

`bitwiseOr`

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

정수 계열 형식에서 비트 Or 연산자를 사용합니다. | 연산자와 같습니다.

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

`bitwiseXor`

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

정수 계열 형식에서 비트 Or 연산자를 사용합니다. 연산자와 | 동일

bitwiseXor(0xf4, 0xef)
0x1b
(0xf4 ^ 0xef)
0x1b
(true ^ false)
true
(true ^ true)
false

`blake2b`

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

비트 길이가 지정된 경우 다양한 기본 데이터 형식의 열 집합에 대한 Blake2 다이제스트를 계산합니다. 이는 8에서 512 사이의 배수일 수 있습니다. 이 기능을 사용하여 행의 지문을 계산할 수 있습니다.

blake2b(256, 'gunchus', 8.2, 'bojjus', true, toDate('2010-4-4'))
'c9521a5080d8da30dffb430c50ce253c345cc4c4effc315dab2162dac974711d'

`blake2bBinary`

blake2bBinary(<value1> : integer, <value2> : any, ...) => binary

비트 길이가 지정된 경우 다양한 기본 데이터 형식의 열 집합의 Blake2 다이제스트를 계산합니다. 이는 8에서 512 사이의 배수일 수 있습니다. 이 기능을 사용하여 행의 지문을 계산할 수 있습니다.

blake2bBinary(256, 'gunchus', 8.2, 'bojjus', true, toDate('2010-4-4'))
unHex('c9521a5080d8da30dffb430c50ce253c345cc4c4effc315dab2162dac974711d')

`byItem`

byItem(<parent column> : any, <column name> : string) => any

구조체 또는 구조 배열 내에서 하위 항목을 찾습니다. 일치하는 항목이 여러 개 있는 경우 첫 번째 일치 항목을 반환합니다. 일치하는 항목이 없으면 값이 NULL 반환됩니다. 반환된 값은 형식 변환 작업(예: ? date 및 ? string)에 의해 변환된 형식이어야 합니다. 디자인 타임에 알려진 열 이름은 이름으로 처리합니다. 계산된 입력은 지원되지 않지만 매개 변수 대체를 사용할 수 있습니다.

byItem( byName('customer'), 'orderItems') ? (itemName as string, itemQty as integer)
byItem( byItem( byName('customer'), 'orderItems'), 'itemName') ? string

`byName`

byName(<column name> : string, [<stream name> : string]) => any

스트림에서 이름을 기준으로 열 값을 선택합니다. 선택적 스트림 이름을 두 번째 인수로 전달할 수 있습니다. 일치하는 항목이 여러 개 있는 경우 첫 번째 일치 항목을 반환합니다. 일치하는 항목이 없으면 값이 NULL 반환됩니다. 반환된 값은 형식 변환 함수(예: TO_DATE 및 TO_STRING)로 변환된 형식이어야 합니다. 디자인 타임에 알려진 열 이름은 이름으로 처리합니다. 계산된 입력은 지원되지 않지만 매개 변수 대체를 사용할 수 있습니다.

toString(byName('parent'))
toLong(byName('income'))
toBoolean(byName('foster'))
toLong(byName($debtCol))
toString(byName('Bogus Column'))
toString(byName('Bogus Column', 'DeriveStream'))

`byNames`

byNames(<column names> : array, [<stream name> : string]) => any

스트림에서 이름을 기준으로 열 배열을 선택합니다. 선택적 스트림 이름을 두 번째 인수로 전달할 수 있습니다. 일치하는 항목이 여러 개 있는 경우 첫 번째 일치 항목을 반환합니다. 열에 일치하는 항목이 없으면 전체 출력이 NULL 값입니다. 반환된 값에는 형식 변환 함수(예: toDate 및 toString)가 필요합니다. 디자인 타임에 알려진 열 이름은 이름으로 처리합니다. 계산된 입력은 지원되지 않지만 매개 변수 대체를 사용할 수 있습니다.

toString(byNames(['parent', 'child']))
byNames(['parent']) ? string
toLong(byNames(['income']))
byNames(['income']) ? long
toBoolean(byNames(['foster']))
toLong(byNames($debtCols))
toString(byNames(['a Column']))
toString(byNames(['a Column'], 'DeriveStream'))
byNames(['orderItem']) ? (itemName as string, itemQty as integer)

`byOrigin`

byOrigin(<column name> : string, [<origin stream name> : string]) => any

원본 스트림에서 이름별 열 값을 선택합니다. 두 번째 인수는 원본 스트림 이름입니다. 일치하는 항목이 여러 개 있는 경우 첫 번째 일치 항목을 반환합니다. 일치하는 항목이 없으면 값이 NULL 반환됩니다. 반환된 값은 형식 변환 함수(예: TO_DATE 및 TO_STRING)로 변환된 형식이어야 합니다. 디자인 타임에 알려진 열 이름은 이름으로 처리합니다. 계산된 입력은 지원되지 않지만 매개 변수 대체를 사용할 수 있습니다.

toString(byOrigin('ancestor', 'ancestorStream'))

`byOrigins`

byOrigins(<column names> : array, [<origin stream name> : string]) => any

스트림에서 이름별 열 배열을 선택합니다. 두 번째 인수는 인수가 시작된 스트림입니다. 일치하는 항목이 여러 개 있는 경우 첫 번째 일치 항목을 반환합니다. 일치하는 항목이 없으면 값이 NULL 반환됩니다. 반환된 값은 형식 변환 함수(예: TO_DATE 및 TO_STRING)로 변환된 형식이어야 합니다. 디자인 타임에 알려진 열 이름은 이름으로 처리합니다. 계산된 입력은 지원되지 않지만 매개 변수 대체를 사용할 수 있습니다.

toString(byOrigins(['ancestor1', 'ancestor2'], 'ancestorStream'))

`byPath`

byPath(<value1> : string, [<streamName> : string]) => any

스트림에서 이름별 계층 경로를 찾습니다. 선택적 스트림 이름을 두 번째 인수로 전달할 수 있습니다. 이러한 경로가 없으면 반환됩니다 NULL. 디자인 시간에 이미 알려진 열 이름과 경로는 이름이나 점 표기법 경로로만 지칭해야 합니다. 계산된 입력은 지원되지 않지만 매개 변수 대체를 사용할 수 있습니다.

byPath('grandpa.parent.child') => column

`byPosition`

byPosition(<position> : integer) => any

스트림에서 상대 위치만큼(1부터 시작) 열 값을 선택합니다. 위치가 범위를 벗어나면 값을 반환 NULL 합니다. 반환된 값은 형식 변환 함수(예: TO_DATE 또는 TO_STRING)로 변환된 형식이어야 합니다. 계산된 입력은 지원되지 않지만 매개 변수 대체를 사용할 수 있습니다.

toString(byPosition(1))
toDecimal(byPosition(2), 10, 2)
toBoolean(byName(4))
toString(byName($colName))
toString(byPosition(1234))

C

`case`

case(<condition> : boolean, <true_expression> : any, <false_expression> : any, ...) => any

교대 조건에 따라 함수는 case 값 하나 또는 다른 값을 적용합니다. 입력 수가 짝수이면 다른 입력은 마지막 조건에 대해 기본값으로 설정 NULL 됩니다.

case(10 + 20 == 30, 'dumbo', 'gumbo') -> 'dumbo'
case(10 + 20 == 25, 'bojjus', 'do' < 'go', 'gunchus') -> 'gunchus'
isNull(case(10 + 20 == 25, 'bojjus', 'do' > 'go', 'gunchus')) -> true
case(10 + 20 == 25, 'bojjus', 'do' > 'go', 'gunchus', 'dumbo') -> 'dumbo'

`cbrt`

cbrt(<value1> : number) => double

숫자의 세제곱근을 계산합니다.

cbrt(8) -> 2.0

`ceil`

ceil(<value1> : number) => number

해당 수보다 작지 않은 가장 작은 정수를 반환합니다.

ceil(-0.1) -> 0

`char`

char(<Input> : number) => string

입력 번호로 표시되는 ASCII 문자를 반환합니다. 숫자가 256보다 크면 결과는 char(숫자 % 256)와 같습니다.

char(65) -> 'A'
char(97) -> 'a'

`coalesce`

coalesce(<value1> : any, ...) => any

입력에서 Null이 아닌 첫 번째 값을 반환합니다. 모든 입력은 동일한 형식이어야 합니다.

coalesce(10, 20) -> 10
coalesce(toString(null), toString(null), 'dumbo', 'bo', 'go') -> 'dumbo'

`collect`

collect(<value1> : any) => array

집계 그룹에 있는 식의 모든 값을 배열로 수집합니다. 이 프로세스 중에 구조를 수집하고 대체 구조로 변환할 수 있습니다. 항목 수는 해당 그룹의 행 수와 같으며 null 값을 포함할 수 있습니다. 수집된 항목 수는 적어야 합니다.

collect(salesPerson)
collect(firstName + lastName))
collect(@(name = salesPerson, sales = salesAmount) )

`collectUnique`

collectUnique(<value1> : any) => array

집계된 그룹에 있는 식의 모든 값을 고유한 배열로 수집합니다. 이 프로세스 중에 구조를 수집하고 대체 구조로 변환할 수 있습니다. 항목 수는 해당 그룹의 행 수와 같으며 null 값을 포함할 수 있습니다. 수집된 항목 수는 적어야 합니다.

collect(salesPerson)
collect(firstName + lastName))
collect(@(name = salesPerson, sales = salesAmount) )

`columnNames`

columnNames( <value1>columnNames( : string, i><value1> : boolean) => array 스트림의 모든 출력 열 이름을 가져옵니다. 선택적 스트림 이름을 첫 번째 인수로 전달할 수 있습니다. 두 번째 인수도 선택 사항이며 false를 기본값으로 사용합니다. 두 번째 인수를 true()로 설정하면 Data Factory는 스키마 드리프트를 통해 드리프트된 열만 반환합니다.



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를 반환합니다. 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


값0(256, 224, 256384및 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 클래스를 참조하세요.

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 클래스를 참조하세요. 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


지정된 날짜의 요일을 가져옵니다. 예를 들어 일요일 12 은 월요일입니다. 토요일 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-1UTF-8 기본값), UTF-16BE및 UTF-16LEUTF-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을 더한 것입니다. 해당 값은 시퀀스에 갭을 생성하지 않습니다. 이 함수는 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


입력 문자열 데이터를 charset에 따라 이진 파일로 인코딩합니다. 두 번째(선택 사항) 인수를 사용하여 사용할 문자 집합을 지정할 수 있습니다. 예를 들어 US-ASCII, ( ISO-8859-1UTF-8 기본값), UTF-16BE및 UTF-16LEUTF-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, ecmascripthtml및 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 를 생략하면 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 클래스를 참조하세요.

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


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

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



hour
hour(<value1> : timestamp, [<value2> : string]) => integer


타임스탬표의 시간 값을 가져옵니다. 선택적 표준 시간대를 GMT, PST, UTC, 또는 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()따라 선택적 형식이 지정된 경우 문자열 값이 10진수 값인지 확인합니다.

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의 형식으로 전달할 수 있습니다. 이 함수는 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부터 시작) 인덱스를 전달할 수 있습니다. 스트림 인덱스는 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


로그 값을 계산합니다. 사용하는 경우 선택할 수 있는 기준 또는 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자 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 클래스를 참조하세요.

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 클래스를 참조하세요.

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 클래스를 참조하세요.

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


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

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


지정된 값 그룹에서 값의 순위는 절에 따른 창 순서로 계산됩니다. 결과는 파티션 순서에서 현재 행보다 앞에 있거나 같은 위치에 있는 행의 수에 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 패턴의 모든 항목을 특정 문자열의 다른 부분 문자열로 바꿉니다. 
              <regex>를 사용하면 이스케이프 없이 문자열을 일치시킬 수 있습니다.

regexReplace('100 and 200', '(\\d+)', 'bojjus') -> 'bojjus and bojjus'
regexReplace('100 and 200', `(\d+)`, 'gunchus') -> 'gunchus and gunchus'



regexSplit
regexSplit(<string to split> : string, <regex expression> : string) => array


정규식을 기준으로 구분 기호에 따라 문자열을 분할하고 문자열의 배열을 반환합니다.

regexSplit('bojjusAgunchusBdumbo', `[CAB]`) -> ['bojjus', 'gunchus', 'dumbo']
regexSplit('bojjusAgunchusBdumboC', `[CAB]`) -> ['bojjus', 'gunchus', 'dumbo', '']
(regexSplit('bojjusAgunchusBdumboC', `[CAB]`)[1]) -> 'bojjus'
isNull(regexSplit('bojjusAgunchusBdumboC', `[CAB]`)[20]) -> true



replace
replace(<string> : string, <substring to find> : string, [<substring to replace> : string]) => string


부분 문자열의 모든 항목을 특정 문자열의 다른 부분 문자열로 바꿉니다. 마지막 매개 변수를 생략하면 기본적으로 빈 문자열로 설정됩니다.

replace('doggie dog', 'dog', 'cat') -> 'catgie cat'
replace('doggie dog', 'dog', '') -> 'gie '
replace('doggie dog', 'dog') -> 'gie '



reverse
reverse(<value1> : string) => string


문자열을 반대로 바꿉니다.

reverse('gunchus') -> 'suhcnug'



right
right(<string to subset> : string, <number of characters> : integral) => string


오른쪽에서 특정 문자 수만큼의 부분 문자열을 추출합니다. 
              SUBSTRING(str, LENGTH(str) - n, n)와 동일합니다.

right('bojjus', 2) -> 'us'
right('bojjus', 20) -> 'bojjus'



rlike
rlike(<string> : string, <pattern match> : string) => boolean


문자열이 지정된 정규식 패턴과 일치하는지 확인합니다.

rlike('200.50', `(\d+).(\d+)`) -> true
rlike('bogus', `M[0-9]+.*`) -> false



round
round(<number> : number, [<scale to round> : number], [<rounding option> : integral]) => double


선택적 배율 및 선택적 반올림 모드가 지정된 경우 숫자를 반올림합니다. 배율을 생략하면 기본값은 0입니다. 모드를 생략하면 기본값은 ROUND_HALF_UP(5)입니다. 반올림을 위한 값에는 다음이 포함됩니다.


              ROUND_UP: 0에서 먼 쪽으로 반올림하는 모드입니다.


              ROUND_DOWN: 0에 가까운 쪽으로 반올림하는 모드입니다.


              ROUND_CEILING: 양의 무한대에 가까운 쪽으로 반올림하는 모드입니다. (입력이 양수인 경우 ROUND_UP와 같습니다. 음수인 경우, ROUND_DOWN처럼 동작합니다. 예를 들어, -1.1은 ROUND_CEILING와 함께 -1.0으로, ROUND_UP와 함께 -2로 변환됩니다.)


              ROUND_FLOOR: 음의 무한대에 가까운 쪽으로 반올림하는 모드입니다. (입력이 양수인 경우는 ROUND_DOWN와 동일합니다. 음수인 경우에는 ROUND_UP로 작동합니다.)


              ROUND_HALF_UP: 두 인접 항목이 동일한 거리에 있는 경우를 제외하고 "가장 인접한 항목"에 가까운 쪽으로 반올림하는 모드입니다. 두 인접 항목이 동일한 거리에 있는 경우 ROUND_UP과 같이 동작합니다. (데이터 흐름의 경우 가장 일반적인 + 기본값입니다.)


              ROUND_HALF_DOWN: 두 인접 항목이 동일한 거리에 있는 경우를 제외하고 "가장 인접한 항목"에 가까운 쪽으로 반올림하는 모드입니다(이 경우 ROUND_DOWN).


              ROUND_HALF_EVEN: 두 인접 항목이 같은 거리에 있는 경우를 제외하고 "가장 인접한 항목"에 가까운 쪽으로 반올림하는 모드입니다. 등거리인 경우 인접한 짝수 항목 쪽으로 반올림합니다.


              ROUND_UNNECESSARY: 반올림 모드를 설정하여 반올림 작업이 정확한 결과를 가져오도록 하여 반올림이 필요하지 않음을 보장합니다.

round(100.123) -> 100.0
round(2.5, 0) -> 3.0
round(5.3999999999999995, 2, 7) -> 5.40





rowNumber
rowNumber() => integer


창에서 행에 대해 순차적으로 1부터 번호를 매깁니다.

rowNumber()


rpad
rpad(<string to pad> : string, <final padded length> : integral, <padding> : string) => string


특정 길이가 될 때까지 제공된 패딩으로 문자열의 오른쪽 여백을 채웁니다. 문자열이 길이보다 크거나 같으면 문자열이 길이로 잘립니다.

rpad('dumbo', 10, '-') -> 'dumbo-----'
rpad('dumbo', 4, '-') -> 'dumb'
rpad('dumbo', 8, '<>') -> 'dumbo<><'



rtrim
rtrim(<string to trim> : string, [<trim characters> : string]) => string


오른쪽의 후행 문자열을 삭제합니다. 두 번째 매개 변수가 지정되지 않은 경우 공백을 트리밍합니다. 그렇지 않으면 두 번째 매개 변수에 지정된 문자를 트리밍합니다.

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


S

second
second(<value1> : timestamp, [<value2> : string]) => integer


날짜의 초 값을 가져옵니다. 선택적 표준 시간대를 GMT, PST, UTC, 또는 America/Cayman의 형식으로 전달할 수 있습니다. 현지 표준 시간대는 기본값으로 사용됩니다. 사용 가능한 형식은 Java의 SimpleDateFormat 클래스를 참조하세요.

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), 224256384, 및 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


제공된 조건자 함수를 사용하여 배열을 정렬합니다. 함수는 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 occurrences> : integral]) => string


구분 기호가 나타나는 횟수만큼 앞에 있는 부분 문자열을 추출합니다. 개수가 양수이면 마지막 구분 기호의 왼쪽에 있는 모든 항목(왼쪽에서 계산)이 반환됩니다. 개수가 음수이면 마지막 구분 기호(오른쪽에서 계산)의 오른쪽에 있는 모든 항목이 반환됩니다.


substringIndex('111-222-333', '-', 1) -> '111'
substringIndex('111-222-333', '-', 2) -> '111-222'
substringIndex('111-222-333', '-', -1) -> '333'
substringIndex('111-222-333', '-', -2) -> '222-333'



sum
sum(<value1> : number) => number


숫자 열의 집계 합계를 구합니다.

sum(col)



sumDistinct
sumDistinct(<value1> : number) => number


숫자 열의 고유 값에 대한 집계 합계를 구합니다.

sumDistinct(col)



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


조건에 따라 숫자 열의 집계 합계를 가져옵니다. 조건의 기준은 어떤 열도 될 수 있습니다.

sumDistinctIf(state == 'CA' && commission < 10000, sales)
sumDistinctIf(true, sales)



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


조건에 따라 숫자 열의 집계 합계를 가져옵니다. 조건의 기준은 어떤 열도 될 수 있습니다.

sumIf(state == 'CA' && commission < 10000, sales)
sumIf(true, sales)


T

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


탄젠트 값을 계산합니다.

tan(0) -> 0.0



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


쌍곡선 탄젠트 값을 계산합니다.

tanh(0) -> 0.0



toBase64
toBase64(<value1> : string, <encoding type> : string]) => string


base64에서 특정 문자열을 인코딩합니다. 필요에 따라 인코딩 형식을 전달할 수 있습니다.

toBase64('bojjus') -> 'Ym9qanVz'
toBase64('± 25000, € 5.000,- |', 'Windows-1252') -> 'sSAyNTAwMCwggCA1LjAwMCwtIHw='



toBinary
toBinary(<value1> : any) => binary


숫자, 날짜, 타임스탬프 또는 문자열을 이진 표현으로 변환합니다.

toBinary(3) -> [0x11]



toBoolean
toBoolean(<value1> : string) => boolean


(t, true, y, yes, 1)의 값을 true로 변환하고, (f, false, n, no, 0)의 값을 false로 변환하며, 다른 모든 값은 NULL로 변환합니다.

toBoolean('true') -> true
toBoolean('n') -> false
isNull(toBoolean('truthy')) -> true



toByte
toByte(<value> : any, [<format> : string], [<locale> : string]) => byte


숫자 또는 문자열을 바이트 값으로 변환합니다. 변환에 선택적 Java 10진수 형식을 사용할 수 있습니다.

toByte(123)
123
toByte(0xFF)
-1
toByte('123')
123



toDate
toDate(<string> : any, [<date format> : string]) => date


선택적 입력 날짜 형식을 사용하여 입력 날짜 문자열을 날짜로 변환합니다. 사용 가능한 형식은 Java의 SimpleDateFormat 클래스를 참조하세요. 입력 날짜 형식을 생략하면 기본 형식은 .입니다 yyyy-[M]M-[d]d. 허용되는 형식은 다음과 같습니다 :[ yyyy, yyyy-[M]M, yyyy-[M]M-[d]d, yyyy-[M]M-[d]dT* ].

toDate('2012-8-18') -> toDate('2012-08-18')
toDate('12/18/2012', 'MM/dd/yyyy') -> toDate('2012-12-18')



toDecimal
toDecimal(<value> : any, [<precision> : integral], [<scale> : integral], [<format> : string], [<locale> : string]) => decimal(10,0)


숫자 또는 문자열을 10진수 값으로 변환합니다. 정밀도와 스케일이 지정되지 않으면 기본값은 (10,2)입니다. 변환에 선택적 Java 10진수 형식을 사용할 수 있습니다. en-US, de 또는 zh-CN같은 BCP47 언어 형식으로 선택적 로캘 형식을 사용합니다.

toDecimal(123.45) -> 123.45
toDecimal('123.45', 8, 4) -> 123.4500
toDecimal('$123.45', 8, 4,'$###.00') -> 123.4500
toDecimal('Ç123,45', 10, 2, 'Ç###,##', 'de') -> 123.45



toDouble
toDouble(<value> : any, [<format> : string], [<locale> : string]) => double


숫자 또는 문자열을 배정도 값으로 변환합니다. 변환에 선택적 Java 10진수 형식을 사용할 수 있습니다. en-US, de 또는 zh-CN같은 BCP47 언어 형식으로 선택적 로캘 형식을 사용합니다.

toDouble(123.45) -> 123.45
toDouble('123.45') -> 123.45
toDouble('$123.45', '$###.00') -> 123.45
toDouble('Ç123,45', 'Ç###,##', 'de') -> 123.45



toFloat
toFloat(<value> : any, [<format> : string], [<locale> : string]) => float


숫자 또는 문자열을 부동 소수점 값으로 변환합니다. 변환에 선택적 Java 10진수 형식을 사용할 수 있습니다. double을 자릅니다.

toFloat(123.45) -> 123.45f
toFloat('123.45') -> 123.45f
toFloat('$123.45', '$###.00') -> 123.45f



toInteger
toInteger(<value> : any, [<format> : string], [<locale> : string]) => integer


숫자 또는 문자열을 정수 값으로 변환합니다. 변환에 선택적 Java 10진수 형식을 사용할 수 있습니다. long, float, double을 자릅니다.

toInteger(123) -> 123
toInteger('123') -> 123
toInteger('$123', '$###') -> 123



toLong
toLong(<value> : any, [<format> : string], [<locale> : string]) => long


숫자 또는 문자열을 긴 값으로 변환합니다. 변환에 선택적 Java 10진수 형식을 사용할 수 있습니다. float, double을 자릅니다.

toLong(123) -> 123
toLong('123') -> 123
toLong('$123', '$###') -> 123



topN
topN(<column/expression> : any, <count> : long, <n> : integer) => array


count 인수에 따라 이 열의 상위 N 값을 가져옵니다.

topN(custId, count, 5)
topN(productId, num_sales, 10)



toShort
toShort(<value> : any, [<format> : string], [<locale> : string]) => short


숫자 또는 문자열을 짧은 값으로 변환합니다. 변환에 선택적 Java 10진수 형식을 사용할 수 있습니다. integer, long, float, double을 자릅니다.

toShort(123) -> 123
toShort('123') -> 123
toShort('$123', '$###') -> 123



toString
toString(<value> : any, [<number format/date format> : string], [<date locale> : string]) => string


기본 데이터 형식을 문자열로 변환합니다. 숫자와 날짜의 형식을 지정할 수 있습니다. 지정하지 않으면 시스템 기본값이 선택됩니다. Java 10진수 형식은 숫자에 사용됩니다. 사용 가능한 형식은 Java의 SimpleDateFormat 클래스를 참조하세요. 기본 형식은 .입니다 yyyy-MM-dd. 날짜 또는 타임스탬프를 위해 필요에 따라 로캘을 지정할 수 있습니다.

toString(10) -> '10'
toString('engineer') -> 'engineer'
toString(123456.789, '##,###.##') -> '123,456.79'
toString(123.78, '000000.000') -> '000123.780'
toString(12345, '##0.#####E0') -> '12.345E3'
toString(toDate('2018-12-31')) -> '2018-12-31'
isNull(toString(toDate('2018-12-31', 'MM/dd/yy'))) -> true
toString(4 == 20) -> 'false'
toString(toDate('12/31/18', 'MM/dd/yy', 'es-ES'), 'MM/dd/yy', 'de-DE')



toTimestamp
toTimestamp(<string> : any, [<timestamp format> : string], [<time zone> : string]) => timestamp


선택적인 타임스탬프 형식을 제공하면 문자열을 타임스탬프로 변환합니다. 타임스탬프를 생략하면 기본 패턴 yyyy-[M]M-[d]d hh:mm:ss[.f...] 이 사용됩니다. 선택적 표준 시간대를 GMT, PST, UTC, 또는 America/Cayman의 형식으로 전달할 수 있습니다. 이 함수는 timestamp 값 999으로 최대 밀리초의 정확도를 지원합니다. 사용 가능한 형식은 Java의 SimpleDateFormat 클래스를 참조하세요.

toTimestamp('2016-12-31 00:12:00') -> toTimestamp('2016-12-31 00:12:00')
toTimestamp('2016-12-31T00:12:00', 'yyyy-MM-dd\'T\'HH:mm:ss', 'PST') -> toTimestamp('2016-12-31 00:12:00')
toTimestamp('12/31/2016T00:12:00', 'MM/dd/yyyy\'T\'HH:mm:ss') -> toTimestamp('2016-12-31 00:12:00')
millisecond(toTimestamp('2019-02-03 05:19:28.871', 'yyyy-MM-dd HH:mm:ss.SSS')) -> 871



toUTC
toUTC(<value1> : timestamp, [<value2> : string]) => timestamp


타임스탬프를 UTC로 변환합니다. 선택적 표준 시간대를 GMT, PST, UTC, 또는 America/Cayman의 형식으로 전달할 수 있습니다. 기본값은 현재 표준 시간대입니다. 사용 가능한 형식은 Java의 SimpleDateFormat 클래스를 참조하세요.

toUTC(currentTimestamp()) == toTimestamp('2050-12-12 19:18:12') -> false
toUTC(currentTimestamp(), 'Asia/Seoul') != toTimestamp('2050-12-12 19:18:12') -> true


translate
translate(<string to translate> : string, <lookup characters> : string, <replace characters> : string) => string


하나의 문자 세트를 문자열의 다른 문자 세트로 바꿉니다. 문자는 1대 1로 대체됩니다.

translate('(bojjus)', '()', '[]') -> '[bojjus]'
translate('(gunchus)', '()', '[') -> '[gunchus'



trim
trim(<string to trim> : string, [<trim characters> : string]) => string


선행 및 후행 문자열을 삭제합니다. 두 번째 매개 변수가 지정되지 않은 경우 공백을 트리밍합니다. 그렇지 않으면 두 번째 매개 변수에 지정된 문자를 트리밍합니다.

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



true
true() => boolean


항상 true 값을 반환합니다. 열의 이름을 syntax(true())지정하는 경우 함수 true 를 사용합니다.

(10 + 20 == 30) -> true
(10 + 20 == 30) -> true()



typeMatch
typeMatch(<type> : string, <base type> : string) => boolean


열의 형식과 일치합니다. 패턴 식에서만 사용할 수 있습니다. 
              number 함수는 short, integer, long, double, float, 또는 decimal과 일치합니다. 함수 integral는 짧은(short), 정수(integer), 긴(long)과 일치합니다. 함수는 fractional double, float, decimal과 일치합니다. 
              datetime 함수는 날짜 또는 타임스탬프의 유형과 일치합니다.

typeMatch(type, 'number')
typeMatch('date', 'datetime')


U

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


형식에 따라 문자열을 이스케이프 해제합니다. 허용되는 형식에 대한 리터럴 값은 json, xml, ecmascripthtml및 java.

unescape('{\\\\\"value\\\\\": 10}', 'json')
'{\\\"value\\\": 10}'



unfold
unfold (<value1>: array) => any


배열을 행 세트로 펼치고 모든 행의 나머지 열에 대해 값을 반복합니다.

unfold(addresses) => any
unfold( @(name = salesPerson, sales = salesAmount) ) => any



unhex
unhex(<value1>: string) => binary


16진 문자열 표현을 이진 값으로 표시합니다. 를 사용하여 sha2md5 문자열에서 이진 표현으로 변환할 수 있습니다.

unhex('1fadbe') -> toBinary([toByte(0x1f), toByte(0xad), toByte(0xbe)])
unhex(md5(5, 'gunchus', 8.2, 'bojjus', true, toDate('2010-4-4'))) -> toBinary([toByte(0x4c),toByte(0xe8),toByte(0xa8),toByte(0x80),toByte(0xbd),toByte(0x62),toByte(0x1a),toByte(0x1f),toByte(0xfa),toByte(0xd0),toByte(0xbc),toByte(0xa9),toByte(0x05),toByte(0xe1),toByte(0xbc),toByte(0x5a)])


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


두 배열에서 고유 항목의 공용 구조체 집합을 반환합니다.

union([10, 20, 30], [20, 40]) => [10, 20, 30, 40]



upper
upper(<value1> : string) => string


문자열을 대문자로 바꿉니다.

upper('bojjus') -> 'BOJJUS'



uuid
uuid() => string


생성된 UUID를 반환합니다.

uuid()


V

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


열의 분산을 구합니다.

variance(sales)



varianceIf
varianceIf(<value1> : boolean, <value2> : number) => double


기준에 따라 열의 분산을 구합니다.

varianceIf(region == 'West', sales)



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


열의 모집단 분산을 구합니다.

variancePopulation(sales)



variancePopulationIf
variancePopulationIf(<value1> : boolean, <value2> : number) => double


조건을 기반으로 열의 모집단 분산을 계산합니다.

variancePopulationIf(region == 'West', sales)



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


열의 불편 분산을 구합니다.

varianceSample(sales)



varianceSampleIf
varianceSampleIf(<value1> : boolean, <value2> : number) => double


기준에 따라 열의 바이어스되지 않은 분산을 구합니다.

varianceSampleIf(region == 'West', sales)


W

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


날짜가 지정된 연도의 주를 가져옵니다.

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



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


주 수의 기간을 밀리초 단위로 가져옵니다.

weeks(2) -> 1209600000L


X

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


논리 XOR 연산자를 사용합니다. 
              ^ 연산자와 같습니다.

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


Y

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


날짜의 연도 값을 구합니다.

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

관련 콘텐츠

모든 집계 함수 목록입니다.
모든 배열 함수 목록입니다.
모든 캐시된 조회 함수 목록입니다.
모든 변환 함수 목록입니다.
모든 날짜 및 시간 함수 목록입니다.
모든 식 함수 목록입니다.
모든 맵 함수 목록입니다.
모든 메타 함수 목록입니다.
모든 창 함수 목록입니다.

              식 작성기를 사용하는 방법을 알아봅니다.

피드백

이 페이지가 도움이 되었나요?

Last updated on 2025-11-19

다음을 통해 공유

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

모든 함수의 사전순 목록

A

abs

acos

add

addDays

addMonths

and

approxDistinctCount

array

ascii

asin

assertErrorMessages

associate

at

atan

atan2

avg

avgIf

B

between

bitwiseAnd

bitwiseOr

bitwiseXor

blake2b

blake2bBinary

byItem

byName

byNames

byOrigin

byOrigins

byPath

byPosition

C

case

cbrt

ceil

char

coalesce

collect

collectUnique

columnNames

columns

compare

concat

concatWS

contains

cos

cosh

count

countAll

countDistinct

countAllDistinct

countIf

covariancePopulation

covariancePopulationIf

covarianceSample

covarianceSampleIf

crc32

cumeDist

currentDate

currentTimestamp

currentUTC

D

dayOfMonth

dayOfWeek

dayOfYear

days

decode

degrees

denseRank

distinct

divide

dropLeft

dropRight

E

encode

endsWith

`abs`

`acos`

`add`

`addDays`

`addMonths`

`and`

`approxDistinctCount`

`array`

`ascii`

`asin`

`assertErrorMessages`

`associate`

`at`

`atan`

`atan2`

`avg`

`avgIf`

`between`

`bitwiseAnd`

`bitwiseOr`

`bitwiseXor`

`blake2b`

`blake2bBinary`

`byItem`

`byName`

`byNames`

`byOrigin`

`byOrigins`

`byPath`

`byPosition`

`case`

`cbrt`

`ceil`

`char`

`coalesce`

`collect`

`collectUnique`

`columnNames`

`columns`

`compare`

`concat`

`concatWS`

`contains`

`cos`

`cosh`

`count`

`countAll`

`countDistinct`

`countAllDistinct`

`countIf`

`covariancePopulation`

`covariancePopulationIf`

`covarianceSample`

`covarianceSampleIf`

`crc32`

`cumeDist`

`currentDate`

`currentTimestamp`

`currentUTC`

`dayOfMonth`

`dayOfWeek`

`dayOfYear`

`days`

`decode`

`degrees`

`denseRank`

`distinct`

`divide`

`dropLeft`

`dropRight`

`encode`

`endsWith`

`equals`

`equalsIgnoreCase`

`escape`

`except`

`expr`

`factorial`

`false`

`filter`