How CROSS JOINs Affect PostgreSQL Query Performance and Ways to Improve It

The Effects of CROSS JOINs on PostgreSQL Performance and How to Enhance It


4 min read

CROSS JOINs in PostgreSQL (or any other database system) can have a significant impact on query performance, even if efficient indexing is in place. This is because CROSS JOINs generate a Cartesian product of the rows from the joined tables, leading to an exponential increase in the number of rows processed.

Understanding CROSS JOIN Impact

A CROSS JOIN returns every possible combination of rows from the two tables. For example, if you have two tables, A with m rows and B with n rows, the result of a CROSS JOIN will have m * n rows.

Performance Considerations

  1. Exponential Growth of Rows:

    • The number of rows produced by a CROSS JOIN grows exponentially with the size of the input tables. This can quickly become unmanageable for large tables.

    • Example: Joining a table with 1,000 rows with another table with 1,000 rows results in 1,000,000 rows.

  2. Increased Memory and CPU Usage:

    • The database needs to allocate more memory and CPU resources to handle the large number of rows generated by the CROSS JOIN.

    • This can lead to higher processing times and potential resource contention with other operations.

  3. Impact on Disk I/O:

    • The increased number of rows can result in higher disk I/O as the database reads more data from disk and writes intermediate results.

    • Even with efficient indexing, the sheer volume of data can overwhelm the system's I/O capabilities.

  4. Query Execution Time:

    • The execution time of queries involving CROSS JOINs can be significantly longer due to the large intermediate result sets.

    • Sorting, aggregating, or further processing the results of a CROSS JOIN can further exacerbate performance issues.

Example Scenario

Let's consider two tables: employees with 1,000 rows and departments with 10 rows.

Schema and Sample Data

CREATE TABLE employees (
    employee_id SERIAL PRIMARY KEY,
    employee_name VARCHAR(100)

CREATE TABLE departments (
    department_id SERIAL PRIMARY KEY,
    department_name VARCHAR(100)

-- Insert sample data
INSERT INTO employees (employee_name)
SELECT 'Employee ' || generate_series(1, 1000);

INSERT INTO departments (department_name)
SELECT 'Department ' || generate_series(1, 10);

Query with CROSS JOIN

SELECT e.employee_name, d.department_name
FROM employees e
CROSS JOIN departments d;

Expected Output:

The output of the EXPLAIN ANALYZE will show the number of rows and the time taken to execute the query.

Nested Loop  (cost=0.00..12500.00 rows=10000 width=64) (actual time=0.014..45.631 rows=10000 loops=1)
  ->  Seq Scan on employees e  (cost=0.00..15.00 rows=1000 width=32) (actual time=0.003..4.151 rows=1000 loops=1)
  ->  Materialize  (cost=0.00..0.20 rows=10 width=32) (actual time=0.000..0.019 rows=10 loops=1000)
        ->  Seq Scan on departments d  (cost=0.00..0.10 rows=10 width=32) (actual time=0.005..0.007 rows=10 loops=1)
Planning Time: 0.115 ms
Execution Time: 45.695 ms

Mitigating the Impact

  1. Avoid Unnecessary CROSS JOINs:

    • Ensure CROSS JOINs are necessary for your query logic. Often, a different type of join (INNER, LEFT, RIGHT) might be more appropriate.
  2. Filter Before Joining:

    • Apply filters to reduce the number of rows before performing the join. This can significantly reduce the size of the Cartesian product.

    • Example: Filtering employees by a specific criterion before joining with departments.

    SELECT e.employee_name, d.department_name
    FROM employees e
    CROSS JOIN departments d
    WHERE e.employee_id <= 100;  -- Filtering before joining
  1. Use JOIN Conditions:

    • When possible, use appropriate join conditions to limit the result set.

    • Example: If there's a logical relationship between the tables, use an INNER JOIN with a condition.

  2. Indexing:

    • While indexing doesn't directly reduce the size of the result set in a CROSS JOIN, it can help in quickly retrieving the relevant rows, especially when filters are applied before the join.


CROSS JOINs in PostgreSQL can lead to significant performance degradation due to the exponential growth of the result set, increased memory and CPU usage, and higher disk I/O. Even with efficient indexing, the sheer volume of data generated by a CROSS JOIN can overwhelm system resources. It's crucial to carefully consider whether a CROSS JOIN is necessary and to apply strategies such as filtering, using appropriate join conditions, and avoiding unnecessary CROSS JOINs to mitigate performance issues.