Cláusula JOIN ON estranha no T-SQL

GLFiscalYearPeriods é uma tabela e esta vírgula implica uma junção cruzada. (Produto cartesiano)

Parece que a consulta retorna alguns valores para cada ano fiscal.

Dadas essas tabelas:

create table a (id int, foo int);
create table c (id int);
insert into a values (1,1),(2,2),(3,3);
insert into c values (10),(20);

select * from a, c;

select * from a cross join c;

identificação | foo | Eu iria
-: | --: | -:
 1 | 1 | 10
 2 | 2 | 10
 3 | 3 | 10
 1 | 1 | 20
 2 | 2 | 20
 3 | 3 | 20

db<>fique aqui

Só mais um exemplo:

create table a (id int, foo int);
create table b (id int, foo int);
create table c (id int);
create table d (id int);
insert into a values (1,1),(2,2),(3,3);
insert into b values (1,1),(2,2),(3,3);
insert into c values (10),(20);
insert into d values (1),(2);

select * from a join b on a.id = b.id       ,     c join d on d.id = a.id ;

Msg 4104 Nível 16 Estado 1 Linha 1
O identificador de várias partes "a.id" não pôde ser vinculado.

mas se você fizer a junção cruzada:

select * from a join b on a.id = b.id  cross join  c join d on d.id = a.id ;

identificação | foo | identificação | foo | identificação | Eu iria
-: | --: | -: | --: | -: | -:
 1 | 1 | 1 | 1 | 10 | 1
 1 | 1 | 1 | 1 | 20 | 1
 2 | 2 | 2 | 2 | 10 | 2
 2 | 2 | 2 | 2 | 20 | 2

db<>fique aqui

Você conhece essa abordagem de junção?

SELECT *
FROM table1, table2
WHERE table1.pk = table2.fk

Se você deixar a cláusula WHERE fora dessa consulta, obterá o produto cartesiano, que é o mesmo que um CROSS JOIN:

SELECT *
FROM table1
CROSS JOIN table2

Sua consulta parece combinar essa abordagem de junção com a sintaxe INNER JOIN. É logicamente igual a isto:

SELECT *     
FROM GLAccounts
INNER JOIN GLCharts
    ON glaGLChartID = glcGLChartID
LEFT JOIN GLCategories
    ON glcGLCategoryID = gltGLCategoryID
INNER JOIN GLDepartments
    ON glaGLDepartmentID = gldGLDepartmentID
INNER JOIN GLDivisions
    ON glaGLDivisionID = glvGLDivisionID
CROSS JOIN GLFiscalYearPeriods                
INNER JOIN GLFiscalYears
    ON glfGLFiscalYearID = glzGLFiscalYearID

Aqui está um exemplo:

DECLARE @t1 TABLE (t1id INT)
DECLARE @t2 TABLE (t2id INT, t1id INT)
DECLARE @t3 TABLE (t3id INT)

INSERT INTO @t1 VALUES (1), (2)
INSERT INTO @t2 VALUES (1, 1), (2, 1), (3, 2), (4, 2)
INSERT INTO @t3 VALUES (5), (6)

SELECT * 
FROM @t1 
INNER JOIN @t2 ON [@t2].t1id = [@t1].t1id
, @t3   

Devoluções:

t1id    t2id    t1id    t3id
1       1       1       5
1       1       1       6
1       2       1       5
1       2       1       6
2       3       2       5
2       3       2       6
2       4       2       5
2       4       2       6

A sintaxe de vírgula para a junção é uma sintaxe mais antiga no padrão ANSI SQL (SQL-89 eu acho, mas posso estar errado) que foi atualizado posteriormente (SQL-92 eu acho, novamente pode estar errado) para usar uma sintaxe mais explícita que também ficou mais legível. É conhecido como 'notação de junção implícita', em contraste com as cláusulas JOIN reais que são 'notação de junção explícita'.

A sintaxe de vírgula implica uma junção implícita em vez de uma junção explícita, por exemplo, em seu código de exemplo sem uma cláusula WHERE, a sintaxe de vírgula implica um CROSS JOIN para produzir um produto cartesiano de todas as linhas em ambos os lados do JOIN.

No padrão SQL preferencial, você usaria uma cláusula CROSS JOIN de notação explícita para produzir o JOIN.

Links:

Junte-se (SQL)

Como faço um JOIN na sintaxe ANSI SQL 89?