Question

有人可以解释一下这个区别：

    applicationVariants.all { variant ->
        variant.outputs.all { output ->
            outputFileName = new File(
                    "release_build", // here you can change the name
                    output.outputFile.name)
        }
}

而且：

SELECT * FROM A
INNER JOIN B ON ...
INNER JOIN C ON ...

示例：

SELECT * FROM A
INNER JOIN B INNER JOIN C ON ... ON ...

Answer 1

使用INNER JOIN并不存在差异。差异在于OUTER JOIN进入游戏时。

我们假设你有这些表格：

表A：

ID          BID
----------- -----------
1           1
2           NULL
3           2

表B：

ID          BVAL
----------- ----------
1           X
2           Y

表C：

BID         CVAL
----------- ----------
1           ABC

如果您再查询

SELECT * FROM A
   LEFT OUTER JOIN B
      ON B.ID = A.ID
   INNER JOIN C
      ON C.BID = B.ID

你会得到一个记录：

ID          BID         ID          BVAL       BID         CVAL
----------- ----------- ----------- ---------- ----------- ----------
1           1           1           X          1           ABC

但是这个查询

SELECT * FROM A
   LEFT OUTER JOIN B
      INNER JOIN C
         ON C.BID = B.ID
      ON B.ID = A.ID

会给出三个：

ID          BID         ID          BVAL       BID         CVAL
----------- ----------- ----------- ---------- ----------- ----------
1           1           1           X          1           ABC
2           NULL        NULL        NULL       NULL        NULL
3           2           NULL        NULL       NULL        NULL

正如您所看到的，嵌套的JOIN在另一个之前进行了评估。

Answer 2

JOIN并非始终位于表之间。它们经常在以前的JOIN s 结果之间。因此，加入订单非常重要。

在第一个查询中，我们将表A连接到表B。在第一个ON子句中，我们只能引用表A或B。让我们说这会产生一个我们非正式地称之为A_B的结果。然后，第二次加入发生在A_B和C之间。第二个ON子句可能包含对A，B或C的引用，但请注意A或B引用实际上是引用到第一个A_B生成的JOIN结果。

在第二个查询中，我们首先将表B加入表C。在第一个ON子句（与第二个 JOIN子句相关）中，我们可能只引用表B或C。我们会将结果称为B_C。第二个ON子句然后完成第一个 JOIN，将A加入B_C，第二个ON子句可能再次引用{ {1}}，A或B，但这次C或B是对C的引用。¹

可视化B_C和JOIN子句匹配方式的最清晰方法是将ON与开括号和JOIN的方式相同，就像它是一个右括号。然后匹配括号表示哪个ON与ON匹配，并且嵌套告诉您 order 连接发生在哪里。

¹虽然这些差异在仅使用JOIN联接时以及每个INNER时通常并不重要，但实际上只引用了两个表中的一个。

Answer 3

结果将是相同的如果只使用INNER JOIN。

但第一种方式是采用标准和正确的方法它更具可读性，更少混淆。

它如何影响解释计划？这取决于数据库。
SQL是一种声明性语言。我们在哪里问我们想要什么，而不是如何把它拉出来。
（至少如果一个人不使用T-SQL hints）

这是一个示例T-SQL，用于演示结果是否相同。

declare @A table (ID_A int, FK_B int);
declare @B table (ID_B int, FK_C int);
declare @C table (ID_C int);
insert into @A (ID_A, FK_B) values (11,21),(12,22),(13,null);
insert into @B (ID_B, FK_C) values (21,null),(22,32),(23,33);
insert into @C (ID_C) values (31),(32),(33);

-- A to B, B to C
select a.ID_A, b.ID_B, c.ID_C
from @A a
inner join @B b on (b.ID_B = a.FK_B)
inner join @C c on (c.ID_C = b.FK_C);

-- (B to C) to A
select a.ID_A, b.ID_B, c.ID_C
from @A a
inner join @B b inner join @C c on (c.ID_C = b.FK_C) 
on (b.ID_B = a.FK_B);

两者都导致：

ID_A ID_B ID_C
---- ---- ----
12   22   32

INNER JOIN的标准INNER JOIN和INNER JOIN之间的区别是什么？

3 个答案: