相关疑难解决方法(0)

假设我有2个表,Products和ProductCategories.两个表都与CategoryId有关系.这是查询.

SELECT p.ProductId, p.Name, c.CategoryId, c.Name AS Category
FROM Products p
INNER JOIN ProductCategories c ON p.CategoryId = c.CategoryId
WHERE c.CategoryId = 1;

当我创建执行计划时,表ProductCategories执行集群索引查找,这是期望的.但对于表产品,它执行集群索引扫描,这让我怀疑.为什么FK无助于提高查询性能？

所以我必须在Products.CategoryId上创建索引.当我再次创建执行计划时,两个表都执行索引查找.估计的子树成本降低了很多.

我的问题是:

1. 除了FK有助于关系约束,它还有其他用处吗？它是否提高了查询性能？

2. 我应该在所有表中的所有FK列(如Products.CategoryId)上创建索引吗？

许多有经验的开发人员建议不要使用Django多表继承,因为它的性能很差:

1. Django的疑难杂症:混凝土继承由雅各布·卡普兰,莫斯,Django的一个核心因素.

   几乎在所有情况下,抽象继承是一种长期更好的方法.我看到在混凝土继承引入的负载下,有很多网站被粉碎,所以我强烈建议Django用户在大量怀疑的情况下使用具体的继承.

2. Django中的两勺由丹尼尔·格林菲尔德(@pydanny)

   多表继承,有时称为"具体继承",作者和许多其他开发人员认为这是一件坏事.我们强烈建议不要使用它.

   不惜一切代价,每个人都应该避免多表继承,因为它会增加混乱和大量开销.而不是多表继承,在模型之间使用显式OneToOneFields和ForeignKeys,以便您可以控制何时遍历连接.

但是没有多表继承,我不能轻易

1. 另一个模型中的参考基础模型(必须使用GenericForeignKey或反向依赖);

2. 获取基本模型的所有实例.

   (随意添加更多)

那么Django中这种继承有什么问题？为什么明确的OneToOneField更好？

性能对JOIN的影响有多大？有没有显示性能差异的基准测试？

不会select_related()让我们连接被调用时控制？

我已经将具体示例移到了一个单独的问题,因为这个问题变得过于宽泛,并且添加了使用多表继承的原因列表.

我有一个表(MainTable)有超过600,000条记录.它通过JoinTable父/子类型关系中的第二个表()连接到自身:

SELECT   Child.ID, Parent.ID
FROM     MainTable
AS       Child
JOIN     JoinTable
      ON Child.ID = JoinTable.ID
JOIN     MainTable
AS       Parent
      ON Parent.ID = JoinTable.ParentID
     AND Parent.SomeOtherData = Child.SomeOtherData

我知道每个子记录都有父记录,JoinTable中的数据是精确的.

当我运行此查询时,运行需要几分钟.但是,如果我使用左连接加入Parent,则运行时间<1秒:

SELECT   Child.ID, Parent.ID
FROM     MainTable
AS       Child
JOIN     JoinTable
      ON Child.ID = JoinTable.ID
LEFT JOIN MainTable
AS       Parent
      ON Parent.ID = JoinTable.ParentID
     AND Parent.SomeOtherData = Child.SomeOtherData
WHERE    ...[some info to make sure we don't select parent records in the child dataset]...

我理解INNER JOINa和a 之间结果的差异LEFT JOIN …

我想知道哪一个最适合下面所述的两个查询之间的性能,还是它们的表现相同？

第一个:[没有WHERE子句,只是和ON]

SELECT related_tabid AS tabid, label, t.name
  FROM relatedlists r
     INNER JOIN tab t 
       ON t.tabid = r.tabid
          AND t.name = 'Leads'
          AND r.is_active=1  and r.related_tabid <> 0
          AND t.is_active=1
  ORDER BY label

第二个:[使用WHERE子句,AND与where相关联而不是ON]

SELECT related_tabid AS tabid, label, t.name
  FROM relatedlists r
     INNER JOIN tab t 
       ON t.tabid = r.tabid
       WHERE t.name = 'Leads'
             AND r.is_active=1  and r.related_tabid <> 0
             AND t.is_active=1
  ORDER BY label

以下是否存在性能差异？

SELECT person.id
FROM person
LEFT JOIN address ON person.id = address.personID
WHERE address.personID IS NOT NULL

VS

SELECT person.id
FROM person
INNER JOIN address ON person.id = address.personID

此查询应显示具有地址记录的所有人员ID(并非所有人都这样做).这里合乎逻辑的做法是使用内部连接,如第二个示例所示.由于不完全重要的原因(查询是从查询构建器生成的),我可能必须使用第一种方法.

好奇是什么影响.MySQL在LEFT JOIN中做了很多额外的工作,然后将该字段与null进行比较以减少设置吗？也许这就是INNER JOIN如何在幕后工作？

我有两张桌子

表 X：数百万条记录

|-----|-----|-----|-----|
|  a  |  b  |  c  |  d  |
|-----|-----|-----|-----|

表Y：只有几条记录

|-----|-----|
|  e  |  f  |
|-----|-----|

X.d允许我加入两个表X.d = Y.e

我有以下索引：

• (Xa)
• (Xb)
• (Xc)
• （Xd）
• （Xa、Xb、Xc、Xd）
• （叶）

我们的一个应用程序正在执行以下查询，该查询需要很长时间才能运行：

SELECT * 
FROM X
INNER JOIN Y ON X.d = Y.e
WHERE 
      X.a in (1, 2, 3)
  AND X.b IS NULL
  AND X.c in (4, 5 ,6)
  AND X.d in (7, 8, 9)

将 更改INNER JOIN为 a后LEFT JOIN，查询速度非常快：

SELECT * 
FROM …

左连接和内连接在性能方面有什么区别吗？我使用SQL Server 2012.

我有两个 postgres 表：

worker_details_verification (verification_id BIGSERIAL, worker_id BIGINT, 
state TEXT, proofs TEXT[])
worker_details(worker_id BIGINT, name TEXT)

现在我想得到

    `verification_id, worker_id, proofs FROM` the table 
    `worker_details_verification`  

限制记录 `WHERE state = 'Initial'

现在除了上述三列之外，我worker_details还想要表中的名称列，其中worker_id可用于查询工人的姓名。

我尝试了以下查询，但没有成功。

SELECT a.verification_id, a.worker_id, a.state, a.proofs, b.Name FROM 
worker_details_verification a FULL OUTER JOIN worker_details b ON 
a.worker_id = b.worker_id AND a.state = 'Initial';

它返回甚至 a.state 都不是的记录'Initial'，并且还返回一些错误的记录，其中所有namefrom都与for列worker_detail一起返回。NULLworker_details_verification

查询是否也这样做？标准是什么？

如果我改变其中一种写查询方式,我会失去性能吗？

查询1

   SELECT a.*, b.id AS b_id
     FROM table_a AS a
LEFT JOIN table_b AS b
       ON a.id = b.id

查询2

   SELECT a.*, b.id AS b_id
     FROM table_a a, table_b b
    WHERE a.id = b.id

SELECT 
   b.User_Id
   ,(CONVERT(varchar, DATEADD(hh, - 7, b.callstartdt), 101))as 'Dt'
   ,(COUNT(distinct b.SeqNum ) + Count(distinct c.SeqNum) + count(distinct d.seqnum)) as 'TotalCalls'
   ,COUNT(distinct b.SeqNum )as 'ACD'
   ,COUNT(distinct c.SeqNum)as 'AOD'
   ,COUNT(distinct d.seqnum)  as 'Manual'
   ,COUNT(distinct e.SeqNum)as 'Contacts'
   ,COUNT (distinct es.seqnum) as 'Success'
FROM 
   [detail_epro].[dbo].[ACDCallDetail]as b 
LEFT JOIN 
   [detail_epro].[dbo].[AODCallDetail]as c on c.User_Id = b.User_Id   
LEFT JOIN
   [detail_epro].[dbo].[manualCallDetail]as d on d.User_Id = b.User_Id 
LEFT JOIN
   (SELECT 
       USER_ID, CallStartDt, SeqNum
    FROM 
       [detail_epro].[dbo].[AgentDispoDetail]
    WHERE 
        Disp_Id IN 
                (100000150, 100000126,  100000137,  100000093,  100000133,  
                100000123,  100000094,  100000161,  100000162,  100000085,  
                100000084, …

如果内连接和左连接都可以实现相同的结果,哪一个更快并且具有更好的性能(特别是对于大数据)？

内部联接:

SELECT *
FROM Table_A A
INNER JOIN Table_B B
ON A.PK_A = B.PK_B

左连接:

SELECT *
FROM Table_A A
LEFT JOIN Table_B B
ON A.PK_A = B.PK_B

WHERE A.PK_A = B.PK_B

表A:

PK_A    User
1   FOX
2   COP
3   TAXI
6   WASHINGTON
7   DELL
5   ARIZONA
4   LINCOLN
10  LUCENT

表-B:

PK_B    Message
1   TROT
2   CAR
3   CAB
6   MONUMENT
7   PC
8   MICROSOFT
9   APPLE
11  SCOTCH

有任何想法吗？如何测试大数据的性能？