SQL - Fonctions de chaîne
Les fonctions de chaîne SQL sont principalement utilisées pour la manipulation de chaînes. Le tableau suivant détaille les fonctions de chaîne importantes -
| N ° Sr. | Description de la fonction |
|---|---|
| 1 | ASCII () Renvoie la valeur numérique du caractère le plus à gauche |
| 2 | POUBELLE() Renvoie une représentation sous forme de chaîne de l'argument |
| 3 | BIT_LENGTH () Renvoie la longueur de l'argument en bits |
| 4 | CHAR_LENGTH () Renvoie le nombre de caractères dans l'argument |
| 5 | CARBONISER() Renvoie le caractère pour chaque entier passé |
| 6 | CHARACTER_LENGTH () Un synonyme de CHAR_LENGTH () |
| sept | CONCAT_WS () Renvoie concaténer avec séparateur |
| 8 | CONCAT () Renvoie une chaîne concaténée |
| 9 | CONV () Convertit les nombres entre différentes bases de nombres |
| dix | ELT () Renvoie la chaîne au numéro d'index |
| 11 | EXPORT_SET () Renvoie une chaîne telle que pour chaque bit défini dans les bits de valeur, vous obtenez une chaîne on et pour chaque bit non défini, vous obtenez une chaîne off |
| 12 | CHAMP() Renvoie l'index (position) du premier argument dans les arguments suivants |
| 13 | FIND_IN_SET () Renvoie la position d'index du premier argument dans le deuxième argument |
| 14 | FORMAT() Renvoie un nombre formaté au nombre spécifié de décimales |
| 15 | HEX () Renvoie une représentation sous forme de chaîne d'une valeur hexadécimale |
| 16 | INSÉRER() Insère une sous-chaîne à la position spécifiée jusqu'au nombre de caractères spécifié |
| 17 | INSTR () Renvoie l'index de la première occurrence de sous-chaîne |
| 18 | LCASE () Synonyme de LOWER () |
| 19 | LA GAUCHE() Renvoie le nombre de caractères le plus à gauche comme spécifié |
| 20 | LONGUEUR() Renvoie la longueur d'une chaîne en octets |
| 21 | FICHIER DE CHARGEMENT() Charge le fichier nommé |
| 22 | LOCALISER() Renvoie la position de la première occurrence de sous-chaîne |
| 23 | INFÉRIEUR() Renvoie l'argument en minuscules |
| 24 | LPAD () Renvoie l'argument de chaîne, complété à gauche avec la chaîne spécifiée |
| 25 | LTRIM () Supprime les espaces principaux |
| 26 | MAKE_SET () Renvoie un ensemble de chaînes séparées par des virgules dont le bit correspondant en bits est défini |
| 27 | MILIEU() Renvoie une sous-chaîne à partir de la position spécifiée |
| 28 | OCT() Renvoie une représentation sous forme de chaîne de l'argument octal |
| 29 | OCTET_LENGTH () Un synonyme de LENGTH () |
| 30 | ORD () Si le caractère le plus à gauche de l'argument est un caractère multi-octets, renvoie le code de ce caractère |
| 31 | POSITION() Un synonyme de LOCATE () |
| 32 | CITATION() Échappe l'argument à utiliser dans une instruction SQL |
| 33 | REGEXP Correspondance de modèles à l'aide d'expressions régulières |
| 34 | RÉPÉTER() Répète une chaîne le nombre de fois spécifié |
| 35 | REMPLACER() Remplace les occurrences d'une chaîne spécifiée |
| 36 | INVERSER() Inverse les caractères d'une chaîne |
| 37 | DROITE() Renvoie le nombre de caractères le plus à droite spécifié |
| 38 | RPAD () Ajoute la chaîne le nombre de fois spécifié |
| 39 | RTRIM () Supprime les espaces de fin |
| 40 | SONDEX () Renvoie une chaîne soundex |
| 41 | SONORITÉS COMME Compare les sons |
| 42 | ESPACE() Renvoie une chaîne du nombre d'espaces spécifié |
| 43 | STRCMP () Compare deux chaînes |
| 44 | SUBSTRING_INDEX () Renvoie une sous-chaîne d'une chaîne avant le nombre d'occurrences spécifié du délimiteur |
| 45 | SUBSTRING (), SUBSTR () Renvoie la sous-chaîne comme spécifié |
| 46 | RÉDUIRE() Supprime les espaces de début et de fin |
| 47 | UCASE () Synonyme de UPPER () |
| 48 | UNHEX () Convertit chaque paire de chiffres hexadécimaux en caractère |
| 49 | PLUS HAUT() Convertit en majuscules |
ASCII (chaîne)
Renvoie la valeur numérique du caractère le plus à gauche de la chaîne str. Renvoie 0 si str est la chaîne vide. Renvoie NULL si str est NULL. ASCII () fonctionne pour les caractères avec des valeurs numériques de 0 à 255.
SQL> SELECT ASCII('2');
+---------------------------------------------------------+
| ASCII('2') |
+---------------------------------------------------------+
| 50 |
+---------------------------------------------------------+
1 row in set (0.00 sec)
SQL> SELECT ASCII('dx');
+---------------------------------------------------------+
| ASCII('dx') |
+---------------------------------------------------------+
| 100 |
+---------------------------------------------------------+
1 row in set (0.00 sec)BIN (N)
Renvoie une représentation sous forme de chaîne de la valeur binaire de N, où N est un nombre long (BIGINT). Cela équivaut à CONV (N, 10,2). Renvoie NULL si N est NULL.
SQL> SELECT BIN(12);
+---------------------------------------------------------+
| BIN(12) |
+---------------------------------------------------------+
| 1100 |
+---------------------------------------------------------+
1 row in set (0.00 sec)BIT_LENGTH (chaîne)
Renvoie la longueur de la chaîne str en bits.
SQL> SELECT BIT_LENGTH('text');
+---------------------------------------------------------+
| BIT_LENGTH('text') |
+---------------------------------------------------------+
| 32 |
+---------------------------------------------------------+
1 row in set (0.00 sec)CHAR (N, ... [USING charset_name])
CHAR () interprète chaque argument N comme un entier et retourne une chaîne composée des caractères donnés par les valeurs de code de ces entiers. Les valeurs NULL sont ignorées.
SQL> SELECT CHAR(77,121,83,81,'76');
+---------------------------------------------------------+
| CHAR(77,121,83,81,'76') |
+---------------------------------------------------------+
| MySQL |
+---------------------------------------------------------+
1 row in set (0.00 sec)CHAR_LENGTH (chaîne)
Renvoie la longueur de la chaîne str mesurée en caractères. Un caractère multi-octets compte comme un caractère unique. Cela signifie que pour une chaîne contenant cinq caractères de deux octets, LENGTH () renvoie 10, tandis que CHAR_LENGTH () renvoie 5.
SQL> SELECT CHAR_LENGTH("text");
+---------------------------------------------------------+
| CHAR_LENGTH("text") |
+---------------------------------------------------------+
| 4 |
+---------------------------------------------------------+
1 row in set (0.00 sec)CHARACTER_LENGTH (chaîne)
CHARACTER_LENGTH () est un synonyme de CHAR_LENGTH ().
CONCAT (str1, str2, ...)
Renvoie la chaîne qui résulte de la concaténation des arguments. Peut avoir un ou plusieurs arguments. Si tous les arguments sont des chaînes non binaires, le résultat est une chaîne non binaire. Si les arguments incluent des chaînes binaires, le résultat est une chaîne binaire. Un argument numérique est converti en sa forme de chaîne binaire équivalente; si vous voulez éviter cela, vous pouvez utiliser un cast de type explicite, comme dans cet exemple -
SQL> SELECT CONCAT('My', 'S', 'QL');
+---------------------------------------------------------+
| CONCAT('My', 'S', 'QL') |
+---------------------------------------------------------+
| MySQL |
+---------------------------------------------------------+
1 row in set (0.00 sec)CONCAT_WS (séparateur, str1, str2, ...)
CONCAT_WS () signifie Concatenate With Separator et est une forme spéciale de CONCAT (). Le premier argument est le séparateur du reste des arguments. Le séparateur est ajouté entre les chaînes à concaténer. Le séparateur peut être une chaîne, tout comme le reste des arguments. Si le séparateur est NULL, le résultat est NULL.
SQL> SELECT CONCAT_WS(',','First name','Last Name' );
+---------------------------------------------------------+
| CONCAT_WS(',','First name','Last Name' ) |
+---------------------------------------------------------+
| First name,Last Name |
+---------------------------------------------------------+
1 row in set (0.00 sec)CONV (N, from_base, to_base)
Convertit les nombres entre différentes bases de nombres. Renvoie une représentation sous forme de chaîne du nombre N, converti de la base from_base à to_base. Renvoie NULL si un argument est NULL. L'argument N est interprété comme un entier, mais peut être spécifié comme un entier ou une chaîne. La base minimale est 2 et la base maximale est 36. Si to_base est un nombre négatif, N est considéré comme un nombre signé. Sinon, N est traité comme non signé. CONV () fonctionne avec une précision de 64 bits.
SQL> SELECT CONV('a',16,2);
+---------------------------------------------------------+
| CONV('a',16,2) |
+---------------------------------------------------------+
| 1010 |
+---------------------------------------------------------+
1 row in set (0.00 sec)ELT (N, str1, str2, str3, ...)
Renvoie str1 si N = 1, str2 si N = 2, et ainsi de suite. Renvoie NULL si N est inférieur à 1 ou supérieur au nombre d'arguments. ELT () est le complément de FIELD ().
SQL> SELECT ELT(1, 'ej', 'Heja', 'hej', 'foo');
+---------------------------------------------------------+
| ELT(1, 'ej', 'Heja', 'hej', 'foo') |
+---------------------------------------------------------+
| ej |
+---------------------------------------------------------+
1 row in set (0.00 sec)EXPORT_SET (bits, on, off [, separator [, number_of_bits]])
Renvoie une chaîne telle que pour chaque bit défini dans les bits de valeur, vous obtenez une chaîne on et pour chaque bit non défini dans la valeur, vous obtenez une chaîne off. Les bits en bits sont examinés de droite à gauche (des bits de poids faible aux bits de poids fort). Les chaînes sont ajoutées au résultat de gauche à droite, séparées par la chaîne de séparation (la valeur par défaut étant la virgule.,.). Le nombre de bits examinés est donné par number_of_bits (64 par défaut).
SQL> SELECT EXPORT_SET(5,'Y','N',',',4);
+---------------------------------------------------------+
| EXPORT_SET(5,'Y','N',',',4) |
+---------------------------------------------------------+
| Y,N,Y,N |
+---------------------------------------------------------+
1 row in set (0.00 sec)CHAMP (str, str1, str2, str3, ...)
Renvoie l'index (position commençant par 1) de str dans la liste str1, str2, str3, ... Renvoie 0 si str n'est pas trouvé.
SQL> SELECT FIELD('ej', 'Hej', 'ej', 'Heja', 'hej', 'foo');
+---------------------------------------------------------+
| FIELD('ej', 'Hej', 'ej', 'Heja', 'hej', 'foo') |
+---------------------------------------------------------+
| 2 |
+---------------------------------------------------------+
1 row in set (0.00 sec)FIND_IN_SET (chaîne, liste de chaînes)
Renvoie une valeur comprise entre 1 et N si la chaîne str est dans la liste de chaînes strlist composée de N sous-chaînes.
SQL> SELECT FIND_IN_SET('b','a,b,c,d');
+---------------------------------------------------------+
| SELECT FIND_IN_SET('b','a,b,c,d') |
+---------------------------------------------------------+
| 2 |
+---------------------------------------------------------+
1 row in set (0.00 sec)FORMAT (X, D)
Formate le nombre X dans un format tel que '#, ###, ###. ##', arrondi à D décimales, et renvoie le résultat sous forme de chaîne. Si D est 0, le résultat n'a pas de point décimal ni de partie fractionnaire.
SQL> SELECT FORMAT(12332.123456, 4);
+---------------------------------------------------------+
| FORMAT(12332.123456, 4) |
+---------------------------------------------------------+
| 12,332.1235 |
+---------------------------------------------------------+
1 row in set (0.00 sec)HEX (N_or_S)
Si N_or_S est un nombre, renvoie une représentation sous forme de chaîne de la valeur hexadécimale de N, où N est un nombre long (BIGINT). Cela équivaut à CONV (N, 10,16).
Si N_or_S est une chaîne, renvoie une représentation sous forme de chaîne hexadécimale de N_or_S où chaque caractère de N_or_S est converti en deux chiffres hexadécimaux.
SQL> SELECT HEX(255);
+---------------------------------------------------------+
| HEX(255) |
+---------------------------------------------------------+
| FF |
+---------------------------------------------------------+
1 row in set (0.00 sec)
SQL> SELECT 0x616263;
+---------------------------------------------------------+
| 0x616263 |
+---------------------------------------------------------+
| abc |
+---------------------------------------------------------+
1 row in set (0.00 sec)INSERT (str, pos, len, newstr)
Renvoie la chaîne str, avec la sous-chaîne commençant à la position pos et les caractères len longs remplacés par la chaîne newstr. Renvoie la chaîne d'origine si pos n'est pas compris dans la longueur de la chaîne. Remplace le reste de la chaîne de la position pos si len n'est pas dans la longueur du reste de la chaîne. Renvoie NULL si un argument est NULL.
SQL> SELECT INSERT('Quadratic', 3, 4, 'What');
+---------------------------------------------------------+
| INSERT('Quadratic', 3, 4, 'What') |
+---------------------------------------------------------+
| QuWhattic |
+---------------------------------------------------------+
1 row in set (0.00 sec)INSTR (chaîne, sous)
Renvoie la position de la première occurrence de sous-chaîne substr dans la chaîne str. C'est la même chose que la forme à deux arguments de LOCATE (), sauf que l'ordre des arguments est inversé.
SQL> SELECT INSTR('foobarbar', 'bar');
+---------------------------------------------------------+
| INSTR('foobarbar', 'bar') |
+---------------------------------------------------------+
| 4 |
+---------------------------------------------------------+
1 row in set (0.00 sec)LCASE (str)
LCASE () est un synonyme de LOWER ().
GAUCHE (str, len)
Renvoie les caractères len les plus à gauche de la chaîne str, ou NULL si un argument est NULL.
SQL> SELECT LEFT('foobarbar', 5);
+---------------------------------------------------------+
| LEFT('foobarbar', 5) |
+---------------------------------------------------------+
| fooba |
+---------------------------------------------------------+
1 row in set (0.00 sec)LONGUEUR (str)
Renvoie la longueur de la chaîne str, mesurée en octets. Un caractère multi-octets compte pour plusieurs octets. Cela signifie que pour une chaîne contenant cinq caractères de deux octets, LENGTH () renvoie 10, tandis que CHAR_LENGTH () renvoie 5.
SQL> SELECT LENGTH('text');
+---------------------------------------------------------+
| LENGTH('text') |
+---------------------------------------------------------+
| 4 |
+---------------------------------------------------------+
1 row in set (0.00 sec)LOAD_FILE (nom_fichier)
Lit le fichier et renvoie le contenu du fichier sous forme de chaîne. Pour utiliser cette fonction, le fichier doit être situé sur l'hôte du serveur, vous devez spécifier le chemin d'accès complet au fichier et vous devez disposer du privilège FILE. Le fichier doit être lisible par tous et sa taille doit être inférieure à max_allowed_packet octets.
Si le fichier n'existe pas ou ne peut pas être lu car l'une des conditions précédentes n'est pas satisfaite, la fonction renvoie NULL.
Depuis SQL 5.0.19, la variable système character_set_filesystem contrôle l'interprétation des noms de fichiers donnés sous forme de chaînes littérales.
SQL> UPDATE table_test
-> SET blob_col=LOAD_FILE('/tmp/picture')
-> WHERE id=1;
...........................................................LOCATE (substr, str), LOCATE (substr, str, pos)
La première syntaxe renvoie la position de la première occurrence de sous-chaîne substr dans la chaîne str. La seconde syntaxe renvoie la position de la première occurrence de substring substr dans la chaîne str, en commençant à la position pos. Renvoie 0 si substr n'est pas dans str.
SQL> SELECT LOCATE('bar', 'foobarbar');
+---------------------------------------------------------+
| LOCATE('bar', 'foobarbar') |
+---------------------------------------------------------+
| 4 |
+---------------------------------------------------------+
1 row in set (0.00 sec)INFÉRIEUR (str)
Renvoie la chaîne str avec tous les caractères modifiés en minuscules en fonction du mappage du jeu de caractères actuel.
SQL> SELECT LOWER('QUADRATICALLY');
+---------------------------------------------------------+
| LOWER('QUADRATICALLY') |
+---------------------------------------------------------+
| quadratically |
+---------------------------------------------------------+
1 row in set (0.00 sec)LPAD (str, len, padstr)
Renvoie la chaîne str, complétée à gauche avec la chaîne padstr à une longueur de caractères len. Si str est plus long que len, la valeur de retour est raccourcie en caractères len.
SQL> SELECT LPAD('hi',4,'??');
+---------------------------------------------------------+
| LPAD('hi',4,'??') |
+---------------------------------------------------------+
| ??hi |
+---------------------------------------------------------+
1 row in set (0.00 sec)LTRIM (str)
Renvoie la chaîne str avec les espaces de début supprimés.
SQL> SELECT LTRIM(' barbar');
+---------------------------------------------------------+
| LTRIM(' barbar') |
+---------------------------------------------------------+
| barbar |
+---------------------------------------------------------+
1 row in set (0.00 sec)MAKE_SET (bits, chaîne1, chaîne2, ...)
Renvoie une valeur définie (une chaîne contenant des sous-chaînes séparées par.,. Caractères) constituée des chaînes dont le bit correspondant en bits est défini. str1 correspond au bit 0, str2 au bit 1, et ainsi de suite. Les valeurs NULL dans str1, str2, ... ne sont pas ajoutées au résultat.
SQL> SELECT MAKE_SET(1,'a','b','c');
+---------------------------------------------------------+
| MAKE_SET(1,'a','b','c') |
+---------------------------------------------------------+
| a |
+---------------------------------------------------------+
1 row in set (0.00 sec)MID (str, pos, len)
MID (str, pos, len) est un synonyme de SUBSTRING (str, pos, len).
OCT (N)
Renvoie une représentation sous forme de chaîne de la valeur octale de N, où N est un nombre long (BIGINT). Cela équivaut à CONV (N, 10,8). Renvoie NULL si N est NULL.
SQL> SELECT OCT(12);
+---------------------------------------------------------+
| OCT(12) |
+---------------------------------------------------------+
| 14 |
+---------------------------------------------------------+
1 row in set (0.00 sec)OCTET_LENGTH (chaîne)
OCTET_LENGTH () est un synonyme de LENGTH ().
ORD (str)
Si le caractère le plus à gauche de la chaîne str est un caractère multi-octets, renvoie le code de ce caractère, calculé à partir des valeurs numériques de ses octets constituants à l'aide de cette formule -
(1st byte code)
+ (2nd byte code . 256)
+ (3rd byte code . 2562) ...Si le caractère le plus à gauche n'est pas un caractère multi-octets, ORD () renvoie la même valeur que la fonction ASCII ().
SQL> SELECT ORD('2');
+---------------------------------------------------------+
| ORD('2') |
+---------------------------------------------------------+
| 50 |
+---------------------------------------------------------+
1 row in set (0.00 sec)POSITION (substr IN str)
POSITION (substr IN str) est un synonyme de LOCATE (substr, str).
DEVIS (str)
Cite une chaîne pour produire un résultat qui peut être utilisé comme valeur de données correctement échappée dans une instruction SQL. La chaîne est renvoyée entre guillemets simples et avec chaque instance de guillemet simple ('), barre oblique inverse (' \ '), ASCII NUL et Control-Z précédée d'une barre oblique inverse. Si l'argument est NULL, la valeur de retour est le mot «NULL» sans les guillemets simples.
SQL> SELECT QUOTE('Don\'t!');
+---------------------------------------------------------+
| QUOTE('Don\'t!') |
+---------------------------------------------------------+
| 'Don\'t!' |
+---------------------------------------------------------+
1 row in set (0.00 sec)NOTE - Veuillez vérifier si votre installation a un bogue avec cette fonction, puis n'utilisez pas cette fonction.
expression REGEXP modèle
Cette fonction effectue une correspondance de motif de expr par rapport à motif. Renvoie 1 si expr correspond à pat; sinon, il renvoie 0. Si expr ou pat est NULL, le résultat est NULL. REGEXP n'est pas sensible à la casse, sauf lorsqu'il est utilisé avec des chaînes binaires.
SQL> SELECT 'ABCDEF' REGEXP 'A%C%%';
+---------------------------------------------------------+
| 'ABCDEF' REGEXP 'A%C%%' |
+---------------------------------------------------------+
| 0 |
+---------------------------------------------------------+
1 row in set (0.00 sec)Un autre exemple est -
SQL> SELECT 'ABCDE' REGEXP '.*';
+---------------------------------------------------------+
| 'ABCDE' REGEXP '.*' |
+---------------------------------------------------------+
| 1 |
+---------------------------------------------------------+
1 row in set (0.00 sec)Voyons un autre exemple -
SQL> SELECT 'new*\n*line' REGEXP 'new\\*.\\*line';
+---------------------------------------------------------+
| 'new*\n*line' REGEXP 'new\\*.\\*line' |
+---------------------------------------------------------+
| 1 |
+---------------------------------------------------------+
1 row in set (0.00 sec)REPEAT (str, count)
Renvoie une chaîne composée de la chaîne str répétée nombre de fois. Si count est inférieur à 1, renvoie une chaîne vide. Renvoie NULL si str ou count sont NULL.
SQL> SELECT REPEAT('SQL', 3);
+---------------------------------------------------------+
| REPEAT('SQL', 3) |
+---------------------------------------------------------+
| SQLSQLSQL |
+---------------------------------------------------------+
1 row in set (0.00 sec)REMPLACER (str, from_str, to_str)
Renvoie la chaîne str avec toutes les occurrences de la chaîne from_str remplacées par la chaîne to_str. REPLACE () effectue une correspondance sensible à la casse lors de la recherche de from_str.
SQL> SELECT REPLACE('www.mysql.com', 'w', 'Ww');
+---------------------------------------------------------+
| REPLACE('www.mysql.com', 'w', 'Ww') |
+---------------------------------------------------------+
| WwWwWw.mysql.com |
+---------------------------------------------------------+
1 row in set (0.00 sec)INVERSE (str)
Renvoie la chaîne str avec l'ordre des caractères inversé.
SQL> SELECT REVERSE('abcd');
+---------------------------------------------------------+
| REVERSE('abcd') |
+---------------------------------------------------------+
| dcba |
+---------------------------------------------------------+
1 row in set (0.00 sec)DROITE (str, len)
Renvoie les caractères len les plus à droite de la chaîne str, ou NULL si un argument est NULL.
SQL> SELECT RIGHT('foobarbar', 4);
+---------------------------------------------------------+
| RIGHT('foobarbar', 4) |
+---------------------------------------------------------+
| rbar |
+---------------------------------------------------------+
1 row in set (0.00 sec)RPAD (str, len, padstr)
Renvoie la chaîne str, complétée à droite avec la chaîne padstr à une longueur de len caractères. Si str est plus long que len, la valeur de retour est raccourcie en caractères len.
SQL> SELECT RPAD('hi',5,'?');
+---------------------------------------------------------+
| RPAD('hi',5,'?') |
+---------------------------------------------------------+
| hi??? |
+---------------------------------------------------------+
1 row in set (0.00 sec)RTRIM (str)
Renvoie la chaîne str avec les espaces de fin supprimés.
SQL> SELECT RTRIM('barbar ');
+---------------------------------------------------------+
| RTRIM('barbar ') |
+---------------------------------------------------------+
| barbar |
+---------------------------------------------------------+
1 row in set (0.00 sec)SOUNDEX (str)
Renvoie une chaîne soundex de str. Deux cordes qui sonnent presque de la même manière doivent avoir des cordes soundex identiques. Une chaîne soundex standard comporte quatre caractères, mais la fonction SOUNDEX () renvoie une chaîne arbitrairement longue. Vous pouvez utiliser SUBSTRING () sur le résultat pour obtenir une chaîne soundex standard. Tous les caractères non alphabétiques de str sont ignorés. Tous les caractères alphabétiques internationaux en dehors de la plage AZ sont traités comme des voyelles.
SQL> SELECT SOUNDEX('Hello');
+---------------------------------------------------------+
| SOUNDEX('Hello') |
+---------------------------------------------------------+
| H400 |
+---------------------------------------------------------+
1 row in set (0.00 sec)expr1 SONORE COMME expr2
C'est la même chose que SOUNDEX (expr1) = SOUNDEX (expr2).
ESPACE (N)
Renvoie une chaîne composée de N caractères d'espace.
SQL> SELECT SPACE(6);
+---------------------------------------------------------+
| SELECT SPACE(6) |
+---------------------------------------------------------+
| ' ' |
+---------------------------------------------------------+
1 row in set (0.00 sec)STRCMP (str1, str2)
Compare deux chaînes et renvoie 0 si les deux chaînes sont égales, renvoie -1 si le premier argument est plus petit que le second selon l'ordre de tri actuel, sinon il renvoie 1.
SQL> SELECT STRCMP('MOHD', 'MOHD');
+---------------------------------------------------------+
| STRCMP('MOHD', 'MOHD') |
+---------------------------------------------------------+
| 0 |
+---------------------------------------------------------+
1 row in set (0.00 sec)Un autre exemple est -
SQL> SELECT STRCMP('AMOHD', 'MOHD');
+---------------------------------------------------------+
| STRCMP('AMOHD', 'MOHD') |
+---------------------------------------------------------+
| -1 |
+---------------------------------------------------------+
1 row in set (0.00 sec)Voyons un autre exemple -
SQL> SELECT STRCMP('MOHD', 'AMOHD');
+---------------------------------------------------------+
| STRCMP('MOHD', 'AMOHD') |
+---------------------------------------------------------+
| 1 |
+---------------------------------------------------------+
1 row in set (0.00 sec)SUBSTRING (str, pos)
SUBSTRING (str FROM pos)
SUBSTRING (str, pos, len)
SUBSTRING (str FROM pos FOR len)
Les formulaires sans argument len renvoient une sous-chaîne de la chaîne str à partir de la position pos. Les formulaires avec un argument len renvoient une sous-chaîne len caractères longue à partir de la chaîne str, en commençant à la position pos. Les formulaires qui utilisent FROM sont la syntaxe SQL standard. Il est également possible d'utiliser une valeur négative pour pos. Dans ce cas, le début de la sous-chaîne correspond aux caractères pos à partir de la fin de la chaîne, plutôt qu'au début. Une valeur négative peut être utilisée pour pos dans n'importe laquelle des formes de cette fonction.
SQL> SELECT SUBSTRING('Quadratically',5);
+---------------------------------------------------------+
| SSUBSTRING('Quadratically',5) |
+---------------------------------------------------------+
| ratically |
+---------------------------------------------------------+
1 row in set (0.00 sec)
SQL> SELECT SUBSTRING('foobarbar' FROM 4);
+---------------------------------------------------------+
| SUBSTRING('foobarbar' FROM 4) |
+---------------------------------------------------------+
| barbar |
+---------------------------------------------------------+
1 row in set (0.00 sec)
SQL> SELECT SUBSTRING('Quadratically',5,6);
+---------------------------------------------------------+
| SUBSTRING('Quadratically',5,6) |
+---------------------------------------------------------+
| ratica |
+---------------------------------------------------------+
1 row in set (0.00 sec)SUBSTRING_INDEX (chaîne, délimitation, nombre)
Renvoie la sous-chaîne de la chaîne str avant de compter les occurrences du délimiteur. Si count est positif, tout ce qui se trouve à gauche du délimiteur final (en partant de la gauche) est renvoyé. Si count est négatif, tout ce qui se trouve à droite du délimiteur final (en partant de la droite) est renvoyé. SUBSTRING_INDEX () effectue une correspondance sensible à la casse lors de la recherche de délimitation.
SQL> SELECT SUBSTRING_INDEX('www.mysql.com', '.', 2);
+---------------------------------------------------------+
| SUBSTRING_INDEX('www.mysql.com', '.', 2) |
+---------------------------------------------------------+
| www.mysql |
+---------------------------------------------------------+
1 row in set (0.00 sec)TRIM ([{BOTH | LEADING | TRAILING} [remstr] FROM] str)
TRIM ([remstr FROM] str)
Renvoie la chaîne str avec tous les préfixes ou suffixes remstr supprimés. Si aucun des spécificateurs BOTH, LEADING ou TRAILING n'est indiqué, BOTH est supposé. remstr est facultatif et, s'il n'est pas spécifié, les espaces sont supprimés.
SQL> SELECT TRIM(' bar ');
+---------------------------------------------------------+
| TRIM(' bar ') |
+---------------------------------------------------------+
| bar |
+---------------------------------------------------------+
1 row in set (0.00 sec)
SQL> SELECT TRIM(LEADING 'x' FROM 'xxxbarxxx');
+---------------------------------------------------------+
| TRIM(LEADING 'x' FROM 'xxxbarxxx') |
+---------------------------------------------------------+
| barxxx |
+---------------------------------------------------------+
1 row in set (0.00 sec)
SQL> SELECT TRIM(BOTH 'x' FROM 'xxxbarxxx');
+---------------------------------------------------------+
| TRIM(BOTH 'x' FROM 'xxxbarxxx') |
+---------------------------------------------------------+
| bar |
+---------------------------------------------------------+
1 row in set (0.00 sec)
SQL> SELECT TRIM(TRAILING 'xyz' FROM 'barxxyz');
+---------------------------------------------------------+
| TRIM(TRAILING 'xyz' FROM 'barxxyz') |
+---------------------------------------------------------+
| barx |
+---------------------------------------------------------+
1 row in set (0.00 sec)UCASE (str)
UCASE () est un synonyme de UPPER ().
UNHEX (str)
Effectue l'opération inverse de HEX (str). Autrement dit, il interprète chaque paire de chiffres hexadécimaux de l'argument comme un nombre et le convertit en caractère représenté par le nombre. Les caractères résultants sont renvoyés sous forme de chaîne binaire.
SQL> SELECT UNHEX('4D7953514C');
+---------------------------------------------------------+
| UNHEX('4D7953514C') |
+---------------------------------------------------------+
| SQL |
+---------------------------------------------------------+
1 row in set (0.00 sec)Les caractères de la chaîne d'argument doivent être des chiffres hexadécimaux autorisés: "0" .. "9", "A" .. "F", "a" .. "f". Si UNHEX () rencontre des chiffres non hexadécimaux dans l'argument, il renvoie NULL.
SUPÉRIEUR (str)
Renvoie la chaîne str avec tous les caractères modifiés en majuscules en fonction du mappage du jeu de caractères actuel.
SQL> SELECT UPPER('Allah-hus-samad');
+---------------------------------------------------------+
| UPPER('Allah-hus-samad') |
+---------------------------------------------------------+
| ALLAH-HUS-SAMAD |
+---------------------------------------------------------+
1 row in set (0.00 sec)