MaxCompute:Fonctions de chaîne

Notes d'utilisation

Limites

Les fonctions suivantes ne prennent en charge que les caractères anglais :

• TRIM/RTRIM/LTRIM : Le paramètre trimChars n'accepte que les caractères anglais.

• REVERSE : Ne prend en charge que les caractères anglais en mode Hive.

• SOUNDEX : Convertit uniquement les caractères anglais.

• TOLOWER : Convertit les lettres majuscules anglaises d'une chaîne en minuscules.

• TOUPPER : Convertit les lettres minuscules anglaises d'une chaîne en majuscules.

• INITCAP : Met en majuscule la première lettre anglaise de chaque mot et le reste en minuscules.

ASCII

• Syntaxe

  bigint ascii(string <str>)

• Description

  Renvoie le code ASCII du premier caractère de la chaîne str.

• Paramètres

  str : obligatoire. Type STRING. Si l'entrée est de type BIGINT, DOUBLE, DECIMAL ou DATETIME, elle est implicitement convertie en type STRING avant le calcul.

• Valeur renvoyée

  Renvoie une valeur de type BIGINT. La valeur renvoyée suit les règles suivantes :

  • Si str n'est pas de type STRING, BIGINT, DOUBLE, DECIMAL ou DATETIME, une erreur est renvoyée.

  • Si str est NULL, la valeur NULL est renvoyée.

• Exemples

  • Exemple 1 : Renvoyer le code ASCII du premier caractère de la chaîne abcde. Exemple d'instruction :

    -- Returns 97.
    select ascii('abcde'); 

  • Exemple 2 : Le paramètre d'entrée est NULL. Exemple d'instruction :

    -- Returns NULL.
    select ascii(null);

CHAR_MATCHCOUNT

• Syntaxe

  bigint char_matchcount(string <str1>, string <str2>)

• Description

  Calcule le nombre de caractères de str1 présents dans str2.

• Paramètres

  str1 et str2 : obligatoires. Type STRING. Les deux chaînes doivent être des chaînes UTF-8 valides. Si des caractères invalides (non encodés en Unicode) sont détectés lors de la comparaison, une valeur négative est renvoyée.

• Valeur renvoyée

  Renvoie une valeur de type BIGINT. Si str1 ou str2 est NULL, la valeur NULL est renvoyée.

• Exemples

  • Exemple 1 : Calculer le nombre de caractères de la chaîne aabc présents dans abcde. Exemple d'instruction :

    -- Returns 4.
    select char_matchcount('aabc','abcde');

  • Exemple 2 : L'un des paramètres d'entrée est NULL. Exemple d'instruction :

    -- Returns NULL.
    select char_matchcount(null,'abcde');

CHR

• Syntaxe

  string chr(bigint <ascii>)

• Description

  Convertit un code ASCII spécifié en caractère.

• Paramètres

  ascii : obligatoire. Valeur ASCII de type BIGINT. Valeurs valides : 0 à 127. Si l'entrée est de type STRING, DOUBLE ou DECIMAL, elle est implicitement convertie en type BIGINT avant le calcul.

• Valeur renvoyée

  Renvoie une valeur de type STRING. La valeur renvoyée suit les règles suivantes :

  • Si la valeur ascii se situe en dehors de la plage valide, une erreur est renvoyée.

  • Si ascii n'est pas de type BIGINT, STRING, DOUBLE ou DECIMAL, une erreur est renvoyée.

  • Si ascii est NULL, la valeur NULL est renvoyée.

• Exemples

  • Exemple 1 : Convertir le code ASCII 100 en caractère. Exemple d'instruction :

    -- Returns d.
    select chr(100);

  • Exemple 2 : Le paramètre d'entrée est NULL. Exemple d'instruction :

    -- Returns NULL.
    select chr(null);

  • Exemple 3 : L'entrée est un caractère de type STRING. Exemple d'instruction :

    --The input is implicitly converted to the BIGINT type for the operation, which returns 'd'.
    select chr('100');

CONCAT

• Syntaxe

  array<T> concat(array<T> <a>, array<T> <b>[,...])
  string concat(string <str1>, string <str2>[,...])

• Description

  • Entrées de type tableau : Concatène tous les éléments de plusieurs tableaux et renvoie un nouveau tableau.

  • Entrées de type chaîne : Concatène plusieurs chaînes et renvoie une nouvelle chaîne.

• Paramètres

  • a et b : obligatoires. Ces paramètres spécifient des tableaux. T dans array<T> indique le type de données des éléments des tableaux. Les éléments peuvent être de n'importe quel type de données. Les éléments du tableau a et ceux du tableau b doivent être du même type de données. Les éléments null participent également à l'opération.

  • str1 et str2 : obligatoires. Valeurs de type STRING. Si les valeurs d'entrée sont de type BIGINT, DOUBLE, DECIMAL ou DATETIME, elles sont implicitement converties en valeurs de type STRING avant le calcul. Si les valeurs d'entrée sont d'autres types de données, une erreur est renvoyée.

• Valeur renvoyée

  • Une valeur de type ARRAY est renvoyée. Si l'un des tableaux d'entrée est null, la valeur null est renvoyée.

  • Une valeur de type STRING est renvoyée. Si aucun paramètre d'entrée n'est configuré ou si un paramètre d'entrée est défini sur null, la valeur null est renvoyée.

• Exemples

  • Exemple 1 : Concaténer tous les éléments de array(10, 20) et array(20, -20). Exemple d'instruction :

    -- The return value is [10, 20, 20, -20]. 
    select concat(array(10, 20), array(20, -20));

  • Exemple 2 : L'un des tableaux d'entrée contient un élément null. Exemple d'instruction :

    -- The return value is [10, null, 20, -20]. 
    select concat(array(10, null), array(20, -20));

  • Exemple 3 : L'un des tableaux d'entrée est null. Exemple d'instruction :

    -- The return value is null. 
    select concat(array(10, 20), null);

  • Exemple 4 : Concaténer les chaînes aabc et abcde. Exemple d'instruction :

    -- The return value is aabcabcde. 
    select concat('aabc','abcde');

  • Exemple 5 : L'entrée est vide. Exemple d'instruction :

    -- The return value is null. 
    select concat();

  • Exemple 6 : L'une des chaînes d'entrée est null. Exemple d'instruction :

    -- The return value is null. 
    select concat('aabc', 'abcde', null);

CONCAT_WS

• Syntaxe

  string concat_ws(string <separator>, string <str1>, string <str2>[,...])
  string concat_ws(string <separator>, array<string> <a>)

• Description

  Renvoie une chaîne formée par la concaténation de toutes les chaînes d'entrée ou éléments de tableau à l'aide du délimiteur spécifié. Cette fonction est une extension de MaxCompute V2.0.

• Paramètres

  • separator : obligatoire. Délimiteur de type STRING.

  • str1 et str2 : Au moins deux chaînes doivent être spécifiées. Type STRING. Si l'entrée est de type BIGINT, DECIMAL, DOUBLE ou DATETIME, elle est implicitement convertie en type STRING avant le calcul.

  • a : obligatoire. Type ARRAY. Les éléments du tableau doivent être de type STRING.

• Valeur renvoyée

  Renvoie une valeur de type STRING ou STRUCT. La valeur renvoyée suit les règles suivantes :

  • Si str1 ou str2 n'est pas de type STRING, BIGINT, DECIMAL, DOUBLE ou DATETIME, une erreur est renvoyée.

  • Si aucun paramètre d'entrée n'est fourni ou si un paramètre d'entrée est NULL, la valeur NULL est renvoyée.

• Exemples

  • Exemple 1 : Concaténer les chaînes name et hanmeimei en utilisant :. Exemple d'instruction :

    -- Returns name:hanmeimei.
    select concat_ws(':','name','hanmeimei');

    -

  • Exemple 2 : Un paramètre d'entrée est NULL. Exemple d'instruction :

    -- Returns NULL.
    select concat_ws(':','avg',null,'34');

  • Exemple 3 : Concaténer les éléments du tableau array('name', 'hanmeimei') en utilisant :. Exemple d'instruction :

    -- Returns name:hanmeimei.
    select concat_ws(':',array('name', 'hanmeimei'));

DECODE

• Syntaxe

  STRING DECODE(BINARY <str>, STRING <charset>)

• Description

  Décode str en utilisant le format spécifié par charset.

• Paramètres

  Paramètre	Obligatoire	Description
  str	Oui	Type BINARY. La chaîne à décoder.
  charset	Oui	Type STRING. Format d'encodage. Valeurs valides : UTF-8, UTF-16, UTF-16LE, UTF-16BE, ISO-8859-1, US-ASCII. Remarque Les formats d'encodage ISO-8859-1 et US-ASCII ne prennent actuellement en charge que les caractères anglais, et non les caractères chinois.

• Valeur renvoyée

  Renvoie une valeur STRING. Si str ou charset est NULL, la valeur NULL est renvoyée.

• Exemples

  • Exemple 1 : Encoder et décoder la chaîne English Sample selon le format UTF-8. Exemple d'instruction :

    -- Encode and decode the string.SELECT DECODE(ENCODE("English Sample","UTF-8"), "UTF-8");

    Résultat :

    +-----+| _c0 |+-----+| English Sample |+-----+

  • Exemple 2 : Définir l'un des paramètres d'entrée sur NULL. Exemple d'instruction :

    SELECT DECODE(ENCODE("English Sample","UTF-8"), NULL);

    Résultat :

    +-----+| _c0 |+-----+| NULL |+-----+

ENCODE

• Syntaxe

  binary encode(string <str>, string <charset>)

• Description

  Encode str en utilisant le format spécifié par charset.

• Paramètres

  • str : obligatoire. Type STRING. La chaîne à réencoder.

  • charset : obligatoire. Type STRING. Format d'encodage. Valeurs valides : UTF-8, UTF-16, UTF-16LE, UTF-16BE, ISO-8859-1, US-ASCII.

• Valeur renvoyée

  Renvoie un type BINARY. Si str ou charset est NULL, la valeur NULL est renvoyée.

• Exemples

  • Exemple 1 : Encoder la chaîne abc au format UTF-8. Exemple d'instruction :

    -- Returns abc.
    select encode("abc", "UTF-8");

  • Exemple 2 : Encoder la chaîne abc au format UTF-16BE. Exemple d'instruction :

    -- Returns =00a=00b=00c.
    select encode("abc", "UTF-16BE");

  • Exemple 3 : Un paramètre d'entrée est NULL. Exemple d'instruction :

    -- Returns NULL.
    select encode("abc", null);

FIND_IN_SET

• Syntaxe

  BIGINT FIND_IN_SET(STRING <str1>, STRING <str2>[, STRING <delimiter>])

• Description

  Recherche la position de la chaîne str1 dans la chaîne str2 séparée par delimiter, en comptant à partir de 1.

• Paramètres

  Paramètre	Obligatoire	Description
  str1	Oui	Type STRING. La chaîne à rechercher.
  str2	Oui	Type STRING. La chaîne séparée par delimiter.
  delimiter	Non	Constante STRING. La valeur par défaut est la virgule (,). Le délimiteur peut être un caractère unique ou une chaîne.

• Valeur renvoyée

  Renvoie un type BIGINT. La valeur renvoyée suit les règles suivantes :

  • Si str2 ne contient pas str1 ou si str1 contient delimiter, la valeur 0 est renvoyée.

  • Si str1 ou str2 est NULL, la valeur NULL est renvoyée.

• Exemples

  • Exemple 1 : Trouver la position de la chaîne ab dans la chaîne abc,hello,ab,c, qui est séparée par des virgules (,). Exemple d'instruction :

    SELECT FIND_IN_SET('ab', 'abc,hello,ab,c') AS pos;

    Résultat :

    +------------+
    | pos        |
    +------------+
    | 3          |
    +------------+

  • Exemple 2 : Trouver la position de la chaîne hi dans la chaîne abc,hello,ab,c séparée par des virgules (,). Exemple d'instruction :

    SELECT FIND_IN_SET('hi', 'abc,hello,ab,c') AS pos;

    Résultat :

    +------------+
    | pos        |
    +------------+
    | 0          |
    +------------+

  • Exemple 3 : Trouver la position de la chaîne ab dans la chaîne abc_hello_ab_c délimitée par des traits de soulignement (_). Exemple d'instruction :

    SELECT FIND_IN_SET('ab', 'abc_hello_ab_c', '_') AS pos;

    Résultat :

    +------------+
    | pos        |
    +------------+
    | 3          |
    +------------+

  • Exemple 4 : Le paramètre d'entrée str1 ou str2 est NULL. Exemple d'instruction :

    SELECT FIND_IN_SET(null, 'abc,hello,ab,c') AS pos;

    Résultat :

    +------------+
    | pos        |
    +------------+
    | NULL       |
    +------------+

FORMAT_NUMBER

• Syntaxe

  STRING FORMAT_NUMBER(DOUBLE|BIGINT|INT|SMALLINT|TINYINT|FLOAT|DECIMAL|STRING <expr1>, INT <expr2>)

• Description

  Convertit expr1 en une chaîne formatée selon expr2.

• Paramètres

• expr1 : obligatoire. Valeur de type FLOAT, DOUBLE ou DECIMAL. Ce paramètre spécifie l'expression à formater.

• expr2 : obligatoire. Valeur de type INT. Valeurs valides : de 0 à 340. Ce paramètre définit le nombre de décimales à conserver. Il peut également s'exprimer dans un format similaire à #,###,###.##. Le nombre de décimales retournées varie en fonction de la valeur de ce paramètre.

• Valeur de retour

  Une valeur de type STRING est retournée. La valeur de retour obéit aux règles suivantes :

  • Si la valeur de expr2 est supérieure à 0 et inférieure ou égale à 340, la valeur retournée est arrondie au nombre de décimales spécifié.

  • Lorsque la valeur de expr2 est égale à 0, la valeur de retour ne contient que la partie entière, sans point décimal ni partie décimale.

  • Une erreur est retournée si la valeur de expr2 est inférieure à 0 ou supérieure à 340.

  • La fonction retourne null si expr1 ou expr2 est vide ou défini sur null.

• Exemples

  • Exemple 1 : Formater un nombre selon les spécifications. Exemples d'instructions :

    -- Returns 5.230.
    SELECT FORMAT_NUMBER(5.230134523424545456,3);
    -- Returns 12,332.123.
    SELECT FORMAT_NUMBER(12332.123456, '#,###,###,###.###');

  • Exemple 2 : Un paramètre d'entrée est vide ou NULL. Exemples d'instructions :

    -- Returns NULL.
    SELECT FORMAT_NUMBER('',3);
    -- Returns NULL.
    SELECT FORMAT_NUMBER(null,3);

FROM_CHARSET

• Syntaxe

  STRING FROM_CHARSET(binary <source>, string <source_charset>, [string <mode>])

• Description

  FROM_CHARSET convertit des données binaires encodées hors UTF-8 en une chaîne UTF-8 pour permettre des calculs ultérieurs.

• Paramètres

  • source : obligatoire. Valeur de type BINARY. Ce paramètre spécifie les données binaires à convertir.

  • source_charset : obligatoire. Valeur de type STRING. Ce paramètre indique le format d'encodage d'origine des données binaires spécifiées par source. Valeurs valides : UTF-8, UTF-16, UTF-16LE, UTF-16BE, ISO-8859-1, US-ASCII, GB2312, GBK et GB18030.

  • mode : facultatif. Valeur de type STRING. Ce paramètre définit le mode de traitement lorsqu'un caractère ne peut pas être converti lors de la transformation des données binaires source en chaîne avec l'encodage spécifié par la fonction FROM_CHARSET. Valeurs valides :

    • NONE : signale une erreur. Aucun traitement n'est effectué. Il s'agit de la valeur par défaut.

    • TRANSLIT : remplace le caractère problématique par un caractère similaire dans le format d'encodage cible.

    • IGNORE : ignore l'erreur et poursuit l'exécution de la commande.

• Valeur de retour

  Retourne une valeur de type STRING encodée en UTF-8. Lorsque les paramètres sont NULL ou des chaînes vides, la valeur de retour suit ces règles :

  • Si l'un des paramètres d'entrée est NULL, la fonction retourne NULL.

  • Une erreur est retournée si l'un des paramètres d'entrée est une chaîne vide.

• Exemples

  • Exemple 1 : Convertir des données binaires encodées en UTF-8 en une chaîne encodée en UTF-8.

    SELECT FROM_CHARSET(unhex('e58aa0e6b2b9e9949fe696a4e68bb70a'),'UTF-8', 'TRANSLIT');

  • Exemple 2 : Convertir des données binaires encodées en GBK en une chaîne encodée en UTF-8.

    SELECT FROM_CHARSET(unhex('b9feb9febac3a4ce'), 'GBK');

  • Exemple 3 : Si un paramètre d'entrée est null, la fonction retourne null.

    SELECT FROM_CHARSET(unhex('b9feb9febac3a4ce'), null);

FROM_JSON

• Syntaxe

  from_json(<jsonStr>, <schema>)

• Description

  Retourne des données de type ARRAY, MAP ou STRUCT en fonction de la chaîne JSON jsonStr et du format de sortie schema.

• Paramètres

  • jsonStr : obligatoire. Chaîne JSON fournie en entrée.

  • schema : obligatoire. Schéma de la chaîne JSON. La valeur de ce paramètre doit respecter le même format que celui utilisé dans une instruction de création de table, par exemple array<bigint>, map<string, array<string>> ou struct<a:int, b:double, .

    Remarque

    Les clés d'une structure (struct) sont sensibles à la casse. Vous pouvez également définir une struct au format a BIGINT, b DOUBLE, ce qui équivaut à STRUCT<a:BIGINT, b:DOUBLE>.

    Le tableau suivant décrit les correspondances entre les types de données JSON et les types de données MaxCompute.

    Type de données JSON	Type de données MaxCompute
    OBJECT	STRUCT, MAP et STRING
    ARRAY	ARRAY et STRING
    NUMBER	TINYINT, SMALLINT, INT, BIGINT, FLOAT, DOUBLE, DECIMAL et STRING
    BOOLEAN	BOOLEAN et STRING
    STRING	STRING, CHAR, VARCHAR, BINARY, DATE et DATETIME
    NULL	Tous les types

    Remarque

    Les chaînes JSON de types OBJECT et ARRAY sont analysées autant que possible. Si le type de données JSON ne correspond à aucun type MaxCompute, la chaîne JSON est ignorée. Pour faciliter l'utilisation, tous les types de données JSON peuvent être convertis en type STRING pris en charge par MaxCompute. Lors de la conversion d'une chaîne JSON de type NUMBER vers une valeur de type FLOAT, DOUBLE ou DECIMAL, la précision de la valeur n'est pas garantie. Nous vous recommandons de convertir d'abord la chaîne JSON en type STRING, puis de transformer la valeur obtenue en type FLOAT, DOUBLE ou DECIMAL.

• Valeur de retour

  Une valeur de type ARRAY, MAP ou STRUCT est retournée.

• Exemples

  • Exemple 1 : Convertir une chaîne JSON spécifique en une valeur d'un type de données donné. Exemple d'instruction :

    -- The return value is {"a":1,"b":0.8}. 
    select from_json('{"a":1, "b":0.8}', 'a int, b double');
    -- The return value is {"time":"26/08/2015"}. 
    select from_json('{"time":"26/08/2015"}', 'time string');
    -- The return value is {"a":1,"b":0.8}. 
    select from_json('{"a":1, "b":0.8}', 'a int, b double, c string');
    -- The return value is [1,2,3]. 
    select from_json('[1, 2, 3, "a"]', 'array<bigint>');
    -- The return value is {"d":"v","a":"1","b":"[1,2,3]","c":"{}"}. 
    select from_json('{"a":1,"b":[1,2,3],"c":{},"d":"v"}', 'map<string, string>');

  • Exemple 2 : Utiliser les fonctions map_keys et from_json pour obtenir toutes les clés d'une chaîne JSON. La fonction JSON_KEYS permet d'obtenir le même résultat. Exemple d'instruction :

    -- The return value is ["a","b"]. 
    select map_keys(from_json('{"a":1,"b":2}','map<string,string>'));

GET_JSON_OBJECT

INITCAP

• Syntaxe

  string initcap(<str>)

• Description

  Convertit str en casse de titre, où les mots sont séparés par des espaces, avec la première lettre de chaque mot en majuscule et les autres en minuscules.

• Paramètres

  str : obligatoire. Type STRING. Chaîne d'entrée.

• Valeur de retour

  Retourne une chaîne avec la première lettre de chaque mot en majuscule et le reste en minuscules.

• Exemple

  -- Returns Odps Sql.
  SELECT initcap("oDps sql");

INSTR

• Syntaxe

  bigint instr(string <str1>, string <str2>[, bigint <start_position>[, bigint <nth_appearance>]])

• Description

  Recherche la position de la sous-chaîne str2 dans la chaîne str1.

• Paramètres

  • str1 : obligatoire. Type STRING. Chaîne cible dans laquelle effectuer la recherche. Si l'entrée est de type BIGINT, DOUBLE, DECIMAL ou DATETIME, elle est implicitement convertie en STRING. Les autres types entraînent une erreur.

  • str2 : obligatoire. Type STRING. Sous-chaîne à rechercher. Si l'entrée est de type BIGINT, DOUBLE, DECIMAL ou DATETIME, elle est implicitement convertie en STRING. Les autres types entraînent une erreur.

  • start_position : facultatif. Valeur de type BIGINT. Une erreur est retournée pour les autres types de données. Ce paramètre indique la position du caractère dans str1 à partir duquel la recherche commence. La position de départ par défaut est le premier caractère, soit la position 1. Si start_position est une valeur négative, la recherche commence à rebours depuis la fin de la chaîne, le dernier caractère étant à la position -1, l'avant-dernier à -2, et ainsi de suite.

  • nth_appearance : facultatif. Valeur de type BIGINT qui doit être supérieure à 0. Ce paramètre précise la position de la nth_appearance-ième occurrence de str2 dans str1. Si nth_appearance est d'un autre type de données ou est inférieur ou égal à 0, une erreur est retournée.

• Valeur de retour

  Retourne une valeur de type BIGINT. La valeur de retour obéit aux règles suivantes :

  • Si str1 ne contient pas str2, la fonction retourne 0.

  • Lorsque str2 est vide, la correspondance est toujours trouvée. Par exemple, select instr('abc',''); retourne 1.

  • La fonction retourne NULL si str1, str2, start_position ou nth_appearance est NULL.

• Exemples

  • Exemple 1 : Trouver la position du caractère e dans la chaîne Tech on the net. Exemple d'instruction :

    -- Returns 2.
    select instr('Tech on the net', 'e');

  • Exemple 2 : Trouver la position de la sous-chaîne on dans la chaîne Tech on the net. Exemple d'instruction :

    -- Returns 6.
    select instr('Tech on the net', 'on');

  • Exemple 3 : Trouver la position de la deuxième occurrence du caractère e dans la chaîne Tech on the net, en commençant la recherche au troisième caractère. Exemple d'instruction :

    -- Returns 14.
    select instr('Tech on the net', 'e', 3, 2);

  • Exemple 4 : Un paramètre d'entrée est NULL. Exemple d'instruction :

    -- Returns NULL.
    select instr('Tech on the net', null);

IS_ENCODING

• Syntaxe

  boolean is_encoding(string <str>, string <from_encoding>, string <to_encoding>)

• Description

  Détermine si la chaîne d'entrée str peut être convertie du jeu de caractères from_encoding vers to_encoding. Cette fonction sert également à détecter les textes illisibles ; dans ce cas, définissez généralement from_encoding sur UTF-8 et to_encoding sur GBK.

• Paramètres

  • str : obligatoire. Type STRING. Les chaînes vides sont considérées comme valides pour n'importe quel jeu de caractères.

  • from_encoding, to_encoding : obligatoires. Type STRING. Jeux de caractères source et cible.

• Valeur de retour

  Renvoie une valeur de type BOOLEAN. La valeur retournée obéit aux règles suivantes :

  • Si la conversion de str réussit, la fonction retourne True ; sinon, elle retourne False.

  • Si str, from_encoding ou to_encoding est NULL, la fonction retourne NULL.

JSON_TUPLE

• Syntaxe

  string json_tuple(string <json>, string <key1>, string <key2>,...)

• Description

  Extrait des chaînes d'une chaîne JSON standard en fonction d'un ensemble de clés d'entrée, telles que (key1,key2,...).

• Paramètres

  • json : obligatoire. Valeur de type STRING. Ce paramètre spécifie une chaîne JSON standard.

  • key : obligatoire. Valeur de type STRING. Ce paramètre décrit le path d'un objet JSON dans la chaîne JSON. La valeur ne doit pas commencer par un signe dollar ($). Vous pouvez saisir plusieurs clés à la fois. MaxCompute analyse les objets JSON en utilisant . ou ['']. Si une clé d'un objet JSON contient un point (.), vous pouvez utiliser [''].

• Valeur de retour

  Une valeur de type STRING est retournée.

  Remarque

  • Si json est vide ou invalide, la valeur null est retournée.

  • Si key est vide, invalide ou absente de la chaîne JSON, la valeur null est retournée.

  • Si json est valide et que key existe, la chaîne correspondante est retournée.

  • Cette fonction peut analyser des données JSON contenant des caractères chinois.

  • Cette fonction prend en charge l'analyse de données JSON imbriquées.

  • Cette fonction peut analyser des données JSON contenant des tableaux imbriqués.

  • L'action d'analyse équivaut à l'exécution de GET_JSON_OBJECT avec set odps.sql.udf.getjsonobj.new=true;. Pour obtenir plusieurs objets d'une chaîne JSON, vous devez appeler la fonction GET_JSON_OBJECT plusieurs fois, ce qui entraîne une analyse répétée de la chaîne. La fonction JSON_TUPLE permet de saisir plusieurs clés simultanément et n'analyse la chaîne JSON qu'une seule fois. JSON_TUPLE est donc plus efficace que GET_JSON_OBJECT.

  • JSON_TUPLE est une fonction table-valued définie par l'utilisateur (UDTF). Pour sélectionner certaines colonnes d'une table, utilisez JSON_TUPLE conjointement avec la clause LATERAL VIEW.

KEYVALUE

• Syntaxe

  keyvalue(string <str>,[string <split1>,string <split2>,] string <key>)
  keyvalue(string <str>,string <key>) 

• Description

  Divise la chaîne str en paires clé-valeur à l'aide de split1, sépare les paires au moyen de split2, puis retourne la valeur correspondant à key.

• Paramètres

  • str : obligatoire. Type STRING. Chaîne à diviser.

  • split1, split2 : facultatifs. Type STRING. Chaînes de délimiteurs pour le découpage. Par défaut, split1 correspond à ";" et split2 à ":". Si une sous-chaîne découpée par split1 contient plusieurs occurrences de split2, le résultat est indéfini.

  • key : obligatoire. Type STRING. Après le découpage par split1 et split2, retourne la valeur associée à key.

• Valeur de retour

  Retourne une valeur de type STRING. La valeur retournée obéit aux règles suivantes :

  • Si split1 ou split2 est NULL, la fonction retourne NULL.

  • Si str ou key est NULL, ou si aucune key correspondante n'existe, la fonction retourne NULL.

  • Si plusieurs paires clé-valeur correspondent, la fonction retourne la valeur de la première key correspondante.

• Exemples

  • Exemple 1 : Diviser la chaîne 0:1/;1:2 en paires clé-valeur et retourner la valeur pour la clé 1. Exemple d'instruction :

    -- Returns 2.
    select keyvalue('0:1/;1:2', 1);

    Les paramètres split1 et split2 ne sont pas spécifiés. La valeur par défaut de split1 est un point-virgule (";") et celle de split2 est un deux-points (":").

    Après le découpage par split1, les paires clé-valeur sont 0:1/,1:2. Après le découpage par split2 :

    0 1/  
    1 2

    La valeur 2 est retournée pour la clé 1.

  • Exemple 2 : Diviser la chaîne “\;decreaseStore:1\;xcard:1\;isB2C:1\;tf:21910\;cart:1\;shipping:2\;pf:0\;market:shoes\;instPayAmount:0\;” en utilisant “\;” comme split1 et ":" comme split2, puis retourner la valeur pour la clé tf. Exemple d'instruction :

    -- Returns 21910.
    select keyvalue("\;decreaseStore:1\;xcard:1\;isB2C:1\;tf:21910\;cart:1\;shipping:2\;pf:0\;market:shoes\;instPayAmount:0\;","\;",":","tf");

    Le découpage de la chaîne "\;decreaseStore:1\;xcard:1\;isB2C:1\;tf:21910\;cart:1\;shipping:2\;pf:0\;market:shoes\;instPayAmount:0\;" à l'aide du délimiteur "\;" génère les paires clé-valeur suivantes.

    decreaseStore:1，xcard:1，isB2C:1，tf:21910，cart:1，shipping:2，pf:0，market:shoes，instPayAmount:0 

    Le résultat du découpage par ":" est le suivant.

    decreaseStore 1  
    xcard 1  
    isB2C 1  
    tf 21910  
    cart 1  
    shipping 2  
    pf 0  
    market shoes  
    instPayAmount 0

    La valeur 21910 est retournée pour la clé tf.

KEYVALUE_TUPLE

• Syntaxe

  KEYVALUE_TUPLE(str, split1, split2, key1, key2, ..., keyN)

• Description

  Divise la chaîne str en paires clé-valeur à l'aide de split1, sépare les paires au moyen de split2, puis retourne les valeurs correspondant à plusieurs key s.

• Paramètres

  • str : obligatoire. Type STRING. Chaîne à diviser.

  • split1, split2 : obligatoires. Type STRING. Chaînes de délimiteurs pour le découpage. Si une sous-chaîne découpée par split1 contient plusieurs occurrences de split2, le résultat est indéfini.

  • key : obligatoire. Type STRING. Après le découpage par split1 et split2, retourne la valeur associée à key.

• Valeur de retour

  Retourne une valeur de type STRING. La valeur retournée obéit aux règles suivantes :

  • Si split1 ou split2 est NULL, la fonction retourne NULL.

  • Si str ou key est NULL, ou si aucune key correspondante n'existe, la fonction retourne NULL.

• Exemple

  -- Create table
  create table mf_user (
  user_id string,
  user_info string
  );
  -- Insert data
  insert into mf_user values('1','age:18;genda:f;address:abc'),('2','age:20;genda:m;address:bcd');
  -- Query
  SELECT user_id,
  KEYVALUE(user_info,';',':','age') as age,
  KEYVALUE(user_info,';',':','genda') as genda,
  KEYVALUE(user_info,';',':','address') as address
  FROM mf_user;
  -- Equivalent to KEYVALUE query
  SELECT user_id,
  age,
  genda,
  address
  FROM mf_user LATERAL VIEW KEYVALUE_TUPLE(user_info,';', ':','age','genda','address') ui AS age,genda,address;

  Le résultat est le suivant.

  +------------+------------+------------+------------+
  | user_id    | age        | genda      | address    |
  +------------+------------+------------+------------+
  | 1          | 18         | f          | abc        |
  | 2          | 20         | m          | bcd        |
  +------------+------------+------------+------------+

LENGTH

• Syntaxe

  bigint length(string <str>)

• Description

  Calcule la longueur de la chaîne str.

• Paramètres

  str : obligatoire. Type STRING. Si l'entrée est de type BIGINT, DOUBLE, DECIMAL ou DATETIME, elle est implicitement convertie en STRING.

• Valeur de retour

  Retourne une valeur de type BIGINT. La valeur retournée obéit aux règles suivantes :

  • Si str n'est pas de type STRING, BIGINT, DOUBLE, DECIMAL ou DATETIME, une erreur est retournée.

  • Si str est NULL, la fonction retourne NULL.

  • Si str n'est pas encodée en UTF-8, la fonction retourne -1.

• Exemples

  • Exemple 1 : Calculer la longueur de la chaîne Tech on the net. Exemple d'instruction :

    -- Returns 15.
    select length('Tech on the net');

  • Exemple 2 : Le paramètre d'entrée est NULL. Exemple d'instruction :

    -- Returns NULL.
    select length(null);

LENGTHB

• Syntaxe

  bigint lengthb(string <str>)

• Description

  Calcule la longueur en octets de la chaîne str.

• Paramètres

  str : obligatoire. Type STRING. Si l'entrée est de type BIGINT, DOUBLE, DECIMAL ou DATETIME, elle est implicitement convertie en STRING.

• Valeur de retour

  Retourne une valeur de type BIGINT. La valeur retournée obéit aux règles suivantes :

  • Si str n'est pas de type STRING, BIGINT, DOUBLE, DECIMAL ou DATETIME, une erreur est retournée.

  • Si str est NULL, la fonction retourne NULL.

• Exemples

  • Exemple 1 : Calculer la longueur en octets de la chaîne Tech on the net. Exemple d'instruction :

    -- Returns 15.
    select lengthb('Tech on the net');

  • Exemple 2 : Le paramètre d'entrée est NULL. Exemple d'instruction :

    -- Returns NULL.
    select lengthb(null);

LOCATE

• Syntaxe

  bigint locate(string <substr>, string <str>[, bigint <start_pos>]) 

• Description

  Recherche la position de la sous-chaîne substr dans str. Utilisez start_pos pour spécifier la position de départ (en commençant à 1).

• Paramètres

  • substr : obligatoire. Type STRING. Sous-chaîne à rechercher.

  • str : obligatoire. Type STRING. Chaîne dans laquelle effectuer la recherche.

  • start_pos : facultatif. Type BIGINT. Position de départ pour la recherche.

• Valeur de retour

  Retourne une valeur de type BIGINT. La valeur retournée obéit aux règles suivantes :

  • Si str ne contient pas substr, la fonction retourne 0.

  • Si str ou substr est NULL, la fonction retourne NULL.

  • Si start_pos est NULL, la fonction retourne 0.

• Exemples

  • Exemple 1 : Trouver la position de la chaîne ab dans la chaîne abchelloabc. Exemple d'instruction :

    -- Returns 1.
    select locate('ab', 'abchelloabc');

  • Exemple 2 : Trouver la position de la chaîne hi dans la chaîne abchelloabc. Exemple d'instruction :

    -- Returns 0.
    select locate('hi', 'abc,hello,ab,c');

  • Exemple 3 : start_pos est NULL. Exemple d'instruction :

    -- Returns 0.
    select locate('ab', 'abhelloabc', null);

LPAD

• Syntaxe

  string lpad(string <str1>, int <length>, string <str2>)

• Description

  Complète la chaîne str1 à gauche jusqu'à atteindre length caractères en utilisant la chaîne str2. Cette fonction est une extension introduite dans MaxCompute V2.0.

• Paramètres

  • str1 : obligatoire. Type STRING. Chaîne à compléter à gauche.

  • length : obligatoire. Type INT. Nombre de caractères pour le remplissage à gauche.

  • str2 : obligatoire. Chaîne de remplissage.

• Valeur de retour

  Retourne une valeur de type STRING. La valeur retournée obéit aux règles suivantes :

  • Si length est inférieur à la longueur de str1, la fonction retourne les length caractères les plus à gauche de str1.

  • Si length vaut 0, une chaîne vide est retournée.

  • En l'absence de paramètres d'entrée ou si l'un d'eux est NULL, la fonction retourne NULL.

• Exemples

  • Exemple 1 : Compléter la chaîne abcdefgh à gauche avec la chaîne 12 pour atteindre 10 caractères. Voici un exemple de commande.

    -- Returns 12abcdefgh.
    select lpad('abcdefgh', 10, '12');

  • Exemple 2 : Compléter la chaîne abcdefgh à gauche avec la chaîne 12 pour atteindre une longueur de 5 caractères. Voici un exemple de commande.

    -- Returns abcde.
    select lpad('abcdefgh', 5, '12');

  • Exemple 3 : length vaut 0. Exemple d'instruction :

    -- Returns empty string.
    select lpad('abcdefgh' ,0, '12'); 

  • Exemple 4 : L'un des paramètres d'entrée est NULL. Exemple d'instruction :

    -- Returns NULL.
    select lpad(null ,0, '12');

LTRIM

• Syntaxe

  string ltrim(string <str>[, <trimChars>])
  string trim(leading [<trimChars>] from <str>)

• Description

  Supprime des caractères à l'extrémité gauche de str :

  • Si trimChars n'est pas spécifié, les espaces de début sont supprimés par défaut.

  • Si vous spécifiez trimChars, la fonction considère les caractères de trimChars comme un ensemble et supprime, à l'extrémité gauche de str, la sous-chaîne la plus longue possible composée exclusivement de caractères appartenant à l'ensemble trimChars.

• Paramètres

  • str : obligatoire. Type STRING. Chaîne à nettoyer. Si l'entrée est de type BIGINT, DECIMAL, DOUBLE ou DATETIME, elle est implicitement convertie en STRING.

  • trimChars : facultatif. Type STRING. Caractères à supprimer.

• Valeur de retour

  Retourne une valeur de type STRING. La valeur retournée obéit aux règles suivantes :

  • Si str n'est pas de type STRING, BIGINT, DOUBLE, DECIMAL ou DATETIME, une erreur est retournée.

  • Si str ou trimChars est NULL, la fonction retourne NULL.

• Exemples

  • Exemple 1 : Supprimer les espaces de début de la chaîne yxTxyomxx . Exemples d'instructions :

    -- Returns yxTxyomxx.
    select ltrim(' yxTxyomxx ');
    -- Equivalent to:
    select trim(leading from ' yxTxyomxx ');

  • Exemple 2 : Supprimer tous les caractères de début de la chaîne yxTxyomxx présents dans l'ensemble xy.

    -- Returns Txyomxx. Any leading x or y is removed.
    select ltrim('yxTxyomxx', 'xy');
    -- Equivalent to:
    select trim(leading 'xy' from 'yxTxyomxx');

  • Exemple 3 : Le paramètre d'entrée est NULL. Exemples d'instructions :

    -- Returns NULL.
    select ltrim(null);
    select ltrim('yxTxyomxx', null);

MASK_HASH

• Syntaxe

  mask_hash(<expr>)

• Description

  Retourne une valeur de hachage calculée à partir de l'expression de chaîne expr. Des valeurs de hachage identiques indiquent des valeurs d'expression identiques.

• Paramètres

  expr : obligatoire. Expression de chaîne pour le calcul du hachage. Prend en charge les types STRING, CHAR, VARCHAR et BINARY.

• Valeur de retour

  Retourne une valeur de hachage de 64 octets. Pour les expressions non textuelles, retourne null (compatible Hive).

• Exemple

  -- Returns hash for abc
  select mask_hash("abc");
  -- Returns
  +------------+
  | _c0        |
  +------------+
  | ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad |
  +------------+
  
  -- Returns NULL for non-string input
  select mask_hash(100);
  -- Returns
  +------------+
  | _c0        |
  +------------+
  | NULL       |
  +------------+

MD5

• Syntaxe

  string md5(string <str>)

• Description

  Calcule le hachage MD5 de la chaîne str.

• Paramètres

  str : obligatoire. Type STRING. Si l'entrée est de type BIGINT, DOUBLE, DECIMAL ou DATETIME, elle est implicitement convertie en STRING.

• Valeur de retour

  Retourne une valeur de type STRING. La valeur retournée obéit aux règles suivantes :

  • Si str n'est pas de type STRING, BIGINT, DOUBLE, DECIMAL ou DATETIME, une erreur est retournée.

  • Si str est NULL, la fonction retourne NULL.

• Exemples

  • Exemple 1 : Calculer le hachage MD5 de la chaîne Tech on the net. Exemple d'instruction :

    -- Returns ddc4c4796880633333d77a60fcda9af6.
    select md5('Tech on the net');

  • Exemple 2 : Le paramètre d'entrée est NULL. Exemple d'instruction :

    -- Returns NULL.
    select md5(null);

PARSE_URL

• Syntaxe

  string parse_url(string <url>, string <part>[, string <key>])

• Description

  Analyse url et extrait les informations spécifiées par part.

• Paramètres

  • url : obligatoire. Type STRING. Lien URL. Les URL invalides entraînent une erreur.

  • part : obligatoire. Type STRING. Valeurs valides : HOST, PATH, QUERY, REF, PROTOCOL, AUTHORITY, FILE, USERINFO (insensible à la casse).

  • key : facultatif. Lorsque part est QUERY, retourne la valeur associée à key.

• Description de la valeur de retour

  Retourne une valeur de type STRING. La valeur retournée obéit aux règles suivantes :

  • Si url, part ou key est NULL, la fonction retourne NULL.

  • Si part est invalide, une erreur est retournée.

• Exemple

  -- Returns example.com.
  select parse_url('file://username:password@example.com:8042/over/there/index.dtb?type=animal&name=narwhal#nose', 'HOST');
  -- Returns /over/there/index.dtb.
  select parse_url('file://username:password@example.com:8042/over/there/index.dtb?type=animal&name=narwhal#nose', 'PATH');
  -- Returns animal.
  select parse_url('file://username:password@example.com:8042/over/there/index.dtb?type=animal&name=narwhal#nose', 'QUERY', 'type');
  -- Returns nose.
  select parse_url('file://username:password@example.com:8042/over/there/index.dtb?type=animal&name=narwhal#nose', 'REF');
  -- Returns file.
  select parse_url('file://username:password@example.com:8042/over/there/index.dtb?type=animal&name=narwhal#nose', 'PROTOCOL');
  -- Returns username:password@example.com:8042.
  select parse_url('file://username:password@example.com:8042/over/there/index.dtb?type=animal&name=narwhal#nose', 'AUTHORITY');
  -- Returns username:password.
  select parse_url('file://username:password@example.com:8042/over/there/index.dtb?type=animal&name=narwhal#nose', 'USERINFO');

PARSE_URL_TUPLE

• Syntaxe

  string parse_url_tuple(string <url>, string <key1>, string <key2>,...)

• Description

  Analyse url et extrait les chaînes spécifiées par les clés d'entrée key1, key2, etc. Semblable à PARSE_URL, mais permet d'extraire plusieurs clés simultanément avec de meilleures performances.

• Paramètres

  • url : obligatoire. Type STRING. Lien URL. Les URL invalides entraînent une erreur.

  • key1, key2 : obligatoires. Type STRING. Clés à extraire. Valeurs valides :

    • HOST : Adresse de l'hôte (domaine ou IP).

    • PATH : Chemin d'accès à la ressource réseau sur le serveur.

    • QUERY : Chaîne de requête (contenu à interroger).

    • REF : Indique l'identifiant de fragment d'une URL, c'est-à-dire le contenu situé après le symbole #.

    • PROTOCOL : Type de protocole.

    • AUTHORITY : Domaine/IP du serveur, port et informations d'authentification utilisateur (nom d'utilisateur, mot de passe).

    • FILE : Chemin d'accès et contenu de la requête (PATH + QUERY).

    • USERINFO : Informations d'authentification de l'utilisateur.

    • QUERY:<KEY> : Valeur pour la clé spécifiée dans la chaîne de requête.

    Insensible à la casse. Les valeurs invalides entraînent une erreur.

• Description de la valeur de retour

  Retourne une valeur de type STRING. Si url ou key est NULL, une erreur est retournée.

• Exemple

  Extraire les chaînes pour chaque clé à partir de file://username:password@example.com:8042/over/there/index.dtb?type=animal&name=narwhal#nose. Exemple d'instruction :

  select parse_url_tuple('file://username:password@example.com:8042/over/there/index.dtb?type=animal&name=narwhal#nose', 'HOST', 'PATH', 'QUERY', 'REF', 'PROTOCOL', 'AUTHORITY', 'FILE', 'USERINFO', 'QUERY:type', 'QUERY:name') as (item0, item1, item2, item3, item4, item5, item6, item7, item8, item9);

  Résultat retourné :

  +------------+------------+------------+------------+------------+------------+------------+------------+------------+------------+
  | item0      | item1      | item2      | item3      | item4      | item5      | item6      | item7      | item8      | item9      |
  +------------+------------+------------+------------+------------+------------+------------+------------+------------+------------+
  | example.com | /over/there/index.dtb | type=animal&name=narwhal | nose       | file       | username:password@example.com:8042 | /over/there/index.dtb?type=animal&name=narwhal | username:password | animal     | narwhal    |
  +------------+------------+------------+------------+------------+------------+------------+------------+------------+------------+

REGEXP_COUNT

• Syntaxe

  bigint regexp_count(string <source>, string <pattern>[, bigint <start_position>])

• Description

  Compte les sous-chaînes dans source qui correspondent au pattern spécifié, en commençant à partir de start_position.

• Paramètres

  • source : obligatoire. Type STRING. Chaîne dans laquelle effectuer la recherche. Les autres types provoquent une erreur.

  • pattern : obligatoire. Constante STRING ou expression régulière. Modèle à faire correspondre. Pour plus d'informations sur les expressions régulières, consultez Correspondance de chaînes RLIKE. Un pattern vide ou invalide renvoie une erreur.

  • start_position : facultatif. Constante de type BIGINT. La valeur de ce paramètre doit être supérieure à 0. Si la valeur est d'un autre type de données ou inférieure ou égale à 0, une erreur est renvoyée. Par défaut, si ce paramètre n'est pas spécifié, sa valeur est 1. Cela indique que la recherche commence au premier caractère de la chaîne source.

• Valeur de retour

  Renvoie une valeur de type BIGINT. La valeur de retour suit les règles suivantes :

  • Si aucune correspondance n'est trouvée, la fonction renvoie 0.

  • Si source, pattern ou start_position est NULL, la fonction renvoie NULL.

• Exemples

  • Exemple 1 : Compter les sous-chaînes correspondantes dans abababc à partir d'une position spécifiée. Exemples d'instructions :

    -- Returns 1.
    select regexp_count('abababc', 'a.c');
    -- Returns 2.
    select regexp_count('abababc', '[[:alpha:]]{2}', 3);

  • Exemple 2 : L'un des paramètres d'entrée est NULL. Exemple d'instruction :

    -- Returns NULL.
    select regexp_count('abababc', null);

  • Exemple 3 : Compter les occurrences de : dans la chaîne JSON {"account_id":123456789,"account_name":"allen","location":"hangzhou","bill":100}. Exemple d'instruction :

    -- Returns 4.
    select regexp_count('{"account_id":123456789,"account_name":"allen","location":"hangzhou","bill":100}',':');

REGEXP_EXTRACT

• Syntaxe

  string regexp_extract(string <source>, string <pattern>[, bigint <groupid>])

  Remarque

  Dans les versions de types de données compatibles avec Hive, REGEXP_EXTRACT suit la spécification des expressions régulières Java. Dans les versions de types de données 1.0 et 2.0, elle suit la spécification MaxCompute.

• Description

  Divise la chaîne source en groupes à l'aide du pattern et renvoie la chaîne du groupe groupid.

• Paramètres

  • source : obligatoire. Type STRING. Chaîne à diviser.

  • pattern : obligatoire. Constante STRING ou expression régulière. Modèle à faire correspondre. Pour plus d'informations sur les expressions régulières, consultez Correspondance de chaînes RLIKE.

  • groupid : facultatif. Constante BIGINT, doit être ≥ 0.

  Remarque

  Les données sont stockées au format UTF-8. Les caractères chinois peuvent être représentés en hexadécimal dans la plage [\\x{4e00},\\x{9fa5}].

• Valeur de retour

  Renvoie une valeur de type STRING. La valeur de retour suit les règles suivantes :

  • Si le pattern est une chaîne vide ou si aucun groupe n'est spécifié dans le pattern, une erreur est renvoyée.

  • Si groupid n'est pas de type BIGINT ou est inférieur à 0, une erreur est renvoyée. Par défaut, si ce paramètre n'est pas spécifié, sa valeur est 1, ce qui signifie que la sous-chaîne du premier groupe est renvoyée. Si groupid est défini sur 0, la sous-chaîne correspondant à l'ensemble du pattern est renvoyée.

  • Si source, pattern ou groupid est NULL, la fonction renvoie NULL.

REGEXP_EXTRACT_ALL

• Syntaxe

  array<T> regexp_extract_all(string <source>, string <pattern>[,bigint <group_id>])

• Description

  Recherche toutes les sous-chaînes correspondant à un modèle d'expression régulière dans une chaîne et les renvoie sous forme de tableau.

• Paramètres

  • source : obligatoire. Type STRING. Chaîne à analyser.

  • pattern : obligatoire. Type STRING. Modèle à faire correspondre. Il peut s'agir d'une constante STRING ou d'une expression régulière. Pour plus d'informations sur les expressions régulières, consultez Correspondance de chaînes RLIKE.

  • group_id : facultatif. Valeur BIGINT. Ce paramètre spécifie l'ID du groupe utilisé pour faire correspondre le modèle. Sa valeur doit être supérieure ou égale à 0. Par défaut, si ce paramètre n'est pas spécifié, le groupe dont le group_id est 1 est utilisé pour la correspondance. Si vous définissez ce paramètre sur 0, le pattern est considéré dans son ensemble.

• Valeur de retour

  Une valeur ARRAY est renvoyée. Si vous spécifiez group_id, un tableau contenant tous les résultats correspondants pour le group_id spécifié est renvoyé. Si vous ne spécifiez pas group_id, un tableau contenant tous les résultats correspondants pour le group_id 1 est renvoyé.

• Exemple

  • Si vous ne spécifiez pas group_id, le comportement par défaut consiste à renvoyer les résultats correspondant au premier group_id.

    SELECT regexp_extract_all('100-200, 300-400', '(\\d+)-(\\d+)');

    Résultat :

    +------------+
    | _c0        |
    +------------+
    | [100,300] |
    +------------+

  • Si vous définissez la valeur de group_id sur 2, le résultat correspondant au deuxième group_id est renvoyé.

    SELECT regexp_extract_all('100-200, 300-400', '(\\d+)-(\\d+)',2);

    Le résultat est le suivant :

    +------------+
    | _c0        |
    +------------+
    | [200,400] |
    +------------+

REGEXP_INSTR

• Syntaxe

  bigint regexp_instr(string <source>, string <pattern>[,bigint <start_position>[, bigint <occurrence>[, bigint <return_option>]]])

• Description

  Renvoie la position de début ou de fin de l'occurrence spécifiée d'une sous-chaîne correspondant au pattern dans source, en commençant à partir de start_position.

• Paramètres

  • source : obligatoire. Chaîne source. Le type de données doit être STRING.

  • pattern : obligatoire. Modèle à faire correspondre. La valeur peut être une constante STRING ou une expression régulière. Pour plus d'informations sur les expressions régulières, consultez Correspondance de chaînes RLIKE. Un pattern vide renvoie une erreur.

  • start_position : facultatif. Position à partir de laquelle la recherche commence. La valeur doit être une constante BIGINT. La valeur par défaut est 1.

  • occurrence : facultatif. Occurrence de la correspondance à rechercher. La valeur doit être une constante BIGINT. La valeur par défaut est 1, ce qui correspond à la première occurrence.

  • return_option : facultatif. Position à renvoyer. La valeur doit être une constante BIGINT. Valeurs valides : 0 pour la position de début et 1 pour la position de fin. La valeur par défaut est 0. Une valeur non valide entraîne le renvoi d'une erreur.

• Valeur de retour

  La valeur de retour est de type BIGINT. Le paramètre return_option détermine s'il faut renvoyer la position de début ou de fin de la sous-chaîne correspondante dans source. La valeur de retour est déterminée par les règles suivantes :

  • Si le pattern est vide, une erreur est renvoyée.

  • Si la valeur de start_position ou de occurrence n'est pas une constante BIGINT ou est inférieure ou égale à 0, une erreur est renvoyée.

  • Si la valeur de source, pattern, start_position, occurrence ou return_option est NULL, la fonction renvoie NULL.

• Exemples

  • Exemple 1 : Renvoyer la position de début de la 2 e occurrence d'une sous-chaîne correspondant à o[[:alpha:]]{1} dans la chaîne i love www.taobao.com, en commençant à la position 3. Exemple d'instruction :

    -- Returns 14.
    select regexp_instr('i love www.taobao.com', 'o[[:alpha:]]{1}', 3, 2);

  • Exemple 2 : Renvoyer la position de fin de la deuxième occurrence d'une sous-chaîne correspondant à o[[:alpha:]]{1} dans la chaîne i love www.taobao.com. La recherche commence au troisième caractère. Exemple d'instruction :

    -- Returns 16.
    select regexp_instr('i love www.taobao.com', 'o[[:alpha:]]{1}', 3, 2, 1);

  • Exemple 3 : Un paramètre d'entrée est NULL. Exemple d'instruction :

    -- Returns NULL.
    select regexp_instr('i love www.taobao.com', null, 3, 2);

REGEXP_REPLACE

• Syntaxe

  string regexp_replace(string <source>, string <pattern>, string <replace_string>[, bigint <occurrence>])

  Remarque

  Pour les types de données compatibles avec Hive, la fonction REGEXP_REPLACE suit la spécification des expressions régulières Java. Pour les types de données 1.0 et 2.0, elle suit la spécification MaxCompute.

• Description

  Remplace la sous-chaîne correspondant au pattern à la position spécifiée par occurrence dans la chaîne source par replace_string et renvoie le résultat.

• Paramètres

  • source : obligatoire. Valeur de type STRING. Il s'agit de la chaîne source à modifier.

  • pattern : obligatoire. Constante STRING ou expression régulière. Il s'agit du modèle à faire correspondre. Pour plus d'informations sur les règles des expressions régulières, consultez Correspondance de chaînes RLIKE. Si le pattern est vide, une erreur est renvoyée.

  • replace_string : obligatoire. Valeur de type STRING. Il s'agit de la chaîne qui remplace la sous-chaîne correspondant au pattern.

    Remarque

    • Si replace_string est une chaîne vide, la fonction supprime la sous-chaîne correspondant au pattern.

    • Le paramètre replace_string peut contenir des rétro-références au format \n pour insérer la sous-chaîne correspondant au nième groupe capturant dans le pattern. La valeur de n peut être un entier compris entre 1 et 9. \0 insère l'intégralité de la sous-chaîne correspondant au pattern. Vous devez échapper les barres obliques inverses, par exemple \\1, ou utiliser une chaîne brute, telle que R'(\1)'.

  • occurrence : facultatif. Constante de type BIGINT, qui doit être supérieure ou égale à 0. La valeur de ce paramètre indique que la chaîne correspondant au modèle spécifié à la nième occurrence définie par occurrence est remplacée par replace_string. Si ce paramètre est défini sur 0, toutes les sous-chaînes correspondant au modèle spécifié sont remplacées. S'il est d'un autre type de données ou inférieur à 0, une erreur est renvoyée. Valeur par défaut : 0.

• Valeur de retour

  Une valeur de type STRING est renvoyée. La valeur de retour est déterminée par les règles suivantes :

  • Si vous référencez un groupe inexistant, le résultat est indéfini.

  • Si replace_string est NULL et qu'une correspondance pour le pattern est trouvée, NULL est renvoyé.

  • Si replace_string est NULL et que le pattern ne correspond pas, la fonction renvoie la chaîne d'origine.

  • Si source, pattern ou occurrence est NULL, NULL est renvoyé.

• Exemples

  • Exemple 1 : Remplacer des sous-chaînes selon des règles spécifiées.

    -- Returns Abcd.
    select regexp_replace("abcd", "a", "A", 0);
    -- Returns bcd.
    select regexp_replace("abcd", "a", "", 0);
    -- Returns 19700101.
    select regexp_replace("1970-01-01", "-", "", 0);
    -- Returns abc.
    select regexp_replace("a1b2c3", "[0-9]", "", 0);
    -- Returns a1b2c.
    select regexp_replace("a1b2c3", "[0-9]", "", 3);

  • Exemple 2 : Remplacer toutes les correspondances du modèle ([[:digit:]]{3})\\.([[:digit:]]{3})\\.([[:digit:]]{4}) dans la chaîne 123.456.7890 par (\\1)\\2-\\3. Exemple d'instruction :

    -- Returns (123)456-7890.
    select regexp_replace('123.456.7890', '([[:digit:]]{3})\\.([[:digit:]]{3})\\.([[:digit:]]{4})',
    '(\\1)\\2-\\3', 0);

  • Exemple 3 : Remplacer les sous-chaînes correspondant à un modèle dans la chaîne abcd selon des règles spécifiées. Exemples d'instructions :

    -- Returns a b c d.
    select regexp_replace('abcd', '(.)', '\\1 ', 0);
    -- Returns a bcd.
    select regexp_replace('abcd', '(.)', '\\1 ', 1);
    -- Returns d.
    select regexp_replace("abcd", "(.*)(.)$", "\\2", 0);

  • Exemple 4 : La table url_set contient une colonne URL dont les valeurs sont au format www.simple@xxx.com. La partie xxx est unique pour chaque ligne. Cet exemple remplace tous les caractères après www. Exemple d'instruction :

    -- Returns wwwtest.
    select regexp_replace(url,'(www)(.*)','wwwtest',0) from url_set;

  • Exemple 5 : Un paramètre d'entrée est NULL. Exemple d'instruction :

    -- Returns NULL.
    select regexp_replace('abcd', '(.)', null, 0);

  • Exemple 6 : Référencer un groupe inexistant. Exemples d'instructions :

    -- Pattern defines only one group; second group reference doesn't exist.
    -- Avoid this usage; result is undefined.
    regexp_replace("abcd", "(.)", "\\2", 0) = "" or "abcd"
    -- Pattern has no groups; \1 references non-existent group.
    -- Avoid this usage; result is undefined.
    regexp_replace("abcd", "a", "\\1", 0) = "bcd" or "abcd"

REGEXP_SUBSTR

• Syntaxe

  string regexp_substr(string <source>, string <pattern>[, bigint <start_position>[, bigint <occurrence>]])

• Description

  Renvoie la sous-chaîne de la chaîne source à partir de start_position qui correspond au pattern pour la occurrence indiquée.

• Paramètres

  • source : obligatoire. Type STRING. Chaîne dans laquelle effectuer la recherche.

  • pattern : obligatoire. Constante STRING ou expression régulière. Modèle à faire correspondre. La syntaxe des expressions régulières est décrite dans Correspondance de chaînes RLIKE.

  • start_position : facultatif. Constante BIGINT. La valeur doit être supérieure à 0. Par défaut, si ce paramètre n'est pas spécifié, sa valeur est 1, ce qui indique que la recherche commence au premier caractère de la chaîne source.

  • occurrence : facultatif. Constante BIGINT. La valeur doit être supérieure à 0. La valeur par défaut est 1, ce qui correspond à la première occurrence.

• Valeur de retour

  Renvoie une valeur STRING. La valeur de retour suit les règles suivantes :

  • Si le pattern est vide, une erreur se produit.

  • Si aucune correspondance n'est trouvée, la fonction renvoie NULL.

  • Si start_position ou occurrence n'est pas de type BIGINT ou est inférieur ou égal à 0, une erreur se produit.

  • Si source, pattern, start_position ou occurrence est NULL, la fonction renvoie NULL.

• Exemples

  • Exemple 1 : Renvoyer la sous-chaîne correspondant au modèle spécifié dans I love aliyun very much. Exemple d'instruction :

    -- Returns aliyun.
    select regexp_substr('I love aliyun very much', 'a[[:alpha:]]{5}');
    -- Returns have.
    select regexp_substr('I have 2 apples and 100 bucks!', '[[:blank:]][[:alnum:]]*', 1, 1);
    -- Returns 2.
    select regexp_substr('I have 2 apples and 100 bucks!', '[[:blank:]][[:alnum:]]*', 1, 2);

  • Exemple 2 : L'un des paramètres d'entrée est NULL. Exemple d'instruction :

    -- Returns NULL.
    select regexp_substr('I love aliyun very much', null);

REPEAT

• Syntaxe

  string repeat(string <str>, bigint <n>)

• Description

  Renvoie la chaîne str répétée n fois.

• Paramètres

  • str : obligatoire. Type STRING. Si l'entrée est de type BIGINT, DOUBLE, DECIMAL ou DATETIME, elle est implicitement convertie en STRING.

  • n : obligatoire. Type BIGINT. La taille de la valeur ne doit pas dépasser 2 Mo.

• Valeur de retour

  Renvoie une valeur de type STRING. La valeur de retour suit les règles suivantes :

  • Si str n'est pas de type STRING, BIGINT, DOUBLE, DECIMAL ou DATETIME, une erreur est renvoyée.

  • Si n est vide, une erreur est renvoyée.

  • Si str ou n est NULL, NULL est renvoyé.

• Exemples

  • Exemple 1 : Répéter la chaîne abc 5 fois. Exemple d'instruction :

    -- Returns abcabcabcabcabc.
    select repeat('abc', 5); 

  • Exemple 2 : L'un des paramètres d'entrée est NULL. Exemple d'instruction :

    -- Returns NULL.
    select repeat('abc', null);

REPLACE

• Syntaxe

  string replace(string <str>, string <old>, string <new>)

• Description

  Remplace toutes les occurrences de old par new dans str et renvoie la chaîne str modifiée. Si aucune correspondance n'est trouvée, la chaîne str d'origine est renvoyée. Cette fonction est une extension MaxCompute V2.0.

• Paramètres

  • str : obligatoire. Type STRING. Chaîne source.

  • old : obligatoire. Chaîne à comparer.

  • new : obligatoire. Type STRING. Chaîne de remplacement.

• Valeur de retour

  Renvoie une valeur de type STRING. Si l'un des paramètres d'entrée est NULL, NULL est renvoyé.

• Exemples

  • Exemple 1 : Remplacer toutes les occurrences de la sous-chaîne abab par 12 dans la chaîne ababab. Exemple d'instruction :

    -- Returns 12ab.
    select replace('ababab','abab','12');

  • Exemple 2 : L'un des paramètres d'entrée est NULL. Exemple d'instruction :

    -- Returns NULL.
    select replace('123abab456ab',null,'abab');

REVERSE

• Syntaxe

  string reverse(string <str>)

• Description

  Renvoie l'inverse de la chaîne str.

• Paramètres

  str : obligatoire. Paramètre de type STRING. Si l'entrée est une valeur BIGINT, DOUBLE, DECIMAL ou DATETIME, elle est implicitement convertie en type STRING.

• Valeur de retour

  Renvoie une valeur de type STRING. Les règles suivantes s'appliquent :

  • Si le type de données de str n'est pas STRING, BIGINT, DOUBLE, DECIMAL ou DATETIME, une erreur est renvoyée.

  • Si str est NULL, NULL est renvoyé.

• Exemples

  • Exemple 1 : Inverser la chaîne I love aliyun very much. Exemple d'instruction :

    -- Returns hcum yrev nuyila evol I.
    select reverse('I love aliyun very much');

  • Exemple 2 : Le paramètre d'entrée est NULL. Exemple d'instruction :

    -- Returns NULL.
    select reverse(null);

RPAD

• Syntaxe

  string rpad(string <str1>, int <length>, string <str2>)

• Description

  Complète la chaîne str1 à droite jusqu'à atteindre length caractères en utilisant la chaîne de remplissage str2. Cette fonction est une extension de MaxCompute V2.0.

• Paramètres

  • str1 : obligatoire. Type STRING. Chaîne à compléter à droite.

  • length : obligatoire. Type INT. Doit être supérieur ou égal à 0. Spécifie le nombre de caractères dans le résultat complété.

  • str2 (obligatoire) : Chaîne utilisée pour le remplissage.

• Valeur de retour

  Renvoie une valeur de type STRING. La valeur de retour suit les règles suivantes :

  • Si length est inférieur à la longueur de str1, la fonction renvoie les length caractères les plus à gauche de str1.

  • Si length est égal à 0, une chaîne vide est renvoyée.

  • Si aucun paramètre d'entrée n'est fourni ou si l'un d'eux est NULL, la fonction renvoie NULL.

• Exemples

  • Exemple 1 : Compléter la chaîne abcdefgh à droite jusqu'à 10 caractères en utilisant la chaîne de remplissage 12. Exemple d'instruction :

    -- Returns abcdefgh12.
    select rpad('abcdefgh', 10, '12');

  • Exemple 2 : Compléter la chaîne abcdefgh à droite jusqu'à 5 caractères en utilisant la chaîne de remplissage 12. Exemple d'instruction :

    -- Returns abcde.
    select rpad('abcdefgh', 5, '12');

  • Exemple 3 : length est égal à 0. Exemple d'instruction :

    -- Returns empty string.
    select rpad('abcdefgh' ,0, '12'); 

  • Exemple 4 : L'un des paramètres d'entrée est NULL. Exemple d'instruction :

    -- Returns NULL.
    select rpad(null ,0, '12');

RTRIM

• Syntaxe

  string rtrim(string <str>[, <trimChars>])
  string trim(trailing [<trimChars>] from <str>)

• Description

  Supprime des caractères à l'extrémité droite de str :

  • Si trimChars n'est pas spécifié, les espaces sont supprimés par défaut.

  • Si trimChars est spécifié, les caractères de trimChars sont traités comme un ensemble. La sous-chaîne la plus longue à l'extrémité droite de str composée entièrement de caractères de l'ensemble trimChars est supprimée.

• Paramètres

  • str : obligatoire. Type STRING. Chaîne à nettoyer. Si l'entrée est de type BIGINT, DECIMAL, DOUBLE ou DATETIME, elle est implicitement convertie en STRING.

  • trimChars : facultatif. Type STRING. Caractères à supprimer.

• Valeur de retour

  Retourne une valeur de type STRING. La valeur retournée suit les règles suivantes :

  • Si str n'est pas de type STRING, BIGINT, DOUBLE, DECIMAL ou DATETIME, une erreur est retournée.

  • Si str ou trimChars est NULL, la fonction retourne NULL.

• Exemples

  • Exemple 1 : Supprimer les espaces de fin de la chaîne yxTxyomxx . Exemples d'instructions :

    -- Returns  yxTxyomxx.
    select rtrim(' yxTxyomxx ');
    -- Equivalent to:
    select trim(trailing from ' yxTxyomxx ');

  • Exemple 2 : Supprimer tous les caractères de fin de la chaîne yxTxyomxx appartenant à l'ensemble xy.

    -- Returns yxTxyom. Any trailing x or y is removed.
    select rtrim('yxTxyomxx', 'xy');
    -- Equivalent to:
    select trim(trailing 'xy' from 'yxTxyomxx');

  • Exemple 3 : Le paramètre d'entrée est NULL. Exemples d'instructions :

    -- Returns NULL.
    select rtrim(null);
    select rtrim('yxTxyomxx', null);

SOUNDEX

• Syntaxe

  string soundex(string <str>)

• Description

  Convertit une chaîne standard en une chaîne SOUNDEX.

• Paramètres

  str : Obligatoire. La chaîne à convertir. Ce paramètre est de type STRING. Cette fonction est une extension de MaxCompute V2.0.

• Valeur de retour

  La valeur de retour est de type STRING. Si str est NULL, la fonction retourne NULL.

• Exemples

  • Exemple 1 : Convertir la chaîne hello en une chaîne SOUNDEX. Exemple d'instruction :

    -- Returns H400.
    select soundex('hello');

  • Exemple 2 : Le paramètre d'entrée est NULL. Exemple d'instruction :

    -- Returns NULL.
    select soundex(null);

SPACE

• Syntaxe

  string space(bigint <n>)

• Description

  Génère une chaîne composée de n espaces.

• Paramètres

  n : Obligatoire. De type BIGINT. La taille de la valeur ne doit pas dépasser 2 Mo.

• Valeur de retour

  Retourne une valeur de type STRING. La valeur de retour suit les règles suivantes :

  • Si n est vide, une erreur est retournée.

  • Si n est NULL, la fonction retourne NULL.

• Exemple

  -- Returns 10.
  select length(space(10));

SPLIT

• Syntaxe

  ARRAY<STRING> SPLIT(STRING <source>, STRING <delimiter>[, BOOLEAN <trimTailEmpty>])
  
  -- Standard example.
  -- Returns ["a","b","c"].
  SELECT SPLIT('a,b,c', ',');

• Paramètres

  • • source : Obligatoire. La chaîne à fractionner. Le type de données est STRING.

    • delimiter : Obligatoire. Le séparateur utilisé pour fractionner la chaîne. Ce paramètre prend en charge les expressions régulières. Le type de données est STRING.

    • trimTailEmpty : Facultatif. Indique s'il faut conserver les chaînes vides de fin. La valeur par défaut est true. Si vous définissez ce paramètre sur false, les chaînes vides de fin sont conservées. Le type de données est BOOLEAN.

• Valeur de retour

  Retourne une valeur de type ARRAY<STRING>.

• Exemple

  -- The return value is ["a"," b"," c"]. 
  select split("a, b, c", ",");
  
  -- No empty string is returned by default.
  select split("a, b, c,,", ",");
  -- The following result is returned:
  +------------+
  | _c0        |
  +------------+
  | ["a"," b"," c"] |
  +------------+
  
  -- If you need to return an empty string, execute the following statement:
  select split("a, b, c,,", ",", false);
  -- The following result is returned:
  +------------+
  | _c0        |
  +------------+
  | ["a"," b"," c","",""] |
  +------------+

SPLIT_PART

• Syntaxe

  string split_part(string <str>, string <separator>, bigint <start>[, bigint <end>])

• Description

  Fractionne la chaîne str à l'aide du délimiteur separator et retourne la sous-chaîne comprise entre la partie start et end (intervalle fermé).

• Paramètres

  • str : Obligatoire. De type STRING. La chaîne à fractionner. Si l'entrée est de type BIGINT, DOUBLE, DECIMAL ou DATETIME, elle est implicitement convertie en STRING.

  • separator : Obligatoire. Constante STRING. Le délimiteur (un caractère unique ou une chaîne).

  • start : Obligatoire. Constante BIGINT, doit être supérieure à 0. Le numéro de la partie de départ (en comptant à partir de 1).

  • end : Une constante BIGINT supérieure ou égale à start. Ce paramètre spécifie le numéro du segment de fin à retourner. Si ce paramètre n'est pas spécifié, sa valeur par défaut est celle de start, et seul le segment spécifié par start est retourné.

• Description de la valeur de retour

  Retourne une valeur de type STRING. La valeur de retour suit les règles suivantes :

  • Si start dépasse le nombre réel de parties (par exemple, il y a 6 parties mais start > 6), une chaîne vide est retournée.

  • Si separator n'est pas trouvé dans str et que start = 1, l'intégralité de str est retournée. Si str est vide, une chaîne vide est retournée.

  • Si separator est vide, la chaîne str d'origine est retournée.

  • Si end dépasse le nombre de parties, la sous-chaîne allant de start jusqu'à la dernière partie est retournée.

  • Si str n'est pas de type STRING, BIGINT, DOUBLE, DECIMAL ou DATETIME, une erreur est retournée.

  • Si separator n'est pas une constante STRING, une erreur est retournée.

  • Si start ou end n'est pas une constante BIGINT, une erreur est retournée.

  • Si un paramètre autre que separator est NULL, la fonction retourne NULL.

• Exemples

  • Exemple 1 : Fractionner la chaîne a,b,c,d à l'aide du délimiteur , et retourner les parties spécifiées. Exemples d'instructions :

    -- Returns a.
    select split_part('a,b,c,d', ',', 1);
    -- Returns a,b.
    select split_part('a,b,c,d', ',', 1, 2);

  • Exemple 2 : start dépasse le nombre réel de parties. Exemple d'instruction :

    -- Returns empty string.
    select split_part('a,b,c,d', ',', 10);

  • Exemple 3 : separator n'est pas trouvé dans str. Exemples d'instructions :

    -- Returns a,b,c,d.
    select split_part('a,b,c,d', ':', 1);
    -- Returns empty string.
    select split_part('a,b,c,d', ':', 2);

  • Exemple 4 : separator est vide. Exemple d'instruction :

    -- Returns a,b,c,d.
    select split_part('a,b,c,d', '', 1);

  • Exemple 5 : end dépasse le nombre réel de parties. Exemple d'instruction :

    -- Returns b,c,d.
    select split_part('a,b,c,d', ',', 2, 6);

  • Exemple 6 : Un paramètre d'entrée autre que separator est NULL. Exemple d'instruction :

    -- Returns NULL.
    select split_part('a,b,c,d', ',', null);

SUBSTR

• Syntaxe

  string substr(string <str>, bigint <start_position>[, bigint <length>])

• Description

  Retourne une sous-chaîne de str commençant à start_position avec une longueur de length.

• Paramètres

  • str : Obligatoire. De type STRING. Si l'entrée est de type BIGINT, DECIMAL, DOUBLE ou DATETIME, elle est implicitement convertie en STRING.

  • start_position : Obligatoire. De type BIGINT. La position de départ par défaut est 1.

    • Version des types de données compatible Hive : Si start_position=0, le comportement est identique à la position 1.

    • Versions des types de données 1.0 et 2.0 : Si start_position=0, la fonction retourne NULL.

  • length : Facultatif. De type BIGINT. La longueur de la sous-chaîne doit être >0.

    Important

    • Si setproject odps.function.strictmode=false : une longueur <0 retourne une valeur vide.

    • Si setproject odps.function.strictmode=true : une longueur <0 retourne une erreur.

• Valeur de retour

  Retourne une valeur de type STRING. La valeur de retour suit les règles suivantes :

  • Si str n'est pas de type STRING, BIGINT, DECIMAL, DOUBLE ou DATETIME, une erreur est retournée.

  • Si length n'est pas de type BIGINT ou est ≤0, une erreur est retournée.

  • Si vous omettez length, la sous-chaîne s'étend jusqu'à la fin de str.

  • Si str, start_position ou length est NULL, la fonction retourne NULL.

• Exemples

  • Exemple 1 : Retourner une sous-chaîne de abc à partir de la position spécifiée avec la longueur spécifiée. Exemples d'instructions :

    -- Returns bc.
    select substr('abc', 2);
    -- Returns b.
    select substr('abc', 2, 1);
    -- Returns bc.
    select substr('abc',-2 , 2);

  • Exemple 2 : Lorsqu'un paramètre d'entrée est NULL. Exemple d'instruction :

    -- Returns NULL.
    select substr('abc', null);

SUBSTRING

• Syntaxe

  string substring(string|binary <str>, int <start_position>[, int <length>])

• Description

  Retourne une sous-chaîne de str commençant à start_position avec une longueur de length.

• Paramètres

  • str : Obligatoire. Ce paramètre est de type STRING ou BINARY.

  • start_position : Obligatoire. Ce paramètre est de type INT. La position de départ commence à 1. Si start_position est 0, une chaîne vide est retournée. Si start_position est une valeur négative, la position est comptée à rebours depuis la fin de la chaîne. Dans ce cas, -1 correspond au dernier caractère, et le décompte se poursuit séquentiellement vers la gauche.

  • length : Facultatif. Ce paramètre est de type BIGINT. La longueur de la sous-chaîne doit être supérieure à 0.

• Valeur de retour

  La valeur de retour est de type STRING. Elle suit les règles suivantes :

  • Si str n'est pas de type STRING ou BINARY, une erreur est retournée.

  • Si length n'est pas de type BIGINT ou est inférieur ou égal à 0, une erreur est retournée.

  • Lorsque le paramètre length est omis, une sous-chaîne allant jusqu'à la fin de str est retournée.

  • Si str, start_position ou length est NULL, la fonction retourne NULL.

• Exemples

  • Exemple 1 : Cet exemple retourne une sous-chaîne de abc à partir d'une position spécifiée avec une longueur spécifiée. Exemples d'instructions :

    -- Returns bc.
    select substring('abc', 2);
    -- Returns b.
    select substring('abc', 2, 1);
    -- Returns bc.
    select substring('abc',-2,2);
    -- Returns ab.
    select substring('abc',-3,2);
    -- Returns 001.
    substring(bin(2345), 2, 3);

  • Exemple 2 : Cet exemple illustre un cas où un paramètre d'entrée est NULL. Exemple d'instruction :

    -- Returns NULL.
    select substring('abc', null, null);

SUBSTRING_INDEX

• Syntaxe

  string substring_index(string <str>, string <separator>, int <count>)

• Description

  Cette fonction extrait une sous-chaîne de la chaîne str, soit avant, soit après la count-ième occurrence d'un délimiteur. Si count est positif, la recherche du délimiteur commence par la gauche. Si count est négatif, la recherche commence par la droite. Cette fonction est une extension de MaxCompute V2.0.

• Paramètres

  • str : Obligatoire. De type STRING. Il s'agit de la chaîne source de l'extraction.

  • separator : Obligatoire. Un délimiteur de type STRING.

  • count : Obligatoire. Une valeur INT qui spécifie la position du séparateur.

• Valeur de retour

  La fonction retourne une valeur de type STRING. Si un paramètre d'entrée est NULL, la fonction retourne NULL.

• Exemples

  • Exemple 1 : Extraction à partir de la chaîne https://www.alibabacloud.com. Exemples d'instructions :

    -- Returns https://www.alibabacloud.
    select substring_index('https://www.alibabacloud.com', '.', 2);
    -- Returns alibabacloud.com.
    select substring_index('https://www.alibabacloud.com', '.', -2);

  • Exemple 2 : Un paramètre d'entrée est NULL. Exemple d'instruction :

    -- Returns NULL.
    select substring_index('https://www.alibabacloud.com', null, 2);

TO_CHAR

• Syntaxe

  string to_char(boolean <value>)
  string to_char(bigint <value>)
  string to_char(double <value>)
  string to_char(decimal <value>)

• Description

  Convertit des valeurs de type BOOLEAN, BIGINT, DECIMAL ou DOUBLE en leur représentation STRING.

• Paramètres

  value : Obligatoire. Une valeur de type BOOLEAN, BIGINT, DECIMAL ou DOUBLE.

• Valeur de retour

  Retourne une valeur de type STRING. La valeur de retour suit les règles suivantes :

  • Si value n'est pas de type BOOLEAN, BIGINT, DECIMAL ou DOUBLE, la fonction retourne une erreur.

  • Si value est NULL, la fonction retourne NULL.

• Exemples

  • Exemple 1 : Convertir des valeurs en représentation STRING. Exemple d'instruction :

    -- Returns 123.
    select to_char(123);
    -- Returns TRUE.
    select to_char(true);
    -- Returns 1.23.
    select to_char(1.23);

  • Exemple 2 : Le paramètre d'entrée est NULL. Exemple d'instruction :

    -- Returns NULL.
    select to_char(null);

TO_JSON

• Syntaxe

  string to_json(<expr>)

• Description

  Convertit une expression spécifiée par expr d'un type de données complexe donné en une chaîne JSON.

• Paramètres

  expr : Obligatoire. Une expression de type ARRAY, MAP ou STRUCT.

  Remarque

  Si l'expression d'entrée est de type STRUCT (struct<key1:value1, key2:value2>), notez les points suivants :

  • Toutes les clés sont converties en minuscules lors de la conversion de l'expression en chaîne JSON.

  • Si une value est null, la paire clé-valeur à laquelle cette value appartient n'est pas incluse dans la chaîne JSON retournée. Par exemple, si value2 est null, key2:value2 n'est pas inclus dans la chaîne JSON retournée.

• Valeur de retour

  Une chaîne JSON est retournée.

• Exemples

  • Exemple 1 : Convertir une expression d'un type de données complexe donné en une chaîne JSON. Exemple d'instruction :

    -- The return value is {"a":1,"b":2}. 
    select to_json(named_struct('a', 1, 'b', 2));
    -- The return value is {"time":"26/08/2015"}. 
    select to_json(named_struct('time', "26/08/2015"));
    -- The return value is [{"a":1,"b":2}]. 
    select to_json(array(named_struct('a', 1, 'b', 2)));
    -- The return value is {"a":{"b":1}}. 
    select to_json(map('a', named_struct('b', 1)));
    -- The return value is {"a":1}. 
    select to_json(map('a', 1));
    -- The return value is [{"a":1}]. 
    select to_json(array((map('a', 1))));

  • Exemple 2 : L'expression d'entrée est de type STRUCT. Exemple d'instruction :

    -- The return value is {"a":"B"}. If the expression of the STRUCT type is converted into a JSON string, all keys are converted into lowercase letters. 
    select to_json(named_struct("A", "B"));
    -- The return value is {"k2":"v2"}. The key-value pair to which null belongs is not included in the JSON string that is returned. 
    select to_json(named_struct("k1", cast(null as string), "k2", "v2"));

TOLOWER

• Syntaxe

  string tolower(string <source>)

• Description

  Convertit les lettres anglaises majuscules de la chaîne source en minuscules.

• Paramètres

  source : Obligatoire. Une valeur de type STRING. Si l'entrée est une valeur BIGINT, DOUBLE, DECIMAL ou DATETIME, elle est implicitement convertie en type STRING. Cette fonction opère uniquement sur les caractères anglais.

• Valeur de retour

  Retourne une valeur de type STRING. La valeur retournée suit les règles suivantes :

  • Si le type de données de source n'est pas STRING, BIGINT, DOUBLE, DECIMAL ou DATETIME, une erreur est retournée.

  • Si source est NULL, la fonction retourne NULL.

• Exemples

  • Exemple 1 : Convertir des lettres majuscules en minuscules. Exemples d'instructions :

    -- Returns abcd.
    select tolower('aBcd');

  • Exemple 2 : Le paramètre d'entrée est NULL. Exemple d'instruction :

    -- Returns NULL.
    select tolower(null);

TOUPPER

• Syntaxe

  string toupper(string <source>)

• Description

  Convertit les caractères minuscules de la chaîne source en leurs caractères majuscules correspondants.

• Paramètres

  source : Obligatoire. De type STRING. Si l'entrée est de type BIGINT, DOUBLE, DECIMAL ou DATETIME, elle est implicitement convertie en STRING. Prend uniquement en charge les caractères anglais.

• Valeur de retour

  Retourne une valeur de type STRING. La valeur retournée suit les règles suivantes :

  • Si le type de données de source n'est pas STRING, BIGINT, DOUBLE, DECIMAL ou DATETIME, une erreur est retournée.

  • Si source est NULL, la fonction retourne NULL.

• Exemples

  • Exemple 1 : Convertir des lettres minuscules en majuscules. Exemples d'instructions :

    -- Returns ABCD.
    select toupper('aBcd');

  • Exemple 2 : Le paramètre d'entrée est NULL. Exemple d'instruction :

    -- Returns NULL.
    select toupper(null);

TRANSLATE

• Syntaxe

  string translate(string|varchar <str1>, string|varchar <str2>, string|varchar <str3>)

• Description

  Remplace chaque caractère de str1 apparaissant dans str2 par le caractère correspondant dans str3. Si aucune correspondance n'est trouvée, aucun remplacement n'est effectué. Cette fonction est une extension de MaxCompute V2.0.

• Valeur de retour

  Retourne une valeur de type STRING. Si un paramètre d'entrée est NULL, la fonction retourne NULL.

• Exemples

  • Exemple 1 : Remplacer chaque caractère de ababab apparaissant dans abab par le caractère correspondant dans cd. Exemple d'instruction :

    -- Returns cdcdcd.
    select translate('ababab','abab','cd');

  • Exemple 2 : Remplacer chaque caractère de ababab apparaissant dans abab par le caractère correspondant dans cdefg. Exemple d'instruction :

    -- Returns cdcdcd.
    select translate('ababab','abab','cdefg');

  • Exemple 3 : Un paramètre d'entrée est NULL. Exemple d'instruction :

    -- Returns NULL.
    select translate('ababab','cd',null);

TRIM

• Syntaxe

  string trim(string <str>[,<trimChars>])
  string trim([BOTH] [<trimChars>] from <str>)

• Description

  Supprime les caractères aux deux extrémités de str :

  • Si vous ne spécifiez pas trimChars, la fonction supprime les espaces par défaut.

  • Si vous spécifiez trimChars, la fonction considère les caractères de trimChars comme un ensemble et supprime les sous-chaînes les plus longues possibles composées uniquement de caractères de cet ensemble, aux extrémités gauche et droite de str.

• Paramètres

  • str : Obligatoire. De type STRING. La chaîne à nettoyer. Si l'entrée est de type BIGINT, DECIMAL, DOUBLE ou DATETIME, elle est implicitement convertie en STRING.

  • trimChars : Facultatif. De type STRING. Les caractères à supprimer.

• Valeur de retour

  Retourne une valeur de type STRING. La valeur de retour suit les règles suivantes :

  • Si str n'est pas de type STRING, BIGINT, DOUBLE, DECIMAL ou DATETIME, une erreur est retournée.

  • Si str ou trimChars est NULL, la fonction retourne NULL.

• Exemples

  • Exemple 1 : Supprimer les espaces aux deux extrémités de la chaîne yxTxyomxx . Exemples d'instructions :

    -- Returns yxTxyomxx.
    select trim(' yxTxyomxx ');
    -- Equivalent to:
    select trim(both from ' yxTxyomxx ');
    select trim(from ' yxTxyomxx ');

  • Exemple 2 : Supprimer tous les caractères aux deux extrémités de la chaîne yxTxyomxx appartenant à l'ensemble xy.

    -- Returns Txyom. Any x or y on either end is removed.
    select trim('yxTxyomxx', 'xy');
    -- Equivalent to:
    select trim(both 'xy' from 'yxTxyomxx');
    select trim('xy' from 'yxTxyomxx');

  • Exemple 3 : Le paramètre d'entrée est NULL. Exemples d'instructions :

    -- Returns NULL.
    select trim(null);
    select trim('yxTxyomxx', null);

URL_DECODE

• Syntaxe

  string url_decode(string <input>[, string <encoding>])

• Description

  Convertit une chaîne d'entrée du format application/x-www-form-urlencoded MIME en caractères standard. Cette fonction est l'inverse de url_encode. Les règles d'encodage sont les suivantes :

  • Les caractères a–z et A–Z restent inchangés.

  • Le point (.), le trait d'union (-), l'astérisque (*) et le trait de soulignement (_) restent inchangés.

  • Le signe plus (+) est converti en espace.

  • Les séquences au format %xy sont converties en valeurs d'octet. Les octets consécutifs sont décodés en chaînes à l'aide du nom d'encoding spécifié.

  • Tous les autres caractères restent inchangés.

• Paramètres

  • input : Ce paramètre est obligatoire et de type STRING. Il représente la chaîne d'entrée.

  • encoding : Ce paramètre est facultatif et spécifie le format d'encodage. Il prend en charge des formats tels que GBK et UTF-8. S'il n'est pas spécifié, l'encodage par défaut est UTF-8.

• Valeur de retour

  Cette fonction retourne une valeur de type STRING encodée en UTF-8. Si le paramètre input ou encoding est NULL, la fonction retourne NULL.

• Exemple

  -- Returns examplefor url_decode:// (fdsf).
  select url_decode('%E7%A4%BA%E4%BE%8Bfor+url_decode%3A%2F%2F+%28fdsf%29');
  -- Returns Example for URL_DECODE:// dsf(fasfs).
  select url_decode('Example+for+url_decode+%3A%2F%2F+dsf%28fasfs%29', 'GBK');

URL_ENCODE

• Syntaxe

  string url_encode(string <input>[, string <encoding>])

• Description

  Encode une chaîne d'entrée au format application/x-www-form-urlencoded MIME. Règles d'encodage :

  • Les lettres de a à z et de A à Z restent inchangées.

  • Le point (.), le trait d'union (-), l'astérisque (*) et le trait de soulignement (_) ne sont pas modifiés.

  • Les espaces sont convertis en signes plus (+).

  • Tous les autres caractères sont convertis en valeurs d'octets selon l'encoding spécifié. Chaque octet est représenté sous la forme %xy, où xy correspond à la représentation hexadécimale du caractère.

• Paramètres

  • input : obligatoire. Type STRING. Chaîne à encoder.

  • encoding : facultatif. Format d'encodage. Les formats pris en charge incluent GBK et UTF-8. La valeur par défaut est UTF-8 si ce paramètre n'est pas spécifié.

• Valeur de retour

  Renvoie une valeur de type STRING. Si input ou encoding est NULL, la fonction renvoie NULL.

• Exemple

  -- Returns %E7%A4%BA%E4%BE%8Bfor+url_encode%3A%2F%2F+%28fdsf%29.
  select url_encode('examplefor url_encode:// (fdsf)');
  -- Returns Example+for+url_encode+%3A%2F%2F+dsf%28fasfs%29.
  select url_encode('Example for url_encode:// dsf(fasfs)', 'GBK');

Références

Pour aller au-delà des fonctions intégrées, créez des fonctions définies par l'utilisateur (UDF). Pour plus d'informations, consultez Présentation des UDF MaxCompute.