select（投影）的列字段中的子查询如何与主查询的结果配对？形式：

 SELECT id,email,(SELECT name From Names WHERE Names.id=Users.id) as name
 FROM Users

子查询是从 , 的输出中每行执行一次SELECT id,email FROM Users，因此应该LIMIT 1在子查询上使用（因为子查询中只有 1 行可以与主查询中的一行配对），还是子查询运行一次，并且然后每个结果都与来自 的相应行配对SELECT id,email FROM Users，很像等效连接：SELECT id,email,name FROM Users JOIN Names ON Users.id=Names.id

我在做一些相当轻量级的数据按摩/清洁跑进其中使用相关子查询（可能是错误的）JOIN的一个版本跑了太大的问题很多比我相信这是正确的慢。我不问如何做查询（我相信现在我已经得到了正确的），但我想知道为什么慢版是如此缓慢。

问题

该域是一个相当简单的数据库，用于管理彩票辛迪加（记录会员付款、玩的游戏和获胜）。在转向新引擎 (SQLite) 时，我正在尝试清理数据并改进表的结构。

现有_Winnings表格记录了赢得的金额和日期以及“游戏类型”（可以玩多个游戏）：

CREATE TABLE [_Winnings](
    [ID]                integer primary key not null,
    [WinDate]           date,
    [Amount]            integer,
    [GameType]          integer references _Games(ID)
);
CREATE INDEX [_WinningsIndex] on _Winnings(GameType) ;

主要问题是没有链接（除了获胜日期）到实际玩的游戏。这些记录已经被迁移，现在保存在一个EventHistory表中：

CREATE TABLE [EventHistory](
    [ID]                integer primary key not null,
    [EventType]         integer references Events(ID),
    [GameType]          integer references Games(ID),
    [EventDate]         date
);
CREATE INDEX [EventHistoryEventIndex] on EventHistory(EventType) ;
CREATE INDEX [EventHistoryGameIndex]  on EventHistory(GameType) ;
CREATE INDEX [EventHistoryDateIndex]  on EventHistory(EventDate) ;

三个表_Games， …

我正在尝试构建一个查询，该查询会生成一个由 SQL Server 生成的 JSON 对象。我发现我可以使用子查询用包含问题列表的 JSON 字符串填充字段（在本例中为问题字段）。

下面是查询：

SELECT
    quizzes.id AS 'id',
    quizzes.name AS 'name',
    quizzes.description AS 'description',
    quizzes.instructions AS 'instructions',
    author.id AS 'author.id',
    author.midas AS 'author.midas',
    author.first_name AS 'author.first_name',
    author.last_name AS 'author.last_name',
    author.email AS 'author.email',
    author.tel AS 'author.tel',
    author.department_name AS 'author.department_name',
    author.created_at AS 'author.created_at',
    author.last_updated AS 'author.last_updated',
    course.id AS 'course.id',
    course.name AS 'course.name',
    course.description AS 'course.description',
    course.crn AS 'course.crn',
    instructor.id AS 'course.instructor.id',
    instructor.midas AS 'course.instructor.midas',
    instructor.first_name AS 'course.instructor.first_name',
    instructor.last_name AS 'course.instructor.last_name',
    instructor.email AS 'course.instructor.email',
    instructor.tel AS 'course.instructor.tel',
    instructor.department_name …

我在我们的代码库中找到了这个查询：

DELETE FROM "Foo"
WHERE ("Foo"."Id", "Foo"."CreatedAt")
IN (SELECT "f"."Id", "f"."CreatedAt"
    FROM "Foo" AS "f"
    WHERE "f"."CreatedAt" <= CURRENT_TIMESTAMP);

它删除当前时间之前创建的记录。

这给出了相同的结果：

DELETE FROM "Foo"
WHERE "Foo"."CreatedAt"
IN (SELECT "f"."CreatedAt"
    FROM "Foo" AS "f"
    WHERE "f"."CreatedAt" <= CURRENT_TIMESTAMP);

我不知道为什么Foo.Id将 包含在WHERE子句中 - 也许是各种重构留下的垃圾（例如，它可能已用于批量删除ORDER BY "f"."Id" LIMIT 1000）。但因为这是一场PK，我不愿意删除它，因为也许它的存在是有原因的。

是否有理论/性能原因将其放在那里，或者这两个查询是否等效？

（这同时针对 postgres 和 sqlite。）

我对 SQL 查询调优相当陌生。我一直在尝试了解如何编写等效的查询。在浏览J. Widom 教授的斯坦福在线视频讲座时，她提到了一些子查询，如果不JOIN使用DISTINCT. 例如，看这个：

1. 4:45 / 20:13 - GPA 示例

   SELECT GPA
   FROM Student
   WHERE sID in (select sID from Apply where major = 'CS');
   

   Run Code Online (Sandbox Code Playgroud)

2. 6:39 / 20:13 - 学生申请 CS 而不是 EE

   SELECT sID, sName
   FROM Student
   WHERE sID IN (select sID from Apply where major = 'CS')
     AND sID NOT IN (select sID from Apply where major = 'EE');
   

   Run Code Online (Sandbox Code Playgroud)

我的问题是如何知道使用子查询编写的 SQL 语句是否将具有使用连接编写的等效语句。我很舒服，如果在答案中，有人喜欢使用关系代数表示法。

我在网上搜索了很多，找不到合适的答案。

样本数据

Schema 和表创建（对于 PostgreSQL）如下，

CREATE TEMP TABLE college …

假设我们有以下查询：

1.

    SELECT COUNT(*) FROM some_big_table WHERE some_col = 'some_val'

2.

    SELECT COUNT(*) FROM ( SELECT * FROM some_big_table WHERE some_col = 'some_val' )

之前的任何查询是否性能更好？或者他们是一样的？

我使用的是 Postgresql 9.4，但是与其他 DBMS 有很大不同吗？

PS：我问这个问题是因为 SQLAlchemy 是一个基于 Python 的 ORM，COUNT它默认在子查询上执行操作，但有一个选项可以强制它COUNT直接在查询上执行。

我有一个 1:m 协会。

symbols表中有很多行company_key_statistics。company_key_statistics有一个时间戳列createdAt，指示行的创建时间。我需要加入最新symbols的company_key_statistics，但我只需要最新的company_key_statistics。例如，我需要获取ORCL并且MSFT symbols仅获取他们最新的company_key_statistics.

到目前为止我已经尝试过了。

SELECT `symbols`.`id`, 
       `symbols`.`symbol`, 
       `statistics`.
       `marketCapitalization` 
FROM   `symbols` 
       LEFT JOIN (SELECT `s`.`companyId`, 
                         `s`.`marketCapitalization` 
                  FROM   `company_key_statistics` AS `s`
                  WHERE  `s`.`companyId` = `symbols`.`id` 
                  ORDER by `createdAt` 
                  DESC LIMIT 1) AS `statistics` 
ON     `symbols`.`id` = `statistics`.`companyId` 
WHERE  `symbols`.`symbol` IN ('ORCL', 'SNAP');

但不幸的是我发现我不能在子查询中使用父查询中的列JOIN。

我怎样才能做到这一点？

我正在尝试编写一个 SQL 语句，从一个表中提取所有记录并查看它们是否在另一个表中使用。SQL 不是我最擅长的语言，所以我确信这是一个非常简单的查询。这是我的两个表：

tblOrderContracts
--------------------------------------
OrderContractID           | bigint
OrderID                   | bigint
UserContractID            | bigint
UserName                  | varchar
OrderContractDateCreated  | datetime
OrderContractStatus       | varchar



tblUserContracts
-------------------------------------
UserContractId            | bigint
UserName                  | varchar
UserContractName          | varchar
UserContractFileName      | varchar
UserContractDateCreated   | datetime
UserContractStatus        | varchar

用户可以将任意数量的合约应用到一个订单，所以我需要做的是获取所有合约的列表，并查看它们是否按特定顺序使用。现在，我使用子查询来完成工作，但如果不需要，我不喜欢使用子查询。

SELECT uc.UserContractId, uc.UserContractName,
(SELECT oc.OrderID FROM tblOrderContracts as oc WHERE uc.UserContractID = 
oc.UserContractID AND oc.OrderID = 466 AND OrderContractStatus = 
'Active')
FROM tblUserContracts as uc
WHERE uc.UserName = 'vandel212' AND UserContractStatus = 'Active'

理想情况下，我希望得到一个如下所示的结果集，如果 OrderID …

我的数据库（Postgresql 10）具有以下架构：

CREATE TABLE "PulledTexts" (
"Id" serial PRIMARY KEY,
"BaseText" TEXT,
"CleanText" TEXT
);

CREATE TABLE "UniqueWords" (
"Id" serial PRIMARY KEY,
"WordText" TEXT
);

CREATE TABLE "WordTexts" (
"Id" serial PRIMARY KEY,
"TextIdId" INTEGER REFERENCES "PulledTexts",
"WordIdId" INTEGER REFERENCES "UniqueWords"
);
CREATE INDEX "IX_WordTexts_TextIdId" ON "WordTexts" ("TextIdId");
CREATE INDEX "IX_WordTexts_WordIdId" ON "WordTexts" ("WordIdId");

一些示例数据：

INSERT INTO public."PulledTexts" ("Id", "BaseText", "CleanText") VALUES
(1, 'automate business audit', null),
(2, 'audit trial', null),
(3, 'trial', null),
(4, 'audit', null),
(5, 'fresh …

SELECT users.*,(SELECT COUNT(user_id) AS mutual_connection FROM 
                (SELECT user_id 
                       FROM (
                                SELECT sender_id AS user_id 
                                FROM `connections`
                                WHERE receiver_id=users.id AND status='2' 
                                UNION 
                                SELECT receiver_id AS user_id 
                                FROM `connections` 
                                WHERE sender_id=users.id AND status='2'
                        ) tempUser
                        WHERE user_id IN (
                                  SELECT sender_id AS user_id
                                  FROM `connections` 
                                  WHERE receiver_id='4' AND status='2'
                                  UNION 
                                  SELECT receiver_id AS user_id 
                                  FROM `connections` WHERE sender_id='4' AND status='2') 
                         GROUP BY user_id) 
                as mutualConnection)

     FROM users

错误：

#1054 - 'where 子句'中的未知列'users.id'

如何使用传递值进行子查询