> This page location: PostgreSQL Triggers > List All Triggers
> Full Neon documentation index: https://neon.com/docs/llms.txt

# How to List All Triggers in PostgreSQL

**Info:** Listing triggers with information_schema.triggers, pg_trigger, and psql works the same on any PostgreSQL database, so you can apply these techniques wherever you run Postgres. If you're an enterprise looking for managed Postgres in the AI era, [Lakebase](https://www.databricks.com/product/lakebase) delivers high performance, strong security, and tight integration with the Lakehouse. If you're a developer or startup who needs to ship and scale fast, [Neon](https://neon.com) gives you the most productive Postgres platform to build on.

**Summary**: in this tutorial, you will learn how to list all triggers in the current database or triggers associated with a specific table in PostgreSQL.

## Listing all triggers using SQL statement

To list all triggers along with their associated tables in the current database, you can use the `information_schema.triggers` system view.

For example, the following statement retrieves the triggers with their associated tables in the current database from the `information_schema.triggers` view:

```sql
SELECT
  event_object_table AS table_name,
  trigger_name
FROM
  information_schema.triggers
GROUP BY
  table_name,
  trigger_name
ORDER BY
  table_name,
  trigger_name;
```

Sample output:

```
table_name |         trigger_name
------------+-------------------------------
 employees  | after_delete_employee_trigger
 members    | after_insert_member_trigger
 products   | before_delete_product_trigger
 salaries   | after_update_salary_trigger
(4 rows)
```

If you want to list all triggers associated with a specific table, you can filter the `event_object_table` column by specifying the table name in the [`WHERE`](../postgresql-tutorial/postgresql-where) clause.

For example, the following query lists all triggers associated with the `employees` table in the current database:

```sql
SELECT
  event_object_table AS table_name,
  trigger_name
FROM
  information_schema.triggers
WHERE
  event_object_table = 'employees'
GROUP BY
  table_name,
  trigger_name
ORDER BY
  table_name,
  trigger_name;
```

Output:

```text
 table_name |         trigger_name
------------+-------------------------------
 employees  | after_delete_employee_trigger
(1 row)
```

To make it more convenient, you can [create a user-defined function](../postgresql-plpgsql/postgresql-create-function) that wraps the above query.

For example, the following creates a function named `get_triggers()` that returns all triggers with their associated tables in the current database:

```sql
create or replace function get_triggers()
returns table (
	table_name text,
	trigger_name text
)
language plpgsql
as
$$
begin
	return query select
	  trg.event_object_table::text AS table_name,
	  trg.trigger_name::text
	from
	  information_schema.triggers trg
	group by
	  table_name,
	  trg.trigger_name
	order by
	  table_name,
	  trg.trigger_name;
end;
$$;
```

The following statement shows how to call the `get_triggers()` function:

```sql
SELECT * FROM get_triggers();
```

The following creates a function `get_triggers()` that accepts a table name and returns all the triggers of the table:

```sql

create or replace function get_triggers(
	p_table_name text
)
returns table (
	table_name text,
	trigger_name text
)
language plpgsql
as
$$
begin
	return query select
	  event_object_table::text AS table_name,
	  trg.trigger_name::text
	from
	  information_schema.triggers trg
	where
	   event_object_table = p_table_name
	group by
	  table_name,
	  trg.trigger_name
	order by
	  table_name,
	  trg.trigger_name;
end;
$$;
```

The following statement uses the `get_triggers(text)` function to retrieve all triggers of the `employees` table:

```sql
SELECT * FROM get_triggers('employees');
```

## Listing all triggers using the pg_trigger view

`pg_trigger` is a system view that provides information about triggers defined in the database. Here are some important columns:

| Column         | Description                                                                                                                                 |
| -------------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
| `tgname`       | The name of the trigger.                                                                                                                    |
| `tgrelid`      | The object ID of the table or view to which the trigger belongs.                                                                            |
| `tgfoid`       | The object ID of the function is called when the trigger fires.                                                                             |
| `tgtype`       | The type of the trigger, such as `BEFORE`, `AFTER`, or [`INSTEAD OF`](https://neon.com/postgresql/triggers/postgresql-instead-of-triggers). |
| `tgenabled`    | The status of the trigger, either enabled or disabled.                                                                                      |
| `tgisinternal` | The boolean indicator indicates whether the trigger is a system-generated trigger or a user-defined trigger.                                |

For example, the following statement retrieves all user-defined triggers of the `employees` table from the `pg_trigger` view:

```sql
SELECT
  tgname AS trigger_name
FROM
  pg_trigger
WHERE
  tgrelid = 'employees' :: regclass
  AND tgisinternal = false
ORDER BY
  trigger_name;
```

Output:

```text
         trigger_name
-------------------------------
 after_delete_employee_trigger
(1 row)
```

## Listing all triggers using psql

First, open the Command Prompt on Windows or Terminal on Unix-like systems and connect to the PostgreSQL server using psql:

```bash
psql -U postgres
```

Second, use the `\dS` command with a table name to list all the triggers associated with the table:

```text
\dS table_name;
```

For example, the following command displays the `employees` table with its triggers:

```text
\dS employees
```

Output:

```text
                                    Table "public.employees"
 Column |          Type          | Collation | Nullable |                Default
--------+------------------------+-----------+----------+---------------------------------------
 id     | integer                |           | not null | nextval('employees_id_seq'::regclass)
 name   | character varying(100) |           | not null |
 salary | numeric(10,2)          |           | not null |
Indexes:
    "employees_pkey" PRIMARY KEY, btree (id)
Triggers:
    after_delete_employee_trigger AFTER DELETE ON employees FOR EACH ROW EXECUTE FUNCTION archive_deleted_employee()
```

The last part of the output shows the triggers of the `employees` table.

Note that psql does not provide a command to list all triggers in the current database.

## Summary

- List all triggers in a database or a specific table using the `information_schema.triggers` or `pg_trigger` views.
- Use psql command `\dS table_name` to display a table along with its associated triggers.

---

## Related docs (PostgreSQL Triggers)

- [Introduction](https://neon.com/postgresql/triggers/introduction-postgresql-trigger)
- [CREATE TRIGGER](https://neon.com/postgresql/triggers/creating-first-trigger-postgresql)
- [DROP TRIGGER](https://neon.com/postgresql/triggers/drop-trigger)
- [ALTER TRIGGER](https://neon.com/postgresql/triggers/alter-trigger)
- [AFTER INSERT Trigger](https://neon.com/postgresql/triggers/after-insert-trigger)
- [BEFORE INSERT Trigger](https://neon.com/postgresql/triggers/before-insert-trigger)
- [BEFORE UPDATE Trigger](https://neon.com/postgresql/triggers/before-update-trigger)
- [AFTER UPDATE Trigger](https://neon.com/postgresql/triggers/after-update-trigger)
- [BEFORE DELETE Trigger](https://neon.com/postgresql/triggers/before-delete-trigger)
- [AFTER DELETE Trigger](https://neon.com/postgresql/triggers/after-delete-trigger)
- [INSTEAD OF Triggers](https://neon.com/postgresql/triggers/instead-of-triggers)
- [BEFORE TRUNCATE Trigger](https://neon.com/postgresql/triggers/before-truncate-trigger)
- [Disable Triggers](https://neon.com/postgresql/triggers/managing-postgresql-trigger)
- [Enable Triggers](https://neon.com/postgresql/triggers/enable-triggers)
- [Event Triggers](https://neon.com/postgresql/triggers/event-trigger)
- [Conditional Triggers](https://neon.com/postgresql/triggers/trigger-when-condition)