假设我有表 a（列 a1）和 b（列 b1 和 b2）并且我执行左外连接

SELECT *
FROM a LEFT OUTER JOIN b
ON a.a1 = b.b1

然后 b1 和 b2 将为 NULL，其中 a1 的值没有 b1 的匹配值。

我可以为 b2 提供默认值而不是 NULL 吗？需要注意的是COALESCE不会在这里工作，因为我不希望默认值来覆盖潜在的NULL在B2那里是B1匹配A1的值。

也就是说，将 a 和 b 作为

CREATE TABLE a (a1)
  AS VALUES (1),
            (2),
            (3) ;

CREATE TABLE b (b1,b2)
  AS VALUES (1, 10),
            (3, null) ;


a1     b1 | b2
---    --------
 1      1 | 10
 2      3 | NULL
 3

和 …

我在 libpq 之上为PostrgreSQL制作了一个远程应用程序草案。它表现良好，但我已经描述了应用程序的一般功能。对于我产生的每个最终业务结果，我碰巧调用了类似 40 select 子句（通过 tcpip）的东西。

我有 SQL-Server 的回忆，提醒我尽量减少远程应用程序和数据库之间的交互次数。分析了我的选择后，我确实认为我可以SELECT使用连接将这个数字减少到 3 个子句。但我不记得SELECT在 another 中使用 a 的结果的语法SELECT。

例如：

SELECT * FROM individual
INNER JOIN publisher
ON individual.individual_id = publisher.individual_id
WHERE individual.individual_id = 'here I would like to use the results of a another select'

另一个SELECT就是这样的：

SELECT identifier FROM another_table WHERE something='something'

这是简化的表布局，针对不同的 item_types 拒绝了多次......（3 种完全不同的类型，因此如果优化了 3 个 SQL 查询）。

table passage
  id_passage PK
  business_field_passage bytea

table item
  id_item PK
  id_passage FK …

在一个简单的投票系统中

CREATE TABLE elections (
election_id int(11) NOT NULL AUTO_INCREMENT,
title varchar(255),

CREATE TABLE votes (
election_id int(11),
user_id int(11),
FOREIGN KEYs

为了获取用户投票的选举列表，使用以下 JOIN

SELECT * FROM elections
JOIN votes USING(election_id)
WHERE votes.user_id='x'

但是如何获取用户未投票的选举列表？

我有两张桌子

@T1 TABLE
(
    Id INT,
    Date DATETIME
)

@T2 TABLE
(
    Id INT,
    Date DATETIME
)

这些表在 (Id, Date) 上有一个非聚集索引

我加入这些表

SELECT *
FROM T1 AS t1
INNER JOIN T2 AS t2
ON 
    t1.Id = t2.Id
WHERE 
    t1.Date <= GETDATE()
    AND
    t2.Date <= GETDATE()

这也可以写成

SELECT *
FROM T1 AS t1
INNER JOIN T2 AS t2
ON 
    t1.Id = t2.Id
    AND
    t1.Date <= GETDATE()
    AND
    t2.Date <= GETDATE()

我的问题是，这两个查询中哪一个提供了更好的性能，为什么？或者他们是平等的？

我有这个 SQL：

CREATE TABLE test(id SERIAL PRIMARY KEY, data JSONB);

INSERT INTO test(data) VALUES
   ('{"parent":null,"children":[2,3]}'),
   ('{"parent":1,   "children":[4,5]}'),
   ('{"parent":1,   "children":[]}'),
   ('{"parent":2,   "children":[]}'),
   ('{"parent":2,   "children":[]}');

那会给：

 id |                 data                 
----+--------------------------------------
  1 | {"parent": null, "children": [2, 3]}
  2 | {"parent": 1, "children": [4, 5]}
  3 | {"parent": 1, "children": []}
  4 | {"parent": 2, "children": []}
  5 | {"parent": 2, "children": []}

当进行正常的一对多时，它会显示如下内容：

SELECT * 
FROM test x1
  LEFT JOIN test x2
    ON x1.id = (x2.data->>'parent')::INT;
 id |                 data                 | id | …

我在 PostgreSQL 9.3 数据库中有两个表： Tablelink_reply有一个which_group指向 table的外键link_group。

我想删除link_group不link_reply存在相关行的所有行。听起来很基本，但我一直在努力。

会不会像这样简单（不工作）？

DELETE FROM link_group WHERE link_reply = NULL;

我们运行的网站在一个表中具有 250 MM 的行，而在另一个表中，我们将其连接到大多数查询中的行不到 15 MM。

示例结构：

MasterTable (Id, UserId, Created, Updated...) -- 15MM Rows
DetailsTable (Id, MasterId, SomeColumn...) -- 250MM Rows
UserTable (Id, Role, Created, UserName...) -- 12K Rows

我们必须定期对所有这些表进行一些查询。一种是抓取免费用户（~10k 免费用户）的统计数据。

Select Count(1) from DetailsTable dt 
join MasterTable mt on mt.Id = dt.MasterId 
join UserTable ut on ut.Id = mt.UserId 
where ut.Role is null and mt.created between @date1 and @date2

问题是这个查询有时会运行很长时间，因为连接发生在 where 之前很久。

在这种情况下，使用 wheres 而不是 joins 或可能更明智where column in(...)吗？

在阅读了慢 SQL 查询后，不确定如何优化，这让我想到了查询的总体性能。当然，我们需要第一个表的结果（当其他表被连接时）在连接之前尽可能小（这个问题的内部连接），以使我们的查询更快一点。

例如，应该这样：

SELECT *
FROM   ( SELECT * FROM table1 WHERE col = @val ) t
INNER JOIN table2 ON col = col2

比以下更好/更快：

SELECT *
FROM table1
INNER JOIN table2 ON col = col2
WHERE table1.col = @val

我的理论如下（这可能不是正确的实现，我试图从我读过的 SQL Server 2008 内部书籍（MSFT Press）中记住）：

1. 查询处理器首先获取左表（table1）
2. 连接第二个表 (table2) 并在过滤掉必要的行之前形成笛卡尔积（如果适用）
3. 然后使用 SEELCT 语句最后执行 WHERE、ORDER BY、GROUP BY、HAVING 子句。

因此，如果在上面的语句 #1 中，表较小，则 SQL 引擎在形成笛卡尔积时要做的工作较少。然后，当您到达 where 语句时，您将拥有一个简化的结果集，可从中过滤内存。

我可能离目标太远了，这是不真实的。就像我说的，这是一个理论。

你的意见？

注意：我刚刚想到这个问题，还没有机会自己进行任何测试。

注2：标记为SQL Server的，因为我不知道任何关于MySQL等的实施，请随时接听/评论反正

提前为非常详细的问题道歉。我已经包含了生成完整数据集以重现问题的查询，并且我正在 32 核机器上运行 SQL Server 2012。但是，我认为这不是 SQL Server 2012 特有的，并且我已将这个特定示例的 MAXDOP 强制为 10。

我有两个使用相同分区方案进行分区的表。在用于分区的列上将它们连接在一起时，我注意到 SQL Server 无法像预期的那样优化并行合并连接，因此选择使用 HASH JOIN 代替。在这种特殊情况下，我能够通过基于分区函数将查询拆分为 10 个不相交的范围并在 SSMS 中同时运行这些查询中的每一个来手动模拟更优化的并行 MERGE JOIN。使用 WAITFOR 精确地同时运行它们，结果是所有查询在原始并行 HASH JOIN 所用总时间的 40% 左右完成。

在等效分区表的情况下，有什么方法可以让 SQL Server 自行进行这种优化？我知道 SQL Server 通常可能会产生大量开销，以便并行执行 MERGE JOIN，但在这种情况下，似乎有一种非常自然的分片方法，开销最小。也许这只是优化器还不够聪明以识别的特殊情况？

以下是设置简化数据集以重现此问题的 SQL：

/* Create the first test data table */
CREATE TABLE test_transaction_properties 
    ( transactionID INT NOT NULL IDENTITY(1,1)
    , prop1 INT NULL
    , prop2 FLOAT NULL
    )

/* Populate table with pseudo-random data (the specific data doesn't …

第一句话

如果您只是想破解代码，您可以放心地忽略以下（包括）JOINs：Starting Off 部分。的背景和结果只是作为背景。如果您想查看代码最初的样子，请查看 2015-10-06 之前的编辑历史记录。

客观的

最终，我想根据表中可用 GPS 数据的日期时间戳计算发射机（X或Xmit）的内插 GPS 坐标，这些数据SecondTable直接位于表中的观测值的两侧FirstTable。

我的近期目标实现的最终目标是要弄清楚如何最好地加入FirstTable到SecondTable得到这些侧翼的时间点。稍后我可以使用该信息我可以计算中间 GPS 坐标，假设沿等距柱状坐标系进行线性拟合（花哨的话说我不在乎地球是这个比例的球体）。

问题

1. 有没有更有效的方法来生成最接近的前后时间戳？
   • 我自己通过抓取“之后”来修复，然后仅获取与“之后”相关的“之前”。
2. 有没有更直观的方式不涉及(A<>B OR A=B)结构。
   • Byrdzeye提供了基本的替代方案，但是我的“现实世界”经验与他的所有 4 个加入策略的表现都不一致。但是完全归功于他解决了替代连接样式。
3. 您可能有的任何其他想法、技巧和建议。
   • 到目前为止，byrdzeye和Phrancis在这方面都非常有帮助。我发现Phrancis 的建议非常好，并在关键阶段提供了帮助，所以我会在这里给他优势。

对于问题 3，我仍然希望得到任何额外的帮助。 要点反映了我认为在个别问题上对我帮助最大的人。

表定义

半视觉表现

第一表

Fields
  RecTStamp | DateTime  --can contain milliseconds via VBA code (see Ref 1) 
  ReceivID  | LONG
  XmitID    | …