我听到了关于这方面的混合信息，希望得到权威或专家的意见。

如果我有多个LEFT OUTER JOINs ，每个都依赖于最后一个，嵌套它们更好吗？

对于一个人为的例子，JOINtoMyParent取决于JOINto MyChild：http : //sqlfiddle.com/#!3/31022/5

SELECT
    {columns}
FROM
    MyGrandChild AS gc
LEFT OUTER JOIN
    MyChild AS c
        ON c.[Id] = gc.[ParentId]
LEFT OUTER JOIN
    MyParent AS p
        ON p.[id] = c.[ParentId]

与http://sqlfiddle.com/#!3/31022/7相比

SELECT
    {columns}
FROM
    MyGrandChild AS gc
LEFT OUTER JOIN
    (
    MyChild AS c            
    LEFT OUTER JOIN
        MyParent AS p
            ON p.[id] = c.[ParentId]
    )
    ON c.[Id] = gc.[ParentId]

如上所示，这些在 SS2k8 中产生不同的查询计划

环境

在数据仓库中，我将一个事实表连接到 20 个维度。事实表有 3200 万行和 30 列。这是一个临时登台表，因此我不必处理其他用户读取或写入该表。我从基表中选择 10 列，从相应维度中选择 20 列。维度表很小（在 3 到 15.000 行之间）。连接的字段是整数和 nvarchars。我使用 SELECT ... INTO 语句。表上没有索引。

此查询的执行速度太慢而无用。

试用的解决方案

由于查询处理时间太长，我尝试了以下解决方案：

1. 将 20 个连接拆分为 5 个表上的 4 个连接。但是查询性能仍然很低。
2. 将索引放在外键列上。时间没有明显减少。
3. 确保连接条件的字段是整数。我注意到性能提高了 25%。不完全是我正在寻找的。
4. 使用 insert into 语句而不是 select into。尽管数据库处于简单恢复模式，但由于日志文件增长而导致性能下降。

这些发现使我将实际执行计划包括在内，该计划表明 89% 的成本在于表插入。其他成本是 8% 的事实表表扫描和 2% 的内连接哈希匹配。

问题

1. 表插入慢的可能原因是什么？
2. 在没有执行计划的情况下，有什么方法可以识别这个瓶颈？
3. 我可以采取哪些措施来降低表插入的成本？

免责声明：请原谅我对数据库内部知识的缺乏。它是这样的：

我们运行一个应用程序（不是我们编写的），它在数据库的定期清理作业中存在很大的性能问题。查询如下所示：

delete from VARIABLE_SUBSTITUTION where BUILDRESULTSUMMARY_ID in (
       select BUILDRESULTSUMMARY_ID from BUILDRESULTSUMMARY
       where BUILDRESULTSUMMARY.BUILD_KEY = "BAM-1");

直截了当、易于阅读和标准 SQL。但不幸的是非常慢。解释查询显示VARIABLE_SUBSTITUTION.BUILDRESULTSUMMARY_ID未使用现有索引：

mysql> explain delete from VARIABLE_SUBSTITUTION where BUILDRESULTSUMMARY_ID in (
    ->        select BUILDRESULTSUMMARY_ID from BUILDRESULTSUMMARY
    ->        where BUILDRESULTSUMMARY.BUILD_KEY = "BAM-1");
| id | select_type        | table                 | type            | possible_keys                    | key     | key_len | ref  | rows    | Extra       |
+----+--------------------+-----------------------+-----------------+----------------------------------+---------+---------+------+---------+-------------+
|  1 | PRIMARY            | VARIABLE_SUBSTITUTION | ALL             | NULL                             | NULL    | NULL    | NULL | 7300039 …

我有一张订单表

   Column   |            Type             |                      Modifiers                      
------------+-----------------------------+-----------------------------------------------------
 id         | integer                     | not null default nextval('orders_id_seq'::regclass)
 client_id  | integer                     | not null
 start_date | date                        | not null
 end_date   | date                        | 
 order_type | character varying           | not null

数据具有针对 client_id 的非重叠常规订单，并且偶尔会出现临时订单，当它们具有匹配的 client_id 时，会覆盖其 start_date 的常规订单。存在应用程序级别的限制，以防止相同类型的订单重叠。

 id | client_id | start_date |  end_date  | order_type 
----+-----------+------------+------------+------------
 17 |        11 | 2014-02-05 |            | standing
 18 |        15 | 2014-07-16 | 2015-07-19 | standing
 19 |        16 | 2015-04-01 |            | standing …

PostgreSQL 9.2

我试图了解Hash Semi Join和 just之间的区别Hash Join。

这里有两个查询：

一世

EXPLAIN ANALYZE SELECT * FROM orders WHERE customerid IN (SELECT
customerid FROM customers WHERE state='MD');

Hash Semi Join  (cost=740.34..994.61 rows=249 width=30) (actual time=2.684..4.520 rows=120 loops=1)
  Hash Cond: (orders.customerid = customers.customerid)
  ->  Seq Scan on orders  (cost=0.00..220.00 rows=12000 width=30) (actual time=0.004..0.743 rows=12000 loops=1)
  ->  Hash  (cost=738.00..738.00 rows=187 width=4) (actual time=2.664..2.664 rows=187 loops=1)
        Buckets: 1024  Batches: 1  Memory Usage: 7kB
        ->  Seq Scan on customers  (cost=0.00..738.00 rows=187 width=4) (actual …

我似乎无法写一个 SQL查询来计算表列和一组给定输入值之间的叉积。

类似的东西：

WITH {1,2} as Input
Select *
From mTable.column, Input

随着mTable.column包含值3和4，它应该返回：

1,3
1,4
2,3
2,4

有没有办法实现这一目标？

我正在从连接两个表的查询中插入，然后我想要插入行中的新 ID，以及插入中不涉及的原始行中的字段。是否可以？我收到“列不存在”错误。

INSERT INTO new_table (x,y) 
select A.x,B.y 
from A 
  join B on A.w = B.z 
RETURNING id,B.z;

对new_table有唯一约束(x,y)。

在new_id和B.z需要插入到第二个表。

这是面试时问我的面试问题，我无法回答。请帮忙..

连接两个表之间具有一对多关系的最有效方法是什么

我正在使用 MS Access 2013 中的食品采购/发票系统，并尝试创建一个 SQL 查询，该查询将返回每个单独食品的最新购买价格。

这是我正在使用的表的图表：

我对 SQL 的理解是非常基本的，我尝试了以下（不正确的）查询，希望它只返回每个项目的一条记录（因为DISTINCT运算符）并且它只会返回最近购买的（因为我做了ORDER BY [Invoice Date] DESC)

SELECT DISTINCT ([Food items].Item), 
    [Food items].Item, [Food purchase data].[Price per unit], [Food purchase data].[Purchase unit], Invoices.[Invoice Date]
FROM Invoices
INNER JOIN ([Food items] 
    INNER JOIN [Food purchase data] 
    ON [Food items].ID = [Food purchase data].[Food item ID]) 
ON Invoices.ID = [Food purchase data].[Invoice ID]
ORDER BY Invoices.[Invoice Date] DESC;

然而，上面的查询只是返回所有的食品购买（即 中每个记录的多条记录[Food items]），结果按日期降序排序。有人可以向我解释我对DISTINCT运营商的误解吗？也就是说，为什么它不只为 中的每个项目返回一条记录[Food items]？

更重要的是 …

像这样的查询

SELECT a.id, a.name,
       COALESCE( json_agg(b.*), '[]'::json ),
       COALESCE( json_agg(c.*), '[]'::json ),
  FROM a
  LEFT JOIN b ON a.id = b.a_id
  LEFT JOIN c ON a.id = c.a_id
 GROUP BY a.id, a.name;

执行时，c和b将彼此相乘并在 JSON 数组对象中产生重复的条目。

我尝试将查询更改为使用 2 个子查询，但出现各种错误和警告，例如“子查询必须只返回一列”等。

我也尝试使用LEFT OUTER JOIN，但我想我还没有掌握连接表的工作原理，因为它仅适用于b并且c仍然相乘并包含重复项。

编辑：DISTINCT在COALESCE函数上使用带有“无法识别 json 类型的相等运算符”的错误。

如何修复此查询并仅聚合唯一行？

编辑 2

我需要指定表b和c实际上都是VIEWs，而且它们都至少有一json_agg列，所以我不能只使用json_agg(DISTINCT b.*). 这太容易了。

编辑 3

这是一个重现问题的小片段：

--DROP TABLE …