| PostgreSQL | |
| Logo Caption: | The World's Most Advanced Open Source Relational Database[1] |
| Developer: | PostgreSQL Global Development Group |
| Programming Language: | C |
| Genre: | RDBMS |
| License: | PostgreSQL License (free and open-source, permissive) |
| PostgreSQL License | |
| Publisher: | PostgreSQL Global Development Group Regents of the University of California |
| Osi Approved: | Yes |
| Debian Approved: | Yes[2] [3] |
| Fsf Approved: | Yes[4] |
| Gpl Compatible: | Yes |
| Copyleft: | No |
| Linking: | Yes |
PostgreSQL,[5] also known as Postgres, is a free and open-source relational database management system (RDBMS) emphasizing extensibility and SQL compliance.PostgreSQL features transactions with atomicity, consistency, isolation, durability (ACID) properties, automatically updatable views, materialized views, triggers, foreign keys, and stored procedures.It is supported on all major operating systems, including Linux, FreeBSD, OpenBSD, macOS, and Windows, and handles a range of workloads from single machines to data warehouses 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[6] or temporal[7] database or features which emulate other database products.[8] [9] [10] [11] Also available from third parties are a wide variety of user and machine interface features, such as graphical user interfaces[12] [13] [14] or load balancing and high availability toolsets.[15] 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.[16]
PostgreSQL was originally named POSTGRES, referring to its origins as a successor to the Ingres database developed at the University of California, Berkeley. In 1996, the project was renamed PostgreSQL
to reflect its support for SQL. After a review in 2007, the development team decided to keep the name PostgreSQL and the alias Postgres.
PostgreSQL evolved from the Ingres project at the University of California, Berkeley. In 1982, the leader of the Ingres team, Michael Stonebraker, left Berkeley to make a proprietary version of Ingres. He returned to Berkeley in 1985, and began a post-Ingres project to address the problems with contemporary database systems that had become increasingly clear during the early 1980s. He won the Turing Award in 2014 for these and other projects,[17] and techniques pioneered in them.
The new project, POSTGRES, aimed to add the fewest features needed to completely support data types. These features included the ability to define types and to fully describe relationships something used widely, but maintained entirely by the user. In POSTGRES, the database understood relationships, and could retrieve information in related tables in a natural way using rules. POSTGRES used many of the ideas of Ingres, but not its code.
Starting in 1986, published papers described the basis of the system, and a prototype version was shown at the 1988 ACM SIGMOD Conference. The team released version 1 to a small number of users in June 1989, followed by version 2 with a re-written rules system in June 1990. Version 3, released in 1991, again re-wrote the rules system, and added support for multiple storage managers[18] 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 on June 30, 1994 primarily a cleanup the project ended. Berkeley released POSTGRES under an MIT License variant, which enabled other developers to use the code for any use. At the time, POSTGRES used an Ingres-influenced POSTQUEL query language interpreter, which could be interactively used with a console application named monitor.
In 1994, Berkeley graduate students Andrew Yu and Jolly Chen replaced the POSTQUEL query language interpreter with one for the SQL query language, creating Postgres95. The monitor console was also replaced by psql. Yu and Chen announced the first version (0.01) to beta testers on May 5, 1995. Version 1.0 of Postgres95 was announced on September 5, 1995, with a more liberal license that enabled the software to be freely modifiable.
On July 8, 1996, Marc Fournier at Hub.org Networking Services provided the first non-university development server for the open-source development effort. With the participation of Bruce Momjian and Vadim B. Mikheev, work began to stabilize the code inherited from Berkeley.
In 1996, the project was renamed to PostgreSQL to reflect its support for SQL. The online presence at the website PostgreSQL.org began on October 22, 1996. The first PostgreSQL release formed version 6.0 on January 29, 1997. Since then developers and volunteers around the world have maintained the software as The PostgreSQL Global Development Group.
The project continues to make releases available under its free and open-source software PostgreSQL License. Code comes from contributions from proprietary vendors, support companies, and open-source programmers.
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. The PostgreSQL MVCC implementation is prone to performance issues that require tuning when under a heavy write load which updates existing rows.[19]
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 that ensures that, for each write transaction, the master waits until at least one replica node has written the data to its transaction log. Unlike other database systems, the durability of a transaction (whether it is asynchronous or synchronous) can be specified per-database, per-user, per-session or even per-transaction. This can be useful for workloads that do not require such guarantees, and may not be wanted for all data as it slows down performance due to the requirement of the confirmation of the transaction reaching the synchronous standby.
Standby servers can be synchronous or asynchronous. Synchronous standby servers can be specified in the configuration which determines which servers are candidates for synchronous replication. The first in the list that is actively streaming will be used as the current synchronous server. When this fails, the system fails over to the next in line.
Synchronous multi-master replication is not included in the PostgreSQL core. Postgres-XC which is based on PostgreSQL provides scalable synchronous multi-master replication. It is licensed under the same license as PostgreSQL. A related project is called Postgres-XL. Postgres-R is yet another fork. Bidirectional replication (BDR) is an asynchronous multi-master replication system for PostgreSQL.
Tools such as repmgr make managing replication clusters easier.
Several asynchronous trigger-based replication packages are available. These remain useful even after introduction of the expanded core abilities, for situations where binary replication of a full database cluster is inappropriate:
PostgreSQL includes built-in support for regular B-tree and hash table indexes, and four index access methods: generalized search trees (GiST), generalized inverted indexes (GIN), Space-Partitioned GiST (SP-GiST) and Block Range Indexes (BRIN). In addition, user-defined index methods can be created, although this is quite an involved process. Indexes in PostgreSQL also support the following features:
PostgreSQL schemas are namespaces, allowing objects of the same kind and name to co-exist in a single database.They are not to be confused with adatabase schema -- the abstract, structural, organizational specification which defines how every table's data relates to data within other tables.All PostgreSQL database objects, except for a few global objects such as roles and tablespaces, exist within a schema.They cannot be nested, schemas cannot contain schemas. The permission system controls access to schemas and their content.By default, newly created databases have only a single schema called public but other schemas can be added and the public schema isn't mandatory.
A setting determines the order in which PostgreSQL checks schemas for unqualified objects (those without a prefixed schema). By default, it is set to (refers to the currently connected database user). This default can be set on a database or role level, but as it is a session parameter, it can be freely changed (even multiple times) during a client session, affecting that session only.
Non-existent schemas, or other schemas not accessible to the logged-in user, that are listed in search_path are silently skipped during object lookup.
New objects are created in whichever valid schema (one that can be accessed) appears first in the search_path.
A wide variety of native data types are supported, including:
In addition, users can create their own data types which can usually be made fully indexable via PostgreSQL's indexing infrastructures GiST, GIN, SP-GiST. Examples of these include the geographic information system (GIS) data types from the PostGIS project for PostgreSQL.
There is also a data type called a domain, which is the same as any other data type but with optional constraints defined by the creator of that domain. This means any data entered into a column using the domain will have to conform to whichever constraints were defined as part of the domain.
A data type that represents a range of data can be used which are called range types. These can be discrete ranges (e.g. all integer values 1 to 10) or continuous ranges (e.g., any time between and). The built-in range types available include ranges of integers, big integers, decimal numbers, time stamps (with and without time zone) and dates.
Custom range types can be created to make new types of ranges available, such as IP address ranges using the inet type as a base, or float ranges using the float data type as a base. Range types support inclusive and exclusive range boundaries using the and characters respectively. (e.g., represents all integers starting from and including 4 up to but not including 9.) Range types are also compatible with existing operators used to check for overlap, containment, right of etc.
New types of almost all objects inside the database can be created, including:
Tables can be set to inherit their characteristics from a parent table. Data in child tables will appear to exist in the parent tables, unless data is selected from the parent table using the ONLY keyword, i.e. . Adding a column in the parent table will cause that column to appear in the child table.
Inheritance can be used to implement table partitioning, using either triggers or rules to direct inserts to the parent table into the proper child tables.
This feature is not fully supported. In particular, table constraints are not currently inheritable. All check constraints and not-null constraints on a parent table are automatically inherited by its children. Other types of constraints (unique, primary key, and foreign key constraints) are not inherited.
Inheritance provides a way to map the features of generalization hierarchies depicted in entity relationship diagrams (ERDs) directly into the PostgreSQL database.
PostgreSQL can link to other systems to retrieve data via foreign data wrappers (FDWs).[21] 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.
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.[22]
The official client implementation of this communication protocol is a C API, libpq.[23] In addition, the officially supported ECPG tool allows SQL commands to be embedded in C code.[24] Both are part of the standard PostgreSQL distribution.[25]
Third-party libraries for connecting to PostgreSQL are available for many programming languages, including C++,[26] Java,[27] Julia,[28] [29] Python, Node.js,[30] Go,[31] and Rust.[32]
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.[33] Procedural languages can also be invoked without defining a function, using a DO command at SQL level.[34]
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:
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.[35] External projects provide support for many other languages,[36] including PL/Java, JavaScript (PL/V8), PL/Julia,[37] PL/R,[38] PL/Ruby, and others.
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.
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.[39] [40] [41]
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.
PostgreSQL server is process-based (not threaded), and uses one operating system process per database session. Multiple sessions are automatically spread across all available CPUs by the operating system. Many types of queries can also be parallelized across multiple background worker processes, taking advantage of multiple CPUs or cores.[42] Client applications can use threads and create multiple database connections from each thread.[43]
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.[44] [45]
PostgreSQL natively supports a broad number of external authentication mechanisms, including:
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 (pg_hba.conf), 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).
PostgreSQL claims high, but not complete, conformance with the latest SQL standard ("as of the version 15 release in October 2022, PostgreSQL conforms to at least 170 of the 179 mandatory features for Core conformance", and no other databases fully conformed to it[47]). One exception is the handling of unquoted identifiers like table or column names. In PostgreSQL they are folded, internally, to lower case characters whereas the standard says that unquoted identifiers should be folded to upper case. Thus, should be equivalent to not according to the standard. Other shortcomings concern the absence of temporal tables allowing automatic logging of row versions during transactions with the possibility of browsing in time (FOR SYSTEM TIME predicate), although relatively SQL compliant third-party extensions are available.
Many informal performance studies of PostgreSQL have been done. Performance improvements aimed at improving scalability began heavily with version 8.1. Simple benchmarks between version 8.0 and version 8.4 showed that the latter was more than ten times faster on read-only workloads and at least 7.5 times faster on both read and write workloads.
The first industry-standard and peer-validated benchmark was completed in June 2007, using the Sun Java System Application Server (proprietary version of GlassFish) 9.0 Platform Edition, UltraSPARC T1-based Sun Fire server and PostgreSQL 8.2. This result of 778.14 SPECjAppServer2004 JOPS@Standard compares favourably with the 874 JOPS@Standard with Oracle 10 on an Itanium-based HP-UX system.
In August 2007, Sun submitted an improved benchmark score of 813.73 SPECjAppServer2004 JOPS@Standard. With the system under test at a reduced price, the price/performance improved from $84.98/JOPS to $70.57/JOPS.
The default configuration of PostgreSQL uses only a small amount of dedicated memory for performance-critical purposes such as caching database blocks and sorting. This limitation is primarily because older operating systems required kernel changes to allow allocating large blocks of shared memory. PostgreSQL.org provides advice on basic recommended performance practice in a wiki.
In April 2012, Robert Haas of EnterpriseDB demonstrated PostgreSQL 9.2's linear CPU scalability using a server with 64 cores.
Matloob Khushi performed benchmarking between PostgreSQL 9.0 and MySQL 5.6.15 for their ability to process genomic data. In his performance analysis he found that PostgreSQL extracts overlapping genomic regions eight times faster than MySQL using two datasets of 80,000 each forming random human DNA regions. Insertion and data uploads in PostgreSQL were also better, although general searching ability of both databases was almost equivalent.[48]
PostgreSQL is available for the following operating systems: Linux (all recent distributions), 64-bit ARM and x86-64 installers available and tested for macOS (OS X) version 10.12 and newer, Windows (with installers available and tested for 64-bit Windows Server 2019 and 2016; some older PostgreSQL versions were tested back to Windows 2012 R2[49]), FreeBSD, OpenBSD,[50] NetBSD, and these without official (though unofficial likely available) binary executables, Solaris,[51] AIX, and HP-UX.[52] Most other (modern) Unix-like systems do also work.
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 XP (or later) and other operating systems; these are supported on other than Windows: 64-bit ARM and the older 32-bit ARM, including older such as ARMv6 in Raspberry Pi), z/Architecture, S/390, PowerPC (incl. 64-bit Power ISA), SPARC (also 64-bit), IA-64 Itanium (HP-UX), MIPS and PA-RISC. It was also known to work on some other platforms (while not been tested on for years, i.e. for latest versions).
See also: Comparison of database administration tools.
Open source front-ends and tools for administering PostgreSQL include:
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 organizations and products that use PostgreSQL as the primary database include:
Some notable vendors offer PostgreSQL as software as a service:
| + Release history | |||||||
| Release | First release | Latest minor version | Latest release | End of life[80] | Milestones | ||
|---|---|---|---|---|---|---|---|
| 6.0 | style=white-space:nowrap | 1997-01-29 | First formal release of PostgreSQL, unique indexes, pg_dumpall utility, ident authentication | ||||
| 6.1 | style=white-space:nowrap | 1997-06-08 | 1997-07-22 | Multicolumn indexes, sequences, money data type, GEQO (GEnetic Query Optimizer) | |||
| 6.2 | 1997-10-02 | 1997-10-17 | JDBC interface, triggers, server programming interface, constraints | ||||
| 6.3 | 1998-03-01 | 1998-04-07 | 2003-03-01 | SQL-92 subselect ability, PL/pgTCL | |||
| 6.4 | 1998-10-30 | 1998-12-20 | 2003-10-30 | VIEWs (then only read-only) and RULEs, PL/pgSQL | |||
| 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) | |
| 7.0 | 2000-05-08 | 2000-11-11 | 2004-05-08 | Foreign keys, SQL-92 syntax for joins | |||
| 7.1 | 2001-04-13 | 2001-08-15 | 2006-04-13 | Write-ahead log, outer joins | |||
| 7.2 | 2002-02-04 | 2005-05-09 | 2007-02-04 | PL/Python, OIDs no longer required, internationalization of messages | |||
| 7.3 | 2002-11-27 | 2008-01-07 | 2007-11-27 | Schema, table function, prepared query[81] | |||
| 7.4 | 2003-11-17 | 2010-10-04 | 2010-10-01 | Optimization on JOINs and data warehouse functions[82] | |||
| 8.0 | 2005-01-19 | 2010-10-04 | 2010-10-01 | Native server on Microsoft Windows, savepoints, tablespaces, point-in-time recovery[83] | |||
| 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 | |||
| 8.2 | 2006-12-05 | 2011-12-05 | 2011-12-05 | Performance optimization, online index builds, advisory locks, warm standby[84] | |||
| 8.3 | 2008-02-04 | 2013-02-07 | 2013-02-07 | Heap-only tuples, full text search,[85] SQL/XML, ENUM types, UUID types | |||
| 8.4 | 2009-07-01 | 2014-07-24 | 2014-07-24 | Window functions, column-level permissions, parallel database restore, per-database collation, common table expressions and recursive queries[86] | |||
| 9.0 | 2010-09-20 | 2015-10-08 | 2015-10-08 | Built-in binary streaming replication, hot standby, in-place upgrade ability, 64-bit Windows[87] | |||
| 9.1 | 2011-09-12 | 2016-10-27 | 2016-10-27 | Synchronous replication, per-column collations, unlogged tables, serializable snapshot isolation, writeable common table expressions, SELinux integration, extensions, foreign tables[88] | |||
| 9.2 | 2012-09-10[89] | 2017-11-09 | 2017-11-09 | Cascading streaming replication, index-only scans, native JSON support, improved lock management, range types, pg_receivexlog tool, space-partitioned GiST indexes | |||
| 9.3 | 2013-09-09 | 2018-11-08 | 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 | |||
| 9.4 | 2014-12-18 | 2020-02-13 | 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.[90] | |||
| 9.5 | 2016-01-07 | 2021-02-11 | 2021-02-11 | UPSERT, row level security, TABLESAMPLE, CUBE/ROLLUP, GROUPING SETS, and new BRIN index[91] | |||
| 9.6 | 2016-09-29 | 2021-11-11 | 2021-11-11 | Parallel query support, PostgreSQL foreign data wrapper (FDW) improvements with sort/join pushdown, multiple synchronous standbys, faster vacuuming of large table | |||
| 10 | 2017-10-05 | 2022-11-10 | 2022-11-10 | Logical replication,[92] declarative table partitioning, improved query parallelism | |||
| 11 | 2018-10-18 | 2023-11-09 | 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[93] [94] | |||
| 12 | 2019-10-03 | 2024-08-08 | 2024-11-14 | Improvements to query performance and space utilization; SQL/JSON path expression support; generated columns; improvements to internationalization, and authentication; new pluggable table storage interface.[95] | |||
| 13 | 2020-09-24 | 2024-08-08 | 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[96] [97] | |||
| 14 | 2021-09-30 | 2024-08-08 | 2026-11-12 | Added SQL-standard SEARCH and CYCLE clauses for common table expressions, allow DISTINCT to be added to GROUP BY[98] [99] | |||
| 15 | 2022-10-13 | 2024-08-08 | 2027-11-11 | Implements SQL-standard MERGE statement. PL/Python now only supports current, and now means, no longer the discontinued . | |||
| 16 | 2023-09-14 | 2024-08-08 | 2028-11-09 | Improvements to logical replication, pg_stat_io view (for I/O metrics)[100] | |||
| 17 | 2024-08-08 |