La función LEN no incluye espacios finales en SQL Server

Tengo la siguiente tabla de prueba en SQL Server 2005:

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

Poblado con:

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

Cuando trato de encontrar la longitud de TestField con la función SQL Server LEN (), no cuenta los espacios finales, por ejemplo:

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

¿Cómo incluyo los espacios finales en el resultado de la longitud?

Esto está claramente documentado por Microsoft en MSDN en http://msdn.microsoft.com/en-us/library/ms190329(SQL.90).aspx , que dice LEN "devuelve el número de caracteres de la expresión de cadena especificada, excluyendo espacios en blanco finales ". Sin embargo, es un detalle fácil de pasar por alto si no tiene cuidado.

En su lugar, debe utilizar la función DATALENGTH; consulte http://msdn.microsoft.com/en-us/library/ms173486(SQL.90).aspx , que "devuelve el número de bytes utilizados para representar cualquier expresión".

Ejemplo:

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

Puedes usar este truco:

LEN (Str + 'x') - 1

Yo uso este método:

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

Prefiero esto sobre DATALENGTH porque funciona con diferentes tipos de datos, y lo prefiero a agregar un carácter al final porque no tiene que preocuparse por el caso de borde donde su cadena ya está en la longitud máxima.

Nota: probaría el rendimiento antes de usarlo en un conjunto de datos muy grande; aunque solo lo probé contra 2M filas y no fue más lento que LEN sin REPLACE ...

"¿Cómo incluyo los espacios finales en el resultado de longitud?"

Usted consigue que alguien presente un informe de error / solicitud de mejora de SQL Server porque casi todas las soluciones enumeradas para este problema increíblemente simple aquí tienen alguna deficiencia o son ineficientes. Esto todavía parece ser cierto en SQL Server 2012. La función de recorte automático puede provenir de ANSI / ISO SQL-92 pero parece haber algunos agujeros (o falta de contarlos).

Vota "Agregar configuración para que LEN cuente los espacios en blanco finales" aquí:

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

Enlace de conexión retirado: https://connect.microsoft.com/SQLServer/feedback/details/801381

Hay problemas con las dos respuestas más votadas. La respuesta recomendada DATALENGTHes propensa a errores del programador. El resultado de DATALENGTHdebe dividirse por 2 para NVARCHARtipos, pero no para VARCHARtipos. Esto requiere conocimiento del tipo que está obteniendo, y si ese tipo cambia, debe cambiar diligentemente los lugares que utilizó DATALENGTH.

También hay un problema con la respuesta más votada (que admito que era mi forma preferida de hacerlo hasta que este problema me mordió). Si lo que obtiene la longitud es de tipo NVARCHAR(4000), y en realidad contiene una cadena de 4000 caracteres, SQL ignorará el carácter agregado en lugar de emitir implícitamente el resultado NVARCHAR(MAX). El resultado final es una longitud incorrecta. Lo mismo ocurrirá con VARCHAR (8000).

Lo que he encontrado funciona, es casi tan rápido como lo viejo LEN, es más rápido que LEN(@s + 'x') - 1para cadenas grandes y no asume que el ancho del carácter subyacente es el siguiente:

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

Esto obtiene la longitud de datos y luego se divide por la longitud de datos de un solo carácter de la cadena. El agregado de 'x' cubre el caso donde la cadena está vacía (lo que daría una división por cero en ese caso). Esto funciona si @ses VARCHARo NVARCHAR. Hacer el LEFTde 1 carácter antes de agregar se afeita en algún momento cuando la cadena es grande. Sin embargo, el problema con esto es que no funciona correctamente con cadenas que contienen pares suplentes.

Hay otra forma mencionada en un comentario para la respuesta aceptada, usando REPLACE(@s,' ','x'). Esa técnica da la respuesta correcta, pero es un par de órdenes de magnitud más lenta que las otras técnicas cuando la cuerda es grande.

Dados los problemas introducidos por los pares sustitutos en cualquier técnica que utilice DATALENGTH, creo que el método más seguro que da respuestas correctas que conozco es el siguiente:

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

Esto es más rápido que la REPLACEtécnica y mucho más rápido con cuerdas más largas. Básicamente, esta técnica es la LEN(@s + 'x') - 1técnica, pero con protección para el caso de borde donde la cadena tiene una longitud de 4000 (para nvarchar) u 8000 (para varchar), de modo que la respuesta correcta se da incluso para eso. También debe manejar correctamente las cadenas con pares sustitutos.

También debe asegurarse de que sus datos se guarden realmente con los espacios en blanco finales. Cuando ANSI PADDING está APAGADO (no predeterminado):

Los espacios en blanco finales en los valores de carácter insertados en una columna varchar se recortan.

LEN corta los espacios finales de forma predeterminada, así que encontré que esto funcionó a medida que los mueve al frente

(LEN (REVERSE (TestField))

Entonces, si quisieras, podrías decir

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)

No use esto para espacios principales, por supuesto.

Debe definir una función CLR que devuelva el campo Longitud de cadena, si no le gusta la concatenación de cadenas. Yo uso LEN('x' + @string + 'x') - 2en mis casos de uso de producción.

Si no le gustan las DATALENGTHpreocupaciones debido a n / varchar, ¿qué tal:

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

que es solo

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

envuelto con protección de división por cero.

Al dividir por DATALENGTH de un solo carácter, obtenemos la longitud normalizada.

(Por supuesto, todavía hay problemas con los pares sustitutos si eso es una preocupación).

use SELECT DATALENGTH ('cadena')