À partir de SQL Server 2017, vous pouvez désormais utiliser le T-SQL TRANSLATE() fonction pour traduire un ou plusieurs caractères dans un autre ensemble de caractères.
À première vue, vous pourriez penser que TRANSLATE() La fonction fait exactement la même chose que REPLACE() fonction, mais il existe des différences significatives entre les deux.
Définitions
Voyons d'abord la définition de chaque fonction :
REPLACE()- Remplace toutes les occurrences d'une valeur de chaîne spécifiée par une autre valeur de chaîne.
TRANSLATE()- Renvoie la chaîne fournie comme premier argument après que certains caractères spécifiés dans le deuxième argument ont été traduits en un ensemble de caractères de destination.
La principale différence est la façon dont chaque fonction traite plusieurs caractères. REPLACE() remplace une chaîne par une autre chaîne. Par conséquent, si une chaîne contient plusieurs caractères, chaque caractère doit être dans le même ordre. TRANSLATE() d'autre part, remplace chaque caractère un par un, quel que soit l'ordre de ces caractères.
Exemple – Même résultat
Dans certains cas, les deux fonctions renverront le même résultat. Comme ceci :
SELECT
REPLACE('123', '123', '456') AS Replace,
TRANSLATE('123', '123', '456') AS Translate;
Résultat :
Replace Translate ------- --------- 456 456
Dans ce cas, REPLACE() renvoie 456 parce que la chaîne exacte dans le deuxième argument correspondait à une chaîne dans le premier argument (dans ce cas, c'était la chaîne entière).
TRANSLATE() renvoie 456 car chaque caractère du deuxième argument est présent dans le premier argument.
Exemple – Résultat différent
Maintenant, pour un exemple qui illustre l'une des différences entre TRANSLATE() et REPLACE() :
SELECT
REPLACE('123', '321', '456') AS Replace,
TRANSLATE('123', '321', '456') AS Translate;
Résultat :
Replace Translate ------- --------- 123 654
Dans ce cas, REPLACE() n'a aucun effet (il renvoie la chaîne d'origine) car le deuxième argument n'est pas une correspondance exacte pour le premier argument (ou une sous-chaîne à l'intérieur de celui-ci). Même si le deuxième argument contient les caractères corrects, ils ne sont pas dans le même ordre que le premier argument, et par conséquent, la chaîne entière ne correspond pas.
TRANSLATE() fait avoir un effet car chaque caractère du deuxième argument est présent dans le premier argument. Peu importe qu'ils soient dans un ordre différent, car chaque caractère est traduit un par un. SQL Server traduit le premier caractère, puis le deuxième, puis le troisième, et ainsi de suite.
Chaînes non contiguës
Comme dans l'exemple précédent, vous pouvez également obtenir des résultats différents lorsque le premier argument contient les caractères du deuxième argument, mais qu'ils ne sont pas contigus :
SELECT
REPLACE('1car23', '123', '456') AS Replace,
TRANSLATE('1car23', '123', '456') AS Translate;
Résultat :
Replace Translate ------- --------- 1car23 4car56
Arguments de longueur différente
Vous pouvez également obtenir des résultats différents entre chaque fonction chaque fois qu'il y a des écarts dans le nombre de caractères dans les différents arguments.
Voici un exemple où le premier argument contient moins de caractères que les deuxième et troisième arguments :
SELECT
REPLACE('123', '1234', '4567') AS Replace,
TRANSLATE('123', '1234', '4567') AS Translate;
Résultat :
Replace Translate ------- --------- 123 456
Dans ce cas, REPLACE() n'a aucun effet car le deuxième argument contient plus de caractères que le premier argument. Il est donc impossible que le premier argument contienne le deuxième argument.
Le TRANSLATE() Cependant, la fonction a un effet dans ce cas. Cela est dû au fait que le deuxième argument contient des caractères qui se trouvent dans le premier argument. Peu importe que le deuxième argument contienne plus de caractères que le premier. Le plus important est que le troisième argument contienne le même nombre de caractères que le second.
Il y a aussi des cas où REPLACE() fonctionne parfaitement mais TRANSLATE() renvoie une erreur.
Exemple :
SELECT REPLACE('1234', '123', '4567') AS Replace;
Résultat :
Replace ------- 45674
Dans ce cas, REPLACE() fonctionne comme prévu.
Cependant, si nous fournissons les mêmes arguments à TRANSLATE() , nous obtenons une erreur :
SELECT TRANSLATE('1234', '123', '4567') AS Translate;
Résultat :
Error: The second and third arguments of the TRANSLATE built-in function must contain an equal number of characters.
Comme l'indique le message d'erreur, les deuxième et troisième arguments doivent contenir un nombre égal de caractères.
Quand dois-je utiliser REMPLACER() ?
Vous devez utiliser REPLACE() lorsque vous devez remplacer toutes les occurrences d'une chaîne spécifique, exactement comme elle est écrite. Par exemple, changer le nom de quelqu'un en un autre nom.
Utilisation de TRANSLATE() dans de tels cas peut avoir des résultats désastreux :
SELECT
REPLACE('Homer Simpson', 'Homer', 'Jason') AS Replace,
TRANSLATE('Homer Simpson', 'Homer', 'Jason') AS Translate; Résultat :
Replace Translate ------------- ------------- Jason Simpson Jason Sispsan
Quand dois-je utiliser TRANSLATE() ?
Comme démontré dans l'exemple précédent, le TRANSLATE() La fonction peut être utile si vous devez remplacer toutes les occurrences de chaque caractère spécifié, quel que soit leur ordre dans la chaîne d'origine.
Il peut également être utilisé à la place de REPLACE() simplement le code. Voici un exemple (basé sur un exemple sur le site Web de Microsoft) :
SELECT
REPLACE(REPLACE(REPLACE(REPLACE('2*[3+4]/{7-2}','[','('), ']', ')'), '{', '('), '}', ')') AS Replace,
TRANSLATE('2*[3+4]/{7-2}', '[]{}', '()()') AS Translate; Résultat :
Replace Translate ------------- ------------- 2*(3+4)/(7-2) 2*(3+4)/(7-2)
