Tous les produits
Search

Ce produit

    AnalyticDB:String functions

    Centre de documentation

    AnalyticDB:String functions

    Dernière mise à jour :Aug 10, 2026

    AnalyticDB for MySQL prend en charge un ensemble de fonctions de chaîne pour les tâches courantes de traitement des chaînes : conversion de la casse, extraction de sous-chaînes, recherche de motifs, encodage et décodage des données, etc. Cette rubrique décrit la syntaxe et l'utilisation de chaque fonction, avec des exemples.

    Fonctions abordées dans cette rubrique :

    Catégorie Fonctions
    Longueur et informations sur les caractères ASCII, BIT_LENGTH, CHAR_LENGTH ou CHARACTER_LENGTH, LENGTH ou OCTET_LENGTH, ORD
    Conversion de la casse LOWER ou LCASE, UPPER ou UCASE
    Concaténation et mise en forme CONCAT, CONCAT_WS, FORMAT, REPEAT, SPACE
    Sous-chaînes et extraction LEFT, MID, RIGHT, SUBSTR ou SUBSTRING, SUBSTRING_INDEX
    Recherche et position FIELD, FIND_IN_SET, INSTR, LOCATE, POSITION
    Correspondance de motif LIKE, RLIKE ou REGEXP
    Remplissage et rognage LPAD, LTRIM, RPAD, RTRIM, TRIM
    Fractionnement SPLIT, SPLIT_PART, SPLIT_TO_MAP
    Encodage et décodage BIN, CHAR, FROM_BASE64, FROM_UTF8, HEX, OCT, TO_BASE64, TO_UTF8, UNHEX
    Comparaison STRCMP
    Opérations sur les ensembles ELT, EXPORT_SET, MAKE_SET
    Remplacement et inversion REPLACE, REVERSE
    Chiffrement et hachage ENCRYPT, MD5_MUR

    ASCII

    ascii(str)

    Renvoie la valeur décimale ASCII du caractère le plus à gauche de str.

    Paramètre Type Description
    str VARCHAR Chaîne d'entrée ou caractère unique

    Type de retour : BIGINT

    Exemples :

    SELECT ascii('2');
    +------------+
| ascii('2') |
+------------+
|         50 |
+------------+
    SELECT ascii('dx');
    +-------------+
| ascii('dx') |
+-------------+
|         100 |
+-------------+

    BIN

    bin(N)

    Renvoie la représentation binaire sous forme de chaîne de N.

    Paramètre Type Description
    N BIGINT Entier à convertir

    Type de retour : VARCHAR

    Notes d'utilisation :

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

    Exemple :

    SELECT bin(12);
    +---------+
| bin(12) |
+---------+
| 1100    |
+---------+

    BIT_LENGTH

    bit_length(str)

    Renvoie la longueur de str en bits.

    Paramètre Type Description
    str VARCHAR Chaîne d'entrée

    Type de retour : BIGINT

    Exemples :

    SELECT bit_length('text');
    +--------------------+
| bit_length('text') |
+--------------------+
|                 32 |
+--------------------+
    SELECT bit_length('China');
    +---------------------+
| bit_length('China') |
+---------------------+
|                  40 |
+---------------------+

    CHAR

    char(N1, N2, ...)

    Renvoie une chaîne composée des caractères correspondant aux codes ASCII décimaux de N1, N2, etc.

    Paramètre Type Description
    N1, N2, ... BIGINT Un ou plusieurs codes ASCII entiers

    Type de retour : VARBINARY

    Exemple :

    SELECT char(97,110,97,108,121,116,105,99,100,98);
    +-------------------------------------------+
| char(97,110,97,108,121,116,105,99,100,98) |
+-------------------------------------------+
| analyticdb                                |
+-------------------------------------------+

    CHAR_LENGTH ou CHARACTER_LENGTH

    char_length(str)
character_length(str)

    Renvoie la longueur de str en caractères.

    Paramètre Type Description
    str VARCHAR Chaîne d'entrée

    Type de retour : BIGINT

    Notes d'utilisation :

    • Chaque caractère chinois compte pour 1.

    Exemples :

    SELECT char_length('China');
    +----------------------+
| char_length('China') |
+----------------------+
|                    5 |
+----------------------+
    SELECT char_length('abc');
    +--------------------+
| char_length('abc') |
+--------------------+
|                  3 |
+--------------------+

    CONCAT

    concat(str1, ..., strN)

    Concatène plusieurs chaînes en une seule.

    Paramètre Type Description
    str1, ..., strN VARCHAR Deux chaînes ou plus à concaténer

    Type de retour : VARCHAR

    Notes d'utilisation :

    • Si l'un des arguments est NULL, la valeur de retour est NULL.

    Exemples :

    SELECT concat('aliyun', ', ', 'analyticdb');
    +--------------------------------------+
| concat('aliyun', ', ', 'analyticdb') |
+--------------------------------------+
| aliyun, analyticdb                   |
+--------------------------------------+
    SELECT concat('abc', null, 'def');
    +--------------------------+
| concat('abc',null,'def') |
+--------------------------+
| NULL                     |
+--------------------------+

    CONCAT_WS

    concat_ws(separator, str1, ..., strN)

    Concatène plusieurs chaînes à l'aide d'un séparateur spécifié. Les valeurs NULL parmi les arguments de type chaîne sont ignorées.

    Paramètre Type Description
    separator VARCHAR Délimiteur inséré entre chaque chaîne
    str1, ..., strN VARCHAR Chaînes à concaténer

    Type de retour : VARCHAR

    Notes d'utilisation :

    • Les arguments de type chaîne NULL sont ignorés : ils ne génèrent ni double séparateur ni valeur vide dans la sortie.

    Exemples :

    SELECT concat_ws(',', 'First name', 'Second name', 'Last Name') AS result;
    +----------------------------------+
| result                           |
+----------------------------------+
| First name,Second name,Last Name |
+----------------------------------+
    SELECT concat_ws(',', 'First name', NULL, 'Last Name') AS result;
    +----------------------+
| result               |
+----------------------+
| First name,Last Name |
+----------------------+

    ELT

    elt(N, str1, ..., strN)

    Renvoie la N-ième chaîne de la liste.

    Paramètre Type Description
    N BIGINT Index basé sur 1 dans la liste de chaînes
    str1, ..., strN VARCHAR Liste de chaînes

    Type de retour : VARCHAR

    Notes d'utilisation :

    • Si N < 1 ou si N est supérieur au nombre d'arguments de type chaîne, la valeur NULL est renvoyée.

    Exemple :

    SELECT elt(4, 'Aa', 'Bb', 'Cc', 'Dd');
    +--------------------------------+
| elt(4, 'Aa', 'Bb', 'Cc', 'Dd') |
+--------------------------------+
| Dd                             |
+--------------------------------+

    ENCRYPT

    encrypt(x, y)

    Chiffre x en utilisant y comme valeur de sel.

    Paramètre Type Description
    x VARBINARY Chaîne à chiffrer
    y VARCHAR Valeur de sel

    Type de retour : VARBINARY

    Exemple :

    SELECT encrypt('abdABC123', 'key');
    +--------------------------------------------------------+
| encrypt('abdABC123','key')                             |
+--------------------------------------------------------+
| 0x6B657A617A6D63496F2E614377                           |
+--------------------------------------------------------+

    EXPORT_SET

    export_set(bits, onstr, offstr [, separator [, number_of_bits]])

    Convertit bits en représentation binaire et renvoie une chaîne construite en remplaçant chaque position de bit par onstr (pour le bit 1) ou offstr (pour le bit 0), séparés par separator. Les bits sont vérifiés de droite à gauche.

    Paramètre Type Description
    bits BIGINT Entier à convertir en binaire
    onstr VARCHAR Chaîne à utiliser pour la valeur de bit 1
    offstr VARCHAR Chaîne à utiliser pour la valeur de bit 0
    separator VARCHAR (Facultatif) Délimiteur entre les valeurs de sortie
    number_of_bits BIGINT (Facultatif) Nombre de bits à vérifier, de droite à gauche. La valeur par défaut est 64

    Type de retour : VARCHAR

    Notes d'utilisation :

    • Si number_of_bits est supérieur à 64, il est limité à 64.

    • Si number_of_bits est égal à -1, la valeur par défaut 64 est utilisée.

    Exemples :

    Convertissez 5 en binaire et vérifiez les deux bits les plus à droite. Remplacez 1 par a et 0 par b, séparés par des virgules :

    SELECT export_set(5, 'a', 'b', ',', 2);
    +-----------------------------+
| export_set(5,'a','b',',',2) |
+-----------------------------+
| a,b                         |
+-----------------------------+

    Convertissez 6 en binaire et vérifiez les 10 bits les plus à droite. Remplacez 1 par 1 et 0 par 0, séparés par des virgules :

    SELECT export_set(6, '1', '0', ',', 10);
    +------------------------------+
| export_set(6,'1','0',',',10) |
+------------------------------+
| 0,1,1,0,0,0,0,0,0,0          |
+------------------------------+

    FIELD

    FIELD(str, str1, str2, ..., strN)

    Renvoie la position de str dans la liste str1, str2, ..., strN.

    Paramètre Type Description
    str VARCHAR Chaîne à rechercher
    str1, ..., strN VARCHAR Liste de chaînes dans laquelle effectuer la recherche

    Type de retour : BIGINT

    Notes d'utilisation :

    • Renvoie 0 si str n'est pas trouvé dans la liste.

    Exemple :

    SELECT FIELD('Bb', 'Aa', 'Bb', 'Cc', 'Dd', 'Ff');
    +-------------------------------------------+
| FIELD('Bb', 'Aa', 'Bb', 'Cc', 'Dd', 'Ff') |
+-------------------------------------------+
|                                         2 |
+-------------------------------------------+

    FIND_IN_SET

    find_in_set(str, strlist)

    Renvoie la position de str dans la liste séparée par des virgules strlist.

    Paramètre Type Description
    str VARCHAR Chaîne à rechercher
    strlist VARCHAR Liste de chaînes séparées par des virgules

    Type de retour : BIGINT

    Notes d'utilisation :

    • Renvoie 0 si str n'est pas trouvé dans strlist, ou si strlist est une chaîne vide.

    • Renvoie NULL si str ou strlist est NULL.

    Exemple :

    SELECT find_in_set('b', 'a,b,c,d');
    +----------------------------+
| find_in_set('b','a,b,c,d') |
+----------------------------+
|                          2 |
+----------------------------+

    FORMAT

    format(X, D)

    Met en forme le nombre X selon le style #,###,###.##, arrondi à D décimales, et renvoie le résultat sous forme de chaîne.

    Paramètre Type Description
    X DOUBLE Nombre à mettre en forme
    D BIGINT Nombre de décimales

    Type de retour : VARCHAR

    Notes d'utilisation :

    • Si D est égal à 0, le résultat ne contient ni point décimal ni partie fractionnaire.

    Exemple :

    SELECT format(12332.123456, 4) AS result1,
       format(12332.1, 4)    AS result2,
       format(12332.2, 0)    AS result3;
    +-------------+-------------+---------+
| result1     | result2     | result3 |
+-------------+-------------+---------+
| 12,332.1235 | 12,332.1000 | 12,332  |
+-------------+-------------+---------+

    FROM_BASE64

    from_base64(x)

    Décode une chaîne encodée en Base64 et renvoie le résultat décodé.

    Paramètre Type Description
    x VARBINARY ou VARCHAR Entrée encodée en Base64

    Type de retour : VARBINARY

    Notes d'utilisation :

    La valeur de retour est de type VARBINARY. Pour obtenir un résultat de type VARCHAR, convertissez-le à l'aide de l'une des méthodes suivantes :

    • AnalyticDB for MySQL V3.1.4 ou version ultérieure : Utilisez CAST AS VARCHAR. Pour plus d'informations, consultez la section Fonctions CAST.

    • Antérieur à la version V3.1.4 : Utilisez la fonction FROM_UTF8. Pour plus d'informations, consultez la section FROM_UTF8.

    Exemples :

    L'entrée est une chaîne VARCHAR :

    SELECT from_base64('Q2hpbmE=');
    +--------------------------------------------------+
| from_base64('Q2hpbmE=')                          |
+--------------------------------------------------+
| 0x4368696E61                                     |
+--------------------------------------------------+

    Pour obtenir la valeur VARCHAR d'origine, convertissez le résultat :

    SELECT cast(from_base64('Q2hpbmE=') AS varchar);
    +------------------------------------------+
| cast(from_base64('Q2hpbmE=') AS varchar) |
+------------------------------------------+
| China                                    |
+------------------------------------------+

    L'entrée est une valeur VARBINARY :

    SELECT from_base64(cast(to_base64('China') AS varbinary));
    +--------------------------------------------------------------------------------------------------------+
| from_base64(cast(to_base64('China') AS varbinary))                                                     |
+--------------------------------------------------------------------------------------------------------+
| 0x4368696E61                                                                                           |
+--------------------------------------------------------------------------------------------------------+

    FROM_UTF8

    from_utf8(x)
from_utf8(x, y)

    Décode une valeur binaire encodée en UTF-8 et renvoie une chaîne VARCHAR.

    • from_utf8(x) — Décode x et renvoie le résultat décodé.

    • from_utf8(x, y) — Décode x en remplaçant toutes les séquences d'octets non valides par y.

    Paramètre Type Description
    x VARBINARY Entrée encodée en UTF-8 à décoder
    y VARCHAR ou BIGINT (Facultatif) Caractère de remplacement pour les octets non valides. Accepte le caractère lui-même (par exemple, #) ou son code ASCII (par exemple, 35). La valeur par défaut est une chaîne vide si ce paramètre est omis

    Type de retour : VARCHAR

    Exemples :

    Décoder une chaîne encodée en UTF-8 valide :

    SELECT from_utf8(to_utf8('hello'));
    +-----------------------------+
| from_utf8(to_utf8('hello')) |
+-----------------------------+
| hello                       |
+-----------------------------+

    Décoder une valeur non encodée en UTF-8 (les octets non valides sont remplacés par une chaîne vide par défaut) :

    SELECT from_utf8(unhex('58BF'));
    +--------------------------+
| from_utf8(unhex('58BF')) |
+--------------------------+
| X                       |
+--------------------------+

    Remplacer les octets non valides par # :

    SELECT from_utf8(unhex('58BF'), '#');
    +-------------------------------+
| from_utf8(unhex('58BF'), '#') |
+-------------------------------+
| X#                            |
+-------------------------------+

    Remplacer les octets non valides à l'aide du code ASCII 35 (équivalent à #) :

    SELECT from_utf8(unhex('58BF'), '35');
    +-------------------------------+
| from_utf8(unhex('58BF'), '35') |
+-------------------------------+
| X#                            |
+-------------------------------+

    HEX

    hex(x)

    Renvoie la représentation hexadécimale sous forme de chaîne de x.

    Paramètre Type Description
    x BIGINT ou VARCHAR Entier ou chaîne à convertir

    Type de retour : VARCHAR

    Exemples :

    Entrée entière :

    SELECT hex(16);
    +---------+
| hex(16) |
+---------+
| 10      |
+---------+

    Entrée de type chaîne :

    SELECT hex('16');
    +-----------+
| hex('16') |
+-----------+
| 3136      |
+-----------+

    INSTR

    instr(str, substr)

    Renvoie la position de la première occurrence de substr dans str.

    Paramètre Type Description
    str VARCHAR Chaîne dans laquelle effectuer la recherche
    substr VARCHAR Sous-chaîne à rechercher

    Type de retour : BIGINT

    Exemple :

    SELECT instr('foobarbar', 'bar');
    +---------------------------+
| instr('foobarbar', 'bar') |
+---------------------------+
|                         4 |
+---------------------------+

    LEFT

    LEFT(str, len)

    Renvoie les len caractères les plus à gauche de str.

    Paramètre Type Description
    str VARCHAR Chaîne d'entrée
    len BIGINT Nombre de caractères à renvoyer

    Type de retour : VARCHAR

    Notes d'utilisation :

    • Renvoie NULL si str ou len est NULL.

    Exemple :

    SELECT LEFT('foobarbar', 5);
    +----------------------+
| LEFT('foobarbar', 5) |
+----------------------+
| fooba                |
+----------------------+

    LENGTH ou OCTET_LENGTH

    length(str)
octet_length(str)

    Renvoie la longueur de str.

    Paramètre Type Description
    str VARCHAR Chaîne d'entrée

    Type de retour : BIGINT

    Exemple :

    SELECT length('aliyun');
    +------------------+
| length('aliyun') |
+------------------+
|                6 |
+------------------+

    LIKE

    expression [NOT] LIKE pattern [ESCAPE 'escape_char']

    Compare expression au pattern. Renvoie 1 en cas de correspondance et 0 sinon.

    Paramètre Type Description
    expression VARCHAR Chaîne à comparer
    pattern VARCHAR Motif avec caractères génériques. Utilisez % pour correspondre à n'importe quelle séquence de caractères et _ pour correspondre à un seul caractère
    escape_char VARCHAR (Facultatif) Caractère d'échappement qui traite le % ou le _ suivant comme un caractère littéral plutôt que comme un caractère générique

    Type de retour : BIGINT

    Exemples :

    Correspondance basique avec caractères génériques :

    SELECT 'David!' LIKE 'David_'   AS result1,
       'David!' NOT LIKE 'David_' AS result2,
       'David!' LIKE '%D%v%'    AS result3;
    +---------+---------+---------+
| result1 | result2 | result3 |
+---------+---------+---------+
|       1 |       0 |       1 |
+---------+---------+---------+

    Utilisation d'un caractère d'échappement pour faire correspondre un trait de soulignement littéral :

    SELECT 'David_' LIKE 'David|_' ESCAPE '|';
    +----------------------------------+
| David_' LIKE 'David|_' ESCAPE '| |
+----------------------------------+
|                                1 |
+----------------------------------+

    LOCATE

    locate(substr, str)
locate(substr, str, pos)

    Renvoie la position de la première occurrence de substr dans str. Vous pouvez éventuellement démarrer la recherche à partir de la position pos.

    Paramètre Type Description
    substr VARCHAR Sous-chaîne à rechercher
    str VARCHAR Chaîne dans laquelle effectuer la recherche
    pos BIGINT (Facultatif) Position de départ de la recherche

    Type de retour : BIGINT

    Notes d'utilisation :

    • Renvoie 0 si substr n'est pas trouvé dans str.

    • Renvoie NULL si substr ou str est NULL.

    Exemples :

    Recherche depuis le début :

    SELECT locate('bar', 'foobarbar');
    +----------------------------+
| locate('bar', 'foobarbar') |
+----------------------------+
|                          4 |
+----------------------------+

    Recherche à partir de la position 7 :

    SELECT locate('bar', 'foobarbar', 7);
    +-------------------------------+
| locate('bar', 'foobarbar', 7) |
+-------------------------------+
|                             7 |
+-------------------------------+

    LOWER ou LCASE

    lower(str)
lcase(str)

    Convertit toutes les lettres de str en minuscules.

    Paramètre Type Description
    str VARCHAR Chaîne d'entrée

    Type de retour : VARCHAR

    Exemple :

    SELECT lower('Aliyun');
    +-----------------+
| lower('Aliyun') |
+-----------------+
| aliyun          |
+-----------------+

    LPAD

    lpad(str, len, padstr)

    Ajoute des caractères de remplissage à gauche de str avec padstr jusqu'à atteindre une longueur totale de len caractères.

    Paramètre Type Description
    str VARCHAR Chaîne à remplir
    len BIGINT Longueur totale cible
    padstr VARCHAR Chaîne de remplissage

    Type de retour : VARCHAR

    Notes d'utilisation :

    • Si str est plus longue que len, la valeur de retour est tronquée à len caractères.

    Exemple :

    SELECT lpad('Aliyun', 9, '#');
    +----------------------+
| lpad('Aliyun',9,'#') |
+----------------------+
| ###Aliyun            |
+----------------------+

    LTRIM

    ltrim(str)

    Supprime tous les espaces situés au début de str.

    Paramètre Type Description
    str VARCHAR Chaîne d'entrée

    Type de retour : VARCHAR

    Exemple :

    SELECT ltrim('  abc');
    +----------------+
| ltrim('  abc') |
+----------------+
| abc            |
+----------------+

    MAKE_SET

    make_set(bits, str1, str2, ...)

    Renvoie un ensemble de chaînes séparées par des virgules, sélectionnées selon les positions de bits définies dans bits. str1 correspond au bit 0, str2 au bit 1, et ainsi de suite.

    Paramètre Type Description
    bits BIGINT Masque de bits indiquant les chaînes à inclure
    str1, str2, ... VARCHAR Chaînes correspondant à chaque position de bit

    Type de retour : VARCHAR

    Notes d'utilisation :

    • Les valeurs NULL présentes dans la liste de chaînes ne sont pas incluses dans le résultat.

    Exemples :

    SELECT make_set(5, 'hello', 'nice', 'world');
    +------------------------------------+
| make_set(5,'hello','nice','world') |
+------------------------------------+
| hello,world                        |
+------------------------------------+

    5 s'écrit 101 en binaire ; les bits 0 et 2 sont donc activés, ce qui sélectionne hello et world.

    SELECT make_set(1 | 4, 'hello', 'nice', NULL, 'world') AS result;
    +--------+
| result |
+--------+
| hello  |
+--------+

    1 | 4 = 5 (soit 101 en binaire) ; les bits 0 et 2 sont donc activés. La chaîne associée au bit 2 étant NULL, seule hello est renvoyée.

    MD5_MUR

    MD5_MUR(x)

    Calcule le hachage MD5 de x, puis le convertit en une valeur de hachage LONG à l'aide de l'algorithme MurmurHash3. Cette fonction présente un taux de collision plus faible que CRC32.

    Paramètre Type Description
    x VARCHAR Chaîne d'entrée

    Type de retour : LONG

    Prérequis : Nécessite la version 3.2.5 du noyau ou une version ultérieure.

    Exemple :

    SELECT MD5_MUR('TEST') AS result;
    +--------------------------+
| result                   |
+--------------------------+
| -6711128042951586494     |
+--------------------------+

    MID

    mid(str, pos, len)

    Renvoie une sous-chaîne de len caractères extraite de str, à partir de la position pos. Cette fonction équivaut à SUBSTR et SUBSTRING.

    Paramètre Type Description
    str VARCHAR Chaîne d'entrée
    pos BIGINT Position de départ (indexation à partir de 1). Utilisez une valeur négative pour compter à partir de la fin de la chaîne
    len BIGINT Nombre de caractères à renvoyer

    Type de retour : VARCHAR

    Exemples :

    SELECT mid('Quadratically', 5, 6);
    +--------------------------+
| mid('Quadratically',5,6) |
+--------------------------+
| ratica                   |
+--------------------------+
    SELECT mid('Sakila', -5, 3);
    +----------------------+
| mid('Sakila', -5, 3) |
+----------------------+
| aki                  |
+----------------------+

    OCT

    oct(N)

    Renvoie la représentation octale de N sous forme de chaîne.

    Paramètre Type Description
    N BIGINT Entier à convertir

    Type de retour : VARCHAR

    Notes d'utilisation :

    • Renvoie NULL si N est NULL.

    Exemple :

    SELECT oct(12);
    +---------+
| oct(12) |
+---------+
| 14      |
+---------+

    ORD

    ord(x)

    Renvoie le code du caractère situé le plus à gauche dans x s'il s'agit d'un caractère multioctet.

    Paramètre Type Description
    x VARBINARY ou VARCHAR Chaîne d'entrée

    Type de retour : LONG

    Exemples :

    Entrée VARCHAR :

    SELECT ord('China');
    +--------------+
| ord('China') |
+--------------+
|           67 |
+--------------+

    Entrée VARBINARY :

    SELECT ord(cast('China' AS varbinary));
    +---------------------------------+
| ord(cast('China' AS varbinary)) |
+---------------------------------+
|                              67 |
+---------------------------------+

    POSITION

    position(substr IN str)

    Renvoie la position de la première occurrence de substr dans str. Les positions sont indexées à partir de 1.

    Paramètre Type Description
    substr VARCHAR Sous-chaîne à rechercher
    str VARCHAR Chaîne dans laquelle effectuer la recherche

    Type de retour : BIGINT

    Notes d'utilisation :

    • Renvoie 0 si substr n'est pas trouvé.

    Exemple :

    SELECT position('bar' IN 'foobarbar');
    +--------------------------------+
| position('bar' in 'foobarbar') |
+--------------------------------+
|                              4 |
+--------------------------------+

    REPEAT

    repeat(str, count)

    Renvoie str répétée count fois.

    Paramètre Type Description
    str VARCHAR Chaîne à répéter
    count BIGINT Nombre de répétitions

    Type de retour : VARCHAR

    Notes d'utilisation :

    • Renvoie une chaîne vide si count < 1.

    • Renvoie NULL si str ou count est NULL.

    Exemples :

    SELECT repeat('a', 3);
    +----------------+
| repeat('a', 3) |
+----------------+
| aaa            |
+----------------+
    SELECT repeat('abc', null);
    +---------------------+
| repeat('abc', null) |
+---------------------+
| NULL                |
+---------------------+
    SELECT repeat(null, 3);
    +-----------------+
| repeat(null, 3) |
+-----------------+
| NULL            |
+-----------------+

    REPLACE

    replace(str, from_str, to_str)

    Remplace toutes les occurrences de from_str dans str par to_str.

    Paramètre Type Description
    str VARCHAR Chaîne d'entrée
    from_str VARCHAR Sous-chaîne à remplacer
    to_str VARCHAR Chaîne de remplacement

    Type de retour : VARCHAR

    Exemple :

    SELECT replace('WWW.aliyun.com', 'W', 'w');
    +-------------------------------------+
| replace('WWW.aliyun.com', 'W', 'w') |
+-------------------------------------+
| www.aliyun.com                      |
+-------------------------------------+

    REVERSE

    reverse(str)

    Renvoie str avec l'ordre des caractères inversé.

    Paramètre Type Description
    str VARCHAR Chaîne d'entrée

    Type de retour : VARCHAR

    Exemple :

    SELECT reverse('123456');
    +-------------------+
| reverse('123456') |
+-------------------+
| 654321            |
+-------------------+

    RIGHT

    RIGHT(str, len)

    Renvoie les len caractères les plus à droite de str.

    Paramètre Type Description
    str VARCHAR Chaîne d'entrée
    len BIGINT Nombre de caractères à renvoyer

    Type de retour : VARCHAR

    Notes d'utilisation :

    • Renvoie NULL si str ou len est NULL.

    Exemple :

    SELECT RIGHT('abc', 3);
    +----------------+
| RIGHT('abc',3) |
+----------------+
| abc            |
+----------------+

    RLIKE ou REGEXP

    expression RLIKE pattern
expression REGEXP pattern

    Renvoie 1 si expression correspond à l'expression régulière pattern, et 0 dans le cas contraire.

    Paramètre Type Description
    expression VARCHAR Chaîne à faire correspondre
    pattern VARCHAR Modèle d'expression régulière

    Type de retour : BOOLEAN

    Notes d'utilisation :

    • Renvoie NULL si expression ou pattern est NULL.

    Exemples :

    SELECT 'Michael!' REGEXP '.*';
    +----------------------+
| Michael!' REGEXP '.* |
+----------------------+
|                    1 |
+----------------------+
    SELECT 'new*\n*line' REGEXP 'new\\*.\\*line';
    +-------------------------------------+
| new*\n*line' REGEXP 'new\\*.\\*line |
+-------------------------------------+
|                                   0 |
+-------------------------------------+
    SELECT 'c' REGEXP '^[a-d]';
    +-------------------+
| c' REGEXP '^[a-d] |
+-------------------+
|                 1 |
+-------------------+

    RPAD

    rpad(str, len, padstr)

    Ajoute des caractères de remplissage à droite de str avec padstr jusqu'à atteindre une longueur totale de len caractères.

    Paramètre Type Description
    str VARCHAR Chaîne à remplir
    len BIGINT Longueur totale cible
    padstr VARCHAR Chaîne de remplissage

    Type de retour : VARCHAR

    Notes d'utilisation :

    • Si str est plus longue que len, la valeur de retour est tronquée à len caractères.

    Exemple :

    SELECT rpad('Aliyun', 9, '#');
    +----------------------+
| rpad('Aliyun',9,'#') |
+----------------------+
| Aliyun###            |
+----------------------+

    RTRIM

    rtrim(str)

    Supprime tous les espaces situés à la fin de str.

    Paramètre Type Description
    str VARCHAR Chaîne d'entrée

    Type de retour : VARCHAR

    Exemple :

    SELECT rtrim('barbar   ');
    +--------------------+
| rtrim('barbar   ') |
+--------------------+
| barbar             |
+--------------------+

    SPACE

    space(N)

    Renvoie une chaîne composée de N espaces.

    Paramètre Type Description
    N BIGINT Nombre d'espaces

    Type de retour : VARCHAR

    Notes d'utilisation :

    • Combinez cette fonction avec concat() pour insérer des espaces dans une chaîne plus longue.

    Exemple :

    SELECT concat('#', space(6), '#');
    +----------------------------+
| concat("#", space(6), "#") |
+----------------------------+
| #      #                   |
+----------------------------+

    SPLIT

    split(string, delimiter)

    Divise string à chaque occurrence de delimiter et renvoie les parties sous forme de tableau.

    Paramètre Type Description
    string VARCHAR Chaîne d'entrée
    delimiter VARCHAR Délimiteur utilisé pour la division

    Type de retour : ARRAY\<varchar\>

    Exemple :

    SELECT split('1#2#3', '#'),
       split('#1#2#3#', '#'),
       split('123', '#');
    +---------------------+-----------------------+-------------------+
| split('1#2#3', '#') | split('#1#2#3#', '#') | split('123', '#') |
+---------------------+-----------------------+-------------------+
| ["1","2","3"]       | ["","1","2","3",""]   | ["123"]           |
+---------------------+-----------------------+-------------------+

    SPLIT_PART

    split_part(string, delimiter, index)

    Divise string selon delimiter et renvoie l'élément situé à la position index. L'indexation commence à 1.

    Paramètre Type Description
    string VARCHAR Chaîne d'entrée
    delimiter VARCHAR Délimiteur utilisé pour la division
    index BIGINT Position (indexée à partir de 1) de l'élément à renvoyer

    Type de retour : VARCHAR

    Notes d'utilisation :

    • Renvoie NULL si index est supérieur au nombre de champs résultants.

    Exemple :

    SELECT split_part('A#B#C', '#', 2),
       split_part('A#B#C', '#', 4);
    +-----------------------------+-----------------------------+
| split_part('A#B#C', '#', 2) | split_part('A#B#C', '#', 4) |
+-----------------------------+-----------------------------+
| B                           | NULL                        |
+-----------------------------+-----------------------------+

    SPLIT_TO_MAP

    split_to_map(string, entryDelimiter, keyValueDelimiter)

    Divise string en paires clé-valeur et renvoie une map. entryDelimiter sépare les différentes paires, tandis que keyValueDelimiter sépare chaque clé de sa valeur.

    Paramètre Type Description
    string VARCHAR Chaîne d'entrée
    entryDelimiter VARCHAR Délimiteur entre les paires clé-valeur
    keyValueDelimiter VARCHAR Délimiteur entre la clé et la valeur au sein de chaque paire

    Type de retour : MAP\<varchar, varchar\>

    Exemple :

    SELECT split_to_map('k1:v1,k2:v2', ',', ':'),
       split_to_map('', ',', ':');
    +---------------------------------------+----------------------------+
| split_to_map('k1:v1,k2:v2', ',', ':') | split_to_map('', ',', ':') |
+---------------------------------------+----------------------------+
| {"k1":"v1","k2":"v2"}                 | {}                         |
+---------------------------------------+----------------------------+

    STRCMP

    strcmp(str1, str2)

    Compare str1 et str2 selon l'ordre de tri actuel.

    Paramètre Type Description
    str1 VARCHAR Première chaîne
    str2 VARCHAR Deuxième chaîne

    Type de retour : BIGINT

    Valeurs renvoyées :

    • 0 si les chaînes sont identiques

    • -1 si str1 est inférieure à str2

    • 1 si str1 est supérieure à str2

    Exemple :

    SELECT strcmp('text', 'text2');
    +-------------------------+
| strcmp('text', 'text2') |
+-------------------------+
|                      -1 |
+-------------------------+

    SUBSTR ou SUBSTRING

    substr(str, pos)
substr(str FROM pos)
substr(str, pos, len)
substr(str FROM pos FOR len)
substring(str, pos)
substring(str FROM pos)
substring(str, pos, len)
substring(str FROM pos FOR len)

    Renvoie une sous-chaîne de str à partir de la position pos, éventuellement limitée à len caractères.

    Paramètre Type Description
    str VARCHAR Chaîne d'entrée
    pos BIGINT Position de départ (indexation à partir de 1). Une valeur négative permet de compter à partir de la fin de la chaîne
    len BIGINT (Facultatif) Nombre maximal de caractères à renvoyer. Si omis, tous les caractères depuis pos jusqu'à la fin sont renvoyés

    Type de retour : VARCHAR

    Exemples :

    Renvoyer tout le contenu à partir de la position 6 jusqu'à la fin :

    SELECT substr('helloworld', 6);
    +-------------------------+
| substr('helloworld', 6) |
+-------------------------+
| world                   |
+-------------------------+

    Utilisation de la syntaxe FROM :

    SELECT substr('helloworld' FROM 6);
    +-----------------------------+
| substr('helloworld' FROM 6) |
+-----------------------------+
| world                       |
+-----------------------------+

    Renvoyer 3 caractères à partir de la position 6 :

    SELECT substr('helloworld', 6, 3);
    +----------------------------+
| substr('helloworld', 6, 3) |
+----------------------------+
| wor                        |
+----------------------------+

    Utilisation de la syntaxe FROM ... FOR :

    SELECT substr('helloworld' FROM 6 FOR 3);
    +-----------------------------------+
| substr('helloworld' FROM 6 FOR 3) |
+-----------------------------------+
| wor                               |
+-----------------------------------+

    SUBSTRING_INDEX

    substring_index(str, delim, count)

    Renvoie une sous-chaîne de str coupée à la count-ième occurrence de delim.

    Paramètre Type Description
    str VARCHAR Chaîne d'entrée
    delim VARCHAR Délimiteur à rechercher (sensible à la casse)
    count BIGINT Nombre d'occurrences du délimiteur. Les valeurs positives comptent depuis la gauche et renvoient tout ce qui se trouve à gauche de la correspondance ; les valeurs négatives comptent depuis la droite et renvoient tout ce qui se trouve à droite

    Type de retour : VARCHAR

    Notes d'utilisation :

    • La recherche de delim est sensible à la casse.

    Exemple :

    Renvoyer tout le contenu avant la deuxième occurrence de . :

    SELECT substring_index('www.aliyun.com', '.', 2);
    +-------------------------------------------+
| substring_index('www.aliyun.com', '.', 2) |
+-------------------------------------------+
| www.aliyun                                |
+-------------------------------------------+

    TO_BASE64

    to_base64(x)

    Renvoie x encodé en Base64.

    Paramètre Type Description
    x VARBINARY ou VARCHAR Données à encoder

    Type de retour : VARCHAR

    Exemples :

    Entrée VARCHAR :

    SELECT to_base64('China');
    +--------------------+
| to_base64('China') |
+--------------------+
| Q2hpbmE=           |
+--------------------+

    Entrée VARBINARY :

    SELECT to_base64(cast('China' AS varbinary));
    +---------------------------------------+
| to_base64(cast('China' AS varbinary)) |
+---------------------------------------+
| Q2hpbmE=                              |
+---------------------------------------+

    TO_UTF8

    to_utf8(x)

    Renvoie x encodé en UTF-8.

    Paramètre Type Description
    x VARCHAR Chaîne d'entrée

    Type de retour : VARCHAR

    Exemple :

    SELECT from_utf8(to_utf8('China'));
    +-----------------------------+
| from_utf8(to_utf8('China')) |
+-----------------------------+
| China                       |
+-----------------------------+

    TRIM

    trim([remstr FROM] str)
trim([{BOTH | LEADING | TRAILING} [remstr] FROM] str)

    Supprime les espaces de début et de fin de la chaîne str, ou retire les caractères correspondant à remstr du ou des côtés spécifiés.

    Paramètre Type Description
    str VARCHAR Chaîne d'entrée
    remstr VARCHAR (Facultatif) Caractère(s) à supprimer. L'espace est utilisé par défaut
    `BOTH LEADING TRAILING`

    —

    (Facultatif) Côté à partir duquel supprimer les caractères. La valeur par défaut est BOTH

    Type de retour : VARCHAR

    Exemples :

    Suppression des espaces de début et de fin :

    SELECT trim('  bar   ');
    +------------------+
| trim('  bar   ') |
+------------------+
| bar              |
+------------------+

    Suppression d'un caractère spécifique des deux côtés :

    SELECT trim(BOTH 'x' FROM 'xxxbarxxx');
    +---------------------------------+
| trim(BOTH 'x' FROM 'xxxbarxxx') |
+---------------------------------+
| bar                             |
+---------------------------------+

    Suppression uniquement au début :

    SELECT trim(LEADING 'x' FROM 'xxxbarxxx');
    +------------------------------------+
| trim(LEADING 'x' FROM 'xxxbarxxx') |
+------------------------------------+
| barxxx                             |
+------------------------------------+

    Suppression uniquement à la fin :

    SELECT trim(TRAILING 'x' FROM 'xxxbarxxx');
    +-------------------------------------+
| trim(TRAILING 'x' from 'xxxbarxxx') |
+-------------------------------------+
| xxxbar                              |
+-------------------------------------+

    UNHEX

    unhex(x)

    Interprète chaque paire de chiffres hexadécimaux dans x comme une valeur d'octet et renvoie la chaîne binaire correspondante.

    Paramètre Type Description
    x VARBINARY ou VARCHAR Chaîne hexadécimale à décoder

    Type de retour : VARBINARY

    Remarques sur l'utilisation :

    La valeur de retour est de type VARBINARY. Pour obtenir un résultat VARCHAR, convertissez-la à l'aide de l'une des méthodes suivantes :

    • AnalyticDB for MySQL V3.1.4 ou version ultérieure : Utilisez CAST AS VARCHAR. Pour plus d'informations, consultez la rubrique Fonctions CAST.

    • Versions antérieures à la V3.1.4 : Utilisez la fonction FROM_UTF8. Pour plus d'informations, consultez la section FROM_UTF8.

    Si l'entrée contient des caractères non hexadécimaux, la valeur NULL est renvoyée.

    Exemples :

    Entrée VARCHAR — utilisez CAST pour obtenir le résultat VARCHAR :

    SELECT unhex(hex('China'));
    +------------------------------------------+
| unhex(hex('China'))                      |
+------------------------------------------+
| China                                    |
+------------------------------------------+

    Pour obtenir explicitement la valeur VARCHAR :

    SELECT cast(unhex(hex('China')) AS varchar);
    +--------------------------------------+
| cast(unhex(hex('China')) AS varchar) |
+--------------------------------------+
| China                                |
+--------------------------------------+

    Entrée VARBINARY :

    SELECT unhex(cast(hex('China') AS varbinary));
    +------------------------------------------+
| unhex(cast(hex('China') AS varbinary))   |
+------------------------------------------+
| China                                    |
+------------------------------------------+

    UPPER ou UCASE

    upper(str)
ucase(str)

    Convertit toutes les lettres de la chaîne str en majuscules.

    Paramètre Type Description
    str VARCHAR Chaîne d'entrée

    Type de retour : VARCHAR

    Exemple :

    SELECT upper('Aliyun');
    +-----------------+
| upper('Aliyun') |
+-----------------+
| ALIYUN          |
+-----------------+