Från och med SQL Server 2017 kan du nu använda T-SQL TRANSLATE() funktion för att översätta ett eller flera tecken till en annan uppsättning tecken.
Vid första anblicken kanske du tror att TRANSLATE() funktionen gör exakt samma sak som REPLACE() funktion, men det finns betydande skillnader mellan de två.
Definitioner
Låt oss först titta på definitionen av varje funktion:
REPLACE()- Ersätter alla förekomster av ett angivet strängvärde med ett annat strängvärde.
TRANSLATE()- Returnerar strängen som tillhandahålls som ett första argument efter att några tecken som anges i det andra argumentet har översatts till en måluppsättning tecken.
Den största skillnaden är hur varje funktion hanterar flera tecken. REPLACE() ersätter en sträng med en annan sträng. Därför, om en sträng innehåller flera tecken, måste varje tecken vara i samma ordning. TRANSLATE() å andra sidan ersätter varje tecken en efter en, oavsett ordningen på dessa tecken.
Exempel – Samma resultat
Det finns vissa fall där båda funktionerna returnerar samma resultat. Så här:
SELECT
REPLACE('123', '123', '456') AS Replace,
TRANSLATE('123', '123', '456') AS Translate;
Resultat:
Replace Translate ------- --------- 456 456
I det här fallet REPLACE() returnerar 456 eftersom den exakta strängen i det andra argumentet matchade en sträng i det första argumentet (i det här fallet var det hela strängen).
TRANSLATE() returnerar 456 eftersom varje tecken i det andra argumentet finns i det första argumentet.
Exempel – Annat resultat
Nu till ett exempel som visar en av skillnaderna mellan TRANSLATE() och REPLACE() :
SELECT
REPLACE('123', '321', '456') AS Replace,
TRANSLATE('123', '321', '456') AS Translate;
Resultat:
Replace Translate ------- --------- 123 654
I det här fallet REPLACE() har ingen effekt (det returnerar den ursprungliga strängen) eftersom det andra argumentet inte är en exakt matchning för det första argumentet (eller en delsträng i det). Även om det andra argumentet innehåller de korrekta tecknen, är de inte i samma ordning som det första argumentet, och därför matchar inte hela strängen.
TRANSLATE() gör har en effekt eftersom varje tecken i det andra argumentet finns i det första argumentet. Det spelar ingen roll att de är i olika ordning, eftersom varje karaktär översätts en efter en. SQL Server översätter det första tecknet, sedan det andra, sedan det tredje och så vidare.
Icke-sammanhängande strängar
I likhet med föregående exempel kan du också få olika resultat när det första argumentet innehåller tecknen i det andra argumentet, men de är inte sammanhängande:
SELECT
REPLACE('1car23', '123', '456') AS Replace,
TRANSLATE('1car23', '123', '456') AS Translate;
Resultat:
Replace Translate ------- --------- 1car23 4car56
Argument av olika längd
Du kan också få olika resultat mellan varje funktion när det finns avvikelser i antalet tecken i de olika argumenten.
Här är ett exempel där det första argumentet innehåller färre tecken än det andra och tredje argumentet:
SELECT
REPLACE('123', '1234', '4567') AS Replace,
TRANSLATE('123', '1234', '4567') AS Translate;
Resultat:
Replace Translate ------- --------- 123 456
I det här fallet REPLACE() har ingen effekt eftersom det andra argumentet innehåller fler tecken än det första argumentet. Därför är det omöjligt för det första argumentet att innehålla det andra argumentet.
TRANSLATE() funktion har dock en effekt i detta fall. Detta beror på att det andra argumentet innehåller tecken som finns i det första argumentet. Det spelar ingen roll att det andra argumentet innehåller fler tecken än det första. Det viktigaste är att det tredje argumentet innehåller samma antal tecken som det andra.
Det finns också fall då REPLACE() fungerar perfekt men TRANSLATE() ger ett fel.
Exempel:
SELECT REPLACE('1234', '123', '4567') AS Replace;
Resultat:
Replace ------- 45674
I det här fallet REPLACE() fungerar som förväntat.
Men om vi tillhandahåller samma argument till TRANSLATE() , får vi ett felmeddelande:
SELECT TRANSLATE('1234', '123', '4567') AS Translate;
Resultat:
Error: The second and third arguments of the TRANSLATE built-in function must contain an equal number of characters.
Som felmeddelandet anger måste det andra och tredje argumentet innehålla lika många tecken.
När ska jag använda REPLACE()?
Du bör använda REPLACE() när du behöver ersätta alla förekomster av en specifik sträng, precis som den är skriven. Till exempel att ändra någons namn till ett annat namn.
Använder TRANSLATE() i sådana fall kan få katastrofala resultat:
SELECT
REPLACE('Homer Simpson', 'Homer', 'Jason') AS Replace,
TRANSLATE('Homer Simpson', 'Homer', 'Jason') AS Translate; Resultat:
Replace Translate ------------- ------------- Jason Simpson Jason Sispsan
När ska jag använda TRANSLATE()?
Som visas i föregående exempel, TRANSLATE() funktionen kan vara användbar om du behöver ersätta alla förekomster av varje angivet tecken, oavsett deras ordning inom den ursprungliga strängen.
Den kan också användas i stället för REPLACE() till helt enkelt koden. Här är ett exempel (baserat på ett exempel på Microsofts webbplats):
SELECT
REPLACE(REPLACE(REPLACE(REPLACE('2*[3+4]/{7-2}','[','('), ']', ')'), '{', '('), '}', ')') AS Replace,
TRANSLATE('2*[3+4]/{7-2}', '[]{}', '()()') AS Translate; Resultat:
Replace Translate ------------- ------------- 2*(3+4)/(7-2) 2*(3+4)/(7-2)