Uma extensão para a resposta do @ db2 com menos (leia-se: zero) hand-wrangling:

DECLARE @tb nvarchar(512) = N'dbo.[table]';

DECLARE @sql nvarchar(max) = N'SELECT * FROM ' + @tb
    + N' WHERE 1 = 0';

SELECT @sql += N' OR ' + QUOTENAME(name) + N' IS NULL'
    FROM sys.columns 
    WHERE [object_id] = OBJECT_ID(@tb)
    AND is_nullable = 1;

EXEC sys.sp_executesql @sql;

Você deve listar todas as colunas conforme o comentário de JNK.

WHERE c1 IS NULL OR c2 IS NULL OR c3 IS NULL

Uma abordagem um pouco menos eficiente que evita isso está abaixo.

;WITH xmlnamespaces('http://www.w3.org/2001/XMLSchema-instance' AS ns) 
SELECT * 
FROM   YourTable AS T1 
WHERE (
    SELECT T1.* 
    FOR XML PATH('row'), ELEMENTS XSINIL, TYPE
  ).exist('//*/@ns:nil') = 1 

(Com base nesta resposta SO)

Não há uma boa sintaxe integrada, mas o Management Studio tem alguns recursos convenientes para gerar a consulta rapidamente.

No Pesquisador de Objetos, desça até a tabela desejada, expanda-a e arraste toda a pasta "Colunas" para um editor de consulta em branco. Isso adicionará uma lista de colunas separadas por vírgulas à consulta.

Em seguida, abra Localizar e substituir. Defina "Localizar o que" para ,e defina "Substituir por" para IS NULL OR(com um espaço à esquerda) e pressione Substituir tudo. Você terá que limpar o último da sequência manualmente.

Ainda é feio, mas é menos trabalhoso e feio.

Várias soluções para: alguns nulos, todos os nulos, colunas únicas e múltiplas, além de torná-lo RÁPIDO usando o Top 1

Se você precisar testar várias colunas, poderá usar o seguinte:

Column_1 Column_2 Column_3
-------- -------- --------
1        2        NULL
1        NULL     NULL
5        6        NULL

Primeiro , teste para NULLs e conte-os:

select 
    sum(case when Column_1 is null then 1 else 0 end) as Column_1, 
    sum(case when Column_2 is null then 1 else 0 end) as Column_2, 
    sum(case when Column_3 is null then 1 else 0 end) as Column_3,
from TestTable 

Produz uma contagem de NULLs:

Column_1  Column_2  Column_3
0         1         3

Onde o resultado é 0, não há NULLs.

Segundo , vamos contar os não-NULLs:

select 
    sum(case when Column_1 is null then 0 else 1 end) as Column_1, 
    sum(case when Column_2 is null then 0 else 1 end) as Column_2, 
    sum(case when Column_3 is null then 0 else 1 end) as Column_3,
from TestTable

...Mas como estamos contando não-NULLs aqui, isso pode ser simplificado para:

select 
    count(Column_1) as Column_1, 
    count(Column_2) as Column_2, 
    count(Column_3) as Column_3,
from TestTable

Qualquer um rende:

Column_1  Column_2  Column_3
3         2         0

Onde o resultado é 0, a coluna é inteiramente composta de NULLs.

Por fim , se você só precisa verificar uma coluna específica, o TOP 1 é mais rápido porque deve parar no primeiro hit. Você pode então opcionalmente usar count(*) para dar um resultado no estilo booleano:

select top 1 'There is at least one NULL' from TestTable where Column_3 is NULL

select count(*) from (select top 1 'There is at least one NULL' AS note from TestTable where Column_3 is NULL) a

0 = Não há NULLs, 1 = Há pelo menos um NULL

ou

select top 1 'There is at least one non-NULL' AS note from TestTable where Column_3 is not NULL

select count(*) from (select top 1 'There is at least one non-NULL' AS note from TestTable where Column_3 is not NULL) a

0 = Todos são NULL, 1 = Existe pelo menos um não NULL

Eu espero que isso ajude.

UNPIVOT converte colunas em linhas. No processo elimina valores NULL ( referência ).

Dada a entrada

create table #t
(
    ID  int primary key,
    c1  int null,
    c2  int null
);

insert #t(id, c1, c2)
values
    (1, 12, 13),
    (2, null, 14),
    (3, 15, null),
    (4, null, null);

a consulta UNPIVOT

select
    ID, ColName, ColValue
from
(
    select *
    from #t
) as p
unpivot
(
    ColValue for ColName in
    (c1, c2)                  -- explicit source column names required
) as unpvt;

produzirá a saída

| ID | ColName | ColValue |
|----|---------|----------|
| 1  | c1      | 12       |
| 1  | c2      | 13       |
| 2  | c2      | 14       |
| 3  | c1      | 15       |

Infelizmente, a linha 4 foi totalmente eliminada, pois possui apenas NULLs! Ele pode ser convenientemente reintroduzido injetando um valor fictício na consulta de origem:

select
    ID, ColName, ColValue
from
(
    select
        -5 as dummy,               -- injected here, -5 is arbitrary
        *
    from #t
) as p
unpivot
(
    ColValue for ColName in
    (dummy, c1, c2)                -- referenced here
) as unpvt;

Ao agregar as linhas no ID, podemos contar os valores não nulos. Uma comparação com o número total de colunas na tabela de origem identificará as linhas que contêm um ou mais NULL.

select
    ID
from
(
    select -5 as dummy, *
    from #t
) as p
unpivot
(
    ColValue for ColName in
    (dummy, c1, c2)
) as unpvt
group by ID
having COUNT(*) <> 3;

Eu calculo 3 como
número de colunas na tabela de origem #t
+ 1 para a coluna fictícia injetada
- 1 para ID, que não é UNPIVOTED

Esse valor pode ser obtido em tempo de execução examinando as tabelas do catálogo.

As linhas originais podem ser recuperadas juntando-se aos resultados.

Se valores diferentes de NULL devem ser investigados, eles podem ser incluídos em uma cláusula where:

...
) as unpvt
where ColValue <> ''      -- will eliminate empty strings

Discussão

Isso requer um identificador que é transportado pelo UNPIVOT. Uma chave seria melhor. Se não existir, um pode ser injetado pela função de janela ROW_NUMBER() , embora isso possa ser caro para executar.

Todas as colunas devem ser explicitamente listadas dentro da cláusula UNPIVOT. Eles podem ser arrastados usando o SSMS, como sugerido pelo @db2. Não será dinâmico quando a definição da tabela mudar, como seria a sugestão de Aaron Bertrand. Este é o caso de quase todos os SQL, no entanto.

Para meu conjunto de dados bastante limitado, o plano de execução é uma varredura de índice clusterizado e uma agregação de fluxo. Isso custará mais memória do que uma varredura direta da tabela e muitas cláusulas OR.