标签: join

为什么 SQL Server 在运行使用子查询的查询时使用并行性，但在使用连接时不使用并行性？加入版本串行运行，需要大约 30 倍的时间才能完成。

加入版本：~30secs

子查询版本：<1 秒

编辑： Xml 版本的查询计划：

加入版本

子查询版本

在某些情况下，需要非常大的查询将多个表与其中的子选择语句连接在一起以产生所需的结果。

我的问题是，我们是否应该考虑使用多个较小的查询，并通过多次调用查询数据库将逻辑操作带入应用程序层，还是最好一次性完成所有操作？
例如，考虑以下查询：

SELECT *
FROM   `users`
WHERE  `user_id` IN (SELECT f2.`friend_user_id`
                     FROM   `friends` AS f1
                            INNER JOIN `friends` AS f2
                              ON f1.`friend_user_id` = f2.`user_id`
                     WHERE  f2.`is_page` = 0
                            AND f1.`user_id` = "%1$d"
                            AND f2.`friend_user_id` != "%1$d"
                            AND f2.`friend_user_id` NOT IN (SELECT `friend_user_id`
                                                            FROM   `friends`
                                                            WHERE  `user_id` = "%1$d"))
       AND `user_id` NOT IN (SELECT `user_id`
                             FROM   `friend_requests`
                             WHERE  `friend_user_id` = "%1$d")
       AND `user_image` IS NOT NULL
ORDER  BY RAND() 
LIMIT %2$d

最好的方法是什么？

当我写这样的查询时......

select *
from table1 t1
join table2 t2
on t1.id = t2.id

SQL 优化器，不确定这是否是正确的术语，是否将其转换为...

select *
from table1 t1, table2 t2
where t1.id = t2.id

本质上，SQL Server 中的 Join 语句只是一种更简单的编写 sql 的方法吗？或者它实际上是在运行时使用的？

编辑：我几乎总是，而且几乎总是，使用 Join 语法。我只是好奇会发生什么。

我有两个表 A 和 B。

表A

id | name | num

表B

id | date | roll

id表 B 中的外键与id表 A 中的相关。

我想获取表 B 的内容，其中给出了 id 以及该数据，我需要从表 A 中给出其 id 的名称。

注意：不能使用逗号分隔的多个查询；需要SELECT在一个查询中同时执行这两个s。

我有一个用户表：

|Username|UserType|Points|
|John    |A       |250   |
|Mary    |A       |150   |
|Anna    |B       |600   |

和级别

|UserType|MinPoints|Level  |
|A       |100      |Bronze |
|A       |200      |Silver |
|A       |300      |Gold   |
|B       |500      |Bronze |

我正在寻找一个查询来获取每个用户的级别。类似的东西：

SELECT *
FROM Users U
INNER JOIN (
    SELECT TOP 1 Level, U.UserName
    FROM Levels L
    WHERE L.MinPoints < U.Points
    ORDER BY MinPoints DESC
    ) UL ON U.Username = UL.Username

这样的结果将是：

|Username|UserType|Points|Level  |
|John    |A       |250   |Silver |
|Mary    |A       |150   |Bronze |
|Anna    |B       |600 …

我们有一个表，用于存储问题的答案。我们需要能够找到对特定问题有特定答案的用户。因此，如果我们的表包含以下数据：

user_id     question_id     answer_value  
Sally        1               Pooch  
Sally        2               Peach  
John         1               Pooch  
John         2               Duke

并且我们想要找到回答问题 1 的“Pooch”和回答问题 2 的“Peach”的用户，以下 SQL 将（显然）不起作用：

select user_id 
from answers 
where question_id=1 
  and answer_value = 'Pooch'
  and question_id=2
  and answer_value='Peach'

我的第一个想法是为我们正在寻找的每个答案自行加入表格：

select a.user_id 
from answers a, answers b 
where a.user_id = b.user_id
  and a.question_id=1
  and a.answer_value = 'Pooch'
  and b.question_id=2
  and b.answer_value='Peach'

这是有效的，但由于我们允许任意数量的搜索过滤器，我们需要找到更有效的东西。我的下一个解决方案是这样的：

select user_id, count(question_id) 
from answers 
where (
       (question_id=2 and answer_value = 'Peach') 
    or (question_id=1 and answer_value = 'Pooch')
      )
group …

我想了解以下内容。
假设我有一个复杂的查询，假设通过求和和排序将一组 5 个表连接起来。
抛开对查询本身的任何优化，例如索引等。
使用LIMIT?是否有任何显着的性能优势？我假设在应用 LIMIT之前必须处理所有查询（和结果），因此使用 LIMIT 来检索结果的子集，这是否提供了任何显着/显着的改进？

我有两个表，“hierarchy_table”和“name_table”。

层次结构表包含一个具有多个父级和子级的对象。每个父级和子级都由 id 引用。

|  object_id  |  parent_id_1  |  parent_id_2  |  child_id_1  |  child_id_2  |
-----------------------------------------------------------------------------
|     1234    |      9999     |      9567     |     5555     |     5556     |
-----------------------------------------------------------------------------

hierarchy_table 中的每个对象 id 在 name_table 中都有一个条目：

|  name_id  |    name    |
--------------------------
|   1234    |   ABCD     |
--------------------------
|   9999    |   ZYXW     |
--------------------------
| ...

如何将hierarchy_table 中的每个id 多次加入name_table，以便我可以得到填充每个名称的结果？

像这样：

|   object    |   parent_1    |   parent_2    |   child_1    |   child_2    |
-----------------------------------------------------------------------------
|     ABCD    |      ZYXW     |      BBBB     |     CCCC     |     DDDD …

我有20M行的表，每一行有3列：time，id，和value。对于每个id和time，value状态都有一个。我想知道time特定id.

我使用了两种方法来实现这一点。一种方法是使用加入和另一种方法是使用功能导致的窗口/滞后与聚簇索引time和id。

我通过执行时间比较了这两种方法的性能。join方法需要16.3秒，窗口函数方法需要20秒，不包括创建索引的时间。这让我感到惊讶，因为窗口函数似乎是先进的，而连接方法是蛮力的。

下面是这两种方法的代码：

创建索引

create clustered index id_time
 on tab1 (id,time)

加入方式

select a1.id,a1.time
   a1.value as value, 
   b1.value as value_lag,
   c1.value as value_lead
into tab2
from tab1 a1
left join tab1 b1
on a1.id = b1.id
and a1.time-1= b1.time
left join tab1 c1
on a1.id = c1.id
and a1.time+1 = c1.time

使用SET STATISTICS TIME, IO ON以下方法生成的 IO …

我刚刚开始使用 Postgres。阅读此文档时，我遇到了以下查询：

SELECT title, ts_rank_cd(textsearch, query) AS rank
FROM apod, to_tsquery('neutrino|(dark & matter)') query
WHERE query @@ textsearch
ORDER BY rank DESC
LIMIT 10;

我可以理解这个查询中的所有内容，除了这个：FROM apod, ...。

这,是什么意思？我习惯于连接但不习惯于用FROM逗号分隔的多个语句。

我在网上搜索无果。在查看并思考之后，在我看来，它声明了一个名为 query 的变量，因此它可以多次使用它。但如果这是真的，这与什么有关系FROM？