索引以查找外键不存在的记录

Question

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. 我需要经常查询（最多每分钟一次）并且需要始终知道当前的孤立产品集是什么

Answer 1

我能想到的最好的就是你在 cmets 中的最后一个想法：materialized view。

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，但根据 cmets，这就是您使用的。您可以在早期版本中轻松地手动实现它。

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

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。
  使用trigger AFTER INSERT ON products 实现。

• 在表 transactions 中出现引用行时，

  从 orphaned_products2 中删除产品。
  使用触发器AFTER UPDATE OF product_id ON transations 实现。 仅如果您的模型允许更新 transations.products_id - 这将是非常规的事情。
  还有一个AFTER INSERT ON transations。

所有相对便宜的操作。

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

VACUUM

根据您的补充信息，我还建议custom settings for aggressive vacuuming 或orphaned_products2，因为它会产生很多死行。

Answer 2

我尝试了一些测试数据并找到了一种我认为更快的方法，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.

两个查询的执行计划