Tous les produits
Search

Ce produit

    AnalyticDB:Fonctions binaires à longueur variable

    Centre de documentation

    AnalyticDB:Fonctions binaires à longueur variable

    Dernière mise à jour :Aug 28, 2026

    Les fonctions binaires à longueur variable traitent les données de types binaires tels que BINARY, VARBINARY et BLOB. Utilisez-les pour chiffrer et déchiffrer des données, compresser et décompresser des chaînes, encoder et décoder des valeurs, calculer des hachages et manipuler des chaînes binaires.

    Tous les exemples de cette rubrique utilisent les valeurs de retour générées par Data Management (DMS). Les valeurs de retour peuvent différer dans d'autres clients en raison des différences d'analyse côté client. Par exemple, 'China' est analysé comme 0x4368696E61 par certains clients.

    Présentation des fonctions

    Chiffrement et déchiffrement

    Fonction

    description

    type de retour

    AES_DECRYPT(X, Y)

    Déchiffre X à l'aide de l'algorithme Advanced Encryption Standard (AES) avec Y comme clé

    VARBINARY

    AES_DECRYPT_MY(X, Y)

    Déchiffre X à l'aide d'AES avec Y comme clé. Compatible MySQL : déchiffre les données chiffrées dans MySQL. Nécessite la version V3.1.10.0 ou ultérieure

    VARBINARY

    AES_ENCRYPT(X, Y)

    Chiffre X à l'aide d'AES avec Y comme clé

    VARBINARY

    AES_ENCRYPT_MY(X, Y)

    Chiffre X à l'aide d'AES avec Y comme clé. Compatible MySQL : les données chiffrées avec cette fonction peuvent être déchiffrées dans MySQL. Nécessite la version V3.1.10.0 ou ultérieure

    VARBINARY

    ENCRYPT(X, Y)

    Chiffre X avec Y comme valeur de sel

    BLOB

    Compression et décompression

    Fonction

    description

    type de retour

    version

    COMPRESS(X)

    Compresse X et renvoie le résultat sous forme de chaîne binaire

    VARBINARY

    —

    UNCOMPRESS(X)

    Décompresse X, qui doit avoir été compressé par COMPRESS()

    BLOB

    —

    UNCOMPRESSED_LENGTH(X)

    Renvoie la longueur de X avant compression

    LONG

    —

    GZIP(X)

    Compresse X au format GZIP et renvoie le résultat sous forme de chaîne binaire

    VARBINARY

    V3.1.9.3+

    GUNZIP(X)

    Décompresse X au format GZIP et renvoie le résultat sous forme de chaîne binaire

    VARBINARY

    V3.1.9.3+

    ZIP(X)

    Compresse X au format ZIP et renvoie le résultat sous forme de chaîne binaire

    VARBINARY

    V3.1.9.3+

    UNZIP(X)

    Décompresse X au format ZIP et renvoie le résultat sous forme de chaîne binaire

    VARBINARY

    V3.1.9.3+

    Encodage et décodage

    Fonction

    description

    type de retour

    HEX(X)

    Convertit X en une chaîne hexadécimale

    VARCHAR

    UNHEX(X)

    Interprète les paires de caractères dans X comme des valeurs hexadécimales, les convertit en octets et renvoie le résultat sous forme de chaîne binaire

    VARBINARY

    FROM_BASE64(X)

    Décode la chaîne X encodée en Base64 et renvoie le résultat

    BLOB

    TO_BASE64(X)

    Encode X au format Base64 et renvoie le résultat

    VARCHAR

    Hachage et sommes de contrôle

    Fonction

    description

    type de retour

    MD5(X)

    Renvoie le hachage MD5 (Message-Digest Algorithm 5) de X

    VARCHAR

    SHA1(X)

    Renvoie la somme de contrôle SHA-1 (Secure Hash Algorithm 1) de X

    VARCHAR

    SHA2(X, Y)

    Renvoie la somme de contrôle SHA-2 de X. Y spécifie la longueur en bits : 224, 256, 384, 512 ou 0

    VARCHAR

    CRC32(X)

    Renvoie le code CRC (Cyclic Redundancy Check) de X

    LONG

    Manipulation de chaînes

    Fonction

    description

    type de retour

    CHAR_LENGTH(X)

    Renvoie la longueur de X mesurée en caractères

    LONG

    LENGTH(X)

    Renvoie la longueur de X mesurée en octets

    LONG

    LEFT(X, Y)

    Renvoie les Y caractères les plus à gauche de X

    BLOB

    RIGHT(X, Y)

    Renvoie les Y caractères les plus à droite de X

    VARBINARY

    [SUBSTR(X, Y[, Z])](#section_21q_byy_83m)

    Renvoie une sous-chaîne commençant à la position Y. Z spécifie la longueur

    VARBINARY

    LPAD(X, Y, Z)

    Ajoute un remplissage à gauche de X avec Z jusqu'à une longueur totale de Y caractères. Tronque X à Y caractères si X est plus long que Y

    VARBINARY

    RPAD(X, Y, Z)

    Ajoute un remplissage à droite de X avec Z jusqu'à une longueur totale de Y caractères. Tronque X à Y caractères si X est plus long que Y

    VARBINARY

    LTRIM(X)

    Supprime les espaces de début de X

    BLOB

    RTRIM(X)

    Supprime les espaces de fin de X

    BLOB

    TRIM(X)

    Supprime les espaces de début et de fin de X

    BLOB

    LOWER(X)

    Renvoie X en minuscules

    VARBINARY

    UPPER(X)

    Renvoie X en majuscules

    VARBINARY

    REPEAT(X, Y)

    Renvoie X répété Y fois

    VARBINARY

    REVERSE(X)

    Renvoie X avec les caractères dans l'ordre inverse

    VARBINARY

    ORD(X)

    Renvoie le code du caractère le plus à gauche de X lorsque ce caractère est un caractère multioctet

    LONG

    Notes d'utilisation

    • Sortie spécifique au client : Les valeurs de retour peuvent différer entre les clients en raison de comportements d'analyse différents. Les exemples de cette rubrique utilisent la sortie de DMS.

    • Exigences de version : GUNZIP, GZIP, UNZIP et ZIP nécessitent la version V3.1.9.3 ou ultérieure. AES_DECRYPT_MY et AES_ENCRYPT_MY nécessitent la version V3.1.10.0 ou ultérieure.

      • Pour vérifier la version mineure d'un cluster Data Lakehouse Edition, exécutez SELECT adb_version();. Pour mettre à jour, contactez le support technique.

      • Pour afficher ou mettre à jour la version mineure d'un cluster Data Warehouse Edition, consultez Mettre à jour la version mineure d'un cluster.

    • AES_ENCRYPT vs AES_ENCRYPT_MY : Utilisez AES_ENCRYPT lorsque le chiffrement et le déchiffrement ont lieu tous deux dans AnalyticDB for MySQL. Utilisez AES_ENCRYPT_MY lorsque les données chiffrées doivent être déchiffrables dans MySQL, ou lors du déchiffrement de données qui ont été chiffrées dans MySQL.

    • Comportement NULL : UNHEX() renvoie NULL lorsque l'entrée contient des caractères en dehors de la plage hexadécimale (0–9, A–F).

    • Stockage des résultats binaires : Les fonctions qui renvoient VARBINARY ou BLOB peuvent produire des valeurs d'octets arbitraires. Pour afficher les résultats binaires sous forme de texte lisible, encapsulez la sortie dans HEX().

    AES_DECRYPT

    AES_DECRYPT(VARBINARY X, VARCHAR Y)

    Déchiffre X à l'aide d'AES avec Y comme clé.

    Exemple :

    SELECT HEX(AES_DECRYPT(AES_ENCRYPT(CAST('China' AS VARBINARY), '0123'),'0123'));

    Le résultat suivant est renvoyé :

    +-----------------------------------------------------------------------------+
| HEX(AES_DECRYPT(AES_ENCRYPT(CAST('China' AS VARBINARY), '0123'),'0123'))    |
+-----------------------------------------------------------------------------+
|   4368696E61                                                                |
+-----------------------------------------------------------------------------+
    SELECT UNZIP(ZIP(CAST('China' AS VARBINARY)));

    Le résultat suivant est renvoyé :

    +---------------------------------------+
| UNZIP(ZIP(CAST('China' AS VARBINARY)))|
+---------------------------------------+
| China                                 | 
+---------------------------------------+
    SELECT UNZIP(ZIP(CAST('China' AS VARBINARY)));

    Le résultat suivant est renvoyé :

    +---------------------------------------+
| UNZIP(ZIP(CAST('China' AS VARBINARY)))|
+---------------------------------------+
| China                                 | 
+---------------------------------------+
    SELECT HEX(GZIP(CAST('China' AS VARBINARY)));

    Le résultat suivant est renvoyé :

    +------------------------------------------------------+
| HEX(GZIP(CAST('China' AS VARBINARY)))                |
+------------------------------------------------------+
|1F8B080000000000000073CEC8CC4B040020ED2EA105000000    | 
+------------------------------------------------------+
    SELECT GUNZIP(GZIP(CAST('China' AS VARBINARY)));

    Le résultat suivant est renvoyé :

    +--------------------------------------------+
| GUNZIP(GZIP(CAST('China' AS VARBINARY)))   |
+--------------------------------------------+
| China                                      |  
+--------------------------------------------+
    SELECT UNHEX(CAST('China' AS VARBINARY));

    Le résultat suivant est renvoyé :

    +------------------------------------+
| UNHEX(CAST('China' AS VARBINARY))  |
+------------------------------------+
| NULL                               |  
+------------------------------------+
    SELECT UNCOMPRESSED_LENGTH(COMPRESS(CAST('China' AS VARBINARY)));

    Le résultat suivant est renvoyé :

    +------------------------------------------------------------+
| UNCOMPRESSED_LENGTH(COMPRESS(CAST('China' AS VARBINARY)))  |
+------------------------------------------------------------+
| 5                                                          |
+------------------------------------------------------------+
    SELECT UNCOMPRESS(COMPRESS(CAST('China' AS VARBINARY)));

    Le résultat suivant est renvoyé :

    +---------------------------------------------------+
| UNCOMPRESS(COMPRESS(CAST('China' AS VARBINARY)))  |
+---------------------------------------------------+
| China                                             | 
+---------------------------------------------------+
    SELECT TRIM(CAST('  China  ' AS VARBINARY));

    Le résultat suivant est renvoyé :

    +---------------------------------------+
| TRIM(CAST('  China  ' AS VARBINARY))  |
+---------------------------------------+
| China                                 | 
+---------------------------------------+
    SELECT TO_BASE64(CAST('China' AS VARBINARY));

    Le résultat suivant est renvoyé :

    +----------------------------------------+
| TO_BASE64(CAST('China' AS VARBINARY))  |
+----------------------------------------+
| Q2hpbmE=                               |
+----------------------------------------+
    SELECT SHA2(CAST('China' AS VARBINARY),256);

    Le résultat suivant est renvoyé :

    +------------------------------------------------------------------+
| SHA2(CAST('China' AS VARBINARY),256)                            |
+------------------------------------------------------------------+
| 10436829032f361a3de50048de41755140e581467bc1895e6c1a17f423e42d10 |
+------------------------------------------------------------------+
    SELECT SHA1(CAST('China' AS VARBINARY));

    Le résultat suivant est renvoyé :

    +------------------------------------------+
| SHA1(CAST('China' AS VARBINARY))         |
+------------------------------------------+
| d2eaf2aa1512d6596e0a5bae633537c6b8e779a3 |      
+------------------------------------------+
    SELECT RTRIM(CAST('  China  ' AS VARBINARY));

    Le résultat suivant est renvoyé :

    +----------------------------------------+
| RTRIM(CAST('  China  ' AS VARBINARY))  |
+----------------------------------------+
|   China                                | 
+----------------------------------------+
    SELECT HEX(RPAD(CAST('China' AS VARBINARY), 4.7,'x'));

    Le résultat suivant est renvoyé :

    +--------------------------------------------------+
| HEX(RPAD(CAST('China' AS VARBINARY), 4.7, 'x'))  |
+--------------------------------------------------+
| 4368696E61                                       | 
+--------------------------------------------------+
    SELECT HEX(RIGHT(CAST('China' AS VARBINARY),1));

    Le résultat suivant est renvoyé :

    +--------------------------------------------+
| HEX(RIGHT(CAST('China' AS VARBINARY), 1))  |
+--------------------------------------------+
| 61                                         |
+--------------------------------------------+
    SELECT HEX(REVERSE(CAST('China' AS VARBINARY)));

    Le résultat suivant est renvoyé :

    +-------------------------------------------+
| HEX(REVERSE(CAST('China' AS VARBINARY)))  |
+-------------------------------------------+
|  616E696843                               |
+-------------------------------------------+
    SELECT HEX(REPEAT(CAST('China' AS VARBINARY),1));

    Le résultat suivant est renvoyé :

    +---------------------------------------------+
| HEX(REPEAT(CAST('China' AS VARBINARY), 1))  |
+---------------------------------------------+
|  4368696E61                                 | 
+---------------------------------------------+
    SELECT ORD(CAST('China' AS VARBINARY));

    Le résultat suivant est renvoyé :

    +----------------------------------+
| ORD(CAST('China' AS VARBINARY))  |
+----------------------------------+
|67                                | 
+----------------------------------+

    SELECT MD5(CAST('China' AS VARBINARY));

    Le résultat suivant est renvoyé :

    +----------------------------------+
| MD5(CAST('China' AS VARBINARY))  |
+----------------------------------+
| ae54a5c026f31ada088992587d92cb3a | 
+----------------------------------+
    SELECT LTRIM(CAST('  China  ' AS VARBINARY));

    Le résultat suivant est renvoyé :

    +----------------------------------------+
| LTRIM(CAST('  China  ' AS VARBINARY))  |
+----------------------------------------+
| China                                  |
+----------------------------------------+
    SELECT HEX(LPAD(CAST('China' AS VARBINARY), 7,'-'));

    Le résultat suivant est renvoyé :

    +------------------------------------------------+
| HEX(LPAD(CAST('China' AS VARBINARY), 7, '-'))  |
+------------------------------------------------+
| 2D2D4368696E61                                 | 
+------------------------------------------------+
    SELECT LEFT(CAST('China' AS VARBINARY),1000);

    Le résultat suivant est renvoyé :

    +-----------------------------------------+
| LEFT(CAST('China' AS VARBINARY), 1000)  |
+-----------------------------------------+
| China                                   | 
+-----------------------------------------+
    SELECT HEX(CAST('China' AS VARBINARY));

    Le résultat suivant est renvoyé :

    +----------------------------------+
| HEX(CAST('China' AS VARBINARY))  |
+----------------------------------+
|  4368696E61                      | 
+----------------------------------+
    SELECT CRC32(CAST('China' AS VARBINARY));

    Le résultat suivant est renvoyé :

    +------------------------------------+
| CRC32(CAST('China' AS VARBINARY))  |
+------------------------------------+
| 2704207136                         | 
+------------------------------------+
    SELECT HEX(COMPRESS(CAST('China' AS VARBINARY)));

    Le résultat suivant est renvoyé :

    +--------------------------------------------+
| HEX(COMPRESS(CAST('China' AS VARBINARY)))  |
+--------------------------------------------+
|  05000000789C73CEC8CC4B0400056C01E4        |
+--------------------------------------------+
    SELECT HEX(AES_ENCRYPT_MY('China', 'key_string'));

    Le résultat suivant est renvoyé :

    +-------------------------------------------------------+
|HEX(AES_ENCRYPT_MY('China', 'key_string'))             |
+-------------------------------------------------------+
|CF3AB34E18CD73CE37D46AD2588BA258                       | 
+-------------------------------------------------------+
    SELECT HEX(AES_ENCRYPT(CAST('China' AS VARBINARY), '0123'));

    Le résultat suivant est renvoyé :

    +-------------------------------------------------------+
|HEX(AES_ENCRYPT(CAST('China' AS VARBINARY), '0123'))   |
+-------------------------------------------------------+
| 6C5CB5E59E3EA58E58CFBE3C76BFBECA                      |
+-------------------------------------------------------+
    SELECT HEX(AES_DECRYPT(AES_ENCRYPT(CAST('China' AS VARBINARY), '0123'),'0123'));

    Le résultat suivant est renvoyé :

    +-----------------------------------------------------------------------------+
| HEX(AES_DECRYPT(AES_ENCRYPT(CAST('China' AS VARBINARY), '0123'),'0123'))    |
+-----------------------------------------------------------------------------+
|   4368696E61                                                                |
+-----------------------------------------------------------------------------+
    SELECT HEX(AES_DECRYPT(AES_ENCRYPT(CAST('China' AS VARBINARY), '0123'), '0123'));

    Sortie :

    +-----------------------------------------------------------------------------+
| HEX(AES_DECRYPT(AES_ENCRYPT(CAST('China' AS VARBINARY), '0123'),'0123'))   |
+-----------------------------------------------------------------------------+
| 4368696E61                                                                  |
+-----------------------------------------------------------------------------+

    AES_DECRYPT_MY

    Important

    AES_DECRYPT_MY est compatible avec MySQL. Utilisez cette fonction pour déchiffrer des données qui ont été chiffrées dans MySQL. Nécessite AnalyticDB for MySQL V3.1.10.0 ou une version ultérieure.

    AES_DECRYPT_MY(VARBINARY X, VARCHAR Y)

    Déchiffre X en utilisant AES avec Y comme clé.

    Exemple :

    SELECT CAST(AES_DECRYPT_MY(UNHEX('CF3AB34E18CD73CE37D46AD2588BA258'), 'key_string') AS CHAR);

    Sortie :

    +----------------------------------------------------------------------------------------+
| CAST(AES_DECRYPT_MY(UNHEX('CF3AB34E18CD73CE37D46AD2588BA258'),'key_string') AS CHAR)  |
+----------------------------------------------------------------------------------------+
| China                                                                                  |
+----------------------------------------------------------------------------------------+

    AES_ENCRYPT

    AES_ENCRYPT(VARBINARY X, VARCHAR Y)

    Chiffre X en utilisant AES avec Y comme clé.

    Exemple :

    SELECT HEX(AES_ENCRYPT(CAST('China' AS VARBINARY), '0123'));

    Sortie :

    +-------------------------------------------------------+
| HEX(AES_ENCRYPT(CAST('China' AS VARBINARY), '0123'))  |
+-------------------------------------------------------+
| 6C5CB5E59E3EA58E58CFBE3C76BFBECA                      |
+-------------------------------------------------------+

    AES_ENCRYPT_MY

    Important

    AES_ENCRYPT_MY est compatible avec MySQL. Les données chiffrées avec cette fonction peuvent être déchiffrées dans MySQL. Nécessite AnalyticDB for MySQL V3.1.10.0 ou une version ultérieure.

    AES_ENCRYPT_MY(VARBINARY X, VARCHAR Y)

    Chiffre X en utilisant AES avec Y comme clé.

    Exemple :

    SELECT HEX(AES_ENCRYPT_MY('China', 'key_string'));

    Sortie :

    +--------------------------------------------+
| HEX(AES_ENCRYPT_MY('China', 'key_string')) |
+--------------------------------------------+
| CF3AB34E18CD73CE37D46AD2588BA258           |
+--------------------------------------------+

    CHAR_LENGTH

    CHAR_LENGTH(VARBINARY X)

    Renvoie la longueur de X, mesurée en caractères.

    Exemple :

    SELECT CHAR_LENGTH(CAST('ABC' AS VARBINARY));

    Résultat :

    +---------------------------------------+
| CHAR_LENGTH(CAST('ABC' AS VARBINARY)) |
+---------------------------------------+
| 3                                     |
+---------------------------------------+

    COMPRESS

    COMPRESS(VARBINARY X)

    Compresse X et renvoie le résultat sous forme de chaîne binaire. Utilisez HEX() pour afficher le résultat sous forme de texte lisible.

    Exemple :

    SELECT HEX(COMPRESS(CAST('China' AS VARBINARY)));

    Résultat :

    +--------------------------------------------+
| HEX(COMPRESS(CAST('China' AS VARBINARY)))  |
+--------------------------------------------+
| 05000000789C73CEC8CC4B0400056C01E4         |
+--------------------------------------------+

    CRC32

    CRC32(VARBINARY X)

    Renvoie le code de contrôle de redondance cyclique (CRC) de X.

    Exemple :

    SELECT CRC32(CAST('China' AS VARBINARY));

    Résultat :

    +------------------------------------+
| CRC32(CAST('China' AS VARBINARY))  |
+------------------------------------+
| 2704207136                         |
+------------------------------------+

    ENCRYPT

    ENCRYPT(VARBINARY X, VARCHAR Y)

    Chiffre X en utilisant Y comme valeur de sel.

    Exemple :

    SELECT ENCRYPT('ABDABC123', 'KEY');

    Résultat :

    +-----------------------------+
| ENCRYPT('ABDABC123','KEY')  |
+-----------------------------+
| kezazmcIo.aCw               |
+-----------------------------+

    FROM_BASE64

    FROM_BASE64(VARBINARY X)

    Décode la chaîne X encodée en Base64 et renvoie le résultat.

    Exemple :

    SELECT FROM_BASE64(TO_BASE64(CAST('abc' AS VARBINARY)));

    Résultat :

    +--------------------------------------------------+
| FROM_BASE64(TO_BASE64(CAST('abc' AS VARBINARY))) |
+--------------------------------------------------+
| abc                                              |
+--------------------------------------------------+

    GUNZIP

    Important

    Nécessite AnalyticDB for MySQL V3.1.9.3 ou une version ultérieure.

    GUNZIP(VARBINARY X)

    Décompresse X au format GZIP et renvoie le résultat sous forme de chaîne binaire.

    Exemple :

    SELECT GUNZIP(GZIP(CAST('China' AS VARBINARY)));

    Résultat :

    +------------------------------------------+
| GUNZIP(GZIP(CAST('China' AS VARBINARY))) |
+------------------------------------------+
| China                                    |
+------------------------------------------+

    GZIP

    Important

    Nécessite AnalyticDB for MySQL V3.1.9.3 ou une version ultérieure.

    GZIP(VARBINARY X)

    Compresse X au format GZIP et renvoie le résultat sous forme de chaîne binaire. Utilisez HEX() pour afficher le résultat sous forme de texte lisible.

    Exemple :

    SELECT HEX(GZIP(CAST('China' AS VARBINARY)));

    Résultat :

    +----------------------------------------------------------+
| HEX(GZIP(CAST('China' AS VARBINARY)))                    |
+----------------------------------------------------------+
| 1F8B080000000000000073CEC8CC4B040020ED2EA105000000       |
+----------------------------------------------------------+

    HEX

    HEX(VARBINARY X)

    Convertit X en une chaîne hexadécimale.

    Exemple :

    SELECT HEX(CAST('China' AS VARBINARY));

    Résultat :

    +----------------------------------+
| HEX(CAST('China' AS VARBINARY))  |
+----------------------------------+
| 4368696E61                       |
+----------------------------------+

    LEFT

    LEFT(VARBINARY X, BIGINT Y)
LEFT(VARBINARY X, DOUBLE Y)

    Renvoie les Y caractères les plus à gauche de X.

    Exemple :

    SELECT LEFT(CAST('China' AS VARBINARY), 1000);

    Résultat :

    +-----------------------------------------+
| LEFT(CAST('China' AS VARBINARY), 1000)  |
+-----------------------------------------+
| China                                   |
+-----------------------------------------+

    LENGTH

    LENGTH(VARBINARY X)

    Renvoie la longueur de X, mesurée en octets.

    Exemple :

    SELECT LENGTH(CAST('ABC' AS VARBINARY));

    Résultat :

    +----------------------------------+
| LENGTH(CAST('ABC' AS VARBINARY)) |
+----------------------------------+
| 3                                |
+----------------------------------+

    LOWER

    LOWER(VARBINARY X)

    Renvoie X en minuscules.

    Exemple :

    SELECT LOWER(CAST('ABC' AS VARBINARY));

    Résultat :

    +---------------------------------+
| LOWER(CAST('ABC' AS VARBINARY)) |
+---------------------------------+
| abc                             |
+---------------------------------+

    LPAD

    LPAD(VARBINARY X, BIGINT Y, VARCHAR Z)
LPAD(VARBINARY X, DOUBLE Y, VARCHAR Z)

    Ajoute des caractères Z à gauche de X jusqu'à atteindre une longueur totale de Y caractères. Si X est plus long que Y caractères, le résultat est tronqué à Y caractères.

    Exemple :

    SELECT HEX(LPAD(CAST('China' AS VARBINARY), 7, '-'));

    Résultat :

    +------------------------------------------------+
| HEX(LPAD(CAST('China' AS VARBINARY), 7, '-'))  |
+------------------------------------------------+
| 2D2D4368696E61                                 |
+------------------------------------------------+

    LTRIM

    LTRIM(VARBINARY X)

    Supprime les espaces de début de X.

    Exemple :

    SELECT LTRIM(CAST('  China  ' AS VARBINARY));

    Résultat :

    +----------------------------------------+
| LTRIM(CAST('  China  ' AS VARBINARY))  |
+----------------------------------------+
| China                                  |
+----------------------------------------+

    MD5

    MD5(VARBINARY X)

    Renvoie le hachage MD5 de X.

    Exemple :

    SELECT MD5(CAST('China' AS VARBINARY));

    Résultat :

    +----------------------------------+
| MD5(CAST('China' AS VARBINARY))  |
+----------------------------------+
| ae54a5c026f31ada088992587d92cb3a |
+----------------------------------+

    ORD

    ORD(VARBINARY X)

    Renvoie le code du caractère le plus à gauche de X lorsque ce caractère est un caractère multioctet.

    Exemple :

    SELECT ORD(CAST('China' AS VARBINARY));

    Résultat :

    +----------------------------------+
| ORD(CAST('China' AS VARBINARY))  |
+----------------------------------+
| 67                               |
+----------------------------------+

    REPEAT

    REPEAT(VARBINARY X, DOUBLE Y)
REPEAT(VARBINARY X, BIGINT Y)

    Renvoie X répété Y fois.

    Exemple :

    SELECT HEX(REPEAT(CAST('China' AS VARBINARY), 1));

    Résultat :

    +---------------------------------------------+
| HEX(REPEAT(CAST('China' AS VARBINARY), 1))  |
+---------------------------------------------+
| 4368696E61                                  |
+---------------------------------------------+

    REVERSE

    REVERSE(VARBINARY X)

    Renvoie X avec les caractères dans l'ordre inverse.

    Exemple :

    SELECT HEX(REVERSE(CAST('China' AS VARBINARY)));

    Résultat :

    +-------------------------------------------+
| HEX(REVERSE(CAST('China' AS VARBINARY)))  |
+-------------------------------------------+
| 616E696843                                |
+-------------------------------------------+

    RIGHT

    RIGHT(VARBINARY X, BIGINT Y)
RIGHT(VARBINARY X, DOUBLE Y)

    Renvoie les Y caractères les plus à droite de X.

    Exemple :

    SELECT HEX(RIGHT(CAST('China' AS VARBINARY), 1));

    Résultat :

    +--------------------------------------------+
| HEX(RIGHT(CAST('China' AS VARBINARY), 1))  |
+--------------------------------------------+
| 61                                         |
+--------------------------------------------+

    RPAD

    RPAD(VARBINARY X, BIGINT Y, VARCHAR Z)
RPAD(VARBINARY X, DOUBLE Y, VARCHAR Z)

    Ajoute des caractères Z à droite de X jusqu'à atteindre une longueur totale de Y caractères. Si X est plus long que Y caractères, le résultat est tronqué à Y caractères.

    Exemple :

    SELECT HEX(RPAD(CAST('China' AS VARBINARY), 4.7, 'x'));

    Résultat :

    +--------------------------------------------------+
| HEX(RPAD(CAST('China' AS VARBINARY), 4.7, 'x'))  |
+--------------------------------------------------+
| 4368696E61                                       |
+--------------------------------------------------+

    RTRIM

    RTRIM(VARBINARY X)

    Supprime les espaces de fin de X.

    Exemple :

    SELECT RTRIM(CAST('  China  ' AS VARBINARY));

    Résultat :

    +----------------------------------------+
| RTRIM(CAST('  China  ' AS VARBINARY))  |
+----------------------------------------+
|   China                                |
+----------------------------------------+

    SHA1

    SHA1(VARBINARY X)

    Renvoie la somme de contrôle SHA-1 de X.

    Exemple :

    SELECT SHA1(CAST('China' AS VARBINARY));

    Résultat :

    +------------------------------------------+
| SHA1(CAST('China' AS VARBINARY))         |
+------------------------------------------+
| d2eaf2aa1512d6596e0a5bae633537c6b8e779a3 |
+------------------------------------------+

    SHA2

    SHA2(VARBINARY X, INTEGER Y)
SHA2(VARBINARY X, VARCHAR Y)

    Renvoie la somme de contrôle SHA-2 de X. Y spécifie la longueur en bits de la sortie et doit être l'une des valeurs suivantes : 224, 256, 384, 512 ou 0. Les variantes prises en charge sont SHA-224, SHA-256, SHA-384 et SHA-512.

    Exemple :

    SELECT SHA2(CAST('China' AS VARBINARY), 256);

    Résultat :

    +------------------------------------------------------------------+
| SHA2(CAST('China' AS VARBINARY),256)                             |
+------------------------------------------------------------------+
| 10436829032f361a3de50048de41755140e581467bc1895e6c1a17f423e42d10 |
+------------------------------------------------------------------+

    SUBSTR

    SUBSTR(VARBINARY X, BIGINT Y, DOUBLE Z)
SUBSTR(VARBINARY X, DOUBLE Y, DOUBLE Z)
SUBSTR(VARBINARY X, BIGINT Y, BIGINT Z)
SUBSTR(VARBINARY X, DOUBLE Y, BIGINT Z)
SUBSTR(VARBINARY X, DOUBLE Y)
SUBSTR(VARBINARY X, BIGINT Y)

    Renvoie une sous-chaîne de X commençant à la position Y. Z spécifie le nombre de caractères à renvoyer.

    TO_BASE64

    TO_BASE64(VARBINARY X)

    Encode X au format Base64 et renvoie le résultat.

    Exemple :

    SELECT TO_BASE64(CAST('China' AS VARBINARY));

    Résultat :

    +----------------------------------------+
| TO_BASE64(CAST('China' AS VARBINARY))  |
+----------------------------------------+
| Q2hpbmE=                               |
+----------------------------------------+

    TRIM

    TRIM(VARBINARY X)

    Supprime les espaces de début et de fin de X.

    Exemple :

    SELECT TRIM(CAST('  China  ' AS VARBINARY));

    Résultat :

    +---------------------------------------+
| TRIM(CAST('  China  ' AS VARBINARY))  |
+---------------------------------------+
| China                                 |
+---------------------------------------+

    UNCOMPRESS

    UNCOMPRESS(VARBINARY X)

    Décompresse X, qui doit avoir été compressé par la fonction COMPRESS().

    Exemple :

    SELECT UNCOMPRESS(COMPRESS(CAST('China' AS VARBINARY)));

    Résultat :

    +---------------------------------------------------+
| UNCOMPRESS(COMPRESS(CAST('China' AS VARBINARY)))  |
+---------------------------------------------------+
| China                                             |
+---------------------------------------------------+

    UNCOMPRESSED_LENGTH

    UNCOMPRESSED_LENGTH(VARBINARY X)

    Renvoie la longueur de X avant compression.

    Exemple :

    SELECT UNCOMPRESSED_LENGTH(COMPRESS(CAST('China' AS VARBINARY)));

    Résultat :

    +------------------------------------------------------------+
| UNCOMPRESSED_LENGTH(COMPRESS(CAST('China' AS VARBINARY)))  |
+------------------------------------------------------------+
| 5                                                          |
+------------------------------------------------------------+

    UNHEX

    UNHEX(VARBINARY X)

    Interprète les paires de caractères de X comme des valeurs hexadécimales, les convertit en octets et renvoie le résultat sous forme de chaîne binaire. Renvoie NULL si l'entrée contient des caractères en dehors de la plage hexadécimale (0–9, A–F).

    Exemple :

    SELECT UNHEX(CAST('China' AS VARBINARY));

    Résultat :

    +------------------------------------+
| UNHEX(CAST('China' AS VARBINARY))  |
+------------------------------------+
| NULL                               |
+------------------------------------+

    Le résultat est NULL car 'China' contient des caractères en dehors de la plage hexadécimale (0–9, A–F).

    UNZIP

    Important

    Nécessite AnalyticDB for MySQL V3.1.9.3 ou une version ultérieure.

    UNZIP(VARBINARY X)

    Décompresse X au format ZIP et renvoie le résultat sous forme de chaîne binaire.

    Exemple :

    SELECT UNZIP(ZIP(CAST('China' AS VARBINARY)));

    Résultat :

    +----------------------------------------+
| UNZIP(ZIP(CAST('China' AS VARBINARY))) |
+----------------------------------------+
| China                                  |
+----------------------------------------+

    UPPER

    UPPER(VARBINARY X)

    Renvoie X en majuscules.

    Exemple :

    SELECT UPPER(CAST('abc' AS VARBINARY));

    Résultat :

    +---------------------------------+
| UPPER(CAST('abc' AS VARBINARY)) |
+---------------------------------+
| ABC                             |
+---------------------------------+

    ZIP

    Important

    Nécessite AnalyticDB for MySQL V3.1.9.3 ou une version ultérieure.

    ZIP(VARBINARY X)

    Compresse X au format ZIP et renvoie le résultat sous forme de chaîne binaire. Utilisez HEX() pour afficher le résultat sous forme de texte lisible.

    Exemple :

    SELECT UNZIP(ZIP(CAST('China' AS VARBINARY)));

    Résultat :

    +----------------------------------------+
| UNZIP(ZIP(CAST('China' AS VARBINARY))) |
+----------------------------------------+
| China                                  |
+----------------------------------------+