Formatador e Validador de SQL - Formate Consultas SQL Online Gratuitamente
Formatador e validador de SQL gratuito. Formata automaticamente SQL com recuo e capitalização adequados. Verifique erros de sintaxe instantaneamente. Funciona com MySQL, PostgreSQL, SQL Server, Oracle.
Formatador e Validador de SQL
Formate e valide consultas SQL com recuo automático, capitalização de palavras-chave e detecção de erros de sintaxe.
Documentação
Por Que a Formatação SQL Importa
Já herdou um projeto de banco de dados onde o SQL parece que foi digitado de olhos vendados? Você não está sozinho. SQL mal formatado é uma das fontes mais comuns de bugs e perda de tempo no desenvolvimento de bancos de dados.
Este formatador e validador de SQL ajuda você a limpar consultas confusas automaticamente. Cole seu SQL, e ele aplica instantaneamente o recuo adequado, capitaliza palavras-chave e verifica erros de sintaxe—tudo no seu navegador sem enviar dados para qualquer servidor. O que normalmente leva 10-15 minutos de formatação manual acontece em segundos.
Na minha experiência trabalhando com equipes de banco de dados, o maior economizador de tempo não é apenas a formatação—é identificar erros antes que cheguem à produção. Um parêntese mal colocado ou uma aspas não fechada pode desperdiçar horas de depuração. Esta ferramenta identifica esses problemas imediatamente, antes de executar qualquer coisa no seu banco de dados.
Como Usar o Formatador SQL
A interface é intencionalmente minimalista—basta colar e pronto:
- Cole seu SQL na caixa de entrada (ou digite diretamente se estiver criando do zero)
- Veja a formatação acontecer automaticamente conforme você digita—sem botões para clicar, sem configurações para ajustar
- Revise erros de validação caso apareçam abaixo da saída formatada
- Copie o SQL formatado com um único clique para usar em seu IDE, documentação ou ferramenta de banco de dados
Funciona em qualquer dispositivo com um navegador. A formatação acontece completamente no lado do cliente, então suas consultas nunca saem da sua máquina—importante ao trabalhar com estruturas de banco de dados de produção ou esquemas sensíveis.
O que o Formatador SQL Faz
Capitalização de Palavras-Chave
Todas as palavras-chave SQL são automaticamente capitalizadas—SELECT, FROM, WHERE, JOIN, e assim por diante. Isso segue a convenção usada pela maioria das equipes de banco de dados e torna as palavras-chave visualmente distintas dos nomes de suas tabelas e colunas. Ao examinar uma consulta complexa, essa separação visual ajuda a identificar a estrutura da consulta rapidamente.
Identação Inteligente
O formatador estrutura seu SQL com base na hierarquia lógica, em vez de apenas adicionar quebras de linha aleatórias. Cláusulas principais como SELECT e FROM começam na margem esquerda. Cláusulas JOIN são recuadas sob FROM para mostrar que fazem parte da seleção de tabela. Subconsultas recebem níveis adicionais de identação, tornando a lógica aninhada clara.
Eis o que acontece na prática: quando você tem uma consulta com múltiplos joins e subconsultas, a identação adequada permite ver a estrutura da consulta sem ler cada palavra. Você pode identificar instantaneamente onde um join termina e outro começa, ou onde uma subconsulta está sendo usada na lista SELECT.
Quebras de Linha Lógicas
Quebras de linha aparecem onde ajudam a legibilidade, não em todos os lugares. Cada cláusula principal recebe sua própria linha. Itens em listas separadas por vírgula (como nomes de colunas em SELECT) recebem sua própria linha com identação adequada. Subconsultas são visualmente separadas. Instruções CASE são quebradas em WHEN, THEN e ELSE para maior clareza.
O espaçamento segue as convenções do Guia de Estilo SQL usadas no setor, o que significa que seu SQL formatado parecerá familiar para outros desenvolvedores.
Validação de SQL: O Que É Verificado
O validador captura os erros que normalmente passam despercebidos quando você está escrevendo SQL rapidamente. Ele não substituirá o analisador de consultas do seu banco de dados, mas detecta erros comuns antes mesmo de você executar a consulta.
Erros Estruturais
Parênteses desbalanceados são surpreendentemente comuns em consultas complexas com subconsultas aninhadas. O validador conta os parênteses de abertura e fechamento para sinalizar incompatibilidades imediatamente. Já vi incidentes em produção causados por um único parêntese faltando em uma consulta de 200 linhas—isso os detecta antecipadamente.
Literais de string não fechados acontecem quando você esquece da aspa de fechamento em um valor de string. Seu banco de dados rejeitará esses imediatamente, mas detectá-los aqui economiza uma ida e volta.
Problemas de ordenação de cláusulas são sinalizados quando as cláusulas aparecem fora de sequência. Por exemplo, se você colocar HAVING antes de GROUP BY, ou WHERE após GROUP BY, o validador o alerta. Isso segue as regras de sintaxe padrão SQL definidas no padrão SQL ISO/IEC 9075.
Erros Lógicos
Cláusulas JOIN sem condições ON criam junções cruzadas acidentais, retornando muito mais linhas do que o pretendido. Um cenário comum: você está adicionando uma terceira ou quarta tabela a uma consulta e esquece da cláusula ON. Sem essa verificação, você pode não perceber até ver milhares de linhas duplicadas nos resultados.
HAVING sem GROUP BY é tecnicamente SQL inválido na maioria dos bancos de dados. A cláusula HAVING filtra resultados agrupados, então requer um GROUP BY para funcionar. O validador detecta essa incompatibilidade lógica.
Condições WHERE incompletas acontecem quando você começa a digitar uma condição mas não a termina—como WHERE status = sem nenhum valor. Esses são fáceis de passar despercebidos ao editar consultas.
O Que Não Será Detectado
Este validador foca em sintaxe e estrutura, não no esquema do banco de dados. Ele não saberá se:
- Seus nomes de tabela ou coluna existem no seu banco de dados
- Você está fazendo join em tipos de dados compatíveis
- Sua consulta terá bom desempenho ou tem problemas de otimização
- Você tem permissão para acessar as tabelas que está consultando
Pense nele como uma verificação preliminar antes de enviar a consulta para o seu banco de dados real.
Regras de Formatação Aplicadas por Esta Ferramenta
A ferramenta de formatação aplica regras consistentes baseadas nas convenções do Guia de Estilo SQL que a maioria das equipes de banco de dados segue.
Palavras-Chave em Maiúsculas
Cada palavra-chave SQL se torna maiúscula: SELECT, INSERT, UPDATE, DELETE, CREATE, ALTER, DROP. Isso inclui cláusulas (FROM, WHERE, GROUP BY, HAVING, ORDER BY), tipos de junção (JOIN, INNER JOIN, LEFT JOIN), operadores (AND, OR, NOT, IN, BETWEEN, LIKE), e funções comuns (COUNT, SUM, AVG, CASE, WHEN).
Por que maiúsculas? Cria uma distinção visual entre os elementos de linguagem SQL e os nomes específicos do seu banco de dados (tabelas, colunas, aliases). Ao examinar uma consulta, seu olho identifica imediatamente a estrutura.
Recuo de Dois Espaços por Nível
Cláusulas principais como SELECT e FROM começam na margem esquerda. Cláusulas JOIN recuam dois espaços abaixo de FROM para mostrar que fazem parte da seleção de tabelas. Subconsultas recuam mais dois espaços a cada nível de aninhamento. Isso cria uma hierarquia visual que corresponde à estrutura lógica.
Listas separadas por vírgula (nomes de colunas em SELECT, por exemplo) recebem sua própria linha com recuo consistente. Quando você tem 15 colunas na sua lista SELECT, isso facilita a varredura e localização de colunas específicas.
Condições em cláusulas WHERE são alinhadas verticalmente. Quando você tem múltiplas condições AND ou OR, o alinhamento torna a estrutura lógica imediatamente óbvia.
Antes e Depois: Veja a Diferença
Antes da Formatação:
1select u.id, u.name, o.order_date from users u join orders o on u.id = o.user_id where o.status = "completed" group by u.id order by u.name;
2Depois da Formatação:
1SELECT
2 u.id,
3 u.name,
4 o.order_date
5FROM users u
6 JOIN orders o ON u.id = o.user_id
7WHERE
8 o.status = "completed"
9GROUP BY
10 u.id
11ORDER BY
12 u.name;
13Regras de Validação: O Que É Sinalizado
O validador verifica a integridade estrutural e a consistência lógica básica. Aqui está o que ele procura:
Verificações Estruturais
Parênteses balanceados: Os parênteses de abertura e fechamento devem corresponder. Subconsultas aninhadas frequentemente têm múltiplos níveis de parênteses, e contar incorretamente é um dos erros de SQL mais comuns. O validador os conta para você.
Strings fechadas corretamente: Cada aspas de abertura (simples ou dupla) precisa de uma aspas de fechamento. Parece óbvio, mas ao escrever uma consulta complexa com múltiplos literais de string, é fácil perder um.
Ordem correta de cláusulas: SQL tem requisitos específicos de ordenação. SELECT vem antes de FROM, que vem antes de WHERE, que vem antes de GROUP BY, que vem antes de HAVING, que vem antes de ORDER BY. Colocá-los fora de sequência causa erros de sintaxe imediatos. O validador verifica essa ordenação com base no padrão SQL.
Verificações de Consistência Lógica
JOIN com condição ON: Cada JOIN precisa de uma cláusula ON ou USING para especificar como as tabelas se relacionam. Sem ela, você obtém um cross join—cada linha de uma tabela emparelhada com cada linha da outra. Isso raramente é o que você quer e geralmente indica uma cláusula ON ausente.
Condições WHERE completas: Uma cláusula WHERE precisa de predicados completos. WHERE status = sem valor é incompleto e inválido. O validador sinaliza essas condições parciais.
HAVING requer GROUP BY: A cláusula HAVING filtra resultados agrupados, então só faz sentido quando você tem um GROUP BY. Usar HAVING sem GROUP BY é um erro lógico que a maioria dos bancos de dados rejeita.
Regras de agregação GROUP BY: Quando você usa funções de agregação como COUNT() ou SUM(), qualquer coluna não agregada na sua lista SELECT deve aparecer no GROUP BY. Este é um requisito fundamental de SQL que o validador verifica.
Exemplo de Erros Comuns Detectados
Aqui está um SQL com múltiplos problemas que o validador sinalizaria:
1SELECT user_id, COUNT(*) FROM orders
2JOIN users
3WHERE status =
4GROUP BY
5HAVING count > 10;
6Problemas detectados:
JOIN userssem condiçãoON(criará um cross join)WHERE status =incompleto (sem valor de comparação)- Cláusula
GROUP BYvazia (nenhuma coluna especificada) HAVING count > 10referencia coluna não definida
Quando Usar Este Formatador SQL
Durante Revisões de Código
Já tentou revisar uma consulta SQL de 50 linhas escrita em uma única linha? É brutal. Antes de enviar consultas para revisão de código, passe-as pelo formatador. Seus revisores agradecerão, e eles realmente poderão se concentrar na lógica em vez de decifrar a estrutura.
Ao revisar pull requests com alterações de banco de dados, peça aos colaboradores para formatar seu SQL primeiro. Isso torna muito mais fácil identificar erros de lógica quando a estrutura é consistente.
Depurando Problemas em Produção
Ao solucionar uma consulta com falha em produção, formatá-la adequadamente ajuda você a ver a estrutura claramente. Já depurei inúmeras consultas onde o problema se tornou óbvio assim que o SQL foi formatado corretamente—uma condição de junção ausente, um agrupamento incorreto de cláusula WHERE, ou uma subconsulta no lugar errado.
Copie a consulta dos seus logs, cole aqui, e você verá imediatamente se há problemas estruturais.
Trabalhando com SQL Gerado
ORMs (Mapeadores Objeto-Relacional) como Hibernate, Entity Framework ou SQLAlchemy geram SQL automaticamente. Às vezes, você precisa ver que consulta eles estão realmente produzindo. O SQL gerado geralmente é uma única linha sem formatação. Esta ferramenta torna as consultas geradas por ORM legíveis para que você possa entender e otimizá-las.
Ensinando e Aprendendo SQL
Se você está aprendendo SQL ou ensinando, este formatador ajuda a entender a estrutura adequada de consultas. Quando você cola uma consulta funcional e vê como ela é formatada, aprende as convenções. Quando cola uma consulta quebrada e vê os erros de validação, entende por que não funciona.
Migrando Entre Sistemas de Banco de Dados
Diferentes bancos de dados (PostgreSQL, MySQL, SQL Server) têm dialetos SQL ligeiramente diferentes. Ao migrar consultas entre sistemas, a formatação adequada ajuda a identificar sintaxes específicas de dialeto que podem precisar de ajuste. O formatador segue convenções SQL padrão que funcionam na maioria dos principais bancos de dados.
Alternativas a Este Formatador SQL
IDEs Específicos de Banco de Dados
Ferramentas como DataGrip, SQL Server Management Studio ou MySQL Workbench possuem formatadores integrados. Eles são poderosos e se integram diretamente com suas conexões de banco de dados.
A contrapartida: eles requerem instalação e configuração. O DataGrip custa $199/ano para indivíduos. O SSMS é gratuito, mas apenas para Windows. Se você precisa de formatação rápida sem instalar nada, ou trabalha em múltiplos sistemas de banco de dados, uma ferramenta baseada em navegador é mais prática.
Extensões de Editor
Se você escreve SQL no VS Code ou Sublime Text, extensões como SQL Beautify ou SqlBeautifier trazem formatação para dentro do seu editor. Isso funciona bem quando você está escrevendo consultas e quer formatação imediata como parte do seu fluxo de trabalho.
A limitação: as extensões precisam de configuração e estão vinculadas ao seu editor específico. Ao compartilhar SQL com colegas de equipe ou publicar consultas em documentação, um formatador web padronizado garante que todos vejam a mesma formatação.
Formatadores de Linha de Comando
Ferramentas como sqlformat (Python) ou sql-formatter-cli (Node.js) podem ser integradas em pipelines de CI/CD para formatar automaticamente SQL no controle de versão. Isso garante consistência em toda a equipe.
Melhor usado para fluxos de trabalho automatizados em vez de formatação ad-hoc. Se você está apenas limpando algumas consultas ou aprendendo SQL, as ferramentas de linha de comando adicionam complexidade desnecessária.
Como a Formatação SQL se Tornou uma Prática Padrão
O SQL foi desenvolvido na IBM na década de 1970, mas as convenções de formatação surgiram muito depois. O SQL inicial era funcional, mas inconsistente — cada desenvolvedor formatava consultas de maneira diferente.
O ponto de virada ocorreu nos anos 1990, quando os bancos de dados passaram de projetos de desenvolvedor único para desenvolvimento em equipe. As organizações começaram a criar guias de estilo SQL internos para manter a consistência. Quando cinco desenvolvedores trabalhavam no mesmo banco de dados, o SQL legível se tornou essencial para a colaboração.
Os anos 2000 trouxeram ORMs que geravam SQL automaticamente. Essas ferramentas produziam SQL funcional, mas feio — tudo em uma linha, sem recuo. Isso criou uma demanda por formatadores automáticos que pudessem tornar o SQL gerado legível para humanos.
Formatadores SQL online apareceram nos anos 2010 conforme o desenvolvimento web amadurecia. Em vez de instalar ferramentas ou configurar plugins de IDE, os desenvolvedores podiam formatar SQL em um navegador. Isso democratizou o acesso à formatação adequada para todos, desde iniciantes aprendendo SQL até desenvolvedores experientes limpando consultas rápidas.
Atualmente, a formatação SQL é considerada uma prática básica, semelhante à formatação de código em outras linguagens de programação. O Guia de Estilo SQL de Simon Holywell fornece convenções amplamente adotadas, e ferramentas como esta implementam esses padrões automaticamente.
Exemplos de Código
Exemplo 1: Consulta SELECT Básica
Não Formatado:
1select id, first_name, last_name, email from customers where status = 'active' order by last_name, first_name;
2Formatado:
1SELECT
2 id,
3 first_name,
4 last_name,
5 email
6FROM
7 customers
8WHERE
9 status = 'active'
10ORDER BY
11 last_name,
12 first_name;
13Exemplo 2: Consulta JOIN
Não Formatado:
1select c.id, c.name, o.order_date, o.total_amount from customers c left join orders o on c.id = o.customer_id where o.order_date >= '2023-01-01' and o.status != 'cancelled' order by o.order_date desc;
2Formatado:
1SELECT
2 c.id,
3 c.name,
4 o.order_date,
5 o.total_amount
6FROM
7 customers c
8 LEFT JOIN orders o ON c.id = o.customer_id
9WHERE
10 o.order_date >= '2023-01-01'
11 AND o.status != 'cancelled'
12ORDER BY
13 o.order_date DESC;
14Exemplo 3: Consulta Complexa com Subconsulta
Não Formatado:
1select d.department_name, (select count(*) from employees e where e.department_id = d.id) as employee_count, (select avg(salary) from employees e where e.department_id = d.id) as avg_salary from departments d where d.active = true having employee_count > 0 order by avg_salary desc;
2Formatado:
1SELECT
2 d.department_name,
3 (
4 SELECT
5 COUNT(*)
6 FROM
7 employees e
8 WHERE
9 e.department_id = d.id
10 ) AS employee_count,
11 (
12 SELECT
13 AVG(salary)
14 FROM
15 employees e
16 WHERE
17 e.department_id = d.id
18 ) AS avg_salary
19FROM
20 departments d
21WHERE
22 d.active = TRUE
23HAVING
24 employee_count > 0
25ORDER BY
26 avg_salary DESC;
27Formatação Programática de SQL
Aqui estão exemplos de como implementar formatação de SQL em várias linguagens de programação:
1// Exemplo de formatação de SQL em JavaScript usando a biblioteca sql-formatter
2const sqlFormatter = require('sql-formatter');
3
4function formatSQL(sql) {
5 return sqlFormatter.format(sql, {
6 language: 'sql',
7 uppercase: true,
8 linesBetweenQueries: 2,
9 indentStyle: 'standard'
10 });
11}
12
13const rawSQL = "select id, name from users where status='active'";
14const formattedSQL = formatSQL(rawSQL);
15console.log(formattedSQL);
161# Exemplo de formatação de SQL em Python usando sqlparse
2import sqlparse
3
4def format_sql(sql):
5 return sqlparse.format(
6 sql,
7 reindent=True,
8 keyword_case='upper',
9 identifier_case='lower',
10 indent_width=2
11 )
12
13raw_sql = "select id, name from users where status='active'"
14formatted_sql = format_sql(raw_sql)
15print(formatted_sql)
161// Exemplo de formatação de SQL em Java usando JSqlParser
2import net.sf.jsqlparser.parser.CCJSqlParserUtil;
3import net.sf.jsqlparser.statement.Statement;
4
5public class SQLFormatter {
6 public static String formatSQL(String sql) throws Exception {
7 Statement statement = CCJSqlParserUtil.parse(sql);
8 return statement.toString()
9 .replaceAll("(?i)SELECT", "\nSELECT")
10 .replaceAll("(?i)FROM", "\nFROM")
11 .replaceAll("(?i)WHERE", "\nWHERE")
12 .replaceAll("(?i)ORDER BY", "\nORDER BY");
13 }
14
15 public static void main(String[] args) throws Exception {
16 String rawSQL = "select id, name from users where status='active'";
17 String formattedSQL = formatSQL(rawSQL);
18 System.out.println(formattedSQL);
19 }
20}
211<?php
2// Exemplo de formatação de SQL em PHP
3function formatSQL($sql) {
4 // Substituir palavras-chave por versões em maiúsculas
5 $keywords = ['SELECT', 'FROM', 'WHERE', 'JOIN', 'LEFT JOIN', 'RIGHT JOIN',
6 'INNER JOIN', 'GROUP BY', 'ORDER BY', 'HAVING', 'LIMIT'];
7
8 $formattedSQL = $sql;
9 foreach ($keywords as $keyword) {
10 $formattedSQL = preg_replace('/\b' . preg_quote($keyword, '/') . '\b/i', "\n$keyword", $formattedSQL);
11 }
12
13 // Adicionar indentação
14 $lines = explode("\n", $formattedSQL);
15 $result = '';
16 $indentLevel = 0;
17
18 foreach ($lines as $line) {
19 $trimmedLine = trim($line);
20 if (!empty($trimmedLine)) {
21 $result .= str_repeat(" ", $indentLevel) . $trimmedLine . "\n";
22 }
23 }
24
25 return $result;
26}
27
28$rawSQL = "select id, name from users where status='active'";
29$formattedSQL = formatSQL($rawSQL);
30echo $formattedSQL;
31?>
32Perguntas Frequentes
Este formatador SQL funciona com PostgreSQL, MySQL e SQL Server?
Sim, ele lida com sintaxe SQL padrão comum entre os principais bancos de dados—PostgreSQL, MySQL, SQL Server (T-SQL), Oracle, SQLite e MariaDB. O formatador foca no SQL básico que funciona em todos os lugares: SELECT, JOIN, WHERE, GROUP BY, e assim por diante.
Recursos específicos de banco de dados podem não ser formatados perfeitamente. Por exemplo, a sintaxe de array do PostgreSQL ou funções proprietárias do SQL Server podem não receber tratamento especial de formatação, mas também não quebrarão o formatador. A consulta ainda será mais legível do que era antes.
Meu código SQL é enviado para um servidor?
Não. Tudo acontece no seu navegador. Cole seu SQL, e ele será formatado localmente sem nenhuma solicitação de rede. Suas consultas nunca saem da sua máquina.
Isso é importante quando você está trabalhando com esquemas de banco de dados de produção ou lógica de negócios proprietária. Não há risco de informações sensíveis serem registradas ou armazenadas no servidor de outra pessoa.
O validador consegue detectar todos os erros de SQL?
Nem de perto. Ele detecta problemas estruturais e de sintaxe—parênteses ausentes, aspas não fechadas, cláusulas na ordem errada. Só isso.
Ele não saberá se seus nomes de tabela estão errados, se os tipos de dados são incompatíveis ou se sua consulta levará 10 minutos para ser executada. Para isso, você precisa do seu banco de dados real. Pense neste validador como um corretor ortográfico para SQL, não como um analisador de consultas completo.
Por que formatar SQL se meu banco de dados o executa independentemente?
Bancos de dados não se importam com formatação—eles analisam a consulta independentemente. Mas os humanos se importam. Quando você precisa depurar uma consulta com falha, modificar uma existente ou revisar o SQL de outra pessoa, a formatação adequada faz a diferença entre entender em 30 segundos ou 30 minutos.
SQL formatado também ajuda a identificar erros de lógica. Quando a estrutura está clara, você pode ver se juntou tabelas incorretamente ou colocou condições no lugar errado.
Posso personalizar o recuo ou o estilo das palavras-chave?
Atualmente, não. O formatador usa convenções padrão: palavras-chave em maiúsculas, recuo de dois espaços, cláusulas em linhas separadas. Estes seguem o Guia de Estilo SQL que a maioria das equipes usa.
Se você precisar de formatação personalizada (largura de recuo diferente, palavras-chave em minúsculas), precisará de uma ferramenta de linha de comando configurável como sqlformat ou um IDE com configurações de formatação.
Isso funcionará com procedimentos armazenados de 1000 linhas?
Ele formatará consultas grandes, embora procedimentos armazenados muito complexos (1000+ linhas) possam levar alguns segundos para processar. O formatador lida com o SQL que você cola, independentemente do comprimento.
Para procedimentos armazenados massivos, você pode querer dividi-los em partes menores ou usar um IDE específico de banco de dados que seja otimizado para arquivos grandes.
A formatação altera como minha consulta é executada?
Não. A formatação apenas adiciona espaços em branco e altera a capitalização. Seu banco de dados ignora ambos. A consulta formatada retorna exatamente os mesmos resultados e é executada com o mesmo desempenho da versão não formatada.
A única exceção: se o validador encontrar erros de sintaxe reais (parênteses ausentes, etc.), corrigir esses erros mudará o comportamento—mas apenas de "não executa" para "executa corretamente".
Qual padrão SQL este segue?
O formatador segue convenções SQL-92 com extensões para recursos comuns em SQL:1999 e padrões posteriores. Isso cobre o SQL que a maioria dos desenvolvedores escreve diariamente—consultas SELECT, junções, subconsultas, instruções CASE, funções de janela.
Recursos SQL muito novos de SQL:2016 ou SQL:2019 podem não ser reconhecidos, mas não quebrarão o formatador. Você simplesmente receberá formatação básica em vez de tratamento especializado.
Posso usar isso para Oracle PL/SQL ou SQL Server T-SQL?
Para consultas básicas, sim. Para código procedural (blocos PL/SQL, procedimentos armazenados T-SQL com fluxo de controle), a formatação será limitada. A ferramenta foca em instruções SELECT, INSERT, UPDATE, DELETE e suas cláusulas.
Se você estiver trabalhando intensamente com código procedural específico de banco de dados, o IDE nativo do seu banco de dados (SQL Developer para Oracle, SSMS para SQL Server) fornecerá uma formatação melhor que entende a sintaxe completa.
Referências e Leituras Adicionais
- Guia de Estilo SQL por Simon Holywell - O padrão de fato para convenções de formatação SQL usadas por equipes de desenvolvimento
- Padrão SQL ISO/IEC 9075 - A especificação oficial do padrão internacional SQL
- Documentação de Sintaxe SQL do PostgreSQL - Referência abrangente de sintaxe SQL do PostgreSQL
- Referência Microsoft T-SQL - Documentação oficial para o dialeto T-SQL do SQL Server
- Manual de Referência MySQL - Referência completa de declarações SQL do MySQL
Comece a Formatar Seu SQL
SQL legível torna a depuração mais rápida, revisões de código mais fáceis e a colaboração mais suave. Cole sua consulta acima para vê-la formatada de acordo com convenções padrão da indústria—sem instalação, sem configuração, sem dados saindo do seu navegador.