标签: having-clause

问题是这个......

表是这个..

+--------------------------+---------+------+-----+---------+----------------+
| Field                    | Type    | Null | Key | Default | Extra          |
+--------------------------+---------+------+-----+---------+----------------+
| facility_map_id          | int(10) | NO   | PRI | NULL    | auto_increment |
| facility_map_facility_id | int(10) | NO   | MUL | NULL    |                |
| facility_map_listing_id  | int(10) | NO   |     | NULL    |                |
+--------------------------+---------+------+-----+---------+----------------+

这是数据..

+-----------------+--------------------------+-------------------------+
| facility_map_id | facility_map_facility_id | facility_map_listing_id |
+-----------------+--------------------------+-------------------------+
|             248 |                        1 |                      18 |
|             259 |                        1 |                      19 |
|             206 …

我有下表

CREATE TABLE Test
    (`Id` int, `value` varchar(20), `adate` varchar(20))
;

INSERT INTO Test
    (`Id`, `value`, `adate`)
VALUES
    (1, 100, '2014-01-01'),
    (1, 200, '2014-01-02'),
    (1, 300, '2014-01-03'),
    (2, 200, '2014-01-01'),
    (2, 400, '2014-01-02'),
    (2, 30 , '2014-01-04'),
    (3, 800, '2014-01-01'),
    (3, 300, '2014-01-02'),
    (3, 60 , '2014-01-04')
;

我想实现只选择具有最大日期值的Id的结果.即

Id,价值,adate

 1, 300,'2014-01-03'     
 2, 30 ,'2014-01-04'     
 3, 60 ,'2014-01-04'

我怎样才能实现这个目的group by？我做了如下但不起作用.

Select Id,value,adate
from Test
group by Id,value,adate
having adate = MAX(adate)

有人可以帮助查询吗？

如果我中创建一个别名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'; 

这有效.为什么这样？

我有三张桌子:

author (columns: aut_id, aut_name)
book (columns: book_id, book_title)
authorbook (linking table, columns: aut_id, book_id)

每个作者都可以与一本或多本书相关联.
每本书都可以与一位或多位作者联系.
我想根据名称和作者的确切数量来选择一本书.

表结构:

author    
aut_id    |   aut_name
1             Aname
2             Bname
3             Cname

book    
book_id    |  book_title (the titles are identical on purpose) 
1             Atitle
2             Atitle
3             Atitle

authorbook
aut_id    |   book_id 
1             1
1             2
2             2
1             3
2             3
3             3

这是我的代码(我遗漏了作者表以便更好地澄清):

SELECT authorbook.book_id 
FROM authorbook 
INNER JOIN book
ON authorbook.book_id = book.book_id
WHERE book_title='Atitle'
AND FIND_IN_SET (authorbook.aut_id,'1,2')
GROUP BY …

我按照标准做法的理解是， HAVING 将与 GROUP BY 一起用于过滤条件，而 WHERE 应该用于一般的按行过滤条件。

然而，关于是否使用 HAVING 作为 WHERE 子句的超集，在线讨论的结论不一。也就是说，它是否可以在没有 GROUP BY 的情况下使用，在这种情况下它作为 WHERE 子句工作。

我想了解在 Oracle、Microsoft SQL 服务器、MySQL、PostGreSQL 和其他工具中使用 HAVING 子句的行业实践是什么。

我在执行此查询时观察到的一件有趣的事情：

SELECT *
FROM SH.SALES
WHERE amount_sold > 1000
HAVING amount_sold < 2000;

它在 Oracle SQL 开发人员桌面中执行时出错，而在 Oracle SQL 开发人员 Web 中成功运行。

1. 我有一些查询获取将来将要删除的行的ID号。
2. 行号放入字符串中，并放在下面的查询中（在此处看到“ 2”）。

3. 我希望结果忽略行（好像它们已被删除）。

   SELECT MAX(T1.id) AS MAXid
   FROM transactions AS T1 
   WHERE id NOT IN ( 2 ) 
   GROUP BY T1.position 
   ORDER BY T1.position
   

   Run Code Online (Sandbox Code Playgroud)

我的猜测是我需要将“ WHERE”行替换为“ HAVING”，但是找不到“ NOT HAVING”语法。

当前编写此查询的方式，如果在WHERE子句中列出了该职位的最大ID，则不会为T1.position返回一行。

在忽略WHERE子句中列出的ID的行时，如何获取此查询以为T1.position提供最大ID？

根据所有示例,SQL转换为LINQ for HAVING子句,如下例所示:

SELECT NAME
FROM TABLES
GROUP BY NAME
HAVING COUNT(*) > 1

是:(vb.net)

from t in tables 
group t by t.NAME into g = Group 
where g.count > 1 
select g

但是上面的LINQ语句被翻译成以下SQL:

SELECT [t1].[NAME] AS [Key]
FROM (
    SELECT COUNT(*) AS [value], [t0].[NAME]
    FROM [tables] AS [t0]
    WHERE [t0].[NAME] <> @p0
    GROUP BY [t0].[NAME]
    ) AS [t1]
WHERE [t1].[value] > @p1

我从未成功生成LINQ的HAVING子句.假设使用WHERE的HAVING和子查询分组在结果中是等价的,但是性能有差异吗？那么保持我的原始SQL查询至少与LINQ生成底层的SIMILAR一样？

我正在尝试使用NHibernate的Criteria API来编写相当于这个:

select foo_id from foo_history
group by foo_id
having sum(bar_in) > 0 or sum(baz_in) > 0;

使用此映射:

<?xml version="1.0" encoding="utf-8" ?>
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2" assembly="MVC"
                   namespace="MVC.Model.Things">
  <class name="MVC.Model.Things.FooHistory, MVC"
         table="foo_history">
    <id name="ID" column="foo_hist_id" type="guid"
        unsaved-value="00000000-0000-0000-0000-000000000000">
      <generator class="guid.comb" />
    </id>

    <!-- Properties -->
    <property name="BarIn" column="bar_in" type="decimal"
              precision="19" scale="4" not-null="true" />
    <property name="BazIn" column="baz_in" type="decimal"
              precision="19" scale="4" not-null="false" />

    <!-- Foreign Keys -->
    <many-to-one name="Foo" column="foo_id"
                 class="MVC.Model.Things.Foo, MVC.Model.Things"
                 not-null="true" />
  </class>
</hibernate-mapping>

和这个Criteria代码(分离,因为它将是一个子查询):

var results = DetachedCriteria.For<FooHistory>("fh")
    .SetProjection(Projections.ProjectionList()
        .Add(Projections.GroupProperty(Projections.Id()))
        .Add(Projections.Sum("fh.BarIn"))
        .Add(Projections.Sum("fh.BazIn"))) …

对于我的生活,我似乎无法让这个工作.

假设我们的实体是一个具有状态字段和订单字段的托管对象.

我如何获得所有有序多个订单相同的订单？

请不要回答告诉我在主谓词中用@count做一个子查询,因为我知道这个解决方案,这篇文章的重点是要理解如何在核心数据中使用having谓词,这可能比一个更快无论如何都是子查询.(除非你解释为什么我不能使用having子句)

以下代码将返回一个字典数组,其中包含每个订单号的订单数.我想要的是能够添加一个having子句来限制我的请求只返回表示那些计数大于1的订单的对象的字典.

这是到目前为止的代码和我对谓词的尝试:

NSFetchRequest *fetchRequest = [[NSFetchRequest alloc] init];
NSEntityDescription *entity = [NSEntityDescription entityForName:@"OrderedEntry"
                                          inManagedObjectContext:context];
[fetchRequest setEntity:entity];
[fetchRequest setResultType:NSDictionaryResultType];

NSPredicate *predicate = [NSPredicate predicateWithFormat:
                 @"(status == %@)",[NSNumber numberWithInt:EntryStatusAlive]];


[fetchRequest setPredicate:predicate];


NSExpression *keyPathExpression = [NSExpression expressionForKeyPath: @"order"]; // Does not really matter
NSExpression *maxExpression = [NSExpression expressionForFunction: @"count:"
                                                        arguments: [NSArray arrayWithObject:keyPathExpression]];
NSExpressionDescription *expressionDescription = [[NSExpressionDescription alloc] init];
[expressionDescription setName: @"orderCount"];
[expressionDescription setExpression: maxExpression]; 
[expressionDescription setExpressionResultType: NSInteger32AttributeType];

[fetchRequest setPropertiesToFetch: [NSArray arrayWithObjects:expressionDescription,@"order",nil]];


[fetchRequest setPropertiesToGroupBy:[NSArray arrayWithObjects:@"order",nil]];
//[fetchRequest setHavingPredicate:[NSPredicate predicateWithFormat:@"@count > 1"]]; …

我有三张桌子

• country_table： id int, country_name string
• city_table： id int, city_name string, postal_code int, country_id int
• customer_table： id int, customer_name string, city_id id, customer_address string

我正在寻找一个答案，该答案将返回客户数量超过所有城市平均客户数量的所有城市。对于每个这样的城市，返回国家名称、城市名称、客户数量。

输出应该是

country_name, city_name, count

我尝试使用子查询，但出现错误

country_name, city_name, count

非常感谢任何帮助