SQL string functions are used primarily for string manipulation. The following table details the important string functions −
| Sr.No., SUBSTR()
Returns the substring as specified |
|
|---|---|
| 46 | TRIM()
Removes leading and trailing spaces |
| 47 | UCASE()
Synonym for UPPER() |
| 48 | UNHEX()
Converts each pair of hexadecimal digits to a character |
| 49 | UPPER()
Converts to uppercase |
ASCII(str)
Returns the numeric value of the leftmost character of the string 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 en chaîne de la valeur binaire de N, où N est un nombre longlong (BIGINT). Ceci est équivalent à 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(str)
Retourne 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,…, )
CHAR () interprète chaque argument N comme un entier et renvoie 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(str)
renvoie la longueur de la chaîne str mesurée en caractères. Un caractère multi-octets compte comme un seul caractère. 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(str)
CHARACTER_LENGTH() est un synonyme de CHAR_LENGTH().,
CONCAT(str1,str2,…)
renvoie la chaîne résultant 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 type explicite cast,comme dans cet exemple −
SQL> SELECT CONCAT('My', 'S', 'QL');+---------------------------------------------------------+| CONCAT('My', 'S', 'QL') |+---------------------------------------------------------+| MySQL |+---------------------------------------------------------+1 row in set (0.00 sec)
CONCAT_WS(separator,str1, str2,…,)
CONCAT_WS () signifie Concatenate With Separator et est une forme spéciale de CONCAT (). Le premier argument est le séparateur pour le reste des arguments. Le séparateur est ajouté entre les chaînes concaténées. 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 numériques. Renvoie une représentation de chaîne du nombre N, convertie de la base from_base en 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 de caractères. La base minimale est de 2 et la base maximale est de 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])
Renvoie une chaîne telle que pour chaque ensemble de bits de la valeur des bits, vous obtenez une chaîne et pour chaque bit pas la valeur, vous obtenez une chaîne de caractères. Les Bits dans les bits sont examinés de droite à gauche (des bits d’ordre faible aux bits d’ordre Élevé). 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 le caractère virgule .,.). Le nombre de bits examinés est donné par number_of_bits (par défaut 64).
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 le str1, str2, str3, … liste. 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(str,strlist)
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)
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 en chaîne de la valeur hexadécimale de N, où N est un nombre longlong (BIGINT). Ceci est équivalent à CONV (N,10,16).,
Si N_or_S est une chaîne, renvoie une représentation 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, la sous-chaîne commençant à la position pos et les caractères Len étant remplacés par la chaîne newstr. Renvoie la chaîne d’origine si pos n’est pas 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(str,substr)
Renvoie la position de la première occurrence de la 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 pour le BAS().
LEFT(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)
Retourne la longueur de la chaîne str, mesurée en octets., Un caractère multi-octets compte comme 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 inférieure à max_allowed_packet octets.,
Si le fichier n’existe pas ou ne peut pas être lu parce que 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 qui sont donnés sous forme de chaînes littérales.
SQL> UPDATE table_test -> SET blob_col=LOAD_FILE('/tmp/picture')-> WHERE id=1;...........................................................
LOCALISER(substr,str), RECHERCHEZ(substr,str,pos)
La première syntaxe renvoie la position de la première occurrence de la sous-chaîne substr dans la chaîne str. La seconde syntaxe renvoie la position de la première occurrence de la sous-chaîne substr dans la chaîne str, en commençant par 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)
LOWER(str)
renvoie la chaîne str avec tous les caractères changés en minuscules selon le 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 caractères d’espace de début supprimés.,
SQL> SELECT LTRIM(' barbar');+---------------------------------------------------------+| LTRIM(' barbar') |+---------------------------------------------------------+| barbar |+---------------------------------------------------------+1 row in set (0.00 sec)
MAKE_SET(bits,str1,str2,…)
renvoie une valeur définie (une chaîne contenant des sous-chaînes séparées par .,. caractères) composé des chaînes qui ont le bit correspondant en bits défini. str1 correspond au bit 0, str2 au bit 1, etc. Valeurs nulles dans str1, str2,… ne sont pas ajoutés 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 sous-chaîne(str,pos,len).
OCT(N)
renvoie une représentation de chaîne de la valeur octale de N, où N est un nombre longlong (BIGINT)., Ceci est équivalent à 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(str)
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 constitutifs en utilisant 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 DANS str)
POSITION(substr DANS str) est un synonyme pour les LOCALISER(substr,str).
QUOTE(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 entourée de 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 guillemets simples.,
SQL> SELECT QUOTE('Don\'t!');+---------------------------------------------------------+| QUOTE('Don\'t!') |+---------------------------------------------------------+| 'Don\'t!' |+---------------------------------------------------------+1 row in set (0.00 sec)
Remarque − Veuillez vérifier si votre installation a un bogue avec cette fonction, alors n’utilisez pas cette fonction.
expr REGEXP pattern
Cette fonction effectue une correspondance entre expr et pattern. 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)
nous allons voir un exemple de plus −
SQL> SELECT 'new*\n*line' REGEXP 'new\\*.\\*line';+---------------------------------------------------------+| 'new*\n*line' REGEXP 'new\\*.\\*line' |+---------------------------------------------------------+| 1 |+---------------------------------------------------------+1 row in set (0.00 sec)
REPEAT(str,comte)
Renvoie une chaîne constituée de la chaîne str, répété count fois. Si count est inférieur à 1, renvoie une chaîne vide. Renvoie NULL si str ou count sont nuls.
SQL> SELECT REPEAT('SQL', 3);+---------------------------------------------------------+| REPEAT('SQL', 3) |+---------------------------------------------------------+| SQLSQLSQL |+---------------------------------------------------------+1 row in set (0.00 sec)
REMPLACER(str,from_str,to_str)
Retourne la chaîne str avec toutes les occurrences de la chaîne from_str remplacée 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)
INVERSER(str)
Retourne la chaîne str avec l’ordre des caractères inversés.
SQL> SELECT REVERSE('abcd');+---------------------------------------------------------+| REVERSE('abcd') |+---------------------------------------------------------+| dcba |+---------------------------------------------------------+1 row in set (0.00 sec)
RIGHT(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 caractères len. 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 caractères d’espace 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 chaînes qui sonnent presque la même chose devraient avoir des chaînes soundex identiques. Une chaîne soundex standard est longue de 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 dans str sont ignorés., Tous les caractères alphabétiques internationaux en dehors de la plage A-Z sont traités comme des voyelles.
SQL> SELECT SOUNDEX('Hello');+---------------------------------------------------------+| SOUNDEX('Hello') |+---------------------------------------------------------+| H400 |+---------------------------------------------------------+1 row in set (0.00 sec)
expr1 sonne comme expr2
c’est la même chose que SOUNDEX(expr1) = SOUNDEX(expr2).
SPACE(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, il 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)
sous-chaîne(str de pos)
sous-chaîne(str de pos pour len)
Les formulaires sans argument Len renvoient une sous-chaîne de la chaîne str commençant à la Position pos. Les formulaires avec un argument len renvoient une sous-chaîne Len long de la chaîne str, en commençant par la position pos. Les formulaires qui utilisent FROM sont une 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 est constitué de caractères pos à partir de la fin de la chaîne, plutôt que du début. Une valeur négative peut être utilisée pour pos dans l’une des formes de cette fonction.
SUBSTRING_INDEX(str,delim,count)
renvoie la sous-chaîne de la chaîne str avant de compter les occurrences du délimiteur delim. Si count est positif, tout ce qui se trouve à gauche du délimiteur final (Compter à partir de la gauche) est renvoyé. Si count est négatif, tout ce qui se trouve à droite du délimiteur final (Compter à partir de la droite) est renvoyé., SUBSTRING_INDEX () effectue une correspondance sensible à la casse lors de la recherche de delim.
SQL> SELECT SUBSTRING_INDEX('www.mysql.com', '.', 2);+---------------------------------------------------------+| SUBSTRING_INDEX('www.mysql.com', '.', 2) |+---------------------------------------------------------+| www.mysql |+---------------------------------------------------------+1 row in set (0.00 sec)
TRIM( 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 Ending n’est donné, les deux sont supposés. remstr est facultatif et, s’il n’est pas spécifié, les espaces sont supprimés.
UCASE(str)
UCASE() est un synonyme de UPPER().
UNHEX(str)
Effectue l’opération inverse de l’hexagone(str)., C’est, il interprète chaque paire de chiffres hexadécimaux dans l’argument d’un nombre et la convertit le 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)
UPPER(str)
renvoie la chaîne str avec tous les caractères changés en majuscules selon le 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)