A partire da SQL Server 2017, ora puoi utilizzare T-SQL TRANSLATE() funzione per tradurre uno o più caratteri in un altro insieme di caratteri.
A prima vista, potresti pensare che il TRANSLATE() La funzione fa esattamente la stessa cosa di REPLACE() funzione, ma ci sono differenze significative tra i due.
Definizioni
Per prima cosa, diamo un'occhiata alla definizione di ciascuna funzione:
REPLACE()- Sostituisce tutte le occorrenze di un valore stringa specificato con un altro valore stringa.
TRANSLATE()- Restituisce la stringa fornita come primo argomento dopo che alcuni caratteri specificati nel secondo argomento sono stati tradotti in un set di caratteri di destinazione.
La differenza principale è il modo in cui ciascuna funzione gestisce più caratteri. REPLACE() sostituisce una stringa con un'altra stringa. Pertanto, se una stringa contiene più caratteri, ogni carattere deve essere nello stesso ordine. TRANSLATE() d'altra parte, sostituisce ogni carattere uno per uno, indipendentemente dall'ordine di quei caratteri.
Esempio – Stesso risultato
Ci sono alcuni casi in cui entrambe le funzioni restituiranno lo stesso risultato. In questo modo:
SELECT
REPLACE('123', '123', '456') AS Replace,
TRANSLATE('123', '123', '456') AS Translate;
Risultato:
Replace Translate ------- --------- 456 456
In questo caso, REPLACE() restituisce 456 perché la stringa esatta nel secondo argomento corrispondeva a una stringa nel primo argomento (in questo caso, era l'intera stringa).
TRANSLATE() restituisce 456 perché ogni carattere nel secondo argomento è presente nel primo argomento.
Esempio:risultato diverso
Ora per un esempio che dimostra una delle differenze tra TRANSLATE() e REPLACE() :
SELECT
REPLACE('123', '321', '456') AS Replace,
TRANSLATE('123', '321', '456') AS Translate;
Risultato:
Replace Translate ------- --------- 123 654
In questo caso, REPLACE() non ha effetto (restituisce la stringa originale) perché il secondo argomento non è una corrispondenza esatta per il primo argomento (o una sottostringa al suo interno). Anche se il secondo argomento contiene i caratteri corretti, non sono nello stesso ordine del primo argomento e, pertanto, l'intera stringa non corrisponde.
TRANSLATE() fa hanno effetto perché ogni carattere nel secondo argomento è presente nel primo argomento. Non importa che siano in un ordine diverso, perché ogni personaggio viene tradotto uno per uno. SQL Server converte il primo carattere, poi il secondo, poi il terzo e così via.
Stringhe non contigue
Simile all'esempio precedente, puoi anche ottenere risultati diversi quando il primo argomento contiene i caratteri nel secondo argomento, ma non sono contigui:
SELECT
REPLACE('1car23', '123', '456') AS Replace,
TRANSLATE('1car23', '123', '456') AS Translate;
Risultato:
Replace Translate ------- --------- 1car23 4car56
Argomenti di diversa lunghezza
Puoi anche ottenere risultati diversi tra ciascuna funzione ogni volta che ci sono discrepanze nel numero di caratteri nei vari argomenti.
Ecco un esempio in cui il primo argomento contiene meno caratteri del secondo e del terzo argomento:
SELECT
REPLACE('123', '1234', '4567') AS Replace,
TRANSLATE('123', '1234', '4567') AS Translate;
Risultato:
Replace Translate ------- --------- 123 456
In questo caso, REPLACE() non ha effetto perché il secondo argomento contiene più caratteri del primo argomento. Pertanto, è impossibile che il primo argomento contenga il secondo argomento.
Il TRANSLATE() funzione, tuttavia, ha effetto in questo caso. Questo perché il secondo argomento contiene caratteri che si trovano nel primo argomento. Non importa che il secondo argomento contenga più caratteri del primo. La cosa più importante è che il terzo argomento contenga lo stesso numero di caratteri del secondo.
Ci sono anche casi in cui REPLACE() funziona perfettamente ma TRANSLATE() genera un errore.
Esempio:
SELECT REPLACE('1234', '123', '4567') AS Replace;
Risultato:
Replace ------- 45674
In questo caso, REPLACE() funziona come previsto.
Tuttavia, se forniamo gli stessi argomenti a TRANSLATE() , otteniamo un errore:
SELECT TRANSLATE('1234', '123', '4567') AS Translate;
Risultato:
Error: The second and third arguments of the TRANSLATE built-in function must contain an equal number of characters.
Come afferma il messaggio di errore, il secondo e il terzo argomento devono contenere un numero uguale di caratteri.
Quando dovrei usare REPLACE()?
Dovresti usare REPLACE() quando è necessario sostituire tutte le occorrenze di una stringa specifica, esattamente come è scritta. Ad esempio, cambiare il nome di qualcuno con un altro nome.
Usando TRANSLATE() in questi casi possono avere risultati disastrosi:
SELECT
REPLACE('Homer Simpson', 'Homer', 'Jason') AS Replace,
TRANSLATE('Homer Simpson', 'Homer', 'Jason') AS Translate; Risultato:
Replace Translate ------------- ------------- Jason Simpson Jason Sispsan
Quando dovrei usare TRANSLATE()?
Come dimostrato nell'esempio precedente, TRANSLATE() può essere utile se devi sostituire tutte le occorrenze di ogni carattere specificato, indipendentemente dal loro ordine all'interno della stringa originale.
Può anche essere usato al posto di REPLACE() al semplice codice. Ecco un esempio (basato su un esempio sul sito Web Microsoft):
SELECT
REPLACE(REPLACE(REPLACE(REPLACE('2*[3+4]/{7-2}','[','('), ']', ')'), '{', '('), '}', ')') AS Replace,
TRANSLATE('2*[3+4]/{7-2}', '[]{}', '()()') AS Translate; Risultato:
Replace Translate ------------- ------------- 2*(3+4)/(7-2) 2*(3+4)/(7-2)
