Ferramentas / Formatador de SQL

Formatador de SQL

Cole uma consulta SQL e receba o código organizado, com palavras-chave em maiúsculas e cláusulas em linhas separadas.

Processamento local: nada do que você digita sai do seu navegador.

Como usar

Cole a consulta e o resultado aparece formatado enquanto você digita. Escolha a indentação e se as palavras-chave devem ficar em maiúsculas.

O que é formatado

  • Cláusulas principais (SELECT, FROM, WHERE, GROUP BY, ORDER BY, HAVING, LIMIT) em linhas próprias.
  • JOIN e ON indentados, AND/OR quebrados em linhas.
  • Colunas do SELECT uma por linha e subconsultas entre parênteses indentadas.
  • Textos entre aspas, identificadores e comentários permanecem intactos.

É um formatador genérico: não valida a consulta nem entende todos os dialetos.

Como implementar em código

Exemplos prontos para usar no seu projeto.

// Coloca as cláusulas principais em maiúsculas e em linhas separadas
function formatarSql(sql) {
  return sql
    .replace(/\s+/g, ' ')
    .replace(/\s*\b(select|from|where|group by|order by|having|limit)\b/gi,
             (m) => '\n' + m.trim().toUpperCase())
    .trim();
}
console.log(formatarSql("select id from t where a = 1 order by id"));

Versão simplificada: não protege palavras dentro de strings. Para produção use sql-formatter.

import re

CLAUSULAS = r"\s*\b(select|from|where|group by|order by|having|limit)\b"

def formatar_sql(sql: str) -> str:
    sql = re.sub(r"\s+", " ", sql)
    sql = re.sub(CLAUSULAS, lambda m: "\n" + m.group(1).upper(), sql, flags=re.I)
    return sql.strip()

print(formatar_sql("select id from t where a = 1 order by id"))

Versão simplificada. Para produção use sqlparse (sqlparse.format(sql, reindent=True, keyword_case="upper")).

package main

import (
	"regexp"
	"strings"
)

var reClausulas = regexp.MustCompile(`(?i)\s*\b(select|from|where|group by|order by|having|limit)\b`)
var reEspacos = regexp.MustCompile(`\s+`)

func formatarSql(sql string) string {
	sql = reEspacos.ReplaceAllString(sql, " ")
	sql = reClausulas.ReplaceAllStringFunc(sql, func(m string) string {
		return "\n" + strings.ToUpper(strings.TrimSpace(m))
	})
	return strings.TrimSpace(sql)
}

Versão simplificada: não protege palavras dentro de strings.

String formatarSql(String sql) {
  final clausulas = RegExp(
      r'\s*\b(select|from|where|group by|order by|having|limit)\b',
      caseSensitive: false);
  return sql
      .replaceAll(RegExp(r'\s+'), ' ')
      .replaceAllMapped(clausulas, (m) => '\n${m[1]!.toUpperCase()}')
      .trim();
}

Versão simplificada: não protege palavras dentro de strings.

import java.util.regex.Pattern;

public class SqlFmt {
    static final Pattern CLAUSULAS = Pattern.compile(
        "\\s*\\b(select|from|where|group by|order by|having|limit)\\b",
        Pattern.CASE_INSENSITIVE);

    static String formatarSql(String sql) {
        sql = sql.replaceAll("\\s+", " ");
        return CLAUSULAS.matcher(sql)
            .replaceAll(m -> "\n" + m.group(1).toUpperCase()).trim();
    }
}

Requer Java 9+. Versão simplificada: não protege palavras dentro de strings.

<?php
function formatarSql(string $sql): string {
    $sql = preg_replace('/\s+/', ' ', $sql);
    $sql = preg_replace_callback(
        '/\s*\b(select|from|where|group by|order by|having|limit)\b/i',
        fn($m) => "\n" . strtoupper($m[1]),
        $sql
    );
    return trim($sql);
}

Versão simplificada: não protege palavras dentro de strings. Alternativa: doctrine/sql-formatter.

using System.Text.RegularExpressions;

static string FormatarSql(string sql)
{
    sql = Regex.Replace(sql, @"\s+", " ");
    sql = Regex.Replace(sql,
        @"\s*\b(select|from|where|group by|order by|having|limit)\b",
        m => "\n" + m.Value.Trim().ToUpper(),
        RegexOptions.IgnoreCase);
    return sql.Trim();
}

Versão simplificada: não protege palavras dentro de strings.

Perguntas frequentes

O formatador altera o resultado da consulta?

Não. Mudamos apenas espaços, quebras de linha e a caixa das palavras-chave. Textos entre aspas e comentários ficam como estavam.

Funciona com MySQL, PostgreSQL e SQL Server?

Funciona com o SQL padrão usado por todos eles. Recursos muito específicos de cada dialeto podem ficar com formatação simples.

Meu SQL é enviado para algum servidor?

Não. A formatação acontece no seu navegador.

Veja também

Precisa de um sistema ou app sob medida?

A VcInova desenvolve software, aplicativos e integrações para empresas de todo o Brasil.

Fale com a VcInova