Adatátalakítási kifejezés használata az adatfolyamok leképezésében

Vonatkozik: Azure Data Factory Azure Synapse Analytics

Tip

Data Factory a Microsoft Fabric a Azure Data Factory következő generációja, egyszerűbb architektúrával, beépített AI-vel és új funkciókkal. Ha még nem ismerkedik az adatintegrációval, kezdje a Fabric Data Factoryvel. A meglévő ADF-számítási feladatok frissíthetők Fabric használatával, hogy elérjék az adatkutatás, a valós idejű elemzés és a jelentéskészítés új képességeit.

Az adatfolyamok Azure Data Factory folyamatokban és Azure Synapse Analytics folyamatokban is elérhetők. Ez a cikk az adatfolyamok leképezésére vonatkozik. Ha még nem ismerkedik az átalakításokkal, tekintse meg az Adatok átalakítása leképezési adatfolyamokkal című bevezető cikket.

Ez a cikk részletesen ismerteti az Azure Data Factory és Azure Synapse Analytics által támogatott összes kifejezés és függvény használatát az adatfolyamok leképezésében. A támogatott függvénytípusok összegzését a következő cikkekben találhatja meg:

Az összes függvény betűrendes listája

Az alábbi betűrendes lista tartalmazza a leképezési adatfolyamokban elérhető összes függvényt.

A

abs

abs(<value1> : number) => number

Egy szám abszolút értékét adja vissza.

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

acos

acos(<value1> : number) => double

Koszinusz inverz értéket számít ki.

  • acos(1) -> 0.0

add

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

Két sztringet vagy számot ad össze. Dátumot ad hozzá több naphoz. Időtartamot ad hozzá egy időbélyeghez. Hasonló típusú tömböt hozzáfűz egy másikhoz. Ugyanaz, mint az + 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

Napokat ad hozzá egy dátum- vagy időbélyeghez. Ugyanaz, mint a + operátor a dátumokhoz.

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

addMonths

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

Hónapokat ad hozzá egy dátum- vagy időbélyeghez. Szükség esetén megadhat egy időzónát.

  • 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

A logikai AND operátort használja. Ugyanaz, mint &&.

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

approxDistinctCount

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

Lekéri egy oszlop különböző értékeinek hozzávetőleges összesített számát. Az opcionális második paraméter a becslési hiba szabályozása.

  • approxDistinctCount(ProductID, .05) => long

array

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

Elemtömböt hoz létre. Minden elemnek azonos típusúnak kell lennie. Ha nincs megadva elem, akkor az alapértelmezett egy üres karakterlánc tömb. Ugyanaz, mint egy [] létrehozási operátor.

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

ascii

ascii(<Input> : string) => number

A bemeneti karakter numerikus értékét adja vissza. Ha a bemeneti sztring egynél több karakterből áll, a függvény az első karakter numerikus értékét adja vissza.

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

asin

asin(<value1> : number) => double

Inverz szinuszértéket számít ki.

  • asin(0) -> 0.0

assertErrorMessages

assertErrorMessages() => map

Az összes hibaüzenet térképét adja vissza a sorhoz, ahol az assertazonosító a kulcs.

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

Kulcs/értékek térképét hozza létre. Minden kulcsnak és értéknek azonos típusúnak kell lennie. Ha nincs megadva elemek, akkor alapértelmezés szerint egy karakterlánc típusú térképként kezeljük. Ugyanaz, mint egy [ -> ] létrehozási operátor. A kulcsoknak és értékeknek váltakozniuk kell egymással.

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

at

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

Megkeresi az elemet egy tömbindexben. Az index 1 alapú. A határon kívüli index null értéket eredményez. Kulcs megadásakor megkeres egy értéket a térképen. Ha a kulcs nem található, null értéket ad vissza.

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

atan

atan(<value1> : number) => double

Inverz tangens értéket számít ki.

  • atan(0) -> 0.0

atan2

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

A sík pozitív x tengelye és a koordináták által megadott pont közötti radiánban megadott szöget adja vissza.

  • atan2(0, 0) -> 0.0

avg

avg(<value1> : number) => number

Egy oszlop értékeinek átlagát kapja meg.

  • avg(sales)

avgIf

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

Egy oszlop értékeinek átlagát kapja meg feltételek alapján.

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

B

between

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

Ellenőrzi, hogy az első érték két másik érték között van-e. Számokat, sztringeket és datetime értékeket hasonlíthat össze.

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

bitwiseAnd

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

A bitenkénti And operátort használja az integráltípusok között. Ugyanaz, mint az & operátor.

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

bitwiseOr

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

A bitenkénti Or operátort használja az integráltípusok között. Ugyanaz, mint az | operátor.

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

bitwiseXor

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

A bitenkénti Or operátort használja az integráltípusok között. Ugyanaz, mint az | operátor

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

blake2b

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

Kiszámítja a Blake2 kivonatot egy különböző primitív adattípusú oszlopkészletből, ha megadja a bitehosszt, ami csak a 8 és 512 közötti 8 többszöröse lehet. Ezzel kiszámíthatja egy sor ujjlenyomatát.

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

blake2bBinary

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

Kiszámítja a Blake2 kivonatot különböző primitív adattípusokból álló oszlopkészletből, amikor meg van adva egy bithossz, amely csak 8 és 512 közötti, 8-cal osztható szám lehet. Ezzel kiszámíthatja egy sor ujjlenyomatát.

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

byItem

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

Alapelemet keres egy struktúra vagy struktúratömb belsejében. Ha több egyezés van, az első egyezést adjuk vissza. Ha nincsenek egyezések, a rendszer visszaad egy NULL értéket. A visszaadott értéket a típuskonvertálási műveletek (például ? date és ? string) egyikével kell átalakítani. Az oszlopneveket tervezéskor címük szerint kell megadni. A számított bemenetek nem támogatottak, de paraméterhelyettesítéseket is használhat.

  • 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

Kiválaszt egy oszlopértéket név szerint a streamben. Második argumentumként megadhat egy választható streamnevet. Ha több egyezés van, az első egyezést adjuk vissza. Ha nincsenek egyezések, a rendszer visszaad egy NULL értéket. A visszaadott értéket a típuskonvertálási függvények (például TO_DATE és TO_STRING) egyikével kell konvertálni. Az oszlopneveket tervezéskor címük szerint kell megadni. A számított bemenetek nem támogatottak, de paraméterhelyettesítéseket is használhat.

  • 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

Válasszon ki egy oszloptömböt név szerint a streamben. Második argumentumként megadhat egy választható streamnevet. Ha több egyezés van, az első egyezést adjuk vissza. Ha nincs egyezés egy oszlophoz, a teljes kimenet egy NULL érték. A visszaadott értékhez típuskonvertálási függvény szükséges (például toDate és toString). Az oszlopneveket tervezéskor címük szerint kell megadni. A számított bemenetek nem támogatottak, de paraméterhelyettesítéseket is használhat.

  • 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

Kiválaszt egy oszlopértéket név szerint a forrásstreamben. A második argumentum a forrásstream neve. Ha több egyezés van, az első egyezést adjuk vissza. Ha nincsenek egyezések, a rendszer visszaad egy NULL értéket. A visszaadott értéket a típuskonvertálási függvények (például TO_DATE és TO_STRING) egyikével kell konvertálni. Az oszlopneveket tervezéskor címük szerint kell megadni. A számított bemenetek nem támogatottak, de paraméterhelyettesítéseket is használhat.

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

byOrigins

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

Kiválaszt egy oszlopok tömbjét név szerint az adatfolyamban. A második argumentum az a stream, ahonnan származik. Ha több egyezés van, az első egyezést adjuk vissza. Ha nincsenek egyezések, a rendszer visszaad egy NULL értéket. A visszaadott értéket a típuskonvertálási függvények (például TO_DATE és TO_STRING) egyikével kell konvertálni. Az oszlopneveket tervezéskor címük szerint kell megadni. A számított bemenetek nem támogatottak, de paraméterhelyettesítéseket is használhat.

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

byPath

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

Megkeresi a hierarchikus elérési utat név szerint a streamben. Második argumentumként megadhat egy választható streamnevet. Ha nem található ilyen elérési út, az eredmény NULL. A tervezéskor ismert oszlopneveket/elérési utakat csak a nevük vagy a pont jelölési útvonaluk használatával szabad kezelni. A számított bemenetek nem támogatottak, de paraméterhelyettesítéseket is használhat.

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

byPosition

byPosition(<position> : integer) => any

Kiválaszt egy oszlopértéket a stream relatív (1 alapú) pozíciója alapján. Ha a pozíció hatókörön kívül esik, akkor egy NULL értéket ad vissza. A visszaadott értéket a típuskonvertálási függvények egyikével (például TO_DATE vagy TO_STRING) kell konvertálni. A számított bemenetek nem támogatottak, de paraméterhelyettesítéseket is használhat.

  • 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

Váltakozó feltételek alapján a case függvény az egyik értéket vagy a másikat alkalmazza. Ha a bemenetek száma páros, akkor az utolsó feltételnél alapértelmezetten NULL lesz használva.

  • 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

Kiszámítja egy szám kockagyökerét.

  • cbrt(8) -> 2.0

ceil

ceil(<value1> : number) => number

A legkisebb egész számot adja vissza, amely nem kisebb a számnál.

  • ceil(-0.1) -> 0

char

char(<Input> : number) => string

A bemeneti szám által képviselt ASCII karaktert adja vissza. Ha a szám nagyobb, mint 256, az eredmény egyenértékű a karakter (szám % 256).

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

coalesce

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

Az első nem null értéket adja vissza bemenetek készletéből. Minden bemenetnek azonos típusúnak kell lennie.

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

collect

collect(<value1> : any) => array

Az összesített csoportban lévő kifejezés összes értékét tömbbe gyűjti. A folyamat során a struktúrákat más struktúrákká gyűjtheti és alakíthatja át. Az elemek száma megegyezik a csoportban lévő sorok számával, és null értékeket tartalmazhat. Az összegyűjtött elemek számának kicsinek kell lennie.

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

collectUnique

collectUnique(<value1> : any) => array

Az összesített csoportban lévő kifejezés összes értékét egy egyedi tömbbe gyűjti össze. A folyamat során a struktúrákat más struktúrákká gyűjtheti és alakíthatja át. Az elemek száma megegyezik a csoportban lévő sorok számával, és null értékeket tartalmazhat. Az összegyűjtött elemek számának kicsinek kell lennie.

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

columnNames

columnNames( <value1>columnNames( : string, i><value1> : boolean) => array

Lekéri egy stream összes kimeneti oszlopának nevét. Első argumentumként megadhat egy választható streamnevet. A második argumentum szintén nem kötelező, alapértelmezés szerint hamis. Ha a második argumentumot true()állítja be, a Data Factory csak olyan oszlopokat ad vissza, amelyek sémaeltolódáson keresztül sodródtak.

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

columns

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

Lekéri egy stream összes kimeneti oszlopának értékeit. Második argumentumként megadhat egy választható streamnevet.

  • columns()
  • columns('DeriveStream')

compare

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

Két azonos típusú értéket hasonlít össze. Negatív egész számot ad vissza, ha érték1 < érték2, 0 ha érték1 == érték2, és pozitív értéket, ha érték1 > érték2.

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

concat

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

Összefűz egy változó számú karakterláncot. Ugyanaz, mint a + operátor sztringekkel.

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

concatWS

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

A sztringek változószámát összefűzi egy elválasztójellel. Az első paraméter az elválasztó.

  • 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

Akkor adja true vissza, ha a megadott tömb bármely eleme a megadott predikátumban szereplő értéket értékeli true ki. A Th contains függvény a predikátumfüggvény #itemegy elemére való hivatkozást vár.

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

cos

cos(<value1> : number) => double

Koszinuszértéket számít ki.

  • cos(10) -> -0.8390715290764524

cosh

cosh(<value1> : number) => double

Egy érték hiperbolikus koszinuszát számítja ki.

  • cosh(0) -> 1.0

count

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

Lekéri az értékek összesített számát. Ha egy vagy több választható oszlop van megadva, figyelmen kívül hagyja NULL a darabszám értékeit.

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

countAll

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

Lekéri az értékek összesített számát, beleértve a null értékeket is.

  • countAll(custId)
  • countAll()

countDistinct

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

Lekéri egy oszlopkészlet különböző értékeinek összesített számát.

  • countDistinct(custId, custName)

countAllDistinct

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

Lekéri egy oszlopkészlet különböző értékeinek összesített számát, beleértve a null értékeket is.

  • countAllDistinct(custId, custName)

countIf

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

A feltételek alapján lekéri az értékek összesített számát. Ha az opcionális oszlop meg van adva, figyelmen kívül hagyja a NULL értékeket a darabszámból.

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

covariancePopulation

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

Lekérdezi a sokaság kovarianciáját két oszlop között.

  • covariancePopulation(sales, profit)

covariancePopulationIf

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

Két oszlop populációs kovarianciáját számítja ki kritériumok alapján.

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

covarianceSample

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

Két oszlop minta kovarianciáját kapja meg.

  • covarianceSample(sales, profit)

covarianceSampleIf

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

Két oszlop minta kovarianciáját kapja meg feltételek alapján.

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

crc32

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

Kiszámítja a CRC32 kivonatot egy változó primitív adattípusú oszlopkészletből, ha egy bithosszt ad meg, amely csak értékekből 0(256állhat , 224, 256384és 512. Ezzel kiszámíthatja egy sor ujjlenyomatát.

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

cumeDist

cumeDist() => integer

A cumeDist függvény kiszámítja egy érték pozícióját a partíció összes értékéhez viszonyítva. Az eredmény a partíció sorrendjének aktuális sorát megelőző vagy azzal egyenlő sorok száma, osztva az ablakpartícióban lévő sorok teljes számával. A rendezés során az egyenlő értékek azonos pozícióba kerülnek.

  • cumeDist()

currentDate

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

Lekéri a feladat futtatásának aktuális dátumát. Az opcionális időzónát a következő formában GMTadhatja át: , PST, UTCvagy America/Cayman. A rendszer alapértelmezés szerint az adat-előállító adatközpontjának/régiójának helyi időzónáját használja. Az elérhető formátumokért tekintse meg Java SimpleDateFormat osztályát.

  • 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

Lekéri az aktuális időbélyeget, amikor a feladat helyi időzónával kezd futni.

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

currentUTC

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

Az aktuális időbélyeget UTC-ként kapja meg. Ha azt szeretné, hogy az aktuális idő a fürt időzónájától eltérő időzónában legyen értelmezve, megadhat egy választható időzónát a következő formában GMT, PST, UTC vagy America/Cayman. Alapértelmezés szerint az aktuális időzóna. Az elérhető formátumokért tekintse meg Java SimpleDateFormat osztályát. Ha az UTC-időt egy másik időzónává szeretné konvertálni, használja a következőt 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

A hónap napját adja vissza egy megadott dátum esetén.

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

dayOfWeek

dayOfWeek(<value1> : datetime) => integer

A hét napját adja meg egy adott dátum esetén. Például vasárnap 1 van, 2 hétfő, ... és 7 szombat van.

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

dayOfYear

dayOfYear(<value1> : datetime) => integer

Az év napját adja meg, ha megadja a dátumot.

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

days

days(<value1> : integer) => long

A napok száma ezredmásodpercben.

  • days(2) -> 172800000L

decode

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

A kódolt bemeneti adatokat egy sztringbe dekódolja az adott karakterkészlet alapján. Egy második (nem kötelező) argumentum használatával megadhatja, hogy melyik karakterkészletet használja. Példák: US-ASCII, ISO-8859-1, UTF-8 (alapértelmezett), UTF-16BE, UTF-16LE, és UTF-16.

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

degrees

degrees(<value1> : number) => double

A radiánokat fokokká alakítja.

  • degrees(3.141592653589793) -> 180

denseRank

denseRank() => integer

Kiszámítja egy érték rangsorát egy ablak sorrendjében megadott értékcsoportban záradék szerint. Az eredmény egy plusz a partíció sorrendjének aktuális sorát megelőző vagy egyenlő sorok száma. Az értékek nem okoznak réseket a sorozatban. A denseRank függvény akkor is működik, ha az adatok nincsenek rendezve, és az értékek változását keresi.

  • denseRank()

distinct

distinct(<value1> : array) => array

Visszaadja egy tömb egyedi elemeinek halmazát.

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

divide

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

Számok párját osztja el. Ugyanaz, mint az / operátor.

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

dropLeft

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

Annyi karaktert távolít el a sztring bal oldaláról, amennyit csak lehet. Ha a lekért rész túllépi a karakterlánc hosszát, egy üres karakterlánccal tér vissza.

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

dropRight

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

Eltávolít annyi karaktert a karakterlánc jobb oldaláról, amennyi csak lehetséges. Ha a lekért rész túllépi a karakterlánc hosszát, egy üres karakterlánccal tér vissza.

  • dropRight('bojjus', 2) => 'bojj'
  • dropRight('cake', 10) => ''

E

encode

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

A bemeneti sztringadatokat karakterkészlet alapján binárisra kódolja. Egy második (nem kötelező) argumentum használatával megadhatja, hogy melyik karakterkészletet használja. Példák: US-ASCII, ISO-8859-1, UTF-8 (alapértelmezett), UTF-16BE, UTF-16LE, és UTF-16.

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

endsWith

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

Ellenőrzi, hogy a sztring a megadott sztringgel végződik-e.

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

equals

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

Az összehasonlítás egyenlő operátort használja. Ugyanaz, mint az == 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

Az összehasonlítási egyenlő operátort használja, figyelmen kívül hagyva az esetet. Ugyanaz, mint az <=> operátor.

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

escape

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

Egy karakterlánc karaktereinek formátum szerinti elkerülése. Az elfogadható formátum literális értékei a következőkjson: , xmlecmascript, htmlés java.

except

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

Egy tömb másik tömbből való különbséghalmazát adja vissza, eltávolítva az ismétlődéseket.

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

expr

expr(<expr> : string) => any

Egy sztringből származó kifejezést eredményez, amely megegyezik a kifejezés nemliterális formában történő írásával. A paraméterek sztringreprezentációként való átadására használható.

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

F

factorial

factorial(<value1> : number) => long

Egy szám faktoriálisát számítja ki.

  • factorial(5) -> 120

false

false() => boolean

Mindig hamis értéket ad vissza. Használja a függvényt syntax(false()) , ha egy oszlop neve el van nevezve false.

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

filter

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

Kiszűri a tömbből azokat az elemeket, amelyek nem felelnek meg a megadott predikátumnak. A Szűrő a predikátumfüggvény #itemegy elemére való hivatkozást vár.

  • 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

Keresse meg a feltételnek megfelelő tömb első elemét. Egy szűrőfüggvényt fogad el, ahol a tömbben lévő elemet #item-ként kezelheti. A mélyen beágyazott térképek esetében a szülőtérképekre a (#item_1, #item_2...) jelöléssel #item_n hivatkozhat.

  • 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

Lekérdezi az oszlopcsoport első értékét. Ha a második paraméter ignoreNulls nincs megadva, a Data Factory hamis értéket feltételez.

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

flatten

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

Tömböt vagy tömböket egyetlen tömbbé lapíthat. Az atomelemek tömbjei változatlanul lesznek visszaadva. Az utolsó argumentum nem kötelező, és alapértelmezés szerint hamis értékre van beállítva, hogy több szint mélységben rekurzívan lapítson.

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

floor

floor(<value1> : number) => number

A legnagyobb egész számot adja vissza, amely nem nagyobb a számnál.

  • floor(-0.1) -> -1

fromBase64

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

Dekódolja az adott base64 kódolású sztringet. A kódolási típust opcionálisan átadhatja.

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

fromUTC

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

Az UTC időbélyegből konvertálja. Az időzónát opcionálisan megadhatja GMT, PST, UTC, vagy America/Cayman formában. Alapértelmezés szerint az aktuális időzóna. Az elérhető formátumokért tekintse meg Java SimpleDateFormat osztályát.

  • 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

A nagyobb összehasonlító operátort használja. Ugyanaz, mint az > 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

Az operátorral nagyobb vagy egyenlő összehasonlítást használ. Ugyanaz, mint az >= operátor.

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

greatest

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

A legnagyobb értéket adja vissza bemenetként az értékek listájában, kihagyva a null értékeket. Akkor adja null vissza, ha az összes bemenet null értékű.

  • 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

A streamben név szerint keres oszlopértéket. Második argumentumként megadhat egy választható streamnevet. Az oszlopneveket tervezéskor címük szerint kell megadni. A számított bemenetek nem támogatottak, de paraméterhelyettesítéseket is használhat.

  • hasColumn('parent')

hasError

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

Ellenőrzi, hogy a megadott azonosítóval rendelkező objektum hibaként van-e megjelölve.

Examples

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

hasPath

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

Ellenőrzi, hogy létezik-e név alapján egy bizonyos hierarchikus elérési út a streamben. Második argumentumként megadhat egy választható streamnevet. A tervezéskor ismert oszlopneveket/elérési utakat csak a nevük vagy a pont jelölési útvonaluk használatával szabad kezelni. A számított bemenetek nem támogatottak, de paraméterhelyettesítéseket is használhat.

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

hex

hex(<value1>: binary) => string

A bináris értéket hexadecimális formában adja vissza.

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

hour

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

Lekéri egy időbélyeg óraértékét. Az opcionális időzónát a következő formában GMTadhatja át: , PST, UTCvagy America/Cayman. A rendszer alapértelmezés szerint a helyi időzónát használja. Az elérhető formátumokért tekintse meg Java SimpleDateFormat osztályát.

  • hour(toTimestamp('2009-07-30 12:58:59')) -> 12
  • hour(toTimestamp('2009-07-30 12:58:59'), 'PST') -> 12

hours

hours(<value1> : integer) => long

Lekéri az időtartamot ezredmásodpercben az órák számától számolva.

  • hours(2) -> 7200000L

I

iif

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

Egy értéket vagy egy másikat alkalmaz egy feltétel alapján. Ha a másik nem meghatározott, akkor az értéket a rendszer figyelembe veszi NULL. Mindkét értéknek kompatibilisnek kell lennie (például numerikus és sztring).

  • 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

Az első nem null elemet adja vissza, ha két vagy több bemenetet ad meg. Ez a függvény egyenértékű a coalesce függvényével.

  • 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

Ellenőrzi, hogy egy elem szerepel-e a tömbben.

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

initCap

initCap(<value1> : string) => string

Minden szó első betűjének nagybetűssé alakítása. A szavakat szóköz választja el egymástól.

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

instr

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

Megkeresi a karakterláncon belüli részsztring pozícióját (1-alapú). Ha nem található, a 0 visszatér.

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

intersect

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

Két tömb egyedi elemeinek metszetét adja vissza.

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

isBitSet

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

Ellenőrzi, hogy a bitpozíció be van-e állítva ebben a bitkészletben.

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

isBoolean

isBoolean(<value1>: string) => boolean

Ellenőrzi, hogy a sztring értéke logikai érték-e a szabálynak toBoolean()megfelelően.

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

isByte

isByte(<value1> : string) => boolean

Ellenőrzi, hogy a karakterlánc értéke bájt érték-e, amikor opcionálisan megad egy formátumot, amely megfelel a toByte() szabályainak.

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

isDate

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

Ellenőrzi, hogy a bemeneti dátum sztringje dátum-e egy opcionális beviteli dátumformátum használatával. Az elérhető formátumokért tekintse meg Java SimpleDateFormat osztályát. Ha a bemeneti dátum formátuma nincs megadva, az alapértelmezett formátum a következő yyyy-[M]M-[d]d. Az elfogadott formátumok a következők :[ 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

A toDecimal() szabályainak megfelelően megadott formátum esetén ellenőrzi, hogy a karakterlánc decimális érték-e.

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

isDelete

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

Ellenőrzi, hogy a sort törölni kell-e. Egynél több bemeneti adatfolyamot használó átalakítások esetén átadhatja a stream (1-alapú) indexét. A streamindexnek vagy 1 az 2, és az alapértelmezett értéknek 1kell lennie.

  • isDelete()
  • isDelete(1)

isDistinct

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

Megállapítja, hogy egy oszlop vagy oszlopkészlet eltérő-e. A null érték nem számít különálló értéknek.

  • isDistinct(custId, custName) => boolean

isDouble

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

Ellenőrzi, hogy a sztring értéke dupla érték-e, ha a szabálynak toDouble()megfelelő formátumot ad meg.

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

isError

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

Ellenőrzi, hogy a sor hibaként van-e megjelölve. Egynél több bemeneti adatfolyamot használó átalakítások esetén átadhatja a stream (1-alapú) indexét. A stream indexnek vagy 1, vagy 2-nek kell lennie, az alapértelmezett érték pedig 1.

  • isError()
  • isError(1)

isFloat

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

Ellenőrzi, hogy a sztring értéke lebegőpontos érték-e, ha a szabálynak toFloat()megfelelő választható formátumot ad meg.

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

isIgnore

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

Ellenőrzi, hogy a sort figyelmen kívül kell-e hagyni. Olyan transzformációk esetén, amelyek több mint egy bemeneti adatfolyamot igényelnek, megadhatja az adatfolyam (1-alapú) indexét. A streamindexnek vagy 1 az 2, és az alapértelmezett értéknek 1kell lennie.

  • isIgnore()
  • isIgnore(1)

isInsert

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

Ellenőrzi, hogy a sor meg van-e jelölve beszúrásra. Olyan transzformációk esetén, amelyek több mint egy bemeneti adatfolyamot igényelnek, megadhatja az adatfolyam (1-alapú) indexét. A streamindexnek vagy 1 az 2, és az alapértelmezett értéknek 1kell lennie.

  • isInsert()
  • isInsert(1)

isInteger

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

Ellenőrzi, hogy a karakterlánc értéke egész szám-e, ha a szabálynak megfelelő formátumot ad meg toInteger() szerint.

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

isLong

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

Ellenőrzi, hogy a sztring értéke hosszú egész szám-e, ha egy megadott formátum illeszkedik a toLong() szabályaihoz.

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

isMatch

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

Ellenőrzi, hogy a sor megfelel-e a keresésnek. Olyan transzformációk esetén, amelyek több mint egy bemeneti adatfolyamot igényelnek, megadhatja az adatfolyam (1-alapú) indexét. A streamindexnek vagy 1 az 2, és az alapértelmezett értéknek 1kell lennie.

  • isMatch()
  • isMatch(1)

isNan

isNan (<value1> : integral) => boolean

Ellenőrzi, hogy az érték nem szám-e.

  • isNan(10.2) => false

isNull

isNull(<value1> : any) => boolean

Ellenőrzi, hogy az érték NULL-e van.

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

isShort

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

Ellenőrzi, hogy a sztring értéke short típusú-e, amikor egy választható formátumot ad meg a toShort() szabályainak megfelelően.

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

isTimestamp

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

Ellenőrzi, hogy a bemeneti dátum karakterlánc időbélyeg-e egy opcionálisan megadott bemeneti időbélyeg formátummal. Az elérhető formátumokért tekintse meg Java SimpleDateFormat osztályát. Ha az időbélyeg nincs megadva, a rendszer az alapértelmezett mintát yyyy-[M]M-[d]d hh:mm:ss[.f...] használja. Az opcionális időzónát a következő formában GMTadhatja át: , PST, UTCvagy America/Cayman. A timestamp függvény akár ezredmásodperc pontossággal is támogat egy 999 értéket. Az elérhető formátumokért tekintse meg Java SimpleDateFormat osztályát.

  • 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

Ellenőrzi, hogy a sor frissítésre van-e megjelölve. Olyan transzformációk esetén, amelyek több mint egy bemeneti adatfolyamot igényelnek, megadhatja az adatfolyam (1-alapú) indexét. A streamindexnek vagy 1 az 2, és az alapértelmezett értéknek 1kell lennie.

  • isUpdate()
  • isUpdate(1)

isUpsert

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

Ellenőrzi, hogy a sor meg van-e jelölve beszúrásra. Olyan transzformációk esetén, amelyek több mint egy bemeneti adatfolyamot igényelnek, megadhatja az adatfolyam (1-alapú) indexét. A streamindexnek vagy 1 az 2, és az alapértelmezett értéknek 1kell lennie.

  • isUpsert()
  • isUpsert(1)

J

jaroWinkler

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

Meghatározza a JaroWinkler távolságot két karakterlánc között.

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

K

keyValues

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

Kulcs/értékek térképét hozza létre. Az első paraméter a kulcsok tömbje, a második pedig az értékek tömbje. Mindkét tömbnek egyenlő hosszúságúnak kell lennie.

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

kurtosis

kurtosis(<value1> : number) => double

Lekéri egy oszlop kurtózisát.

  • kurtosis(sales)

kurtosisIf

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

Meghatározza egy oszlop kurtózisát a feltételek alapján.

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

L

lag

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

Lekéri az első paraméter által kiértékelt n sorok értékét az aktuális sor előtt. A második paraméter a visszatekintendő sorok száma, az alapértelmezett érték pedig 1a . Ha nincs annyi sor, a rendszer null értéket ad vissza, hacsak nincs megadva alapértelmezett érték.

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

last

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

Egy oszlopcsoport utolsó értékét kapja meg. Ha a második paraméter ignoreNulls nincs megadva, akkor hamisnak kell lennie.

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

lastDayOfMonth

lastDayOfMonth(<value1> : datetime) => date

Egy megadott dátum esetén a hónap utolsó dátumát adja meg.

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

lead

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

Lekéri az aktuális sor után kiértékelt n első paramétersor értékét. A második paraméter a megtekintendő sorok száma, az alapértelmezett érték pedig 1az . Ha nincs annyi sor, a rendszer null értéket ad vissza, hacsak nincs megadva alapértelmezett érték.

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

least

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

Az operátorral kisebb vagy egyenlő összehasonlítást használ. Ugyanaz, mint az <= 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

Kivon egy részkarakterláncot az 1 indexnél kezdve a megadott karakterek számával. Ugyanaz, mint SUBSTRING(str, 1, n).

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

length

length(<value1> : string) => integer

A karakterlánc hosszát adja vissza.

  • length('dumbo') -> 5

lesser

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

Az összehasonlítás kevesebb operátort használ. Ugyanaz, mint az < 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

Az operátorral kisebb vagy egyenlő összehasonlítást használ. Ugyanaz, mint az <= operátor.

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

levenshtein

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

Lekérdezi a Levenshtein-távolságot két karakterlánc között.

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

like

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

Szó szerint egyező karakterláncmintát használ. A kivételek a következő speciális szimbólumok: _ egyezik a bemenet bármely karakterével (hasonló a .* normál kifejezésekhezposix). % nulla vagy több karakterrel egyezik meg a bemenetben (hasonló a .* a reguláris kifejezésekben posix). A menekülési karakter a "". Ha egy vezérlőkarakter egy speciális szimbólumot vagy egy másik vezérlőkaraktert előz meg, a következő karakter szó szerint illeszkedik. Érvénytelen a többi karakter kimenekülése.

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

locate

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

Megkeresi az alsztring pozícióját (1 alapján) egy sztringen belül, egy adott pozíciótól kezdve. Ha a pozíció nincs megadva, az a sztring elejétől kezdődik. Ha nem található, a 0 visszatér.

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

log

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

Kiszámítja a logaritmus értékét. Ha használja, megadhat egy választható bázist vagy egy Euler-számot.

  • log(100, 10) -> 2

log10

log10(<value1> : number) => double

A logaritmus értékét 10-es alapon számítja ki.

  • log10(100) -> 2

lookup

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

A gyorsítótárban lévő cél első sorát keresi meg az adott kulcsok alapján, amelyek egyeznek a gyorsítótári cél kulcsaival.

  • cacheSink#lookup(movieId)

lower

lower(<value1> : string) => string

Egy karaktersor kisbetűssé alakítása.

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

lpad

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

Addig balról kitölti a sztringet a megadott kitöltéssel, amíg el nem éri a kívánt hosszúságot. Ha a sztring hossza egyenlő vagy nagyobb a meghatározott hosszúságnál, a sztring le lesz rövidítve a hosszúságra.

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

ltrim

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

A karaktersor elején lévő bevezető karakterek lesznek eltávolítva. Ha a második paraméter nincs meghatározva, levágja a térközt. Ellenkező esetben a második paraméterben megadott karaktereket levágja.

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

M

map

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

A megadott kifejezéssel a tömb minden elemét egy új elemhez rendeli. A map függvény a kifejezésfüggvény #itemegy elemére való hivatkozást vár.

  • 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

Átalakítja a térképet úgy, hogy a kulcsokat új értékekhez társítja. Tömböt ad vissza. Egy leképezési függvényt vesz igénybe, ahol az elemet a következőképpen #key , az aktuális értéket pedig a következőképpen #valuekezelheti.

  • 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

Feltételesen egy tömböt egy másik, azonos vagy kisebb hosszúságú tömbre képez le. Az értékek bármilyen típusúak lehetnek, beleértve a structTypes. Egy leképezési függvényt vesz igénybe, ahol a tömbben lévő elemet #item-ként, az aktuális indexet pedig #index-ként kezelheti. A mélyen beágyazott térképek esetében a szülőtérképekre a ''#item_[n] (#item_1, #index_1' jelöléssel hivatkozhat.

  • 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

A megadott kifejezéssel a tömb minden elemét egy új elemhez rendeli. A map függvény elvárja, hogy a kifejezési függvény egyik elemére #item hivatkozás, illetve az elemindexre hivatkozás #index biztosítva legyen.

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

mapLoop

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

A 1-tól a megadott hosszig végighaladva létrehoz egy ilyen hosszúságú tömböt. Egy leképezési függvényt vesz igénybe, ahol a tömb indexét a következőképpen #indexkezelheti. A mélyen beágyazott térképek esetében a szülőtérképekre a (#index_n, #index_1) jelöléssel #index_2 hivatkozhat.

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

max

max(<value1> : any) => any

Egy oszlop maximális értékét adja meg.

  • max(sales)

maxIf

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

Egy oszlop maximális értékét adja meg feltételek alapján.

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

md5

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

Kiszámítja a különböző primitív adattípusokból álló oszlopok MD5-kivonatát, és egy 32 karakterből álló hexa sztringet ad vissza. Ezzel kiszámíthatja egy sor ujjlenyomatát.

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

mean

mean(<value1> : number) => number

Egy oszlop értékeinek középértékét kapja meg. Ugyanaz, mint AVG.

  • mean(sales)

meanIf

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

Egy oszlop értékeinek átlagát kapja meg feltételek alapján. Ugyanaz, mint avgIf.

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

millisecond

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

Lekéri egy dátum ezredmásodpercét. Az opcionális időzónát a következő formában GMTadhatja át: , PST, UTCvagy America/Cayman. A rendszer alapértelmezés szerint a helyi időzónát használja. Az elérhető formátumokért tekintse meg Java SimpleDateFormat osztályát.

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

milliseconds

milliseconds(<value1> : integer) => long

Lekéri az időtartam számlálását milliszekundumban.

  • milliseconds(2) -> 2L

min

min(<value1> : any) => any

Egy oszlop minimális értékét adja meg.

  • min(sales)

minIf

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

Egy oszlop minimális értékét adja meg feltételek alapján.

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

minus

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

Számokat von ki. Kivonja a dátumtól számított napok számát. Kivonja az időtartamot egy időbélyegből. Kivon két időbélyeget, hogy ezredmásodpercben megkaphassa a különbséget. Ugyanaz, mint az - 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

Lekérdezi egy időbélyeg percértékét. Az opcionális időzónát a következő formában GMTadhatja át: , PST, UTCvagy America/Cayman. A rendszer alapértelmezés szerint a helyi időzónát használja. Az elérhető formátumokért tekintse meg Java SimpleDateFormat osztályát.

  • minute(toTimestamp('2009-07-30 12:58:59')) -> 58
  • minute(toTimestamp('2009-07-30 12:58:59'), 'PST') -> 58

minutes

minutes(<value1> : integer) => long

Megadja az időtartamot ezredmásodpercben a megadott percérték alapján.

  • minutes(2) -> 120000L

mlookup

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

Megkeresi a gyorsítótárazott tárolóban az összes egyező sort azzal, hogy a meghatározott kulcsokat használja, amelyek megegyeznek a tároló kulcsaival.

  • cacheSink#mlookup(movieId)

mod

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

Lekéri egy számpár modulusát. Ugyanaz, mint az % operátor.

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

month

month(<value1> : datetime) => integer

Lekéri egy dátum vagy időbélyeg hónapértékét.

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

monthsBetween

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

Két dátum közötti hónapok számát adja meg. A számítást lekerekítheti. Az opcionális időzónát a következő formában GMTadhatja át: , PST, UTCvagy America/Cayman. A rendszer alapértelmezés szerint a helyi időzónát használja. Az elérhető formátumokért tekintse meg Java SimpleDateFormat osztályát.

  • monthsBetween(toTimestamp('1997-02-28 10:30:00'), toDate('1996-10-30')) -> 3.94959677

multiply

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

Egy számpárt szoroz össze. Ugyanaz, mint az * operátor.

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

N

negate

negate(<value1> : number) => number

Egy számot nem ad meg. A pozitív számokat negatívra váltja, és fordítva.

  • negate(13) -> -13

nextSequence

nextSequence() => long

A következő egyedi szekvenciát adja vissza. A szám csak egy partíción belül van egymás után, és a partícióazonosítót előtagként használják.

  • nextSequence() == 12313112 -> false

normalize

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

Normalizálja a sztringértéket a ékezetes Unicode-karakterek elválasztására.

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

not

not(<value1> : boolean) => boolean

A logikai negation operátort használja.

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

notEquals

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

Az összehasonlítás nem egyenlő operátort használja. Ugyanaz, mint az != operátor.

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

nTile

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

A nTile függvény az egyes ablakpartíciók sorait legfeljebb gyűjtőkre n1nosztja. A gyűjtőértékek legfeljebb annyiban különböznek. 1 Ha a partíció sorainak száma nem egyenlően oszlik meg a gyűjtők számával, akkor a többi érték gyűjtőnként egy lesz elosztva, kezdve az első gyűjtővel. A nTile függvény hasznos a kvartilisek, a decilek és más általános összefoglaló statisztikák kiszámításához tertiles. A függvény két változót számít ki az inicializálás során. A szokásos vödör mérete egy extra sorral lett növelve. Mindkét változó az aktuális partíció méretén alapul. A számítási folyamat során a függvény nyomon követi az aktuális sorszámot, az aktuális gyűjtőszámot és azt a sorszámot, amelyen a gyűjtő módosul (bucketThreshold). Amikor az aktuális sorszám eléri a vödör küszöbértékét, a vödör értéke eggyel növekszik. A küszöbérték a vödör méretével nő (plusz egy további, ha az aktuális vödör ki van párnázva).

  • nTile()
  • nTile(numOfBuckets)

null

null() => null

Visszaad egy NULL értéket. Használja a függvényt syntax(null()) , ha egy oszlop neve el van nevezve null. Minden olyan művelet, amely null értéket használ, értéket ad eredményként 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

A logikai OR operátort használja. Ugyanaz, mint ||.

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

originColumns

originColumns(<streamName> : string) => any

Lekéri egy forrásfolyam összes kimeneti oszlopát, ahol az oszlopok létre lettek hozva. Más függvényhez kell csatolni.

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

output

output() => any

A gyorsítótár-fogadó adatainak első sorát adja vissza.

  • cacheSink#output()

outputs

output() => any

A gyorsítótár-fogadó eredményeinek teljes kimeneti sorkészletét adja vissza.

  • cacheSink#outputs()

P

partitionId

partitionId() => integer

A bemeneti sor aktuális partícióazonosítóját adja vissza.

  • partitionId()

pMod

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

Egy számpár pozitív modulusát adja meg.

  • pmod(-20, 8) -> 4

power

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

Egy számot a másik erejére emel.

  • power(10, 2) -> 100

R

radians

radians(<value1> : number) => double

A fokokat radiánokká alakítja.

  • radians(180) => 3.141592653589793

random

random(<value1> : integral) => double

Egy partíción belül adott mag esetén egy véletlenszerű számot ad vissza. A magnak egy fix értékkel kell rendelkeznie, és a partícióazonosítóval együtt használva véletlenszerű értékeket állít elő egy tartományban (0.0-1.0).

  • random(1) == 1 -> false

rank

rank() => integer

Kiszámítja egy érték rangsorát egy ablak sorrendjében megadott értékcsoportban záradék szerint. Az eredmény egy plusz a partíció sorrendjének aktuális sorát megelőző vagy egyenlő sorok száma. Az értékek hézagokat eredményeznek a sorozatban. A rank függvény akkor is működik, ha az adatok nincsenek rendezve, és az értékek változását keresi.

  • rank()

reassociate

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

Átalakítja a térképet úgy, hogy a kulcsokat új értékekhez társítja. Egy leképezési függvényt vesz igénybe, ahol az elemet a következőképpen #key , az aktuális értéket pedig a következőképpen #valuekezelheti.

  • 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

Elemek halmozódnak fel egy tömbben. A reduce függvény egy akkumulátorra és az első kifejezésfüggvény egy elemére való hivatkozást vár, mint #acc és #item. Az eredményként kapott értéket #result a második kifejezési függvényben kell használni.

  • 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

Kiolvas egy egyező részsztringet egy adott regex-mintához. Az utolsó paraméter azonosítja az egyezéscsoportot, és 1 lesz az alapértelmezett érték, ha nincs megadva. Használja a <regex> elemet a szövegrészek karakterek kikerülése nélküli összehasonlítására. Az index 0 az összes egyezést visszaadja. Csoportokra bontás nélkül, az index 1 és a feletti értékek nem adnak eredményt.

  • 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

Ellenőrzi, hogy a sztring megfelel-e az adott regex-mintának. Használja a <regex> elemet a szövegrészek karakterek kikerülése nélküli összehasonlítására.

  • 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

A reguláris kifejezés mintájának minden előfordulását lecseréli egy másik karakterláncra az adott karakterláncban. Használja a <regex> elemet a szövegrészek karakterek kikerülése nélküli összehasonlítására.

  • 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

Egy regex alapú elválasztó alapján feloszt egy sztringet, és sztringtömböt ad vissza.

  • 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

Az összes előforduló részszöveget lecseréli egy másik részszövegre a megadott szövegben. Ha az utolsó paraméter nincs megadva, az alapértelmezés szerint üres sztring lesz.

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

reverse

reverse(<value1> : string) => string

Megfordítja a szöveget.

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

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

Jobbról egy megadott számú karakterből álló alsztringet nyer ki. Ugyanaz, mint SUBSTRING(str, LENGTH(str) - n, n).

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

rlike

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

Ellenőrzi, hogy a sztring megfelel-e az adott regex-mintának.

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

round

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

Egy szám kerekítése opcionális skálázás és opcionális kerekítési mód esetén. Ha a skálázás nincs megadva, az alapértelmezés szerint a következő lesz 0: . Ha a mód nincs megadva, az alapértelmezés szerint a következő lesz ROUND_HALF_UP(5). A kerekítés értékei a következők:

  1. ROUND_UP: Kerekítési mód a nullától való lekerekítéshez.

  2. ROUND_DOWN: Kerekítési mód a nullához való kerekítéshez.

  3. ROUND_CEILING: Kerekítési mód a pozitív végtelen felé kerekítéshez. (Ugyanaz, mint ROUND_UP, ha a bemenet pozitív. Ha negatív, akkor úgy viselkedik, mint ROUND_DOWN. A például -1.1 az -1.0-val ROUND_CEILING és -2 ROUND_UP lenne.)

  4. ROUND_FLOOR: Kerekítési mód a negatív végtelen felé kerekítéshez. (Ugyanaz, mintha ROUND_DOWN a bemenet pozitív. Ha negatív, úgy viselkedik, mint ROUND_UP.)

  5. ROUND_HALF_UP: Lekerekítési mód, amely a "legközelebbi szomszédhoz" kerekít, kivéve, ha a célérték egyenlő távolságra van mindkét szomszédtól, ebben az esetben úgy viselkedik, mint ROUND_UP. (Az adatfolyam leggyakoribb + alapértelmezett értéke.)

  6. ROUND_HALF_DOWN: Kerekítési mód a "legközelebbi szomszéd" felé kerekítéshez, kivéve, ha mindkét szomszéd egyenlő, ebben az esetben ROUND_DOWN.

  7. ROUND_HALF_EVEN: Lekerekítési mód a "legközelebbi szomszéd" felé történő kerekítéshez, kivéve ha mindkét szomszéd egyenlő távolságra van, ebben az esetben a páros szomszéd felé kerekít.

  8. ROUND_UNNECESSARY: Kerekítési mód annak megállapításához, hogy a kerekítési művelet pontos eredményt ad-e, ezért nincs szükség kerekítésre.

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

rowNumber

rowNumber() => integer

Szekvenciális sorszámozást rendel hozzá egy ablak soraihoz 1-től kezdődően.

  • rowNumber()

rpad

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

A sztringet jobb irányba párnázza a megadott kitöltéssel, amíg a sztring el nem ér egy bizonyos hosszúságot. Ha a sztring hossza egyenlő vagy nagyobb a meghatározott hosszúságnál, a sztring le lesz rövidítve a hosszúságra.

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

rtrim

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

A jobb karakterlánc eltávolítja a végéről a záró karaktereket. Ha a második paraméter nincs meghatározva, levágja a térközt. Ellenkező esetben a második paraméterben megadott karaktereket levágja.

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

S

second

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

Lekéri a dátum második értékét. Az opcionális időzónát a következő formában GMTadhatja át: , PST, UTCvagy America/Cayman. A rendszer alapértelmezés szerint a helyi időzónát használja. Az elérhető formátumokért tekintse meg Java SimpleDateFormat osztályát.

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

seconds

seconds(<value1> : integer) => long

Ezredmásodpercben adja meg a másodpercek számát.

  • seconds(2) -> 2000L

setBitSet

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

Bitpozíciókat állít be ebben a bitkészletben.

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

sha1

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

Kiszámítja a különböző primitív adattípusokból álló oszlopok SHA-1 kivonatát, és egy 40 karakterből álló hexa sztringet ad vissza. Ezzel kiszámíthatja egy sor ujjlenyomatát.

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

sha2

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

Kiszámítja a különböző primitív adattípusokból álló oszlopok SHA-2 kivonatát, ha megad egy bithosszt, amely csak 0(256), 224, 256, 384 vagy 512 értékekből állhat. Ezzel kiszámíthatja egy sor ujjlenyomatát.

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

sin

sin(<value1> : number) => double

Szinuszértéket számít ki.

  • sin(2) -> 0.9092974268256817

sinh

sinh(<value1> : number) => double

Hiperbolikus szinuszértéket számít ki.

  • sinh(0) -> 0.0

size

size(<value1> : any) => integer

Megkeresi egy tömb vagy térképtípus méretét.

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

skewness

skewness(<value1> : number) => double

Lekéri egy oszlop ferdeségét.

  • skewness(sales)

skewnessIf

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

Meghatározza az oszlop ferdeségét a megadott feltételek alapján.

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

slice

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

Egy tömb részhalmazát egy adott pozíciótól nyeri ki. A pozíció 1 alapú. Ha a hossz nincs megadva, akkor automatikusan a karakterlánc végétől kezdődően alapértelmezett.

  • 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

A tömb rendezése a megadott predikátumfüggvénnyel. A sort függvény arra számít, hogy a kifejezésfüggvény két egymást követő elemére hivatkozik, mint #item1 és #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

Lekéri a karakterlánc soundex kódját.

  • soundex('genius') -> 'G520'

split

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

Elválaszt egy sztringet egy elválasztó alapján, és sztringtömböt ad vissza.

  • 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

Kiszámítja egy szám négyzetgyökét.

  • sqrt(9) -> 3

startsWith

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

Ellenőrzi, hogy a karakterlánc a megadott karakterlánccal kezdődik-e.

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

stddev

stddev(<value1> : number) => double

Meghatározza egy oszlop szórását.

  • stdDev(sales)

stddevIf

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

Megadja egy oszlop szórását a megadott feltétel alapján.

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

stddevPopulation

stddevPopulation(<value1> : number) => double

Megkapja az oszlop népességi szórását.

  • stddevPopulation(sales)

stddevPopulationIf

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

Egy oszlop statisztikai szórását kapja meg feltételek alapján.

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

stddevSample

stddevSample(<value1> : number) => double

Lekéri egy oszlop minta standard eltérését.

  • stddevSample(sales)

stddevSampleIf

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

Egy oszlop mintaszórását számítja ki feltételek alapján.

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

subDays

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

Dátum- vagy időbélyegből kivonja a napokat. Ugyanaz, mint a - dátum operátora.

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

subMonths

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

Hónapokat von ki egy dátum- vagy időbélyegből.

  • 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

Kivon egy bizonyos hosszúságú részláncot egy adott pozícióból. A pozíció 1 alapú. Ha a hossz nincs megadva, akkor automatikusan a karakterlánc végétől kezdődően alapértelmezett.

  • 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><elválasztó>substringIndex( : string, : string, <elválasztó előfordulások száma> : integral]) = string>

Adott számú határoló előfordulása előtti részsztringet nyer ki. Ha a darabszám pozitív, a végső elválasztótól balra (a balról számolva) minden vissza lesz adva. Ha a darabszám negatív, a végső elválasztótól jobbra (jobbról számolva) minden vissza lesz adva.

  • 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

Lekéri egy numerikus oszlop összesített összegét.

  • sum(col)

sumDistinct

sumDistinct(<value1> : number) => number

Lekéri egy numerikus oszlop különböző értékeinek összesített összegét.

  • sumDistinct(col)

sumDistinctIf

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

Lekéri egy numerikus oszlop összesített összegét a feltételek alapján. A feltétel bármely oszlopon alapulhat.

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

sumIf

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

Lekéri egy numerikus oszlop összesített összegét a feltételek alapján. A feltétel bármely oszlopon alapulhat.

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

T

tan

tan(<value1> : number) => double

Tangens értéket számít ki.

  • tan(0) -> 0.0

tanh

tanh(<value1> : number) => double

Hiperbolikus tangens értéket számít ki.

  • tanh(0) -> 0.0

toBase64

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

Az adott sztringet a base64-ben kódolja. A kódolási típust opcionálisan átadhatja.

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

toBinary

toBinary(<value1> : any) => binary

Bármilyen numerikus, dátum-, időbélyeget vagy sztringet bináris ábrázolássá alakít át.

  • toBinary(3) -> [0x11]

toBoolean

toBoolean(<value1> : string) => boolean

A (t, true, y, yes, 1) értéket igazzá, és (f, false, n, no, 0) értéket false-ké konvertálja, míg minden más értéket NULL-ré alakul.

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

toByte

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

Bármilyen numerikus vagy sztringet bájtértékké alakít át. Az átalakításhoz választható Java decimális formátumot használhat.

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

toDate

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

A bemeneti dátum sztringet dátummá alakítja egy opcionális beviteli dátumformátum használatával. Az elérhető formátumokért tekintse meg Java SimpleDateFormat osztályát. Ha a bemeneti dátum formátuma nincs megadva, az alapértelmezett formátum a következő yyyy-[M]M-[d]d. Az elfogadott formátumok a következők :[ 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)

Bármely numerikus vagy sztringet decimális értékké alakít át. Ha nincs megadva a pontosság és a skálázás, az alapértelmezés szerint a (10,2) értékre van kapcsolva. Az átalakításhoz választható Java decimális formátumot használhat. Használjon választható helyi beállítás formátumát BCP47-nyelv formájában, például en-US, de vagy zh-CN formájában.

  • 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

Bármely numerikus vagy sztringet dupla értékké alakít át. Az átalakításhoz választható Java decimális formátumot használhat. Használjon választható helyi beállítás formátumát BCP47-nyelv formájában, például en-US, de vagy zh-CN formájában.

  • 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

Bármilyen numerikus vagy sztringet lebegőpontos értékké alakít át. Az átalakításhoz választható Java decimális formátumot használhat. Csonkolja a dupla elemet.

  • 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

Bármilyen numerikus vagy sztringet egész számmá alakít át. Az átalakításhoz választható Java decimális formátumot használhat. Csonkolja a hosszú, lebegő, dupla.

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

toLong

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

Bármilyen numerikus vagy sztringet hosszú értékké alakít át. Az átalakításhoz választható Java decimális formátumot használhat. Csonkolja a float és double típusokat.

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

topN

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

Lekéri az oszlop legfontosabb N értékeit a darabszám argumentum alapján.

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

toShort

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

Bármilyen numerikus vagy sztringet rövid értékké alakít át. Az átalakításhoz választható Java decimális formátumot használhat. Csonkolja az összes egész számot, hosszú egész, lebegő, dupla.

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

toString

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

Egy primitív adattípust sztringgé alakít át. Megadhatja a számok és a dátum formátumát. Ha nincs meghatározva, a rendszer alapértelmezése lesz kiválasztva. Java decimális formátumot használ a számokhoz. Az elérhető formátumokért tekintse meg Java SimpleDateFormat osztályát. Az alapértelmezett formátum a következő yyyy-MM-dd: . Dátum- vagy időbélyeghez megadhat területi beállításokat.

  • 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

A sztringet időbélyeggé konvertálja, amikor megad egy választott időbélyeg formátumot. Ha az időbélyeg nincs megadva, a rendszer az alapértelmezett mintát yyyy-[M]M-[d]d hh:mm:ss[.f...] használja. Az opcionális időzónát a következő formában GMTadhatja át: , PST, UTCvagy America/Cayman. A timestamp függvény akár ezredmásodperc pontossággal is támogat egy 999 értéket. Az elérhető formátumokért tekintse meg Java SimpleDateFormat osztályát.

  • 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

Az időbélyeget UTC-vé alakítja. Az opcionális időzónát a következő formában GMTadhatja át: , PST, UTCvagy America/Cayman. Alapértelmezés szerint az aktuális időzóna. Az elérhető formátumokért tekintse meg Java SimpleDateFormat osztályát.

  • 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

Cseréljen le egy karakterkészletet egy másikra a karakterláncban. A karakterek egy az egyben cserélődnek.

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

trim

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

Bevezető és záró karakterek sztringjének vágása. Ha a második paraméter nincs meghatározva, levágja a térközt. Ellenkező esetben a második paraméterben megadott karaktereket levágja.

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

true

true() => boolean

Mindig igaz értéket ad vissza. Használja a függvényt syntax(true()) , ha egy oszlop neve el van nevezve true.

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

typeMatch

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

Megfelel az oszlop típusának. Csak mintakifejezésekben használhatja. A number függvény egyezik a rövid, egész szám, hosszú, dupla, lebegőpontos vagy decimális értékével. A integral függvény «short», «int» és «long» típusokat egyeztet. A fractional függvény illeszkedik a double, a float és a decimal típusokhoz. A datetime függvény megegyezik a dátum- vagy időbélyeg típusával.

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

U

unescape

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

Egy karakterlánc kibontása egy adott formátum szerint. Az elfogadható formátumok literális értékei a következőkjson: , xmlecmascript, htmlés java.

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

unfold

unfold (<value1>: array) => any

Bontsa ki a tömböt sorkészletté, és minden sorban megismétli a többi oszlop értékeit.

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

unhex

unhex(<value1>: string) => binary

A karakterlánc-ábrázolásból felold egy bináris értéket. A sha2 és a md5 tagekkel használhatja a karakterláncból bináris reprezentációvá való alakításhoz.

  • 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

Két tömb egyedi elemeinek unióját adja vissza.

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

upper

upper(<value1> : string) => string

Sztring nagybetűssé alakítása.

  • upper('bojjus') -> 'BOJJUS'

uuid

uuid() => string

A létrehozott UUID-t adja vissza.

  • uuid()

V

variance

variance(<value1> : number) => double

Lekéri egy oszlop varianciáját.

  • variance(sales)

varianceIf

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

Lekéri egy oszlop varianciáját feltételek alapján.

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

variancePopulation

variancePopulation(<value1> : number) => double

Lekérdezi egy oszlop sokasági varianciáját.

  • variancePopulation(sales)

variancePopulationIf

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

Lekéri az oszlop sokasági varianciáját meghatározott feltételek alapján.

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

varianceSample

varianceSample(<value1> : number) => double

Lekéri egy oszlop elfogulatlan varianciáját.

  • varianceSample(sales)

varianceSampleIf

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

Egy oszlop elfogulatlan varianciáját kapja meg feltételek alapján.

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

W

weekOfYear

weekOfYear(<value1> : datetime) => integer

Az év hetét adja meg, ha dátumot ad.

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

weeks

weeks(<value1> : integer) => long

Lekéri a hetek tartamát ezredmásodpercekben.

  • weeks(2) -> 1209600000L

X

xor

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

A logikai XOR operátort használja. Ugyanaz, mint az ^ operátor.

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

Y

year

year(<value1> : datetime) => integer

Lekéri egy dátum évértékét.

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

Kapcsolódó tartalom

  • Last updated on