Início / dba / Perguntas / 343949
Accepted
J. Mini
Asked: 2024-12-01 23:30:55 +0800 CST

Se LATERAL é opcional para funções com valor de tabela, então por que essa consulta gera erro sem ele?

  • 772

Configurar

CREATE TABLE persons
(
  person_id int not null,
  name TEXT 
);

INSERT INTO persons VALUES
(1, 'Adam'),
(2, 'Paul'),
(3, 'Tye'),
(4, 'Sarah');

CREATE TABLE json_to_parse
(
  person_id int not null,
  block json
);

INSERT INTO json_to_parse VALUES
  (1, '{"size": "small", "love": "x"}'),
  (2, '{"size": "medium", "love": "xx"}'),
  (3, '{"size": "big", "love": "xxx"}');

O erro

Isso funciona sem problemas

SELECT
  *
FROM
  json_to_parse
CROSS JOIN LATERAL
  json_to_record(json_to_parse.block) AS my_json(size TEXT, love TEXT)
INNER JOIN
  persons
ON
  persons.person_id = json_to_parse.person_id;

mas isso não

SELECT
  *
FROM
  json_to_parse,
  json_to_record(json_to_parse.block) AS my_json(size TEXT, love TEXT)
INNER JOIN
  persons
ON
  persons.person_id = json_to_parse.person_id;

e recebo o erro "referência inválida para a entrada da cláusula FROM para a tabela "json_to_parse""

Por que esse segundo erro de consulta? Os documentos deixam bem claro que LATERALé opcional para funções com valor de tabela

As funções de tabela que aparecem em FROMtambém podem ser precedidas pela palavra-chave LATERAL, mas para funções a palavra-chave é opcional; os argumentos da função podem conter referências a colunas fornecidas pelos FROMitens precedentes em qualquer caso.

dbfiddle

postgresql

2 respostas

  1. Best Answer

    A palavra-chave LATERAL é sempre opcional para funções na FROMlista. Esse não é o problema na sua consulta.

    Ligações explícitas JOINmais fortes do que uma vírgula na FROMlista. Esse é o problema. Veja:

    Sua segunda consulta está logicamente errada. json_to_record(json_to_parse.block)binds to persons antes do resultado de both seria unido com json_to_parse, o que contradiz a referência inicial a json_to_parse.block. Daí o erro.

    Não há nada de errado com vírgulas na FROMlista em si . É apenas tipicamente mais fácil de ler e manter quando você coloca a condição de junção principal entre duas tabelas na cláusula ONor USINGde a JOINonde for viável. (E faz uma diferença funcional para OUTER JOIN!). Use a vírgula livremente quando for correto e apropriado.

    Enquanto damos opiniões, é assim que eu escreveria sua consulta:

    SELECT *  -- really all columns from all tables?
FROM   persons p
JOIN   json_to_parse jp USING (person_id)
     , json_to_record(jp.block) AS bl(size text, love text);

    Ou, se preferir soletrar:

    ...
CROSS  JOIN LATERAL json_to_record(jp.block) AS bl(size text, love text);
    • 6

  2. TL;DR; Não misture comma-joins com explícitas joins. Na verdade, não use comma-joins de forma alguma.

    Você tem uma vírgula-join na segunda consulta. Comma-joins são interpretadas como CROSS JOINentão você parece ter esperado que a consulta fosse interpretada da seguinte forma:

    FROM
  json_to_parse
CROSS JOIN
  json_to_record(json_to_parse.block) AS my_json(size TEXT, love TEXT)
INNER JOIN
  persons
ON
  persons.person_id = json_to_parse.person_id

    o que realmente funciona, pois LATERALé opcional.

    Mas como as junções por vírgula têm uma precedência menor do que a sintaxe de junção explícita, o que realmente acontece é isto:

    FROM
  json_to_parse
CROSS JOIN (
    json_to_record(json_to_parse.block) AS my_json(size TEXT, love TEXT)
    INNER JOIN
      persons
    ON
      persons.person_id = json_to_parse.person_id
)

    * Eu sei que o Postgres não suporta essa sintaxe, mas outros SGBDs suportam, e você também pode usar uma subconsulta

    Já que agora você tem um tipo de subconsulta, LATERALnão é opcional. Agora deve ser óbvio por que não funciona: os parênteses implícitos estão empurrando o INNER JOIN persons... ON...para um escopo separado.

    Dos documentos :

    Uma JOINcláusula combina dois FROMitens, que por conveniência chamaremos de “tabelas”, embora na realidade possam ser qualquer tipo de FROMitem. Use parênteses se necessário para determinar a ordem de aninhamento. Na ausência de parênteses, JOINs aninha da esquerda para a direita. Em qualquer caso, JOINvincula mais firmemente do que as vírgulas que separam FROMos itens da lista.

    Junções por vírgula são velharias. Junções explícitas foram introduzidas no SQL-92, e há muito poucos casos em que é mais legível usar junções por vírgula. Favoreça sempre a sintaxe de junção explícita .

    • 2

relate perguntas