MaxCompute:Présentation des 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 ne prend en charge 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 : convertit la première lettre anglaise de chaque mot en majuscule 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 de retour

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

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

  • Si str est NULL, NULL est renvoyé.

• 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 qui apparaissent 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 non valides (non encodés en Unicode) sont trouvés lors de la comparaison, une valeur négative est renvoyée.

• Valeur de retour

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

• Exemples

  • Exemple 1 : calculer le nombre de caractères de la chaîne aabc qui apparaissent 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 de retour

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

  • 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, NULL est renvoyé.

• 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

  • Tableaux en entrée : concatène tous les éléments de plusieurs tableaux et renvoie un nouveau tableau.

  • Chaînes en entrée : 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 contenus dans les 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 impérativement partager le 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 type STRING avant le calcul. Pour tout autre type de données, une erreur est renvoyée.

• Valeur de retour

  • Renvoie une valeur de type ARRAY. Si l'un des tableaux d'entrée est null, la fonction renvoie null.

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

• Exemples

  • Exemple 1 : concaténez 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énez 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 de tous les éléments du tableau, en utilisant le délimiteur spécifié. Cette fonction constitue une extension introduite avec MaxCompute V2.0.

• Paramètres

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

  • str1 et str2 : vous devez spécifier au moins deux chaînes. 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 de retour

  Renvoie une valeur de type STRING ou STRUCT. La valeur de retour obéit aux 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 l'un des paramètres d'entrée est NULL, la fonction renvoie NULL.

• Exemples

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

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

    -

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

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

  • Exemple 3 : concaténez 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 selon le format spécifié par charset.

• Paramètres

  Paramètre	Obligatoire	Description
  str	Oui	Type BINARY. 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 de retour

  Renvoie une valeur de type STRING. Si str ou charset est NULL, la fonction renvoie NULL.

• Exemples

  • Exemple 1 : encodez et décodez 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éfinissez 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 selon le format spécifié par charset.

• Paramètres

  • str : obligatoire. Type STRING. 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 de retour

  Renvoie une valeur de type BINARY. Si str ou charset est NULL, la fonction renvoie NULL.

• Exemples

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

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

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

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

  • Exemple 3 : l'un des paramètres 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. Chaîne à rechercher.
  str2	Oui	Type STRING. 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 de retour

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

  • Si str2 ne contient pas str1 ou si str1 contient delimiter, la fonction renvoie 0.

  • Si str1 ou str2 est NULL, la fonction renvoie NULL.

• Exemples

  • Exemple 1 : recherchez 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 : recherchez 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 : recherchez 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 que vous souhaitez formater.

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

• Valeur de retour

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

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

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

  • Si la valeur de expr2 est inférieure à 0 ou supérieure à 340, une erreur est renvoyée.

  • Si expr1 ou expr2 est vide ou défini sur null, la fonction renvoie null.

• Exemples

  • Exemple 1 : formatez un nombre comme spécifié. Exemples d'instructions :

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

  • Exemple 2 : l'un des paramètres 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

  La fonction FROM_CHARSET convertit des données binaires encodées dans un format autre que UTF-8 en une chaîne UTF-8 pour les calculs ultérieurs.

• Paramètres

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

  • source_charset : obligatoire. Valeur de type STRING. Ce paramètre spécifie le format d'encodage d'origine des données binaires indiqué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 spécifie le mode de traitement lorsqu'un caractère ne peut pas être converti pendant que la fonction FROM_CHARSET transforme les données binaires spécifiées par source en une chaîne dans le format d'encodage indiqué. 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 par un caractère similaire dans le format d'encodage spécifié.

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

• Valeur de retour

  Renvoie une chaîne de type STRING encodée en UTF-8. Lorsque les paramètres sont NULL ou des chaînes vides, la valeur de retour obéit aux règles suivantes :

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

  • Si l'un des paramètres d'entrée est une chaîne vide, une erreur est renvoyée.

• Exemples

  • Exemple 1 : convertissez 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 : convertissez 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 renvoie null.

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

FROM_JSON

• Syntaxe

  from_json(<jsonStr>, <schema>)

• Description

  Renvoie des données de type ARRAY, MAP ou STRUCT à partir d'une chaîne JSON jsonStr et d'un format de sortie schema.

• Paramètres

  • jsonStr : obligatoire. La chaîne JSON que vous avez saisie.

  • schema : obligatoire. Le schéma de la chaîne JSON. La valeur de ce paramètre doit respecter le même format que celui utilisé dans l'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 sont sensibles à la casse. Vous pouvez également spécifier une structure 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 type OBJECT et ARRAY sont analysées autant que possible. Si le type de données de la chaîne JSON ne correspond à aucun type de données MaxCompute, la chaîne JSON est omise. Pour faciliter l'utilisation, tous les types de données JSON peuvent être convertis vers le type de données STRING pris en charge par MaxCompute. Lors de la conversion d'une chaîne JSON de type NUMBER en une valeur de type FLOAT, DOUBLE ou DECIMAL, la précision de la valeur ne peut pas être garantie. Nous vous recommandons de convertir la chaîne JSON en une valeur de type STRING, puis de convertir la valeur obtenue en une valeur de type FLOAT, DOUBLE ou DECIMAL.

• Valeur renvoyée

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

• Exemples

  • Exemple 1 : Convertissez une chaîne JSON spécifique en une valeur d'un type de données spécifique. 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 : Utilisez les fonctions map_keys et from_json pour obtenir toutes les clés d'une chaîne JSON. Vous pouvez également utiliser JSON_KEYS dans le même but. Exemple d'instruction :

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

GET_JSON_OBJECT

• Syntaxe

  STRING GET_JSON_OBJECT(JSON|STRING <json>, STRING <json_path>)
  
  -- Example: Returns Alice.
  SELECT GET_JSON_OBJECT(JSON '{"name": "Alice", "age": 30}', '$.name');

• Description

  La fonction GET_JSON_OBJECT extrait une chaîne d'une chaîne JSON ou d'une valeur de type de données JSON selon un chemin JSON spécifié, json_path.

• Remarques sur l'utilisation

  • La fonction GET_JSON_OBJECT ne prend pas en charge la syntaxe des expressions régulières dans les chemins JSON.

  • La syntaxe du chemin JSON pour le nouveau type de données JSON diffère de la spécification d'origine. Cela peut entraîner des problèmes de compatibilité.

  • Si une requête contient plusieurs fonctions GET_JSON_OBJECT qui traitent les mêmes données JSON, la fonction analyse plusieurs fois la même chaîne JSON. Cela peut nuire aux performances et augmenter les coûts. Pour éviter cela, vous pouvez utiliser GET_JSON_OBJECT avec une fonction définie par l'utilisateur retournant une table (UDTF) pour transformer les données de journal JSON.

• Paramètres

  • json : Obligatoire. Les données JSON que vous souhaitez traiter. Ce paramètre prend en charge deux types d'entrée : JSON et STRING.

    • Type JSON : Une valeur de type de données JSON. La valeur doit être au format {"Key":"Value", "Key":"Value",...}, par exemple JSON '{"name": "Alice", "age": 30}'.

    • Type STRING : Si l'entrée est une chaîne STRING, elle doit répondre aux exigences de format suivantes :

      • La chaîne doit être au format '{"Key":"Value", "Key":"Value",...}', par exemple '{"name": "Alice", "age": 30}'.

      • Un guillemet double (") doit être échappé avec deux barres obliques inverses (\\).

      • Un guillemet simple (') doit être échappé avec une barre oblique inverse (\).

  • json_path : Obligatoire. Une chaîne STRING qui spécifie l'expression de chemin JSON utilisée pour extraire les données. Le chemin doit commencer par un caractère $, par exemple $.aliyun.test[0].demo. L'expression de chemin utilise les caractères suivants :

    • $ : Indique le nœud racine.

    • . ou [''] : Indique un nœud enfant. Ceci est utilisé pour analyser les objets JSON, par exemple $.store.book. Si une clé JSON contient un point (.), vous pouvez utiliser [''] à la place.

      L'extraction de données à l'aide de [''] est prise en charge uniquement si vous exécutez l'instruction SET odps.sql.udf.getjsonobj.new=true;.

    • [] : [number] indique un indice de tableau. L'indice commence à 0.

    • * : Caractère générique pour []. Il renvoie l'intégralité du tableau. L'astérisque (*) ne peut pas être échappé.

• Valeur renvoyée

  Renvoie une valeur de type STRING. Cette valeur correspond aux données extraites du chemin spécifié. La fonction suit ces règles pour sa valeur de retour :

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

  • Si json est vide ou a un format invalide, NULL est renvoyé.

  • Si json_path contient [*], la valeur de retour n'est pas au format tableau. Pour forcer la valeur de retour à être dans un format tableau unifié, vous pouvez exécuter l'instruction SET odps.sql.force.getjsonobj.array.format=true;.

  • Si json_path est invalide, NULL est renvoyé.

  Comportement de retour

  • Vous pouvez contrôler le comportement de retour de la fonction en définissant l'indicateur au niveau du projet ou de la session avec la commande suivante : SET odps.sql.udf.getjsonobj.new=true/false;.

    Les deux comportements de retour correspondant aux différents paramètres d'indicateur sont les suivants :

    Important

    Nous vous recommandons d'utiliser la configuration SET odps.sql.udf.getjsonobj.new=true;. Cette configuration offre un comportement de fonction plus standard, simplifie le traitement des données et améliore les performances. Si votre projet MaxCompute comporte des tâches existantes qui dépendent du comportement d'échappement des caractères réservés JSON, nous vous recommandons de continuer à utiliser le comportement d'origine. Cela permet d'éviter les erreurs ou les problèmes d'exactitude qui pourraient survenir si vous passez au nouveau comportement sans vérification.

    Paramètres	SET odps.sql.udf.getjsonobj.new=true;	SET odps.sql.udf.getjsonobj.new=false;
    Comportement de retour	Renvoie la chaîne d'origine sans modification.	Renvoie la chaîne avec les caractères réservés JSON échappés.
    	La valeur de retour est une chaîne JSON qui peut être analysée directement. Vous n'avez pas besoin d'utiliser des fonctions telles que REPLACE ou REGEXP_REPLACE pour remplacer les barres obliques inverses.	Les caractères réservés JSON, tels que les sauts de ligne (\n) et les guillemets ("), sont renvoyés sous forme de chaînes '\n' et '\"'.
    Analyse des clés en double	Un objet JSON peut contenir des clés en double, qui peuvent être analysées avec succès. -- Renvoie 1. SELECT GET_JSON_OBJECT('{"a":"1","a":"2"}', '$.a');	Un objet JSON ne peut pas contenir de clés en double. Si c'est le cas, l'analyse peut échouer. -- Renvoie NULL. SELECT GET_JSON_OBJECT('{"a":"1","a":"2"}', '$.a');
    Ordre de tri de la sortie	La sortie est triée dans le même ordre que la chaîne JSON d'origine. -- Renvoie {"b":"1","a":"2"}. SELECT GET_JSON_OBJECT('{"b":{"b":"1","a":"2"},"a":"2"}', '$.b');	La sortie est triée par ordre alphabétique. -- Renvoie {"a":"2","b":"1"}. SELECT GET_JSON_OBJECT('{"b":{"b":"1","a":"2"},"a":"2"}', '$.b');

  • Si le mode de compatibilité Hive est activé en exécutant la commande SET odps.sql.hive.compatible=true;, la fonction GET_JSON_OBJECT conserve les chaînes d'origine dans sa valeur de retour.

  • Pour les projets MaxCompute créés le 21 janvier 2021 ou après, le comportement de retour par défaut de la fonction GET_JSON_OBJECT consiste à conserver les chaînes d'origine.

  • Pour les projets MaxCompute créés avant le 21 janvier 2021, le comportement de retour par défaut de la fonction GET_JSON_OBJECT consiste à échapper les caractères réservés JSON.

  • Vous pouvez utiliser l'exemple suivant pour déterminer le comportement utilisé par la fonction GET_JSON_OBJECT dans votre projet MaxCompute. Pour ce faire, exécutez la commande suivante :

    SELECT GET_JSON_OBJECT('{"a":"[\\"1\\"]"}', '$.a');
    --The return value if the behavior is to escape JSON reserved characters:
    [\"1\"]
    
    --The return value if the behavior is to preserve original strings:
    ["1"]

    Pour basculer le comportement de retour par défaut de la fonction GET_JSON_OBJECT dans votre projet afin de conserver les chaînes d'origine, vous pouvez soumettre un ticket. Cela évite d'avoir à définir la propriété au niveau de la session pour chaque session.

• Exemples

  Paramètre d'entrée JSON

  Exemple 1 : Obtenir les valeurs de clés spécifiques à partir des données JSON

  -- Returns 1.
  SELECT GET_JSON_OBJECT(JSON '{"a":1, "b":2}', '$.a');
  
  -- Returns NULL.
  SELECT GET_JSON_OBJECT(JSON '{"a":1, "b":2}', '$.c');

  Un paramètre json_path invalide renvoie NULL.

  -- Returns NULL.
  SELECT GET_JSON_OBJECT(JSON '{"a":1, "b":2}', '$invalid_json_path');

  Paramètre d'entrée STRING

  Exemple 1 : Extraire des informations de l'objet JSON src_json.json

  -- Prepare the test data.
  CREATE TABLE IF NOT EXISTS src_json (
      json STRING
  );
  
  INSERT OVERWRITE TABLE src_json
  VALUES
  ('{"store":
    {"fruit":[{"weight":8,"type":"apple"},
      {"weight":9,"type":"pear"}],
       "bicycle":{"price":19.95,
       "color":"red"}},
     "email":"amy@only_for_json_udf_test.net",
     "owner":"amy"}');
  
  -- Extract the information of the owner field. The return value is amy.
  SELECT GET_JSON_OBJECT(src_json.json, '$.owner') FROM src_json;
  
  -- Optional. Output by preserving the original string.
  SET odps.sql.udf.getjsonobj.new=true;
  -- Extract the information of the first array in the store.fruit field. The return value is {"weight":8,"type":"apple"}.
  SELECT GET_JSON_OBJECT(src_json.json, '$.store.fruit[0]') FROM src_json;
  
  -- Extract the information of a non-existent field. The return value is NULL.
  SELECT GET_JSON_OBJECT(src_json.json, '$.non_exist_key') FROM src_json;

  Exemple 2 : Extraire des informations des données de tableau JSON

  -- Returns 2222.
  SELECT GET_JSON_OBJECT('{"array":[["aaaa",1111],["bbbb",2222],["cccc",3333]]}','$.array[1][1]');
  
  -- Output by preserving the original string.
  SET odps.sql.udf.getjsonobj.new=true;
  -- Returns ["h0","h1","h2"].
  SELECT GET_JSON_OBJECT('{"aaa":"bbb","ccc":{"ddd":"eee","fff":"ggg","hhh":["h0","h1","h2"]},"iii":"jjj"}','$.ccc.hhh[*]');
  
  -- Output by escaping JSON reserved characters.
  SET odps.sql.udf.getjsonobj.new=false;
  -- Returns ["h0","h1","h2"].
  SELECT GET_JSON_OBJECT('{"aaa":"bbb","ccc":{"ddd":"eee","fff":"ggg","hhh":["h0","h1","h2"]},"iii":"jjj"}','$.ccc.hhh[*]');
  
  -- Returns h1.
  SELECT GET_JSON_OBJECT('{"aaa":"bbb","ccc":{"ddd":"eee","fff":"ggg","hhh":["h0","h1","h2"]},"iii":"jjj"}','$.ccc.hhh[1]');

  Exemple 3 : Extraire des informations des données JSON contenant un point (.) dans la clé

  -- Prepare the test data.
  CREATE TABLE json_test (id STRING, json STRING);
  
  -- Insert data where the key contains a period (.).
  INSERT INTO TABLE json_test (id, json) VALUES 
  ("1", 
    "{
      \"China.beijing\":
        {\"school\":
          {\"id\":0,\"book\":
            [{\"title\": \"A\",\"price\": 8.95},
             {\"title\": \"B\",\"price\": 10.2}]
          }
        }
    }"
  );
  
  -- Insert data where the key does not contain a period (.).
  INSERT INTO TABLE json_test (id, json) VALUES 
  ("2", 
    "{
      \"China_beijing\":
        {\"school\":
          {\"id\":0,\"book\":
            [{\"title\": \"A\",\"price\": 8.95},
             {\"title\": \"B\",\"price\": 10.2}]
          }
        }
    }"
  );
  
  -- Use square brackets [''] to parse data that contains a period (.).
  -- This extracts the 'id' value under 'China.beijing'. The return value is 0.
  SELECT GET_JSON_OBJECT(json, "$['China.beijing'].school['id']") FROM json_test WHERE id =1;
  
  -- For data without special characters, both '.' and [''] are valid and equivalent.
  -- This extracts the 'id' value under 'China_beijing'. The return value is 0.
  SELECT GET_JSON_OBJECT(json, "$['China_beijing'].school['id']") FROM json_test WHERE id =2;
  SELECT GET_JSON_OBJECT(json, "$.China_beijing.school['id']") FROM json_test WHERE id =2;

  Utilisez [''] pour les clés contenant un point (.)

  SET odps.sql.udf.getjsonobj.new=true;
  
  -- Returns 1.
  SELECT GET_JSON_OBJECT('{"a.1":"1","a":"2"}', '$[\'a.1\']');

  Exemple 5 : Entrée JSON vide ou invalide

  -- Returns NULL.
  SELECT GET_JSON_OBJECT('','$.array[1][1]');
  
  -- Returns NULL.
  SELECT GET_JSON_OBJECT('"array":["aaaa",1111],"bbbb":["cccc",3333]','$.array[1][1]');

  Exemple 6 : Chaînes JSON échappées

  SET odps.sql.udf.getjsonobj.new=true;
  
  --Returns "1".
  SELECT GET_JSON_OBJECT('{"a":"\\"1\\"","b":"2"}', '$.a'); 
  
  --Returns '1'.
  SELECT GET_JSON_OBJECT('{"a":"\'1\'","b":"2"}', '$.a');

  Exemple 7 : Prise en charge des emojis

  -- Returns the emoji symbol.
  SELECT GET_JSON_OBJECT('{"a":"<Emoji symbol>"}', '$.a');

  Remarque : DataWorks ne prend pas en charge la saisie directe de caractères emoji. Vous pouvez utiliser un outil tel que Data Integration pour écrire les chaînes encodées correspondant aux caractères emoji dans MaxCompute. Ensuite, vous pouvez utiliser la fonction GET_JSON_OBJECT pour les traiter.

INITCAP

• Syntaxe

  string initcap(<str>)

• Description

  Convertit str en majuscules initiales où les mots sont séparés par des espaces, avec la première lettre de chaque mot en majuscule et le reste en minuscule.

• Paramètres

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

• Valeur renvoyée

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

• 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 renvoyée pour les autres types de données. Ce paramètre spécifie la position du caractère dans str1 à partir de laquelle la recherche commence. La position de départ par défaut est le premier caractère, c'est-à-dire la position 1. Si start_position est une valeur négative, la recherche commence à partir de la fin de la chaîne, où le dernier caractère se trouve à 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 spécifie 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 renvoyée.

• Valeur de retour

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

  • Si str1 ne contient pas str2, renvoie 0.

  • Si str2 est vide, la correspondance est toujours réussie. Exemple : select instr('abc',''); renvoie 1.

  • Si str1, str2, start_position ou nth_appearance est NULL, renvoie NULL.

• Exemples

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

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

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

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

  • Exemple 3 : Recherchez la position de la deuxième occurrence du caractère e dans la chaîne Tech on the net en commençant à partir du troisième caractère. Instruction d'exemple :

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

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

    -- 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 corrompus ; 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 tout 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 de retour suit ces règles :

  • Si la conversion de str réussit, renvoie True ; sinon, renvoie False.

  • Si str, from_encoding ou to_encoding est NULL, renvoie 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 peut 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é dans un objet JSON inclut un point (.), vous pouvez utiliser [''].

• Valeur de retour

  Une valeur de type STRING est renvoyée.

  Remarque

  • Si json est vide ou invalide, null est renvoyé.

  • Si key est vide, invalide ou n'existe pas dans la chaîne JSON, null est renvoyé.

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

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

  • Cette fonction peut analyser des 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. Par conséquent, la chaîne JSON est analysée plusieurs fois. La fonction JSON_TUPLE vous permet de saisir plusieurs clés à la fois et la chaîne JSON n'est analysée qu'une seule fois. JSON_TUPLE est plus efficace que GET_JSON_OBJECT.

  • JSON_TUPLE est une fonction définie par l'utilisateur renvoyant une table (UDTF). Si vous souhaitez 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 en utilisant split1, sépare les paires en utilisant split2 et renvoie la valeur correspondant à key.

• Paramètres

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

  • split1, split2 : facultatifs. type STRING. Chaînes de délimitation pour la division. Si non spécifiés, la valeur par défaut de split1 est ";" et celle de split2 est ":". Si une sous-chaîne divisée par split1 contient plusieurs occurrences de split2, le résultat est indéfini.

  • key : obligatoire. type STRING. Après la division par split1 et split2, renvoie la valeur pour key.

• Valeur de retour

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

  • Si split1 ou split2 est NULL, renvoie NULL.

  • Si str ou key est NULL ou si aucune key correspondante n'existe, renvoie NULL.

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

• Exemples

  • Exemple 1 : Divisez la chaîne 0:1/;1:2 en paires clé-valeur et renvoyez la valeur pour la clé 1. Instruction d'exemple :

    -- 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 la valeur par défaut de split2 est un deux-points (":").

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

    0 1/  
    1 2

    Renvoie la valeur 2 pour la clé 1.

  • Exemple 2 : Divisez 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 renvoyez la valeur pour la clé tf. Instruction d'exemple :

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

    La division 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 de la division par ":" est le suivant.

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

    Renvoie la valeur 21910 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 en utilisant split1, sépare les paires en utilisant split2 et renvoie les valeurs pour plusieurs key s.

• Paramètres

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

  • split1, split2 : obligatoires. type STRING. Chaînes de délimitation pour la division. Si une sous-chaîne divisée par split1 contient plusieurs occurrences de split2, le résultat est indéfini.

  • key : obligatoire. type STRING. Après la division par split1 et split2, renvoie la valeur pour key.

• Valeur de retour

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

  • Si split1 ou split2 est NULL, renvoie NULL.

  • Si str ou key est NULL ou si aucune key correspondante n'existe, renvoie 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

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

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

  • Si str est NULL, renvoie NULL.

  • Si str n'est pas encodé en UTF-8, renvoie -1.

• Exemples

  • Exemple 1 : Calculez la longueur de la chaîne Tech on the net. Instruction d'exemple :

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

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

    -- 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

  Renvoie une valeur de type BIGINT. La valeur de retour obéit aux 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 fonction renvoie NULL.

• Exemples

  • Exemple 1 : calculez 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 la chaîne str. Utilisez start_pos pour spécifier la position de départ (à partir de 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

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

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

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

  • Si start_pos est NULL, la fonction renvoie 0.

• Exemples

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

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

  • Exemple 2 : recherchez 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

  Ajoute un remplissage à gauche à la chaîne str1 jusqu'à atteindre length caractères, en utilisant la chaîne str2. Cette fonction est une extension disponible dans MaxCompute V2.0.

• Paramètres

  • str1 : obligatoire. type STRING. Chaîne à remplir à gauche.

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

  • str2 : obligatoire. Chaîne de remplissage.

• Valeur de retour

  Renvoie une valeur de type STRING. La valeur de retour obéit aux 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, la fonction renvoie une chaîne vide.

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

• Exemples

  • Exemple 1 : utilisez la chaîne 12 pour ajouter un remplissage à gauche à la chaîne abcdefgh afin d'atteindre 10 caractères. Voici la commande d'exemple.

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

  • Exemple 2 : utilisez la chaîne 12 pour ajouter un remplissage à gauche à la chaîne abcdefgh afin d'atteindre une longueur de 5 caractères. Voici la commande d'exemple.

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

  • Exemple 3 : length est égal à 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 les caractères situés à 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 traite les caractères contenus dans trimChars comme un ensemble et supprime, à l'extrémité gauche de str, la plus longue sous-chaîne possible composée exclusivement de caractères appartenant à l'ensemble trimChars.

• Paramètres

  • str : obligatoire. type STRING. Chaîne à rogner. 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

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

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

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

• Exemples

  • Exemple 1 : supprimez 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 : supprimez tous les caractères de début de la chaîne yxTxyomxx qui appartiennent à 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

  Renvoie une valeur de hachage calculée à partir de l'expression de chaîne expr. Des valeurs de hachage identiques indiquent que les valeurs d'expression sont 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

  Renvoie une valeur de hachage de 64 octets. Pour les expressions non textuelles, la fonction renvoie null (compatible avec 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

  Renvoie une valeur de type STRING. La valeur de retour obéit aux 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 fonction renvoie NULL.

• Exemples

  • Exemple 1 : calculez 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 l'URL url et extrait les informations spécifiées par part.

• Paramètres

  • url : obligatoire. type STRING. Lien URL. Les URL non valides renvoient une erreur.

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

  • key : facultatif. Lorsque part est défini sur QUERY, renvoie la valeur associée à key.

• description de la valeur de retour

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

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

  • Si part n'est pas valide, une erreur est renvoyé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 l'URL url et extrait les chaînes spécifiées par les clés d'entrée key1, key2, etc. Cette fonction est similaire à PARSE_URL, mais elle extrait plusieurs clés simultanément avec de meilleures performances.

• Paramètres

  • url : obligatoire. type STRING. Lien URL. Les URL non valides renvoient une erreur.

  • key1, key2 : obligatoire. 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 utilisateur.

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

    Insensible à la casse. Les valeurs non valides renvoient une erreur.

• description de la valeur de retour

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

• Exemple

  Extrayez les chaînes correspondant à 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 :

  +------------+------------+------------+------------+------------+------------+------------+------------+------------+------------+
  | 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 à partir de start_position qui correspondent au pattern spécifié.

• Paramètres

  • source : obligatoire. type STRING. Chaîne dans laquelle effectuer la recherche. Les autres types renvoient 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îne RLIKE. Un pattern vide ou non valide renvoie une erreur.

  • start_position : facultatif. Constante de type BIGINT. La valeur de ce paramètre doit être supérieure à 0. Si la valeur appartient à un autre type de données ou est inférieure ou égale à 0, une erreur est renvoyée. Si vous ne spécifiez pas ce paramètre, la valeur par défaut est 1. Cette valeur indique que la recherche commence à partir du premier caractère de la chaîne source.

• Valeur de retour

  Renvoie une valeur de type BIGINT. La valeur de retour obéit aux 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 : comptez 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 : comptez 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 type de données compatibles avec Hive, la fonction REGEXP_EXTRACT suit la spécification des expressions régulières Java. Dans les versions de type de données 1.0 et 2.0, elle suit la spécification MaxCompute.

• description

  Cette fonction divise la chaîne source en groupes à l'aide du pattern et renvoie la chaîne correspondant au 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 règles des expressions régulières, consultez la section Correspondance de chaîne RLIKE.

  • groupid : facultatif. Constante BIGINT, doit être supérieure ou égale à 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 obéit aux 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 le paramètre groupid n'est pas de type BIGINT ou est inférieur à 0, une erreur est renvoyée. Si vous ne spécifiez pas ce paramètre, la valeur par défaut est 1, ce qui indique que la sous-chaîne du premier groupe est renvoyée. Si le paramètre groupid est défini sur 0, la sous-chaîne qui correspond à l'intégralité du pattern est renvoyée.

  • Si les paramètres source, pattern ou groupid ont la valeur 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 règles des expressions régulières, consultez la section Correspondance de chaîne RLIKE.

  • group_id : facultatif. Valeur BIGINT. Ce paramètre spécifie l'ID du groupe utilisé pour la correspondance du modèle. La valeur de ce paramètre doit être supérieure ou égale à 0. Si vous ne spécifiez pas ce paramètre, le groupe dont l'identifiant 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 intégralité.

• Valeur de retour

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

• Exemple

  • Si vous ne spécifiez pas le paramètre 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 du paramètre group_id sur 2, le résultat de correspondance pour le 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 la chaîne source, en commençant à partir de la position 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 la section Correspondance de chaîne RLIKE. Un pattern vide génère 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 indique la première correspondance.

  • return_option : Facultatif. Position à renvoyer. La valeur doit être une constante BIGINT. Valeurs valides : 0 spécifie la position de début et 1 spécifie la position de fin. La valeur par défaut est 0. Si vous spécifiez une valeur non valide, une erreur est renvoyée.

• Valeur de retour

  La valeur de retour est de type BIGINT. Le paramètre return_option spécifie s'il faut renvoyer la position de début ou de fin de la sous-chaîne correspondante dans la chaîne 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, de pattern, de start_position, de occurrence ou de return_option est NULL, la fonction renvoie NULL.

• Exemples

  • Exemple 1 : Renvoyez la position de départ de la 2ème occurrence d'une sous-chaîne correspondant au modèle 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 : Renvoyez la position de fin de la second occurrence d'une sous-chaîne correspondant au modèle o[[:alpha:]]{1} dans la chaîne i love www.taobao.com. La recherche commence à partir du third 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 a la valeur 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 le paramètre occurrence dans la chaîne source par la chaîne 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 la section Correspondance de chaîne 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 le paramètre 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éférences arrière au format \n pour insérer la sous-chaîne correspondant au nième groupe de capture 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, par exemple 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 indiquée par le paramètre occurrence est remplacée par la chaîne 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 qui n'existe pas, le résultat est indéfini.

  • Si le paramètre replace_string a la valeur NULL et qu'une correspondance pour le pattern est trouvée, la fonction renvoie NULL.

  • Si le paramètre replace_string a la valeur NULL et que le pattern ne correspond à rien, la fonction renvoie la chaîne d'origine.

  • Si les paramètres source, pattern ou occurrence ont la valeur NULL, la fonction renvoie NULL.

• Exemples

  • Exemple 1 : Remplacez 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 : Remplacez toutes les occurrences du modèle ([[:digit:]]{3})\\.([[:digit:]]{3})\\.([[:digit:]]{4}) dans la chaîne 123.456.7890 par la chaîne (\\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 : Remplacez 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 situés 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 a la valeur NULL. Exemple d'instruction :

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

  • Exemple 6 : Référencez un groupe qui n'existe pas. 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 qui correspond au pattern pour la occurrence-ième fois, en commençant à partir de la position start_position.

• Paramètres

  • source : Obligatoire. Type STRING. Chaîne à rechercher.

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

  • start_position : Facultatif. Constante BIGINT. La valeur doit être supérieure à 0. Si vous ne spécifiez pas ce paramètre, la valeur par défaut est 1, ce qui indique que la recherche commence à partir du 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 indique la première correspondance.

• Valeur de retour

  Renvoie une valeur STRING. La valeur de retour obéit aux règles suivantes :

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

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

  • Si les paramètres start_position ou occurrence ne sont pas de type BIGINT ou sont inférieurs ou égaux à 0, une erreur se produit.

  • Si les paramètres source, pattern, start_position ou occurrence ont la valeur NULL, la fonction renvoie NULL.

• Exemples

  • Exemple 1 : Renvoyez la sous-chaîne correspondant au modèle spécifié dans la chaîne 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 a la valeur 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étez 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 fonction d'extension MaxCompute V2.0.

• Paramètres

  • str : obligatoire. Type STRING. La chaîne source.

  • old : Obligatoire. La chaîne à comparer.

  • new : obligatoire. Type STRING. La 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 : Remplacez 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 au 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 : Inversez 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

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

• Paramètres

  • str1 : obligatoire. Type STRING. La 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) : La chaîne utilisée pour le remplissage.

• Valeur de retour

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

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

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

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

• Exemples

  • Exemple 1 : Complétez à droite la chaîne abcdefgh 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étez à droite la chaîne abcdefgh 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 les 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 dans trimChars sont traités comme un ensemble. La plus longue sous-chaîne à 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. La chaîne à rogner. Si l'entrée est de type BIGINT, DECIMAL, DOUBLE ou DATETIME, elle est implicitement convertie en STRING.

  • trimChars : facultatif. Type STRING. Les caractères à supprimer.

• Valeur de retour

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

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

  • Si str ou trimChars est NULL, renvoie NULL.

• Exemples

  • Exemple 1 : Supprimez 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 : Supprimez tous les caractères de fin de la chaîne yxTxyomxx qui appartiennent à 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 chaîne SOUNDEX.

• Paramètres

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

• Valeur de retour

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

• Exemples

  • Exemple 1 : Convertit la chaîne hello en 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 constituée de n espaces.

• Paramètres

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

• Valeur de retour

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

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

  • Si n est NULL, NULL est renvoyé.

• 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 finales. La valeur par défaut est true. Si vous définissez ce paramètre sur false, les chaînes vides finales sont conservées. Le type de données est BOOLEAN.

• Valeur de retour

  Renvoie une valeur de type ARRAY<STRING>.

• Exemple

  • Exemple 1 : Fractionnez une chaîne à l'aide d'une virgule.

    -- Returns ["a","b","c"].
    SELECT SPLIT('a,b,c', ',');

  • Exemple 2 : Gérez les cas où le séparateur n'existe pas.

    -- Returns ["a,b,c"].
    SELECT SPLIT('a,b,c', ':');

  • Exemple 3 : Gérez les séparateurs consécutifs. Cela crée un élément de chaîne vide.

    -- Returns ["a","","b"].
    SELECT SPLIT('a,,b', ',');

  • Exemple 4 : Utilisez un séparateur multi-caractères.

    -- Returns ["a","b","c"].
    SELECT SPLIT('a::b::c', '::');

  • Exemple 5 : Conservez les chaînes vides finales.

    -- By default, trailing empty strings are not returned.
    -- Returns ["a","b","c"].
    SELECT SPLIT('a,b,c,,', ',');
    
    -- Return trailing empty strings.
    -- Returns ["a","b","c","",""].
    SELECT SPLIT('a,b,c,,', ',', false);

  • Exemple 6 : Utilisez un caractère d'échappement ou un caractère spécial comme séparateur.

    -- Split by a line feed.
    -- Returns ["hello","world"].
    SELECT SPLIT('hello\nworld', '\n');  
    
    -- Split by a tab character.
    -- Returns ["a","b","c"].
    SELECT SPLIT('a\tb\tc', '\t');  
    
    -- Split by a carriage return.
    -- Returns ["line1","line2"].
    SELECT SPLIT('line1\rline2', '\r');  
    
    -- Escape a backslash.
    -- Returns ["a","b","c"].
    SELECT SPLIT('a\\b\\c', '\\\\');  

  • Exemple 7 : Gérez les entrées NULL.

    -- If any parameter is NULL, the function returns NULL.
    -- Returns NULL.
    SELECT SPLIT(NULL, ',');
    
    -- Returns NULL.
    SELECT SPLIT('a,b,c', NULL);
    
    -- Returns NULL.
    SELECT SPLIT('a,b,c', ',', NULL);

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 renvoie la sous-chaîne de la partie start à end (intervalle fermé).

• Paramètres

  • str : obligatoire. 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 seul caractère ou une chaîne).

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

  • end : une constante BIGINT supérieure ou égale à start. Ce paramètre spécifie le numéro du segment de fin à renvoyer. 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 renvoyé.

• description de la valeur de retour

  Renvoie une chaîne 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 renvoyée.

  • Si separator n'est pas trouvé dans str et que start = 1, la totalité de str est renvoyée. Si str est vide, une chaîne vide est renvoyée.

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

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

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

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

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

  • Si l'un des paramètres sauf separator est NULL, NULL est renvoyé.

• Exemples

  • Exemple 1 : Fractionnez la chaîne a,b,c,d à l'aide du délimiteur , et renvoyez 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 : L'un des paramètres d'entrée sauf 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

  Renvoie une sous-chaîne de str à partir de la position start_position sur une longueur de length.

• Paramètres

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

  • start_position : obligatoire. Type BIGINT. La position de départ par défaut est 1.

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

    • Versions des types de données 1,0 et 2,0 : si start_position=0, la fonction renvoie NULL.

  • length : facultatif. Type BIGINT. La longueur de la sous-chaîne doit être >0.

    Important

    • Si setproject odps.function.strictmode=false : une longueur<0 renvoie une chaîne vide.

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

• 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, DECIMAL, DOUBLE ou DATETIME, une erreur est renvoyée.

  • Si length n'est pas de type BIGINT ou est ≤0, une erreur est renvoyé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 renvoie NULL.

• Exemples

  • Exemple 1 : Renvoie une sous-chaîne de abc à partir d'une position spécifiée avec une longueur donné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

  Renvoie une sous-chaîne de str à partir de la position start_position sur 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 est basée sur 1. Si start_position vaut 0, une chaîne vide est renvoyé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 comptage se poursuit séquentiellement vers l'arrière.

  • 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 respecte les règles suivantes :

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

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

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

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

• Exemples

  • Exemple 1 : Cet exemple renvoie une sous-chaîne de abc à partir d'une position spécifiée avec une longueur donné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ù l'un des paramètres 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 fonction d'extension MaxCompute V2.0.

• Paramètres

  • str : obligatoire. Type STRING. Il s'agit de la chaîne source à partir de laquelle extraire la sous-chaîne.

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

  • count : obligatoire. Valeur INT qui spécifie la position du séparateur.

• Valeur de retour

  La fonction renvoie une valeur de type STRING. Si l'un des paramètres d'entrée est NULL, la fonction renvoie 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 : L'un des paramètres 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 les 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

  Renvoie 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 renvoie une erreur.

  • Si value est NULL, la fonction renvoie 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. Expression de type ARRAY, MAP ou STRUCT.

  Remarque

  Si l'expression d'entrée est de type STRUCT (struct<key1:value1, key2:value2>), tenez compte des 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 appartient cette value n'est pas incluse dans la chaîne JSON renvoyée. Par exemple, si value2 est null, key2:value2 n'est pas inclus dans la chaîne JSON renvoyée.

• Valeur de retour

  Une chaîne JSON est renvoyé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. 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 agit uniquement sur les caractères anglais.

• Valeur de retour

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

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

  • Si source est NULL, NULL est renvoyé.

• Exemples

  • Exemple 1 : Convertir les 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 équivalents majuscules.

• Paramètres

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

• Valeur de retour

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

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

  • Si source est NULL, NULL est renvoyé.

• Exemples

  • Exemple 1 : Convertir les 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 présent dans str2 par le caractère correspondant dans str3. Si aucune correspondance n'est trouvée, aucun remplacement n'a lieu. Cette fonction est une extension dans MaxCompute V2.0.

• Valeur de retour

  Renvoie une valeur STRING. Si l'un des paramètres d'entrée est NULL, la fonction renvoie NULL.

• Exemples

  • Exemple 1 : Remplacer chaque caractère de ababab présent 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 présent dans abab par le caractère correspondant dans cdefg. Exemple d'instruction :

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

  • Exemple 3 : L'un des paramètres 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 traite les caractères de trimChars comme un ensemble et supprime les plus longues sous-chaînes possibles composées uniquement de caractères de cet ensemble, à la fois à gauche et à droite de str.

• Paramètres

  • str : obligatoire. Type STRING. Chaîne à rogner. 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

  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 str ou trimChars est NULL, NULL est renvoyé.

• 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 appartenant à l'ensemble xy aux deux extrémités de la chaîne yxTxyomxx.

    -- 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 soulignement (_) restent inchangés.

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

  • Les séquences au format %xy sont converties en valeurs d'octets. 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 renvoie une valeur de type STRING encodée en UTF-8. Si le paramètre input ou encoding est NULL, la fonction renvoie 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 a–z et A–Z restent inchangées.

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

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

  • Tous les autres caractères sont convertis en valeurs d'octets à l'aide de l'encoding spécifié. Chaque octet apparaît sous la forme %xy, où xy est 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 non spécifié.

• Valeur de retour

  Renvoie une valeur STRING. Si input ou encoding est NULL, NULL est renvoyé.

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