Por que não devemos permitir NULLs?

Lembro-me de ler este artigo sobre o design de banco de dados e também lembro que você deveria ter propriedades de campo NOT NULL. Não me lembro por que esse foi o caso.

Tudo o que consigo pensar é que, como desenvolvedor de aplicativos, você não precisaria testar NULL e um possível valor inexistente de dados (por exemplo, uma string vazia para strings).

Mas o que você faz no caso de datas, data e hora e hora (SQL Server 2008)? Você precisaria usar uma data histórica ou de fundo do poço.

Alguma idéia sobre isso?

Acho que a pergunta está mal formulada, pois a redação implica que você já decidiu que os NULLs são ruins. Talvez você quis dizer "Devemos permitir NULLs?"

Enfim, aqui está a minha opinião: acho que os NULLs são uma coisa boa. Quando você começa a impedir NULLs apenas porque "NULLs são ruins" ou "NULLs são difíceis", você começa a criar dados. Por exemplo, e se você não souber minha data de nascimento? O que você vai colocar na coluna até saber? Se você é como um monte de gente anti-NULL, vai entrar em 1900-01-01. Agora vou ser colocado na enfermaria geriátrica e provavelmente receber uma ligação da minha estação de notícias local parabenizando-me por minha longa vida, me perguntando meus segredos para viver uma vida tão longa, etc.

Se uma linha puder ser inserida onde é possível que você não saiba o valor de uma coluna, acho que NULL faz muito mais sentido do que escolher algum valor de token arbitrário para representar o fato de que é desconhecido - um valor que outros irão você já deve saber, fazer engenharia reversa ou pedir para descobrir o que isso significa.

Porém, existe um equilíbrio - nem todas as colunas do seu modelo de dados devem ser anuláveis. Geralmente, existem campos opcionais em um formulário ou informações que, de outra forma, não são coletadas no momento em que a linha é criada. Mas isso não significa que você pode adiar o preenchimento de todos os dados. :-)

Além disso, a capacidade de usar NULL pode ser limitada por requisitos cruciais na vida real. No campo da medicina, por exemplo, pode ser uma questão de vida ou morte saber por que um valor é desconhecido. A frequência cardíaca é NULL porque não havia pulso ou porque ainda não o medimos? Nesse caso, podemos colocar NULL na coluna da frequência cardíaca e ter notas ou uma coluna diferente com um motivo NULL-porque?

Não tenha medo dos NULLs, mas esteja disposto a aprender ou ditar quando e onde eles devem ser usados ​​e quando e onde não devem.

Os motivos estabelecidos são:

• NULL não é um valor e, portanto, não possui um tipo de dados intrínseco. Os nulos precisam de tratamento especial em todo o lugar, quando o código que depende de tipos reais também pode receber o NULL não digitado.

• NULL quebra a lógica de dois valores (familiar Verdadeiro ou Falso) e requer uma lógica de três valores. Isso é muito mais complexo de implementar corretamente, e certamente é pouco compreendido pela maioria dos DBAs e praticamente todos os que não são DBAs. Como conseqüência, ele convida positivamente muitos erros sutis no aplicativo.

• O significado semântico de qualquer NULL específico é deixado para o aplicativo , diferentemente dos valores reais.

  Semânticas como “não aplicável” e “desconhecido” e “sentinela” são comuns, e existem outras também. Eles são freqüentemente usados ​​simultaneamente no mesmo banco de dados, mesmo na mesma relação; e, é claro, significados inexplicáveis, indistinguíveis e incompatíveis .

• Eles não são necessários para bancos de dados relacionais , conforme argumentado em "Como lidar com informações ausentes sem nulos" . Normalização adicional é um primeiro passo óbvio para tentar livrar uma tabela de NULLs.

Isso não significa que NULL nunca deve ser permitido. Ele se argumentar que há muitas boas razões para não permitir NULL sempre que possível.

Significativamente, ele argumenta que é muito difícil - através de um melhor design de esquema, melhores mecanismos de banco de dados e ainda melhores linguagens de banco de dados - tornar possível evitar NULL com mais frequência.

Fabian Pascal responde a uma série de argumentos, em "Nulls Nullified" .

Eu discordo, os nulos são um elemento essencial do design do banco de dados. A alternativa, como você aludiu também, seria uma proliferação de valores conhecidos para representar os desaparecidos ou os desconhecidos. O problema está no fato de o nulo ser tão amplamente incompreendido e, como resultado, ser usado de forma inadequada.

Segundo o IIRC, Codd sugeriu que a implementação atual de null (significando não presente / ausente) poderia ser melhorada com dois marcadores nulos em vez de um, "não presente, mas aplicável" e "não presente e não aplicável". Não é possível imaginar como os projetos relacionais seriam melhorados pessoalmente.

Deixe-me começar dizendo que não sou um DBA, sou um desenvolvedor de cor e mantenho e atualizo nossos bancos de dados com base em nossas necessidades. Dito isto, tive a mesma pergunta por alguns motivos.

1. Valores nulos tornam o desenvolvimento mais difícil e propenso a erros.
2. Valores nulos tornam as consultas, procedimentos armazenados e visualizações mais complexas e propensas a erros.
3. Valores nulos ocupam espaço (? Bytes com base no comprimento fixo da coluna ou 2 bytes no comprimento variável da coluna).
4. Valores nulos podem e freqüentemente afetam a indexação e a matemática.

Passo muito tempo vasculhando as respostas, comentários, artigos e conselhos por toda a Internet. Escusado será dizer que a maioria das informações foi a mesma que a resposta de @ AaronBertrand. Por isso, senti a necessidade de responder a essa pergunta.

Em primeiro lugar, quero esclarecer algo para todos os futuros leitores ... Valores nulos representam dados desconhecidos, NÃO dados não utilizados. Se você possui uma tabela de funcionários com um campo de data de término. Um valor nulo na data de término é porque é um campo obrigatório futuro que atualmente é desconhecido. Todo funcionário, ativo ou demitido, em algum momento terá uma data adicionada a esse campo. Essa é, na minha opinião, a única razão para um campo Anulável.

Dito isto, a mesma tabela de funcionários provavelmente conteria algum tipo de dados de autenticação. É comum em um ambiente corporativo que os funcionários sejam listados no banco de dados para RH e contabilidade, mas nem sempre possuem ou precisam de detalhes de autenticação. A maioria das respostas levaria você a acreditar que não há problema em anular esses campos ou, em alguns casos, criar uma conta para eles, mas nunca enviar as credenciais. O primeiro fará com que sua equipe de desenvolvimento escreva um código para verificar se há NULLs e lide com eles de acordo, e o último representa um enorme risco à segurança! Contas que nunca são usadas ainda no sistema apenas aumentam o número de pontos de acesso possíveis para um hacker, além de ocupar um espaço valioso no banco de dados para algo que nunca é usado.

Dadas as informações acima, a melhor maneira de lidar com dados anuláveis ​​que serão utilizados é permitir valores anuláveis. É triste, mas é verdade, e seus desenvolvedores o odiarão por isso. O segundo tipo de dados anuláveis ​​deve ser colocado em uma tabela relacionada (IE: conta, credenciais, etc.) e ter um relacionamento individual. Isso permite que um usuário exista sem credenciais, a menos que seja necessário. Isso remove o risco extra de segurança, o espaço valioso do banco de dados e fornece um banco de dados muito mais limpo.

Abaixo está uma estrutura de tabela muito simplista que mostra a coluna anulável necessária e um relacionamento um para um.

Sei que estou um pouco atrasado para a festa, já que essa pergunta foi feita anos atrás, mas espero que isso ajude a esclarecer esse assunto e a melhor forma de lidar com ele.

Além de todos os problemas com desenvolvedores confusos NULL, os NULLs têm outra desvantagem muito séria: Desempenho

As colunas NULL'able são um desastre da perspectiva de desempenho. Considere números inteiros aritméticos como exemplo. Em um mundo sadio sem NULL, é "fácil" vetorizar a aritmética inteira no código do mecanismo de banco de dados usando instruções SIMD para executar praticamente qualquer cálculo em velocidades mais rápidas que 1 linha por ciclo de CPU. No entanto, no momento em que você introduz o NULL, você precisa lidar com todos os casos especiais que o NULL cria. Os modernos conjuntos de instruções da CPU (leia também: lógica x86 / x64 / ARM e GPU) simplesmente não estão equipados para fazer isso com eficiência.

Considere a divisão como um exemplo. Em um nível muito alto, esta é a lógica que você precisa com um número inteiro não nulo:

if (b == 0)
  do something when dividing by error
else
  return a / b

Com NULL, isso se torna um pouco mais complicado. Juntamente com bvocê, será necessário um indicador se bfor nulo e similar para a. A verificação agora se torna:

if (b_null_bit == NULL)
   return NULL
else if (b == 0) 
   do something when dividing by error
else if (a_null_bit == NULL)
   return NULL
else 
   return a / b

A aritmética NULL é significativamente mais lenta para executar em uma CPU moderna do que a aritmética não nula (por um fator de cerca de 2-3x).

Fica pior quando você apresenta o SIMD. Com o SIMD, uma CPU Intel moderna pode executar divisões inteiras de 4 x 32 bits em uma única instrução, como esta:

x_vector = a_vector / b_vector
if (fetestexception(FE_DIVBYZERO))
   do something when dividing by zero
return x_vector;

Agora, existem maneiras de lidar com o NULL também no SIMD, mas isso requer o uso de mais vetores e registradores de CPU e o mascaramento inteligente de bits. Mesmo com bons truques, a penalidade de desempenho da aritmética de número inteiro NULL se aproxima do intervalo 5-10x mais lento, mesmo para expressões relativamente simples.

Algo como o descrito acima vale para agregados e, até certo ponto, para junções também.

Em outras palavras: A existência de NULL no SQL é uma incompatibilidade de impedância entre a teoria do banco de dados e o design real dos computadores modernos. Há uma boa razão para o NULL confundir os desenvolvedores - porque um número inteiro não pode ser NULL na maioria das linguagens de programação sãs - não é assim que os computadores funcionam.

Perguntas interessantes.

Tudo o que consigo pensar é que, como desenvolvedor de aplicativos, você não precisaria testar NULL e um possível valor inexistente de dados (por exemplo, uma string vazia para strings).

É mais complicado que isso. Nulo tem vários significados distintos e uma razão realmente importante para não permitir nulos em muitas colunas é que, quando a coluna é nula, isso significa apenas uma e apenas uma coisa (a saber, que ela não apareceu em uma junção externa). Além disso, permite definir padrões mínimos de entrada de dados, o que é realmente útil.

Mas o que você faz no caso de datas, data e hora e hora (SQL Server 2008)? Você precisaria usar uma data histórica ou de fundo do poço.

Isso ilustra um problema com nulos imediatamente, ou seja, que um valor armazenado em uma tabela pode significar "esse valor não se aplica" ou "não sabemos". Com cadeias, uma cadeia vazia pode servir como "isso não se aplica", mas com datas e horas, não existe tal convenção porque não há valor válido que convencionalmente significa isso. Normalmente, você ficará preso usando NULLs.

Existem maneiras de contornar isso (adicionando mais relações e junção), mas elas apresentam exatamente os mesmos problemas de clareza semântica que os NULLs no banco de dados. Para esses bancos de dados, eu não me preocuparia com isso. Simplesmente não há nada que você possa fazer sobre isso.

EDIT: Uma área onde NULLs são indispensáveis ​​está em chaves estrangeiras. Aqui eles geralmente têm apenas um significado, idêntico ao nulo no significado da junção externa. Esta é uma exceção ao problema, é claro.

O artigo da Wikipedia sobre SQL Null tem algumas observações interessantes sobre o valor NULL e, como resposta independente do banco de dados, desde que você esteja ciente dos possíveis efeitos de ter valores NULL para seu RDBMS específico, eles são aceitáveis ​​em seu design. Caso contrário, você não poderá especificar colunas como anuláveis.

Esteja ciente de como o RDBMS os trata em operações SELECT, como matemática, e também em índices.

Uau, a resposta correta "Não permita NULLs quando você não precisar, porque eles prejudicam o desempenho" é de alguma forma a última resposta classificada. Vou votá-lo e elaborar. Quando um RDBMS permite NULLs para uma coluna não esparsa, essa coluna é adicionada a um bitmap que rastreia se o valor é NULL para cada linha individual. Portanto, adicionando capacidade NULL a uma coluna em uma tabela em que todas as colunas não permitem NULLs, você aumenta o espaço de armazenamento necessário para salvar a tabela. Além disso, você está exigindo que o RDBMS leia e grave no bitmap, prejudicando o desempenho em todas as operações.

Além disso, em vários casos, permitir NULLs quebrará 3NF. Embora eu não seja um defensor da 3NF como muitos de meus colegas, considere o seguinte cenário:

Na tabela Pessoa, há uma coluna chamada DateOfDeath, que é anulável. Se uma pessoa morreu, ela será preenchida com o DateOfDeath, caso contrário, será deixado NULL. Há também uma coluna de bits não anulável chamada IsAlive. Esta coluna é definida como 1 se a pessoa estiver viva e 0 se a pessoa estiver morta. A grande maioria dos procedimentos armazenados usa a coluna IsAlive, eles se importam apenas se uma pessoa estiver viva, não seu DateOfDeath.

No entanto, a coluna IsAlive interrompe a normalização do banco de dados, porque é completamente derivável de DateOfDeath. Mas como o IsAlive está conectado à maioria dos SPs, a solução direta é tornar o DateOfDeath não nulo e atribuir um valor padrão à coluna no caso de a pessoa ainda estar viva. Os poucos SPs que usam DateOfDeath podem ser reescritos para verificar a coluna IsAlive e honrar o DateOfDeath apenas se a pessoa não estiver viva. Novamente, como a maioria dos SPs se preocupa apenas com o IsAlive (um pouco) e não com o DateOfDeath (uma data), esse padrão acelera consideravelmente o acesso.

Um script T-SQL útil para localizar colunas anuláveis ​​sem NULLs em todos os esquemas é:

select 'IF NOT EXISTS (SELECT 1 FROM ' + QUOTENAME(s.name) + '.' + QUOTENAME(t.name) + ' WHERE ' + QUOTENAME(c.name) + ' IS NULL)
    AND (SELECT COUNT(*) FROM ' + QUOTENAME(s.name) + '.' + QUOTENAME(t.name) + ') > 1 PRINT ''' + s.name + '.' + t.name + '.' + REPLACE(c.name, '''', '''''') + ''''
    from sys.columns c
    inner join sys.tables t ON c.object_id = t.object_id
    inner join sys.schemas s ON s.schema_id = t.schema_id
    where c.is_nullable = 1 AND c.is_computed = 0
    order by s.name, t.name, c.name;

Se você executar isso em uma cópia do banco de dados de produção, poderá encontrar as colunas desenvolvedores marcadas como permitindo NULLs que não possuem NULLs na prática. A grande maioria deles pode ser marcada como NOT NULL, aumentando assim o desempenho e diminuindo o espaço de armazenamento.

Pode não ser possível eliminar todos os NULLs em todas as tabelas e ainda ter um design limpo, mas há uma vantagem considerável na eliminação do maior número possível de NULLs. O otimizador trabalha muito mais rápido com essas informações e, se você puder eliminar todos os NULLs em uma tabela, poderá recuperar uma quantidade considerável de espaço de armazenamento.

Eu sei que desempenho não é algo que os DBAs pensam muito, mas você só pode gastar uma quantidade limitada de memória e potência do processador em uma solução, em algum momento você precisará começar a pensar em design lógico e físico .

Observe também que isso é apenas para RDBMSes verdadeiros e estou baseando a parte técnica das minhas respostas no SQL Server. O T-SQL listado para encontrar colunas anuláveis ​​sem nulos também é do SQL Server.