6

我在查询中使用多个左连接时遇到了一些麻烦。有些表与左表是一对一的关系，有些是一对多的关系。查询如下所示： 

Select 
    files.filename,
    coalesce(count(distinct case
                when dm_data.weather like '%clear%' then 1
                    end),
            0) as clear,
    coalesce(count(distinct case
                when dm_data.weather like '%lightRain%' then 1
                    end),
            0) as lightRain,
    coalesce(count(case
                when kc_data.type like '%bicycle%' then 1
                    end),
            0) as bicycle,
    coalesce(count(case
                when kc_data.type like '%bus%' then 1
                    end),
            0) as bus,
    coalesce(count(case
                when kpo_data.movement like '%walking%' then 1
                    end),
            0) as walking,
    coalesce(count(case
                when kpo_data.type like '%pedestrian%' then 1
                    end),
            0) as pedestrian
from
    files
        left join
    dm_data ON dm_data.id = files.id
        left join
    kc_data ON kc_data.id = files.id
        left join
    kpo_data ON kpo_data.id = files.id
where
    files.filename in (X, Y, Z, ........)
group by files.filename;

在这里，dm_data 表与“files”表具有一对一的关系（这就是我使用“distinct”的原因），而 kc_data 和 kpo_data 数据与“files”表具有一对多的关系。（kc_data 和 kpo_data 可以针对一个 files.id 有 10 到 20 行）。此查询工作正常。

当我添加另一个左连接和另一个一对多表 pd_markings（它可以有 100 行针对一个 files.id）时，就会出现问题。

Select 
    files.filename,
    coalesce(count(distinct case
                when dm_data.weather like '%clear%' then 1
                    end),
            0) as clear,
    coalesce(count(distinct case
                when dm_data.weather like '%lightRain%' then 1
                    end),
            0) as lightRain,
    coalesce(count(case
                when kc_data.type like '%bicycle%' then 1
                    end),
            0) as bicycle,
    coalesce(count(case
                when kc_data.type like '%bus%' then 1
                    end),
            0) as bus,
    coalesce(count(case
                when kpo_data.movement like '%walking%' then 1
                    end),
            0) as walking,
    coalesce(count(case
                when kpo_data.type like '%pedestrian%' then 1
                    end),
            0) as pedestrian,
    **coalesce(count(case
                when pd_markings.movement like '%walking%' then 1
                    end),
            0) as walking**
from
    files
        left join
    dm_data ON dm_data.id = files.id
        left join
    kc_data ON kc_data.id = files.id
        left join
    kpo_data ON kpo_data.id = files.id
        left join
    **kpo_data ON pd_markings.id = files.id**
where
    files.filename in (X, Y, Z, ........)
group by files.filename;

现在所有的值都变成了彼此的倍数。有任何想法吗？？？

请注意，前两列返回 1 或 0 值。这实际上是期望的结果，因为一对一的关系表对于任何 files.id 只有 1 或 0 行，所以如果我不使用“Distinct”，那么结果值是错误的（我猜是因为其他针对同一个 file.id 返回超过一行的表）不，不幸的是，我的表没有自己的唯一 ID 列，除了“文件”表。

4

2 回答 2

7

您需要展平查询结果，以获得正确的计数。

您说您的文件表与其他表之间存在一对多关系

如果SQL只有一个关键字LOOKUP，而不是把所有的东西都塞进JOIN关键字里，那么应该很容易推断A表和B表的关系是一对一的，使用JOIN会自动表示一对多。我跑题了。无论如何，我应该已经推断出您的文件与 dm_data 是一对多的；而且，针对 kc_data 的文件也是一对多的。LEFT JOIN是第一个表和第二个表之间的关系是一对多的另一个提示；虽然这不是确定的，一些编码人员只是用LEFT JOIN. 您的查询中的 LEFT JOIN 没有任何问题，但是如果您的查询中有多个一对多表，那肯定会失败，您的查询将产生针对其他行的重复行。

from
    files
        left join
    dm_data ON dm_data.id = files.id
        left join
    kc_data ON kc_data.id = files.id

因此，有了这些知识，您表明文件与 dm_data 是一对多的，而且与 kc_data 也是一对多的。我们可以得出结论，链接这些连接并将它们分组到一个整体查询中存在问题。

例如，如果您有三个表，即 app(files)、ios_app(dm_data)、android_app(kc_data)，这是 ios 的示例数据：

test=# select * from ios_app order by app_code, date_released;
 ios_app_id | app_code | date_released | price  
------------+----------+---------------+--------
          1 | AB       | 2010-01-01    | 1.0000
          3 | AB       | 2010-01-03    | 3.0000
          4 | AB       | 2010-01-04    | 4.0000
          2 | TR       | 2010-01-02    | 2.0000
          5 | TR       | 2010-01-05    | 5.0000
(5 rows)

这是您的 android 的数据：

test=# select * from android_app order by app_code, date_released;
.android_app_id | app_code | date_released |  price  
----------------+----------+---------------+---------
              1 | AB       | 2010-01-06    |  6.0000
              2 | AB       | 2010-01-07    |  7.0000
              7 | MK       | 2010-01-07    |  7.0000
              3 | TR       | 2010-01-08    |  8.0000
              4 | TR       | 2010-01-09    |  9.0000
              5 | TR       | 2010-01-10    | 10.0000
              6 | TR       | 2010-01-11    | 11.0000
(7 rows)

如果您仅使用此查询：

select x.app_code, 
    count(i.date_released) as ios_release_count, 
    count(a.date_released) as android_release_count
from app x
left join ios_app i on i.app_code = x.app_code
left join android_app a on a.app_code = x.app_code
group by x.app_code
order by x.app_code

输出将是错误的：

 app_code | ios_release_count | android_release_count 
----------+-------------------+-----------------------
 AB       |                 6 |                     6
 MK       |                 0 |                     1
 PM       |                 0 |                     0
 TR       |                 8 |                     8
(4 rows)

您可以将链连接视为笛卡尔积，因此如果第一个表有 3 行，第二个表有 2 行，则输出将为 6

这是可视化，看到每个 ios AB 都有 2 个重复的 android AB。有 3 个 ios AB，那么当你做 COUNT(ios_app.date_released) 时计数是多少？那将变成6；与 相同COUNT(android_app.date_released)，这也将是 6。同样，每个 ios TR 有 4 个重复的 android TR，在 ios 中有 2 个 TR，所以我们的计数是 8。

.app_code | ios_release_date | android_release_date 
----------+------------------+----------------------
 AB       | 2010-01-01       | 2010-01-06
 AB       | 2010-01-01       | 2010-01-07
 AB       | 2010-01-03       | 2010-01-06
 AB       | 2010-01-03       | 2010-01-07
 AB       | 2010-01-04       | 2010-01-06
 AB       | 2010-01-04       | 2010-01-07
 MK       |                  | 2010-01-07
 PM       |                  | 
 TR       | 2010-01-02       | 2010-01-08
 TR       | 2010-01-02       | 2010-01-09
 TR       | 2010-01-02       | 2010-01-10
 TR       | 2010-01-02       | 2010-01-11
 TR       | 2010-01-05       | 2010-01-08
 TR       | 2010-01-05       | 2010-01-09
 TR       | 2010-01-05       | 2010-01-10
 TR       | 2010-01-05       | 2010-01-11
(16 rows)

因此，您应该做的是在将每个结果加入其他表和查询之前将它们展平。

如果您的数据库能够进行 CTE，请使用。它非常整洁且非常自我记录：

with ios_app_release_count_list as
(
 select app_code, count(date_released) as ios_release_count
 from ios_app
 group by app_code
)
,android_release_count_list as
(
 select app_code, count(date_released) as android_release_count 
 from android_app 
 group by app_code  
)
select
 x.app_code, 
 coalesce(i.ios_release_count,0) as ios_release_count, 
 coalesce(a.android_release_count,0) as android_release_count
from app x
left join ios_app_release_count_list i on i.app_code = x.app_code
left join android_release_count_list a on a.app_code = x.app_code
order by x.app_code;

而如果你的数据库还没有 CTE 功能，比如 MySQL，你应该这样做：

select x.app_code, 
 coalesce(i.ios_release_count,0) as ios_release_count, 
 coalesce(a.android_release_count,0) as android_release_count
from app x
left join
(
 select app_code, count(date_released) as ios_release_count
 from ios_app
 group by app_code
) i on i.app_code = x.app_code
left join
(
 select app_code, count(date_released) as android_release_count 
 from android_app 
 group by app_code   
) a on a.app_code = x.app_code
order by x.app_code

该查询和 CTE 样式的查询将显示正确的输出：

 app_code | ios_release_count | android_release_count 
----------+-------------------+-----------------------
 AB       |                 3 |                     2
 MK       |                 0 |                     1
 PM       |                 0 |                     0
 TR       |                 2 |                     4
(4 rows)

现场测试

查询不正确：http ://www.sqlfiddle.com/#!2/9774a/2

正确查询：http ://www.sqlfiddle.com/#!2/9774a/1

于 2012-05-03T16:35:17.687 回答
0

我在这里质疑您的不同用法 - 它的编写方式将返回 1 或 0。这意味着不同的计数只会返回 0、1 或 2。

我假设您的每个表中都有唯一的 ID 列。您可以更改大小写以返回 ID 值，然后计算不同的值。如果您的联接从您的 pd_markings 表中返回多个相同的行，则 ID 上的不同计数将返回，好吧，仅返回不同的行数。

于 2012-05-03T12:52:38.573 回答