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

• 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 et 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 du tableau fourni est évalué comme true dans le prédicat fourni. La fonction Th contains attend une référence à un élément dans la fonction de prédicat en tant que #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, elle ignore les NULL valeurs du nombre.

• 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é de valeurs distinctes d’un ensemble de colonnes, y compris les valeurs Null.

• countAllDistinct(custId, custName)

countIf

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

Obtient le nombre agrégé de valeurs, en fonction des critères. Si la colonne facultative est spécifiée, elle ignore les NULL valeurs du nombre.

• 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

Obtient la covariance de population de deux colonnes, sur la base de critères.

• 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

Obtient l’exemple de covariance de deux colonnes, en fonction des critères.

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

crc32

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

Calcule le hachage CRC32 d’un ensemble de colonnes de types de données primitifs variables en fonction d’une longueur de bits, qui ne peut être que de valeurs 0(256), 224, , 256384et 512. Vous pouvez l’utiliser pour calculer une empreinte digitale pour une ligne.

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

cumeDist

cumeDist() => integer

La cumeDist fonction 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 sous la forme , GMTPSTou UTCAmerica/Cayman. Le fuseau horaire local du centre de données/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.

• 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 un 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 fuseau horaire de cluster, vous pouvez passer un fuseau horaire facultatif sous la forme GMT, PSTou UTCAmerica/Cayman. Il est défini par défaut sur le fuseau horaire actuel. Reportez-vous à la classe SimpleDateFormat de Java pour connaître les formats disponibles. Pour convertir l’heure UTC en 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 lorsqu’une date est donnée.

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

dayOfWeek

dayOfWeek(<value1> : datetime) => integer

Obtient le jour de la semaine lorsqu’une date est donnée. Par exemple, 1 est dimanche, 2 est lundi, ... et 7 est samedi.

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

dayOfYear

dayOfYear(<value1> : datetime) => integer

Calcule le jour de l'année à partir d'une date donnée.

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

days

days(<value1> : integer) => long

Durée en millisecondes pour le 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é. Vous pouvez utiliser un deuxième argument (facultatif) pour spécifier l’ensemble de caractères à utiliser. Exemples : US-ASCII, ( ISO-8859-1UTF-8par défaut), UTF-16BE, UTF-16LEet 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. La denseRank fonction fonctionne même lorsque les données ne sont pas triées et recherchent la modification des valeurs.

• 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 spécifier l’ensemble de caractères à utiliser. Exemples : US-ASCII, ( ISO-8859-1UTF-8par défaut), UTF-16BE, UTF-16LEet 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

Utilise l’opérateur de comparaison « É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

Utilise l’opérateur de comparaison « É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, , xmlecmascript, htmlet 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, qui est identique à l’écriture de cette expression dans une forme non littérale. Vous pouvez l’utiliser pour passer des paramètres en tant que représentations sous forme de chaînes.

• 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()) si une colonne est 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 sous forme de #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. Il prend une fonction de filtre dans laquelle vous pouvez vous référer à l’élément dans le tableau en utilisant #item. Pour les cartes profondément imbriquées, vous pouvez faire référence aux cartes parentes à l’aide de la #item_n notation (#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 false.

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

flatten

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

Aplatit un tableau ou des 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 spécifique. 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 en horodatage à partir de l’heure UTC. Vous pouvez éventuellement passer le fuseau horaire sous la forme , GMTPSTou UTCAmerica/Cayman. Il est défini par défaut sur le fuseau horaire actuel. Reportez-vous à la classe SimpleDateFormat de Java pour connaître les formats disponibles.

• 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

Utilise l’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

Utilise l’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 la liste des valeurs en tant qu’entrée, en ignorant les valeurs Null. Retourne null si toutes les entrées sont 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. Adressez les noms de colonnes connus au moment du design par leurs noms. Les entrées calculées ne sont pas prises en charge, mais vous pouvez utiliser des substitutions de paramètres.

• hasColumn('parent')

hasError

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

Vérifie si l’actif avec ID fourni est marqué comme erreur.

Examples

• 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 du design doivent être traités uniquement à l’aide de leur nom ou de leur chemin de notation par points. Les entrées calculées ne sont pas prises en charge, mais vous pouvez utiliser des substitutions de paramètres.

• 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 sous la forme , GMTPSTou UTCAmerica/Cayman. Le fuseau horaire local est utilisé comme valeur par défaut. Reportez-vous à la classe SimpleDateFormat de Java pour connaître les formats disponibles.

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

hours

hours(<value1> : integer) => long

Obtient la durée en millisecondes pour le nombre d’heures.

• hours(2) -> 7200000L

I

iif

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

Applique une valeur ou l’autre en fonction d’une condition. Si l’autre n’est pas spécifié, la valeur est considérée NULL. Les deux valeurs doivent être compatibles (telles que numérique et 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

Retourne le premier élément non null lorsqu’il reçoit deux entrées ou plus. Cette fonction est équivalente à la coalesce fonction.

• 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. S’il 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 bits est définie dans ce bitset.

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

isBoolean

isBoolean(<value1>: string) => boolean

Vérifie si la valeur de chaîne est une valeur booléenne en fonction des règles de toBoolean().

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

isByte

isByte(<value1> : string) => boolean

Vérifie si la valeur de chaîne est une valeur d’octet lorsqu’elle est donnée à un format facultatif en fonction des règles de toByte().

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

isDate

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

Vérifie si la chaîne de date d’entrée est une 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 yyyy-[M]M-[d]d. Les formats acceptés sont :[ 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

Vérifie si la valeur de chaîne est une valeur décimale lorsqu’elle reçoit un 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 doit être supprimée. Pour les transformations qui prennent plusieurs flux d’entrée, vous pouvez passer l’index (basé sur 1) du flux. L’index de flux doit être soit 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 valeur distincte.

• isDistinct(custId, custName) => boolean

isDouble

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

Vérifie si la valeur de chaîne est une valeur double lorsqu’elle est donnée à un format facultatif en fonction des 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 une erreur. Pour les transformations qui prennent plusieurs flux d’entrée, vous pouvez passer l’index (basé sur 1) du flux. L’index de flux doit être l’un 1 ou l’autre 2 et la valeur par défaut est 1.

• isError()
• isError(1)

isFloat

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

Vérifie si la valeur de chaîne est une valeur float lorsqu’elle reçoit un format facultatif en fonction des 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 doit être ignorée. Pour les transformations qui prennent plusieurs flux d’entrée, vous pouvez passer l’index (basé sur 1) du flux. L’index de flux doit être soit 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 prennent plusieurs flux d’entrée, vous pouvez passer l’index (basé sur 1) du flux. L’index de flux doit être soit 1 ou 2, et la valeur par défaut est 1.

• isInsert()
• isInsert(1)

isInteger

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

Vérifie si la valeur de chaîne est une valeur entière lorsqu’elle est donnée à un format facultatif en fonction des règles de toInteger().

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

isLong

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

Vérifie si la valeur de chaîne est une valeur longue lorsqu’elle est donnée à un format facultatif en fonction des 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 prennent plusieurs flux d’entrée, vous pouvez passer l’index (basé sur 1) du flux. L’index de flux doit être soit 1 ou 2, et la valeur par défaut est 1.

• isMatch()
• isMatch(1)

isNan

isNan (<value1> : integral) => boolean

Vérifie si la valeur n’est pas 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

Vérifie si la valeur de chaîne est une valeur courte lorsqu’elle est donnée à un format facultatif en fonction des règles de toShort().

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

isTimestamp

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

Vérifie si la chaîne de date d’entrée est un horodatage à 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 yyyy-[M]M-[d]d hh:mm:ss[.f...] par défaut est utilisé. Vous pouvez passer un fuseau horaire facultatif sous la forme , GMTPSTou UTCAmerica/Cayman. La fonction timestamp 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 prennent plusieurs flux d’entrée, vous pouvez passer l’index (basé sur 1) du flux. L’index de flux doit être soit 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 prennent plusieurs flux d’entrée, vous pouvez passer l’index (basé sur 1) du flux. L’index de flux doit être soit 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

Obtient l’aplatissement d’une colonne selon certains critères.

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

L

lag

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

Obtient la valeur du premier paramètre évalué n les lignes avant la ligne actuelle. Le deuxième paramètre est le nombre de lignes à examiner et la valeur par défaut est 1. S’il n’y a pas autant de lignes, une 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é false.

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

lastDayOfMonth

lastDayOfMonth(<value1> : datetime) => date

Obtient le dernier jour du mois lorsqu’une date est donnée.

• 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 du premier paramètre évalué après n lignes suivant la ligne actuelle. Le deuxième paramètre est le nombre de lignes à regarder vers l’avant, et la valeur par défaut est 1. S’il n’y a pas autant de lignes, une 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

Utilise l’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 commençant à l’index 1 avec le nombre de caractères. 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

Utilise l’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

Utilise l’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

Utilise un motif de chaîne qui est mis en correspondance littéralement. Les exceptions sont les symboles spéciaux suivants : _ correspond à n’importe quel caractère de l’entrée (similaire à .* dans les posix expressions régulières). % correspond à zéro ou plusieurs caractères dans l’entrée (comme .* dans les posix expressions régulières). 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 (basée sur 1) de la sous-chaîne dans une chaîne commençant à une certaine position. Si la position est omise, elle commence à partir du début de la chaîne. S’il 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 logarithmique. Vous pouvez fournir une base facultative ou un numéro Euler si utilisé.

• log(100, 10) -> 2

log10

log10(<value1> : number) => double

Calcule la valeur du logarithme en 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 que la chaîne atteigne une certaine longueur. Si la longueur de la chaîne est supérieure ou égale à cette longueur, la chaîne 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é, il supprime les espaces blancs. Sinon, il 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. La fonction 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. Il prend une fonction de mappage où vous pouvez traiter l’élément en tant que #key et la valeur actuelle en tant que #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 de manière conditionnelle un tableau à un autre tableau de la même longueur ou plus petite. Les valeurs peuvent être de n’importe quel type de données, y compris structTypes. Il prend une fonction de mappage où vous pouvez traiter l’élément dans le tableau en tant que #item et l’index actuel en tant que #index. Pour les cartes profondément imbriquées, vous pouvez faire référence aux cartes parentes à 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. La map fonction attend une référence à un élément dans la fonction d’expression en tant que #item et une référence à l’index d’élément en tant que #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. Il prend une fonction de mappage où vous pouvez traiter l’index dans le tableau en tant que #index. Pour les cartes profondément imbriquées, vous pouvez faire référence aux cartes parentes à l’aide de la #index_n notation (#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

Obtient la valeur maximale d’une colonne, en fonction des critères.

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

md5

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

Calcule la synthèse MD5 d’un ensemble de colonnes de différents types de données primitifs et retourne une chaîne hexadécimal de 32 caractères. Vous pouvez l’utiliser pour 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

Obtient la moyenne des valeurs d’une colonne, en fonction des critères. 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 sous la forme , GMTPSTou UTCAmerica/Cayman. Le fuseau horaire local est utilisé comme valeur par défaut. Reportez-vous à la classe SimpleDateFormat de Java pour connaître les formats disponibles.

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

milliseconds

milliseconds(<value1> : integer) => long

Obtient la durée en millisecondes pour le 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

Obtient la valeur minimale d’une colonne, en fonction des critères.

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

minus

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

Soustrait des nombres. Soustrait le nombre de jours à partir d'une date. Soustrait la durée d’un horodatage. Soustraire deux horodatages afin d'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 des minutes d’un horodatage. Vous pouvez passer un fuseau horaire facultatif sous la forme , GMTPSTou UTCAmerica/Cayman. Le fuseau horaire local est utilisé comme valeur par défaut. Reportez-vous à la classe SimpleDateFormat de Java pour connaître les formats disponibles.

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

minutes

minutes(<value1> : integer) => long

Obtient la durée en millisecondes pour un nombre donné 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

Obtient le module d’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 sous la forme , GMTPSTou UTCAmerica/Cayman. Le fuseau horaire local est utilisé comme valeur par défaut. Reportez-vous à la classe SimpleDateFormat de Java pour connaître les formats disponibles.

• 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 dans une partition et est précédé de l’ID de partition.

• 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

Utilise l’opérateur de négation logique.

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

notEquals

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

Utilise l’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 nTile fonction divise les lignes de chaque partition de fenêtre en n compartiments allant du 1 au plus n. Les valeurs des compartiments diffèrent au maximum de 1. 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 n’est 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 numéro de ligne actuel, du numéro de compartiment actuel et du numéro de ligne auquel le compartiment change (bucketThreshold). Lorsque le numéro de ligne actuel atteint le seuil de compartiment, la valeur du compartiment augmente d’une unité. Le seuil augmente par la taille du compartiment (plus un supplémentaire si le compartiment actuel est rembourré).

• nTile()
• nTile(numOfBuckets)

null

null() => null

Retourne une valeur NULL. Utilisez la fonction syntax(null()) si une colonne est nommée null. Toute opération qui utilise null génère une NULL valeur.

• 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

Utilise l’opérateur logique OR . 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 actuel de partition dans lequel se trouve la ligne d’entrée.

• partitionId()

pMod

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

Donne les modulus positifs d’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) => double

Retourne un nombre aléatoire lorsqu’une valeur initiale est donnée dans une partition. La valeur initiale doit être une valeur fixe et est utilisée avec l’ID de partition pour produire des valeurs aléatoires dans une plage (0.0-1.0).

• 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 produisent des écarts dans la séquence. La rank fonction fonctionne même lorsque les données ne sont pas triées et recherchent la modification des valeurs.

• rank()

reassociate

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

Transforme une carte en associant les clés aux nouvelles valeurs. Il prend une fonction de mappage où vous pouvez traiter l’élément en tant que #key et la valeur actuelle en tant que #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. La fonction reduce requiert une référence à un accumulateur et un élément en tant que fonction d'expression initiale, représentés par #acc et #item. La valeur résultante, #result, est censée être 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 correspondante pour un modèle regex donné. Le dernier paramètre identifie le groupe de correspondances et par défaut il est défini à 1 s'il est omis. Utilise <regex> pour rechercher une chaîne sans séquence d’échappement. L’index 0 retourne toutes les correspondances. Sans groupes de correspondance, les indices 1 et supérieurs ne renvoient 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é. Utilise <regex> 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 regex par une autre sous-chaîne dans la chaîne spécifique. Utilise <regex> 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 la chaîne spécifique. Si le dernier paramètre est omis, il est défini par défaut sur 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 en fonction d’une échelle facultative et d’un mode d’arrondi facultatif. Si l’échelle est omise, elle a la valeur par défaut 0. Si le mode est omis, il est défini par défaut sur ROUND_HALF_UP(5). Les valeurs de l’arrondi incluent :

1. ROUND_UP : mode arrondi pour arrondir vers le haut.

2. ROUND_DOWN : mode arrondi pour arrondir vers zéro.

3. ROUND_CEILING: mode arrondi pour arrondir vers l’infini positif. (Identique à ROUND_UP si l’entrée est positive. S’il est négatif, il se comporte comme ROUND_DOWN. Par exemple, -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. S’il est négatif, il 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 il se comporte comme ROUND_UP. (Plus courant + valeur par défaut pour Dataflow.)

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.

7. ROUND_HALF_EVEN : mode arrondi pour arrondir vers le « plus proche voisin », 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 que la chaîne atteigne une certaine longueur. Si la longueur de la chaîne est supérieure ou égale à cette longueur, la chaîne 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é, il supprime les espaces blancs. Sinon, il 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 sous la forme , GMTPSTou UTCAmerica/Cayman. Le fuseau horaire local est utilisé comme valeur par défaut. Reportez-vous à la classe SimpleDateFormat de Java pour connaître les formats disponibles.

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

seconds

seconds(<value1> : integer) => long

Donne la durée en millisecondes pour un nombre en secondes.

• seconds(2) -> 2000L

setBitSet

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

Définit les positions de bits dans ce bitset.

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

sha1

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

Calcule la synthèse SHA-1 d’un ensemble de colonnes de différents types de données primitifs et retourne une chaîne hexadécimal de 40 caractères. Vous pouvez l’utiliser pour 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 la synthèse SHA-2 d’un ensemble de colonnes de types de données primitifs variables en fonction d’une longueur de bits, qui ne peut être que de valeurs 0(256), , 224, 256384et 512. Vous pouvez l’utiliser pour 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 carte.

• 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

Obtient l’asymétrie d’une colonne, selon certains critères.

• 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 par défaut à 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. La sort fonction attend une référence à deux éléments consécutifs dans la fonction d’expression en tant que #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

Obtient l’écart type d’une colonne, en fonction des critères.

• 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

Obtient l’écart type de population d’une colonne, en fonction des critères.

• 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

Obtient l’exemple d’écart type d’une colonne, en fonction des critères.

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

• 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 par défaut à 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( <chaîne vers sous-ensemble><délimiteur>substringIndex( : chaîne, : chaîne, <nombre d’occurrences du délimiteur> : entier]) => chaîne

Extrait la sous-chaîne avant les occurrences « count » du délimiteur. Si le nombre est positif, tout ce qui se trouve à gauche du dernier délimiteur (en comptant à partir de la gauche) est renvoyé. Si le nombre est négatif, tout ce qui se trouve à droite du dernier délimiteur (en comptant à partir de la droite) est retourné.