pg_dump Table and Schema Pattern Tester

pg_dump -t, -T, -n and -N take patterns, not plain names: unquoted letters fold to lower case, * and ? are wildcards, a dot splits schema from table, and a pattern without a schema only matches tables on your search_path. This tester converts each pattern the same way pg_dump does (PostgreSQL 14 and later), shows the SQL condition it runs, lists the tables it matches in your own object list, and prints the final set of tables that would be dumped, together with a correctly quoted command. Everything runs in your browser.

Database name (for db.schema.table patterns)search_path (comma separated, resolve "$user" yourself)--strict-names

-t include table patterns

-T exclude table patterns

--exclude-table-data patterns

-n include schema patterns

-N exclude schema patterns

Your tables, views and sequences (schema.name, one per line)

SQL that lists them in this format

SELECT format('%I.%I', n.nspname, c.relname)
FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace
WHERE c.relkind IN ('r','p','v','m','S','f')
  AND n.nspname NOT IN ('pg_catalog', 'information_schema')
  AND n.nspname NOT LIKE 'pg_toast%'
ORDER BY 1;

Matches, result and command

-t order*
  SQL condition: c.relname OPERATOR(pg_catalog.~) '^(order.*)$' COLLATE pg_catalog.default
               AND pg_catalog.pg_table_is_visible(c.oid)
  matches (4): public.orders, public.orders_id_seq, public.order_items, public."order$log"
  note: No schema given, so only tables visible on the search_path count. Not matched because they are not visible: sales.orders. Add a schema, e.g. sales.order*
  note: pg_catalog is always on the search_path, so an unqualified wildcard can also match system catalogs (for example -t '*x' also matches pg_catalog.pg_index). Qualify the pattern with a schema to avoid that.

-t Orders
  SQL condition: c.relname OPERATOR(pg_catalog.~) '^(orders)$' COLLATE pg_catalog.default
               AND pg_catalog.pg_table_is_visible(c.oid)
  matches (1): public.orders
  note: No schema given, so only tables visible on the search_path count. Not matched because they are not visible: sales.orders. Add a schema, e.g. sales.Orders
  note: Unquoted upper-case letters are folded to lower case. Double-quote the part to match mixed-case names.

-t only_in_sales
  SQL condition: c.relname OPERATOR(pg_catalog.~) '^(only_in_sales)$' COLLATE pg_catalog.default
               AND pg_catalog.pg_table_is_visible(c.oid)
  matches (0): nothing
  note: No schema given, so only tables visible on the search_path count. Not matched because they are not visible: sales.only_in_sales. Add a schema, e.g. sales.only_in_sales

pg_dump result:
  4 relation(s) dumped:
    public.orders
    public.orders_id_seq
    public.order_items
    public."order$log"
  note: sequences owned by a dumped table (serial / identity) are dumped with it, even if -T matches the sequence. Partitions are not, unless you use --table-and-children (PostgreSQL 16+) or a pattern that matches them.

Command (patterns single-quoted so the shell does not expand * or strip double quotes):
  pg_dump -d shop \
    -t 'order*' \
    -t Orders \
    -t only_in_sales \
    -Fc -f backup.dump

Do more than pg_dump table and schema pattern tester — meet Chat2DB

Chat2DB is an AI-powered SQL client for Windows, macOS and Linux. Write SQL in natural language, format and optimize queries automatically, and manage MySQL, PostgreSQL, Oracle and 20+ other databases in one workspace.

How to use

Run the SQL shown under the object list in your database and paste its output, or keep the sample list. Set the database name and your search_path (SHOW search_path;).
Type the patterns you plan to pass to -t, -T, -n, -N or --exclude-table-data, one per line, and choose whether --strict-names is on.
Read the per-pattern matches and notes, check the final list of dumped tables, then copy the quoted pg_dump command.

Frequently asked questions

Why does pg_dump -t say no matching tables were found?

The usual causes are case folding (-t Orders looks for orders; use -t '"Orders"'), a table outside the search_path (-t invoices does not find sales.invoices; use -t sales.invoices), the shell expanding or stripping characters (always single-quote the pattern), and partitions, which -t parent does not include. With several -t switches pg_dump only fails when none of them matches, unless you add --strict-names.

How do I use wildcards with pg_dump -t?

Use * for any sequence of characters and ? for one character, and put the pattern in single quotes so the shell leaves it alone: pg_dump -t 'public.order*'. Regular expression syntax also works outside double quotes, for example -t 'sales.invoices_20(25|26)' or -t 'audit_202[56].log'. Inside double quotes every character is literal.

Does pg_restore -t accept the same patterns?

No. pg_restore -t, -n and -I compare plain names exactly; wildcards and schema-qualified names are not supported there. To restore a subset with patterns, use pg_restore -l to write the table of contents to a file, edit it, and restore with pg_restore -L.