PostgreSQL Error 42P01

SQLSTATE

42P01

Condition name

undefined_table

Product

PostgreSQL

Versions

PostgreSQL 13 to 18 (examples run on PostgreSQL 18.6 in PGlite)

Category

Syntax & Names

Last reviewed

24 October 2026

What it means

SQLSTATE 42P01 means PostgreSQL could not find a table, view, sequence or other relation with that name in the schemas it searched, or a query refers to a table that is not in its FROM clause.

"Relation" is PostgreSQL's word for anything table-like: tables, views, materialized views, sequences, indexes and foreign tables. An unqualified name such as customers is looked up in each schema of the search_path in turn (by default your own schema, then public); a qualified name such as sales.orders only in that schema. If no match is found, the statement fails with 42P01 (undefined_table). Lookup is also exact about case: unquoted names are folded to lower case, so Customers and customers are the same, but a table created as "Customers" (with quotes, as many GUI tools and ORMs do) can only be reached as "Customers". The message shows the name after folding, which is the clue.

Two related messages share this SQLSTATE. "missing FROM-clause entry for table" means a column is qualified with a table name that the query does not list in FROM. "invalid reference to FROM-clause entry" means the table is in FROM under an alias, so only the alias may be used. Finally, every database is separate: a table in another database on the same server is never found, whatever the search_path; check which database you are connected to (a missing database itself is 3D000).

Common causes

• The table was created with a quoted mixed-case name ("Customers") and is queried unquoted, which looks for customers.
• The table is in a schema that is not on the search_path (for example sales.orders queried as orders).
• The schema is on the search_path but the role has no USAGE privilege on it, so PostgreSQL silently skips it.
• The application is connected to a different database, or a different server or environment, from the one that has the table.
• The table does not exist yet: a migration has not run, ran in another schema, or a script uses the table before the CREATE TABLE.
• A typo or a singular/plural mix-up (customer and customers).
• A column is qualified with a table name that is not in FROM, or with the table name instead of its alias.
• A temporary table created in another session or connection: temporary tables are visible only in the session that created them, which matters with connection pools.

Diagnose it

Read-only These queries only read the system catalogs (pg_catalog, information_schema) and statistics views such as pg_stat_activity and pg_locks. They do not change data, roles or settings, so they are safe to run first.

SELECT n.nspname AS schema_name, c.relname AS table_name, c.relkind
FROM pg_class AS c
JOIN pg_namespace AS n ON n.oid = c.relnamespace
WHERE lower(c.relname) = lower('customers')
ORDER BY 1, 2;

SELECT current_database(), current_user, current_schemas(true) AS searched_schemas;

SHOW search_path;

SELECT to_regclass('customers')   AS unquoted,
       to_regclass('"Customers"') AS quoted,
       to_regclass('sales.customers') AS qualified;

How to fix it

Each fix is labelled with what it changes. Try read-only checks and the least invasive fix first, and test changes outside production.

SELECT * FROM "Customers";

-- or rename it once
ALTER TABLE "Customers" RENAME TO customers;

SELECT * FROM sales.orders;

SET search_path TO sales, public;

-- default for new sessions of one role
ALTER ROLE app_user SET search_path TO sales, public;

SELECT o.id
FROM sales.orders AS o
WHERE o.id = 1;

Examples

A table created with a quoted mixed-case name

SELECT * FROM "Customers"; works. The message shows customers in lower case because the unquoted name was folded before the lookup.

CREATE TABLE "Customers" (id int, name text);

SELECT * FROM Customers;  -- folded to customers

ERROR:  relation "customers" does not exist

A table in a schema that is not on the search_path

CREATE SCHEMA sales;
CREATE TABLE sales.orders (id int, customer_id int);

SELECT * FROM orders;

ERROR:  relation "orders" does not exist

Using the table name instead of its alias

CREATE TABLE orders (id int, customer_id int);

SELECT orders.id
FROM orders AS o;

ERROR:  invalid reference to FROM-clause entry for table "orders"
HINT:  Perhaps you meant to reference the table alias "o".

The schema is on the search_path, but the role has no USAGE on it

Because app_reader lacks USAGE on sales, that schema is silently left out of the search (current_schemas(true) shows only pg_catalog and public), so the unqualified name is not found. Written as sales.orders, the same query fails with 42501 permission denied for schema sales instead, which points at the real problem. Fix it with GRANT USAGE ON SCHEMA sales TO app_reader; plus SELECT on the table.

CREATE SCHEMA sales;
CREATE TABLE sales.orders (id int);
CREATE ROLE app_reader;

SET ROLE app_reader;
SET search_path TO sales, public;
SELECT * FROM orders;

ERROR:  relation "orders" does not exist

How to prevent it

Name tables in lower case with underscores and never quote them, so case can never cause this error; configure ORMs and GUI tools not to quote mixed-case names. Qualify names with the schema in migrations, views and functions, and keep search_path settings explicit per role rather than relying on defaults.

Run migrations as part of deployment and check at start-up that the application is connected to the expected database (for example by logging current_database()). In tests, create every table a script uses before the script runs.

Common questions

Learn more on CodeWithSQL

• SQL SELECT statement explained
• SQL Server to PostgreSQL

Official documentation

• PostgreSQL error codes (Appendix A)
• Schemas and the schema search path
• Identifiers and key words (case folding and quoting)
• System information functions (to_regclass, current_schemas)

Last technically reviewed 24 October 2026; examples and diagnostics run on PostgreSQL 18.6 (PGlite 0.5.11). SQL-level examples were run in PGlite (PostgreSQL compiled to WebAssembly); examples that need a running server are shown as documented in the PostgreSQL documentation.