Partager via


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

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 à plusieurs 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 de type mappage de chaîne à 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, la valeur redevient nulle.

  • 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 Date/Heure 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 à & 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 la synthèse Blake2 de l’ensemble de colonnes comprenant différents types de données primitifs à partir d’une longueur en bits, qui peut uniquement être égale aux multiples de 8 compris 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 la synthèse Blake2 de l’ensemble de colonnes comprenant différents types de données primitifs à partir d’une longueur en bits, qui peut uniquement être égale aux multiples de 8 compris 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, ? chaîne...). Il suffit d’adresser les noms de colonnes connus au moment du design par 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...). Il suffit d’adresser les noms de colonnes connus au moment du design par 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 des fonctions de conversion de type (toDate, toString...). Il suffit d’adresser les noms de colonnes connus au moment du design 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...). Il suffit d’adresser les noms de colonnes connus au moment du design par 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...). Il suffit d’adresser les noms de colonnes connus au moment du design par 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...). Les entrées calculées ne sont pas prises en charge, mais vous pouvez utiliser des 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 nulles. 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 nulles. 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(), Data Factory 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 une ou plusieurs colonnes facultatives sont spécifiées, les valeurs nulles 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))

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, Data Factory suppose une fausse valeur.

  • 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. Il suffit d’adresser les noms de colonnes connus au moment du design par 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’actif avec l’ID fourni est marqué 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 n’est pas spécifié, la valeur est considérée comme nulle. 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’éléments distincts 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 symboles spéciaux suivants représentent des exceptions : « _ » correspond à tout caractère saisi (comme dans. les expressions régulières posix « % » correspond à un, aucun ou plusieurs caractère(s) saisi(s) (comme .* 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(<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

  1. ROUND_UP : mode arrondi pour arrondir vers le haut.
  2. ROUND_DOWN : mode arrondi à arrondir vers le bas.
  3. 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]
  4. 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]
  5. 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].
  6. 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.
  7. 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.
  8. 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. Ne peut être utilisé que dans les expressions de modèle. Nombre peut être court, entier, long, double, flottant ou decimal ; Intégral peut être de court, entier, long ; Fractionnaire peut être double, flottant ou decimal et Date/Heure 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