Fonctionnement de la fonction TRANSLATE() dans SQL Server (T-SQL)

Dans SQL Server, le T-SQL TRANSLATE() La fonction renvoie la chaîne fournie en tant que 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 spécifié dans le troisième argument.

C'est similaire au REPLACE() fonction, mais avec quelques différences importantes.

Le TRANSLATE() la fonction nécessite 3 arguments ; la chaîne d'entrée, les caractères à remplacer et les caractères pour les remplacer.

Syntaxe

La syntaxe ressemble à ceci :

TRANSLATE ( inputString, characters, translations)

Où chaîne d'entrée est la chaîne qui contient les caractères à remplacer.

Les caractères argument spécifie quels caractères doivent être remplacés.

Les traductions L'argument spécifie par quoi ces caractères doivent être remplacés.

Exemple 1 - Utilisation de base

Voici un exemple de son fonctionnement :

SELECT TRANSLATE('Cat', 'at', 'ow') AS Result;

Résultat :

+----------+
| Result   |
|----------|
| Cow      |
+----------+

Ainsi, dans cet exemple, le a et t les caractères ont été remplacés par o et w .

Dans ce cas, le REPLACE() fonction aurait produit le même résultat. Voici les deux fonctions côte à côte :

SELECT 
  TRANSLATE('Cat', 'at', 'ow') AS 'TRANSLATE',
  REPLACE('Cat', 'at', 'ow') AS 'REPLACE';

Résultat :

+-------------+-----------+
| TRANSLATE   | REPLACE   |
|-------------+-----------|
| Cow         | Cow       |
+-------------+-----------+

Dans ce cas, le résultat pour les deux fonctions est le même, mais pour des raisons différentes.

Voici ce que faisait chaque fonction :

• TRANSLATE() remplacé a et t (chaque caractère individuel)
• REPLACE() remplacé at (la chaîne)

Exemple 2 – Commande mixte

Cet exemple montre où TRANSLATE() diffère de REPLACE() . Dans cet exemple, je change l'ordre des caractères à remplacer, ainsi que les caractères pour les remplacer :

SELECT 
  TRANSLATE('Cat', 'ta', 'wo') AS 'TRANSLATE',
  REPLACE('Cat', 'ta', 'wo') AS 'REPLACE';

Résultat :

+-------------+-----------+
| TRANSLATE   | REPLACE   |
|-------------+-----------|
| Cow         | Cat       |
+-------------+-----------+

Dans ce cas, seul le TRANSLATE() fonction a pris effet. C'est parce que cette fonction parcourt chaque caractère un par un. Le REPLACE() d'autre part, recherche la chaîne entière, exactement dans le même ordre.

Exemple 3 - Un exemple plus puissant

L'exemple suivant est basé sur la documentation Microsoft pour le TRANSLATE() une fonction. Il illustre un scénario où cette fonction présente un avantage significatif par rapport à REPLACE() fonction :

SELECT TRANSLATE('2*[3+4]/{7-2}', '[]{}', '()()') AS Result;

Résultat :

+---------------+
| Result        |
|---------------|
| 2*(3+4)/(7-2) |
+---------------+

Pour obtenir le résultat équivalent en utilisant le REPLACE() fonction, nous aurions besoin de faire ceci :

SELECT
REPLACE
(
      REPLACE
      (
            REPLACE
            (
                  REPLACE
                  (
                        '2*[3+4]/{7-2}',
                        '[',
                        '('
                  ),
                  ']',
                  ')'
            ),
            '{',
            '('
      ),
      '}',
      ')'
) AS Result;

Résultat :

+---------------+
| Result        |
|---------------|
| 2*(3+4)/(7-2) |
+---------------+