标签: subquery

我有这样的查询:

SELECT t1.id,
    (SELECT COUNT(t2.id)
     FROM t2
     WHERE t2.id = t1.id
          ) as num_things
FROM t1
WHERE num_things = 5;

目标是获取在另一个表中出现5次的所有元素的id.但是,我收到此错误:

ERROR: column "num_things" does not exist
SQL state: 42703

我可能在这里做些傻事,因为我对数据库有些新意.有没有办法修复此查询,以便我可以访问num_things？或者,如果没有,是否还有其他方法可以实现这一结果？

我只是尝试在Oracle语句的FROM子句中进行相关的子查询SELECT，但是却收到一条错误消息，指示我无法进行相关（某种Obs.pID无法识别的效果）。

应该行吗？

FROM ml.Person Person 
    JOIN ml.Obs ON Person.pID = Obs.pId
        JOIN (SELECT ObsMax2.pId, ObsMax2.hdId
                , MAX(ObsMax2.obsDate) as maxDate
                FROM ml.Obs ObsMax2
                WHERE ObsMax2.pId = Obs.pId
                    AND ObsMax2.obsDate < {?EndDate}
                GROUP BY ObsMax2.pId, ObsMax2.hdId) ObsMax 
            ON Obs.pId = ObsMax.pId
                AND Obs.hdId = ObsMax.hdId
                AND Obs.obsDate = ObsMax.maxDate

我的解决办法似乎是使它成为一个非相关子查询，并添加标准，保持它完全运行横行霸道，横行霸道，amu--子查询OOF对不起。

我宁愿弄清楚如何正确地关联它，但是，如果可能的话-像子查询一样工作的视图将永远需要构建。

我有点卡住,并会感谢帮助.....我确定我需要使用子查询,但当我尝试即时错误说返回多行....

所以这就是代码

SELECT to_char(p.releasedate, 'YYYY') AS releaseyear , t.genre
, COUNT(*) AS "Number of awards"
FROM dbf11.film p
JOIN dbf11.genre t
ON p.filmID = t.filmID
GROUP BY p.releasedate, t.genre
ORDER BY p.releasedate, t.genre ;

我想要做的是....每年都会显示不.每种类型的电影

我现在得到的是

2010 Action 1
2010 Comedy 1
2010 Comedy 1
2011 Action 1
2011 Action 1
2011 Action 1

我想要它显示的是

2010 Action 1
2010 Comedy 2
2011 Action 3

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

Select 
    tradesmen.id,
    (SELECT COUNT(quotes.id) FROM quotes WHERE quotes.tradesman_id = tradesmen.id) AS quoted
From
    tradesmen;

所以基本上数据库中的每一行都有一个子查询(50,000+).现在每个商人可能会有大约1,000到2,000个报价.

所以我可以使用这个子查询来计算它们.

要么,

我可以做查询以获得所有的商人.

select tradesman.id from tradesmen;

执行一个查询以获取所有引号计数

select tradesman_id as id, count(quotes.id) as quotes from quotes group by tradesman_id;

然后循环每个商人并从数组中拉出每个商人的计数.

mysql有多快？第二种方法会提供显着的好处,还是两种方法都可以接受？

一般参考我的实际查询是:

SELECT 
    tradesmen.*, 
    regions.name AS region_name, 
    GROUP_CONCAT(ptypes_tradesmen.ptype_id SEPARATOR '|') AS ptype_ids, 
    (SELECT 
         COUNT(quotes.id) 
     FROM 
         quotes 
     WHERE 
         quotes.tradesman_id = tradesmen.id
    ) AS quoted, 
    (SELECT 
         COUNT(quote_intentions.id) 
     FROM 
         quote_intentions 
     WHERE 
         quote_intentions.tradesman_id = tradesmen.id
    ) AS intended, 
    (SELECT 
         COUNT(quotes.id) FROM quotes 
     WHERE 
         quotes.tradesman_id = tradesmen.id 
         AND …

我正在学习mysql手册:http: //dev.mysql.com/doc/refman/5.6/en/example-maximum-column-group-row.html我和"where.s1.article =混淆了s2.article'部分,这是什么意思？

Task: For each article, find the dealer or dealers with the most expensive price.

+---------+--------+-------+
| article | dealer | price |
+---------+--------+-------+
|    0001 | A      |  3.45 |
|    0001 | B      |  3.99 |
|    0002 | A      | 10.99 |
|    0003 | B      |  1.45 |
|    0003 | C      |  1.69 |
|    0003 | D      |  1.25 |
|    0004 | D      | 19.95 |
+---------+--------+-------+


SELECT article, …

(可能是重复但我只能通过JOIN找到问题和解决方案,[3]而且这不是一个选项.)

我有两张桌子.非常薄(很少列)和很长(很多行).一个是数据表(articles),一个是ACL表(acl).

我想只显示我可以访问的文章acl.some_id.哪个子查询更快？

[1]
SELECT a.title
FROM articles a
WHERE 0 < (
  SELECT COUNT(1)
  FROM acl
  WHERE article_id = a.id AND some_id IN (1, 2, 3)
)

要么

[2]
SELECT a.title
FROM articles a
WHERE a.id IN (
  SELECT article_id
  FROM acl WHERE some_id IN (1, 2, 3)
)

我的想法会说第二个,因为子查询可以重用于所有可能匹配的行,因此只会执行一次(虽然结果集会非常大),而第一个子查询必须检查每个潜在的匹配行.

还有第三种方法,但这不是一种选择,因为它会复制行(而GROUP BY不是解决方案,因为我以后需要COUNT用于其他东西(而且DISTINCT永远不是解决方案!)):

[3]
SELECT a.title
FROM articles a
JOIN acl
  ON acl.article_id = a.id
WHERE acl.some_id IN …

我想生成以下数据集以用于DataTables.为了使过滤和排序正常工作,使用JOINS而不是子查询是困难的,如果不是不可能的话(据我所知).

申请人姓名,职位,面试官,面试1分,面试2分,演示.分数,面试日期

以下是数据在mySQL(简化版)中的存储方式:

applicant_scores表

id  applicant_id    interviewer_id  score_type  score   datetime_recorded
 1             2                 3  Interview 1    80   2013-04-23 09:35:48
 2             2                45  Interview 1    70   2013-04-23 10:14:23
 3             2                 3  Interview 2    85   2013-04-23 09:35:48
 4             2                45  Interview 2    77   2013-04-23 10:14:23
 5             2                 3  Demonstration  76   2013-04-23 09:35:48
 6             3                45  Interview 1    79   2013-04-23 10:14:23
 7             3                 3  Interview 1    86   2013-04-23 09:35:48
 8             3                45  Interview 2    92   2013-04-23 10:14:23

申请人表

id  first_name  last_name
 2  John        Doe …

我有一个名为Object的模型(这并不重要)

它有一个默认价格(列称为"价格").

然后有一个Schedule对象允许覆盖特定日期的价格.

我希望能够在SQL查询期间确定MINIMUM价格(根据定义,默认值和"当前"价格之间的最小值),以便能够按计算的最低价格进行排序

我想让我的搜索查询尽可能高效,我想知道我是否可以这样做:

Object.select("id AS p_id, id, (SELECT MIN(`schedules`.`price`) FROM `schedules` WHERE `schedules`.`object_id` = p_id`) AS objects.min_price").limit(5)

但是,它会生成一个奇怪的SQL,如下所示:

SELECT `objects`.`id` AS t0_r0, `objects`.`title` AS t0_r1, `objects`.`created_at` AS t0_r2, `objects`.`updated_at` AS t0_r3, `objects`.`preferences` AS t0_r4 ........ (a lot of columns here) ... ` WHERE `objects`.`id` IN (1, 2, 3, 4 ....)

所以,你可以看到它不起作用.首先 - 它加载对象表中的所有列,其次 - 它看起来很糟糕.

我不想使用finder_sql的原因是我有很多可选参数和东西,所以在获取结果本身之前使用AR :: Relation对象是非常优选的.

除了上面提到的,我在DB中有很多记录,我认为将它们全部加载到内存中并不是一个好主意,这也是我想要执行这个子查询的主要原因 - 只是过滤掉尽可能多的记录.

有人可以帮助我更有效地做到这一点吗？

我想让工作人员level等于"高级".我想将用户表与员工合并,因为它包含有关员工的常见信息,如姓名,电子邮件等.

目前我在Eloquent中使用它:

$results = User::with(array('staff' => function($query) {
    $query->where('level', 'Senior');
}))->all();

如果我运行这个我获得所有用户虽然级别不等于高级,但我可以在数组中看到人员对象是空的.

目前我做空检查以丢弃不匹配的记录.

反正有没有以更好的方式实现它,所以当我在子查询中过滤一些东西时,主查询将只返回匹配的结果数组,所以我不必再进行任何空检查.

我按行和起点使用以下用于查询数据的代码:

SELECT InquiryId
FROM (select InquiryId,  ROW_NUMBER() over (order by InquiryId) as Seq 
from [InquiryTable] WITH(NOLOCK)
where InquiryId >= 100 and InquiryId <= 200)t
where Seq Between 1 and 20

什么是字符't'意味着在SQL服务器的第四行的末尾？

谢谢