无法通过非ID列执行Postgres分组，以获取包含最大值的ID

Question

I'm attempting to perform a GROUP BY on a join table table. The join table essentially looks like:

CREATE TABLE user_foos (
    id SERIAL PRIMARY KEY,
    user_id INT NOT NULL,
    foo_id INT NOT NULL,
    effective_at DATETIME NOT NULL
);
ALTER TABLE user_foos
    ADD CONSTRAINT user_foos_uniqueness
    UNIQUE (user_id, foo_id, effective_at);

I'd like to query this table to find all records where the effective_at is the max value for any pair of user_id, foo_id given. I've tried the following:

SELECT "user_foos"."id",
       "user_foos"."user_id",
       "user_foos"."foo_id",
       max("user_foos"."effective_at")
FROM "user_foos"
GROUP BY "user_foos"."user_id", "user_foos"."foo_id";

Unfortunately, this results in the error:

column "user_foos.id" must appear in the GROUP BY clause or be used in an aggregate function

I understand that the problem relates to "id" not being used in an aggregate function and that the DB doesn't know what to do if it finds multiple records with differing ID's, but I know this could never happen due to my trinary primary key across those columns ( user_id , foo_id , and effective_at ).

To work around this, I also tried a number of other variants such as using the first_value window function on the id :

SELECT first_value("user_foos"."id"),
       "user_foos"."user_id",
       "user_foos"."foo_id",
       max("user_foos"."effective_at")
FROM "user_foos"
GROUP BY "user_foos"."user_id", "user_foos"."foo_id";

and:

SELECT first_value("user_foos"."id")
FROM "user_foos"
GROUP BY "user_foos"."user_id", "user_foos"."foo_id"
HAVING "user_foos"."effective_at" = max("user_foos"."effective_at")

Unfortunately, these both result in a different error:

window function call requires an OVER clause

Ideally, my goal is to fetch ALL matching id 's so that I can use it in a subquery to fetch the legitimate full row data from this table for matching records. Can anyone provide insight on how I can get this working?

Answer 1

Postgres has a very nice feature called distinct on , which can be used in this case:

SELECT DISTINCT ON (uf."user_id", uf."foo_id") uf.*
FROM "user_foos" uf
ORDER BY uf."user_id", uf."foo_id", uf."effective_at" DESC;

It returns the first row in a group, based on the values in parentheses. The order by clause needs to include these values as well as a third column for determining which is the first row in the group.

Answer 2

Try:

SELECT *
FROM (
  SELECT t.*,
         row_number() OVER( partition by user_id, foo_id ORDER BY effective_at DESC ) x
  FROM user_foos t
)
WHERE x = 1

Answer 3

If you don't want to use a sub query based on a composite of all three keys then you need to create a "dense rank" window function field that orders subsets of id, user_id and foo_id by effective date with the rank order field. Then subquery that and take the records where rank_order=1. Since the rank ordering was by effective date you are getting all fields of the record with the highest effective date for each foo and user.

DATSET
1 1 1 01/01/2001
2 1 1 01/01/2002
3 1 1 01/01/2003
4 1 2 01/01/2001
5 2 1 01/01/2001

DATSET WITH RANK ORDER PARTITIONED BY FOO_ID, USER_ID ORDERED BY DATE DESC
1 3 1 1 01/01/2001
2 2 1 1 01/01/2002
3 1 1 1 01/01/2003
4 1 1 2 01/01/2001
5 1 2 1 01/01/2001

SELECT * FROM QUERY ABOVE WHERE RANK_ORDER=1
3 1 1 1 01/01/2003
4 1 1 2 01/01/2001
5 1 2 1 01/01/2001