Sql 我们希望每个客户有一行，由附加标准定义，如“id最小的一行”。要修复此问题，请将id附加到orderby列表中的行编号（）。然后，您将得到与第二次查询相同的结果，对于这种情况，这是非常低效的。此外，每增加一列，您都需要另一个子查询。Google的BigQu

---

---

我们希望每个客户有一行，由附加标准定义，如“id<代码>最小的一行”。要修复此问题，请将

id

附加到

orderby

列表中的

行编号（）。然后，您将得到与第二次查询相同的结果，对于这种情况，这是非常低效的。此外，每增加一列，您都需要另一个子查询。Google的BigQuery还支持第一个查询的ROW_NUMBER（）命令。对于usNote来说，这是一个很好的解决方案。请注意，第一个带有窗口功能的版本与SQLite 3.25.0版一样工作：这对于大多数数据库大小来说都是一个很好的解决方案，但是我想指出，当您接近

上的~1000000行

时，速度会变得非常慢。实现总是对整个表进行排序，并在其中扫描重复项，忽略所有索引（即使您已经创建了所需的多列索引）。有关可能的解决方案，请参阅。使用序数“缩短代码”是一个糟糕的想法。把列名留在里面让它可读怎么样？@KOTJMF：那我建议你按照你个人的喜好去做。我展示了两种教育方式。语法速记对于
SELECT
列表中的长表达式很有用。@jangorecki:最初的基准是从2011年开始的，我不再有这个设置了。但无论如何，现在是时候用第9.4页和第9.5页进行测试了。您可以在下面添加一条评论，其中包含您安装的结果？@PirateApp:不是从我的头顶上
DISTINCT ON
仅适用于每组同龄人获得一行。感谢您提供了一个出色的基准测试。我想知道，如果查询具有时间戳而不是总计的事件数据，是否会受益于新的BRIN索引。这可能会加快时态查询的速度。@jangorecki:任何包含物理排序数据的大型表都可以从BRIN索引中获益。@ErwinBrandstetter在
2中。行号（）
和
5。带有横向
示例的客户表，什么可以确保id最小？@ArtemNovikov:没有。目标是根据
customer\u id
检索总计
最高的行。在问题的测试数据中，所选行中的
id
恰好也是每个
customer\u id
@ArtemNovikov:允许仅索引扫描的最小值，这是一个误导性的巧合。USING子句非常标准。只是一些小的数据库系统没有它。这并没有发现使用这种自定义函数方法的客户购买的最大总数。足够普遍和简单。为什么要把事情复杂化呢？这是不是比其他解决方案的性能要差得多？谢谢！这非常好用，并且很容易理解和实现。因为您只查找最大的一个，为什么不查询
MAX（total）
？@phil294查询MAX（total）将不会将该合计与发生它的行的“id”值相关联。这是否回答了您的问题？如果有人想
分组+加入行数据
，请查看是否有两篇价格相同的文章，这两篇文章都将在此处选择。因此，如果目的是通过子句使每组返回一行，那么这是行不通的。但是，如果目的是让所有行都满足max-price标准，那么很好。仅供参考，在DB2上，我们不需要“row”语句。
id | customer | total
---+----------+------
 1 | Joe      | 5
 2 | Sally    | 3
 3 | Joe      | 2
 4 | Sally    | 1
FIRST(id) | customer | FIRST(total)
----------+----------+-------------
        1 | Joe      | 5
        2 | Sally    | 3
WITH summary AS (
    SELECT p.id, 
           p.customer, 
           p.total, 
           ROW_NUMBER() OVER(PARTITION BY p.customer 
                                 ORDER BY p.total DESC) AS rank
      FROM PURCHASES p)
 SELECT *
   FROM summary
 WHERE rank = 1

  SELECT MIN(x.id),  -- change to MAX if you want the highest
         x.customer, 
         x.total
    FROM PURCHASES x
    JOIN (SELECT p.customer,
                 MAX(total) AS max_total
            FROM PURCHASES p
        GROUP BY p.customer) y ON y.customer = x.customer
                              AND y.max_total = x.total
GROUP BY x.customer, x.total

SELECT DISTINCT ON (customer)
       id, customer, total
FROM   purchases
ORDER  BY customer, total DESC, id;
SELECT DISTINCT ON (2)
       id, customer, total
FROM   purchases
ORDER  BY 2, 3 DESC, 1;

...
ORDER  BY customer, total DESC NULLS LAST, id;
CREATE INDEX purchases_3c_idx ON purchases (customer, total DESC, id);

select * from purchases p1 where total in
(select max(total) from purchases where p1.customer=customer) order by total desc;

SELECT a.* 
FROM
    purchases a 
    JOIN ( 
        SELECT customer, min( id ) as id 
        FROM purchases 
        GROUP BY customer 
    ) b USING ( id );

create index purchases_id on purchases (id);

SELECT  customer,
        (array_agg(id ORDER BY total DESC))[1],
        max(total)
FROM purchases
GROUP BY customer

-- Create a function that always returns the first non-NULL item
CREATE OR REPLACE FUNCTION public.first_agg ( anyelement, anyelement )
RETURNS anyelement LANGUAGE sql IMMUTABLE STRICT AS $$
        SELECT $1;
$$;

-- And then wrap an aggregate around it
CREATE AGGREGATE public.first (
        sfunc    = public.first_agg,
        basetype = anyelement,
        stype    = anyelement
);

-- Create a function that always returns the last non-NULL item
CREATE OR REPLACE FUNCTION public.last_agg ( anyelement, anyelement )
RETURNS anyelement LANGUAGE sql IMMUTABLE STRICT AS $$
        SELECT $2;
$$;

-- And then wrap an aggregate around it
CREATE AGGREGATE public.last (
        sfunc    = public.last_agg,
        basetype = anyelement,
        stype    = anyelement
);

SELECT FIRST(id), customer, FIRST(total)
FROM  purchases
GROUP BY customer
ORDER BY FIRST(total) DESC;

apt-get install postgresql-server-dev-9.3 git build-essential -y
git clone git://github.com/wulczer/first_last_agg.git
cd first_last_app
make && sudo make install
psql -c 'create extension first_last_agg'

http://www.postgresql.org/docs/current/static/sql-expressions.html#SYNTAX-AGGREGATES

SELECT first(id order by id), customer, first(total order by id)
  FROM purchases
 GROUP BY customer
 ORDER BY first(total);

CREATE TABLE purchases (
  id          serial
, customer_id int  -- REFERENCES customer
, total       int  -- could be amount of money in Cent
, some_column text -- to make the row bigger, more realistic
);

CREATE INDEX purchases_3c_idx ON purchases (customer, total DESC, id);

select * from purchase
join (
    select min(id) as id from purchase
    join (
        select customer, max(total) as total from purchase
        group by customer
    ) t1 using (customer, total)
    group by customer
) t2 using (id)
order by customer

SELECT purchases.*
FROM purchases
LEFT JOIN purchases as p 
ON 
  p.customer = purchases.customer 
  AND 
  purchases.total < p.total
WHERE p.total IS NULL

LEFT JOIN purchases as p 
ON 
p.customer = purchases.customer 
AND 
purchases.total < p.total

+--------------+---------------------+-----------------+------+------------+---------+
| purchases.id |  purchases.customer | purchases.total | p.id | p.customer | p.total |
+--------------+---------------------+-----------------+------+------------+---------+
|            1 | Tom                 |             200 |    2 | Tom        |     300 |
|            2 | Tom                 |             300 |      |            |         |
|            3 | Bob                 |             400 |    4 | Bob        |     500 |
|            4 | Bob                 |             500 |      |            |         |
|            5 | Alice               |             600 |    6 | Alice      |     700 |
|            6 | Alice               |             700 |      |            |         |
+--------------+---------------------+-----------------+------+------------+---------+

WHERE p.total IS NULL
    
+--------------+----------------+-----------------+------+--------+---------+
| purchases.id | purchases.name | purchases.total | p.id | p.name | p.total |
+--------------+----------------+-----------------+------+--------+---------+
|            2 | Tom            |             300 |      |        |         |
|            4 | Bob            |             500 |      |        |         |
|            6 | Alice          |             700 |      |        |         |
+--------------+----------------+-----------------+------+--------+---------+

SELECT  
    (  
       SELECT **id** FROM t2   
       WHERE id = ANY ( ARRAY_AGG( tf.id ) ) AND amount = MAX( tf.amount )   
    ) id,  
    name,   
    MAX(amount) ma,  
    SUM( ratio )  
FROM t2  tf  
GROUP BY name

SELECT *
FROM (
SELECT ROW_NUMBER()
OVER(PARTITION BY customer
ORDER BY total DESC) AS StRank, *
FROM Purchases) n
WHERE StRank = 1

with
ids as ( --condition for split table into groups
    select i from (values (9),(12),(17),(18),(19),(20),(22),(21),(23),(10)) as v(i) 
) 
,src as ( 
    select * from yourTable where  <condition> --use this as filter for other conditions
)
,joined as (
    select tops.* from ids 
    cross apply --it`s like for each rows
    (
        select top(1) * 
        from src
        where CommodityId = ids.i 
    ) as tops
)
select * from joined

SELECT customer, (ARRAY_AGG(id ORDER BY total DESC))[1], MAX(total)
FROM purchases
GROUP BY customer

SELECT id, customer, total
FROM PURCHASES
QUALIFY ROW_NUMBER() OVER(PARTITION BY p.customer ORDER BY p.total DESC) = 1

select distinct customer_id,
                first_value(row(id, total)) over(partition by customer_id order by total desc, id)
from            purchases;

SELECT article, dealer, price
FROM   shop s1
WHERE  price=(SELECT MAX(s2.price)
              FROM shop s2
              WHERE s1.article = s2.article
              GROUP BY s2.article)
ORDER BY article;