Come posso trovare caratteri Unicode/non ASCII in un campo NTEXT in una tabella di SQL Server 2005?

Question

Ho una tabella con un paio di migliaia di righe. I campi descrizione e riepilogo sono NTEXT e talvolta hanno caratteri non ASCII. Come posso individuare tutte le righe con caratteri non ASCII?

Answer 1

Prima costruisci una stringa con tutti i caratteri che non ti interessano (l'esempio usa l'intervallo 0x20 - 0x7F o 7 bit senza i caratteri di controllo). Ogni carattere è preceduto da |, per l'uso nella clausola escape dopo.

-- Start with tab, line feed, carriage return 
declare @str varchar(1024) 
set @str = '|' + char(9) + '|' + char(10) + '|' + char(13) 

-- Add all normal ASCII characters (32 -> 127) 
declare @i int 
set @i = 32 
while @i <= 127 
    begin 
    -- Uses | to escape, could be any character 
    set @str = @str + '|' + char(@i) 
    set @i = @i + 1 
    end 

Il snippet successivo ricerca qualsiasi carattere che non sia nell'elenco. La% corrisponde a 0 o più caratteri. [] Corrisponde a uno dei caratteri all'interno di [], ad esempio [abc] corrisponde a a, boc. Il^nega l'elenco, ad esempio [^ abc] corrisponde a tutto ciò che non è a, b, o c.

select * 
from yourtable 
where yourfield like '%[^' + @str + ']%' escape '|' 

è necessario il carattere di escape perché altrimenti alla ricerca di personaggi come],% o _ sarebbe rovinare l'espressione LIKE.

Spero che questo sia utile, e grazie al commento di JohnFX sull'altra risposta.

Answer 2

probabilmente non è la soluzione migliore, ma forse una query come:

SELECT * 
FROM yourTable 
WHERE yourTable.yourColumn LIKE '%[^0-9a-zA-Z]%' 

Sostituire l'espressione "0-9a-zA-Z" con qualcosa che cattura il set ASCII completo (o un sottoinsieme che il vostro i dati contengono).

Answer 3

La mia risposta precedente confondeva i dati UNICODE/non-UNICODE. Ecco una soluzione che dovrebbe funzionare per tutte le situazioni, anche se sto ancora incontrando alcune anomalie. Sembra che certi caratteri unicode non ASCII per i caratteri in apice siano confusi con il carattere numerico attuale. Potresti essere in grado di giocare con le regole di confronto per aggirare il problema.

Speriamo che tu abbia già una tabella di numeri nel tuo database (possono essere molto utili), ma nel caso in cui ho incluso il codice per riempirlo parzialmente.

Potrebbe anche essere necessario per giocare con l'intervallo numerico, dal momento che i caratteri Unicode possono andare oltre 255.

CREATE TABLE dbo.Numbers 
(
    number INT NOT NULL, 
    CONSTRAINT PK_Numbers PRIMARY KEY CLUSTERED (number) 
) 
GO 
DECLARE @i INT 

SET @i = 0 

WHILE @i < 1000 
BEGIN 
    INSERT INTO dbo.Numbers (number) VALUES (@i) 

    SET @i = @i + 1 
END 
GO 

SELECT *, 
    T.ID, N.number, N'%' + NCHAR(N.number) + N'%' 
FROM 
    dbo.Numbers N 
INNER JOIN dbo.My_Table T ON 
    T.description LIKE N'%' + NCHAR(N.number) + N'%' OR 
    T.summary LIKE N'%' + NCHAR(N.number) + N'%' 
and t.id = 1 
WHERE 
    N.number BETWEEN 127 AND 255 
ORDER BY 
    T.id, N.number 
GO 

Answer 4

- Questo è un modo molto, molto inefficiente di farlo, ma dovrebbe essere OK per - Tavolini Utilizza una tabella ausiliaria di numeri secondo Itzik Ben-Gan e semplicemente - cerca i caratteri con il bit 7 impostato.

SELECT * 
FROM yourTable as t 
WHERE EXISTS (SELECT * 
       FROM msdb..Nums as NaturalNumbers 
       WHERE NaturalNumbers.n < LEN(t.string_column) 
         AND ASCII(SUBSTRING(t.string_column, NaturalNumbers.n, 1)) > 127) 

Answer 5

Tecnicamente, credo che un NCHAR (1) è un carattere ASCII valida se & solo se UNICODE (@NChar) < 256 e ASCII (@NChar) = Unicode (@NChar) anche se questo potrebbe non essere esattamente quello che volevi. Quindi questa sarebbe una soluzione corretta:

;With cteNumbers as 
(
    Select ROW_NUMBER() Over(Order By c1.object_id) as N 
    From sys.system_columns c1, sys.system_columns c2 
) 
Select Distinct RowID 
From YourTable t 
    Join cteNumbers n ON n <= Len(CAST(TXT As NVarchar(MAX))) 
Where UNICODE(Substring(TXT, n.N, 1)) > 255 
    OR UNICODE(Substring(TXT, n.N, 1)) <> ASCII(Substring(TXT, n.N, 1)) 

Questo dovrebbe anche essere molto veloce.

Answer 6

volte ho usato questa dichiarazione "cast" di trovare caratteri "strani"

select 
    * 
from 
    <Table> 
where 
    <Field> != cast(<Field> as varchar(1000)) 

Answer 7

ho iniziato con la soluzione di @ CC1960 ma ho trovato un interessante caso d'uso che ha causato il fallimento.Sembra che SQL Server equiparerà determinati caratteri Unicode alle loro approssimazioni non Unicode. Ad esempio, SQL Server considera il carattere Unicode "fullwidth comma" (http://www.fileformat.info/info/unicode/char/ff0c/index.htm) lo stesso di una virgola ASCII standard se confrontato in una clausola WHERE.

Per aggirare questo problema, fare in modo che SQL Server confronti le stringhe come binario. Ma ricordate, nvarchar e varchar binari non corrispondono up (16-bit vs 8-bit), quindi è necessario convertire il vostro varchar indietro fino alla nvarchar di nuovo prima di fare il confronto binario:

select * 
from my_table 
where CONVERT(binary(5000),my_table.my_column) != CONVERT(binary(5000),CONVERT(nvarchar(1000),CONVERT(varchar(1000),my_table.my_column))) 

Answer 8

Se sei cercando un carattere unicode specifico, potresti usare qualcosa come sotto.

select Fieldname from 
    (
     select Fieldname, 
      REPLACE(Fieldname COLLATE Latin1_General_BIN, 
      NCHAR(65533) COLLATE Latin1_General_BIN, 
      'CustomText123') replacedcol 
     from table 
    ) results where results.replacedcol like '%CustomText123%' 

Answer 9

Qui ya go:

SELECT * 
FROM Objects 
WHERE 
    ObjectKey LIKE '%[^0-9a-zA-Z !"#$%&''()*+,\-./:;<=>?@\[\^_`{|}~\]\\]%' ESCAPE '\'