标签: having

我有一个有3列的表:

userid   mac_address   count

一个用户的条目可能如下所示:

57193   001122334455   42
57193   000C6ED211E6   15
57193   FFFFFFFFFFFF   2

我想创建一个视图,只显示那些被认为对这个用户"常用"的MAC.例如,我想过滤掉与该用户最常用的MAC地址相比使用<10%的MAC.此外,我想要每个用户1行.这可以通过GROUP BY,HAVING和GROUP_CONCAT轻松实现:

SELECT userid, GROUP_CONCAT(mac_address SEPARATOR ',') AS macs, count
FROM mactable
GROUP BY userid
HAVING count*10 >= MAX(count)

事实上,结果如下:

57193   001122334455,000C6ED211E6   42

但是我真的不想在我的视图中使用count-column.但是如果我把它从SELECT语句中删除,我会收到以下错误:

#1054 - Unknown column 'count' in 'having clause'

有没有什么方法可以执行此操作,而不会被迫在我的视图中有一个令人讨厌的计数列？我知道我可以使用内部查询来做到这一点,但我想避免出于性能原因这样做.

非常感激您的帮忙!

SELECT  
CASE WHEN SUM(X.Count)*3600 is null THEN  '0'  
            ELSE  
            SUM(X.Count)*3600  
       END AS PJZ,  
       X.Mass  
FROM X  
WHERE X.Mass > 2000  
HAVING ((X.Mass / PJZ * 100) - 100) >= 10;

正在获取：错误：»pjz«列不存在。

我该怎么做？

今天早些时候我在这个问题上做了一点傻瓜.问题是使用SQL Server,正确的答案涉及添加一个HAVING子句.我犯的最初错误是认为SELECT语句中的别名可以在HAVING子句中使用,这在SQL Server中是不允许的.我犯了这个错误是因为我认为SQL Server与MySQL有相同的规则,它允许在HAVING子句中使用别名.

这让我很好奇,我在Stack Overflow和其他地方探索过,发现了一堆材料,解释了为什么在两个相应的RDBMS上强制实施这些规则.但我没有找到解释在该条款中允许/禁止别名的性能影响的解释HAVING.

举一个具体的例子,我将复制上述问题中出现的查询:

SELECT students.camID, campus.camName, COUNT(students.stuID) as studentCount
FROM students
JOIN campus
    ON campus.camID = students.camID
GROUP BY students.camID, campus.camName
HAVING COUNT(students.stuID) > 3
ORDER BY studentCount

在HAVING子句中使用别名而不是重新指定COUNT？的性能影响是什么？这个问题可以在MySQL中直接回答,希望有人可以深入了解SQL中如果支持该HAVING子句中的别名会发生什么.

这是一个罕见的实例,可以用MySQL和SQL Server标记SQL问题,所以在阳光下享受这一刻.

在MySQL中

select a,b,count(1) as cnt from list group by a, b having cnt > 2;

我必须使用mongodb中的条件来执行group by函数.但我得到以下错误.请分享您的意见.

在MongoDB中

> res = db.list.group({key:{a:true,b:true},
...                      reduce: function(obj,prev) {prev.count++;},
...                      initial: {count:0}}).limit(10);

Sat Jan  7 16:36:30 uncaught exception: group command failed: {
        "errmsg" : "exception: group() can't handle more than 20000 unique keys",
        "code" : 10043,
        "ok" : 0

一旦执行,我们需要在下一个文件上运行以下文件.

for (i in res) {if (res[i].count>2) printjson(res[i])};

此致,库马兰

我经常看到人们通过这样的查询回答MySQL问题:

SELECT DAY(date), other columns
FROM table
GROUP BY DAY(date);

SELECT somecolumn, COUNT(*)
FROM table
HAVING COUNT(*) > 1;

我总是喜欢给列添加一个别名,并在GROUP BYor HAVING子句中引用它,例如

SELECT DAY(date) AS day, other columns
FROM table
GROUP BY day;

SELECT somecolumn, COUNT(*) AS c
FROM table
HAVING c > 1;

MySQL是否足够聪明,可以注意到后面的子句中的表达式与in中的表达式相同SELECT,并且只执行一次？我不确定如何测试这个 - EXPLAIN没有显示任何差异,但它似乎并没有显示它是如何进行分组或过滤的; 它似乎主要用于优化连接和WHERE子句.

我倾向于对MySQL优化感到悲观,所以我想尽我所能给予它.

如何从下面的数据中选择像苹果和香蕉这样的人？

表:MyTable

persons |  fruit
-----------------------------
   P1       Apple
   P1       Banana
   P1       Mango
   P2       Banana
   P2       Apple
   P3       Mango   
   P3       Apple  

即在这种情况下,P1,P2应该是结果.

我试过了

select * from MyTable where fruit in("Apple","Banana");

这也是P3的结果,因为P3也有苹果.

谢谢你的帮助.

我正在尝试将以下 SQL 查询转换为相应的 Rust Diesel 代码：

SELECT COUNT(*)
FROM BookStore
WHERE BookName IN ('Lord of the Rings', 'Hobbit')
GROUP BY StoreId
HAVING COUNT(DISTINCT BookName) = 2

到目前为止我能够将其翻译为：

let bookNames = vec!["Lord of the Rings", "Hobbit"];

let subquery = bookStores::table
.select(count_star())
.filter(bookName.eq_any(bookNames));

我相信这可以翻译为：

SELECT COUNT(*)
FROM BookStore
WHERE BookName IN ('Lord of the Rings', 'Hobbit')

我无法找到GROUP BY和HAVINGSQL 子句的任何 Diesel 等效项。Diesel 中是否存在这些条款？

我是一个MySQL查询noobie所以我敢肯定这是一个明显答案的问题.

但是,我正在研究这两个问题.他们会返回不同的结果集吗？我知道排序过程会以不同的方式开始,但我相信它们会返回相同的结果,第一个查询的效率稍高一些吗？

查询1:HAVING,然后是AND

SELECT user_id   
FROM forum_posts  
GROUP BY user_id 
    HAVING COUNT(id) >= 100   
    AND user_id NOT IN (SELECT user_id FROM banned_users)

查询2:在哪里,然后是HAVING

SELECT user_id   
FROM forum_posts 
WHERE user_id NOT IN(SELECT user_id FROM banned_users) 
GROUP BY user_id 
    HAVING COUNT(id) >= 100   

如果我中创建一个别名select子句然后我不能在使用where条款,因为根据SQL查询的执行顺序where之前来select.

但我可以创建在一个别名select子句和它的使用having条款,虽然having来之前select.

为什么会这样？

例如:

select type, (case when number>25 then 1 else 0 end) inc 
from animals
where inc='1';

这不行.但,

select type, (case when number>25 then 1 else 0 end) inc 
from animals
having inc='1'; 

这有效.为什么这样？

Java (9+) 流是否支持HAVING类似于 SQL的子句？用例：分组然后删除具有特定计数的所有组。是否可以将以下 SQL 子句编写为 Java 流？

GROUP BY id
HAVING COUNT(*) > 5

我能想到的最接近的是：

input.stream()
        .collect(groupingBy(x -> x.id()))
        .entrySet()
        .stream()
        .filter(entry -> entry.getValue().size() > 5)
        .collect(toMap(Map.Entry::getKey, Map.Entry::getValue));

但是提取分组结果的entrySet来收集两次感觉很奇怪，尤其是终端collect调用基本上是将映射映射到自身。

我看到有collectingAndThen和filtering收藏家，但我不知道他们是否会解决我的问题（或者说如何正确地应用它们）。

是否有上述更好（更惯用）的版本，或者我是否坚持收集到中间地图，过滤然后收集到最终地图？