在查询中使用相同的表别名两次

问题描述 投票：3回答：2

我的同事是ANSI连接语法的新手，最近编写了一个这样的查询：

SELECT count(*)
  FROM table1 t1
       JOIN table2 t2 ON
            (t1.col_a = t2.col_a)
       JOIN table3 t3 ON
            (t2.col_b = t3.col_b)
       JOIN table3 t3 ON
             (t3.col_c = t1.col_c);

请注意，table3在不同的列上连接到table1和table2，但是两个JOIN子句对table3使用相同的表别名。

查询运行，但我不确定它是否有效。这是编写此查询的有效方法吗？

我认为联接应该是这样的：

SELECT count(*)
  FROM table1 t1
       JOIN table2 t2 ON
            (t1.col_a = t2.col_a)
       JOIN table3 t3 ON
            (t2.col_b = t3.col_b AND
             t3.col_c = t1.col_c);

这两个版本功能相同吗？我确实在数据库中没有足够的数据。

谢谢。

sql oracle ansi
2个回答
4
投票

第一个查询是4个表的连接，第二个是3个表的连接。所以我不希望两个查询返回相同数量的行。

SELECT *
  FROM table1 t1
       JOIN table2 t2 ON
            (t1.col_a = t2.col_a)
       JOIN table3 t3 ON
            (t2.col_b = t3.col_b)
       JOIN table3 t3 ON
             (t3.col_c = t1.col_c);

别名t3仅用于ON子句。别名t3引用ON关键字之前的表。我通过实验发现了这一点。因此，以前的查询是等价的

SELECT *
  FROM table1 t1
       JOIN table2 t2 ON
            (t1.col_a = t2.col_a)
       JOIN table3 t3 ON
            (t2.col_b = t3.col_b)
       JOIN table3 t4 ON
             (t4.col_c = t1.col_c);

这可以在传统的连接中转换

SELECT *
  FROM table1 t1,
       table2 t2,
       table3 t3,
       table3 t4
where (t1.col_a = t2.col_a)
    and  (t2.col_b = t3.col_b)
    and (t4.col_c = t1.col_c);

第二个查询是

SELECT *
  FROM table1 t1
       JOIN table2 t2 ON
            (t1.col_a = t2.col_a)
       JOIN table3 t3 ON
            (t2.col_b = t3.col_b AND
             t3.col_c = t1.col_c);

这也可以在传统的连接中转变

SELECT *
  FROM table1 t1,
    table2 t2,
    table3 t3
where (t1.col_a = t2.col_a)
    and (t2.col_b = t3.col_b)
    AND (t3.col_c = t1.col_c);

这些查询似乎有所不同。为了证明它们的不同，我们使用以下示例：

create table table1(
    col_a number,
    col_c number
);

create table table2(
    col_a number,
    col_b number
);

create table table3(
    col_b number,
    col_c number
);

insert into table1(col_a, col_c) values(1,3);
insert into table1(col_a, col_c) values(4,3);
insert into table2(col_a, col_b) values(1,2);
insert into table2(col_a, col_b) values(4,2);
insert into table3(col_b, col_c) values(2,3);
insert into table3(col_b, col_c) values(2,5);
insert into table3(col_b, col_c) values(7,9);

commit;

我们得到以下输出

SELECT *
  FROM table1 t1
       JOIN table2 t2 ON
            (t1.col_a = t2.col_a)
       JOIN table3 t3 ON
            (t2.col_b = t3.col_b)
       JOIN table3 t3 ON
             (t3.col_c = t1.col_c)


| COL_A | COL_C | COL_A | COL_B | COL_B | COL_C | COL_B | COL_C |
|-------|-------|-------|-------|-------|-------|-------|-------|
|     1 |     3 |     1 |     2 |     2 |     3 |     2 |     3 |
|     4 |     3 |     4 |     2 |     2 |     3 |     2 |     3 |
|     1 |     3 |     1 |     2 |     2 |     5 |     2 |     3 |
|     4 |     3 |     4 |     2 |     2 |     5 |     2 |     3 |




SELECT *
  FROM table1 t1
       JOIN table2 t2 ON
            (t1.col_a = t2.col_a)
       JOIN table3 t3 ON
            (t2.col_b = t3.col_b AND
             t3.col_c = t1.col_c)

| COL_A | COL_C | COL_A | COL_B | COL_B | COL_C |
|-------|-------|-------|-------|-------|-------|
|     4 |     3 |     4 |     2 |     2 |     3 |
|     1 |     3 |     1 |     2 |     2 |     3 |

检索到的行数不同，因此count(*)不同。

别名的使用令人惊讶。至少对于我来说。

以下查询有效，因为t1中的where_clause引用了table2。

select *
from table1 t1 join table2 t1 on(1=1)
where t1.col_b<0;

以下查询有效，因为t1中的where_clause引用了table1。

select *
from table1 t1 join table2 t1 on(1=1)
where t1.col_c<0;

以下查询引发错误，因为table1和table2都包含列col_a。

select *
from table1 t1 join table2 t1 on(1=1)
where t1.col_a<0;

抛出的错误是

ORA-00918: column ambiguously defined

以下查询有效，别名t1指的是同一个where_clause中的两个不同的表。

select *
from table1 t1 join table2 t1 on(1=1)
where t1.col_b<0 and t1.col_c<0;

这些和更多的例子可以在这里找到：http://sqlfiddle.com/#!4/84feb/12

最小的反例

最小的反例是

table1
col_a  col_c
    1      2

table2
col_a  col_b
    1      3

table3
col_b  col_c
    3      5
    6      2

这里第二个查询有一个空结果集，第一个查询返回一行。可以证明，第二个查询的count(*)永远不会执行第一个查询的count(*)。

A more detailed explanation

如果我们详细分析以下语句，这种行为将变得更加清晰。

SELECT t.col_b, t.col_c
  FROM table1 t
       JOIN table2 t ON
            (t.col_b = t.col_c) ;

以下是Backus-Naur形式的此查询的简化语法，该语法源自Oracle 12.2的SQL Language Reference中的语法描述。请注意，在每个语法图下都有一个指向该图的Backus-Naur形式的链接，例如Description of the illustration select.eps。 “减少”意味着我遗漏了未使用的所有可能性，例如。 select定义为

select::=subquery [ for_update_clause ] ;

我们的查询不使用可选的for_update_clause，所以我将规则缩减为

select::=subquery

唯一的豁免是可选的where-clause。我没有删除它，因此即使我们添加了where_clause，这个简化的规则也可用于分析上述查询。

这些简化规则将仅定义所有可能的select语句的子集。

select::=subquery 
subquery::=query_block
query_block::=SELECT select_list FROM join_clause [ where_clause ]
join_clause::=table_reference  inner_cross_join_clause ...  
table_reference::=query_table_expression  t_alias query_table_expression::=table
inner_cross_join_clause::=JOIN table_reference ON condition

所以我们的select语句是query_block而join_clause是类型的

table_reference inner_cross_join_clause

其中table_reference是table1 t，inner_cross_join_clause是JOIN table2 t ON (t.col_b = t.col_c)。省略号...意味着可能有额外的inner_cross_join_clauses，但我们在这里不需要它。

在inner_cross_join_clause，别名t指的是table2。只有在不能满足这些引用的情况下，才能在外部范围内搜索别名。因此ONcondition中的所有以下表达式都是有效的：

t.col_b = t.col_c

这里t.col_b是table2.col_b因为t指的是其inner_cross_join_clause的别名，t.col_c是table1.col_c。 t的inner_cross_join_clause（参考table2）没有列col_c所以将搜索外部范围并找到适当的别名。

如果我们有条款

t.col_a = t.col_a

别名可以在这个ON-inner_cross_join_clause所属的condition中定义为别名，因此t将被解析为table2。

如果选择列表包含

t.col_c, t.col_b, t.col_a

而不是*然后join_clause将搜索别名和t.col_c将被解析为table1.col_c（table2不包含列col_c），t.col_b将被解析为table2.col_b（table1不包含col_b）但t.col_a将提出错误

ORA-00918: column ambiguously defined

因为对于select_list，所有aias定义都没有先于另一个定义。如果我们的查询也有where_clause，则别名的解析方式与在select_list中使用的方式相同。

3
投票

随着更多数据，它将产生不同的结果。您的同事查询与此相同。

select * from table3 where t3.col_b = 'XX'
union
select * from table3 where t3.col_c = 'YY'

要么

select * from table3 where t3.col_b = 'XX' or t3.col_c = 'YY'

而你的查询是这样的。

select * from table3 where t3.col_b ='XX' and t3.col_c='YY'

第一个是数据，其中（xx或yy），而第二个是数据，其中（xx和yy）

最新问题
© www.soinside.com 2019 - 2024. All rights reserved.