O que é a cláusula AS do SQL? Use aliases para nomear tabelas e colunas e torne suas consultas drasticamente mais legíveis!

"O nome da coluna do meu cálculo fica feio, como `price * 1.1`..."
"Depois de um JOIN, os nomes das tabelas são tão longos que minha consulta fica uma bagunça para ler!"

Ao começar a escrever SQL, você já sentiu essas "pequenas frustrações"? A consulta funciona, mas é difícil de ler. Quando você a revisa mais tarde, leva tempo até mesmo para você decifrar o que estava fazendo...

A palavra-chave mágica que resolve esses problemas em um instante é a cláusula "AS", que apresentaremos hoje. Usando AS, você pode dar "aliases (apelidos)" para tabelas e colunas. É como chamar um amigo por um apelido em vez de seu nome completo e longo. Uma vez que você dominar o AS, suas consultas SQL se tornarão drasticamente mais fáceis de ler e escrever!

Neste artigo, explicaremos detalhadamente desde o uso básico da cláusula AS, que aumenta vertiginosamente a legibilidade do SQL, até técnicas avançadas como seu uso com JOINs e auto-junções (self-joins), tudo com código de exemplo pronto para copiar e colar.

Preparação: Uma Tabela de Prática

Primeiro, vamos configurar uma tabela para experimentar a conveniência dos aliases. Desta vez, usaremos uma tabela de produtos simples.

-- Excluir a tabela se ela existir
DROP TABLE IF EXISTS products;

-- Criar a tabela de produtos
CREATE TABLE products (
    id INT PRIMARY KEY,
    product_name VARCHAR(100),
    price INT,
    category VARCHAR(50)
);

-- Inserir dados
INSERT INTO products (id, product_name, price, category) VALUES
(1, '高機能オフィスチェア', 35000, '家具'),
(2, '静音ワイヤレスキーボード', 8000, '周辺機器'),
(3, '4K対応27インチモニター', 42000, '周辺機器'),
(4, '電動昇降式デスク', 65000, '家具'),
(5, 'ノイズキャンセリングヘッドホン', 28000, 'オーディオ');
    

Vamos explorar as várias maneiras de usar a cláusula AS com esta tabela!

1. Aliases de Coluna: Arrumando a Aparência dos Seus Resultados

Um alias de coluna é um recurso que renomeia os nomes das colunas (cabeçalhos) no conjunto de resultados de uma consulta para algo mais compreensível. Não se preocupe, isso não altera os nomes reais das colunas na tabela original. É útil principalmente ao gerar relatórios ou exibir dados em uma aplicação.

Exemplo 1: Renomeando colunas para nomes mais compreensíveis

É útil quando você quer exibir nomes de coluna em inglês como `product_name` e `price` como cabeçalhos mais descritivos em português, como "Nome do Produto" e "Preço".

SELECT
    product_name AS "Nome do Produto",
    price AS "Preço"
FROM
    products;
    

Assim, os cabeçalhos do resultado mudaram simplesmente especificando um novo nome após AS. Agora você pode criar relatórios que são fáceis de entender, mesmo para pessoas que não conhecem SQL.

Exemplo 2: Nomeando colunas calculadas

Um dos usos mais comuns para AS é dar um nome claro a uma coluna que resulta de um cálculo ou função. Por exemplo, vamos calcular um preço com imposto (preço × 1.2).

-- Sem AS, o nome da coluna se torna o próprio cálculo
SELECT
    product_name,
    price * 1.2
FROM
    products;
    

O nome da coluna acaba sendo `price * 1.2`, o que parece bem desajeitado, certo? É aqui que AS vem para o resgate.

-- Usando AS para dar um nome claro
SELECT
    product_name AS "Nome do Produto",
    price * 1.2 AS "Preço com Imposto"
FROM
    products;
    

Que tal? Apenas adicionando AS "Preço com Imposto", o resultado fica muito mais fácil de ler. É prática padrão usar AS para nomear os resultados de funções de agregação (`COUNT`, `SUM`, `AVG`, etc.) da mesma forma.

※ A propósito, em muitos ambientes SQL, a palavra-chave AS é opcional para aliases de coluna (por exemplo, `price "Preço"`). No entanto, para melhorar a legibilidade do código, recomenda-se escrever AS explicitamente.

2. Aliases de Tabela: Simplificando Consultas Complexas

Um alias de tabela é um recurso que dá a uma tabela um "nome curto e temporário" dentro de uma consulta. Isso é incrivelmente eficaz, especialmente quando você está usando JOIN com várias tabelas. Torna as consultas mais curtas, mais simples e deixa óbvio a qual tabela uma coluna pertence.

Exemplo 1: Deixando uma instrução JOIN mais limpa

Vejamos um exemplo usando as tabelas "employees" (funcionários) e "departments" (departamentos).

-- Preparação de tabelas para este exemplo
DROP TABLE IF EXISTS employees;
DROP TABLE IF EXISTS departments;
CREATE TABLE departments (id INT, department_name STRING);
INSERT INTO departments VALUES (1, '営業部'), (2, '開発部');
CREATE TABLE employees (id INT, name STRING, department_id INT);
INSERT INTO employees VALUES (1, '山田 太郎', 1), (2, '鈴木 花子', 2);
    

Sem aliases, você tem que escrever o formato completo `nome_da_tabela.nome_da_coluna` toda vez, o que é muito verboso.

-- Sem aliases (exemplo verboso)
SELECT
    employees.name,
    departments.department_name
FROM
    employees
INNER JOIN
    departments ON employees.department_id = departments.id;
    

Vamos reescrever isso usando aliases de tabela. Vamos nomear employees como e e departments como d.

-- Com aliases (forma recomendada)
SELECT
    e.name,
    d.department_name
FROM
    employees AS e
INNER JOIN
    departments AS d ON e.department_id = d.id;
    

Ficou incrivelmente limpo agora! Está claro que e.name significa a coluna `name` da tabela `employees`, e a legibilidade geral da consulta melhorou drasticamente.

Prática! Vamos Experimentar os Aliases no seu Navegador

Obrigado por esperar! Aqui está um ambiente onde você pode colocar a mão na massa e experimentar as técnicas de alias que aprendeu até agora.

Copie o bloco de código inteiro abaixo, salve-o como um arquivo com um nome como alias_practice.html e abra-o no seu navegador. Aplique aliases à consulta `INNER JOIN` e experimente como a consulta se torna muito mais legível!

<!DOCTYPE html>
<html lang="pt">
<head>
    <meta charset="UTF-8">
    <title>Ambiente de Testes para Alias de SQL</title>
    <script src="https://cdn.jsdelivr.net/npm/alasql@4"></script>
    <style>
        body { font-family: sans-serif; padding: 2rem; background-color: #f9f9f9; }
        .container { max-width: 800px; margin: auto; background: white; padding: 2rem; border-radius: 8px; box-shadow: 0 4px 8px rgba(0,0,0,0.1); }
        h1 { color: #333; }
        textarea { width: 100%; height: 180px; font-family: monospace; font-size: 16px; padding: 10px; border: 1px solid #ccc; border-radius: 4px; box-sizing: border-box; margin-bottom: 1rem; }
        button { background-color: #007bff; color: white; padding: 10px 20px; border: none; border-radius: 4px; cursor: pointer; font-size: 16px; }
        button:hover { background-color: #0056b3; }
        #result-area { margin-top: 2rem; }
        table { width: 100%; border-collapse: collapse; margin-top: 1rem; }
        th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
        th { background-color: #f2f2f2; }
        .error { color: red; font-weight: bold; }
    </style>
</head>
<body>
    <div class="container">
        <h1>Vamos Experimentar os Aliases!</h1>
        <p>Insira uma instrução SQL na área de texto abaixo e pressione o botão "Executar SQL".</p>
        <textarea id="sql-input">-- Escreva seu SQL aqui
SELECT
    e.name AS "Nome do Funcionário",
    d.department_name AS "Nome do Departamento"
FROM
    employees AS e
INNER JOIN
    departments AS d ON e.department_id = d.id;</textarea>
        <button onclick="executeSQL()">Executar SQL</button>
        <div id="result-area"></div>
    </div>

    <script>
        // Inicializar o banco de dados e preparar dados para JOIN
        const db = new alasql.Database();
        db.exec(`
            CREATE TABLE departments (id INT, department_name STRING);
            INSERT INTO departments VALUES (1, '営業部'), (2, '開発部');
            CREATE TABLE employees (id INT, name STRING, department_id INT);
            INSERT INTO employees VALUES (1, '山田 太郎', 1), (2, '鈴木 花子', 2);
        `);

        function executeSQL() {
            const sql = document.getElementById('sql-input').value;
            const resultArea = document.getElementById('result-area');
            resultArea.innerHTML = '';

            try {
                const result = db.exec(sql);
                if (result.length > 0) {
                    resultArea.appendChild(createTable(result));
                } else {
                    resultArea.innerHTML = '<p>A consulta retornou 0 linhas.</p>';
                }
            } catch (e) {
                resultArea.innerHTML = `<p class="error">Erro: ${e.message}</p>`;
            }
        }

        function createTable(data) {
            const table = document.createElement('table');
            const thead = table.createTHead();
            const tbody = table.createTBody();
            const headerRow = thead.insertRow();
            for (const key in data[0]) {
                const th = document.createElement('th');
                th.textContent = key;
                headerRow.appendChild(th);
            }
            data.forEach(rowData => {
                const row = tbody.insertRow();
                for (const key in rowData) {
                    const cell = row.insertCell();
                    cell.textContent = rowData[key];
                }
            });
            return table;
        }

        // Exibição inicial
        executeSQL();
    </script>
</body>
</html>
    

Pontos de Atenção: Escopo e Ordem dos Aliases

Os aliases são muito convenientes, mas há uma regra importante que você precisa conhecer. Tem a ver com a "ordem de execução do SQL".

Você não pode usar aliases de coluna nas cláusulas `WHERE` ou `GROUP BY`

A ordem interna em que o SQL é executado é um pouco diferente da ordem em que o escrevemos (SELECT → FROM → WHERE). Em termos gerais, a ordem real é a seguinte:

FROM → WHERE → GROUP BY → HAVING → SELECT → ORDER BY

Você percebeu? A cláusula SELECT é processada após as cláusulas WHERE e GROUP BY. Por causa disso, você não pode usar um alias de coluna definido na lista SELECT em uma cláusula que é processada antes, como WHERE.

-- Este exemplo causará um erro
-- Este exemplo usa a tabela 'products' para a explicação
SELECT
    product_name AS "Nome do Produto"
FROM
    products
WHERE
    "Nome do Produto" = '高機能オフィスチェア';
    

A consulta acima resultará em um erro. Isso ocorre porque no momento em que a cláusula WHERE é processada, o alias "Nome do Produto" ainda não existe. Neste caso, você deve usar o nome da coluna original. (Para testar este erro, você precisaria alterar a configuração de dados na área de prática acima de volta para a tabela 'products').

-- Esta é a forma correta
SELECT
    product_name AS "Nome do Produto"
FROM
    products
WHERE
    product_name = '高機能オフィスチェア';
    

Por outro lado, você pode usar aliases de coluna na cláusula ORDER BY, já que ela é processada após a cláusula SELECT. Isso é muito útil, então é bom lembrar.

Resumo

Ótimo trabalho! Neste artigo, explicamos a cláusula AS (alias), que torna as consultas SQL drasticamente mais fáceis de ler e escrever.

• Alias de Coluna: Escrito como AS "Alias" após o nome de uma coluna na cláusula SELECT. Usado para arrumar a aparência dos resultados ou para dar um nome claro a uma coluna calculada.
• Alias de Tabela: Escrito como AS Alias após o nome de uma tabela na cláusula FROM ou JOIN. Simplifica drasticamente as consultas e melhora a legibilidade, especialmente ao lidar com várias tabelas em um JOIN.
• Ponto de Atenção: Um alias de coluna definido na cláusula SELECT não pode ser usado em cláusulas que são executadas antes, como WHERE ou GROUP BY.

AS é uma palavra-chave essencial que todos deveriam usar, desde iniciantes que estão apenas começando com SQL até profissionais que lidam com dados complexos. A partir de hoje, tente dar alguns "apelidos" às suas consultas. Seu eu do futuro, e seus colegas de equipe, certamente agradecerão por isso!