Versões do padrão SQL e dialetos SQL

Lição 1.8 · Tempo de leitura: ~8 min

O padrão SQL é a especificação internacional da linguagem SQL, publicada pela ISO e pela ANSI como ISO/IEC 9075. A primeira versão saiu em 1986, e a mais recente é o SQL:2023. Nesta lição você vai ver o que cada versão do padrão adicionou, da sintaxe explícita de JOIN ao JSON e às consultas de grafos, e por que cada banco de dados fala o seu próprio dialeto SQL. No fim, você saberá quais partes de uma consulta são portáveis e quais dependem do banco.

Na lição anterior você viu o que é SQL e como se monta uma consulta básica. O SQL não pertence a um único fornecedor: o seu núcleo é definido por um padrão, e cada banco de dados implementa esse padrão à sua maneira.

Isso explica uma surpresa comum: uma consulta que funciona no PostgreSQL pode falhar no SQL Server ou no MySQL. Conhecer o padrão ajuda a escrever consultas que passam de um banco para outro com menos mudanças.

O que é o padrão SQL?

O SQL foi criado na IBM nos anos 1970. Em meados dos anos 1980 vários fornecedores tinham as suas próprias versões da linguagem, então a ANSI e depois a ISO publicaram uma especificação comum: o SQL-86. Desde então o padrão é revisado regularmente pelo comitê ISO/IEC JTC 1/SC 32.

O padrão é grande e se divide em várias partes. A Parte 2, SQL/Foundation, define o núcleo da linguagem: tabelas, consultas, alteração de dados, transações. Outras partes tratam de XML, dados externos, arrays multidimensionais e, desde 2023, grafos de propriedades.

Vale saber alguns fatos:

• O padrão define um conjunto obrigatório de recursos chamado Core SQL; todo o resto é opcional.
• Nenhum banco de dados implementa o padrão inteiro, e cada um acrescenta as suas próprias extensões.
• Os documentos do padrão são pagos, por isso na prática se aprende SQL pela documentação dos bancos.

Versões do padrão SQL e o que elas adicionaram

Cada versão manteve as anteriores e acrescentou novos recursos. A tabela mostra as mudanças que você vai encontrar neste curso:

O SQL-92 ainda é uma referência importante: ele definiu a sintaxe que quase todo banco relacional suporta. Mas o padrão moderno é muito mais rico, e a maior parte dos recursos do SQL analítico surgiu depois de 1999.

O que há de novo no SQL:2023: JSON e consultas de grafos

O SQL:2023 permite que um mesmo banco trabalhe com dados relacionais, documentos e grafos na mesma consulta.

O tipo de dados JSON

O SQL:2016 adicionou funções que leem JSON guardado como texto. O SQL:2023 traz um tipo JSON de verdade: o banco verifica se a coluna contém JSON válido e pode guardá-lo numa forma binária eficiente. MySQL, MariaDB e PostgreSQL (jsonb) tinham os seus próprios tipos JSON antes do padrão; o Oracle, a partir da versão 21c, segue o tipo padrão.

Consultas de grafos de propriedades (SQL/PGQ)

Um grafo de propriedades é um conjunto de vértices e arestas, por exemplo atores e filmes ligados por "atuou em". Bancos de grafos como o Neo4j consultam esses dados com linguagens próprias. O SQL/PGQ, a nova Parte 16 do padrão, permite definir um grafo sobre tabelas comuns e consultá-lo em SQL.

No Sakila, actor e film viram vértices, e film_actor vira a aresta entre eles:

CREATE PROPERTY GRAPH film_graph
  VERTEX TABLES (actor KEY (actor_id), film KEY (film_id))
  EDGE TABLES (
    film_actor KEY (actor_id, film_id)
      SOURCE KEY (actor_id) REFERENCES actor (actor_id)
      DESTINATION KEY (film_id) REFERENCES film (film_id)
      LABEL acted_in
  );

Observação: o grafo não copia dados; ele descreve como as tabelas existentes se ligam.

O operador GRAPH_TABLE encontra caminhos por um padrão. Esta consulta retorna os atores que atuaram num filme junto com Penelope Guiness:

SELECT DISTINCT partner
FROM GRAPH_TABLE (film_graph
  MATCH (a IS actor) -[IS acted_in]-> (f IS film) <-[IS acted_in]- (b IS actor)
  WHERE a.first_name = 'PENELOPE'
    AND a.last_name = 'GUINESS'
    AND b.actor_id <> a.actor_id
  COLUMNS (b.first_name || ' ' || b.last_name AS partner)
);

Resultado: uma linha por colega de elenco. O padrão se lê como o desenho: ator → filme ← ator.

O mesmo resultado pode ser obtido com duas junções de film_actor, que você vai aprender no módulo de JOINs. Para caminhos mais longos, como "atores ligados por dois filmes", a sintaxe de grafos fica bem mais curta. Hoje o SQL/PGQ é suportado pelo Oracle Database 23ai; o suporte no PostgreSQL está em desenvolvimento.

Dialetos SQL: como os bancos diferem do padrão

Um dialeto SQL é a versão do SQL implementada por um banco de dados específico: os recursos do padrão que ele suporta mais as suas próprias extensões. Consultas básicas parecem iguais em todo lugar, mas os detalhes mudam. Por exemplo, os cinco filmes mais longos em bancos diferentes:

-- Padrão (PostgreSQL, Oracle)
SELECT title, length
FROM film
ORDER BY length DESC
FETCH FIRST 5 ROWS ONLY;

-- MySQL, MariaDB, SQLite, PostgreSQL
SELECT title, length
FROM film
ORDER BY length DESC
LIMIT 5;

-- SQL Server
SELECT TOP 5 title, length
FROM film
ORDER BY length DESC;

Resultado: os mesmos cinco filmes em todos os casos. LIMIT e TOP surgiram antes do FETCH FIRST padrão e ainda são mais comuns.

Outras diferenças frequentes:

O PostgreSQL costuma ser considerado o mais próximo do padrão. O MySQL tem mais diferenças, embora as versões recentes tenham ganhado CTEs, funções de janela e outros recursos padrão.

Como escrever SQL portável

Levar um esquema para outro banco sempre dá algum trabalho, mas alguns hábitos mantêm as consultas mais perto do padrão:

• Prefira construções padrão quando o banco as suporta: CASE em vez de IF(), COALESCE em vez de IFNULL ou ISNULL, JOIN ... ON explícito.
• Use CAST(x AS type) em vez de atalhos como x::type do PostgreSQL.
• Evite nomes entre aspas: nomes em minúsculas e sem espaços não precisam de aspas em nenhum banco.
• Deixe as partes específicas de cada banco, como limite de linhas ou funções de data, em lugares bem marcados.

Neste site as mesmas tarefas podem ser resolvidas em vários bancos, então você vai ver essas diferenças na prática. O próximo módulo começa a escrever consultas com SELECT, o comando por trás de toda leitura de dados.

Principais conclusões:

• O padrão SQL é o ISO/IEC 9075; começou com o SQL-86, e a versão atual é o SQL:2023.
• O SQL-92 definiu a base comum, o SQL:1999 e o SQL:2003 trouxeram CTEs e funções de janela, o SQL:2016 trouxe funções JSON.
• O SQL:2023 adiciona o tipo JSON e as consultas de grafos de propriedades (SQL/PGQ) sobre tabelas comuns.
• Um dialeto SQL é o padrão como implementado por um banco, mais as suas extensões.
• Consultas básicas são portáveis; limite de linhas, funções de string, autoincremento e aspas são o que mais muda.

Perguntas frequentes

Qual é a versão mais recente do padrão SQL?

A versão mais recente é o SQL:2023 (ISO/IEC 9075:2023), publicado em junho de 2023. Ele adicionou o tipo de dados JSON, as consultas de grafos de propriedades (SQL/PGQ) e vários recursos menores, como GREATEST, LEAST e ANY_VALUE.

Qual é a diferença entre ANSI SQL e ISO SQL?

Hoje são o mesmo padrão. A ANSI publicou a primeira versão em 1986, a ISO a adotou em 1987, e desde então a ANSI adota o padrão ISO/IEC 9075. "ANSI SQL" é só o nome comum do SQL padrão.

Algum banco de dados suporta o padrão SQL por completo?

Não. Cada banco suporta o Core SQL e um conjunto diferente de recursos opcionais, além de acrescentar as suas próprias extensões. O PostgreSQL costuma ser considerado o mais próximo do padrão.

Ainda vale a pena aprender o SQL-92?

A sintaxe do SQL-92 é a base que funciona em quase todo banco, então é um bom começo. Mas o SQL moderno também inclui CTEs, funções de janela e JSON, e o trabalho analítico usa esses recursos todos os dias.

Perguntas de entrevista

O que é um dialeto SQL?

Um dialeto SQL é a versão do SQL implementada por um banco específico: uma parte do padrão ISO mais extensões do fornecedor. Exemplos são o T-SQL do SQL Server e os dialetos SQL do Oracle, do MySQL e do PostgreSQL. A sintaxe básica é comum; detalhes como limite de linhas, funções e tipos de dados variam.

Cite algumas diferenças entre a sintaxe do MySQL e a do SQL Server.

O MySQL limita linhas com LIMIT, o SQL Server com TOP ou OFFSET ... FETCH. O MySQL concatena strings com CONCAT, o SQL Server também com +; o MySQL põe nomes entre crases, o SQL Server entre colchetes. Chaves autoincrementais são AUTO_INCREMENT no MySQL e IDENTITY no SQL Server.

O que o SQL:2023 adicionou ao padrão?

Um tipo de dados JSON nativo e o SQL/PGQ, consultas de grafos de propriedades sobre tabelas relacionais com CREATE PROPERTY GRAPH e GRAPH_TABLE. Também trouxe recursos menores, como GREATEST, LEAST e ANY_VALUE.

Como tornar uma consulta SQL portável entre bancos de dados?

Use construções padrão: JOIN ... ON explícito, CASE, COALESCE, CAST. Evite funções específicas de um fornecedor e identificadores entre aspas, e isole as partes que precisam ser diferentes, como limite de linhas e funções de data.