Fonction LEN n'incluant pas les espaces de fin dans SQL Server

J'ai la table de test suivante dans SQL Server 2005:

CREATE TABLE [dbo].[TestTable]
(
 [ID] [int] NOT NULL,
 [TestField] [varchar](100) NOT NULL
) 

Rempli de:

INSERT INTO TestTable (ID, TestField) VALUES (1, 'A value');   -- Len = 7
INSERT INTO TestTable (ID, TestField) VALUES (2, 'Another value      '); -- Len = 13 + 6 spaces

Lorsque j'essaie de trouver la longueur de TestField avec la fonction SQL Server LEN (), il ne compte pas les espaces de fin - par exemple:

-- Note: Also results the grid view of TestField do not show trailing spaces (SQL Server 2005).
SELECT 
 ID, 
 TestField, 
 LEN(TestField) As LenOfTestField, -- Does not include trailing spaces
FROM 
 TestTable

Comment inclure les espaces de fin dans le résultat de longueur?

Ceci est clairement documenté par Microsoft dans MSDN à l' adresse http://msdn.microsoft.com/en-us/library/ms190329(SQL.90).aspx , qui indique LEN "renvoie le nombre de caractères de l'expression de chaîne spécifiée, à l'exclusion blancs de fin ". C'est, cependant, un détail facile à manquer si vous ne vous méfiez pas.

Vous devez à la place utiliser la fonction DATALENGTH - voir http://msdn.microsoft.com/en-us/library/ms173486(SQL.90).aspx - qui "renvoie le nombre d'octets utilisés pour représenter une expression".

Exemple:

SELECT 
    ID, 
    TestField, 
    LEN(TestField) As LenOfTestField,           -- Does not include trailing spaces
    DATALENGTH(TestField) As DataLengthOfTestField      -- Shows the true length of data, including trailing spaces.
FROM 
    TestTable

Vous pouvez utiliser cette astuce:

LEN (Str + 'x') - 1

J'utilise cette méthode:

LEN(REPLACE(TestField, ' ', '.'))

Je préfère cela à DATALENGTH car cela fonctionne avec différents types de données, et je préfère cela à l'ajout d'un caractère à la fin car vous n'avez pas à vous soucier du cas de bord où votre chaîne est déjà à la longueur maximale.

Remarque: je testerais les performances avant de l'utiliser sur un très grand ensemble de données; bien que je viens de le tester contre 2M de lignes et ce n'était pas plus lent que LEN sans le REMPLACER ...

"Comment puis-je inclure les espaces de fin dans le résultat de longueur?"

Vous demandez à quelqu'un de déposer une demande d'amélioration / rapport de bogue de SQL Server car presque toutes les solutions de contournement répertoriées à ce problème étonnamment simple ici présentent des lacunes ou sont inefficaces. Cela semble toujours être vrai dans SQL Server 2012. La fonction de découpage automatique peut provenir de ANSI / ISO SQL-92 mais il semble y avoir quelques trous (ou manque de les compter).

Veuillez voter pour "Ajouter un paramètre pour que LEN compte les espaces de fin" ici:

https://feedback.azure.com/forums/908035-sql-server/suggestions/34673914-add-setting-so-len-counts-trailing-whitespace

Lien de connexion retiré: https://connect.microsoft.com/SQLServer/feedback/details/801381

Il y a des problèmes avec les deux réponses les plus votées. La réponse recommandée DATALENGTHest sujette à des erreurs de programmeur. Le résultat de DATALENGTHdoit être divisé par 2 pour les NVARCHARtypes, mais pas pour les VARCHARtypes. Cela nécessite la connaissance du type dont vous obtenez la longueur, et si ce type change, vous devez changer avec diligence les endroits que vous avez utilisés DATALENGTH.

Il y a aussi un problème avec la réponse la plus votée (ce que je reconnais était ma façon préférée de le faire jusqu'à ce que ce problème me mette en cause). Si l'élément dont vous obtenez la longueur est de type NVARCHAR(4000)et qu'il contient en fait une chaîne de 4 000 caractères, SQL ignorera le caractère ajouté au lieu de convertir implicitement le résultat en NVARCHAR(MAX). Le résultat final est une longueur incorrecte. La même chose se produira avec VARCHAR (8000).

Ce que j'ai trouvé fonctionne, est presque aussi rapide que l'ancien LEN, est plus rapide que LEN(@s + 'x') - 1pour les grandes chaînes et ne suppose pas que la largeur des caractères sous-jacents est la suivante:

DATALENGTH(@s) / DATALENGTH(LEFT(LEFT(@s, 1) + 'x', 1))

Cela obtient la longueur de données, puis divise par la longueur de données d'un seul caractère de la chaîne. L'ajout de «x» couvre le cas où la chaîne est vide (ce qui donnerait une division par zéro dans ce cas). Cela fonctionne que ce @ssoit VARCHARou NVARCHAR. Faire le caractère LEFTde 1 avant l'ajout réduit le temps lorsque la chaîne est volumineuse. Le problème avec ceci cependant, c'est que cela ne fonctionne pas correctement avec des chaînes contenant des paires de substitution.

Il y a une autre façon mentionnée dans un commentaire à la réponse acceptée, en utilisant REPLACE(@s,' ','x'). Cette technique donne la bonne réponse, mais est de quelques ordres de grandeur plus lente que les autres techniques lorsque la chaîne est grande.

Compte tenu des problèmes introduits par les paires de substitution sur toute technique qui utilise DATALENGTH, je pense que la méthode la plus sûre qui donne des réponses correctes que je connaisse est la suivante:

LEN(CONVERT(NVARCHAR(MAX), @s) + 'x') - 1

C'est plus rapide que la REPLACEtechnique, et beaucoup plus rapide avec des cordes plus longues. Fondamentalement, cette technique est la LEN(@s + 'x') - 1technique, mais avec une protection pour le cas de bord où la chaîne a une longueur de 4000 (pour nvarchar) ou 8000 (pour varchar), de sorte que la bonne réponse est donnée même pour cela. Il doit également gérer correctement les chaînes avec des paires de substitution.

Vous devez également vous assurer que vos données sont effectivement enregistrées avec les blancs de fin. Lorsque ANSI PADDING est désactivé (non par défaut):

Les blancs de fin dans les valeurs de caractère insérées dans une colonne varchar sont coupés.

LEN coupe les espaces de fin par défaut, donc j'ai trouvé que cela fonctionnait lorsque vous les déplacez vers l'avant

(LEN (REVERSE (TestField))

Donc si tu le voulais, tu pourrais dire

SELECT
t.TestField,
LEN(REVERSE(t.TestField)) AS [Reverse],
LEN(t.TestField) AS [Count]
FROM TestTable t
WHERE LEN(REVERSE(t.TestField)) <> LEN(t.TestField)

N'utilisez pas cela pour diriger des espaces bien sûr.

Vous devez définir une fonction CLR qui renvoie le champ Longueur de la chaîne, si vous n'aimez pas la concatination de chaînes. j'utiliseLEN('x' + @string + 'x') - 2 dans mes cas d'utilisation de production.

Si vous n'aimez pas le en DATALENGTHraison de préoccupations n / varchar, que diriez-vous:

select DATALENGTH(@var)/isnull(nullif(DATALENGTH(left(@var,1)),0),1)

qui est juste

select DATALENGTH(@var)/DATALENGTH(left(@var,1))

enveloppé d'une protection de division par zéro.

En divisant par la DATALENGTH d'un seul caractère, nous obtenons la longueur normalisée.

(Bien sûr, il y a toujours des problèmes avec les paires de substitution si cela pose un problème.)

utilisez SELECT DATALENGTH ('string')