O que é uma maneira eficaz de rotular colunas em um banco de dados?

Eu costumava rotular colunas em meus bancos de dados como este:

user_id
user_name
user_password_hash

Para evitar conflitos ao ingressar em duas tabelas, aprendi um pouco mais sobre como aliasar tabelas e parei de fazer isso.

O que é uma maneira eficaz de rotular colunas em um banco de dados? Por quê?

No seu caso, o usuário do prefixo é redundante. Nós (os desenvolvedores encarregados) sabemos que esse é o usuário da tabela; então, por que adicionar user_prefixo na frente de cada campo?

O que eu sugeriria é fazê-lo com uma abordagem mais natural.

Quais são as características de uma Pessoa: Sobrenome, Nome, Data de Nascimento, Nacionalidade, etc ...

Quais são as características de um carro: modelo, ano, cor, energia, etc ...

Sua coluna deve ter o nome o mais natural possível, isso tornaria o esquema mais claro para todos, para você e para os que vierem depois de você. Isso também é chamado de fase de manutenção, e tudo o que você pode fazer para facilitar a manutenção geralmente vale a pena.

Além do comentário da Spredzy, rotule suas chaves primárias da mesma forma (ID) para que, ao escrever consultas em tempo real, você possa se lembrar facilmente (u.ID = c.ID) em vez de precisar procurar "Era o countryID , country_ID, countries_ID, countriesID,? "

Eu não poderia concordar mais com o adendo de David Hall à excelente resposta de Spredzy. Simples e natural é o caminho a percorrer. A confusão de tabelas não deve ser um problema se você nomear tabelas naturalmente também.

Não faz sentido ter users.user_id e cars.car_id quando você pode ter users.id e cars.id

Eu diria que, em um esquema de banco de dados, cada coluna deve ter um nome exclusivo, entre tabelas. Há várias razões para isso:

• Do ponto de vista da modelagem: você começa com uma sopa de atributos e a normaliza em tabelas. Com o tempo, você pode desnormalizar ou normalizar ainda mais ou introduzir visualizações ou visualizações materializadas ou introduzir novas tabelas. Isso nunca é um problema se todos os nomes de colunas forem exclusivos.

• Você pode usar esta junção sintaxe: a JOIN b USING (a_id) JOIN c USING (a_id). Muito conveniente e também ajuda com o seguinte ponto.

• Se você executar consultas com muitas associações ou criar visualizações materializadas SELECT *, nunca terá (bem, talvez raramente) um conflito. Pense sobre como ingressar person.name, product.name, country.name, etc. Urgh.

• Em geral, se você tiver grandes consultas, é difícil acompanhar o que idsignifica em qualquer lugar.

Vamos ver, com o seu exemplo, será algo como isto:

USERS
----
id
username,
password
registration_date

Eu uso o nome da tabela em maiúsculas. Isso me permite identificar a tabela facilmente. As colunas que acabei de nomear são cada uma para o que elas representam. Tento não usar números ou incluir qualquer prefixo ou sufixo. Isso tornará as consultas simples e bem diretas.

BTW, acho que você deve encontrar um estilo que você goste e ficar com ele. Se você alterá-lo com freqüência, terá um esquema de banco de dados mais confuso.

Como os outros, recomendo que você não inclua o nome da tabela como parte da coluna. A menos que você tenha centenas de tabelas, todas com nomes de colunas semelhantes: se você tiver várias dezenas de tabelas, todas com uma coluna denominada ID, prefira-as com o nome da tabela.

Recentemente, saí de uma empresa em que um dos desenvolvedores preferiu prefixar as colunas chave primária e chave estrangeira com pk e fk. Isso levou a algumas abominações nas quais as colunas começaram com pkfk (geralmente uma chave primária composta com base em 2 colunas, das quais uma coluna era uma chave estrangeira para outra tabela).

Estou trabalhando em um ambiente em que cada nome de coluna começa com um prefixo derivado do nome da tabela, não é minha invenção, mas estou muito feliz com isso.

Idealmente, os nomes das colunas são exclusivos em todas as tabelas do banco de dados.

Algumas observações:

• precisamos apenas de aliases de tabela, quando as tabelas são unidas várias vezes em uma instrução select
• evita algumas falhas ao copiar trechos de código, porque os nomes das colunas devem ser adaptados ao nome da tabela
• ajuda a mostrar para qual tabela uma coluna de chave estrangeira aponta

Idéias gerais: O mais importante é a consistência de cada uma das convenções de nomenclatura: - singular vs. plural (ok que se aplica a tabelas e não colunas) - identifique chaves primárias e estrangeiras (elas constroem a estrutura versus o conteúdo do banco de dados) - seja consistente quando você armazena strings e uma variante curta da mesma string - seja consistente com sinalizadores, status etc.

Concordo com a resposta de Spredzy, mas acrescentaria que, por uma questão de preferência, eu usaria camelCase em vez de under_score.

nome, sobrenome etc.

No caso do Oracle, convém não nomear as colunas 'id' ou 'name' ou qualquer coisa genérica.

O problema é que, por padrão, em versões mais antigas , o Oracle tentará ingressar em tabelas com base em nomes de colunas semelhantes; portanto, se eu nomeei tudo bem, também acabei especificando a cláusula de associação padrão entre minhas tabelas.

Mas mesmo que você não esteja usando o Oracle, não escolhendo nomes que aparecem em várias tabelas, também significa que você não precisará passar pelo problema de criar aliases toda vez que precisar fazer uma seleção em duas tabelas:

SELECT
  instrument.name as instrument_name,
  instrument.abbr as instrument_abbr,
  source.name     as source_name,
  source.abbr     as source_abbr,
  ...
FROM ...

Portanto, se a seleção de várias tabelas for a norma, os nomes mais longos das colunas economizarão a digitação. (se você estiver usando apenas uma tabela por vez ... você realmente precisa de um banco de dados relacional?)

... e salvar a digitação nos leva a outro problema no Oracle - pelo menos no 8i (a versão atual quando participei dos cursos de Oracle SQL Tuning e Data Modeling), o cache dos planos de execução é baseado apenas nos primeiros tantos caracteres do consulta (não se lembra do valor exato ... 1024?), portanto, se você tiver consultas que variam apenas de alguma forma no final da cláusula where e uma lista realmente longa de colunas que você está extraindo, pode ter um desempenho atingido, pois não pode armazenar em cache o plano de execução corretamente.

A Oracle tinha um guia para selecionar o que eles afirmam ser bons nomes de tabelas e colunas, que é basicamente um guia para remover letras até que tenham entre 5 e 8 caracteres, mas eu nunca me importei muito com isso.

...

Como as coisas vão além disso:

• as colunas são sempre singulares (as tabelas são sempre plurais)
• todos os nomes são minúsculos, caso haja algo que diferencia maiúsculas de minúsculas
• como resultado acima, use sublinhados em vez de estojo de camelo.

update : para aqueles que não estão familiarizados com o comportamento de junção do Oracle, consulte o último exemplo em Mastering Oracle SQL: Join Conditions , em que ele menciona:

O que aconteceu? O motivo está no fato de que, além de supplier_id, essas duas tabelas têm outro par de colunas com um nome comum. Essa coluna é o nome. Portanto, quando você solicita uma junção natural entre o fornecedor e as tabelas de peças, a junção ocorre não apenas igualando a coluna supplier_id das duas tabelas, mas também a coluna de nome das duas tabelas. Como nenhum nome de fornecedor é igual a um nome de peça desse mesmo fornecedor, nenhuma linha é retornada pela consulta.

Sob 'sintaxe de junção antiga' (8i e anterior), 'NATURAL JOIN' era o comportamento de junção padrão, e acredito que ainda será se você não especificar uma condição de junção. Uma vez que 'NATURAL JOIN' era uma opção oficial no 9i, a recomendação geral era não usá-lo , porque a má nomeação de colunas pode estragar tudo, o que eu estou defendendo por bons nomes de colunas.

1. Nunca use aspas duplas, "pois, ao fazer isso, você substitui a dobra nativa do banco de dados. A especificação SQL exige que todos os identificadores sejam dobrados para maiúsculas. Alguns bancos de dados, como o PostgreSQL, dobram-nos para minúsculas. Se nada for citado, ele funcionará em todos os bancos de dados e eles poderão dobrá-los para a especificação ou o padrão específico do rdbms.
2. Use um under_score ( _), porque conforme descrito acima - você não deve usar camelCase.

3. use {entity}_idpara identificações (e chaves estrangeiras apontando para essas identificações). Porque então você pode usar a USINGcláusula Os nomes de chave exclusivos globalmente usados ​​nas condições de junção são uma convenção estabelecida na especificação.

   SELECT *
   FROM employee
   INNER JOIN department
     USING (department_id);
   
     -- compare to
     ON employee.department_id = department.department_id;