Quais são os anti-padrões SQL mais comuns? [fechadas]

Todos nós que trabalhamos com bancos de dados relacionais aprendemos (ou estamos aprendendo) que o SQL é diferente. Obter os resultados desejados e fazê-lo com eficiência envolve um processo tedioso, parcialmente caracterizado por aprender paradigmas desconhecidos e descobrir que alguns de nossos padrões de programação mais familiares não funcionam aqui. Quais são os antipadrões comuns que você já viu (ou se comprometeu)?

Estou constantemente decepcionado com a tendência da maioria dos programadores de misturar sua lógica de interface do usuário na camada de acesso a dados:

SELECT
    FirstName + ' ' + LastName as "Full Name",
    case UserRole
        when 2 then "Admin"
        when 1 then "Moderator"
        else "User"
    end as "User's Role",
    case SignedIn
        when 0 then "Logged in"
        else "Logged out"
    end as "User signed in?",
    Convert(varchar(100), LastSignOn, 101) as "Last Sign On",
    DateDiff('d', LastSignOn, getDate()) as "Days since last sign on",
    AddrLine1 + ' ' + AddrLine2 + ' ' + AddrLine3 + ' ' +
        City + ', ' + State + ' ' + Zip as "Address",
    'XXX-XX-' + Substring(
        Convert(varchar(9), SSN), 6, 4) as "Social Security #"
FROM Users

Normalmente, os programadores fazem isso porque pretendem vincular seus conjuntos de dados diretamente a uma grade, e é conveniente ter o formato SQL Server do lado do servidor do que o formato no cliente.

Consultas como a mostrada acima são extremamente frágeis porque acoplam firmemente a camada de dados à camada da interface do usuário. Além disso, esse estilo de programação impede completamente que os procedimentos armazenados sejam reutilizáveis.

Aqui estão os meus 3 principais.

Número 1. Falha ao especificar uma lista de campos. (Editar: para evitar confusão: esta é uma regra de código de produção. Ela não se aplica a scripts de análise únicos - a menos que eu seja o autor.)

SELECT *
Insert Into blah SELECT *

deveria estar

SELECT fieldlist
Insert Into blah (fieldlist) SELECT fieldlist

Número 2. Usando um cursor e um loop while, quando um loop while com uma variável loop for suficiente.

DECLARE @LoopVar int

SET @LoopVar = (SELECT MIN(TheKey) FROM TheTable)
WHILE @LoopVar is not null
BEGIN
  -- Do Stuff with current value of @LoopVar
  ...
  --Ok, done, now get the next value
  SET @LoopVar = (SELECT MIN(TheKey) FROM TheTable
    WHERE @LoopVar < TheKey)
END

Número 3. DateLogic através dos tipos de string.

--Trim the time
Convert(Convert(theDate, varchar(10), 121), datetime)

Deveria estar

--Trim the time
DateAdd(dd, DateDiff(dd, 0, theDate), 0)

Vi um pico recente de "Uma consulta é melhor que duas, certo?"

SELECT *
FROM blah
WHERE (blah.Name = @name OR @name is null)
  AND (blah.Purpose = @Purpose OR @Purpose is null)

Essa consulta requer dois ou três planos de execução diferentes, dependendo dos valores dos parâmetros. Apenas um plano de execução é gerado e preso no cache para este texto sql. Esse plano será usado independentemente do valor dos parâmetros. Isso resulta em baixo desempenho intermitente. É muito melhor escrever duas consultas (uma consulta por plano de execução pretendido).

• Campos de senha legíveis por humanos , por exemplo. Auto-explicativo.

• Usando LIKE contra colunas indexadas , estou quase tentado a dizer LIKE em geral.

• Reciclando valores de PK gerados por SQL.

• Surpresa, ninguém mencionou a mesa divina ainda. Nada diz "orgânico" como 100 colunas de sinalizadores de bits, grandes seqüências de caracteres e números inteiros.

• Depois, há o padrão "Sinto falta de arquivos .ini" : armazenando CSVs, seqüências delimitadas por pipe ou outros dados necessários para análise em grandes campos de texto.

• E para servidor MS SQL o uso de cursores em tudo . Existe uma maneira melhor de executar qualquer tarefa do cursor.

Editado porque há tantos!

Não precisa se aprofundar: não usar instruções preparadas.

Usando aliases de tabela sem sentido:

from employee t1,
department t2,
job t3,
...

Torna a leitura de uma instrução SQL grande muito mais difícil do que precisa

var query = "select COUNT(*) from Users where UserName = '" 
            + tbUser.Text 
            + "' and Password = '" 
            + tbPassword.Text +"'";

1. Confiando cegamente na entrada do usuário
2. Não usando consultas parametrizadas
3. Senhas de texto não criptografado

Meus insetos são as tabelas de acesso de 450 colunas que foram reunidas pelo filho de 8 anos da melhor amiga do diretor de administração e a tabela de pesquisa que só existe porque alguém não sabe como normalizar uma estrutura de dados corretamente.

Normalmente, esta tabela de pesquisa se parece com isso:

EU NÃO FIZ,
Nome NVARCHAR (132),
IntValue1 INT,
IntValue2 INT,
CharValue1 NVARCHAR (255),
CharValue2 NVARCHAR (255),
Date1 DATETIME,
Date2 DATETIME

Perdi a conta do número de clientes que vi que têm sistemas que dependem de abominações como essa.

Os que eu mais não gosto são

1. Usando espaços ao criar tabelas, sprocs etc. Estou bem com CamelCase ou under_scores e singular ou plural e MAIÚSCULAS ou minúsculas, mas preciso me referir a uma tabela ou coluna [com espaços], especialmente se [estiver estranhamente espaçada] (sim, Eu me deparei com isso) realmente me irrita.

2. Dados não normalizados. Uma tabela não precisa ser perfeitamente normalizada, mas quando encontro uma tabela de funcionários que possui informações sobre sua pontuação de avaliação atual ou sobre qualquer outra coisa principal, isso me diz que provavelmente precisarei criar uma tabela separada em algum momento e tente mantê-los sincronizados. Normalizarei os dados primeiro e, em seguida, se vir um local em que a desnormalização ajuda, considerarei.

3. Uso excessivo de visualizações ou cursores. As visualizações têm um objetivo, mas quando cada tabela é agrupada em uma visualização, é demais. Eu tive que usar cursores algumas vezes, mas geralmente você pode usar outros mecanismos para isso.

4. Acesso. Um programa pode ser um antipadrão? Temos o SQL Server no meu trabalho, mas várias pessoas usam o acesso devido à sua disponibilidade, "facilidade de uso" e "simpatia" a usuários não técnicos. Há muito aqui para entrar, mas se você já esteve em um ambiente semelhante, você sabe.

use SP como o prefixo do nome do procedimento de armazenamento, porque ele primeiro procurará no local dos procedimentos do sistema, em vez dos personalizados.

Uso excessivo de tabelas e cursores temporários.

Para armazenar valores de tempo, apenas o fuso horário UTC deve ser usado. A hora local não deve ser usada.

usando @@ IDENTITY em vez de SCOPE_IDENTITY ()

Citado nesta resposta :

• @@ IDENTITY retorna o último valor de identidade gerado para qualquer tabela na sessão atual, em todos os escopos. Você precisa ter cuidado aqui, já que é através de escopos. Você pode obter um valor de um gatilho, em vez de sua declaração atual.
• SCOPE_IDENTITY retorna o último valor de identidade gerado para qualquer tabela na sessão atual e o escopo atual. Geralmente o que você deseja usar.
• IDENT_CURRENT retorna o último valor de identidade gerado para uma tabela específica em qualquer sessão e qualquer escopo. Isso permite especificar de qual tabela você deseja obter o valor, caso as duas acima não sejam exatamente o que você precisa (muito raro). Você pode usar isso se desejar obter o valor atual de IDENTITY para uma tabela na qual você não inseriu um registro.

Reutilizar um campo "morto" para algo a que não se destinava (por exemplo, armazenar dados do usuário em um campo "Fax") - muito tentador como uma solução rápida!

select some_column, ...
from some_table
group by some_column

e assumindo que o resultado será classificado por alguma_coluna. Eu já vi isso um pouco com a Sybase, onde a suposição se mantém (por enquanto).

SELECT FirstName + ' ' + LastName as "Full Name", case UserRole when 2 then "Admin" when 1 then "Moderator" else "User" end as "User's Role", case SignedIn when 0 then "Logged in" else "Logged out" end as "User signed in?", Convert(varchar(100), LastSignOn, 101) as "Last Sign On", DateDiff('d', LastSignOn, getDate()) as "Days since last sign on", AddrLine1 + ' ' + AddrLine2 + ' ' + AddrLine3 + ' ' + City + ', ' + State + ' ' + Zip as "Address", 'XXX-XX-' + Substring(Convert(varchar(9), SSN), 6, 4) as "Social Security #" FROM Users

Ou, amontoando tudo em uma linha.

• A FROM TableA, TableB WHEREsintaxe para JOINS em vez deFROM TableA INNER JOIN TableB ON

• Fazendo suposições de que uma consulta será retornada classificada de uma certa maneira sem inserir uma cláusula ORDER BY, apenas porque foi dessa maneira que ela apareceu durante o teste na ferramenta de consulta.

Aprendendo SQL nos primeiros seis meses de sua carreira e nunca aprendendo mais nada nos próximos 10 anos. Em particular, não aprendendo ou usando efetivamente os recursos SQL de janela / analítica. Em particular, o uso de over () e partição por.

As funções da janela, como funções agregadas, executam uma agregação em um conjunto definido (um grupo) de linhas, mas, em vez de retornar um valor por grupo, as funções da janela podem retornar vários valores para cada grupo.

Consulte o Apêndice A do O'Reilly SQL Cookbook para obter uma boa visão geral das funções de janelas.

Preciso colocar meu favorito atual aqui, apenas para completar a lista. Meu antipadrão favorito não está testando suas consultas .

Isso se aplica quando:

1. Sua consulta envolve mais de uma tabela.
2. Você acha que possui um design ideal para uma consulta, mas não se preocupe em testar suas suposições.
3. Você aceita a primeira consulta que funciona, sem nenhuma pista sobre se ela está quase otimizada.

E todos os testes executados com dados atípicos ou insuficientes não contam. Se for um procedimento armazenado, coloque a instrução de teste em um comentário e salve-a com os resultados. Caso contrário, coloque-o em um comentário no código com os resultados.

Abuso temporário da tabela.

Especificamente esse tipo de coisa:

SELECT personid, firstname, lastname, age
INTO #tmpPeople
FROM People
WHERE lastname like 's%'

DELETE FROM #tmpPeople
WHERE firstname = 'John'

DELETE FROM #tmpPeople
WHERE firstname = 'Jon'

DELETE FROM #tmpPeople
WHERE age > 35

UPDATE People
SET firstname = 'Fred'
WHERE personid IN (SELECT personid from #tmpPeople)

Não crie uma tabela temporária a partir de uma consulta, apenas para excluir as linhas que você não precisa.

E sim, vi páginas de código neste formulário nos bancos de dados de produção.

Visão contrária: excesso de obsessão com normalização.

A maioria dos sistemas SQL / RBDBs oferece muitos recursos (transações, replicação) que são bastante úteis, mesmo com dados não normalizados. O espaço em disco é barato e, às vezes, pode ser mais simples (código mais fácil, tempo de desenvolvimento mais rápido) manipular / filtrar / pesquisar dados buscados, do que escrever o esquema 1NF e lidar com todos os aborrecimentos nele (junções complexas, subselects desagradáveis) etc).

Descobri que os sistemas super normalizados costumam ser otimização prematura, especialmente durante os estágios iniciais de desenvolvimento.

(mais pensamentos sobre isso ... http://writeonly.wordpress.com/2008/12/05/simple-object-db-using-json-and-python-sqlite/ )

Acabei de montar este, com base em algumas das respostas SQL aqui no SO.

É um antipadrão sério pensar que os gatilhos são para bancos de dados, assim como os manipuladores de eventos são para OOP. Existe essa percepção de que qualquer lógica antiga pode ser acionada para ser acionada quando uma transação (evento) acontece em uma tabela.

Não é verdade. Uma das grandes diferenças é que os gatilhos são síncronos - com uma vingança, porque são síncronos em uma operação definida, não em uma operação de linha. No lado OOP, exatamente o oposto - os eventos são uma maneira eficiente de implementar transações assíncronas.

Procedimentos ou funções armazenados sem nenhum comentário ...

1) Não sei se é um antipadrão "oficial", mas não gosto e tento evitar literais de string como valores mágicos em uma coluna do banco de dados.

Um exemplo da tabela 'image' da MediaWiki:

img_media_type ENUM("UNKNOWN", "BITMAP", "DRAWING", "AUDIO", "VIDEO", 
    "MULTIMEDIA", "OFFICE", "TEXT", "EXECUTABLE", "ARCHIVE") default NULL,
img_major_mime ENUM("unknown", "application", "audio", "image", "text", 
    "video", "message", "model", "multipart") NOT NULL default "unknown",

(Eu só noto caixa diferente, outra coisa a evitar)

Eu projeto casos como pesquisas int em tabelas ImageMediaType e ImageMajorMime com chaves primárias int.

2) conversão de data / string que depende de configurações específicas do NLS

CONVERT(NVARCHAR, GETDATE())

sem identificador de formato

Subconsultas idênticas em uma consulta.

• A visão alterada - uma visão alterada com muita frequência e sem aviso ou motivo. A mudança será notada no momento mais inapropriado ou, pior, errada e nunca notada. Talvez seu aplicativo seja interrompido porque alguém pensou em um nome melhor para essa coluna. Como regra, as exibições devem estender a utilidade das tabelas base, mantendo um contrato com os consumidores. Corrija os problemas, mas não adicione recursos ou pior comportamento de alteração, pois isso cria uma nova exibição. Para mitigar, não compartilhe visualizações com outros projetos e use CTEs quando as plataformas permitirem. Se sua loja possui um DBA, você provavelmente não poderá alterar as visualizações, mas todas as suas visualizações estarão desatualizadas e / ou inúteis nesse caso.

• O! Paramed - uma consulta pode ter mais de uma finalidade? Provavelmente, mas a próxima pessoa que a ler não saberá até profunda meditação. Mesmo que você não precise deles agora, é provável que sim, mesmo que seja "apenas" para depurar. A adição de parâmetros reduz o tempo de manutenção e mantém as coisas SECA. Se você tiver uma cláusula where, deverá ter parâmetros.

• O caso sem CASE -

  SELECT  
  CASE @problem  
    WHEN 'Need to replace column A with this medium to large collection of strings hanging out in my code.'  
      THEN 'Create a table for lookup and add to your from clause.'  
    WHEN 'Scrubbing values in the result set based on some business rules.'  
      THEN 'Fix the data in the database'  
    WHEN 'Formating dates or numbers.'   
      THEN 'Apply formating in the presentation layer.'  
    WHEN 'Createing a cross tab'  
      THEN 'Good, but in reporting you should probably be using cross tab, matrix or pivot templates'   
  ELSE 'You probably found another case for no CASE but now I have to edit my code instead of enriching the data...' END  

Os dois que eu mais encontro e que podem ter um custo significativo em termos de desempenho são:

• Usando cursores em vez de uma expressão baseada em conjunto. Eu acho que esse ocorre com frequência quando o programador está pensando de maneira processual.

• Usando subconsultas correlacionadas, quando uma associação a uma tabela derivada pode fazer o trabalho.

Colocar coisas em tabelas temporárias, especialmente as pessoas que alternam do SQL Server para o Oracle, costumam usar tabelas temporárias em excesso. Basta usar instruções de seleção aninhadas.

Desenvolvedores que escrevem consultas sem ter uma boa idéia sobre o que torna os aplicativos SQL (consultas individuais e sistemas multiusuário) rápidos ou lentos. Isso inclui ignorância sobre:

• estratégias de minimização de E / S física, uma vez que o gargalo da maioria das consultas é de E / S, não da CPU
• impacto de diferentes tipos de acesso ao armazenamento físico (por exemplo, muitas E / S sequenciais serão mais rápidas que muitas pequenas E / S aleatórias, embora menos se o seu armazenamento físico for um SSD!)
• como ajustar manualmente uma consulta se o DBMS produzir um plano de consulta ruim
• como diagnosticar um desempenho ruim do banco de dados, como "depurar" uma consulta lenta e como ler um plano de consulta (ou EXPLAIN, dependendo do DBMS de sua escolha)
• estratégias de bloqueio para otimizar a taxa de transferência e evitar conflitos em aplicativos multiusuários
• importância do lote e outros truques para lidar com o processamento de conjuntos de dados
• design de tabela e índice para melhor equilibrar espaço e desempenho (por exemplo, cobertura de índices, manutenção de índices pequenos sempre que possível, redução de tipos de dados para o tamanho mínimo necessário, etc.)

Usando o SQL como um pacote ISAM (Método de Acesso Sequencial Indexado) glorificado. Em particular, aninhando cursores em vez de combinar instruções SQL em uma única instrução, embora maior. Isso também conta como 'abuso do otimizador', pois, na verdade, não há muito que o otimizador possa fazer. Isso pode ser combinado com declarações não preparadas para máxima ineficiência:

DECLARE c1 CURSOR FOR SELECT Col1, Col2, Col3 FROM Table1

FOREACH c1 INTO a.col1, a.col2, a.col3
    DECLARE c2 CURSOR FOR
        SELECT Item1, Item2, Item3
            FROM Table2
            WHERE Table2.Item1 = a.col2
    FOREACH c2 INTO b.item1, b.item2, b.item3
        ...process data from records a and b...
    END FOREACH
END FOREACH

A solução correta (quase sempre) é combinar as duas instruções SELECT em uma:

DECLARE c1 CURSOR FOR
    SELECT Col1, Col2, Col3, Item1, Item2, Item3
        FROM Table1, Table2
        WHERE Table2.Item1 = Table1.Col2
        -- ORDER BY Table1.Col1, Table2.Item1

FOREACH c1 INTO a.col1, a.col2, a.col3, b.item1, b.item2, b.item3
    ...process data from records a and b...
END FOREACH

A única vantagem da versão de loop duplo é que você pode identificar facilmente as quebras entre os valores na Tabela1 porque o loop interno termina. Isso pode ser um fator nos relatórios de quebra de controle.

Além disso, a classificação no aplicativo geralmente é um não-não.

Usando chaves primárias como substitutas para endereços de registros e usando chaves estrangeiras como substitutas para ponteiros incorporados nos registros.