Question: How can you add an index concurrently in a PostgreSQL cluster?


Adding indexes concurrently in PostgreSQL is crucial for minimizing lock contention and allowing normal database operations to continue without significant disruption. This is especially important in a PostgreSQL cluster where multiple nodes might be serving high volumes of queries.

Why Concurrent Index Creation?

Creating an index on a large table can be time-consuming, and during this process, a standard CREATE INDEX would lock the table against writes (and possibly reads, depending on the type of lock). To avoid this, PostgreSQL allows the creation of indexes concurrently.

How to Create Indexes Concurrently

To create an index concurrently, you use the CONCURRENTLY keyword with the CREATE INDEX command. Here’s a basic example:

CREATE INDEX CONCURRENTLY idx_customer_name ON customers (name);

This statement creates an index on the name column of the customers table without locking out writes to the table.

Considerations for Concurrent Indexing in Clusters

In a PostgreSQL cluster setup (such as when using PostgreSQL with extensions like Citus or timescaleDB), the same principles apply. However, you should ensure that the indexing commands are issued in a way that recognizes the distributed nature of your data:

  1. Node-by-Node Execution: Depending on your cluster configuration and tooling, you may need to run the index creation script on each node individually, or there might be a central management tool that handles this for you.
  2. Load Balancing: Be aware of extra load due to index creation which might affect query performance across the cluster. It might be wise to create indexes during off-peak hours.

Additional Tips

  • Monitoring: Always monitor the performance of your database when creating indexes concurrently. Even though it allows other operations to proceed, it still consumes resources.
  • Locks: While CREATE INDEX CONCURRENTLY does not lock the entire table, it still requires some lighter locks. Check for any lock conflicts with other operations in your database.
  • Validation: After creating an index concurrently, it’s often a good idea to validate that the index is built correctly and is being used by your queries as expected. You can check the execution plan using EXPLAIN.

Using concurrent index creation helps maintain application performance and availability, particularly critical in high-load or clustered environments.

Was this content helpful?

White Paper

Free System Design on AWS E-Book

Download this early release of O'Reilly's latest cloud infrastructure e-book: System Design on AWS.

Free System Design on AWS E-Book
Start building today

Dragonfly is fully compatible with the Redis ecosystem and requires no code changes to implement.