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

VZTAHUJE SE NA: Azure Data Factory Azure Synapse Analytics

Tip

Data Factory v Microsoft Fabric je nová generace Azure Data Factory s jednodušší architekturou, integrovanou AI a novými funkcemi. Pokud s integrací dat začínáte, začněte Fabric Data Factory. Stávající úlohy ADF lze upgradovat na Fabric pro přístup k novým funkcím v oblastech datové vědy, analýz v reálném čase a vytváření sestav.

Toky dat jsou k dispozici v kanálech Azure Data Factory i v kanálech Azure Synapse Analytics. 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í toků dat.

Tento článek obsahuje podrobnosti o použití všech výrazů a funkcí podporovaných 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ásledující abecední seznam obsahuje všechny funkce, které jsou k dispozici v mapování toků dat.

A

abs

abs(<value1> : number) => number

Vrátí absolutní hodnotu čí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á datové označení na mnoho dnů. Přidá dobu trvání do časového razítka. Připojí jedno pole podobného typu k jiné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řidá dny k datu nebo časové značce. Stejné jako + operátor kalendářních dat.

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

addMonths

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

Přidá měsíce k datu nebo časovému razítku. Volitelně můžete předat časové pásmo.

  • 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

Používá logický AND operátor. 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 pole prázdných řetězců výchozí. Stejné jako operátor [] pro vytvoř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íč.

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

Vytvoří mapu klíčů/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í je použita mapa s typem řetězec-řetězec. Stejné jako operátor [ -> ] pro 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 1-základový. Index mimo hranice má za následek hodnotu null. Vyhledá hodnotu v mapě při zadání klíče. 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á hodnotu inverzního tangens.

  • 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

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

  • avgIf(region == 'West', sales)

B

between

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

Zkontroluje, jestli je první hodnota mezi dvěma dalšími hodnotami včetně. Můžete porovnat číselné hodnoty, řetězce a datetime hodnoty.

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

bitwiseAnd

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

Používá bitový And operátor napříč celočíselnými typy. Stejné jako operátor & .

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

bitwiseOr

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

Používá bitový Or operátor napříč celočíselnými typy. Stejné jako operátor | .

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

bitwiseXor

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

Používá bitový Or operátor 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á shrnutí Blake2 pro množinu sloupců obsahující různé primitivní datové typy při zadání bitové délky, která musí být násobkem 8 od 8 do 512. Můžete ho 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 pro sadu sloupců s různými primitivními datovými typy při uvedení bitové délky, kde délka musí být pouze násobkem 8 v rozmezí od 8 do 512. Můžete ho 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

Najde dílčí položku v rámci struktury nebo pole struktury. Pokud existuje více shod, vrátí se první shoda. Pokud neexistují žádné shody, vrátí se hodnota NULL. Vrácená hodnota musí být převedena jednou z akcí převodu typu (například ? date a ? string). Adresovat názvy sloupců známé v době návrhu podle jejich názvů. Vypočítané vstupy se nepodporují, ale můžete použít nahrazení 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 neexistují žádné shody, vrátí se hodnota NULL. Vrácená hodnota musí být převedena jednou z funkcí převodu typů (například TO_DATE a TO_STRING). Adresovat názvy sloupců známé v době návrhu podle jejich názvů. Vypočítané vstupy se nepodporují, 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 (například toDate a toString). Adresovat názvy sloupců známé v době návrhu podle jejich názvů. Vypočítané vstupy se nepodporují, 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 neexistují žádné shody, vrátí se hodnota NULL. Vrácená hodnota musí být převedena jednou z funkcí převodu typů (například TO_DATE a TO_STRING). Adresovat názvy sloupců známé v době návrhu podle jejich názvů. Vypočítané vstupy se nepodporují, 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 neexistují žádné shody, vrátí se hodnota NULL. Vrácená hodnota musí být převedena jednou z funkcí převodu typů (například TO_DATE a TO_STRING). Adresovat názvy sloupců známé v době návrhu podle jejich názvů. Vypočítané vstupy se nepodporují, 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í NULL. Názvy sloupců a cesty známé během návrhu by měly být odkazovány pouze pomocí jejich názvu nebo cesty v notaci s tečkou. Vypočítané vstupy se nepodporují, ale můžete použít nahrazení parametrů.

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

byPosition

byPosition(<position> : integer) => any

Vybere hodnotu sloupce podle relativní pozice (začínající od 1) v datovém toku. Pokud je pozice mimo hranice, vrátí NULL hodnotu. Vrácená hodnota musí být převedena jednou z funkcí převodu typů (například TO_DATE ).TO_STRING Vypočítané vstupy se nepodporují, 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 case funkce použije jednu nebo druhou hodnotu. Pokud je počet vstupů sudý, druhý se ve výchozím nastavení nastaví na NULL pro poslední podmínku.

  • 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 je ekvivalentní znaku (číslo % 256).

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

coalesce

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

Vrátí první nenullovou hodnotu 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 můžete shromažďovat a transformovat struktury na alternativní struktury. Počet položek se rovná počtu řádků v dané 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 můžete shromažďovat a transformovat struktury na alternativní struktury. Počet položek se rovná počtu řádků v dané 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ů datového proudu. 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(), Data Factory vrátí pouze sloupce, které jsou posunuty přes posun schématu.

  • 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, a kladnou hodnotu, 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ů s použitím oddělovače. 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í true , pokud se některý prvek v zadaném poli vyhodnotí jako true v zadaném predikátu. Funkce Th contains očekává odkaz na jeden prvek jako argument predikátové funkce #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 je zadán jeden nebo více volitelných sloupců, ignoruje NULL hodnoty 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 množiny sloupců včetně hodnot null.

  • countAllDistinct(custId, custName)

countIf

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

Získá agregovaný počet hodnot na základě kritérií. Pokud je specifikován volitelný sloupec, počítání ignoruje hodnoty NULL.

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

covariancePopulation

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

Získá populační kovarianci mezi dvěma sloupci.

  • covariancePopulation(sales, profit)

covariancePopulationIf

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

Získá populační kovarianci dvou sloupců na základě kritérií.

  • covariancePopulationIf(region == 'West', sales)

covarianceSample

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

Získá výběrovou kovarianci dvou sloupců.

  • covarianceSample(sales, profit)

covarianceSampleIf

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

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

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

crc32

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

Vypočítá hodnotu hash CRC32 množiny sloupců různých primitivních datových typů při zadání bitové délky, která může být pouze z hodnot 0(256), 224, 256, 384a 512. Můžete ho 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 shodné hodnoty v pořadí budou vyhodnoceny na stejnou pozici.

  • cumeDist()

currentDate

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

Získá aktuální datum, kdy se tato úloha spustí. Volitelně můžete předat časové pásmo ve formě GMT, PST, UTCnebo 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 v Java třídy 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

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í časovou značku v čase UTC. Pokud chcete, aby váš aktuální čas byl interpretován v jiném časovém pásmu než v časovém pásmu clusteru, můžete předat volitelné časové pásmo ve formě GMT, PST, UTCnebo America/Cayman. Výchozí hodnota je aktuální časové pásmo. Dostupné formáty najdete v Java třídy SimpleDateFormat. 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 při zadání data.

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

dayOfWeek

dayOfWeek(<value1> : datetime) => integer

Zjistí den v týdnu při zadání data. Například 1 je neděle, 2 je pondělí, ... a 7 je sobota.

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

dayOfYear

dayOfYear(<value1> : datetime) => integer

Zjistí den v roce na základě zadaného data.

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

days

days(<value1> : integer) => long

Doba trvání v milisekundách pro počet 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. Pomocí druhého (volitelného) argumentu můžete určit, která znaková sada se má použít. Příklady: US-ASCII, , ISO-8859-1( UTF-8 výchozí), UTF-16BE, UTF-16LE, a 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 specifikovaných v klauzuli ORDER BY v rámci okna. Výsledkem je jedna plus počet řádků, které předcházejí aktuálnímu řádku, nebo jsou mu rovné v pořadí oddílu. Hodnoty nevytvářely mezery v sekvenci. Funkce denseRank funguje i v případě, že data nejsou seřazená a hledají změny hodnot.

  • denseRank()

distinct

distinct(<value1> : array) => array

Vrátí unikátní množinu položek z pole.

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

divide

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

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

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

dropLeft

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

Odstraní co nejvíce znaků z levé části řetězce. Pokud požadovaný pokles překročí délku řetězce, vrátí se prázdný řetězec.

  • dropLeft('bojjus', 2) => 'jjus'
  • dropLeft('cake', 10) => ''

dropRight

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

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

  • dropRight('bojjus', 2) => 'bojj'
  • dropRight('cake', 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. Příklady: US-ASCII, , ISO-8859-1( UTF-8 výchozí), UTF-16BE, UTF-16LE, a UTF-16.

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

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

Používá operátor porovnání rovnosti. 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

Používá operátor rovnosti ignorující velikost písmen. 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, a java.

except

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

Vrátí množinu rozdílů jednoho pole od druhého odstraněním duplicit.

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

expr

expr(<expr> : string) => any

Výsledkem je výraz z řetězce, který je stejný jako zápis tohoto výrazu v neliterální podobě. Můžete ho použít k předání parametrů jako řetězcových reprezentací.

  • expr('price * discount') => any

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 je sloupec pojmenován 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átové 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 adresovat položku v poli jako #item. U hluboko vnořených map můžete odkazovat na nadřazené mapy pomocí #item_n notace (#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, služba Data Factory předpokládá hodnotu false.

  • first(sales)
  • first(sales, false)

flatten

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

Zplošťuje pole nebo pole do jednoho pole. Pole atomických položek se vracejí beze změny. Poslední argument je nepovinný a ve výchozím nastavení je nastaven na false, což umožňuje zploštění více než jedné úrovně rekurzivně.

  • 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 konkrétní řetězec kódovaný v 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 se na časové razítko z UTC. Volitelně můžete předat časové pásmo ve formě GMT, PST, UTC, nebo America/Cayman. Výchozí hodnota je aktuální časové pásmo. Dostupné formáty najdete v Java třídy 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

Používá operátor větší porovnání. 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

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

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

greatest

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

Vrátí nejvyšší hodnotu ze seznamu hodnot jako vstupu a přeskočí hodnoty null. Vrátí null , pokud všechny vstupy mají hodnotu 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. Adresovat názvy sloupců známé v době návrhu podle jejich názvů. Vypočítané vstupy se nepodporují, ale můžete použít nahrazení parametrů.

  • hasColumn('parent')

hasError

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

Kontroluje, zda je položka se zadaným ID označena jako chyba.

Examples

  • 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é během návrhu by měly být odkazovány pouze pomocí jejich názvu nebo cesty v notaci s tečkou. Vypočítané vstupy se nepodporují, 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á hodnotu hodiny časového razítka. Volitelně můžete předat časové pásmo ve formě GMT, PST, UTCnebo America/Cayman. Místní časové pásmo se používá jako výchozí. Dostupné formáty najdete v Java třídy 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

Získá dobu trvání v milisekundách pro počet hodin.

  • hours(2) -> 7200000L

I

iif

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

Použije jednu nebo druhou hodnotu na základě podmínky. Pokud druhý není zadán, hodnota je považována za NULL. Obě hodnoty musí být kompatibilní (například číselné a ř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

Vrátí první položku, která nemá hodnotu null, pokud zadáte dva nebo více vstupů. Tato funkce je ekvivalentní coalesce funkci.

  • 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 podřetězce v řetězci (počínaje od 1). Pokud se nenajde, vrátí se 0.

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

intersect

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

Vrátí množinu různých položek ze dvou 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, zda je řetězcová hodnota Boolean hodnota podle pravidel toBoolean().

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

isByte

isByte(<value1> : string) => boolean

Zkontroluje, jestli je řetězcová hodnota bajtová hodnota, pokud je uveden volitelný formát podle pravidel toByte().

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

isDate

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

Zkontroluje, jestli je vstupní řetězec datum pomocí volitelného formátu data. Dostupné formáty najdete v Java třídy SimpleDateFormat. Pokud je vynechán vstupní formát data, 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 desetinná hodnota, pokud je uveden volitelný formát podle pravidel .toDecimal()

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

isDelete

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

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

  • isDelete()
  • isDelete(1)

isDistinct

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

Najde, jestli je sloupec nebo sada sloupců odlišná. Nezapočítává 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, pokud je uveden volitelný formát 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 než jeden vstupní datový 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, zda hodnota řetězce je plovoucí hodnota, pokud je uveden volitelný formát podle pravidel toFloat().

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

isIgnore

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

Zkontroluje, jestli se má řádek ignorovat. U transformací, které přebírají více než jeden vstupní datový proud, můžete předat index datového proudu (1). Index datového proudu by měl být buď 1 nebo 2a 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 než jeden vstupní datový proud, můžete předat index datového proudu (1). Index datového proudu by měl být buď 1 nebo 2a výchozí hodnota je 1.

  • isInsert()
  • isInsert(1)

isInteger

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

Zkontroluje, zda hodnota řetězce je celočíselná hodnota, pokud je uveden volitelný formát podle pravidel .toInteger()

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

isLong

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

Zkontroluje, zda je hodnota řetězce dlouhá hodnota, když je uveden volitelný formát 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 než jeden vstupní datový proud, můžete předat index datového proudu (1). Index datového proudu by měl být buď 1 nebo 2a výchozí hodnota je 1.

  • isMatch()
  • isMatch(1)

isNan

isNan (<value1> : integral) => boolean

Zkontroluje, jestli hodnota není čí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, zda je řetězcová hodnota krátká hodnota, pokud je uveden volitelný formát podle pravidel .toShort()

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

isTimestamp

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

Kontroluje, jestli je vstupní řetězec datumového formátu časové razítko pomocí volitelného vstupního formátu časového razítka. Dostupné formáty najdete v Java třídy SimpleDateFormat. Pokud je časové razítko vynecháno, použije se výchozí vzor yyyy-[M]M-[d]d hh:mm:ss[.f...] . Volitelně můžete předat časové pásmo ve formě GMT, PST, UTCnebo America/Cayman. Funkce timestamp podporuje až milisekundovou přesnost s hodnotou 999. Dostupné formáty najdete v Java třídy 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

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

  • isUpsert()
  • isUpsert(1)

J

jaroWinkler

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

Zjistí vzdálenost Jaro-Winkler mezi dvěma řetězci.

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

K

keyValues

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

Vytvoří mapu klíčů/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

Provádí výpočet kurtózy sloupce.

  • kurtosis(sales)

kurtosisIf

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

Vypočítá kurtózu sloupce podle stanovených kritérií.

  • 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ých 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í k dispozici tolik řádků, vrátí se hodnota null, 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, že je false.

  • last(sales)
  • last(sales, false)

lastDayOfMonth

lastDayOfMonth(<value1> : datetime) => date

Získá poslední datum v měsíci, pokud je 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ých n řádků za aktuálním řádkem. Druhým parametrem je počet řádků, které se mají dívat dopředu, a výchozí hodnota je 1. Pokud není k dispozici tolik řádků, vrátí se hodnota null, pokud není zadána výchozí hodnota.

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

least

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

Používá porovnání menší než nebo rovno 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 SUBSTRING(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

Používá porovnávací 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

Používá porovnání menší než nebo rovno operátoru. Stejné jako operátor <= .

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

levenshtein

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

Určuje Levenshteinovu vzdálenost mezi dvěma řetězci.

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

like

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

Používá vzor řetězce, který odpovídá 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 (počítáno od 1) podřetězce v řetězci, přičemž hledání začíná na určité pozici. Pokud je pozice vynechána, začíná na začátku řetězce. Pokud se nenajde, vrátí se 0.

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

log

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

Vypočítá logaritmickou hodnotu. Pokud použijete, můžete zadat volitelný základ nebo jiné číslo Euleru.

  • log(100, 10) -> 2

log10

log10(<value1> : number) => double

Vypočítá logaritmickou hodnotu se základem 10.

  • 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

Převádí řetězec na malá písmena.

  • lower('GunChus') -> 'gunchus'

lpad

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

Doleva odsazuje řetězec pomocí dodatečného odsazení, dokud řetězec nedosáhne určité délky. Pokud je řetězec roven nebo větší než zadaná délka, řetězec se ořízne na tuto 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 druhý parametr není zadaný, oříznou se prázdné znaky. Jinak ořízne všechny znaky určené v druhém parametru.

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

M

map

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

Namapuje každý prvek pole na nový prvek pomocí poskytnutého výrazu. Funkce map 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í, kde můžete přistupovat k položce 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 mohou být libovolného datového typu, včetně structTypes. Přebírá funkci mapování, kde můžete adresovat položku v poli jako #item a index jako #index. U hluboko vnořených map můžete odkazovat na nadřazené mapy pomocí notace #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

Namapuje každý prvek pole na nový prvek pomocí poskytnutého výrazu. Funkce map 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

Prochází smyčkou od 1 do zadané délky a vytvoří pole o této délce. Přebírá funkci mapování, kde můžete adresovat index v poli jako #index. U hluboko vnořených map můžete odkazovat na nadřazené mapy pomocí #index_n notace (#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

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

  • 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 se 32 znaky. Můžete ho 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

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

  • meanIf(region == 'West', sales)

millisecond

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

Získá hodnotu milisekund daného data. Volitelně můžete předat časové pásmo ve formě GMT, PST, UTCnebo America/Cayman. Místní časové pásmo se používá jako výchozí. Dostupné formáty najdete v Java třídy SimpleDateFormat.

  • millisecond(toTimestamp('2009-07-30 12:58:59.871', 'yyyy-MM-dd HH:mm:ss.SSS')) -> 871

milliseconds

milliseconds(<value1> : integer) => long

Získá dobu 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

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

  • minIf(region == 'West', sales)

minus

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

Odečte čísla. Odečte počet dní od data. Odečte dobu trvání od časového razítka. Odeč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ě můžete předat časové pásmo ve formě GMT, PST, UTCnebo America/Cayman. Místní časové pásmo se používá jako výchozí. Dostupné formáty najdete v Java třídy 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

Získá dobu trvání v milisekundách pro počet 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

Získá moduly dvojice čí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ě můžete předat časové pásmo ve formě GMT, PST, UTCnebo America/Cayman. Místní časové pásmo se používá jako výchozí. Dostupné formáty najdete v Java třídy SimpleDateFormat.

  • 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 souvislé pouze v rámci oddílu a je opatřeno předponou s ID oddílu.

  • nextSequence() == 12313112 -> false

normalize

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

Normalizuje hodnotu řetězce na samostatné zvýrazňované znaky Unicode.

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

not

not(<value1> : boolean) => boolean

Používá logický operátor negace.

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

notEquals

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

Používá relační operátor nerovná se. Stejné jako operátor != .

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

nTile

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

Funkce nTile rozdělí řádky každého oddílu okna do n segmentů, které se pohybují od 1 až do nejvýše n. Hodnoty kbelíku se liší nejvýše o 1. Pokud se počet řádků v oddílu rovnoměrně nerozdělí na počet kbelíků, zbývající hodnoty se rozdělí po jedné do každého kbelíku, počínaje prvním kbelíkem. 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 má přidán jeden řádek navíc. 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 kbelíku se zvýší o jednu. Prahová hodnota se zvýší o velikost bucketu (plus jeden navíc, pokud je aktuální bucket doplněn).

  • nTile()
  • nTile(numOfBuckets)

null

null() => null

Vrátí hodnotu NULL. syntax(null()) Funkci použijte, pokud je sloupec pojmenován null. Každá operace, která používá hodnotu null, vede k hodnotě 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

Používá logický OR operátor. 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řeno v rámci jiné funkce.

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

output

output() => any

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

  • cacheSink#output()

outputs

output() => any

Vrátí celou sadu výstupních řádků výsledků z úložiště 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

Poskytuje kladné moduly dvojice čí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) => double

Vrátí náhodné číslo při zadaném semenu v rámci sekce. Semeno by mělo být pevnou hodnotou a používá se s ID oddílu k generování náhodných hodnot v rozsahu (0.0-1.0).

  • random(1) == 1 -> false

rank

rank() => integer

Vypočítá pořadí hodnoty ve skupině hodnot specifikovaných v klauzuli ORDER BY v rámci okna. Výsledkem je jedna plus počet řádků, které předcházejí aktuálnímu řádku, nebo jsou mu rovné v pořadí oddílu. Hodnoty vytvářejí mezery v sekvenci. Funkce rank 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í, kde můžete přistupovat k položce 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. Očekává se, že výsledná hodnota jako #result bude použita 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

Extrahuje odpovídající podřetězec pro daný vzor regulárního výrazu. Poslední parametr identifikuje skupinu shody a v případě vynechání se použije výchozí hodnota 1. Slouží <regex> k porovnávání řetězce bez odvozování. Index 0 vrátí všechny shody. Bez odpovídajících skupin nevrací index 1 ani výše žá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. Slouží <regex> k porovnávání řetězce bez odvozování.

  • 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

Nahradí všechny výskyty vzoru regulárního výrazu jiným podřetězcem v konkrétním řetězci. Slouží <regex> k porovnávání řetězce bez odvozování.

  • 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 pomocí oddělovače podle 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

Nahradí všechny výskyty podřetězce jiným podřetězcem v konkrétním řetězci. Pokud je poslední parametr vynechán, výchozí hodnota je 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

Převrátí řetězec.

  • reverse('gunchus') -> 'suhcnug'

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

Extrahuje podřetězec o určitém počtu znaků zprava. Stejné jako SUBSTRING(str, LENGTH(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, pokud zadáte volitelné měřítko a volitelný režim zaokrouhlování. Pokud je měřítko vynecháno, výchozí hodnota je 0. Pokud je režim vynechán, výchozí hodnota je ROUND_HALF_UP(5). Mezi hodnoty zaokrouhlení patří:

  1. ROUND_UP: Režim zaokrouhlování, který zaokrouhluje od nuly.

  2. ROUND_DOWN: Režim zaokrouhlování směrem k nule.

  3. ROUND_CEILING: Režim zaokrouhlování směrem ke kladnému nekonečnu. (Stejné jako ROUND_UP v případě, že vstup je kladný. Pokud je negativní, chová se jako ROUND_DOWN. Například -1.1 by byl -1.0 s ROUND_CEILING a -2 s ROUND_UP.)

  4. ROUND_FLOOR: Režim zaokrouhlování směrem k zápornému nekonečnu. (Stejné jako ROUND_DOWN v případě, že vstup je kladný. Pokud je negativní, chová se jako ROUND_UP.)

  5. ROUND_HALF_UP: Režim zaokrouhlování směrem k "nejbližšímu sousedovi", pokud oba sousedé nejsou stejně vzdálení, v takovém případě se chová jako ROUND_UP. (Nejběžnější + výchozí pro tok dat.)

  6. ROUND_HALF_DOWN: Režim zaokrouhlování směrem k "nejbližšímu sousedovi", pokud jsou oba sousedé stejně vzdálení, v takovém případě ROUND_DOWN.

  7. ROUND_HALF_EVEN: Režim zaokrouhlování směrem k nejbližšímu sousedovi, pokud oba sousedé nejsou rovno vzdálení, v takovém případě zaokrouhlení směrem k sudému sousedovi.

  8. ROUND_UNNECESSARY: Režim zaokrouhlování, aby se potvrdilo, že operace zaokrouhlování má přesný výsledek, takže 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

Doplní řetězec napravo zadaným odsazením, dokud řetězec nedosáhne určité délky. Pokud je řetězec roven nebo větší než zadaná délka, řetězec se ořízne na tuto délku.

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

rtrim

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

Pravá strana ořízne řetězec od koncových znaků. Pokud druhý parametr není zadaný, oříznou se prázdné znaky. Jinak ořízne všechny znaky určené 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ě můžete předat časové pásmo ve formě GMT, PST, UTCnebo America/Cayman. Místní časové pásmo se používá jako výchozí. Dostupné formáty najdete v Java třídy SimpleDateFormat.

  • second(toTimestamp('2009-07-30 12:58:59')) -> 59

seconds

seconds(<value1> : integer) => long

Udává dobu trvání v milisekundách pro počet 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á SHA-1 hash pro sadu sloupců s různými primitivními datovými typy a vrátí šestnáctkový řetězec o 40 znacích. Můžete ho 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á otisk SHA-2 pro sadu sloupců různých primitivních datových typů při zadání bitové délky, která může být pouze z hodnot 0(256), 224, 256, 384 a 512. Můžete ho 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á hodnotu hyperbolického sinu.

  • 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

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

  • skewnessIf(region == 'West', sales)

slice

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

Extrahuje podmnožinu pole od dané pozice. Pozice je založená na 1. Pokud je délka vynechána, nastaví se 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 funkci 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

Získává kód pro řetězec soundex.

  • 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 dat.

  • stdDev(sales)

stddevIf

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

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

  • stddevIf(region == 'West', sales)

stddevPopulation

stddevPopulation(<value1> : number) => double

Získá směrodatnou odchylku populace pro sloupec.

  • stddevPopulation(sales)

stddevPopulationIf

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

Vypočítá směrodatnou odchylku populace sloupce na základě specifikovaných kritérií.

  • 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

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

  • stddevSampleIf(region == 'West', sales)

subDays

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

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

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

subMonths

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

Odečte 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ězec určité délky z pozice. Pozice je založená na 1. Pokud je délka vynechána, nastaví se 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( <řetězec k podmnožině><oddělovač>substringIndex( : string, : string, <počet výskytů oddělovače> : celé číslo]) => řetězec

Extrahuje podřetězec před stanoveným počtem výskytů oddělovače. Pokud je počet kladný, vrátí se vše vlevo od konečného oddělovače (počítá se zleva). Pokud je počet 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

Získá agregovaný součet číselného sloupce na základě kritérií. 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

Získá agregovaný součet číselného sloupce na základě kritérií. 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á hodnotu tangensu.

  • 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

Kóduje konkrétní ř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 libovolné číselné číslo, datum, časové razítko nebo řetězec na binární reprezentaci.

  • toBinary(3) -> [0x11]

toBoolean

toBoolean(<value1> : string) => boolean

Převede hodnotu (t, , true, y, yes1) na hodnotu true a (f, false, , n, no0) 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 můžete použít volitelný Java desetinný formát.

  • 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 v Java třídy SimpleDateFormat. Pokud je vynechán vstupní formát data, 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* ].

  • 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, výchozí hodnota je (10,2). Pro převod můžete použít volitelný Java desetinný formát. Použijte volitelný formát národního prostředí ve formě jazyka BCP47, jako je en-US, de nebo 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 můžete použít volitelný Java desetinný formát. Použijte volitelný formát národního prostředí ve formě jazyka BCP47, jako je en-US, de nebo 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 datový typ float. Pro převod můžete použít volitelný Java desetinný formát. 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 můžete použít volitelný Java desetinný formát. 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 můžete použít volitelný Java desetinný formát. 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 můžete použít volitelný Java desetinný formát. Zkrátí libovolný int, 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

Převede primitivní datový typ na řetězec. Můžete zadat formát pro čísla a datum. Pokud není zadáno, vybere se výchozí nastavení systému. Java desetinný formát se používá pro čísla. Dostupné formáty najdete v Java třídy SimpleDateFormat. Výchozí formát je yyyy-MM-dd. Pro datum nebo časové razítko můžete volitelně zadat jazykovou lokalizaci.

  • 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 při zadání volitelného formátu časového razítka. Pokud je časové razítko vynecháno, použije se výchozí vzor yyyy-[M]M-[d]d hh:mm:ss[.f...] . Volitelně můžete předat časové pásmo ve formě GMT, PST, UTCnebo America/Cayman. Funkce timestamp podporuje až milisekundovou přesnost s hodnotou 999. Dostupné formáty najdete v Java třídy 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

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

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

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

trim

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

Ořízne řetězec o počáteční a koncové znaky. Pokud druhý parametr není zadaný, oříznou se prázdné znaky. Jinak ořízne všechny znaky určené 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 je sloupec pojmenován true.

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

typeMatch

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

Odpovídá typu sloupce. Můžete ho použít jenom ve vzorových výrazech. Funkce number odpovídá krátkému, celočíselnému, dlouhému, dvojitému, plovoucímu nebo desetinnému. Funkce integral odpovídá typům short, int, long. Funkce fractional odpovídá typům double, float a decimal. Funkce datetime 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

Rozbalí řetězec podle formátu. Literální hodnoty pro přijatelné formáty jsou json, xml, ecmascript, html, a java.

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

unfold

unfold (<value1>: array) => any

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

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

unhex

unhex(<value1>: string) => binary

Převede binární hodnotu z jejího šesticového řetězcového zápisu. Můžete ho použít s sha2a md5 převést 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í sjednocenou množinu unikátních položek ze dvou 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á rozptyl sloupce.

  • variance(sales)

varianceIf

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

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

  • varianceIf(region == 'West', sales)

variancePopulation

variancePopulation(<value1> : number) => double

Získá populační rozptyl sloupce.

  • variancePopulation(sales)

variancePopulationIf

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

Získá rozptyl populace sloupce na základě kritérií.

  • variancePopulationIf(region == 'West', sales)

varianceSample

varianceSample(<value1> : number) => double

Získá nezaujatý rozptyl sloupce.

  • varianceSample(sales)

varianceSampleIf

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

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

  • varianceSampleIf(region == 'West', sales)

W

weekOfYear

weekOfYear(<value1> : datetime) => integer

Získá týden roku při zadání data.

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

weeks

weeks(<value1> : integer) => long

Získá dobu trvání v milisekundách pro počet týdnů.

  • weeks(2) -> 1209600000L

X

xor

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

Používá logický XOR operátor. 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

  • Last updated on