标签: subquery

以下两个查询是子查询.两者都是一样的,两者都适合我.但问题是方法1查询需要大约10秒才能执行,而方法2查询需要不到1秒.

我能够将方法1查询转换为方法2,但我不明白查询中发生了什么.我一直试图弄清楚自己.我真的想了解下面两个查询之间的区别是什么以及性能增益是如何发生的？它背后的逻辑是什么？

我是这些先进技术的新手.我希望有人能在这里帮助我.鉴于我阅读的文档没有给我一些线索.

方法1:

SELECT
   *       
FROM
   tracker       
WHERE
   reservation_id IN (
      SELECT
         reservation_id                                 
      FROM
         tracker                                 
      GROUP  BY
         reservation_id                                 
      HAVING
         (
            method = 1                                          
            AND type = 0                                          
            AND Count(*) > 1 
         )                                         
         OR (
            method = 1                                              
            AND type = 1                                              
            AND Count(*) > 1 
         )                                         
         OR (
            method = 2                                              
            AND type = 2                                              
            AND Count(*) > 0 
         )                                         
         OR (
            method = 3                                              
            AND type = 0                                              
            AND Count(*) > 0 
         )                                         
         OR (
            method …

我有两个存储过程,其中一个返回付款清单,而另一个返回这些付款的摘要,按货币分组.现在,我有一个重复的查询:返回付款清单的存储过程的主要查询是存储过程的子查询,它返回按货币付款的摘要.我想通过使返回付款列表的存储过程成为存储过程的子查询来返回按货币付款的摘要,从而消除这种双重性.这可能在SQL Server 2008中吗？

我有一个看起来像这样的查询:

SELECT a, b, c,
    (SELECT d from B limit 0,1) as d
FROM A
WHERE d >= 10

当我在没有where子句的情况下运行查询时,我得到了我想要的结果,但是当我添加该where子句时,查询失败了.

有没有人有建议如何解决？

我一直在寻找一个解释,一个select语句中的子查询如何工作,但由于非常含糊的解释,我仍然无法理解这个概念.

我想知道如何在oracle中的select语句中使用子查询以及它输出的确切内容.

例如,如果我有一个想要显示员工姓名的查询以及他们从这些表中管理的配置文件数

员工(EmpName,EmpId)

个人资料(ProfileId,...,EmpId)

我如何使用子查询？

我认为在select语句中需要一个子查询来实现按功能分组来计算每个员工管理的配置文件的数量,但我不太确定.

我想通过指定innertable.id = outertable.id为内部查询提供WHERE条件.但是,MySQL(5.0.45)在'where子句'中报告"未知列'outertable.id'".这种查询是否可行？

内部查询使用GROUP BY将行旋转到列.这可以完全在外部查询中执行,但由于额外的连接可能会产生额外的开销.

或者,我可以在内部查询中省略WHERE条件,而是指定一个ON outertable.id = innerquery.id,但它会获取整个内部查询行集再次连接外部,这是低效的.

实际的SQL如下所示:

select t.ticketid, u.userid, t.fullname, u.loginapi_userid, t.email, tp.subject, tp.contents, a.PhoneNumber, a.Location, a.Extension, a.BusinessUnit, a.Department
from swtickets t
inner join swticketposts tp on t.ticketid = tp.ticketid
inner join swusers u on t.userid = u.userid
left join
  (
  select
  cfv.typeid,
  min(case cfv.customfieldid when 1 then cfv.fieldvalue end) as 'PhoneNumber',
  min(case cfv.customfieldid when 3 then cfv.fieldvalue end) as 'Location',
  min(case cfv.customfieldid when 5 then cfv.fieldvalue end) as 'Extension',
  min(case cfv.customfieldid when 8 then cfv.fieldvalue …

以两个表为例:tbl_product和tbl_transaction.
tbl_product列出产品详细信息,包括名称和ID,同时tbl_transaction列出涉及产品的交易,包括日期,产品ID,客户等.

我需要显示一个显示10个产品和每个产品的网页,最后5个交易.到目前为止,没有LEFT JOIN查询似乎工作,如果mysql可以允许该tx.product_id=ta.product_id部分,下面的子查询将起作用(在'where子句'中出现未知列'ta.product_id'失败:[错误:1054]).

SELECT  
ta.product_id,  
ta.product_name,  
tb.transaction_date  
FROM tbl_product ta  
LEFT JOIN (SELECT tx.transaction_date FROM tbl_transaction tx WHERE tx.product_id=ta.product_id LIMIT 5) tb
LIMIT 10

有没有办法实现我需要的列表,而无需在循环中使用多个查询？

编辑:
这正是我需要的MySQL:

SELECT ta.product_id, ta.product_name, tb.transaction_date ...  
FROM tbl_product ta  
LEFT JOIN tbl_transaction tb ON (tb.product_id=ta.product_id LIMIT 5)  
LIMIT 10

当然这是非法的,但我真的希望不是!

我在我的Express应用程序中使用Sequelize.我需要生成一个在WHERE子句中有子查询的查询.

SELECT *
  FROM MyTable
 WHERE id NOT IN (
       SELECT fkey
         FROM MyOtherTable
        WHERE field1 = 1
          AND field2 = 2
          AND field3 = 3
       )

我首先通过我的模型尝试过关系/关联,但无法让它发挥作用.就像是:

MyTable.find( {
    where: {
        id: {
            $notIn: // <= what goes here? Can I somehow reference my include model?
        }
    },
    include: [ {
        model: MyOtherTable,
        where: {
            field1: 1,
            field2: 2,
            field3: 3
    } ]
} );

然后我尝试使用Sequelize.where(),那里没有运气.

然后我尝试了Sequelize.literal(),但是不确定它是否是在Sequelize的where子句中做一个子查询的"正确"方式,因为我是新手.

MyTable.find( { …

我怎样才能将SELECT查询中的行计为值？如

SELECT FUCNTIONIMLOOKINGFOR(SELECT * FROM anothertable) AS count FROM table;

因此count是子查询SELECT * FROM anothertable返回的行数的整数.

编辑

SELECT p.PostPID, p.PostUID, p.PostText, p.PostTime, u.UserUID, u.UserName, u.UserImage, u.UserRep,
    (
        SELECT COUNT(f.FlagTime)
            FROM Flags as f 
                JOIN Posts as p 
                ON p.PostPID = f.FlagPID
    ) as PostFlags
    FROM Posts AS p
        JOIN Users AS u
        ON p.PostUID = u.UserUID
    ORDER BY PostTime DESC
    LIMIT 0, 30

我有一张名为'jobs'的桌子.对于特定用户,作业可以是活动的,存档的,过期的,挂起的或关闭的.现在每个页面请求都生成5个COUNT个查询,并且在尝试优化时我试图将其减少为单个查询.这是我到目前为止所拥有的,但它几乎比5个单独的查询快.请注意,我已经简化了每个子查询的条件,使其更容易理解,但完整查询的行为却相同.

有没有办法在不使用低效子查询的情况下在同一查询中获取这5个计数？

SELECT
  (SELECT count(*)
    FROM "jobs"
    WHERE
      jobs.creator_id = 5 AND
      jobs.status_id NOT IN (8,3,11) /* 8,3,11 being 'inactive' related statuses */
  ) AS active_count, 
  (SELECT count(*)
    FROM "jobs"
    WHERE
      jobs.creator_id = 5 AND
      jobs.due_date < '2011-06-14' AND
      jobs.status_id NOT IN(8,11,5,3) /* Grabs the overdue active jobs
                                      ('5' means completed successfully) */
  ) AS overdue_count,
  (SELECT count(*)
    FROM "jobs"
    WHERE
      jobs.creator_id = 5 AND
      jobs.due_date BETWEEN '2011-06-14' AND '2011-06-15 06:00:00.000000'
  ) AS due_today_count

这继续2个子查询,但我想你明白了.

是否有更简单的方法来收集这些数据,因为它基本上是5个不同的COUNT,来自作业表的相同数据子集？

数据子集是'creator_id = 5',之后每个计数基本上只有1-2个附加条件.请注意,目前我们正在使用Postgres,但可能会在不久的将来转向MySQL.因此,如果您能提供与ANSI兼容的解决方案,我将非常感激:)

是否存在将SQL子查询转换为连接的通用过程或算法,反之亦然？也就是说,是否有一组排版操作可以应用于语法正确的SQL查询语句,其中包含一个子查询,该子查询导致函数等效语句没有子查询？如果是这样,它们是什么(即算法是什么),在什么情况下它们不适用？