Condividi tramite

|| (Concatenazione di stringhe) (Transact-SQL)

  • Articolo

Si applica a: database SQL di Azure database SQL in Microsoft Fabric

L'operatore || pipe in un'espressione stringa concatena due o più stringhe, colonne o stringhe binarie o una combinazione di stringhe e nomi di colonna in un'unica espressione (un operatore stringa). Ad esempio SELECT 'SQL ' || 'Server'; restituisce SQL Server.

Convenzioni relative alla sintassi Transact-SQL

Sintassi

expression || expression

Argomenti

expression

Qualsiasi espressione valida di uno dei tipi di dati nella categoria di tipi di dati carattere e binario, ad eccezione dei tipi di dati xml, json, image, ntext o text. È necessario che alle due espressioni sia applicato lo stesso tipo di dati oppure che un'espressione possa essere convertita in modo implicito nel tipo di dati dell'altra espressione.

Tipi restituiti

Viene restituito il tipo di dati dell'argomento con precedenza maggiore. Per altre informazioni, vedere Precedenza del tipo di dati.

Osservazioni:

Se il risultato della concatenazione di stringhe supera il limite di 8.000 byte, il risultato viene troncato. Tuttavia, se almeno una delle stringhe concatenate è un tipo valore di grandi dimensioni, il troncamento non si verifica.

Stringhe e caratteri di lunghezza zero

L'operatore || (concatenazione di stringhe) si comporta in modo diverso quando funziona con una stringa vuota e di lunghezza zero rispetto a quando funziona con NULLo valori sconosciuti. Una stringa di caratteri di lunghezza zero può essere specificata con due virgolette singole senza alcun carattere all'interno delle virgolette. Una stringa binaria di lunghezza zero può essere specificata come 0x senza valori di byte specificati nella costante esadecimale. La concatenazione di una stringa di valore zero comporta sempre la concatenazione delle due stringhe specificate.

Concatenazione di valori NULL

Come per le operazioni aritmetiche eseguite sui NULL valori, quando un NULL valore viene aggiunto a un valore noto, il risultato è in genere un NULL valore. Un'operazione di concatenazione di stringhe eseguita con un NULL valore deve produrre anche un NULL risultato.

L'operatore || non rispetta l'opzione SET CONCAT_NULL_YIELDS_NULL e si comporta sempre come se il comportamento SQL ANSI sia abilitato, producendo NULL se uno degli input è NULL. Questa è la differenza principale nel comportamento tra gli + operatori di concatenazione e || . Per altre informazioni, vedere SET CONCAT_NULL_YIELDS_NULL.

Uso di CAST e CONVERT quando necessario

Per la concatenazione di stringhe binarie e dei caratteri tra le stringhe binarie, è necessario eseguire una conversione esplicita in dati di tipo carattere.

Gli esempi seguenti mostrano quando CONVERT, o CAST, deve essere usato con la concatenazione binaria e quando CONVERT, o CAST, non deve essere usato.

In questo esempio non è necessaria alcuna CONVERT funzione o CAST perché in questo esempio vengono concatenate due stringhe binarie.

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

In questo esempio è necessaria una CONVERT funzione o CAST perché in questo esempio vengono concatenate due stringhe binarie più uno spazio.

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));

Esempi

Gli esempi di codice Transact-SQL in questo articolo utilizzano il database campione AdventureWorks2022 o AdventureWorksDW2022, che è possibile scaricare dalla home page di Esempi di Microsoft SQL Server e progetti collettivi.

R. Usare la concatenazione di stringhe

Nell'esempio seguente viene creata una singola colonna sotto l'intestazione Name di colonna da più colonne di caratteri, con il nome della famiglia (LastName) della persona seguita da una virgola, uno spazio singolo e quindi il nome (FirstName) della persona. Il set di risultati è in ordine alfabetico crescente in base al nome della famiglia e quindi al nome.

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

B. Combinare tipi di dati numerici e data

Nell'esempio seguente viene usata la funzione CONVERT per concatenare i tipi di dati numeric e date.

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

Il set di risultati è il seguente.

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

C. Usare più concatenazioni di stringhe

Nell'esempio seguente vengono concatenate più stringhe per formare una stringa lunga per visualizzare il nome della famiglia e il primo iniziale dei vice presidenti di Adventure Works Cycles. Viene aggiunta una virgola dopo il nome della famiglia e un punto dopo la prima iniziale.

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

Il set di risultati è il seguente.

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

D. Usare stringhe di grandi dimensioni nella concatenazione

Nell'esempio seguente si concatenano più stringhe per formare una stringa lunga e quindi si prova a calcolare la lunghezza della stringa finale. La lunghezza finale del set di risultati è 16.000, perché la valutazione dell'espressione inizia da sinistra, ovvero> = + @x@z@y + (@x + @z) + . @y In questo caso, il risultato di (@x + @z) viene troncato a 8.000 byte e quindi @y viene aggiunto al set di risultati, che rende la lunghezza finale della stringa 16.000. Poiché @y è una stringa di tipo valore di grandi dimensioni, il troncamento non si verifica.

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

Il set di risultati è il seguente.

y
-------
16000

Contenuto correlato