Utilisation des expressions de transformation de données dans le flux de données de mappage

Article
10/20/2023

S’APPLIQUE À : Azure Data Factory Azure Synapse Analytics

Conseil

Essayez Data Factory dans Microsoft Fabric, une solution d’analyse tout-en-un pour les entreprises. Microsoft Fabric couvre tous les aspects, du déplacement des données à la science des données, en passant par l’analyse en temps réel, l’aide à la décision et la création de rapports. Découvrez comment démarrer un nouvel essai gratuitement !

Les flux de données sont disponibles à la fois dans les pipelines Azure Data Factory et Azure Synapse. Cet article s’applique aux flux de données de mappage. Si vous débutez dans le domaine des transformations, consultez l’article d’introduction Transformer des données avec un flux de données de mappage.

Les articles suivants fournissent des détails sur l’utilisation de toutes les expressions et fonctions prises en charge par Azure Data Factory et Azure Synapse Analytics dans les flux de données de mappage. Pour obtenir des synthèses de chaque type de fonction pris en charge, reportez-vous aux articles suivants :

Liste alphabétique de toutes les fonctions

Voici une liste alphabétique de toutes les fonctions disponibles dans le flux de données de mappage.

Un

`abs`

abs(<value1> : number) => number

Valeur absolue d’un nombre.

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

`acos`

acos(<value1> : number) => double

Calcule une valeur inverse de cosinus.

acos(1) -> 0.0

`add`

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

Ajoute une paire de chaînes ou de nombres. Ajoute une date à un nombre de jours. Ajoute une durée à un timestamp. Ajoute un tableau à un autre de type similaire. Identique à l’opérateur +.

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

Ajoute des jours à une date ou à un horodatage. Identique à l’opérateur + pour la date.

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

`addMonths`

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

Ajoute des mois à une date ou à un timestamp. Vous pouvez éventuellement transmettre un fuseau horaire.

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

Opérateur AND logique. Identique à &&.

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

`approxDistinctCount`

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

Obtient le nombre agrégé approximatif de valeurs distinctes pour une colonne. Le deuxième paramètre facultatif sert à contrôler l’erreur d’estimation.

approxDistinctCount(ProductID, .05) => long

`array`

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

Crée un tableau d’éléments. Tous les éléments doivent être du même type. Si aucun élément n’est spécifié, par défaut, le tableau contient des chaînes vides. Identique à un opérateur de création [].

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

`ascii`

ascii(<Input> : string) => number

Retourne la valeur numérique du caractère d’entrée. Si la chaîne d’entrée contient plusieurs caractères, la valeur numérique du premier caractère est retournée

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

`asin`

asin(<value1> : number) => double

Calcule une valeur de sinus inverse.

asin(0) -> 0.0

`assertErrorMessages`

assertErrorMessages() => map

Retourne une carte de tous les messages d’erreur pour la ligne avec l’ID d’assertion comme clé.

Exemples

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

Crée un mappage de clés/valeurs. Toutes les clés et valeurs doivent être du même type. Si aucun élément n’est spécifié, la valeur par défaut est un mappage de type chaîne en type chaîne. Identique à un opérateur de création [ -> ]. Les clés et les valeurs doivent être spécifiées en alternance.

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

`at`

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

Recherche l’élément au niveau d’un index de tableau. L'index est de base 1. L’index hors limites génère une valeur Null. Recherche une valeur dans une carte d’après une clé. Si la clé est introuvable, retourne Null.

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

`atan`

atan(<value1> : number) => double

Calcule une valeur de tangente inverse.

atan(0) -> 0.0

`atan2`

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

Retourne l’angle (en radians) qui se trouve entre l’axe positif des abscisses d’un plan et le point donné par les coordonnées.

atan2(0, 0) -> 0.0

`avg`

avg(<value1> : number) => number

Obtient la moyenne des valeurs d’une colonne.

avg(sales)

`avgIf`

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

Selon certains critères, obtient la moyenne des valeurs d’une colonne.

avgIf(region == 'West', sales)

B

`between`

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

Vérifie si la première valeur est comprise entre deux autres valeurs incluses. Les valeurs numériques, de chaîne et DateHeure peuvent être comparées

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

`bitwiseAnd`

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

Opérateur And au niveau du bit sur des types de données intégraux. Identique à l’opérateur &

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

`bitwiseOr`

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

Opérateur Or au niveau du bit sur des types de données intégraux. Identique à l’opérateur |

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

`bitwiseXor`

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

Opérateur Or au niveau du bit sur des types de données intégraux. Identique à l’opérateur |

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

`blake2b`

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

Calcule le digest Blake2 de l’ensemble de colonnes de types de données primitifs variables en fonction d’une longueur de bits, qui ne peut être que des multiples de 8 entre 8 et 512. Il peut être utilisé dans le but de calculer une empreinte digitale pour une ligne

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

`blake2bBinary`

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

Calcule le digest Blake2 de l’ensemble de colonnes de types de données primitifs variables en fonction d’une longueur de bits, qui ne peut être que des multiples de 8 entre 8 et 512. Il peut être utilisé dans le but de calculer une empreinte digitale pour une ligne

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

`byItem`

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

Rechercher un sous-élément dans une structure ou un tableau de structure. S’il existe plusieurs correspondances, la première correspondance est retournée. S’il n’existe aucune correspondance, une valeur Null est retournée. Le type de la valeur retournée doit être converti par l’une des actions de conversion de type (? date, ? string ...). Les noms de colonne connus au moment de la conception doivent être traités uniquement selon leur nom. Les entrées calculées ne sont pas prises en charge, mais vous pouvez utiliser des substitutions de paramètre.

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

Sélectionne une valeur de colonne selon le nom dans le flux de données. Vous pouvez transmettre un nom de flux facultatif en tant que deuxième argument. S’il existe plusieurs correspondances, la première correspondance est retournée. S’il n’existe aucune correspondance, une valeur Null est retournée. Le type de la valeur retournée doit être converti par l’une des fonctions de conversion de type (TO_DATE, TO_STRING, etc.). Les noms de colonne connus au moment de la conception doivent être traités uniquement selon leur nom. Les entrées calculées ne sont pas prises en charge, mais vous pouvez utiliser des substitutions de paramètre.

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

Sélectionnez un tableau de colonnes par son nom dans le flux. Vous pouvez transmettre un nom de flux facultatif en tant que deuxième argument. S’il existe plusieurs correspondances, la première correspondance est retournée. S’il n’existe aucune correspondance pour une colonne, la sortie entière est une valeur NULL. La valeur retournée requiert une fonction de conversion de type (ToDate, toString, ...). Les noms de colonnes connus au moment de la conception doivent être traités uniquement par leur nom. Les entrées calculées ne sont pas prises en charge, mais vous pouvez utiliser des substitutions de paramètre.

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

Sélectionne une valeur de colonne selon le nom dans le flux de données d’origine. Le deuxième argument est le nom du flux d’origine. S’il existe plusieurs correspondances, la première correspondance est retournée. S’il n’existe aucune correspondance, une valeur Null est retournée. Le type de la valeur retournée doit être converti par l’une des fonctions de conversion de type (TO_DATE, TO_STRING, etc.). Les noms de colonne connus au moment de la conception doivent être traités uniquement selon leur nom. Les entrées calculées ne sont pas prises en charge, mais vous pouvez utiliser des substitutions de paramètre.

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

`byOrigins`

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

Sélectionne un tableau de colonnes par son nom dans le flux. Le deuxième argument est le flux à partir duquel il provient. S’il existe plusieurs correspondances, la première correspondance est retournée. S’il n’existe aucune correspondance, une valeur Null est retournée. Le type de la valeur retournée doit être converti par l’une des fonctions de conversion de type (TO_DATE, TO_STRING, etc.). Les noms de colonne connus au moment de la conception doivent être traités uniquement selon leur nom. Les entrées calculées ne sont pas prises en charge, mais vous pouvez utiliser des substitutions de paramètre.

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

`byPath`

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

Recherche un chemin d’accès hiérarchique par nom dans le flux. Vous pouvez transmettre un nom de flux facultatif en tant que deuxième argument. Si aucun chemin n’est trouvé, la valeur Null est retournée. Les noms/chemins de colonnes connus au moment de la conception doivent être adressés uniquement par leur nom ou leur chemin en notation pointée. Les entrées calculées ne sont pas prises en charge, mais vous pouvez utiliser des substitutions de paramètre.

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

`byPosition`

byPosition(<position> : integer) => any

Sélectionne une valeur de colonne selon sa position relative (base 1) dans le flux. Si la position est hors limites, une valeur Null est retournée. Le type de la valeur retournée doit être converti par l’une des fonctions de conversion de type (TO_DATE, TO_STRING, etc.). Les entrées calculées ne sont pas prises en charge, mais vous pouvez utiliser les substitutions de paramètre.

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

Selon des conditions alternantes, applique une valeur ou une autre. Si les entrées sont en nombre égal, l’autre valeur est Null par défaut pour la dernière condition.

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

Calcule la racine cubique d’un nombre.

cbrt(8) -> 2.0

`ceil`

ceil(<value1> : number) => number

Retourne le plus petit entier qui n’est pas inférieur au nombre.

ceil(-0.1) -> 0

`char`

char(<Input> : number) => string

Retourne le caractère ascii représenté par le numéro d’entrée. Si le numéro d’entrée est supérieur à 256, le résultat équivaut à char(number % 256)

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

`coalesce`

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

Renvoie la première valeur non nulle d'un jeu d'entrées. Toutes les entrées doivent être du même type.

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

`collect`

collect(<value1> : any) => array

Collecte toutes les valeurs de l’expression dans le groupe agrégé dans un tableau. Les structures peuvent être collectées et transformées en d’autres structures au cours de ce processus. Le nombre d’éléments est égal au nombre de lignes dans ce groupe, et peut contenir des valeurs Null. Le nombre d’éléments collectés doit être petit.

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

`collectUnique`

collectUnique(<value1> : any) => array

Collecte toutes les valeurs de l’expression dans le groupe agrégé pour former un tableau unique. Les structures peuvent être collectées et transformées en d’autres structures au cours de ce processus. Le nombre d’éléments est égal au nombre de lignes dans ce groupe, et peut contenir des valeurs Null. Le nombre d’éléments collectés doit être petit.

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

`columnNames`

columnNames(<value1>columnNames( : string, i><value1> : boolean) => array Obtient les noms de toutes les colonnes de sortie pour un flux. Vous pouvez transmettre un nom de flux facultatif en tant que premier argument. Le deuxième argument est également facultatif, avec false comme valeur par défaut. Si vous définissez le deuxième argument sur true(), ADF retourne uniquement les colonnes dérivées via la dérive de schéma.



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



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


Obtient les valeurs de toutes les colonnes de sortie pour un flux. Vous pouvez transmettre un nom de flux facultatif en tant que deuxième argument.

columns()
columns('DeriveStream')



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


Compare deux valeurs du même type. Retourne un entier négatif si valeur1 < valeur2, 0 si valeur1 == valeur2, une valeur positive si valeur1 > valeur2.

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



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


Concatène un nombre variable de chaînes. Identique à l’opérateur + avec des chaînes.

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



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


Concatène un nombre variable de chaînes avec un séparateur. Le premier paramètre est le séparateur.

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


Retourne true si un élément quelconque du tableau fourni correspond à true dans le prédicat fourni. Contains attend une référence à un élément dans la fonction de prédicat comme #item.

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



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


Calcule une valeur de cosinus.

cos(10) -> -0.8390715290764524



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


Calcule le cosinus hyperbolique d’une valeur.

cosh(0) -> 1.0



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


Obtient le nombre agrégé de valeurs. Si la ou les colonnes facultatives sont spécifiées, les valeurs Null ne sont pas comptabilisées.

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



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


Obtient le nombre agrégé de valeurs, y compris les valeurs Null.

countAll(custId)
countAll()



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


Obtient la somme agrégée de valeurs distinctes appartenant à un ensemble de colonnes.

countDistinct(custId, custName)



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


Obtient le nombre agrégé des valeurs distinctes d’un ensemble de colonnes, y compris les valeurs Null.

countAllDistinct(custId, custName)



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


Selon certains critères, obtient le nombre agrégé de valeurs. Si la colonne facultative est spécifiée, les valeurs Null ne sont pas comptabilisées.

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



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


Obtient la covariance de remplissage entre deux colonnes.

covariancePopulation(sales, profit)



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


Selon certains critères, obtient la covariance de remplissage de deux colonnes.

covariancePopulationIf(region == 'West', sales)



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


Obtient l’exemple de covariance de deux colonnes.

covarianceSample(sales, profit)



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


Selon certains critères, obtient l’exemple de covariance de deux colonnes.

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



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


Calcule le hachage CRC32 de l’ensemble de colonnes comprenant différents types de données primitives à partir d’une longueur en bits, qui peut uniquement être égale aux valeurs 0(256), 224, 256, 384, 512. Il peut être utilisé dans le but de calculer une empreinte digitale pour une ligne.

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



cumeDist
cumeDist() => integer


La fonction CumeDist calcule la position d’une valeur par rapport à toutes les valeurs de la partition. Le résultat correspond au nombre de lignes précédant ou correspondant à la ligne actuelle dans l’ordre de la partition, divisé par le nombre total de lignes de la partition de fenêtre. Toutes les valeurs égales auront la même position.

cumeDist()



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


Obtient la date à laquelle l’exécution du travail commence. Vous pouvez passer un fuseau horaire facultatif au format 'GMT', 'PST', 'UTC', 'Amérique/Caïmans'. Le fuseau horaire local du centre de données/de la région de la fabrique de données est utilisé comme valeur par défaut. Reportez-vous à la classe SimpleDateFormat de Java pour connaître les formats disponibles. https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html.

currentDate() == toDate('2250-12-31') -> false
currentDate('PST')  == toDate('2250-12-31') -> false
currentDate('America/New_York')  == toDate('2250-12-31') -> false



currentTimestamp
currentTimestamp() => timestamp


Obtient l’horodatage du début de l’exécution du travail avec le fuseau horaire local.

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



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


Obtient l’horodatage actuel au format UTC. Si vous souhaitez que votre heure actuelle soit interprétée dans un fuseau horaire différent de celui de votre cluster, vous pouvez passer un fuseau horaire facultatif au format « GMT », « PST », « UTC », « Amérique/Caïmans ». La valeur par défaut est le fuseau horaire actuel. Reportez-vous à la classe SimpleDateFormat de Java pour connaître les formats disponibles. https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html. Pour convertir l’heure UTC en un fuseau horaire différent, utilisez 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


Obtient le jour du mois dans une date.

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



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


Obtient le jour de la semaine dans une date. 1 - dimanche, 2 - lundi..., 7 - samedi.

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



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


Obtient le jour de l’année dans une date.

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



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


Durée en millisecondes du nombre de jours.

days(2) -> 172800000L



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


Décode les données d’entrée encodées dans une chaîne basée sur le jeu de caractères donné. Un deuxième argument (facultatif) peut être utilisé pour indiquer quel jeu de caractères utiliser : « US-ASCII », « ISO-8859-1 », « UTF-8 » (par défaut), « UTF-16BE », « UTF-16LE », « UTF-16LE », « UTF-16 »

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



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


Convertit les radians en degrés.

degrees(3.141592653589793) -> 180



denseRank
denseRank() => integer


Calcule le rang d’une valeur dans un groupe de valeurs spécifiées dans la clause ORDER BY d’une fenêtre. Le résultat est égal à 1 plus le nombre de lignes précédant ou correspondant à la ligne actuelle dans l’ordre de la partition. Les valeurs ne produiront pas d’écarts dans la séquence. Le rang Dense fonctionne même quand les données ne sont pas triées, et il recherche les valeurs qui ont été modifiées.

denseRank()



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


Retourne un ensemble distinct d’éléments d’un tableau.

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



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


Divise une paire de nombres. Identique à l’opérateur /.

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



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


Supprime le nombre de caractères nécessaire à partir de la gauche de la chaîne. Si le nombre à supprimer est supérieur à la longueur de la chaîne, une chaîne vide est retournée.

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



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


Supprime le nombre de caractères nécessaire à partir de la droite de la chaîne. Si le nombre à supprimer est supérieur à la longueur de la chaîne, une chaîne vide est retournée.

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


E

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


Encode les données de la chaîne d’entrée en binaire basé sur un jeu de caractères. Un deuxième argument (facultatif) peut être utilisé pour indiquer quel jeu de caractères utiliser : « US-ASCII », « ISO-8859-1 », « UTF-8 » (par défaut), « UTF-16BE », « UTF-16LE », « UTF-16LE », « UTF-16 »

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


Chaîne d’entrée : chaîne, Jeu de caractères : chaîne) => binaire 
endsWith
endsWith(<string> : string, <substring to check> : string) => boolean


Vérifie si la chaîne se termine par la chaîne fournie.

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



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


Opérateur de comparaison « Est égal à » Identique à l’opérateur ==.

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


Opérateur de comparaison « Est égal à » qui ignore la casse. Identique à l’opérateur <=>.

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



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


Échappe une chaîne conformément à un format. Les valeurs littérales pour le format acceptable sont « json », « xml », « ecmascript », « html », « java ».


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


Retourne un jeu de différences d’un tableau à partir d’un autre en supprimant les doublons.

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



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


Génère une expression à partir d’une chaîne. Cela revient à écrire cette expression sous une forme non littérale. Ceci peut être utilisé pour passer des paramètres sous forme de représentations de chaîne.

expr('price * discount') => any


F

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


Calcule la factorielle d’un nombre.

factorial(5) -> 120



false
false() => boolean


Retourne toujours une valeur false. Utilisez la fonction syntax(false()) s’il existe une colonne nommée « false ».

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



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


Filtre hors du tableau les éléments qui ne respectent pas le prédicat fourni. Filter attend une référence à un élément dans la fonction de prédicat comme #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


Recherche le premier élément d’un tableau qui correspond à la condition. Elle prend une fonction de filtre dans laquelle vous pouvez traiter l’élément dans le tableau comme #item. Pour les mappages profondément imbriqués, vous pouvez faire référence aux mappages parents à l’aide de la notation #item_n(#item_1, #item_2...).

find([10, 20, 30], #item > 10) -> 20
find(['azure', 'data', 'factory'], length(#item) > 4) -> 'azure'
find([ @( name = 'Daniel', types = [ @(mood = 'jovial', behavior = 'terrific'), @(mood = 'grumpy', behavior = 'bad') ] ), @( name = 'Mark', types = [ @(mood = 'happy', behavior = 'awesome'), @(mood = 'calm', behavior = 'reclusive') ] ) ], contains(#item.types, #item.mood=='happy')  /*Filter out the happy kid*/ )
@( name = 'Mark', types = [ @(mood = 'happy', behavior = 'awesome'), @(mood = 'calm', behavior = 'reclusive') ] )



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


Obtient la première valeur d’un groupe de colonnes. Si le deuxième paramètre ignoreNulls est omis, il est supposé que sa valeur est false.

first(sales)
first(sales, false)



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


Aplatit le ou les tableaux en un seul tableau. Les tableaux d’éléments atomiques sont retournés sans modification. Le dernier argument est facultatif et sa valeur par défaut est false pour aplatir de manière récursive plus d’un niveau de profondeur.

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



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


Retourne le plus grand entier qui n’est pas supérieur au nombre.

floor(-0.1) -> -1



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


Décode la chaîne encodée en base64. Vous pouvez éventuellement passer le type d’encodage.

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



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


Convertit vers l’horodatage à partir du temps universel coordonné. Vous pouvez, si vous le souhaitez, passer un fuseau horaire au format 'GMT', 'PST', 'UTC', 'Amérique/Caïmans'. La valeur par défaut est le fuseau horaire actuel. Reportez-vous à la classe SimpleDateFormat de Java pour connaître les formats disponibles. https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html.

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


G

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


Opérateur de comparaison « Supérieur à » Identique à l’opérateur >.

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


Opérateur de comparaison « Supérieur ou égal à ». Identique à l’opérateur >=.

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



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


Retourne la valeur la plus élevée parmi celles de la liste des valeurs d’entrée, en ignorant les valeurs Null. Retourne la valeur Null si toutes les entrées ont une valeur 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


Vérifie une valeur de colonne par son nom dans le flux de données. Vous pouvez transmettre un nom de flux facultatif en tant que deuxième argument. Les noms de colonne connus au moment de la conception doivent être traités uniquement selon leur nom. Les entrées calculées ne sont pas prises en charge, mais vous pouvez utiliser des substitutions de paramètre.

hasColumn('parent')



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


Vérifie si l’assertion avec l’ID fourni est marquée comme erreur.
Exemples

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



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


Vérifie s’il existe un certain chemin d’accès hiérarchique par nom dans le flux. Vous pouvez transmettre un nom de flux facultatif en tant que deuxième argument. Les noms/chemins de colonnes connus au moment de la conception doivent être adressés uniquement par leur nom ou leur chemin en notation pointée. Les entrées calculées ne sont pas prises en charge, mais vous pouvez utiliser des substitutions de paramètre.

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



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


Renvoie une représentation sous forme de chaîne hexadécimale d'une valeur binaire

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



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


Obtient la valeur d’heure d’un horodatage. Vous pouvez passer un fuseau horaire facultatif au format 'GMT', 'PST', 'UTC', 'Amérique/Caïmans'. Le fuseau horaire local est utilisé par défaut. Reportez-vous à la classe SimpleDateFormat de Java pour connaître les formats disponibles. https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html.

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



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


Durée en millisecondes du nombre d’heures.

hours(2) -> 7200000L


I

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


Selon la condition, applique une valeur ou une autre. Si l’autre valeur n’est pas spécifiée, elle est considérée comme Null. Les deux valeurs doivent être compatibles (numérique, chaîne...).

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


À partir de deux entrées ou plus, retourne le premier élément non null. Cette fonction est équivalente à coalesce.

iifNull(10, 20) -> 10
iifNull(null, 20, 40) -> 20
iifNull('azure', 'data', 'factory') -> 'azure'
iifNull(null, 'data', 'factory') -> 'data'



in
in(<array of items> : array, <item to find> : any) => boolean


Vérifie si un élément se trouve dans le tableau.

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



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


Convertit la première lettre de chaque mot en majuscules. Les mots sont identifiés comme étant séparés par des espaces blancs.

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



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


Recherche la position (de base 1) de la sous-chaîne au sein d’une chaîne. Si elle est introuvable, 0 est retourné.

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



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


Retourne un ensemble d’intersection d’un élément distinct depuis 2 tableaux.

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



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


Vérifie si une position de bit est définie dans ce bitset

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



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


Détermine si la valeur de chaîne est une valeur booléenne conformément aux règles de toBoolean()

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



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


Détermine si la valeur de chaîne est une valeur d'octet au format facultatif conformément aux règles de toByte()

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



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


Détermine si la chaîne de date d'entrée est une date en utilisant un format de date d'entrée facultatif. Reportez-vous à la classe SimpleDateFormat de Java pour connaître les formats disponibles. Si le format de date d’entrée est omis, le format par défaut est yyyy-[M]M-[d]d. Les formats acceptés sont les suivants : [ 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


Détermine si la valeur de chaîne est une valeur décimale au format facultatif conformément aux règles de toDecimal()

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



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


Vérifie si la ligne est marquée pour la suppression. Pour les transformations qui acceptent plusieurs flux d’entrée, vous pouvez passer l’index (de base 1) du flux. L’index de flux doit être 1 ou 2 et la valeur par défaut est 1.

isDelete()
isDelete(1)



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


Détermine si une colonne ou un ensemble de colonnes est distinct. Elle ne compte pas Null comme une valeur distincte

isDistinct(custId, custName) => boolean



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


Détermine si la valeur de chaîne est une valeur double au format facultatif conformément aux règles de toDouble()

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



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


Vérifie si la ligne est marquée comme comprenant une erreur. Pour les transformations qui acceptent plusieurs flux d’entrée, vous pouvez passer l’index (de base 1) du flux. L’index de flux doit être 1 ou 2 et la valeur par défaut est 1.

isError()
isError(1)



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


Détermine si la valeur de chaîne est une valeur flottante au format facultatif conformément aux règles de toFloat()

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



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


Vérifie si la ligne est marquée comme devant être ignorée. Pour les transformations qui acceptent plusieurs flux d’entrée, vous pouvez passer l’index (de base 1) du flux. L’index de flux doit être 1 ou 2 et la valeur par défaut est 1.

isIgnore()
isIgnore(1)



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


Vérifie si la ligne est marquée pour l’insertion. Pour les transformations qui acceptent plusieurs flux d’entrée, vous pouvez passer l’index (de base 1) du flux. L’index de flux doit être 1 ou 2 et la valeur par défaut est 1.

isInsert()
isInsert(1)



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


Détermine si la valeur de chaîne est une valeur entière au format facultatif conformément aux règles de toInteger()

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



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


Détermine si la valeur de chaîne est une valeur longue au format facultatif conformément aux règles de toLong()

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



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


Vérifie si la ligne correspond à la recherche. Pour les transformations qui acceptent plusieurs flux d’entrée, vous pouvez passer l’index (de base 1) du flux. L’index de flux doit être 1 ou 2 et la valeur par défaut est 1.

isMatch()
isMatch(1)



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


Vérifiez s’il ne s’agit pas d’un nombre.

isNan(10.2) => false



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


Vérifie si la valeur est NULL.

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



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


Détermine si la valeur de chaîne est une valeur courte au format facultatif conformément aux règles de toShort()

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



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


Détermine si la chaîne de date d'entrée est un horodateur à l'aide d'un format d'horodatage d'entrée facultatif. Reportez-vous à la classe SimpleDateFormat de Java pour connaître les formats disponibles. Si l'horodatage est omis, le modèle par défaut yyyy-[M]M-[d]d hh:mm:ss[.f...] est utilisé. Vous pouvez passer un fuseau horaire facultatif au format 'GMT', 'PST', 'UTC', 'Amérique/Caïmans'. L'horodatage prend en charge une précision allant jusqu'à la milliseconde avec une valeur de 999. Reportez-vous à la classe SimpleDateFormat de Java pour connaître les formats disponibles.

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


Vérifie si la ligne est marquée pour la mise à jour. Pour les transformations qui acceptent plusieurs flux d’entrée, vous pouvez passer l’index (de base 1) du flux. L’index de flux doit être 1 ou 2 et la valeur par défaut est 1.

isUpdate()
isUpdate(1)



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


Vérifie si la ligne est marquée pour l’insertion. Pour les transformations qui acceptent plusieurs flux d’entrée, vous pouvez passer l’index (de base 1) du flux. L’index de flux doit être 1 ou 2 et la valeur par défaut est 1.

isUpsert()
isUpsert(1)


J

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


Obtient la distance JaroWinkler entre deux chaînes.

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


K

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


Crée un mappage de clés/valeurs. Le premier paramètre est un tableau de clés et le second est le tableau de valeurs. Les deux tableaux doivent avoir la même longueur.

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



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


Obtient l’aplatissement d’une colonne.

kurtosis(sales)



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


Selon certains critères, obtient l’aplatissement d’une colonne.

kurtosisIf(region == 'West', sales)


L

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


Obtient la valeur des n lignes évaluées dans le premier paramètre avant la ligne actuelle. Le deuxième paramètre correspond au nombre de lignes précédentes à examiner et la valeur par défaut est 1. S’il n’y a pas autant de lignes, la valeur Null est retournée, sauf si une valeur par défaut est spécifiée.

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



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


Obtient la dernière valeur d’un groupe de colonnes. Si le deuxième paramètre ignoreNulls est omis, il est supposé que sa valeur est false.

last(sales)
last(sales, false)



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


Obtient le dernier jour du mois dans une date.

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



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


Obtient la valeur des n lignes évaluées dans le premier paramètre après la ligne actuelle. Le deuxième paramètre correspond au nombre de lignes suivantes à examiner et la valeur par défaut est 1. S’il n’y a pas autant de lignes, la valeur Null est retournée, sauf si une valeur par défaut est spécifiée.

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



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


Opérateur de comparaison « Inférieur ou égal à ». Identique à l’opérateur <=.

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


Extrait une sous-chaîne comportant un certain nombre de caractères en partant de la gauche d’une chaîne au niveau de l’index 1. Identique à SUBSTRING(str, 1, n).

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



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


Retourne la longueur de la chaîne.

length('dumbo') -> 5



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


Opérateur de comparaison « Inférieur à » Identique à l’opérateur <.

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


Opérateur de comparaison « Inférieur ou égal à ». Identique à l’opérateur <=.

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



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


Obtient la distance levenshtein entre deux chaînes.

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



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


Le modèle est une chaîne qui est mise en correspondance littéralement. Les exceptions sont les symboles spéciaux suivants : _ correspond à n’importe quelle entrée (semblable à . dans les expressions régulières posix) % correspond à zéro ou plusieurs caractères de l’entrée (semblable à .* dans les expressions régulières posix).
Le caractère d’échappement est « '' ». Si un caractère d’échappement précède un caractère spécial ou un autre caractère d’échappement, le caractère qui suit a une correspondance littérale. Aucun autre caractère ne peut être échappé.

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



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


Recherche la position (de base 1) de la sous-chaîne au sein d’une chaîne, en partant d’une certaine position. Si la position est omise, on considère qu’elle est située au début de la chaîne. Si elle est introuvable, 0 est retourné.

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



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


Calcule la valeur de journal. Une base facultative peut être fournie, voire un nombre Euler, le cas échéant.

log(100, 10) -> 2



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


Calcule la valeur de journal sur une base 10.

log10(100) -> 2



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


Recherche la première ligne du récepteur mis en cache en utilisant les clés spécifiées qui correspondent aux clés du récepteur mis en cache.

cacheSink#lookup(movieId)



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


Convertit une chaîne en minuscules.

lower('GunChus') -> 'gunchus'



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


Décale la chaîne sur la gauche selon la marge intérieure fournie, jusqu’à ce qu’elle atteigne une certaine longueur. Si la longueur de la chaîne est supérieure ou égale à cette longueur, elle est tronquée à la longueur.

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



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


Supprime une chaîne de caractères de début situés sur la gauche. Si le deuxième paramètre n’est pas spécifié, cela supprime l’espace blanc. Sinon, cela supprime tout caractère spécifié dans le deuxième paramètre.

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


M

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


Mappe chaque élément du tableau à un nouvel élément à l’aide de l’expression fournie. Map attend une référence à un élément dans la fonction d’expression comme #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


Transforme une carte en associant les clés aux nouvelles valeurs. Retourne un tableau. Prend une fonction de mappage dans laquelle vous pouvez traiter l’élément comme #key et la valeur actuelle comme #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


Mappe conditionnellement un tableau à un autre tableau de même longueur ou plus petit. Les valeurs peuvent être de n’importe quel type de données, y compris structTypes. Elle prend une fonction de filtre dans laquelle vous pouvez traiter l’élément dans le tableau comme #item et l’index actuel comme #index. Pour les mappages profondément imbriqués, vous pouvez référencer les mappages parents à l’aide de la notation #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


Mappe chaque élément du tableau à un nouvel élément à l’aide de l’expression fournie. Map attend une référence à un élément dans la fonction d’expression sous la forme #item et une référence à l’index des éléments sous la forme #index.

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



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


Boucle de 1 à la longueur définie pour créer un tableau de cette longueur. Elle prend une fonction de mappage dans laquelle vous pouvez traiter l’index dans le tableau comme #index. Pour les mappages profondément imbriqués, vous pouvez référencer les mappages parents à l’aide de la notation #index_n(#index_1, #index_2...).

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



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


Obtient la valeur maximale d’une colonne.

max(sales)



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


Selon certains critères, obtient la valeur maximale d’une colonne.

maxIf(region == 'West', sales)



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


Calcule le code de hachage MD5 de l’ensemble de colonnes comprenant différents types de données primitives, et retourne une chaîne hexadécimale de 32 caractères. Il peut être utilisé dans le but de calculer une empreinte digitale pour une ligne.

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



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


Obtient la moyenne des valeurs d’une colonne. Identique à AVG.

mean(sales)



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


Selon certains critères, obtient la moyenne des valeurs d’une colonne. Identique à avgIf.

meanIf(region == 'West', sales)



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


Obtient la valeur en millisecondes d'une date. Vous pouvez passer un fuseau horaire facultatif au format 'GMT', 'PST', 'UTC', 'Amérique/Caïmans'. Le fuseau horaire local est utilisé par défaut. Reportez-vous à la classe SimpleDateFormat de Java pour connaître les formats disponibles. https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html.

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



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


Durée en millisecondes du nombre de millisecondes.

milliseconds(2) -> 2L



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


Obtient la valeur minimale d’une colonne.

min(sales)



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


Selon certains critères, obtient la valeur minimale d’une colonne.

minIf(region == 'West', sales)



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


Soustrait des nombres. Soustrait le nombre de jours à une date. Soustrait une durée d’un timestamp. Soustrait deux timestamps pour obtenir la différence en millisecondes. Identique à l’opérateur -.

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


Obtient la valeur de minute d’un horodatage. Vous pouvez passer un fuseau horaire facultatif au format 'GMT', 'PST', 'UTC', 'Amérique/Caïmans'. Le fuseau horaire local est utilisé par défaut. Reportez-vous à la classe SimpleDateFormat de Java pour connaître les formats disponibles. https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html.

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



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


Durée en millisecondes du nombre de minutes.

minutes(2) -> 120000L



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


Recherche toutes les lignes correspondantes du récepteur mis en cache en utilisant les clés spécifiées qui correspondent aux clés du récepteur mis en cache.

cacheSink#mlookup(movieId)



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


Module une paire de nombres. Identique à l’opérateur %.

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



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


Obtient la valeur de mois d’une date ou d’un horodatage.

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



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


Obtient le nombre de mois entre deux dates. Vous pouvez arrondir le calcul. Vous pouvez passer un fuseau horaire facultatif au format 'GMT', 'PST', 'UTC', 'Amérique/Caïmans'. Le fuseau horaire local est utilisé par défaut. Reportez-vous à la classe SimpleDateFormat de Java pour connaître les formats disponibles. https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html.

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



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


Multiplie une paire de nombres. Identique à l’opérateur *.

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


N

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


Inverse un nombre. Transforme les nombres positifs en nombres négatifs, et vice versa.

negate(13) -> -13



nextSequence
nextSequence() => long


Retourne la séquence unique suivante. Le nombre est consécutif uniquement au sein d’une partition et il est préfixé de partitionId.

nextSequence() == 12313112 -> false



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


Normalise la valeur de chaîne pour séparer les caractères Unicode accentués.

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



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


Opérateur de négation logique.

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



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


Opérateur de comparaison « N'est pas égal à » Identique à l’opérateur !=.

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



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


La fonction NTile divise les lignes de chaque partition de fenêtre en n compartiments, compris entre 1 et n au maximum. Les valeurs de compartiment varient de 1 au maximum. Si les lignes de la partition ne sont pas réparties de façon uniforme dans les compartiments, les valeurs restantes sont distribuées une par une dans chaque compartiment, en commençant par le premier compartiment. La fonction NTile est utile pour le calcul des tertiles, quartiles, déciles et autres statistiques de synthèse courantes. La fonction calcule deux variables pendant l’initialisation : Aucune ligne supplémentaire ne sera ajoutée à la taille d’un compartiment habituel. Les deux variables sont basées sur la taille de la partition actuelle. Pendant le processus de calcul, la fonction effectue le suivi du nombre actuel de lignes, du nombre actuel de compartiments et du nombre de lignes où le compartiment va changer (bucketThreshold). Lorsque le nombre actuel de lignes atteint le seuil du compartiment, la valeur du compartiment est augmentée de 1 et le seuil est augmenté par la taille du compartiment (plus 1, si le compartiment actuel est rempli).

nTile()
nTile(numOfBuckets)



null
null() => null


Retourne une valeur NULL. Utilisez la fonction syntax(null()) s’il existe une colonne nommée « null ». Toute opération qui l’utilise entraînera une valeur 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


Opérateur OR logique. Identique à ||.

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



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


Obtient toutes les colonnes de sortie pour un flux d’origine où des colonnes ont été créées. Se place au sein d’une autre fonction.

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



output
output() => any


Retourne la première ligne des résultats du récepteur de cache

cacheSink#output()



outputs
output() => any


Retourne la totalité des lignes de sortie des résultats du récepteur de cache

cacheSink#outputs()


P

partitionId
partitionId() => integer


Retourne l’ID de partition actuel où se trouve la ligne d’entrée.

partitionId()



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


Module positivement une paire de nombres.

pmod(-20, 8) -> 4



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


Élève un nombre à la puissance d’un autre nombre.

power(10, 2) -> 100


R

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


Convertit les degrés en radians.

radians(180) => 3.141592653589793



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


Retourne un nombre aléatoire selon une valeur initiale facultative dans une partition. La valeur initiale doit être une valeur fixe, et elle est utilisée avec la valeur partitionId pour produire des valeurs aléatoires

random(1) == 1 -> false



rank
rank() => integer


Calcule le rang d’une valeur dans un groupe de valeurs spécifiées dans la clause ORDER BY d’une fenêtre. Le résultat est égal à 1 plus le nombre de lignes précédant ou correspondant à la ligne actuelle dans l’ordre de la partition. Les valeurs vont produire des écarts dans la séquence. Le rang fonctionne même quand les données ne sont pas triées, et il recherche les valeurs qui ont été modifiées.

rank()



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


Transforme une carte en associant les clés aux nouvelles valeurs. Prend une fonction de mappage dans laquelle vous pouvez traiter l’élément comme #key et la valeur actuelle comme #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


Accumule des éléments dans un tableau. Reduce attend une référence à un accumulateur et un élément dans la première fonction d’expression comme #acc et #item et il attend que la valeur résultante comme #result soit utilisée dans la deuxième fonction d’expression.

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


Extrait une sous-chaîne correspondant à un modèle d’expression régulière donné. Le dernier paramètre identifie le groupe de correspondance. S’il est omis, la valeur par défaut est de 1. Utilisez <regex> (apostrophe ouvrante) pour rechercher une chaîne sans séquence d’échappement. L’index 0 retourne toutes les correspondances. Sans les groupes de correspondances, l’index 1 et les versions ultérieures ne retournent aucun résultat.

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


Vérifie si la chaîne correspond au modèle d’expression régulière donné. Utilisez <regex> (apostrophe ouvrante) pour rechercher une chaîne sans séquence d’échappement.

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


Remplace toutes les occurrences d’un modèle d’expression régulière par une autre sous-chaîne d’une chaîne donnée. Utilisez <regex>(apostrophe ouvrante) pour rechercher une chaîne sans séquence d’échappement.

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


Fractionne une chaîne selon un délimiteur basé sur une expression régulière et retourne un tableau de chaînes.

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


Remplace toutes les occurrences d’une sous-chaîne par une autre sous-chaîne dans une chaîne donnée. Si le dernier paramètre est omis, sa valeur par défaut est une chaîne vide.

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



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


Inverse une chaîne.

reverse('gunchus') -> 'suhcnug'



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


Extrait une sous-chaîne comportant un certain nombre de caractères en partant de la droite. Identique à SUBSTRING(str, LENGTH(str) - n, n).

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



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


Vérifie si la chaîne correspond au modèle d’expression régulière donné.

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



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


Arrondit un nombre donné selon une mise à l’échelle et un mode d’arrondi facultatifs. Si l’échelle est omise, la valeur par défaut 0 est utilisée. Si le mode est omis, la valeur par défaut ROUND_HALF_UP(5) est utilisée. Les valeurs de l’arrondi incluent

ROUND_UP : mode arrondi pour arrondir vers le haut.
ROUND_DOWN : mode arrondi à arrondir vers le bas.
ROUND_CEILING : mode arrondi pour arrondir vers l’infini positif. [Identique à ROUND_UP si l’entrée est positive. Si elle est négative, se comporte comme ROUND_DOWN. Ex = -1.1 serait -1.0 avec ROUND_CEILING et -2 avec ROUND_UP]
ROUND_FLOOR : mode arrondi pour arrondir vers l’infini négatif. [Identique à ROUND_DOWN si l’entrée est positive. Si elle est négative, se comporte comme ROUND_UP]
ROUND_HALF_UP : mode arrondi pour arrondir vers le « voisin le plus proche », sauf si les deux voisins sont équidistants, auquel cas ROUND_UP s’applique. [La valeur la plus courante + celle par défaut pour le flux de données].
ROUND_HALF_DOWN : mode arrondi pour arrondir vers le « voisin le plus proche », sauf si les deux voisins sont équidistants, auquel cas ROUND_DOWN s’applique.
ROUND_HALF_EVEN : mode arrondi pour arrondir vers le « voisin le plus proche », sauf si les deux voisins sont équidistants, auquel cas, arrondit vers le voisin pair.
ROUND_UNNECESSARY : mode arrondi pour affirmer que l’opération arrondie a un résultat exact. Par conséquent, aucun arrondi n’est nécessaire.


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



rowNumber
rowNumber() => integer


Attribue un numérotage séquentiel aux lignes d’une fenêtre en commençant par 1.

rowNumber()


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


Décale la chaîne sur la droite selon la marge intérieure fournie, jusqu’à ce qu’elle atteigne une certaine longueur. Si la longueur de la chaîne est supérieure ou égale à cette longueur, elle est tronquée à la longueur.

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



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


Supprime une chaîne de caractères de début situés sur la droite. Si le deuxième paramètre n’est pas spécifié, cela supprime l’espace blanc. Sinon, cela supprime tout caractère spécifié dans le deuxième paramètre.

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


S

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


Obtient la deuxième valeur d’une date. Vous pouvez passer un fuseau horaire facultatif au format 'GMT', 'PST', 'UTC', 'Amérique/Caïmans'. Le fuseau horaire local est utilisé par défaut. Reportez-vous à la classe SimpleDateFormat de Java pour connaître les formats disponibles. https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html.

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



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


Durée en millisecondes du nombre de secondes.

seconds(2) -> 2000L



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


Fixe la position des bits dans ce bitset

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



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


Calcule le code de hachage SHA-1 de l’ensemble de colonnes comprenant différents types de données primitives, et retourne une chaîne hexadécimale de 40 caractères. Il peut être utilisé dans le but de calculer une empreinte digitale pour une ligne.

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



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


Calcule le code de hachage SHA-2 de l’ensemble de colonnes comprenant différents types de données primitives à partir d’une longueur en bits, qui peut uniquement être égale aux valeurs 0(256), 224, 256, 384, 512. Il peut être utilisé dans le but de calculer une empreinte digitale pour une ligne.

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



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


Calcule une valeur de sinus.

sin(2) -> 0.9092974268256817



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


Calcule une valeur de sinus hyperbolique.

sinh(0) -> 0.0



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


Recherche la taille d’un tableau ou d’un type de mappage

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



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


Obtient l’asymétrie d’une colonne.

skewness(sales)



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


Selon certains critères, obtient l’asymétrie d’une colonne.

skewnessIf(region == 'West', sales)



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


Extrait un sous-ensemble d’un tableau en partant d’une position. La position est de base 1. Si la longueur est omise, elle est définie par défaut sur la fin de la chaîne.

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


Trie le tableau à l’aide de la fonction de prédicat fournie. Sort attend une référence à deux éléments consécutifs dans la fonction d’expression comme #item1 et #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


Obtient le code soundex de la chaîne.

soundex('genius') -> 'G520'



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


Fractionne une chaîne selon un délimiteur et retourne un tableau de chaînes.

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


Calcule la racine carrée d’un nombre.

sqrt(9) -> 3



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


Vérifie si la chaîne commence par la chaîne fournie.

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



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


Obtient l’écart type d’une colonne.

stdDev(sales)



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


Selon certains critères, obtient l’écart type d’une colonne.

stddevIf(region == 'West', sales)



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


Obtient l’écart type de remplissage d’une colonne.

stddevPopulation(sales)



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


Selon certains critères, obtient l’écart type de remplissage d’une colonne.

stddevPopulationIf(region == 'West', sales)



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


Obtient l’exemple d’écart type d’une colonne.

stddevSample(sales)



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


Selon certains critères, obtient l’exemple d’écart type d’une colonne.

stddevSampleIf(region == 'West', sales)



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


Soustrait des jours d’une date ou d’un horodatage. Identique à l’opérateur - pour la date.

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



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


Soustrait des mois d’une date ou d’un timestamp.

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


Extrait une sous-chaîne d’une certaine longueur en partant d’une position. La position est de base 1. Si la longueur est omise, elle est définie par défaut sur la fin de la chaîne.

substring('Cat in the hat', 5, 2) -> 'in'
substring('Cat in the hat', 5, 100) -> 'in the hat'
substring('Cat in the hat', 5) -> 'in the hat'
substring('Cat in the hat', 100, 100) -> ''



substringIndex
substringIndex(<string to subset><delimiter>substringIndex( : string,  : string, <count of delimiter occurences> : integral]) => string


Extrait le substring avant les occurrences count du délimiteur. Si count est positif, tout ce qui se trouve à gauche du délimiteur final (en partant de la gauche) est retourné. Si count est négatif, tout ce qui se trouve à droite du délimiteur final (en partant de la droite) est retourné.


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


Obtient la somme agrégée d’une colonne numérique.

sum(col)



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


Obtient la somme agrégée de valeurs distinctes appartenant à une colonne numérique.

sumDistinct(col)



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


Selon certains critères, obtient la somme agrégée d’une colonne numérique. La condition peut être basée sur n’importe quelle colonne.

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



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


Selon certains critères, obtient la somme agrégée d’une colonne numérique. La condition peut être basée sur n’importe quelle colonne.

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


T

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


Calcule une valeur de tangente.

tan(0) -> 0.0



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


Calcule une valeur de tangente hyperbolique.

tanh(0) -> 0.0



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


Encode la chaîne donnée en base64. Vous pouvez éventuellement passer le type d’encodage.

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



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


Convertit toutes les valeurs numériques/date/timestamp/chaîne en représentation binaire.

toBinary(3) -> [0x11]



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


Convertit ('t', 'true', 'y', 'yes', '1') en valeur true, ('f', 'false', 'n', 'no', '0') en valeur false et toute autre valeur en valeur Null.

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



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


Convertit une valeur numérique ou une chaîne en une valeur de type octet. Un format décimal Java facultatif peut être utilisé pour la conversion.

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



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


Convertit la chaîne de date d’entrée en date à l’aide d’un format de date d’entrée facultatif. Reportez-vous à la classe SimpleDateFormat de Java pour connaître les formats disponibles. Si le format de date d’entrée est omis, le format par défaut est aaaa-[M]M-[j]j. Les formats acceptés sont les suivants :[ aaaa, aaaa-[M]M, aaaa-[M]M-[j]h, aaaa-[M]M-[j]jT* ].

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)


Convertit une valeur numérique ou une chaîne en une valeur de type decimal. Si la précision et l’échelle ne sont pas spécifiées, la valeur par défaut est (10,2). Un format décimal Java facultatif peut être utilisé pour la conversion. Un format de paramètres régionaux facultatif sous forme de langue BCP47, par exemple en-US, de, zh-CN.

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



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


Convertit une valeur numérique ou une chaîne en une valeur de type double. Un format décimal Java facultatif peut être utilisé pour la conversion. Un format de paramètres régionaux facultatif sous forme de langue BCP47, par exemple en-US, de, zh-CN.

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



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


Convertit une valeur numérique ou une chaîne en une valeur de type float. Un format décimal Java facultatif peut être utilisé pour la conversion. Tronque toutes les valeurs de type double.

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



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


Convertit une valeur numérique ou une chaîne en une valeur entière. Un format décimal Java facultatif peut être utilisé pour la conversion. Tronque toutes les valeurs de type long, float ou double.

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



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


Convertit une valeur numérique ou une chaîne en une valeur de type long. Un format décimal Java facultatif peut être utilisé pour la conversion. Tronque toutes les valeurs de type float ou double.

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



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


Obtient les N premières valeurs de cette colonne en fonction de l’argument count.

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



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


Convertit une valeur numérique ou une chaîne en une valeur de type short. Un format décimal Java facultatif peut être utilisé pour la conversion. Tronque toutes les valeurs de type integer, long, float ou double.

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



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


Convertit un type de données primitif en une chaîne. Vous pouvez spécifier un format pour les nombres et les dates. Si aucun format n’est spécifié, la valeur système par défaut est utilisée. Le format décimal Java est utilisé pour les nombres. Pour connaître tous les formats de date possibles, reportez-vous à Java SimpleDateFormat. Le format par défaut est aaaa-MM-jj. Pour la date ou l’horodatage, des paramètres régionaux peuvent éventuellement être spécifiés.

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


Convertit une chaîne en timestamp en fonction d’un format de timestamp facultatif. Si l’horodatage est omis, le modèle par défaut est utilisé : aaaa-[M]M-[j]j hh:mm:ss[.f...]. Vous pouvez passer un fuseau horaire facultatif au format 'GMT', 'PST', 'UTC', 'Amérique/Caïmans'. L’horodateur prend en charge une précision à la milliseconde avec la valeur 999. Reportez-vous à la classe SimpleDateFormat de Java pour connaître les formats disponibles. https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html.

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



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


Convertit l’horodatage au format UTC. Vous pouvez passer un fuseau horaire facultatif au format 'GMT', 'PST', 'UTC', 'Amérique/Caïmans'. La valeur par défaut est le fuseau horaire actuel. Reportez-vous à la classe SimpleDateFormat de Java pour connaître les formats disponibles. https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html.

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


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


Remplace un jeu de caractères par un autre jeu de caractères dans la chaîne. Chaque caractère est remplacé par un seul caractère.

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



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


Supprime une chaîne de caractères de début et de fin. Si le deuxième paramètre n’est pas spécifié, cela supprime l’espace blanc. Sinon, cela supprime tout caractère spécifié dans le deuxième paramètre.

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



true
true() => boolean


Retourne toujours une valeur true. Utilisez la fonction syntax(true()) s’il existe une colonne nommée « true ».

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



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


Correspond au type de la colonne. Peut uniquement être utilisé dans les expressions de modèle. « number » peut être de type short, integer, long, double, float ou decimal ; « integral » peut être de type short, integer ou long ; « fractional » peut être de type double, float ou decimal et « datetime » peut être de type date ou timestamp.

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


U

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


Annule l’échappement d’une chaîne conformément à un format. Les valeurs littérales pour le format acceptable sont « json », « xml », « ecmascript », « html », « java ».

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



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


Déplie un tableau en un ensemble de lignes et répète les valeurs pour la colonne restante dans chaque ligne.

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



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


Annule la représentation sous forme de chaîne hexadécimale d'une valeur binaire. Peut être utilisé avec sha2, md5 pour convertir une chaîne en représentation binaire

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


Retourne un ensemble d’unions d’éléments distincts depuis 2 tableaux.

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



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


Convertit une chaîne en majuscules.

upper('bojjus') -> 'BOJJUS'



uuid
uuid() => string


Retourne l’UUID généré.

uuid()


V

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


Obtient la variance d’une colonne.

variance(sales)



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


Selon certains critères, obtient la variance d’une colonne.

varianceIf(region == 'West', sales)



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


Obtient la variance de remplissage d’une colonne.

variancePopulation(sales)



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


Selon certains critères, obtient la variance de remplissage d’une colonne.

variancePopulationIf(region == 'West', sales)



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


Obtient la variance non biaisée d’une colonne.

varianceSample(sales)



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


Selon certains critères, obtient la variance non biaisée d’une colonne.

varianceSampleIf(region == 'West', sales)


W

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


Obtient la semaine de l’année dans une date.

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



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


Durée en millisecondes du nombre de semaines.

weeks(2) -> 1209600000L


X

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


Opérateur logique XOR. Identique à l’opérateur ^.

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


O

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


Obtient la valeur d’année d’une date.

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

Contenu connexe

Liste de toutes les fonctions d’agrégation.
Liste de toutes les fonctions de tableau.
Liste de toutes les fonctions de recherche mise en cache.
Liste de toutes les fonctions de conversion.
Liste de toutes les fonctions de date et d’heure.
Liste de toutes les fonctions de conversion.
Liste de toutes les fonctions cartographiques.
Liste de toutes les métafonctions.
Liste de toutes les fonctions de fenêtre.
Découvrez comment utiliser le Générateur d’expressions.