Dela via

|| (Strängsammanfogning) (Transact-SQL)

  • Artikel

gäller för:Azure SQL DatabaseAzure SQL Managed InstanceSQL-databas i Microsoft Fabric

Operatorn || pipes i ett stränguttryck sammanfogar två eller flera tecken eller binära strängar, kolumner eller en kombination av strängar och kolumnnamn i ett uttryck (en strängoperator). Till exempel returnerar SELECT 'SQL ' || 'Server';SQL Server. Operatorn || följer ANSI SQL-standarden för sammanfogning av strängar. I SQL Server kan du också utföra strängsammanfogning med hjälp av +-operatorn och funktionen CONCAT().

Transact-SQL syntaxkonventioner

Syntax

expression || expression

Argument

uttryck

Giltiga uttryck av någon av datatyperna i kategorin tecken och binär datatyp, förutom xml-, json, bild, ntexteller text datatyper. Båda uttrycken måste ha samma datatyp, eller så måste ett uttryck kunna konverteras implicit till datatypen för det andra uttrycket.

Returtyper

Returnerar datatypen för argumentet med högsta prioritet. Mer information finns i Datatypspriorence.

Anmärkningar

Några fördelar med att använda ANSI-strängsammanfogningssyntaxen är:

  • Portabilitet: Om du använder ANSI-standardoperatorn || för sammanfogning av strängar ser du till att SQL-koden är portabel mellan olika databassystem. Det innebär att du kan köra samma SQL-frågor på olika databasplattformar utan ändringar.

  • Konsekvens: Om du följer ANSI-standarden höjs konsekvensen i SQL-koden, vilket gör det enklare att läsa och underhålla, särskilt när du arbetar i miljöer med flera databassystem.

  • Samverkan: ANSI-standarden är allmänt erkänd och stöds av de flesta SQL-kompatibla databassystem, vilket förbättrar samverkan mellan olika system och verktyg.

Beteende för strängtrunkering

Om resultatet av sammanlänkningen av strängar överskrider gränsen på 8 000 byte trunkeras resultatet. Men om minst en av de sammanfogade strängarna är en stor värdetyp sker trunkering inte.

Strängar och tecken med noll längd

Operatorn || (strängsammanfogning) fungerar annorlunda när den fungerar med en tom sträng med noll längd än när den fungerar med NULLeller okända värden. En teckensträng med noll längd kan anges som två enkla citattecken utan några tecken inom citattecknen. En binär sträng med noll längd kan anges som 0x utan några bytevärden som anges i hexadecimal konstanten. När du sammanfogar en sträng med noll längd sammanfogas alltid de två angivna strängarna.

Sammanfogning av NULL-värden

Precis som med aritmetiska åtgärder som utförs på NULL värden, när ett NULL-värde läggs till i ett känt värde, är resultatet vanligtvis ett NULL värde. En strängsammanfogningsåtgärd som utförs med ett NULL värde bör också ge ett NULL resultat.

Operatorn || uppfyller inte alternativet SET CONCAT_NULL_YIELDS_NULL och beter sig alltid som om ANSI SQL-beteendet är aktiverat, vilket ger NULL om någon av indata är NULL. Det här är den primära skillnaden i beteende mellan operatorerna + och || sammanfogning. Mer information finns i SET CONCAT_NULL_YIELDS_NULL.

Användning av CAST och CONVERT vid behov

En explicit konvertering till teckendata måste användas när binära strängar sammanfogas och eventuella tecken mellan de binära strängarna.

Följande exempel visar när CONVERT, eller CAST, måste användas med binär sammanlänkning och när CONVERT, eller CAST, inte behöver användas.

I det här exemplet krävs ingen CONVERT eller CAST funktion eftersom det här exemplet sammanfogar två binära strängar.

DECLARE @mybin1 VARBINARY(5), @mybin2 VARBINARY(5);

SET @mybin1 = 0xFF;
SET @mybin2 = 0xA5;

-- No CONVERT or CAST function is required because this example
-- concatenates two binary strings.
SELECT @mybin1 || @mybin2

I det här exemplet krävs en CONVERT- eller CAST-funktion eftersom det här exemplet sammanfogar två binära strängar plus ett blanksteg.

DECLARE @mybin1 VARBINARY(5), @mybin2 VARBINARY(5);

SET @mybin1 = 0xFF;
SET @mybin2 = 0xA5;

-- A CONVERT or CAST function is required because this example
-- concatenates two binary strings plus a space.
SELECT CONVERT(VARCHAR(5), @mybin1) || ' '
    || CONVERT(VARCHAR(5), @mybin2);

-- Here is the same conversion using CAST.
SELECT CAST(@mybin1 AS VARCHAR(5)) || ' '
    || CAST(@mybin2 AS VARCHAR(5));

Exempel

I Transact-SQL kodexempel i den här artikeln används AdventureWorks2022- eller AdventureWorksDW2022-exempeldatabasen, som du kan ladda ned från Microsoft SQL Server-exempel och Community Projects startsida.

A. Använda strängsammanfogning

I följande exempel skapas en enskild kolumn under kolumnrubriken Name från flera teckenkolumner, med familjenamnet (LastName) för personen följt av ett kommatecken, ett enda blanksteg och sedan personens förnamn (FirstName). Resultatuppsättningen är i stigande, alfabetisk ordning efter familjenamnet och sedan efter förnamnet.

SELECT (LastName || ', ' || FirstName) AS Name
FROM Person.Person
ORDER BY LastName ASC, FirstName ASC;

B. Kombinera numeriska datatyper och datumdatatyper

I följande exempel används funktionen CONVERT för att sammanfoga numeriska och datum datatyper.

SELECT 'The order is due on ' || CONVERT(VARCHAR(12), DueDate, 101)
FROM Sales.SalesOrderHeader
WHERE SalesOrderID = 50001;
GO

Här är resultatuppsättningen.

------------------------------------------------
The order is due on 04/23/2007

C. Använda flera strängsammanfogningar

I följande exempel sammanfogas flera strängar för att bilda en lång sträng för att visa familjenamnet och den första initialen av vicepresidenterna på Adventure Works Cycles. Ett kommatecken läggs till efter familjenamnet och en punkt efter den första initialen.

SELECT (LastName || ',' + SPACE(1) || SUBSTRING(FirstName, 1, 1) || '.') AS Name, e.JobTitle
FROM Person.Person AS p
    JOIN HumanResources.Employee AS e
    ON p.BusinessEntityID = e.BusinessEntityID
WHERE e.JobTitle LIKE 'Vice%'
ORDER BY LastName ASC;
GO

Här är resultatuppsättningen.

Name               Title
-------------      ---------------`
Duffy, T.          Vice President of Engineering
Hamilton, J.       Vice President of Production
Welcker, B.        Vice President of Sales

D. Använda stora strängar i sammanfogning

I följande exempel sammanfogas flera strängar för att bilda en lång sträng och försöker sedan beräkna längden på den sista strängen. Den slutliga längden på resultatuppsättningen är 16 000 eftersom uttrycksutvärderingen börjar från vänster, dvs. @x + @z + @y => (@x + @z) + @y. I det här fallet trunkeras resultatet av (@x + @z) till 8 000 byte och sedan läggs @y till i resultatuppsättningen, vilket gör den slutliga stränglängden till 16 000. Eftersom @y är en sträng av stor värdetyp sker inte trunkering.

DECLARE @x VARCHAR(8000) = REPLICATE('x', 8000);
DECLARE @y VARCHAR(MAX) = REPLICATE('y', 8000);
DECLARE @z VARCHAR(8000) = REPLICATE('z', 8000);

SET @y = @x || @z || @y;

-- The result of following select is 16000
SELECT LEN(@y) AS y;
GO

Här är resultatuppsättningen.

y
-------
16000

Relaterat innehåll