7 
table products
id primary_key

table transactions
product_id foreign_key references products

下面的 SQL 查询非常慢：

SELECT products.* 
FROM   products 
       LEFT JOIN transactions 
              ON ( products.id = transactions.product_id ) 
WHERE  transactions.product_id IS NULL;

在 100 亿条产品记录中，可能只有 100 条产品没有对应的交易记录。

此查询非常慢，因为我怀疑它正在执行全表扫描以查找那些空外键产品记录。

我想创建一个像这样的部分索引：

CREATE INDEX products_with_no_transactions_index 
ON (Left JOIN TABLE 
    BETWEEN products AND transactions) 
WHERE transactions.product_id IS NULL;

以上是可能的，我将如何去做？

注：该数据集的一些特征：

  1. 交易永远不会被删除，只会被添加。

  2. 产品永远不会被删除，而是以每分钟 100 次的速度添加（显然这是一个复杂得多的实际用例背后的虚构示例）。其中一小部分是暂时的孤儿

  3. 我需要经常查询（最多每分钟一次）并且需要始终知道当前的孤立产品集是什么

4

2 回答 2

5

我能想到的最好的就是你在评论中的最后一个想法：物化视图。

CREATE MATERIALIZED VIEW orphaned_products AS
SELECT *
FROM   products p
WHERE  NOT EXISTS (SELECT 1 FROM transactions t WHERE t.product_id = p.id)

然后，您可以使用此表（物化视图只是一个表）作为products使用孤立产品的查询中大表的直接替换 - 显然对性能有很大影响（几 100 行而不是 1 亿行）。物化视图需要Postgres 9.3，但这就是您根据评论使用的。您可以在早期版本中轻松地手动实现它。

但是，物化视图是快照，不会动态更新。（无论如何，这可能会使任何性能优势无效。）要更新，您运行（昂贵的）操作：

REFRESH MATERIALIZED VIEW orphaned_products;

您可以在战略性的适当时间点执行此操作，并让多个后续查询从中受益，具体取决于您的业务模型。

当然，你会有一个索引orphaned_products.id，但这对于几百行的小表来说不是很重要。

如果您的模型永远不会删除事务，那么您可以利用它来产生巨大的影响。手动创建一个类似的表：

CREATE TABLE orphaned_products2 AS
SELECT *
FROM   products p
WHERE  NOT EXISTS (SELECT 1 FROM transactions t WHERE t.product_id = p.id);

当然，您可以通过截断和重新填充它来刷新“物化视图”，就像第一个一样。但关键是要避免昂贵的操作。你真正需要的是：

  • 将新产品添加到orphaned_products2.
    使用触发器 AFTER INSERT ON products实现。

  • 表中orphaned_products2出现引用行时立即删除产品。 使用触发器实现。仅当您的模型允许更新时-这将是非常规的事情。 还有一个。transactions
    AFTER UPDATE OF product_id ON transationstransations.products_id
    AFTER INSERT ON transations

所有相对便宜的操作。

  • 如果交易也可以删除，您需要另一个触发器来添加孤立的产品AFTER DELETE ON transations——这会有点贵。对于每个已删除的交易，您需要检查它是否是最后一次引用相关产品，并在这种情况下添加一个孤儿。可能仍然比刷新整个物化视图便宜很多。

VACUUM

在您提供其他信息之后，我还建议自定义设置以进行激进的吸尘， orphaned_products2因为它会产生很多死行。

于 2014-01-02T01:13:25.353 回答
0

我已经尝试了一些测试数据并找到了一种我认为更快的方法，USING THE EXCEPT OPERATOR

以下是我的发现。

测试数据

CREATE TABLE TestTable_1 
(ID INT IDENTITY PRIMARY KEY,
Column1 INT,
Column2 INT
)
GO

CREATE TABLE TestTable_2
(ID INT IDENTITY PRIMARY KEY,
Column1 INT,
Column2 INT,
FK_ID INT references TestTable_1(ID)
)
GO

DECLARE @i INT = 1

WHILE (@i <= 10000)
 BEGIN
   INSERT INTO TestTable_1 (Column1, Column2)
   VALUES (@i , @i + 100)
   SET @i = @i + 1;
 END

 DECLARE @i2 INT = 1

WHILE (@i2 <= 10000)
 BEGIN
   INSERT INTO TestTable_2 (Column1, Column2, FK_ID)
   VALUES (@i2 , @i2 + 100, 1 + CONVERT(INT, (10000-1+1)*RAND()))
   SET @i2 = @i2 + 1;
 END

 UPDATE  TestTable_2
 SET FK_ID = NULL
 WHERE ID IN (SELECT TOP 10 ID FROM TestTable_2 ORDER BY NEWID())

表二上的过滤索引

CREATE NONCLUSTERED INDEX FIX_FK_ID
ON TestTable_2(ID, FK_ID)
WHERE FK_ID IS NULL ;
GO

查询 1

SET STATISTICS IO ON;
PRINT 'TEST 1'
SELECT T1.*
FROM TestTable_1 T1 LEFT JOIN TestTable_2 T2
ON T1.ID = T2.FK_ID
WHERE FK_ID IS NOT NULL

查询 2

PRINT 'TEST 2'
SELECT ID,  Column1,    Column2 FROM TestTable_1
EXCEPT 
SELECT ID,  Column1,    Column2 FROM TestTable_2
WHERE FK_ID IS NULL

TEST 1

(9990 row(s) affected)
Table 'Worktable'. Scan count 0, logical reads 0, physical reads 0, read-ahead reads 0, lob logical reads 0, lob physical reads 0, lob read-ahead reads 0.
Table 'TestTable_1'. Scan count 1, logical reads 28, physical reads 0, read-ahead reads 19, lob logical reads 0, lob physical reads 0, lob read-ahead reads 0.
Table 'TestTable_2'. Scan count 1, logical reads 33, physical reads 3, read-ahead reads 29, lob logical reads 0, lob physical reads 0, lob read-ahead reads 0.


TEST 2

(9990 row(s) affected)
Table 'TestTable_1'. Scan count 1, logical reads 28, physical reads 0, read-ahead reads 0, lob logical reads 0, lob physical reads 0, lob read-ahead reads 0.
Table 'TestTable_2'. Scan count 1, logical reads 22, physical reads 1, read-ahead reads 0, lob logical reads 0, lob physical reads 0, lob read-ahead reads 0.

两个查询的执行计划

执行计划

于 2014-01-02T01:37:20.727 回答