|| (Concaténation de chaînes) (Transact-SQL)

  • Article

S’applique à : Base de données Azure SQL Base de données SQL dans Microsoft Fabric

L’opérateur || de canaux d’une expression de chaîne concatène deux ou plusieurs chaînes, colonnes ou chaînes binaires ou une combinaison de chaînes et de noms de colonnes en une seule expression (opérateur de chaîne). Par exemple, SELECT 'SQL ' || 'Server'; retourne SQL Server.

Conventions de la syntaxe Transact-SQL

Syntaxe

expression || expression

Arguments

expression

Toute expression valide d’un des types de données dans la catégorie de type de données caractères et binaires, à l’exception des types de données xml, json, image, ntext ou texte. Les deux expressions doivent être de même type de données, ou l'une des expressions doit pouvoir être implicitement convertie dans le type de données de l'autre expression.

Types de retour

Retourne le type de données de l'argument dont la priorité est la plus élevée. Pour plus d’informations, consultez Priorité du type de données.

Notes

Si le résultat de la concaténation de chaînes dépasse la limite des 8 000 octets, il sera tronqué. Toutefois, si au moins une des chaînes concaténées est un type de valeur volumineux, la troncation ne se produit pas.

Chaînes et caractères de longueur zéro

L’opérateur || (concaténation de chaîne) se comporte différemment lorsqu’il fonctionne avec une chaîne vide et de longueur nulle que lorsqu’il fonctionne avec NULLdes valeurs inconnues ou avec des valeurs inconnues. Une chaîne de caractères de longueur nulle peut être spécifiée par deux guillemets simples sans caractères à l'intérieur. Une chaîne binaire de longueur nulle peut être spécifiée comme 0x sans aucune valeur d’octet spécifiée dans la constante hexadécimale. La concaténation d'une chaîne de longueur nulle concatène toujours deux chaînes spécifiées.

Concaténation des valeurs NULL

Comme pour les opérations arithmétiques effectuées sur NULL les valeurs, lorsqu’une NULL valeur est ajoutée à une valeur connue, le résultat est généralement une NULL valeur. Une opération de concaténation de chaîne effectuée avec une NULL valeur doit également produire un NULL résultat.

L’opérateur || ne respecte pas l’option SET CONCAT_NULL_YIELDS_NULL et se comporte toujours comme si le comportement ANSI SQL est activé, ce qui NULL génère si l’une des entrées est NULL. Il s’agit de la principale différence de comportement entre les + opérateurs de || concaténation. Pour plus d’informations, voir SET CONCAT_NULL_YIELDS_NULL.

Utilisation de CAST et CONVERT si nécessaire

Pour concaténer des chaînes binaires et tout caractère compris entre ces chaînes, il faut utiliser une conversion explicite en données de type caractère.

Les exemples suivants montrent quand CONVERT, ou CAST, doit être utilisé avec la concaténation binaire et quand CONVERT, ou CAST, n’a pas besoin d’être utilisé.

Dans cet exemple, aucune ou CAST fonction n’est CONVERT requise, car cet exemple concatène deux chaînes binaires.

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

Dans cet exemple, une ou CAST une CONVERT fonction est requise, car cet exemple concatène deux chaînes binaires plus un espace.

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

Exemples

Les exemples de code Transact-SQL de cet article sont fondés sur l’échantillon de base de données AdventureWorks2022 ou AdventureWorksDW2022 fourni, que vous pouvez télécharger à partir de la page d’accueil Échantillons et projets communautaires Microsoft SQL Server.

R : Utiliser la concaténation de chaînes

L’exemple suivant crée une seule colonne sous l’en-tête Name de colonne à partir de plusieurs colonnes de caractères, avec le nom de famille (LastName) de la personne suivie d’une virgule, d’un espace unique, puis du prénom (FirstName) de la personne. Le jeu de résultats se trouve dans l’ordre croissant, alphabétique par le nom de la famille, puis par le prénom.

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

B. Combiner des types de données numériques et de date

L’exemple suivant utilise la fonction CONVERT pour concaténer des types de données numeric et date.

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

Voici le jeu de résultats.

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

C. Utiliser plusieurs concaténations de chaînes

L’exemple suivant concatène plusieurs chaînes pour former une chaîne longue pour afficher le nom de la famille et le premier initial des vice-présidents à Adventure Works Cycles. Une virgule est ajoutée après le nom de la famille et un point après le premier initial.

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

Voici le jeu de résultats.

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

D. Utiliser des chaînes volumineuses en concaténation

L’exemple suivant concatène plusieurs chaînes pour former une seule et même longue chaîne, puis essaie de calculer la longueur de la chaîne finale. La longueur finale du jeu de résultats est de 16 000, car l’évaluation de l’expression commence à partir de gauche, c’est-à-dire @x@y + @z + => (@x + @z) + . @y Dans ce cas, le résultat de (@x + @z) est tronqué à 8 000 octets, puis @y est ajouté au jeu de résultats, ce qui rend la longueur de chaîne finale 16 000. Étant donné qu’il @y s’agit d’une chaîne de type valeur importante, la troncation ne se produit pas.

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

Voici le jeu de résultats.

y
-------
16000

Contenu connexe