Použití výrazů transformace dat v mapování toku dat

Článek
12/09/2023

PLATÍ PRO: Azure Data Factory Azure Synapse Analytics

Tip

Vyzkoušejte si službu Data Factory v Microsoft Fabric, řešení pro analýzy typu all-in-one pro podniky. Microsoft Fabric zahrnuje všechno od přesunu dat až po datové vědy, analýzy v reálném čase, business intelligence a vytváření sestav. Přečtěte si, jak začít používat novou zkušební verzi zdarma.

Toky dat jsou k dispozici ve službě Azure Data Factory i v kanálech Azure Synapse. Tento článek se týká mapování toků dat. Pokud s transformacemi začínáte, přečtěte si úvodní článek Transformace dat pomocí mapování toku dat.

Následující články obsahují podrobnosti o použití všech výrazů a funkcí podporovaných službou Azure Data Factory a Azure Synapse Analytics při mapování toků dat. Souhrny jednotlivých podporovaných typů funkcí najdete v následujících článcích:

Abecední seznam všech funkcí

Následuje abecední seznam všech funkcí dostupných v mapování toků dat.

A

`abs`

abs(<value1> : number) => number

Absolutní hodnota čísla

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

`acos`

acos(<value1> : number) => double

Vypočítá kosinus inverzní hodnotu.

acos(1) -> 0.0

`add`

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

Sečte dvojici řetězců nebo čísel. Přidá datum k určitému počtu dnů. Přidá dobu trvání do časového razítka. Připojí jedno pole podobného typu k druhému. Stejné jako operátor +.

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

Přidejte dny do data nebo časového razítka. Stejné jako operátor + pro datum.

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

`addMonths`

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

Přidejte měsíce do data nebo časového razítka. Volitelně můžete projít časovým pásmem.

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

Logický operátor AND. Stejné jako &.

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

`approxDistinctCount`

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

Získá přibližný agregovaný počet jedinečných hodnot pro sloupec. Volitelným druhým parametrem je kontrola chyby odhadu.

approxDistinctCount(ProductID, .05) => long

`array`

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

Vytvoří pole položek. Všechny položky by měly mít stejný typ. Pokud nejsou zadány žádné položky, je výchozí pole prázdných řetězců. Stejné jako operátor vytváření []

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

`ascii`

ascii(<Input> : string) => number

Vrátí číselnou hodnotu vstupního znaku. Pokud má vstupní řetězec více znaků, vrátí se číselná hodnota prvního znaku.

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

`asin`

asin(<value1> : number) => double

Vypočítá inverzní sinusovou hodnotu.

asin(0) -> 0.0

`assertErrorMessages`

assertErrorMessages() => map

Vrátí mapu všech chybových zpráv pro řádek s ID assert jako klíč.

Příklady

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

Vytvoří mapu klíče/hodnot. Všechny klíče a hodnoty by měly být stejného typu. Pokud nejsou zadány žádné položky, ve výchozím nastavení se mapuje řetězec na typ řetězce. Stejné jako operátor vytvoření [ -> ] . Klíče a hodnoty by se měly vzájemně střídat.

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

`at`

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

Vyhledá prvek v indexu pole. Index je založený na 1. Hodnota indexu mimo hranice má za následek hodnotu null. Najde hodnotu v mapě zadaném klíči. Pokud se klíč nenajde, vrátí hodnotu null.

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

`atan`

atan(<value1> : number) => double

Vypočítá inverzní tangens hodnotu.

atan(0) -> 0.0

`atan2`

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

Vrátí úhel v radiánech mezi kladnou osou x roviny a bodem daným souřadnicemi.

atan2(0, 0) -> 0.0

`avg`

avg(<value1> : number) => number

Získá průměr hodnot sloupce.

avg(sales)

`avgIf`

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

Na základě kritérií získá průměr hodnot sloupce.

avgIf(region == 'West', sales)

T

`between`

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

Zkontroluje, jestli je první hodnota mezi dvěma dalšími hodnotami včetně. Číselné hodnoty, řetězcové hodnoty a hodnoty data a času lze porovnat.

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

`bitwiseAnd`

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

Bitový operátor And napříč celočíselnými typy. Stejné jako operátor &.

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

`bitwiseOr`

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

Bitový operátor Or napříč celočíselnými typy Stejné jako | Operátor

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

`bitwiseXor`

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

Bitový operátor Or napříč celočíselnými typy Stejné jako | Operátor

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

`blake2b`

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

Vypočítá hodnotu hash Blake2 sady sloupců s různými primitivními datovými typy zadanou bitovou délkou, která může být násobky 8 v rozmezí od 8 do 512. Dá se použít k výpočtu otisku prstu pro řádek.

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

`blake2bBinary`

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

Vypočítá hodnotu hash Blake2 sady sloupců s různými primitivními datovými typy zadanou bitovou délkou, která může být násobky 8 v rozmezí od 8 do 512. Dá se použít k výpočtu otisku prstu pro řádek.

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

`byItem`

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

Najděte dílčí položku ve struktuře nebo matici struktury. Pokud existuje více shod, vrátí se první shoda. Pokud se žádná shoda neshoduje, vrátí hodnotu NULL. Vrácená hodnota musí být převedena jednou z akcí převodu typu(? datum, ? řetězec ...). Názvy sloupců známé v době návrhu by měly být adresovány pouze jejich názvem. Vypočítané vstupy se nepodporují, ale můžete použít nahrazování parametrů.

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

Vybere hodnotu sloupce podle názvu v datovém proudu. Jako druhý argument můžete předat volitelný název datového proudu. Pokud existuje více shod, vrátí se první shoda. Pokud se žádná shoda neshoduje, vrátí hodnotu NULL. Vrácená hodnota musí být převedena jednou z funkcí převodu typů(TO_DATE, TO_STRING ...). Názvy sloupců známé v době návrhu by měly být adresovány pouze jejich názvem. Vypočítané vstupy nejsou podporované, ale můžete použít nahrazení parametrů.

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

Vyberte pole sloupců podle názvu v datovém proudu. Jako druhý argument můžete předat volitelný název datového proudu. Pokud existuje více shod, vrátí se první shoda. Pokud sloupec neobsahuje žádné shody, celý výstup je hodnota NULL. Vrácená hodnota vyžaduje funkci převodu typu (toDate, toString, ...). Názvy sloupců známé v době návrhu by měly být adresovány pouze jejich názvem. Vypočítané vstupy nejsou podporované, ale můžete použít nahrazení parametrů.

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

Vybere hodnotu sloupce podle názvu v datovém proudu původu. Druhým argumentem je název původního datového proudu. Pokud existuje více shod, vrátí se první shoda. Pokud se žádná shoda neshoduje, vrátí hodnotu NULL. Vrácená hodnota musí být převedena jednou z funkcí převodu typů(TO_DATE, TO_STRING ...). Názvy sloupců známé v době návrhu by měly být adresovány pouze jejich názvem. Vypočítané vstupy nejsou podporované, ale můžete použít nahrazení parametrů.

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

`byOrigins`

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

Vybere pole sloupců podle názvu v datovém proudu. Druhým argumentem je datový proud, ze kterého pochází. Pokud existuje více shod, vrátí se první shoda. Pokud se žádná shoda neshoduje, vrátí hodnotu NULL. Vrácená hodnota musí být převedena jednou z funkcí převodu typů(TO_DATE, TO_STRING ...) Názvy sloupců známé v době návrhu by měly být adresovány pouze jejich názvem. Vypočítané vstupy nejsou podporované, ale můžete použít nahrazení parametrů.

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

`byPath`

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

Vyhledá hierarchickou cestu podle názvu v datovém proudu. Jako druhý argument můžete předat volitelný název datového proudu. Pokud se taková cesta nenajde, vrátí hodnotu null. Názvy sloupců a cesty známé v době návrhu by měly být adresovány pouze jejich názvem nebo tečkovanou cestou. Vypočítané vstupy nejsou podporované, ale můžete použít nahrazení parametrů.

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

`byPosition`

byPosition(<position> : integer) => any

Vybere hodnotu sloupce podle relativní pozice (1 na základě) v datovém proudu. Pokud je pozice mimo hranice, vrátí hodnotu NULL. Vrácená hodnota musí být převedena jednou z funkcí převodu typů(TO_DATE, TO_STRING ...) Vypočítané vstupy nejsou podporované, ale můžete použít nahrazení parametrů.

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

Na základě střídavých podmínek platí jedna nebo druhá hodnota. Pokud je počet vstupů sudý, druhý se pro poslední podmínku ve výchozím nastavení nastaví na hodnotu 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

Vypočítá kořen datové krychle čísla.

cbrt(8) -> 2.0

`ceil`

ceil(<value1> : number) => number

Vrátí nejmenší celé číslo, které není menší než číslo.

ceil(-0.1) -> 0

`char`

char(<Input> : number) => string

Vrátí znak ascii reprezentovaný vstupním číslem. Pokud je číslo větší než 256, výsledek odpovídá znaku (číslo % 256).

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

`coalesce`

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

Vrátí první hodnotu null ze sady vstupů. Všechny vstupy by měly být stejného typu.

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

`collect`

collect(<value1> : any) => array

Shromažďuje všechny hodnoty výrazu v agregované skupině do pole. Během tohoto procesu je možné shromažďovat a transformovat struktury na alternativní struktury. Počet položek bude roven počtu řádků v této skupině a může obsahovat hodnoty null. Počet shromážděných položek by měl být malý.

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

`collectUnique`

collectUnique(<value1> : any) => array

Shromažďuje všechny hodnoty výrazu v agregované skupině do jedinečného pole. Během tohoto procesu je možné shromažďovat a transformovat struktury na alternativní struktury. Počet položek bude roven počtu řádků v této skupině a může obsahovat hodnoty null. Počet shromážděných položek by měl být malý.

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

`columnNames`

columnNames(<value1>columnNames( : string, i><value1> : boolean) = array> Získá názvy všech výstupních sloupců pro datový proud. Jako první argument můžete předat volitelný název datového proudu. Druhý argument je také volitelný s hodnotou false jako výchozí. Pokud nastavíte druhý argument na true(), ADF vrátí pouze sloupce, které jsou posunuty schématem.



columnNames()
columnNames('DeriveStream')
columnNames('DeriveStream', true())
columnNames('', true())



columns
columns([<stream name> : string]) => any


Získá hodnoty všech výstupních sloupců pro datový proud. Jako druhý argument můžete předat volitelný název datového proudu.

columns()
columns('DeriveStream')



compare
compare(<value1> : any, <value2> : any) => integer


Porovná dvě hodnoty stejného typu. Vrátí záporné celé číslo, pokud hodnota1 < hodnota2, 0 pokud hodnota1 == hodnota2, kladná hodnota, pokud hodnota1 > hodnota2.

(compare(12, 24) < 1) -> true
(compare('dumbo', 'dum') > 0) -> true



concat
concat(<this> : string, <that> : string, ...) => string


Zřetězí proměnný počet řetězců dohromady. Stejné jako operátor + s řetězci.

concat('dataflow', 'is', 'awesome') -> 'dataflowisawesome'
'dataflow' + 'is' + 'awesome' -> 'dataflowisawesome'
isNull('sql' + null) -> true



concatWS
concatWS(<separator> : string, <this> : string, <that> : string, ...) => string


Zřetězí proměnný počet řetězců společně s oddělovačem. Prvním parametrem je oddělovač.

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


Vrátí hodnotu true, pokud jakýkoli prvek v zadaném poli vyhodnotí jako true v zadaném predikátu. Obsahuje očekává odkaz na jeden prvek v predikát funkce jako #item.

contains([1, 2, 3, 4], #item == 3) -> true
contains([1, 2, 3, 4], #item > 5) -> false



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


Vypočítá kosinusovou hodnotu.

cos(10) -> -0.8390715290764524



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


Vypočítá hyperbolický kosinus hodnoty.

cosh(0) -> 1.0



count
count([<value1> : any]) => long


Získá agregovaný počet hodnot. Pokud jsou zadány volitelné sloupce, ignoruje hodnoty NULL v počtu.

count(custId)
count(custId, custName)
count()
count(iif(isNull(custId), 1, NULL))



countAll
countAll([<value1> : any]) => long


Získá agregovaný počet hodnot včetně hodnot null.

countAll(custId)
countAll()



countDistinct
countDistinct(<value1> : any, [<value2> : any], ...) => long


Získá agregovaný počet jedinečných hodnot sady sloupců.

countDistinct(custId, custName)



countAllDistinct
countAllDistinct(<value1> : any, [<value2> : any], ...) => long


Získá agregovaný počet jedinečných hodnot sady sloupců včetně hodnot null.

countAllDistinct(custId, custName)



countIf
countIf(<value1> : boolean, [<value2> : any]) => long


Na základě kritérií získá agregovaný počet hodnot. Pokud je zadaný volitelný sloupec, ignoruje hodnoty NULL v počtu.

countIf(state == 'CA' && commission < 10000, name)



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


Získá kovarianci základního souboru mezi dvěma sloupci.

covariancePopulation(sales, profit)



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


Na základě kritérií získá kovarianci základního souboru dvou sloupců.

covariancePopulationIf(region == 'West', sales)



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


Získá kovarianci vzorku dvou sloupců.

covarianceSample(sales, profit)



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


Na základě kritérií získá kovarianci vzorku dvou sloupců.

covarianceSampleIf(region == 'West', sales, profit)



crc32
crc32(<value1> : any, ...) => long


Vypočítá hodnotu hash CRC32 sady sloupců s různými primitivními datovými typy zadanou bitovou délkou, která může být pouze z hodnot 0(256), 224, 256, 384, 512. Dá se použít k výpočtu otisku prstu pro řádek.

crc32(256, 'gunchus', 8.2, 'bojjus', true, toDate('2010-4-4')) -> 3630253689L



cumeDist
cumeDist() => integer


Funkce CumeDist vypočítá pozici hodnoty vzhledem ke všem hodnotám v oddílu. Výsledkem je počet řádků předcházejících nebo rovno aktuálnímu řádku v pořadí oddílu děleného celkovým počtem řádků v oddílu okna. Všechny hodnoty vazby v pořadí se vyhodnotí na stejnou pozici.

cumeDist()



currentDate
currentDate([<value1> : string]) => date


Získá aktuální datum, kdy se tato úloha spustí. Volitelné časové pásmo můžete předat ve tvaru GMT, PST, UTC, America/Cayman. Jako výchozí se používá místní časové pásmo datového centra nebo oblasti datové továrny. Dostupné formáty najdete ve třídě Javy 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


Získá aktuální časové razítko při spuštění úlohy s místním časovým pásmem.

currentTimestamp() == toTimestamp('2250-12-31 12:12:12') -> false



currentUTC
currentUTC([<value1> : string]) => timestamp


Získá aktuální časové razítko jako UTC. Pokud chcete, aby váš aktuální čas byl interpretován v jiném časovém pásmu než vaše časové pásmo clusteru, můžete předat volitelné časové pásmo ve formě GMT, PST, UTC, America/Cayman. Výchozí hodnota je aktuální časové pásmo. Dostupné formáty najdete ve třídě Javy SimpleDateFormat . https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html. Chcete-li převést čas UTC na jiné časové pásmo, použijte 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


Získá den v měsíci zadané datum.

dayOfMonth(toDate('2018-06-08')) -> 8



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


Získá den v týdnu zadané datum. 1 – neděle, 2 – pondělí ..., 7 – sobota.

dayOfWeek(toDate('2018-06-08')) -> 6



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


Získá den v roce zadané datum.

dayOfYear(toDate('2016-04-09')) -> 100



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


Doba trvání v milisekundách po dobu několika dnů.

days(2) -> 172800000L



decode
decode(<Input> : any, <Charset> : string) => binary


Dekóduje zakódovaná vstupní data do řetězce na základě dané znakové sady. Druhý (volitelný) argument lze použít k určení, kterou znakovou sadu použít – US-ASCII, ISO-8859-1, UTF-8 (výchozí), UTF-16BE, UTF-16LE, UTF-16LE, UTF-16.

decode(array(toByte(97),toByte(98),toByte(99)), 'US-ASCII') -> abc



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


Převede radiány na stupně.

degrees(3.141592653589793) -> 180



denseRank
denseRank() => integer


Vypočítá pořadí hodnoty ve skupině hodnot zadaných v klauzuli order by v okně. Výsledkem je jeden plus počet řádků předcházejících nebo rovno aktuálnímu řádku v pořadí oddílu. Hodnoty nebudou v sekvenci vytvářet mezery. Funkce Dense Rank funguje i v případě, že data nejsou seřazená a hledají změny hodnot.

denseRank()



distinct
distinct(<value1> : array) => array


Vrátí jedinečnou sadu položek z pole.

distinct([10, 20, 30, 10]) => [10, 20, 30]



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


Rozdělí dvojici čísel. Stejné jako operátor / .

divide(20, 10) -> 2
20 / 10 -> 2



dropLeft
dropLeft(<value1> : string, <value2> : integer) => string


Odebere zleva od řetězce tolik znaků. Pokud požadovaný pokles překročí délku řetězce, vrátí se prázdný řetězec.

dropLeft('bojjus'; 2) => 'jjus'
dropLeft('dort'; 10) => ''



dropRight
dropRight(<value1> : string, <value2> : integer) => string


Odebere z pravého řetězce tolik znaků. Pokud požadovaný pokles překročí délku řetězce, vrátí se prázdný řetězec.

dropRight('bojjus'; 2) => 'bojj'
dropRight('dort'; 10) => ''


E

encode
encode(<Input> : string, <Charset> : string) => binary


Zakóduje vstupní řetězcová data do binárního souboru na základě znakové sady. Druhý (volitelný) argument lze použít k určení, kterou znakovou sadu použít – US-ASCII, ISO-8859-1, UTF-8 (výchozí), UTF-16BE, UTF-16LE, UTF-16LE, UTF-16.

encode('abc', 'US-ASCII') -> array(toByte(97),toByte(98),toByte(99))


Vstupní řetězec: string, Charset: string) => binary 
endsWith
endsWith(<string> : string, <substring to check> : string) => boolean


Zkontroluje, jestli řetězec končí zadaným řetězcem.

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



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


Relační operátor rovná se. Stejné jako operátor ==

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


Relační operátor rovná se ignoruje malá a velká písmena. Stejné jako <operátor =>

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



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


Unikne řetězci podle formátu. Hodnoty literálů pro přijatelný formát jsou json, xml, ecmascript, html, java.


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


Vrátí sadu rozdílů v jedné matici z jiného vyřazení duplicit.

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



expr
expr(<expr> : string) => any


Výsledkem je výraz z řetězce. Je to stejné jako při psaní tohoto výrazu v neslovné podobě. Můžete ho použít k předání parametrů jako řetězcových reprezentací.

výraz('price * discount') => libovolná


F

factorial
factorial(<value1> : number) => long


Vypočítá faktoriál čísla.

factorial(5) -> 120



false
false() => boolean


Vždy vrátí hodnotu false. syntax(false()) Funkci použijte, pokud existuje sloupec s názvem false.

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



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


Filtruje prvky z pole, které nesplňují zadaný predikát. Filtr očekává odkaz na jeden prvek v predikát funkci jako #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


Najděte první položku z pole, které odpovídá podmínce. Přebírá funkci filtru, kde můžete položku v poli adresovat jako #item. U hluboko vnořených map můžete odkazovat na nadřazené mapy pomocí notace #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


Získá první hodnotu skupiny sloupců. Pokud druhý parametr ignoreNulls vynecháte, předpokládá se nepravda.

first(sales)
first(sales, false)



flatten
flatten(<array> : array, <value2> : array ..., <value2> : boolean) => array


Zploštěná matice nebo matice do jednoho pole. Pole atomických položek se vrátí beze vrácené hodnoty. Poslední argument je nepovinný a ve výchozím nastavení se hodnota false zploštěla rekurzivně více než jedna úroveň.

flatten([['bojjus', 'girl'], ['gunchus', 'boy']]) => ['bojjus', 'girl', 'gunchus', 'boy']
flatten([[['bojjus', 'gunchus']]] , true) => ['bojjus', 'gunchus']



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


Vrátí největší celé číslo, které není větší než číslo.

floor(-0.1) -> -1



fromBase64
fromBase64(<value1> : string, <encoding type> : string) => string


Dekóduje zadaný řetězec s kódováním base64. Volitelně můžete předat typ kódování.

fromBase64('Z3VuY2h1cw==') -> 'gunchus'
fromBase64('SGVsbG8gV29ybGQ=', 'Windows-1252') -> 'Hello World'



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


Převede na časové razítko z UTC. Volitelně můžete časové pásmo předat ve tvaru GMT, PST, UTC, America/Cayman. Výchozí hodnota je aktuální časové pásmo. Dostupné formáty najdete ve třídě Javy 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


Relační operátor větší. Stejné jako > operátor.

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


Porovnání operátoru větší než nebo rovno Stejné jako >operátor =

greaterOrEqual(12, 12) -> true
('dumbo' >= 'dum') -> true



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


Vrátí nejvyšší hodnotu ze seznamu hodnot, protože vstupní hodnoty null přeskočí. Vrátí hodnotu null, pokud jsou všechny vstupy 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


Kontroluje hodnotu sloupce podle názvu v datovém proudu. Jako druhý argument můžete předat volitelný název datového proudu. Názvy sloupců známé v době návrhu by měly být adresovány pouze jejich názvem. Vypočítané vstupy nejsou podporované, ale můžete použít nahrazení parametrů.

hasColumn('parent')



hasError
hasError([<value1> : string]) => boolean


Zkontroluje, jestli je kontrolní výraz se zadaným ID označený jako chyba.
Příklady

hasError('assert1')
hasError('assert2')



hasPath
hasPath(<value1> : string, [<streamName> : string]) => boolean


Zkontroluje, jestli v datovém proudu existuje určitá hierarchická cesta podle názvu. Jako druhý argument můžete předat volitelný název datového proudu. Názvy sloupců a cesty známé v době návrhu by měly být adresovány pouze jejich názvem nebo tečkovanou cestou. Vypočítané vstupy nejsou podporované, ale můžete použít nahrazení parametrů.

hasPath('grandpa.parent.child') => boolean



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


Vrátí šestnáctkové řetězcové vyjádření binární hodnoty.

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



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


Získá hodinovou hodnotu časového razítka. Volitelné časové pásmo můžete předat ve tvaru GMT, PST, UTC, America/Cayman. Místní časové pásmo se používá jako výchozí. Dostupné formáty najdete ve třídě Javy 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


Doba trvání v milisekundách po dobu několika hodin.

hours(2) -> 7200000L


I

iif
iif(<condition> : boolean, <true_expression> : any, [<false_expression> : any]) => any


Na základě podmínky platí jedna hodnota nebo druhá. Pokud není zadán jiný, považuje se za HODNOTU NULL. Obě hodnoty musí být kompatibilní (číselné, řetězcové...).

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


Při zadání dvou nebo více vstupů vrátí první položku, která není null. Tato funkce je ekvivalentem shodné funkce.

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


Zkontroluje, jestli je položka v poli.

in([10, 20, 30], 10) -> true
in(['good', 'kid'], 'bad') -> false



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


Převede první písmeno každého slova na velká písmena. Slova jsou označena jako oddělená prázdným znakem.

initCap('cool iceCREAM') -> 'Cool Icecream'



instr
instr(<string> : string, <substring to find> : string) => integer


Najde pozici (1) podřetězce v řetězci. Pokud nebyl nalezen, vrátí se hodnota 0.

instr('dumbo', 'mbo') -> 3
instr('microsoft', 'o') -> 5
instr('good', 'bad') -> 0



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


Vrátí sadu průniků různých položek z 2 polí.

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



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


Zkontroluje, jestli je v této bitové sadě nastavená bitová pozice.

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



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


Zkontroluje, jestli je řetězcová hodnota logická hodnota podle pravidel toBoolean()

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



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


Zkontroluje, jestli je řetězcová hodnota hodnotou bajtu zadanou volitelným formátem podle pravidel toByte()

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



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


Zkontroluje, jestli je vstupním řetězcem kalendářního data datum datum pomocí volitelného vstupního formátu data. Dostupné formáty najdete v jazyce Java SimpleDateFormat. Pokud je formát vstupního data vynechán, je výchozí formát yyyy-[M]M-[d]d. Přijaté formáty jsou [ 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


Zkontroluje, jestli je řetězcová hodnota desetinnou hodnotou zadanou volitelným formátem podle pravidel toDecimal()

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



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


Zkontroluje, jestli je řádek označený k odstranění. U transformací, které přebírají více vstupních datových proudů, můžete předat index datového proudu (1). Index datového proudu by měl být buď 1, nebo 2 a výchozí hodnota je 1.

isDelete()
isDelete(1)



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


Najde, jestli je sloupec nebo sada sloupců odlišná. Nepočítá hodnotu null jako jedinečnou hodnotu.

isDistinct(custId, custName) => boolean



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


Zkontroluje, jestli je řetězcová hodnota dvojitou hodnotou vzhledem k volitelnému formátu podle pravidel toDouble()

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



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


Zkontroluje, jestli je řádek označený jako chyba. U transformací, které přebírají více vstupních datových proudů, můžete předat index datového proudu (1). Index datového proudu by měl být buď 1, nebo 2 a výchozí hodnota je 1.

isError()
isError(1)



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


Zkontroluje, jestli je řetězcová hodnota plovoucí hodnotou zadanou volitelným formátem podle pravidel toFloat()

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



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


Zkontroluje, jestli je řádek označený jako ignorováný. U transformací, které přebírají více vstupních datových proudů, můžete předat index datového proudu (1). Index datového proudu by měl být buď 1, nebo 2 a výchozí hodnota je 1.

isIgnore()
isIgnore(1)



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


Zkontroluje, jestli je řádek označený pro vložení. U transformací, které přebírají více vstupních datových proudů, můžete předat index datového proudu (1). Index datového proudu by měl být buď 1, nebo 2 a výchozí hodnota je 1.

isInsert()
isInsert(1)



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


Zkontroluje, jestli je řetězcová hodnota celočíselnou hodnotou vzhledem k volitelnému formátu podle pravidel toInteger()

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



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


Zkontroluje, jestli je řetězcová hodnota dlouhá hodnota vzhledem k volitelnému formátu podle pravidel toLong()

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



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


Zkontroluje, jestli se řádek shoduje s vyhledáváním. U transformací, které přebírají více vstupních datových proudů, můžete předat index datového proudu (1). Index datového proudu by měl být buď 1, nebo 2 a výchozí hodnota je 1.

isMatch()
isMatch(1)



isNan
isNan (<value1> : integral) => boolean


Zkontrolujte, jestli se nejedná o číslo.

isNan(10.2) => false



isNull
isNull(<value1> : any) => boolean


Zkontroluje, jestli je hodnota NULL.

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



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


Zkontroluje, jestli je řetězcová hodnota krátká vzhledem k volitelnému formátu podle pravidel toShort()

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



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


Zkontroluje, jestli je vstupním řetězcem kalendářního data časové razítko časové razítko s volitelným formátem časového razítka. Dostupné formáty najdete v jazyce Java SimpleDateFormat. Pokud je časové razítko vynecháno, použije se výchozí vzor yyyy-[M]M-[d]d hh:mm:ss[.f...] . Volitelné časové pásmo můžete předat ve tvaru GMT, PST, UTC, America/Cayman. Časové razítko podporuje až milisekund přesnost s hodnotou 999 Refer to Java SimpleDateFormat pro dostupné formáty.

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


Zkontroluje, jestli je řádek označený k aktualizaci. U transformací, které přebírají více vstupních datových proudů, můžete předat index datového proudu (1). Index datového proudu by měl být buď 1, nebo 2 a výchozí hodnota je 1.

isUpdate()
isUpdate(1)



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


Zkontroluje, jestli je řádek označený pro vložení. U transformací, které přebírají více vstupních datových proudů, můžete předat index datového proudu (1). Index datového proudu by měl být buď 1, nebo 2 a výchozí hodnota je 1.

isUpsert()
isUpsert(1)


J

jaroWinkler
jaroWinkler(<value1> : string, <value2> : string) => double


Získá JaroWinkler vzdálenost mezi dvěma řetězci.

jaroWinkler('frog', 'frog') => 1.0


K

keyValues
keyValues(<value1> : array, <value2> : array) => map


Vytvoří mapu klíče/hodnot. První parametr je pole klíčů a druhý je pole hodnot. Obě pole by měla mít stejnou délku.

keyValues(['bojjus', 'appa'], ['gunchus', 'ammi']) => ['bojjus' -> 'gunchus', 'appa' -> 'ammi']



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


Získá kurtózu sloupce.

kurtosis(sales)



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


Na základě kritérií získá kurtózu sloupce.

kurtosisIf(region == 'West', sales)


L

lag
lag(<value> : any, [<number of rows to look before> : number], [<default value> : any]) => any


Získá hodnotu prvního parametru vyhodnoceného n řádků před aktuálním řádkem. Druhým parametrem je počet řádků, které se mají vrátit zpět a výchozí hodnota je 1. Pokud není zadáno tolik řádků, kolik řádků je hodnota null vrácena, pokud není zadána výchozí hodnota.

lag(amount, 2)
lag(amount, 2000, 100)



last
last(<value1> : any, [<value2> : boolean]) => any


Získá poslední hodnotu skupiny sloupců. Pokud druhý parametr ignoreNulls vynecháte, předpokládá se nepravda.

last(sales)
last(sales, false)



lastDayOfMonth
lastDayOfMonth(<value1> : datetime) => date


Získá poslední datum v měsíci zadané datum.

lastDayOfMonth(toDate('2009-01-12')) -> toDate('2009-01-31')



lead
lead(<value> : any, [<number of rows to look after> : number], [<default value> : any]) => any


Získá hodnotu prvního parametru vyhodnoceného n řádků za aktuálním řádkem. Druhým parametrem je počet řádků, které mají vypadat dopředu, a výchozí hodnota je 1. Pokud není zadáno tolik řádků, kolik řádků je hodnota null vrácena, pokud není zadána výchozí hodnota.

lead(amount, 2)
lead(amount, 2000, 100)



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


Porovnání menší než nebo rovnou operátoru Stejné jako <operátor =

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


Extrahuje podřetězdí začínající indexem 1 s počtem znaků. Stejné jako PODŘETĚZCE(str, 1, n).

left('bojjus', 2) -> 'bo'
left('bojjus', 20) -> 'bojjus'



length
length(<value1> : string) => integer


Vrátí délku řetězce.

length('dumbo') -> 5



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


Relační operátor menší. Stejné jako < operátor.

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


Porovnání menší než nebo rovnou operátoru Stejné jako <operátor =

lesserOrEqual(12, 12) -> true
('dumbo' <= 'dum') -> false



levenshtein
levenshtein(<from string> : string, <to string> : string) => integer


Získá levenshtein vzdálenost mezi dvěma řetězci.

levenshtein('boys', 'girls') -> 4



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


Vzor je řetězec, který se shoduje doslova. Výjimky jsou následující speciální symboly: _ odpovídá jakémukoli znaku ve vstupu (podobně jako v posix regulárních výrazech) % odpovídá nule nebo více znaků ve vstupu (podobně jako .* v posix regulárních výrazech).
Řídicí znak je "". Pokud řídicí znak předchází speciálnímu symbolu nebo jinému řídicímu znaku, odpovídá následující znak doslova. Není platné umiskovat jakýkoli jiný znak.

like('icecream', 'ice%') -> true



locate
locate(<substring to find> : string, <string> : string, [<from index - 1-based> : integral]) => integer


Najde pozici (1 založenou) podřetězce v řetězci, která začíná určitou pozicí. Pokud je pozice vynechána, považuje se od začátku řetězce. Pokud nebyl nalezen, vrátí se hodnota 0.

locate('mbo', 'dumbo') -> 3
locate('o', 'microsoft', 6) -> 7
locate('bad', 'good') -> 0



log
log(<value1> : number, [<value2> : number]) => double


Vypočítá hodnotu protokolu. Nepovinný základ lze zadat jinak číslo Euleru, pokud se použije.

log(100, 10) -> 2



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


Vypočítá hodnotu protokolu na základě 10 základu.

log10(100) -> 2



lookup
lookup(key, key2, ...) => complex[]


Vyhledá první řádek z jímky uložené v mezipaměti pomocí zadaných klíčů, které odpovídají klíčům z jímky uložené v mezipaměti.

cacheSink#lookup(movieId)



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


Malá písmena řetězce.

lower('GunChus') -> 'gunchus'



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


Levá pole řetězec zadaným odsazením, dokud není určitou délkou. Pokud je řetězec roven nebo větší než délka, je oříznutý na délku.

lpad('dumbo', 10, '-') -> '-----dumbo'
lpad('dumbo', 4, '-') -> 'dumb'



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


Levý oříznou řetězec počátečních znaků. Pokud není zadaný druhý parametr, oříznou se prázdné znaky. Jinak oříznou libovolný znak zadaný v druhém parametru.

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


M

map
map(<value1> : array, <value2> : unaryfunction) => any


Mapy každý prvek pole na nový prvek pomocí poskytnutého výrazu. Mapa očekává odkaz na jeden prvek ve funkci výrazu jako #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


Transformuje mapu přidružením klíčů k novým hodnotám. Vrátí matici. Přebírá funkci mapování, ve které můžete položku řešit jako #key a aktuální hodnotu jako #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


Podmíněně mapuje pole na jiné pole se stejnou nebo menší délkou. Hodnoty můžou být libovolného datového typu, včetně structTypes. Přebírá funkci mapování, kde můžete položku v poli řešit jako #item a aktuální index jako #index. U hluboko vnořených map můžete odkazovat na nadřazené mapy pomocí zápisu #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


Mapy každý prvek pole na nový prvek pomocí poskytnutého výrazu. Mapa očekává odkaz na jeden prvek ve funkci výrazu jako #item a odkaz na index elementu jako #index.

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



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


Smyčky prochází od 1 do délky a vytvoří pole této délky. Přebírá funkci mapování, kde můžete index v poli řešit jako #index. U hluboko vnořených map můžete odkazovat na nadřazené mapy pomocí notace #index_n(#index_1, #index_2...).

mapLoop(3, #index * 10) -> [10, 20, 30]



max
max(<value1> : any) => any


Získá maximální hodnotu sloupce.

max(sales)



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


Na základě kritérií získá maximální hodnotu sloupce.

maxIf(region == 'West', sales)



md5
md5(<value1> : any, ...) => string


Vypočítá hodnotu hash MD5 sady sloupců různých primitivních datových typů a vrátí šestnáctkový řetězec o 32 znacích. Dá se použít k výpočtu otisku prstu pro řádek.

md5(5, 'gunchus', 8.2, 'bojjus', true, toDate('2010-4-4')) -> '4ce8a880bd621a1ffad0bca905e1bc5a'



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


Získá střední hodnotu hodnot sloupce. Stejné jako AVG.

mean(sales)



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


Na základě kritérií získá střední hodnotu hodnot sloupce. Stejné jako avgIf.

meanIf(region == 'West', sales)



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


Získá hodnotu milisekund data. Volitelné časové pásmo můžete předat ve tvaru GMT, PST, UTC, America/Cayman. Místní časové pásmo se používá jako výchozí. Dostupné formáty najdete ve třídě Javy 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


Doba trvání v milisekundách pro počet milisekund.

milliseconds(2) -> 2L



min
min(<value1> : any) => any


Získá minimální hodnotu sloupce.

min(sales)



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


Na základě kritérií získá minimální hodnotu sloupce.

minIf(region == 'West', sales)



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


Odečte čísla. Odečítá počet dní od data. Odečte dobu trvání od časového razítka. Odečtěte dvě časová razítka, abyste získali rozdíl v milisekundách. Stejné jako operátor - .

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


Získá minutovou hodnotu časového razítka. Volitelné časové pásmo můžete předat ve tvaru GMT, PST, UTC, America/Cayman. Místní časové pásmo se používá jako výchozí. Dostupné formáty najdete ve třídě Javy 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


Doba trvání v milisekundách po dobu několika minut.

minutes(2) -> 120000L



mlookup
mlookup(key, key2, ...) => complex[]


Vyhledá všechny odpovídající řádky z jímky uložené v mezipaměti pomocí zadaných klíčů, které odpovídají klíčům z jímky uložené v mezipaměti.

cacheSink#mlookup(movieId)



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


Moduly páru čísel. Stejné jako operátor %.

mod(20, 8) -> 4
20 % 8 -> 4



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


Získá hodnotu měsíce data nebo časového razítka.

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



monthsBetween
monthsBetween(<from date/timestamp> : datetime, <to date/timestamp> : datetime, [<roundoff> : boolean], [<time zone> : string]) => double


Získá počet měsíců mezi dvěma daty. Výpočet můžete zaokrouhlit. Volitelné časové pásmo můžete předat ve tvaru GMT, PST, UTC, America/Cayman. Místní časové pásmo se používá jako výchozí. Dostupné formáty najdete ve třídě Javy 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


Vynásobí dvojici čísel. Stejné jako operátor *.

multiply(20, 10) -> 200
20 * 10 -> 200


N

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


Neguje číslo. Změní kladná čísla na záporná a naopak.

negate(13) -> -13



nextSequence
nextSequence() => long


Vrátí další jedinečnou sekvenci. Číslo je po sobě jdoucí pouze v rámci oddílu a je předponou id oddílu.

nextSequence() == 12313112 -> false



normalize
normalize(<String to normalize> : string) => string


Normalizuje hodnotu řetězce na samostatné znaky unicode s diakritikou.

regexReplace(normalize('bo²s'), `\p{M}`, '') -> 'boys'



not
not(<value1> : boolean) => boolean


Logický operátor negace.

not(true) -> false
not(10 == 20) -> true



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


Porovnání není rovno operátoru. Stejné jako operátor !=

12 != 24 -> true
'bojjus' != 'bo' + 'jjus' -> false



nTile
nTile([<value1> : integer]) => integer


Funkce NTile rozdělí řádky pro každý oddíl okna do n kbelíků od 1 do maximálně n. Hodnoty kbelíku se budou lišit maximálně o 1. Pokud se počet řádků v oddílu rovnoměrně nerozdělí na počet kbelíků, pak se zbývající hodnoty rozdělí o jeden do kbelíku počínaje prvním kontejnerem. Funkce NTile je užitečná pro výpočet tertiles, kvartilů, deciles a dalších běžných souhrnných statistik. Funkce vypočítá dvě proměnné během inicializace: Velikost běžného kbelíku bude mít přidaný jeden další řádek. Obě proměnné jsou založené na velikosti aktuálního oddílu. Během procesu výpočtu funkce sleduje aktuální číslo řádku, aktuální číslo kbelíku a číslo řádku, ve kterém se kbelík změní (bucketThreshold). Když aktuální číslo řádku dosáhne prahové hodnoty kbelíku, hodnota kontejneru se zvýší o jednu a prahová hodnota se zvýší o velikost kbelíku (plus jeden další, pokud je aktuální kbelík vycpaný).

nTile()
nTile(numOfBuckets)



null
null() => null


Vrátí hodnotu NULL. syntax(null()) Funkci použijte, pokud existuje sloupec s názvem null. Jakákoli operace, která používá, bude mít za následek hodnotu 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


Logický operátor OR. Stejné jako ||.

or(true, false) -> true
true || false -> true



originColumns
originColumns(<streamName> : string) => any


Získá všechny výstupní sloupce pro původní datový proud, ve kterém byly sloupce vytvořeny. Musí být uzavřena v jiné funkci.

array(toString(originColumns('source1')))



output
output() => any


Vrátí první řádek výsledků jímky mezipaměti.

cacheSink#output()



outputs
output() => any


Vrátí celou sadu výstupních řádků výsledků jímky mezipaměti.

cacheSink#outputs()


P

partitionId
partitionId() => integer


Vrátí aktuální ID oddílu, ve které je vstupní řádek.

partitionId()



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


Kladné moduly páru čísel.

pmod(-20, 8) -> 4



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


Zvýší jedno číslo na mocninu druhého.

power(10, 2) -> 100


R

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


Převede stupně na radiány.

radians(180) => 3.141592653589793



random
random(<value1> : integral) => long


Vrátí náhodné číslo zadané volitelné počáteční hodnoty v rámci oddílu. Počáteční hodnota by měla být pevná a používá se s ID oddílu k vytvoření náhodných hodnot.

random(1) == 1 -> false



rank
rank() => integer


Vypočítá pořadí hodnoty ve skupině hodnot zadaných v klauzuli order by v okně. Výsledkem je jeden plus počet řádků předcházejících nebo rovno aktuálnímu řádku v pořadí oddílu. Hodnoty v sekvenci vytvoří mezery. Pořadí funguje i v případě, že data nejsou seřazená a hledají změny hodnot.

rank()



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


Transformuje mapu přidružením klíčů k novým hodnotám. Přebírá funkci mapování, ve které můžete položku řešit jako #key a aktuální hodnotu jako #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


Shromažďuje prvky v poli. Funkce Reduce očekává odkaz na akumulátor a jeden prvek v první funkci výrazu jako #acc a #item a očekává, že výsledná hodnota se použije jako #result ve druhé funkci výrazu.

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


Extrahujte odpovídající podřetěžce pro daný vzor regulárního výrazu. Poslední parametr identifikuje skupinu shody a pokud je vynechán, výchozí hodnota je 1. K porovnání řetězce bez zapouzdření použijte <regex>(zpětné uvozovky). Index 0 vrátí všechny shody. Bez odpovídajících skupin index 1 a vyšší nevrátí žádný výsledek.

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


Zkontroluje, jestli řetězec odpovídá danému vzoru regulárního výrazu. K porovnání řetězce bez zapouzdření použijte <regex>(zpětné uvozovky).

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


Nahraďte všechny výskyty vzoru regulárního výrazu jiným podřetězcem v daném řetězci Use <regex>(zpětné uvozovky) tak, aby odpovídaly řetězci bez zapouzdření.

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


Rozdělí řetězec na základě oddělovače na základě regulárního výrazu a vrátí pole řetězců.

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


Nahraďte všechny výskyty podřetězce jiným podřetězcem v daném řetězci. Pokud je poslední parametr vynechán, je výchozí prázdný řetězec.

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



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


Vrátí řetězec.

reverse('gunchus') -> 'suhcnug'



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


Extrahuje podřetěr s počtem znaků zprava. Stejné jako podřetězce(str, DÉLKA(str) - n, n).

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



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


Zkontroluje, jestli řetězec odpovídá danému vzoru regulárního výrazu.

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



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


Zaokrouhlí číslo zadanou volitelnou škálou a volitelný režim zaokrouhlování. Pokud je měřítko vynecháno, je ve výchozím nastavení nastaveno na 0. Pokud je režim vynechán, je výchozí hodnota ROUND_HALF_UP(5). Hodnoty pro zaokrouhlování zahrnují:

ROUND_UP – režim zaokrouhlování směrem od nuly.
ROUND_DOWN – režim zaokrouhlování na nulu.
ROUND_CEILING - režim zaokrouhlování na kladné nekonečno. [Stejné jako ROUND_UP, pokud je vstup pozitivní. Pokud je negativní, chová se jako ROUND_DOWN. Příklad = -1,1 by byl -1,0 s ROUND_CEILING a -2 s ROUND_UP]
ROUND_FLOOR – režim zaokrouhlování zaokrouhlení směrem k zápornému nekonečnu. [Stejné jako ROUND_DOWN, pokud je vstup pozitivní. Pokud je negativní, chová se jako ROUND_UP]
ROUND_HALF_UP – režim zaokrouhlování zaokrouhlení směrem k nejbližšímu sousedovi, pokud oba sousedy nejsou ekvividantní, v takovém případě ROUND_UP. [Nejběžnější + výchozí pro tok dat].
ROUND_HALF_DOWN – režim zaokrouhlování zaokrouhlení směrem k nejbližšímu sousedovi, pokud oba sousedy nejsou ekvividantní, v takovém případě ROUND_DOWN.
ROUND_HALF_EVEN – režim zaokrouhlování zaokrouhlení směrem k "nejbližšímu sousedovi", pokud oba sousedy nejsou ekvividantní, v takovém případě zaokrouhlení směrem k rovnoměrné sousedce.
ROUND_UNNECESSARY – režim zaokrouhlování k tvrzení, že operace zaokrouhlování má přesný výsledek, a proto není nutné zaokrouhlovat.


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



rowNumber
rowNumber() => integer


Přiřadí sekvenční číslování řádků pro řádky v okně začínajícím číslem 1.

rowNumber()


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


Pravá výplň řetězce zadaným odsazením, dokud není určitou délkou. Pokud je řetězec roven nebo větší než délka, je oříznutý na délku.

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



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


Vpravo oříznou řetězec koncových znaků. Pokud není zadaný druhý parametr, oříznou se prázdné znaky. Jinak oříznou libovolný znak zadaný v druhém parametru.

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


S

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


Získá druhou hodnotu data. Volitelné časové pásmo můžete předat ve tvaru GMT, PST, UTC, America/Cayman. Místní časové pásmo se používá jako výchozí. Dostupné formáty najdete ve třídě Javy 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


Doba trvání v milisekundách po dobu několika sekund.

seconds(2) -> 2000L



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


Nastaví pozice bitů v této bitové sadě.

setBitSet(toBitSet([10, 32]), [98]) => [4294968320L, 17179869184L]



sha1
sha1(<value1> : any, ...) => string


Vypočítá hodnotu hash SHA-1 sady sloupců různých primitivních datových typů a vrátí šestnáctkový řetězec 40 znaků. Dá se použít k výpočtu otisku prstu pro řádek.

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



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


Vypočítá hodnotu hash SHA-2 sady sloupců s různými primitivními datovými typy zadanou bitovou délkou, která může být pouze z hodnot 0(256), 224, 256, 384, 512. Dá se použít k výpočtu otisku prstu pro řádek.

sha2(256, 'gunchus', 8.2, 'bojjus', true, toDate('2010-4-4')) -> 'afe8a553b1761c67d76f8c31ceef7f71b66a1ee6f4e6d3b5478bf68b47d06bd3'



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


Vypočítá sinusovou hodnotu.

sin(2) -> 0.9092974268256817



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


Vypočítá hyperbolickou sinusovou hodnotu.

sinh(0) -> 0.0



size
size(<value1> : any) => integer


Najde velikost pole nebo typu mapy.

size(['element1', 'element2']) -> 2
size([1,2,3]) -> 3



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


Získá nerovnoměrnou distribuci sloupce.

skewness(sales)



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


Na základě kritérií získá nerovnoměrnou distribuci sloupce.

skewnessIf(region == 'West', sales)



slice
slice(<array to slice> : array, <from 1-based index> : integral, [<number of items> : integral]) => array


Extrahuje podmnožinu pole z pozice. Pozice je založená na 1. Pokud je délka vynechána, je ve výchozím nastavení nastavená na konec řetězce.

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


Seřadí pole pomocí zadané predikátové funkce. Funkce Sort očekává odkaz na dva po sobě jdoucí prvky ve výrazu jako #item1 a #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 Získá kód pro řetězec.

soundex('genius') -> 'G520'



split
split(<string to split> : string, <split characters> : string) => array


Rozdělí řetězec na základě oddělovače a vrátí pole řetězců.

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


Vypočítá druhou odmocninu čísla.

sqrt(9) -> 3



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


Zkontroluje, jestli řetězec začíná zadaným řetězcem.

startsWith('dumbo', 'du') -> true



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


Získá směrodatnou odchylku sloupce.

stdDev(sales)



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


Na základě kritérií získá směrodatnou odchylku sloupce.

stddevIf(region == 'West', sales)



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


Získá směrodatnou odchylku základního souboru sloupce.

stddevPopulation(sales)



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


Na základě kritérií získá směrodatnou odchylku základního souboru sloupce.

stddevPopulationIf(region == 'West', sales)



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


Získá vzorovou směrodatnou odchylku sloupce.

stddevSample(sales)



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


Na základě kritérií získá směrodatnou odchylku vzorku sloupce.

stddevSampleIf(region == 'West', sales)



subDays
subDays(<date/timestamp> : datetime, <days to subtract> : integral) => datetime


Odečítá dny od data nebo časového razítka. Stejné jako operátor - pro datum.

subDays(toDate('2016-08-08'), 1) -> toDate('2016-08-07')



subMonths
subMonths(<date/timestamp> : datetime, <months to subtract> : integral) => datetime


Odečítá měsíce od data nebo časového razítka.

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


Extrahuje podřetězení určité délky z pozice. Pozice je založená na 1. Pokud je délka vynechána, je ve výchozím nastavení nastavená na konec řetězce.

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>


Extrahuje podřetězen count před výskyty oddělovače. Pokud count je kladné, vrátí se vše nalevo od konečného oddělovače (počítá se zleva). Pokud count je záporné, vrátí se vše napravo od konečného oddělovače (počítá se zprava).


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


Získá agregovaný součet číselného sloupce.

sum(col)



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


Získá agregovaný součet jedinečných hodnot číselného sloupce.

sumDistinct(col)



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


Na základě kritérií získá agregovaný součet číselného sloupce. Podmínka může být založená na libovolném sloupci.

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



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


Na základě kritérií získá agregovaný součet číselného sloupce. Podmínka může být založená na libovolném sloupci.

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


T

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


Vypočítá tangens hodnotu.

tan(0) -> 0.0



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


Vypočítá hyperbolickou tangensovou hodnotu.

tanh(0) -> 0.0



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


Zakóduje daný řetězec v base64. Volitelně můžete předat typ kódování.

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



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


Převede libovolnou číselnou hodnotu/datum/časové razítko/řetězec na binární reprezentaci.

toBinary(3) -> [0x11]



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


Převede hodnotu (t), true, y, yes, 1 na true a (f, n, no, 0) na false a null pro jakoukoli jinou hodnotu.

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



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


Převede libovolnou číselnou hodnotu nebo řetězec na bajtovou hodnotu. Pro převod lze použít volitelný desetinný formát Jazyka Java.

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



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


Převede vstupní řetězec data na datum pomocí volitelného vstupního formátu data. Dostupné formáty najdete ve třídě Javy SimpleDateFormat . Pokud je formát vstupního data vynechán, výchozí formát je rrrr-[M]M-[d]d. Přijaté formáty jsou :[ y, y-[M]M, y-[M]M-[d]d, y-[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)


Převede libovolnou číselnou nebo řetězcovou hodnotu na desetinnou hodnotu. Pokud není zadána přesnost a měřítko, je výchozí hodnota (10,2). Pro převod lze použít volitelný desetinný formát Jazyka Java. Volitelný formát národního prostředí ve formě jazyka BCP47, jako je en-US, de, zh-CN.

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



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


Převede libovolnou číselnou hodnotu nebo řetězec na dvojitou hodnotu. Pro převod lze použít volitelný desetinný formát Jazyka Java. Volitelný formát národního prostředí ve formě jazyka BCP47, jako je en-US, de, zh-CN.

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



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


Převede libovolnou číselnou hodnotu nebo řetězec na hodnotu s plovoucí desetinnou čárkou. Pro převod lze použít volitelný desetinný formát Jazyka Java. Zkrátí všechny dvojité.

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


Převede libovolnou číselnou hodnotu nebo řetězec na celočíselnou hodnotu. Pro převod lze použít volitelný desetinný formát Jazyka Java. Zkrátí všechny dlouhé, plovoucí, dvojité.

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



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


Převede libovolnou číselnou nebo řetězcovou hodnotu na dlouhou hodnotu. Pro převod lze použít volitelný desetinný formát Jazyka Java. Zkrátí všechny plovoucí, dvojité.

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



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


Získá nejvyšší N hodnoty pro tento sloupec na základě argumentu count.

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



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


Převede libovolnou číselnou nebo řetězcovou hodnotu na krátkou hodnotu. Pro převod lze použít volitelný desetinný formát Jazyka Java. Zkrátí celé číslo, dlouhé, plovoucí, dvojité.

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



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


Převede primitivní datový typ na řetězec. Pro čísla a datum lze zadat formát. Pokud není zadán výchozí systém, vybere se. Desetinný formát Jazyka Java se používá pro čísla. Všechny možné formáty kalendářních dat najdete v Jazyce Java SimpleDateFormat; výchozí formát je rrrr-MM-dd. Pro datum nebo časové razítko lze volitelně zadat národní prostředí.

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


Převede řetězec na časové razítko s volitelným formátem časového razítka. Pokud je časové razítko vynecháno, použije se výchozí vzor y-[M]M-[d]d hh:mm:ss[.f...]. Volitelné časové pásmo můžete předat ve tvaru GMT, PST, UTC, America/Cayman. Časové razítko podporuje až milisekundovou přesnost s hodnotou 999. Dostupné formáty najdete ve třídě Javy SimpleDateFormat . https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html.

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



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


Převede časové razítko na UTC. Volitelné časové pásmo můžete předat ve tvaru GMT, PST, UTC, America/Cayman. Výchozí hodnota je aktuální časové pásmo. Dostupné formáty najdete ve třídě Javy SimpleDateFormat . https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html.

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


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


Nahraďte jednu sadu znaků jinou sadou znaků v řetězci. Znaky mají nahrazení 1 až 1.

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



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


Oříznou řetězec počátečních a koncových znaků. Pokud není zadaný druhý parametr, oříznou se prázdné znaky. Jinak oříznou libovolný znak zadaný v druhém parametru.

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



true
true() => boolean


Vždy vrátí hodnotu true. syntax(true()) Funkci použijte, pokud existuje sloupec s názvem true.

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



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


Odpovídá typu sloupce. Lze použít pouze ve vzorových výrazech.number odpovídá krátkému, celočíselnému, dlouhému, dvojitému, plovoucímu nebo desítkovému, celočíselnému integrálu, dlouhému, zlomkovému shodování s dvojitou desetinnou čárkou, desetinným číslem, desetinným číslem a datem a časem odpovídá typu data nebo časového razítka.

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


U

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


Unescapes řetězec podle formátu. Hodnoty literálů pro přijatelný formát jsou json, xml, ecmascript, html, java.

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



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


Rozbalí matici do sady řádků a zopakuje hodnoty pro zbývající sloupce v každém řádku.

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



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


Unhexes binární hodnotu z řetězcové reprezentace. To lze použít s sha2, md5 pro převod z řetězce na binární reprezentaci.

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


Vrátí sjednocovací sadu odlišných položek od 2 polí.

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



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


Velká písmena řetězce.

upper('bojjus') -> 'BOJJUS'



uuid
uuid() => string


Vrátí vygenerované UUID.

uuid()


V

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


Získá odchylku sloupce.

variance(sales)



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


Na základě kritérií získá rozptyl sloupce.

varianceIf(region == 'West', sales)



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


Získá rozptyl základního souboru sloupce.

variancePopulation(sales)



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


Na základě kritérií získá rozptyl základního souboru sloupce.

variancePopulationIf(region == 'West', sales)



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


Získá nestrannou odchylku sloupce.

varianceSample(sales)



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


Na základě kritérií získá nestrannou odchylku sloupce.

varianceSampleIf(region == 'West', sales)


S

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


Získá týden v roce zadané datum.

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



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


Doba trvání v milisekundách po dobu několika týdnů.

weeks(2) -> 1209600000L


X

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


Logický operátor XOR Stejné jako ^ – operátor.

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


Y

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


Získá hodnotu roku kalendářního data.

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

Související obsah

Seznam všech agregačních funkcí
Seznam všech maticových funkcí
Seznam všech vyhledávacích funkcí uložených v mezipaměti
Seznam všech funkcí převodu
Seznam všech funkcí data a času
Seznam všech funkcí výrazů
Seznam všech mapových funkcí
Seznam všech metafunkcí
Seznam všech funkcí okna
Naučte se používat Tvůrce výrazů.

Share via

Použití výrazů transformace dat v mapování toku dat

Abecední seznam všech funkcí

A

abs

acos

add

addDays

addMonths

and

approxDistinctCount

array

ascii

asin

assertErrorMessages

associate

at

atan

atan2

avg

avgIf

T

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`