# Lock: extend

> Waiting to extend a relation
---

<div class="event-kicker">PostgreSQL wait event dossier</div>
<div class="event-identity">
  <span>Class<strong>Lock</strong></span>
  <span>Event<strong><code>extend</code></strong></span>
  <span>Versions<strong>PG 13-18</strong></span>
  <span>Evidence<strong>3 source location(s)</strong></span>
</div>

## Official description {#official-description}

Waiting to extend a relation

| PG 13 | PG 14 | PG 15 | PG 16 | PG 17 | PG 18 |
| :---: | :---: | :---: | :---: | :---: | :---: |
| ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |

## Trigger mechanism {#mechanism}

`PG_WAIT_LOCK` at `src/backend/storage/lmgr/proc.c:1487` is the grep-verified reporting path. The public identity/resource is mapped at `src/backend/utils/activity/wait_event_names.txt:419`. The instrumented operation is: Waiting to extend a relation. The lock manager could not grant the extend heavyweight lock immediately. ProcSleep reports the lock wait and parks the backend on the lock's wait queue until owners release or the request is cancelled.

## Normal or trouble? {#normal-vs-trouble}

- <span class="severity-normal">**Normal:**</span> Sub-second handoff during ordinary writes or planned DDL can be normal.
- <span class="severity-watch">**Investigate:**</span> Investigate once a user-facing wait breaches its latency objective, a blocking chain grows, or the root holder is idle in transaction.

## Diagnostic SQL {#diagnostic-sql}

```sql {title="Sessions waiting on Lock/extend"}
SELECT pid, backend_type, usename, datname, application_name,
       state, now() - query_start AS query_age,
       now() - xact_start AS xact_age,
       wait_event_type, wait_event,
       pg_blocking_pids(pid) AS blocking_pids,
       left(query, 160) AS query
FROM pg_stat_activity
WHERE wait_event_type = 'Lock'
  AND wait_event = 'extend'
ORDER BY query_age DESC NULLS LAST;
```

```sql {title="Current Lock cohort"}
SELECT wait_event, count(*) AS waiting_sessions,
       count(*) FILTER (WHERE state = 'active') AS active_waiters,
       max(now() - query_start) AS oldest_query
FROM pg_stat_activity
WHERE wait_event_type = 'Lock'
GROUP BY wait_event
ORDER BY waiting_sessions DESC, wait_event;
```

```sql {title="Lock and relation context for these sessions"}
SELECT a.pid, l.locktype, l.mode, l.granted, l.fastpath,
       d.datname, n.nspname, c.relname,
       l.page, l.tuple, l.virtualxid, l.transactionid,
       l.classid, l.objid, l.objsubid
FROM pg_stat_activity AS a
LEFT JOIN pg_locks AS l ON l.pid = a.pid
LEFT JOIN pg_database AS d ON d.oid = l.database
LEFT JOIN pg_class AS c
  ON c.oid = l.relation
 AND l.database = (
       SELECT oid FROM pg_database WHERE datname = current_database()
     )
LEFT JOIN pg_namespace AS n ON n.oid = c.relnamespace
WHERE a.wait_event_type = 'Lock'
  AND a.wait_event = 'extend'
ORDER BY a.pid, l.granted, l.locktype, l.mode;
```

## Response {#response}

1. Build the pg_blocking_pids graph to its root.
2. Inspect the root holder's state, transaction age, and business purpose.
3. Choose cancellation, timeout, or workload sequencing only after identifying the safest root action.

## Source evidence {#source}

- [PostgreSQL 18.6 · src/backend/storage/lmgr/proc.c:1487](https://github.com/postgres/postgres/blob/REL_18_6/src/backend/storage/lmgr/proc.c#L1487) — `PG_WAIT_LOCK`
- [PostgreSQL 18.6 · src/backend/utils/activity/wait_event_names.txt:419](https://github.com/postgres/postgres/blob/REL_18_6/src/backend/utils/activity/wait_event_names.txt#L419) — `extend`
- [PostgreSQL 18.6 · src/backend/utils/adt/lockfuncs.c:30](https://github.com/postgres/postgres/blob/REL_18_6/src/backend/utils/adt/lockfuncs.c#L30) — `extend`

## Related controls and signals {#related}

- **GUCs:** [[guc:lock_timeout]](/guc/lock-timeout/) · [[guc:deadlock_timeout]](/guc/deadlock-timeout/)
- **Metrics:** [[metric:waiting_sessions]](/metric/waiting-sessions/) · [[metric:wait_event_share]](/metric/wait-event-share/) · [[metric:blocked_sessions]](/metric/blocked-sessions/) · [[metric:locks_per_backend]](/metric/locks-per-backend/)

---

Backlinks:

- [Lock](/lock/)