Skip to content
TheChatArchiveThe Chat Archive
Geminigemini-2.5-pro· GoogleHugging Face LMArena Human Preference 140K

Qual a melhor prática para nomear tabelas e colunas no SQL?

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with o4-mini-2025-04-16’s answer.
  1. User

    Qual a melhor prática para nomear tabelas e colunas no SQL?

  2. Gemini Assistant

    Ótima pergunta! A escolha de um padrão para nomear tabelas e colunas (Naming Convention) é uma das práticas mais importantes para garantir a manutenibilidade, legibilidade e colaboração em qualquer projeto de banco de dados.

    Não existe um padrão oficial "único e verdadeiro" imposto pelo SQL, mas existem convenções amplamente aceitas pela comunidade que formam as "melhores práticas". O mais importante é escolher um padrão e ser consistente em todo o projeto.

    Vamos detalhar as práticas mais recomendadas, dividindo por tabelas e colunas.


    Princípios Gerais (A Filosofia por Trás das Regras)

    1. Clareza e Legibilidade: O nome deve descrever o seu conteúdo. Alguém que nunca viu seu banco de dados deve ser capaz de entender o que a tabela armazena ou o que a coluna significa apenas lendo o nome.
    2. Consistência: A regra mais importante de todas. Se você decidir usar snake_case, use-o em todos os lugares. Se decidir por nomes de tabelas no plural, todas devem ser no plural.
    3. Evite Palavras Reservadas: Nunca use palavras-chave do SQL como nomes de tabelas ou colunas (ex: user, order, group, select, table). Isso causa conflitos e força o uso de delimitadores (aspas ou crases), tornando as queries mais verbosas e propensas a erros.
    4. Use Inglês: Para projetos que podem envolver desenvolvedores de diferentes nacionalidades (ou mesmo para facilitar a busca por soluções online), o inglês é o padrão universal. Evite acentos e caracteres especiais.

    1. Nomeando Tabelas

    a) Plural vs. Singular (O Grande Debate)

    Esta é a discussão mais comum. Ambas as abordagens têm lógica, mas uma delas é mais popular.

    • Plural (Recomendado): users, products, orders

      • Lógica: A tabela representa uma coleção de registros. Faz sentido intuitivo ler SELECT * FROM users;, que se traduz como "Selecione tudo de (uma coleção de) usuários".
      • Vantagem: É a convenção mais comum e amplamente adotada por frameworks populares como Ruby on Rails e Laravel.
    • Singular: user, product, order

      • Lógica: A tabela representa a definição da entidade ou o "molde" de um registro. Um registro na tabela user representa um único usuário.
      • Vantagem: Pode alinhar-se melhor com o nome de classes em programação orientada a objetos (uma classe User mapeia para uma tabela user).

    Veredito: Use nomes no plural. É mais intuitivo para a maioria dos desenvolvedores e evita conflitos com palavras reservadas (por exemplo, orders é seguro, mas order é uma palavra-chave do SQL).

    b) Estilo de Escrita (Case Style)

    • snake_case (Recomendado): user_profiles, order_details

      • Todas as letras minúsculas, com palavras separadas por um underscore (_).
      • Vantagens: É o mais portável entre diferentes sistemas de banco de dados (PostgreSQL, MySQL, Oracle). Alguns sistemas não são case-sensitive por padrão, e o snake_case evita qualquer ambiguidade. É extremamente legível.
    • PascalCase (Comum em alguns ecossistemas): UserProfiles, OrderDetails

      • Cada palavra começa com uma letra maiúscula.
      • Vantagens: Comum no ecossistema Microsoft (SQL Server) e C#/.NET.
      • Desvantagem: Pode causar problemas de portabilidade se você migrar para um SGBD que é case-sensitive (como o PostgreSQL em certas configurações).

    Veredito: Use snake_case. É a aposta mais segura, legível e universal.

    c) Prefixos (Prática Antiga / Não Recomendada)

    No passado, era comum ver prefixos como tbl_users ou T_Users.

    • Por que evitar? É redundante. Já sabemos que é uma tabela. Isso apenas adiciona ruído visual. A forma moderna de agrupar objetos relacionados é usar schemas (ex: billing.invoices, auditing.logs).

    2. Nomeando Colunas

    a) Estilo de Escrita (Case Style)

    • snake_case (Altamente Recomendado): first_name, created_at, user_id

      • Pelos mesmos motivos das tabelas: legibilidade, portabilidade e consistência.
    • camelCase (Alternativa comum): firstName, createdAt, userId

      • Comum em projetos com forte integração com JavaScript ou Java, onde essa é a convenção padrão para variáveis.
      • Desvantagem: Pode ser menos legível no SQL puro e, como PascalCase, pode ter problemas de portabilidade com case-sensitivity.

    Veredito: Novamente, snake_case é o padrão ouro para SQL.

    b) Regras Específicas para Colunas

    • Chaves Primárias (Primary Keys):

      • Simplesmente id. É universalmente entendido como a chave primária da tabela.
      • Ex: Na tabela users, a PK é id. Na tabela products, a PK é id.
    • Chaves Estrangeiras (Foreign Keys):

      • Use o padrão: [nome_da_tabela_referenciada_no_singular]_id.
      • Exemplo: A tabela posts tem uma chave estrangeira para a tabela users. A coluna deve se chamar user_id.
      • Por que isso é genial? A query de junção (JOIN) se torna autoexplicativa:
        SELECT *
        FROM posts
        JOIN users ON posts.user_id = users.id;
        
        É imediatamente óbvio qual coluna se conecta com qual tabela.
    • Colunas Booleanas (Verdadeiro/Falso):

      • Use prefixos como is_, has_, allows_.
      • Exemplos: is_active, has_accepted_terms, allows_notifications.
      • Vantagem: A cláusula WHERE se torna muito legível, quase como uma frase em inglês: WHERE is_active = TRUE.
    • Datas e Timestamps:

      • Seja específico. Use sufixos como _at, _on, ou _date.
      • Exemplos: created_at, updated_at, deleted_at (para soft delete), published_on.
      • Evite nomes genéricos como date. Data de quê?
    • Evite Nomes de Colunas Genéricos:

      • Em vez de name, seja específico: first_name, product_name, category_name.
      • Em vez de description, product_description.
    • Não inclua o tipo de dado no nome:

      • Evite: name_varchar, age_int. Isso é redundante e se torna um problema se você precisar mudar o tipo da coluna no futuro.

    Exemplo Prático: Bom vs. Ruim

    Vamos criar um esquema para um blog simples.

    👎 Exemplo Ruim (Inconsistente e Confuso)

    -- Tabela de usuários (singular, PascalCase, prefixo)
    CREATE TABLE Tbl_User (
        UserID INT PRIMARY KEY, -- PK com nome da tabela
        Name VARCHAR(100), -- Nome genérico
        "email" VARCHAR(100), -- Aspas necessárias, minúsculo
        ativo BOOLEAN, -- Em português, sem padrão
        creation_date TIMESTAMP -- Outro padrão de data
    );
    
    -- Tabela de posts (plural, minúsculo, sem prefixo)
    CREATE TABLE posts (
        post_id INT PRIMARY KEY, -- PK diferente
        texto TEXT, -- Nome em português
        user INT, -- FK ambígua, palavra reservada
        postDate TIMESTAMP -- camelCase, padrão de data diferente
    );
    

    👍 Exemplo Bom (Consistente e Claro)

    -- snake_case, plural
    CREATE TABLE users (
        id INT PRIMARY KEY, -- PK simples
        first_name VARCHAR(100), -- Nome específico
        last_name VARCHAR(100),
        email VARCHAR(100) UNIQUE,
        is_active BOOLEAN DEFAULT TRUE, -- Padrão booleano
        created_at TIMESTAMP, -- Padrão de data
        updated_at TIMESTAMP
    );
    
    -- snake_case, plural
    CREATE TABLE posts (
        id INT PRIMARY KEY,
        user_id INT, -- FK clara e padronizada
        title VARCHAR(255),
        content TEXT,
        published_at TIMESTAMP,
        created_at TIMESTAMP,
        updated_at TIMESTAMP,
    
        FOREIGN KEY (user_id) REFERENCES users(id) -- A relação é óbvia
    );
    

    Resumo (TL;DR)

    1. Consistência é Rei: Escolha um padrão e siga-o.
    2. Tabelas: snake_case e no plural (ex: users, order_items).
    3. Colunas: snake_case (ex: first_name, created_at).
    4. Chave Primária: Simplesmente id.
    5. Chave Estrangeira: nome_tabela_singular_id (ex: user_id na tabela posts).
    6. Booleanos: Use prefixos como is_active ou has_permissions.
    7. Datas: Use sufixos como created_at ou published_on.
    8. Nomes: Seja descritivo e evite abreviações e palavras reservadas do SQL.
    9. Linguagem: Use inglês.

    Seguir essas práticas tornará seu código muito mais profissional, fácil de manter e de colaborar.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.