PostgreSQL

PostgreSQL ( ), or web services with many concurrent users.

The PostgreSQL Global Development Group focuses only on developing a database engine and closely related components.

This core is, technically, what comprises PostgreSQL itself, but there is an extensive developer community and ecosystem that provides other important feature sets that might, traditionally, be provided by a proprietary software vendor. These include special-purpose database engine features, like those needed to support a geospatial or temporal database or features which emulate other database products.

Also available from third parties are a wide variety of user and machine interface features, such as graphical user interfaces or load balancing and high availability toolsets.

The large third-party PostgreSQL support network of people, companies, products, and projects, even though not part of The PostgreSQL Development Group, are essential to the PostgreSQL database engine's adoption and use and make up the PostgreSQL ecosystem writ large.

PostgreSQL was originally named POSTGRES, referring to its origins as a successor to the Ingres database developed at the University of California, Berkeley. and techniques pioneered in them.

The new project, POSTGRES, aimed to add the fewest features needed to completely support data types. and an improved query engine. By 1993, the number of users began to overwhelm the project with requests for support and features. After releasing version 4.2

Multiversion concurrency control (MVCC)

PostgreSQL manages concurrency through multiversion concurrency control (MVCC), which gives each transaction a "snapshot" of the database, allowing changes to be made without affecting other transactions. This largely eliminates the need for read locks, and ensures the database maintains ACID principles. PostgreSQL offers four levels of transaction isolation: Read Uncommitted, Read Committed, Repeatable Read and Serializable. Because PostgreSQL is immune to dirty reads, requesting a Read Uncommitted transaction isolation level provides read committed instead. PostgreSQL supports full serializability via the serializable snapshot isolation (SSI) method.

Storage and replication

Replication

PostgreSQL includes built-in binary replication based on shipping the changes (write-ahead logs (WAL)) to replica nodes asynchronously, with the ability to run read-only queries against these replicated nodes. This allows splitting read traffic among multiple nodes efficiently. Earlier replication software that allowed similar read scaling normally relied on adding replication triggers to the master, increasing load.

PostgreSQL includes built-in synchronous replication To address this, PostgreSQL includes a feedback flag where the standby server proactively informs the primary server of any ongoing queries to mitigate this type of conflict.

Synchronous multi-master replication is not included in the PostgreSQL core. Postgres-XC which is based on PostgreSQL provides scalable synchronous multi-master replication.

Arrays (variable-length and can be of any data type, including text and composite types) up to 1 GB in total storage size
Geometric primitives
IPv4 and IPv6 addresses
Classless Inter-Domain Routing (CIDR) blocks and MAC addresses
XML supporting XPath queries
Universally unique identifier (UUID)
JavaScript Object Notation (JSON), and a faster binary JSONB (not the same as BSON and later) -->

Control and connectivity

Foreign data wrappers

PostgreSQL can link to other systems to retrieve data via foreign data wrappers (FDWs).

These can take the form of any data source, such as a file system, another relational database management system (RDBMS), or a web service. This means that regular database queries can use these data sources like regular tables, and even join multiple data-sources together.

Interfaces

PostgreSQL supports a binary communication protocol that allows applications to connect to the database server. The protocol is versioned (currently 3.0, as of PostgreSQL 7.4) and has a detailed specification.

The official client implementation of this communication protocol is a C API, libpq. In addition, the officially supported ECPG tool allows SQL commands to be embedded in C code. Both are part of the standard PostgreSQL distribution.

Third-party libraries for connecting to PostgreSQL are available for many programming languages, including C++, Java, Julia, Go, and Rust.

Procedural languages

Procedural languages allow developers to extend the database with custom subroutines (functions), often called stored procedures. These functions can be used to build database triggers (functions invoked on modification of certain data) and custom data types and aggregate functions. Procedural languages can also be invoked without defining a function, using a DO command at SQL level.

Languages are divided into two groups: Procedures written in safe languages are sandboxed and can be safely created and used by any user. Procedures written in unsafe languages can only be created by superusers, because they allow bypassing a database's security restrictions, but can also access sources external to the database. Some languages like Perl provide both safe and unsafe versions.

PostgreSQL has built-in support for three procedural languages:

Plain SQL (safe). Simpler SQL functions can get expanded inline into the calling (SQL) query, which saves function call overhead and allows the query optimizer to "see inside" the function.
Procedural Language/PostgreSQL (PL/pgSQL) (safe), which resembles Oracle's Procedural Language for SQL (PL/SQL) procedural language and SQL/Persistent Stored Modules (SQL/PSM).
C (unsafe), which allows loading one or more custom shared library into the database. Functions written in C offer the best performance, but bugs in code can crash and potentially corrupt the database. Most built-in functions are written in C.

In addition, PostgreSQL allows procedural languages to be loaded into the database through extensions. Three language extensions are included with PostgreSQL to support Perl, Tcl, and Python. For Python, the current is used, and the discontinued is no longer supported as of PostgreSQL 15. Both were supported previously, defaulting to , while old and new versions couldn't be used in the same session. External projects provide support for many other languages, including PL/Java, JavaScript (PL/V8), PL/Julia, PL/R, PL/Ruby, and others.

Triggers

Triggers are events triggered by the action of SQL data manipulation language (DML) statements. For example, an INSERT statement might activate a trigger that checks if the values of the statement are valid. Most triggers are only activated by either INSERT or UPDATE statements.

Triggers are fully supported and can be attached to tables. Triggers can be per-column and conditional, in that UPDATE triggers can target specific columns of a table, and triggers can be told to execute under a set of conditions as specified in the trigger's WHERE clause. Triggers can be attached to views by using the INSTEAD OF condition. Multiple triggers are fired in alphabetical order. In addition to calling functions written in the native PL/pgSQL, triggers can also invoke functions written in other languages like PL/Python or PL/Perl.

Asynchronous notifications

PostgreSQL provides an asynchronous messaging system that is accessed through the NOTIFY, LISTEN and UNLISTEN commands. A session can issue a NOTIFY command, along with the user-specified channel and an optional payload, to mark a particular event occurring. Other sessions are able to detect these events by issuing a LISTEN command, which can listen to a particular channel. This functionality can be used for a wide variety of purposes, such as letting other sessions know when a table has updated or for separate applications to detect when a particular action has been performed. Such a system prevents the need for continuous polling by applications to see if anything has yet changed, and reducing unnecessary overhead. Notifications are fully transactional, in that messages are not sent until the transaction they were sent from is committed. This eliminates the problem of messages being sent for an action being performed which is then rolled back.

Many connectors for PostgreSQL provide support for this notification system (including libpq, JDBC, Npgsql, psycopg and node.js) so it can be used by external applications.

PostgreSQL can act as an effective, persistent "pub/sub" server or job server by combining LISTEN with FOR UPDATE SKIP LOCKED.

Rules

Rules allow the "query tree" of an incoming query to be rewritten; they are an, automatically invoked, macro language for SQL. "Query Re-Write Rules" are attached to a table/class and "Re-Write" the incoming DML (select, insert, update, and/or delete) into one or more queries that either replace the original DML statement or execute in addition to it. Query Re-Write occurs after DML statement parsing and before query planning.

The functionality rules provide was, in almost every way, later duplicated with the introduction of newer types of triggers.

The use of triggers is usually preferred over rules as it is easier to reason about trigger behavior and interactions than when equivalent rules are used.

Other querying features

Transactions
Full-text search
Views
Materialized views Client applications can use threads and create multiple database connections from each thread.

Security

PostgreSQL manages its internal security on a per-role basis. A role is generally regarded to be a user (a role that can log in), or a group (a role of which other roles are members). Permissions can be granted or revoked on any object down to the column level, and can allow or prevent the visibility/creation/alteration/deletion of objects at the database, schema, table, and row levels.

PostgreSQL's SECURITY LABEL feature (extension to SQL standards), allows for additional security; with a bundled loadable module that supports label-based mandatory access control (MAC) based on Security-Enhanced Linux (SELinux) security policy.

PostgreSQL natively supports a broad number of external authentication mechanisms, including:

Password: either SCRAM-SHA-256, MD5 or plain-text
Generic Security Services Application Program Interface (GSSAPI)
Security Support Provider Interface (SSPI)
Kerberos
ident (maps O/S user-name as provided by an ident server to database user-name)
Peer (maps local user name to database user name)
Lightweight Directory Access Protocol (LDAP)
Active Directory (AD)
RADIUS
Certificate
Pluggable authentication module (PAM)

The GSSAPI, SSPI, Kerberos, peer, ident and certificate methods can also use a specified "map" file that lists which users matched by that authentication system are allowed to connect as a specific database user.

These methods are specified in the cluster's host-based authentication configuration file (<kbd>pg_hba.conf</kbd>), which determines what connections are allowed. This allows control over which user can connect to which database, where they can connect from (IP address, IP address range, domain socket), which authentication system will be enforced, and whether the connection must use Transport Layer Security (TLS).

Standards compliance

PostgreSQL claims high, but not complete, conformance with the latest SQL standard ("as of the version 17 release in September 2024, PostgreSQL conforms to at least 170 of the 177 mandatory features for SQL:2023 Core conformance", and no other databases fully conformed to it). One exception is the handling of unquoted identifiers like table or column names. In PostgreSQL they are folded, internally, to lower case characters

Platforms

PostgreSQL is available for the following operating systems: Linux (all recent distributions), 64-bit ARM and x86-64 installers available and tested for macOS version 10.14 and newer,),  FreeBSD, OpenBSD, NetBSD, DragonFlyBSD, and these without official (though unofficial likely available) binary executables, Solaris,

PostgreSQL can be expected to work on any of the following instruction set architectures (and operating systems): 64-bit x86-64 and 32-bit x86 on Windows and other operating systems; these are supported on other than Windows: 64-bit ARM

|<syntaxhighlight lang="psql">

regression=# select foo;

ERROR: column "foo" does not exist

CONTEXT: PL/pgSQL function "test1" while casting return value to function's return type

LINE 1: select foo;

regression=# \q

</syntaxhighlight>

peter@localhost testdb=> \a \t \x

Output format is aligned.

Tuples only is off.

Expanded display is on.

</syntaxhighlight>

regression=# select '\x';

WARNING: nonstandard use of escape in a string literal

LINE 1: select '\x';

HINT: Use the escape string syntax for escapes, e.g., E'\r\n'.

?column?

----------

(1 row)

regression=# select E'\x';

</syntaxhighlight>

piro=> \set foo 30;

piro=> select * from test where foo <= :foo;

foo | bar

-----+-----

10 |

20 |

(2 rows)

</syntaxhighlight>

testdb=> \set foo 'my_table'

testdb=> SELECT * FROM :"foo";

testdb=> \set content `cat my_file.txt`

testdb=> INSERT INTO my_table VALUES (:'content');

</syntaxhighlight>

regression=# select (

regression(# 1);

?column?

----------

(1 row)

</syntaxhighlight>

piro=> select (

piro(> '

piro'> ' || $$

piro$> $$)

piro-> from "

piro"> foo";

ERROR: relation "

foo" does not exist

LINE 5: from "

</syntaxhighlight>

testdb=> CREATE TABLE my_table (

first integer not null default 0,

second text) ; -- end of command

CREATE TABLE

=# SELECT '0x10'::mpz AS "hex", '10'::mpz AS "dec",

-# '010'::mpz AS oct, '0b10'::mpz AS bin; -- Table output

hex | dec | oct | bin

-----+-----+-----+-----

16 | 10 | 8 | 2

(1 row)

</syntaxhighlight>

regression=# select schemaname from pg_tables limit 3; -- One field output

schemaname

------------

pg_catalog

(3 rows)

=# select 10.0, 1e-6, 1E+6;

?column? | ?column? | ?column?

----------+----------+----------

10.0 | 0.000001 | 1000000

(1 row)

regression=# begin;

BEGIN

regression=# create table asdf (foo serial primary key);

NOTICE: CREATE TABLE will create implicit sequence "asdf_foo_seq" for serial column "asdf.foo"

NOTICE: CREATE TABLE / PRIMARY KEY will create implicit index "asdf_pkey" for table "asdf"

CREATE TABLE

regression=# insert into asdf values (10) returning foo;

foo

-----

(1 row)

INSERT 0 1

regression=# ROLLBACK ;

ROLLBACK

</syntaxhighlight>

; psql: The primary front-end for PostgreSQL is the command-line program, which can be used to enter SQL queries directly, or execute them from a file. In addition, psql provides a number of meta-commands and various shell-like features to facilitate writing scripts and automating a wide variety of tasks; for example tab completion of object names and SQL syntax.

; pgAdmin: The pgAdmin package is a free and open-source graphical user interface (GUI) administration tool for PostgreSQL, which is supported on many computer platforms. framework allowing it to run on most common operating systems. The query tool includes a scripting language called pgScript for supporting admin and development tasks. In December 2014, Dave Page, the pgAdmin project founder and primary developer, announced that with the shift towards web-based models, work has begun on pgAdmin 4 with the aim to facilitate cloud deployments. In 2016, pgAdmin 4 was released. The pgAdmin 4 backend was written in Python, using Flask and the Qt framework.

; phpPgAdmin: phpPgAdmin is a web-based administration tool for PostgreSQL written in PHP and based on the popular phpMyAdmin interface originally written for MySQL administration.

; Adminer: Adminer is a simple web-based administration tool for PostgreSQL and others, written in PHP.

; pgBackRest: pgBackRest is a backup and restore tool for PostgreSQL that provides support for full, differential, and incremental backups.

; pgaudit: pgaudit is a PostgreSQL extension that provides detailed session and/or object audit logging via the standard logging facility provided by PostgreSQL.

; WAL-E: WAL-E is a backup and restore tool for PostgreSQL that provides support for physical (WAL-based) backups, written in Python.

; DBeaver: DBeaver is a free and open source GUI administration tool for PostgreSQL, it has Visual Entity Diagrams and Intellisense features. It also has a commercial PRO license.

; Postgresus: Postgresus is an open source backup tool with GUI for scheduled backups with support of external sources (S3, NAS, FTP, Google Drive, Google Cloud, etc.) and notifications to external services (Slack, Discord, Telegram, SMTP, etc.).

A number of companies offer proprietary tools for PostgreSQL. They often consist of a universal core that is adapted for various specific database products. These tools mostly share the administration features with the open source tools but offer improvements in data modeling, importing, exporting or reporting.

Notable users

<!-- https://www.postgresql.org/about/users

Only add widely recognized organizations and products that use PostgreSQL as their *primary* database, and state specifically what they are using it for. Do *not* add new entries without providing comprehensive reliable sources; see Wikipedia:Reliable sources -->

Notable organizations and products that use PostgreSQL as the primary database include:

Microsoft, used for a petabyte-scale “Release Quality View” (RQV) analytics dashboard, which tracks quality of Windows updates analyzing 20K types of metrics from over 800M Windows devices.
Sun xVM, Sun's virtualization and datacenter automation suite.
Amazon Redshift, part of AWS, a columnar online analytical processing (OLAP) system based on ParAccel's Postgres modifications.
National Oceanic and Atmospheric Administration's (NOAA) National Weather Service (NWS), Interactive Forecast Preparation System (IFPS), a system that integrates data from the NEXRAD weather radars, surface, and hydrology systems to build detailed localized forecast models.
United Kingdom's national weather service, Met Office, has begun swapping Oracle for PostgreSQL in a strategy to deploy more open source technology.
WhitePages.com had been using Oracle and MySQL, but when it came to moving its core directories in-house, it turned to PostgreSQL. Because WhitePages.com needs to combine large sets of data from multiple sources, PostgreSQL's ability to load and index data at high rates was a key to its decision to use PostgreSQL.
Grofers, an online grocery delivery service.
The Guardian migrated from MongoDB to PostgreSQL in 2018.
YugabyteDB implements the PostgreSQL query layer as its default SQL mode
OpenAI uses PostgreSQL as part of its primary API service - including for ChatGPT.

Service implementations

Some notable vendors offer PostgreSQL as software as a service:

Heroku, a platform as a service provider, has supported PostgreSQL since the start in 2007.
VMware has offered vFabric Postgres (also termed vPostgres) for private clouds on VMware vSphere since May 2012.
In November 2013, Amazon Web Services announced the addition of PostgreSQL to their Relational Database Service offering.
In May 2017, Microsoft Azure announced Azure Databases for PostgreSQL.
In May 2019, Alibaba Cloud announced PolarDB for PostgreSQL.
Jelastic Multicloud Platform as a Service has provided container-based PostgreSQL support since 2011. It also offers automated asynchronous master-slave replication of PostgreSQL.
In September 2020, Crunchy Data announced Crunchy Bridge.
In October 2021, Render has provided support for managed PostgreSQL databases since 2021..
In June 2022, Neon.tech announced Neon Serverless Postgres.
In December 2022, Google Cloud Platform announced general availability of AlloyDB as fully managed PostgreSQL cloud service.
In October 2023, Nile announced Nile Postgres Platform.
In April 2024, Google Cloud Platform announced general availability of AlloyDB Omni, a downloadable version of AlloyDB designed to run on any infrastructure, including on-premises, other clouds, or edge environments.
In September 2025, PlanetScale.com announced general availability of PlanetScale for Postgres, a managed, highly available version of Postgres.

Release history

{| class="wikitable"

|+ Release history

! scope="col" | Release

! scope="col" | First release

! scope="col" | Latest minor version

! scope="col" | Latest release

! scope="col" | End of<br />life

! scope="col" | Milestones

! scope="row" | 6.0

| style=white-space:nowrap | 1997-01-29

| First formal release of PostgreSQL, unique indexes, pg_dumpall utility, ident authentication

! scope="row" | 6.1

| style=white-space:nowrap | 1997-06-08

| 1997-07-22

| Multicolumn indexes, sequences, money data type, GEQO (GEnetic Query Optimizer)

! scope="row" | 6.2

| 1997-10-02

| 1997-10-17

| JDBC interface, triggers, server programming interface, constraints

! scope="row" | 6.3

| 1998-03-01

| 1998-04-07

| 2003-03-01

| SQL-92 subselect ability, PL/pgTCL

! scope="row" | 6.4

| 1998-10-30

| 1998-12-20

| 2003-10-30

| VIEWs (then only read-only) and RULEs, PL/pgSQL

! scope="row" | 6.5

| 1999-06-09

| style=white-space:nowrap | 1999-10-13

| style=white-space:nowrap | 2004-06-09

| MVCC, temporary tables, more SQL statement support (CASE, INTERSECT, and EXCEPT)

! scope="row" | 7.0

| 2000-05-08

| 2000-11-11

| 2004-05-08

| Foreign keys, SQL-92 syntax for joins

! scope="row" | 7.1

| 2001-04-13

| 2001-08-15

| 2006-04-13

| Write-ahead log, outer joins

! scope="row" | 7.2

| 2002-02-04

| 2005-05-09

| 2007-02-04

| PL/Python, OIDs no longer required, internationalization of messages

! scope="row" | 7.3

| 2002-11-27

| 2008-01-07

| 2007-11-27

| Schema, table function, prepared query

! scope="row" | 7.4

| 2003-11-17

| 2010-10-04

| 2010-10-01

| Optimization on JOINs and data warehouse functions

! scope="row" | 8.0

| 2005-01-19

| 2010-10-04

| 2010-10-01

| Native server on Microsoft Windows, savepoints, tablespaces, point-in-time recovery

! scope="row" | 8.1

| 2005-11-08

| 2010-12-16

| 2010-11-08

| Performance optimization, two-phase commit, table partitioning, index bitmap scan, shared row locking, roles

! scope="row" | 8.2

| 2006-12-05

| 2011-12-05

| Performance optimization, online index builds, advisory locks, warm standby

! scope="row" | 8.3

| 2008-02-04

| 2013-02-07

| Heap-only tuples, full text search, SQL/XML, ENUM types, UUID types

! scope="row" | 8.4

| 2009-07-01

| 2014-07-24

| Window functions, column-level permissions, parallel database restore, per-database collation, common table expressions and recursive queries

! scope="row" | 9.0

| 2010-09-20

| 2015-10-08

| Built-in binary streaming replication, hot standby, in-place upgrade ability, 64-bit Windows

! scope="row" | 9.1

| 2011-09-12

| 2016-10-27

| Synchronous replication, per-column collations, unlogged tables, serializable snapshot isolation, writeable common table expressions, SELinux integration, extensions, foreign tables

! scope="row" | 9.2

| 2012-09-10

| 2017-11-09

| Cascading streaming replication, index-only scans, native JSON support, improved lock management, range types, pg_receivexlog tool, space-partitioned GiST indexes

! scope="row" | 9.3

| 2013-09-09

| 2018-11-08

| Custom background workers, data checksums, dedicated JSON operators, LATERAL JOIN, faster pg_dump, new pg_isready server monitoring tool, trigger features, view features, writeable foreign tables, materialized views, replication improvements

! scope="row" | 9.4

| 2014-12-18

| 2020-02-13

| JSONB data type, ALTER SYSTEM statement for changing config values, ability to refresh materialized views without blocking reads, dynamic registration/start/stop of background worker processes, Logical Decoding API, GiN index improvements, Linux huge page support, database cache reloading via pg_prewarm, reintroducing Hstore as the column type of choice for document-style data.

! scope="row" | 9.5

| 2016-01-07

| 2021-02-11

| UPSERT, row level security, TABLESAMPLE, CUBE/ROLLUP, GROUPING SETS, and new BRIN index

! scope="row" | 9.6

| 2016-09-29

| 2021-11-11

| Parallel query support, PostgreSQL foreign data wrapper (FDW) improvements with sort/join pushdown, multiple synchronous standbys, faster vacuuming of large table

! scope="row" | 10

| 2017-10-05

| 2022-11-10

| Logical replication, declarative table partitioning, improved query parallelism

! scope="row" | 11

| 2018-10-18

| 2023-11-09

| Increased robustness and performance for partitioning, transactions supported in stored procedures, enhanced abilities for query parallelism, just-in-time (JIT) compiling for expressions

! scope="row" | 12

| 2019-10-03

| 2024-11-21

| Improvements to query performance and space utilization; SQL/JSON path expression support; generated columns; improvements to internationalization, and authentication; new pluggable table storage interface.

! scope="row" | 13

| 2020-09-24

| 2025-11-13

| Space savings and performance gains from de-duplication of B-tree index entries, improved performance for queries that use aggregates or partitioned tables, better query planning when using extended statistics, parallelized vacuuming of indexes, incremental sorting

! scope="row" | 14

| 2021-09-30

| 2026-05-14

| 2026-11-12

| Added SQL-standard SEARCH and CYCLE clauses for common table expressions, allow DISTINCT to be added to GROUP BY

! scope="row" | 15

| 2022-10-13

| 2026-05-14

| 2027-11-11

| Implements SQL-standard MERGE statement. PL/Python now only supports current , and now means , no longer the discontinued .

! scope="row" | 16

| 2023-09-14

| 2026-05-14

| 2028-11-09

| Improvements to logical replication, pg_stat_io view (for I/O metrics)

! scope="row" | 17

| 2024-09-26

| 2026-05-14

| 2029-11-08

| Performance boosts to the vacuum process, I/O layer, and query execution, expanding JSON functionality, more features to MERGE and improving COPY; enhances logical replication for high availability and upgrades, improvements to security, operations, monitoring, and analysis.

! scope="row" | 18

| 2025-09-25

| 2026-05-14

| 2030-11-14

| New I/O subsystem and asynchronous I/O enhancements.

Ecosystem and Derivatives

Due to its permissive open-source license and extensible architecture, a broad ecosystem has developed around PostgreSQL. This includes numerous companies offering dedicated support and hosting, as well as several forks and derivative databases that adapt PostgreSQL for specific workloads. Notable derivatives include:

Greenplum Database: A massively parallel processing (MPP) data warehouse based on an older version of PostgreSQL, designed for large-scale analytics.
TimescaleDB: A time-series database delivered as a PostgreSQL extension, optimized for handling fast ingest and complex queries of time-series data.
Amazon Aurora: A cloud-native relational database offered by Amazon Web Services that provides a PostgreSQL-compatible edition.
Neon: An open-source, serverless implementation of PostgreSQL that separates storage and compute to offer modern development features like database branching.
AlloyDB: A fully managed PostgreSQL-compatible Google Cloud database that separates compute and storage, designed for hybrid workloads and integrated AI capabilities.
PlanetScale Postgres: Fully managed, highly available Postgres instances that support database branching and Database Traffic Control™.

References

</references>

External links

, and wiki
A Software Catalog of related projects and products
The official Main Source Code Repository (for browsing), and the Developer FAQ
The official Reference for PostgreSQL Documentation Authors
All official PostgreSQL Source Code Repositories

Multiversion concurrency control (MVCC)

Storage and replication

Replication

Control and connectivity

Foreign data wrappers

Interfaces

Procedural languages

Triggers

Asynchronous notifications

Rules

Other querying features

Security

Standards compliance

Platforms

Notable users

Service implementations

Release history

Ecosystem and Derivatives

See also

References

Further reading

External links