MaxCompute:Présentation des fonctions de chaîne

Notes d'utilisation

Limitations

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

• TRIM/RTRIM/LTRIM : le paramètre trimChars ne supporte 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 présents dans str2.

• Paramètres

  str1 et str2 : obligatoires. Type STRING. Les deux chaînes doivent être des chaînes UTF-8 valides. Si des caractères 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 présents dans abcde. Exemple d'instruction :

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

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

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

CHR

• Syntaxe

  string chr(bigint <ascii>)

• description

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

• Paramètres

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

• Valeur de retour

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

  • Si la valeur ascii est hors 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> spécifie le type de données des éléments des tableaux. Les éléments peuvent être de n'importe quel type de données. Les éléments du tableau a et ceux du tableau b doivent être du même type de données. Les éléments null participent également à l'opération.

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

• Valeur de retour

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

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

• Exemples

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

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

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

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

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

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

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

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

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

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

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

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

CONCAT_WS

• Syntaxe

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

• description

  Renvoie une chaîne formée en concaténant toutes les chaînes d'entrée ou les éléments du tableau à l'aide du délimiteur spécifié. Cette fonction est une extension dans 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 renvoyée

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

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

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

• Exemples

  • Exemple 1 : concaténez les chaînes name et hanmeimei à l'aide de :. 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') à l'aide de :. Exemple d'instruction :

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

DECODE

• Syntaxe

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

• description

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

• Paramètres

  Parameter	Required	Description
  str	Yes	BINARY type. The string to decode.
  charset	Yes	STRING type. Encoding format. Valid values: UTF-8, UTF-16, UTF-16LE, UTF-16BE, ISO-8859-1, US-ASCII. Remarque ISO-8859-1 and US-ASCII encoding formats currently support only English characters, not Chinese.

• Valeur renvoyée

  Renvoie STRING. Si str ou charset est NULL, NULL est renvoyé.

• 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 en utilisant 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 renvoyée

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

• 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

  Parameter	Required	Description
  str1	Yes	STRING type. The string to search for.
  str2	Yes	STRING type. The string separated by delimiter.
  delimiter	No	STRING constant. Default is comma (,). The delimiter can be a single character or a string.

• Valeur renvoyée

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

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

  • Si str1 ou str2 est NULL, NULL est renvoyé.

• 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 un trait 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 que vous souhaitez conserver. Ce paramètre peut également être exprimé dans un format similaire à #,###,###.##. Le nombre de décimales renvoyées varie en fonction de la valeur de ce paramètre.

• Valeur renvoyée

  Une valeur de type STRING est renvoyée. La valeur renvoyée varie selon les règles suivantes :

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

  • Si la valeur de expr2 est 0, la valeur renvoyée contient uniquement la partie entière et ne contient ni point décimal ni partie décimale.

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

  • Si expr1 ou expr2 est vide ou défini sur null, null est renvoyé.

• 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

  FROM_CHARSET convertit les données binaires encodées autres qu'en 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 spécifiées par source. Valeurs valides : UTF-8, UTF-16, UTF-16LE, UTF-16BE, ISO-8859-1, US-ASCII, GB2312, GBK et GB18030.

  • mode : facultatif. Valeur de type STRING. Ce paramètre spécifie le mode de traitement si un caractère ne peut pas être converti lorsque la fonction FROM_CHARSET convertit les données binaires spécifiées par source en une chaîne dans le format d'encodage spécifié. 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 continue d'exécuter la commande.

• Valeur renvoyée

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

  • Si un paramètre d'entrée est NULL, renvoie NULL.

  • Si un paramètre d'entrée est une chaîne vide, renvoie une erreur.

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

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

FROM_JSON

• Syntaxe

  from_json(<jsonStr>, <schema>)

• description

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

• Paramètres

  • jsonStr : obligatoire. 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 être dans le même format que celui de 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.

    JSON data type	MaxCompute data type
    OBJECT	STRUCT, MAP, and STRING
    ARRAY	ARRAY and STRING
    NUMBER	TINYINT, SMALLINT, INT, BIGINT, FLOAT, DOUBLE, DECIMAL, and STRING
    BOOLEAN	BOOLEAN and STRING
    STRING	STRING, CHAR, VARCHAR, BINARY, DATE, and DATETIME
    NULL	All types

    Remarque

    La chaîne JSON des types OBJECT et ARRAY est analysée 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 en 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 du type de données JSON en fonction d'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 reprises 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 table définie par l'utilisateur (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 du 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 respecter les 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 du 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.

    • * : un caractère générique pour []. Il renvoie le tableau entier. L'astérisque (*) ne peut pas être échappé.

• Valeur de retour

  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 présente un format non valide, 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 n'est pas valide, 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 basculez vers le 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. -- Returns 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. -- Returns NULL. SELECT GET_JSON_OBJECT('{"a":"1","a":"2"}', '$.a');
    Ordre de tri de sortie	La sortie est triée dans le même ordre que la chaîne JSON d'origine. -- Returns {"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. -- Returns {"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.

  • Utilisez l'exemple suivant pour déterminer quel comportement la fonction GET_JSON_OBJECT utilise 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 de votre projet vers la conservation des 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');

  Exemple 2 : Un json_path non valide 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;

  Exemple 4 : Utiliser [''] 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 non valide

  -- 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 casse de titre 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 de retour

  Renvoie une chaîne dont la première lettre de chaque mot est 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 à rechercher. Si l'entrée est de type BIGINT, DOUBLE, DECIMAL ou DATETIME, elle est implicitement convertie en STRING. Les autres types renvoient une erreur.

  • str2 : obligatoire. Type STRING. Sous-chaîne à faire correspondre. Si l'entrée est de type BIGINT, DOUBLE, DECIMAL ou DATETIME, elle est implicitement convertie en STRING. Les autres types renvoient 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, soit la position 1. Si start_position est une valeur négative, la recherche commence à compter à rebours depuis la fin de la chaîne, où le dernier caractère est à 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 niè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 un type BIGINT. La valeur de retour suit ces règles :

  • Si str1 ne contient pas str2, renvoie 0.

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

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

• Exemples

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

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

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

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

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

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

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

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

IS_ENCODING

• Syntaxe

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

• Description

  Détermine si la chaîne d'entrée str peut être convertie du jeu de caractères from_encoding vers to_encoding. Également utilisé pour détecter le texte corrompu — 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 un type BOOLEAN. La valeur de retour suit ces règles :

  • Si str est converti avec succès, renvoie True ; sinon 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 : facultatif. Type STRING. Chaînes de délimitation pour la division. Si elles ne sont pas spécifiées, 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 un 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 : Diviser la chaîne 0:1/;1:2 en paires clé-valeur et renvoyer 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 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 : Diviser la chaîne “\;decreaseStore:1\;xcard:1\;isB2C:1\;tf:21910\;cart:1\;shipping:2\;pf:0\;market:shoes\;instPayAmount:0\;” en utilisant “\;” comme split1 et ":" comme split2, puis renvoyer 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 : obligatoire. 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 un 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 un 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 : Calculer 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 un 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.

• Exemples

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

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

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

    -- Returns NULL.
    select lengthb(null);

LOCATE

• Syntaxe

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

• description

  Trouve la position de la sous-chaîne substr dans str. Utilisez start_pos pour spécifier la position de départ (comptage à partir de 1).

• Paramètres

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

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

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

• Valeur de retour

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

  • Si str ne contient pas substr, renvoie 0.

  • Si str ou substr est NULL, renvoie NULL.

  • Si start_pos est NULL, renvoie 0.

• Exemples

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

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

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

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

  • Exemple 3 : start_pos est NULL. Instruction d'exemple :

    -- 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 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 un type STRING. La valeur de retour suit ces règles :

  • 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 un paramètre d'entrée est NULL, renvoie NULL.

• Exemples

  • Exemple 1 : Utiliser la chaîne 12 pour remplir à gauche la chaîne abcdefgh jusqu'à 10 caractères. La commande d'exemple est la suivante.

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

  • Exemple 2 : Utiliser la chaîne 12 pour remplir à gauche la chaîne abcdefgh jusqu'à une longueur de 5 caractères. Voici une commande d'exemple.

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

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

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

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

    -- 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 la chaîne str :

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

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

• Paramètres

  • str : obligatoire. Type STRING. Chaîne à traiter. 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 le paramètre str n'est pas de type STRING, BIGINT, DOUBLE, DECIMAL ou DATETIME, une erreur est renvoyée.

  • Si le paramètre str ou trimChars a la valeur NULL, la fonction renvoie NULL.

• Exemples

  • Exemple 1 : Suppression des espaces de début dans la chaîne yxTxyomxx . Requêtes d'exemple :

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

  • Exemple 2 : Suppression de 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 a la valeur NULL. Requêtes d'exemple :

    -- 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 le paramètre str n'est pas de type STRING, BIGINT, DOUBLE, DECIMAL ou DATETIME, une erreur est renvoyée.

  • Si le paramètre str a la valeur NULL, la fonction renvoie NULL.

• Exemples

  • Exemple 1 : Calcul du hachage MD5 de la chaîne Tech on the net. Requête d'exemple :

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

  • Exemple 2 : Le paramètre d'entrée a la valeur NULL. Requête d'exemple :

    -- 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 le paramètre part.

• Paramètres

  • url : obligatoire. Type STRING. Lien URL. Les URL invalides génèrent une erreur.

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

  • key : facultatif. Lorsque le paramètre part est défini sur QUERY, renvoie la valeur correspondant à la clé key.

• Description de la valeur de retour

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

  • Si le paramètre url, part ou key a la valeur NULL, la fonction renvoie NULL.

  • Si la valeur du paramètre part est invalide, 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 permet d'extraire plusieurs clés simultanément avec de meilleures performances.

• Paramètres

  • url : obligatoire. Type STRING. Lien URL. Les URL invalides génèrent une erreur.

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

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

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

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

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

    • PROTOCOL : type de protocole.

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

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

    • USERINFO : informations d'authentification utilisateur.

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

    Insensible à la casse. Les valeurs invalides génèrent une erreur.

• Description de la valeur de retour

  Renvoie une valeur de type STRING. Si le paramètre url ou key a la valeur NULL, une erreur est renvoyée.

• Exemple

  Extraction des chaînes pour chaque clé à partir de l'URL file://username:password@example.com:8042/over/there/index.dtb?type=animal&name=narwhal#nose. Requête d'exemple :

  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 qui correspondent au pattern spécifié, en commençant à la position start_position.

• Paramètres

  • source : obligatoire. Type STRING. Chaîne à rechercher. Les autres types génèrent 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 la section Correspondance de chaîne RLIKE. Un pattern vide ou invalide génère une erreur.

  • start_position : facultatif. Constante de type BIGINT. La valeur de ce paramètre doit être supérieure à 0. Si la valeur est d'un autre type de données ou inférieure ou égale à 0, une erreur est renvoyée. 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, renvoie 0.

  • Si le paramètre source, pattern ou start_position a la valeur NULL, la fonction renvoie NULL.

• Exemples

  • Exemple 1 : Comptage des sous-chaînes correspondantes dans abababc à partir d'une position spécifiée. Requêtes d'exemple :

    -- 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 a la valeur NULL. Requête d'exemple :

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

  • Exemple 3 : Comptage des occurrences du caractère : dans la chaîne JSON {"account_id":123456789,"account_name":"allen","location":"hangzhou","bill":100}. Requête d'exemple :

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

REGEXP_EXTRACT

• Syntaxe

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

  Remarque

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

• Description

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

• Paramètres

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

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

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

  Remarque

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

• Valeur de retour

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

  • Si le paramètre 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 le paramètre source, pattern ou groupid a 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 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 faire correspondre le 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'ID group_id est 1 est utilisé pour faire correspondre le modèle. 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 qui correspondent 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);

    Voici le résultat.

    +------------+
    | _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 le source, à partir de la position start_position.

• Paramètres

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

  • pattern : obligatoire. Le 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 renvoie une erreur.

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

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

  • return_option : facultatif. La 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 le 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, NULL est renvoyé.

• Exemples

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

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

  • Exemple 2 : Renvoyez la position de fin de la second occurrence d'une sous-chaîne correspondant à o[[:alpha:]]{1} dans la chaîne i love www.taobao.com. La recherche commence au 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 est NULL. Exemple d'instruction :

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

REGEXP_REPLACE

• Syntaxe

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

  Remarque

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

• Description

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

• Paramètres

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

  • pattern : obligatoire. Une constante STRING ou une 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. Une valeur de type STRING. Il s'agit de la chaîne qui remplace la sous-chaîne correspondant au pattern.

    Remarque

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

    • Le 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 la sous-chaîne entière correspondant au pattern. Vous devez échapper les barres obliques inverses, telles que \\1, ou utiliser une chaîne brute, telle que R'(\1)'.

  • occurrence : facultatif. Une 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 occurrence est remplacée par replace_string. Si ce paramètre est défini sur 0, toutes les sous-chaînes correspondant au modèle spécifié sont remplacées. S'il est d'un autre type de données ou inférieur à 0, une erreur est renvoyée. Valeur par défaut : 0.

• Valeur de retour

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

  • Si vous référencez un groupe qui n'existe pas, le résultat est indéfini.

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

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

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

• Exemples

  • Exemple 1 : Remplacez les sous-chaînes selon les 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 correspondances pour le modèle ([[:digit:]]{3})\\.([[:digit:]]{3})\\.([[:digit:]]{4}) dans la chaîne 123.456.7890 par (\\1)\\2-\\3. Exemple d'instruction :

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

  • Exemple 3 : Remplacez les sous-chaînes correspondant à un modèle dans la chaîne abcd selon les 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 où les valeurs sont au format www.simple@xxx.com. La partie xxx est unique pour chaque ligne. Cet exemple remplace tous les caractères après www. Exemple d'instruction :

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

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

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

  • Exemple 6 : Réfé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 à partir de la position start_position dans la chaîne source qui correspond au pattern pour la occurrence-ième fois.

• Paramètres

  • source : obligatoire. Type STRING. La chaîne à rechercher.

  • pattern : obligatoire. Constante STRING ou expression régulière. Le 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 chaîne STRING. La valeur de retour suit ces règles :

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

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

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

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

• Exemples

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

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

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

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

REPEAT

• Syntaxe

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

• Description

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

• Paramètres

  • str : obligatoire. Type STRING. Si l'entrée est 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 ces règles :

  • 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 : Un paramètre 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 le str modifié. Si aucune correspondance n'est trouvée, le str d'origine est renvoyé. 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 un paramètre 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. Un paramètre de type STRING. Si l'entrée est une valeur BIGINT, DOUBLE, DECIMAL ou DATETIME, elle est implicitement convertie en type STRING.

• Valeur de retour

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

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

  • Si str est NULL, NULL est renvoyé.

• Exemples

  • Exemple 1 : 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 à 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 à remplir à droite.

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

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

• Valeur de retour

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

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

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

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

• Exemples

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

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

  • Exemple 2 : Ajoutez un remplissage à droite à la chaîne abcdefgh jusqu'à atteindre 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 0. Exemple d'instruction :

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

  • Exemple 4 : Un paramètre 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 situés à l'extrémité droite de la chaîne str :

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

  • Si le paramètre trimChars est spécifié, les caractères qu'il contient sont traités comme un ensemble. La plus longue sous-chaîne située à l'extrémité droite de str et composée exclusivement de caractères appartenant à l'ensemble trimChars est supprimée.

• Paramètres

  • str : obligatoire. Type STRING. Chaîne à traiter. Si la valeur d'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. Le résultat 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 fin de la chaîne yxTxyomxx . Requêtes d'exemple :

    -- 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. Requêtes d'exemple :

    -- 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. Chaîne à convertir. Ce paramètre est de type STRING. Cette fonction constitue 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 : convertissez la chaîne hello en chaîne SOUNDEX. Requête d'exemple :

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

  • Exemple 2 : le paramètre d'entrée est NULL. Requête d'exemple :

    -- Returns NULL.
    select soundex(null);

SPACE

• Syntaxe

  string space(bigint <n>)

• description

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

• Paramètres

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

• Valeur de retour

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

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

  • Si n est NULL, la fonction renvoie NULL.

• Exemple

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

SPLIT

• Syntaxe

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

• Paramètres

  • source : obligatoire. Chaîne à fractionner. Le type de données est STRING.

  • delimiter : obligatoire. 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 est absent.

    -- 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 composé de plusieurs 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 allant de la partie start à la partie end (intervalle fermé).

• Paramètres

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

  • separator : obligatoire. Constante de type STRING. Délimiteur (caractère unique ou chaîne).

  • start : obligatoire. Constante de type BIGINT, supérieure à 0. Numéro de la partie de départ (comptage à partir de 1).

  • end : constante de type BIGINT supérieure ou égale à start. Ce paramètre spécifie le numéro du segment final à renvoyer. S'il n'est pas spécifié, sa valeur par défaut correspond à celle de start et seul le segment indiqué par start est renvoyé.

• description de la valeur de retour

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

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

  • Si le separator est introuvable 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 le separator est vide, la chaîne str d'origine est renvoyée.

  • Si end dépasse le nombre de parties, la sous-chaîne allant de start jusqu'à 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 le separator n'est pas une constante de type STRING, une erreur est renvoyée.

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

  • Si l'un des paramètres autres que separator est NULL, la fonction renvoie NULL.

• Exemples

  • Exemple 1 : fractionnez la chaîne a,b,c,d à l'aide du délimiteur , et renvoyez les parties spécifiées. Requêtes d'exemple :

    -- 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. Requête d'exemple :

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

  • Exemple 3 : le separator est introuvable dans str. Requêtes d'exemple :

    -- 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 : le separator est vide. Requête d'exemple :

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

  • Exemple 5 : end dépasse le nombre réel de parties. Requête d'exemple :

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

  • Exemple 6 : l'un des paramètres d'entrée autres que separator est NULL. Requête d'exemple :

    -- 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 commençant à la position start_position et d'une longueur de length.

• Paramètres

  • str : obligatoire. Type STRING. Si la valeur d'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 compatible avec Hive : si start_position=0, le comportement est identique à celui de la position 1.

    • Versions 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 valeur vide.

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

• Valeur de retour

  Renvoie une valeur de type STRING. Le résultat obéit aux 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 le paramètre 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 : renvoyez une sous-chaîne de abc à partir de la position spécifiée et avec la longueur indiquée. Requêtes d'exemple :

    -- 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. Requête d'exemple :

    -- 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 commençant à la position start_position et d'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 indexée à partir de 1. Si start_position vaut 0, une chaîne vide est renvoyée. Si start_position est négatif, 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 et avec une longueur donnée. Requêtes d'exemple :

    -- 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. Requête d'exemple :

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

SUBSTRING_INDEX

• Syntaxe

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

• description

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

• Paramètres

  • str : obligatoire. Type STRING. Chaîne source de l'extraction.

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

  • count : obligatoire. Valeur de type 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 : extrayez une sous-chaîne à partir de la chaîne https://www.alibabacloud.com. Requêtes d'exemple :

    -- 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. Requête d'exemple :

    -- 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 renvoyée

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

  • 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. Une 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 une 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 renvoyée

  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. Une valeur de type STRING. Si l'entrée est une valeur BIGINT, DOUBLE, DECIMAL ou DATETIME, elle est implicitement convertie au type STRING. Cette fonction opère uniquement sur les caractères anglais.

• Valeur renvoyée

  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 caractères majuscules correspondants.

• Paramètres

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

• Valeur renvoyée

  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 dans str1 qui apparaît 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 renvoyée

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

• Exemples

  • Exemple 1 : Remplacer chaque caractère dans ababab qui apparaît 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 dans ababab qui apparaît dans abab par le caractère correspondant dans cdefg. Exemple d'instruction :

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

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

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

TRIM

• Syntaxe

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

• Description

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

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

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

• Paramètres

  • str : obligatoire. Type STRING. La chaîne à rogner. Si l'entrée est BIGINT, DECIMAL, DOUBLE ou DATETIME, elle est implicitement convertie en STRING.

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

• Valeur renvoyée

  Renvoie le type STRING. La valeur renvoyée suit ces règles :

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

  • Si str ou trimChars est NULL, renvoie NULL.

• Exemples

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

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

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

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

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

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

URL_DECODE

• Syntaxe

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

• Description

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

  • 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 (+) se convertit 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 renvoyée

  Cette fonction renvoie un type STRING encodé 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 se convertissent 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. La chaîne à entrer.

  • encoding : facultatif. Le format d'encodage. Les formats pris en charge incluent GBK et UTF-8. La valeur par défaut est UTF-8 s'il n'est pas spécifié.

• Valeur renvoyée

  Renvoie une chaîne STRING. Si input ou encoding est NULL, renvoie NULL.

• Exemple

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

Références

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