Show the First N Rows for Each Group in PostgreSQL: Window Functions vs. Lateral JOIN

sql postgresql


You have a table with data, and you want to retrieve the top N (let's say N = 2) rows for each group based on a specific column. For instance, you might have an employees table with columns like department and salary, and you'd like to see the two highest-paid employees from each department.


PostgreSQL offers a couple of effective approaches to achieve this:

  1. Window Functions (Recommended):

    • This method is generally preferred due to its clarity, efficiency, and broader applicability. It leverages window functions like ROW_NUMBER() or DENSE_RANK().
    • Here's the syntax:
    SELECT *
    FROM (
        SELECT your_column1, your_column2,
               ROW_NUMBER() OVER (PARTITION BY grouping_column ORDER BY order_column DESC) AS row_num
        FROM your_table
    ) AS subquery
    WHERE row_num <= N;
    • Explanation:
      • We create a subquery to assign a row number (row_num) to each row within each group defined by grouping_column.
      • The ORDER BY clause sorts the rows in descending order based on order_column (e.g., salary for highest-paid).
      • The outer query then selects rows where row_num is less than or equal to N (in this case, 2), effectively retrieving the top N rows for each group.
  2. Lateral JOIN (Alternative):

    • This method is less common but can be useful in specific situations. It involves a lateral join to fetch the desired rows from the same table.
    SELECT t_outer.grouping_column, t_top.your_column1, t_top.your_column2
    FROM your_table AS t_outer
        SELECT *
        FROM your_table AS t_inner
        WHERE t_inner.grouping_column = t_outer.grouping_column
        ORDER BY order_column DESC
        LIMIT N
    ) AS t_top ON true
    ORDER BY t_outer.grouping_column;
    • Explanation:
      • We use a lateral join to create a temporary result set (t_top) containing the top N rows for each group defined by grouping_column.
      • The ORDER BY clause within the lateral join sorts the rows in descending order based on order_column.
      • The LIMIT N clause restricts the result set to the top N rows for each group.
      • The outer query then joins t_outer with t_top and selects the desired columns.

Choosing the Right Method:

  • Window functions are generally the preferred approach for their clarity and efficiency, especially for larger datasets.
  • Lateral joins might be considered in certain scenarios where you need more control over the subquery or have limitations with your PostgreSQL version (pre-8.4).


  • Replace your_column1, your_column2, grouping_column, and order_column with the actual column names from your table.
  • Adjust N to the desired number of top rows to retrieve for each group.

Example 1: Using Window Functions (Recommended)

-- Sample table (employees)
CREATE TABLE employees (
  department varchar(20),
  salary integer,
  name varchar(50)

-- Sample data
INSERT INTO employees (department, salary, name)
VALUES ('Sales', 80000, 'John'),
       ('Sales', 75000, 'Jane'),
       ('Marketing', 90000, 'Alice'),
       ('Marketing', 85000, 'Bob'),
       ('Engineering', 100000, 'David'),
       ('Engineering', 95000, 'Emily');

-- Get top 2 highest-paid employees from each department
SELECT department, name, salary
    SELECT department, name, salary,
           ROW_NUMBER() OVER (PARTITION BY department ORDER BY salary DESC) AS row_num
    FROM employees
) AS subquery
WHERE row_num <= 2;

This code will output:

 department |  name  | salary 
 Engineering | David | 100000
 Engineering | Emily |  95000
 Marketing  | Alice |  90000
 Marketing  | Bob   |  85000
 Sales       | John  |  80000
 Sales       | Jane  |  75000

Example 2: Using Lateral JOIN (Alternative)

-- Same sample table (employees) from Example 1

-- Get top 2 highest-paid employees from each department
SELECT e.department, t.name, t.salary
FROM employees AS e
    SELECT *
    FROM employees AS t
    WHERE t.department = e.department
    ORDER BY salary DESC
    LIMIT 2
) AS t ON true
ORDER BY e.department;

This code will also output the same results as the first example.

Key Points:

  • Both methods achieve the same goal of retrieving the top N rows for each group.
  • The window function approach is generally more concise and efficient.
  • Choose the method that best suits your specific needs and PostgreSQL version.

  1. Recursive Common Table Expression (CTE) (Advanced):

    • This method is more complex and might be less performant for large datasets. It involves a recursive CTE that iterates through distinct group values and retrieves the first N rows for each group.
        SELECT DISTINCT grouping_column, 1 AS level
        FROM your_table
        UNION ALL
        SELECT yt.grouping_column, c.level + 1 AS level
        FROM your_table yt
        JOIN cte c ON c.grouping_column = yt.grouping_column
        WHERE c.level < N
    SELECT yt.*
    FROM your_table yt
    JOIN cte c ON c.grouping_column = yt.grouping_column
    WHERE c.level = 1;
    • Explanation:
      • The CTE (cte) recursively iterates, building a hierarchy of distinct group values with increasing level.
      • The outer query then joins your_table with cte and selects rows where level is 1, effectively retrieving the first row for each group. However, this can be extended to retrieve the first N rows by adjusting the conditions and joining logic within the CTE.
  2. DISTINCT ON and LIMIT (PostgreSQL-specific):

    • This method leverages the DISTINCT ON clause, which is specific to PostgreSQL and not part of the standard SQL language. It allows selecting distinct rows based on a specified column and then applying a LIMIT clause.
    SELECT *
    FROM (
        SELECT DISTINCT ON (grouping_column) your_column1, your_column2
        FROM your_table
        ORDER BY grouping_column, order_column
        LIMIT N
    ) AS subquery;
    • Explanation:
      • DISTINCT ON ensures we only get distinct rows based on grouping_column.
      • The ORDER BY clause sorts the rows within each group.

Choosing the Right Alternative Method:

  • The recursive CTE approach is less common and might be less efficient for large datasets. It's generally used for more complex scenarios where other methods are not suitable.
  • DISTINCT ON with LIMIT is a PostgreSQL-specific solution and might not be portable to other SQL databases.


  • Adapt the column names and ordering criteria in the examples to match your table structure.
  • Consider the performance implications of each method, especially for large datasets. The window function approach is often the most performant choice.

sql postgresql

Finding Rows with Maximum Values Partitioned by Another Column in MySQL

Using Subqueries with Inner Joins:This method involves creating a subquery to find the maximum value for the target column within each group (defined by the partition column). Then...

Generating Unique Identifiers (UUIDs) in PostgreSQL Inserts

Understanding UUIDs:Universally Unique Identifiers (UUIDs) are 128-bit numbers that are highly likely to be unique across space and time...

From Bulk Exports to Precise Selections: Your Guide to PostgreSQL Row Export Options

pg_dump with filtering: This powerful tool can dump entire tables or specific data. Use the --where option to filter rows based on a condition (e.g., --where "city = 'New York'"). Combine with --data-only and --column-inserts for INSERT statements:...

Troubleshooting the "psql: FATAL: role \"postgres\" does not exist" Error in macOS PostgreSQL

Understanding the "psql: FATAL: role "postgres" does not exist" Error in macOS PostgreSQLIntroduction:When attempting to connect to a PostgreSQL database using the psql command on your macOS system...