Every core PostgreSQL schema object — structure, tables, views, indexes, types, identity, routines, security, and replication — in one dense reference.
PostgreSQL stores data in named schema objects. Each object has one job: a table holds rows, an index speeds lookups, a routine holds logic. Know what each object is before choosing which to add, and treat constraints and policies as the rules that keep the data honest.
Reference table · 45 entries
Database ObjectsExplained
45 of 45 rows
Structure
One isolated catalog of schemas inside a cluster.
Separate applications or environments that must not share data.
A named namespace inside a database that groups related objects.
Organize objects by feature or owner and avoid name clashes.
A named location on disk where table and index files are placed.
Steer hot tables to fast storage and keep cold data on cheap disks.
The setting that decides which schemas an unqualified object name resolves to.
Point a session at the right schema so queries can use short names.
A description stored on any database object with COMMENT ON.
Document tables and columns where the next query author will find them.
Tables & views
A named relation that stores rows in typed columns.
The primary container for persistent data.
A table whose rows vanish at the end of the session or transaction.
Hold scratch or staged data that must not outlive the connection.
A parent table split into child partitions by a declared key.
Keep very large tables manageable by ranging or listing rows across partitions.
A table whose rows live in an external system, reached through a foreign data wrapper.
Query a remote database or file as if it were a local table.
A stored query exposed as a virtual table.
Present the same rows through different filters or joins.
A simple view that forwards INSERT, UPDATE, and DELETE to its base table.
Expose a filtered or joined slice of a table that stays writable.
A view whose result set is written to disk and refreshed on demand.
Cache expensive aggregates or joins and read them fast.
A function that returns a set of rows usable anywhere a table fits.
Expand a computed set in place, the way unnest turns an array into rows.
Indexes
A balanced-tree index for equality and range lookups.
Speed up WHERE, JOIN, and ORDER BY on sortable columns.
An index that rejects duplicate values in its key.
Enforce uniqueness on a column or combination of columns.
Inverted or generalized search-tree indexes for non-scalar values.
Index arrays, JSONB, full-text, or geometric data.
An index built only over rows matching a WHERE clause.
Index the hot subset and skip the rest to save space.
Types & extensions
A user-defined type whose values come from a fixed list of labels.
Constrain a column to a closed set such as status codes.
A base type plus a check constraint, named for reuse as a column type.
Share one validated definition, like a non-empty text, across many columns.
A rule set that defines how strings compare and sort.
Get correct ordering for case, accents, or a specific locale.
An installable package that adds functions, types, or operators to a database.
Adopt proven tooling such as PostGIS or pg_trgm in one step.
Identity & generated
A standalone counter object that yields successive integers.
Feed a serial key when several tables share one generator.
A table column backed by an internal sequence, per SQL standard.
Modern auto-incrementing primary key, preferred over SERIAL.
A column whose value is computed from other columns in the same row.
Store or expose a derived value without manual writes.
Routines
A named block of SQL that returns a value or rows.
Encapsulate reusable logic and call it inside queries.
A named block that runs actions and controls its own transaction.
Multi-step ETL where the routine commits or rolls back internally.
A routine that folds many input rows into one value through state and final functions.
Define custom reductions such as a weighted average.
A symbol bound to one or more functions for specific operand types.
Give your own types natural syntax such as a + b or @>.
A declared conversion path from one type to another.
Control how values change types, including which conversions happen implicitly.
A routine bound to a table event that fires automatically.
Audit, validate, or cascade changes on INSERT, UPDATE, or DELETE.
A trigger that fires on database-level events such as DDL commands.
Log, block, or audit schema changes across the whole database.
A parsed query stored for repeated execution with bound parameters.
Reuse one parse and plan across many runs of the same query.
A handle that holds a result set open for row-by-row retrieval.
Page through large results or step through rows inside a routine.
Security & rules
A named identity that holds privileges; a user is a role that can log in.
Group permissions once, then grant them to people, services, or other roles.
Statements that assign privileges on objects to roles, or remove them.
Decide which role can read, write, or execute each object.
The creator's built-in rights to alter or drop an object, separate from grants.
Name the role responsible for an object's lifecycle.
A standing instruction that auto-grants privileges on objects a role creates later.
Pre-set rights so new tables need no manual grants for the app role.
A rule that rejects writes violating a declared condition.
Enforce NOT NULL, CHECK, UNIQUE, PRIMARY KEY, and FOREIGN KEY guarantees.
A per-role rule that hides rows the session must not see.
Tenant isolation or per-user access without rewriting application queries.
An alias that resolves one name to an object elsewhere; native in Oracle and SQL Server.
Port schema layouts; in PostgreSQL use search_path instead.
A definition of which actions get recorded for review, via pgaudit or vendor tooling.
Prove who read or changed what, for compliance and investigation.
An instruction that rewrites an incoming query into another command.
Legacy write redirection; PostgreSQL now favors triggers or updatable views.
Replication
A sender-side definition of which tables and change types stream out to replicas.
Declare what a database offers to logical replication subscribers.
A receiver that connects to a publication and applies its changes to local tables.
Pull changes from another PostgreSQL database into this one.
A marker that makes the primary retain WAL until a consumer has read it.
Guarantee a standby or subscriber can resume without losing changes.