Funzione LEN che non include gli spazi finali in SQL Server

Ho la seguente tabella di test in SQL Server 2005:

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

Popolato 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

Quando provo a trovare la lunghezza di TestField con la funzione LEN () di SQL Server non conta gli spazi finali, ad esempio:

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

Come includo gli spazi finali nel risultato della lunghezza?

Ciò è chiaramente documentato da Microsoft in MSDN all'indirizzo http://msdn.microsoft.com/en-us/library/ms190329(SQL.90).aspx , che afferma LEN "restituisce il numero di caratteri dell'espressione stringa specificata, escludendo spazi vuoti finali ". Tuttavia, è un dettaglio facile da perdere se non sei diffidente.

È necessario invece utilizzare la funzione DATALENGTH - vedere http://msdn.microsoft.com/en-us/library/ms173486(SQL.90).aspx - che "restituisce il numero di byte utilizzati per rappresentare qualsiasi espressione".

Esempio:

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

Puoi usare questo trucco:

LEN (Str + 'x') - 1

Uso questo metodo:

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

Lo preferisco a DATALENGTH perché funziona con diversi tipi di dati, e lo preferisco rispetto all'aggiunta di un carattere alla fine perché non devi preoccuparti del caso limite in cui la tua stringa è già alla lunghezza massima.

Nota: testerei le prestazioni prima di utilizzarlo su un set di dati molto grande; anche se l'ho appena testato su 2 milioni di righe e non era più lento di LEN senza REPLACE ...

"Come includo gli spazi finali nel risultato della lunghezza?"

Puoi chiedere a qualcuno di presentare una richiesta di miglioramento di SQL Server / una segnalazione di bug perché quasi tutte le soluzioni alternative elencate a questo problema incredibilmente semplice qui presentano alcune lacune o sono inefficienti. Questo sembra essere ancora vero in SQL Server 2012. La funzione di taglio automatico potrebbe derivare da ANSI / ISO SQL-92 ma sembra che ci siano alcuni buchi (o la mancanza di conteggio).

Si prega di votare "Aggiungi impostazione in modo che LEN conti gli spazi vuoti finali" qui:

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

Collegamento Connect ritirato: https://connect.microsoft.com/SQLServer/feedback/details/801381

Ci sono problemi con le due risposte più votate. La risposta che consiglia DATALENGTHè soggetta a errori del programmatore. Il risultato di DATALENGTHdeve essere diviso per 2 per i NVARCHARtipi, ma non per i VARCHARtipi. Ciò richiede la conoscenza del tipo di cui stai ottenendo la lunghezza e, se quel tipo cambia, devi cambiare diligentemente i luoghi che hai usato DATALENGTH.

C'è anche un problema con la risposta più votata (che ammetto era il mio modo preferito per farlo fino a quando questo problema non mi ha colpito). Se l'oggetto di cui stai ottenendo la lunghezza è di tipo NVARCHAR(4000)e contiene effettivamente una stringa di 4000 caratteri, SQL ignorerà il carattere aggiunto anziché eseguire il cast implicito del risultato NVARCHAR(MAX). Il risultato finale è una lunghezza errata. La stessa cosa accadrà con VARCHAR (8000).

Quello che ho trovato funziona, è veloce quasi quanto il vecchio LEN, è più veloce rispetto LEN(@s + 'x') - 1alle stringhe di grandi dimensioni e non presume che la larghezza del carattere sottostante sia la seguente:

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

Questo ottiene la lunghezza dei dati e quindi la divide per la lunghezza dei dati di un singolo carattere dalla stringa. L'appendice di "x" copre il caso in cui la stringa è vuota (che in quel caso darebbe una divisione per zero). Questo funziona se @sè VARCHARo NVARCHAR. L'esecuzione LEFTdi 1 carattere prima dell'appendice riduce il tempo quando la stringa è grande. Il problema con questo però è che non funziona correttamente con stringhe contenenti coppie surrogate.

C'è un altro modo menzionato in un commento alla risposta accettata, usando REPLACE(@s,' ','x'). Questa tecnica fornisce la risposta corretta, ma è un paio di ordini di grandezza più lenta rispetto alle altre tecniche quando la corda è grande.

Dati i problemi introdotti dalle coppie surrogate su qualsiasi tecnica che utilizzi DATALENGTH, penso che il metodo più sicuro che dia risposte corrette che conosco sia il seguente:

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

Questo è più veloce della REPLACEtecnica e molto più veloce con corde più lunghe. Fondamentalmente questa tecnica è la LEN(@s + 'x') - 1tecnica, ma con protezione per il caso limite in cui la stringa ha una lunghezza di 4000 (per nvarchar) o 8000 (per varchar), in modo che la risposta corretta sia data anche per questo. Inoltre, dovrebbe gestire correttamente le stringhe con coppie surrogate.

Devi anche assicurarti che i tuoi dati siano effettivamente salvati con gli spazi finali. Quando ANSI PADDING è OFF (non predefinito):

Gli spazi finali nei valori dei caratteri inseriti in una colonna varchar vengono tagliati.

LEN taglia gli spazi finali per impostazione predefinita, quindi ho scoperto che ha funzionato mentre li sposti in primo piano

(LEN (REVERSE (TestField))

Quindi, se lo volessi, potresti 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)

Ovviamente non usarlo per gli spazi principali.

È necessario definire una funzione CLR che restituisca il campo Lunghezza della stringa, se non ti piace la concatinazione di stringhe. Uso LEN('x' + @string + 'x') - 2nei miei casi d'uso di produzione.

Se non ti piace la DATALENGTHcausa di problemi di n / varchar, che ne dici di:

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

che è giusto

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

avvolto con protezione divide per zero.

Dividendo per DATALENGTH di un singolo carattere, otteniamo la lunghezza normalizzata.

(Ovviamente, problemi con le coppie surrogate se questo è un problema.)

usa SELECT DATALENGTH ('stringa')