_CONFIG.
+set(${CMAKE_FIND_PACKAGE_NAME}_CONFIG "${CMAKE_CURRENT_LIST_FILE}")
+
+#include(FindPackageHandleStandardArgs)
+#find_package_handle_standard_args(${CMAKE_FIND_PACKAGE_NAME} CONFIG_MODE)
diff --git a/nvcomp/lib/cmake/nvcomp/nvcomp-targets-dynamic-release.cmake b/nvcomp/lib/cmake/nvcomp/nvcomp-targets-dynamic-release.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..32a36c68538fd453ea10c076151df48a18b93ea7
--- /dev/null
+++ b/nvcomp/lib/cmake/nvcomp/nvcomp-targets-dynamic-release.cmake
@@ -0,0 +1,29 @@
+#----------------------------------------------------------------
+# Generated CMake target import file for configuration "Release".
+#----------------------------------------------------------------
+
+# Commands may need to know the format version.
+set(CMAKE_IMPORT_FILE_VERSION 1)
+
+# Import target "nvcomp::nvcomp" for configuration "Release"
+set_property(TARGET nvcomp::nvcomp APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(nvcomp::nvcomp PROPERTIES
+ IMPORTED_IMPLIB_RELEASE "${nvcomp_LIBRARY_DIR}/nvcomp.lib"
+ IMPORTED_LOCATION_RELEASE "${nvcomp_BINARY_DIR}/nvcomp64_5.dll"
+ )
+
+list(APPEND _cmake_import_check_targets nvcomp::nvcomp )
+list(APPEND _cmake_import_check_files_for_nvcomp::nvcomp "${nvcomp_LIBRARY_DIR}/nvcomp.lib" "${nvcomp_BINARY_DIR}/nvcomp64_5.dll" )
+
+# Import target "nvcomp::nvcomp_cpu" for configuration "Release"
+set_property(TARGET nvcomp::nvcomp_cpu APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(nvcomp::nvcomp_cpu PROPERTIES
+ IMPORTED_IMPLIB_RELEASE "${nvcomp_LIBRARY_DIR}/nvcomp_cpu.lib"
+ IMPORTED_LOCATION_RELEASE "${nvcomp_BINARY_DIR}/nvcomp_cpu64_5.dll"
+ )
+
+list(APPEND _cmake_import_check_targets nvcomp::nvcomp_cpu )
+list(APPEND _cmake_import_check_files_for_nvcomp::nvcomp_cpu "${nvcomp_LIBRARY_DIR}/nvcomp_cpu.lib" "${nvcomp_BINARY_DIR}/nvcomp_cpu64_5.dll" )
+
+# Commands beyond this point should not need to know the version.
+set(CMAKE_IMPORT_FILE_VERSION)
diff --git a/nvcomp/lib/cmake/nvcomp/nvcomp-targets-dynamic.cmake b/nvcomp/lib/cmake/nvcomp/nvcomp-targets-dynamic.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..4029a16e748812d34d308835ec80da63c27ba94e
--- /dev/null
+++ b/nvcomp/lib/cmake/nvcomp/nvcomp-targets-dynamic.cmake
@@ -0,0 +1,114 @@
+# Generated by CMake
+
+if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8)
+ message(FATAL_ERROR "CMake >= 2.8.12 required")
+endif()
+if(CMAKE_VERSION VERSION_LESS "2.8.12")
+ message(FATAL_ERROR "CMake >= 2.8.12 required")
+endif()
+cmake_policy(PUSH)
+cmake_policy(VERSION 2.8.12...3.29)
+#----------------------------------------------------------------
+# Generated CMake target import file.
+#----------------------------------------------------------------
+
+# Commands may need to know the format version.
+set(CMAKE_IMPORT_FILE_VERSION 1)
+
+# Protect against multiple inclusion, which would fail when already imported targets are added once more.
+set(_cmake_targets_defined "")
+set(_cmake_targets_not_defined "")
+set(_cmake_expected_targets "")
+foreach(_cmake_expected_target IN ITEMS nvcomp::nvcomp nvcomp::nvcomp_cpu)
+ list(APPEND _cmake_expected_targets "${_cmake_expected_target}")
+ if(TARGET "${_cmake_expected_target}")
+ list(APPEND _cmake_targets_defined "${_cmake_expected_target}")
+ else()
+ list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}")
+ endif()
+endforeach()
+unset(_cmake_expected_target)
+if(_cmake_targets_defined STREQUAL _cmake_expected_targets)
+ unset(_cmake_targets_defined)
+ unset(_cmake_targets_not_defined)
+ unset(_cmake_expected_targets)
+ unset(CMAKE_IMPORT_FILE_VERSION)
+ cmake_policy(POP)
+ return()
+endif()
+if(NOT _cmake_targets_defined STREQUAL "")
+ string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}")
+ string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}")
+ message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n")
+endif()
+unset(_cmake_targets_defined)
+unset(_cmake_targets_not_defined)
+unset(_cmake_expected_targets)
+
+
+# Compute the installation prefix relative to this file.
+get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+if(_IMPORT_PREFIX STREQUAL "/")
+ set(_IMPORT_PREFIX "")
+endif()
+
+# Create imported target nvcomp::nvcomp
+add_library(nvcomp::nvcomp SHARED IMPORTED)
+
+set_target_properties(nvcomp::nvcomp PROPERTIES
+ INTERFACE_INCLUDE_DIRECTORIES "${nvcomp_INCLUDE_DIR}"
+)
+
+# Create imported target nvcomp::nvcomp_cpu
+add_library(nvcomp::nvcomp_cpu SHARED IMPORTED)
+
+set_target_properties(nvcomp::nvcomp_cpu PROPERTIES
+ INTERFACE_INCLUDE_DIRECTORIES "${nvcomp_INCLUDE_DIR}"
+ INTERFACE_LINK_LIBRARIES "Threads::Threads"
+)
+
+# Load information for each installed configuration.
+file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/nvcomp-targets-dynamic-*.cmake")
+foreach(_cmake_config_file IN LISTS _cmake_config_files)
+ include("${_cmake_config_file}")
+endforeach()
+unset(_cmake_config_file)
+unset(_cmake_config_files)
+
+# Cleanup temporary variables.
+set(_IMPORT_PREFIX)
+
+# Loop over all imported files and verify that they actually exist
+foreach(_cmake_target IN LISTS _cmake_import_check_targets)
+ if(CMAKE_VERSION VERSION_LESS "3.28"
+ OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target}
+ OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}")
+ foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}")
+ if(NOT EXISTS "${_cmake_file}")
+ message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file
+ \"${_cmake_file}\"
+but this file does not exist. Possible reasons include:
+* The file was deleted, renamed, or moved to another location.
+* An install or uninstall procedure did not complete successfully.
+* The installation package was faulty and contained
+ \"${CMAKE_CURRENT_LIST_FILE}\"
+but not all the files it references.
+")
+ endif()
+ endforeach()
+ endif()
+ unset(_cmake_file)
+ unset("_cmake_import_check_files_for_${_cmake_target}")
+endforeach()
+unset(_cmake_target)
+unset(_cmake_import_check_targets)
+
+# This file does not depend on other imported targets which have
+# been exported from the same project but in a separate export set.
+
+# Commands beyond this point should not need to know the version.
+set(CMAKE_IMPORT_FILE_VERSION)
+cmake_policy(POP)
diff --git a/nvcomp/lib/cmake/nvcomp/nvcomp-targets-static-release.cmake b/nvcomp/lib/cmake/nvcomp/nvcomp-targets-static-release.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..6c4c9b64abf9031c8b923a963e26619ac82424be
--- /dev/null
+++ b/nvcomp/lib/cmake/nvcomp/nvcomp-targets-static-release.cmake
@@ -0,0 +1,29 @@
+#----------------------------------------------------------------
+# Generated CMake target import file for configuration "Release".
+#----------------------------------------------------------------
+
+# Commands may need to know the format version.
+set(CMAKE_IMPORT_FILE_VERSION 1)
+
+# Import target "nvcomp::nvcomp_static" for configuration "Release"
+set_property(TARGET nvcomp::nvcomp_static APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(nvcomp::nvcomp_static PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CUDA;CXX"
+ IMPORTED_LOCATION_RELEASE "${nvcomp_LIBRARY_DIR}/nvcomp_static.lib"
+ )
+
+list(APPEND _cmake_import_check_targets nvcomp::nvcomp_static )
+list(APPEND _cmake_import_check_files_for_nvcomp::nvcomp_static "${nvcomp_LIBRARY_DIR}/nvcomp_static.lib" )
+
+# Import target "nvcomp::nvcomp_cpu_static" for configuration "Release"
+set_property(TARGET nvcomp::nvcomp_cpu_static APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(nvcomp::nvcomp_cpu_static PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "C;CXX"
+ IMPORTED_LOCATION_RELEASE "${nvcomp_LIBRARY_DIR}/nvcomp_cpu_static.lib"
+ )
+
+list(APPEND _cmake_import_check_targets nvcomp::nvcomp_cpu_static )
+list(APPEND _cmake_import_check_files_for_nvcomp::nvcomp_cpu_static "${nvcomp_LIBRARY_DIR}/nvcomp_cpu_static.lib" )
+
+# Commands beyond this point should not need to know the version.
+set(CMAKE_IMPORT_FILE_VERSION)
diff --git a/nvcomp/lib/cmake/nvcomp/nvcomp-targets-static.cmake b/nvcomp/lib/cmake/nvcomp/nvcomp-targets-static.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..cb6bf6aa54d123a0f50a0723ac39c8e3b0c39706
--- /dev/null
+++ b/nvcomp/lib/cmake/nvcomp/nvcomp-targets-static.cmake
@@ -0,0 +1,114 @@
+# Generated by CMake
+
+if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8)
+ message(FATAL_ERROR "CMake >= 2.8.12 required")
+endif()
+if(CMAKE_VERSION VERSION_LESS "2.8.12")
+ message(FATAL_ERROR "CMake >= 2.8.12 required")
+endif()
+cmake_policy(PUSH)
+cmake_policy(VERSION 2.8.12...3.29)
+#----------------------------------------------------------------
+# Generated CMake target import file.
+#----------------------------------------------------------------
+
+# Commands may need to know the format version.
+set(CMAKE_IMPORT_FILE_VERSION 1)
+
+# Protect against multiple inclusion, which would fail when already imported targets are added once more.
+set(_cmake_targets_defined "")
+set(_cmake_targets_not_defined "")
+set(_cmake_expected_targets "")
+foreach(_cmake_expected_target IN ITEMS nvcomp::nvcomp_static nvcomp::nvcomp_cpu_static)
+ list(APPEND _cmake_expected_targets "${_cmake_expected_target}")
+ if(TARGET "${_cmake_expected_target}")
+ list(APPEND _cmake_targets_defined "${_cmake_expected_target}")
+ else()
+ list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}")
+ endif()
+endforeach()
+unset(_cmake_expected_target)
+if(_cmake_targets_defined STREQUAL _cmake_expected_targets)
+ unset(_cmake_targets_defined)
+ unset(_cmake_targets_not_defined)
+ unset(_cmake_expected_targets)
+ unset(CMAKE_IMPORT_FILE_VERSION)
+ cmake_policy(POP)
+ return()
+endif()
+if(NOT _cmake_targets_defined STREQUAL "")
+ string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}")
+ string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}")
+ message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n")
+endif()
+unset(_cmake_targets_defined)
+unset(_cmake_targets_not_defined)
+unset(_cmake_expected_targets)
+
+
+# Compute the installation prefix relative to this file.
+get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+if(_IMPORT_PREFIX STREQUAL "/")
+ set(_IMPORT_PREFIX "")
+endif()
+
+# Create imported target nvcomp::nvcomp_static
+add_library(nvcomp::nvcomp_static STATIC IMPORTED)
+
+set_target_properties(nvcomp::nvcomp_static PROPERTIES
+ INTERFACE_INCLUDE_DIRECTORIES "${nvcomp_INCLUDE_DIR}"
+)
+
+# Create imported target nvcomp::nvcomp_cpu_static
+add_library(nvcomp::nvcomp_cpu_static STATIC IMPORTED)
+
+set_target_properties(nvcomp::nvcomp_cpu_static PROPERTIES
+ INTERFACE_INCLUDE_DIRECTORIES "${nvcomp_INCLUDE_DIR}"
+ INTERFACE_LINK_LIBRARIES "Threads::Threads"
+)
+
+# Load information for each installed configuration.
+file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/nvcomp-targets-static-*.cmake")
+foreach(_cmake_config_file IN LISTS _cmake_config_files)
+ include("${_cmake_config_file}")
+endforeach()
+unset(_cmake_config_file)
+unset(_cmake_config_files)
+
+# Cleanup temporary variables.
+set(_IMPORT_PREFIX)
+
+# Loop over all imported files and verify that they actually exist
+foreach(_cmake_target IN LISTS _cmake_import_check_targets)
+ if(CMAKE_VERSION VERSION_LESS "3.28"
+ OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target}
+ OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}")
+ foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}")
+ if(NOT EXISTS "${_cmake_file}")
+ message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file
+ \"${_cmake_file}\"
+but this file does not exist. Possible reasons include:
+* The file was deleted, renamed, or moved to another location.
+* An install or uninstall procedure did not complete successfully.
+* The installation package was faulty and contained
+ \"${CMAKE_CURRENT_LIST_FILE}\"
+but not all the files it references.
+")
+ endif()
+ endforeach()
+ endif()
+ unset(_cmake_file)
+ unset("_cmake_import_check_files_for_${_cmake_target}")
+endforeach()
+unset(_cmake_target)
+unset(_cmake_import_check_targets)
+
+# This file does not depend on other imported targets which have
+# been exported from the same project but in a separate export set.
+
+# Commands beyond this point should not need to know the version.
+set(CMAKE_IMPORT_FILE_VERSION)
+cmake_policy(POP)
diff --git a/nvcomp/lib/nvcomp.lib b/nvcomp/lib/nvcomp.lib
new file mode 100644
index 0000000000000000000000000000000000000000..516c19b4bfed26a39176cc477fcbe45009bc4376
Binary files /dev/null and b/nvcomp/lib/nvcomp.lib differ
diff --git a/nvcomp/lib/nvcomp_cpu.lib b/nvcomp/lib/nvcomp_cpu.lib
new file mode 100644
index 0000000000000000000000000000000000000000..7cb43108ca10f1ddc1b01cafa49cfef1c2aa2a45
Binary files /dev/null and b/nvcomp/lib/nvcomp_cpu.lib differ
diff --git a/pgsql/doc/postgresql/html/indexes-collations.html b/pgsql/doc/postgresql/html/indexes-collations.html
new file mode 100644
index 0000000000000000000000000000000000000000..5167fd637b00d8c7aba14102eeadce70d525c895
--- /dev/null
+++ b/pgsql/doc/postgresql/html/indexes-collations.html
@@ -0,0 +1,31 @@
+
+11.11. Indexes and Collations11.11. Indexes and Collations #
+ An index can support only one collation per index column.
+ If multiple collations are of interest, multiple indexes may be needed.
+
+ Consider these statements:
+
+CREATE TABLE test1c (
+ id integer,
+ content varchar COLLATE "x"
+);
+
+CREATE INDEX test1c_content_index ON test1c (content);
+
+ The index automatically uses the collation of the
+ underlying column. So a query of the form
+
+SELECT * FROM test1c WHERE content > constant;
+
+ could use the index, because the comparison will by default use the
+ collation of the column. However, this index cannot accelerate queries
+ that involve some other collation. So if queries of the form, say,
+
+SELECT * FROM test1c WHERE content > constant COLLATE "y";
+
+ are also of interest, an additional index could be created that supports
+ the "y" collation, like this:
+
+CREATE INDEX test1c_content_y_index ON test1c (content COLLATE "y");
+
+
11.12. Examining Index Usage #
+ Although indexes in PostgreSQL do not need
+ maintenance or tuning, it is still important to check
+ which indexes are actually used by the real-life query workload.
+ Examining index usage for an individual query is done with the
+ EXPLAIN
+ command; its application for this purpose is
+ illustrated in Section 14.1.
+ It is also possible to gather overall statistics about index usage
+ in a running server, as described in Section 28.2.
+
+ It is difficult to formulate a general procedure for determining
+ which indexes to create. There are a number of typical cases that
+ have been shown in the examples throughout the previous sections.
+ A good deal of experimentation is often necessary.
+ The rest of this section gives some tips for that:
+
+ Always run ANALYZE
+ first. This command
+ collects statistics about the distribution of the values in the
+ table. This information is required to estimate the number of rows
+ returned by a query, which is needed by the planner to assign
+ realistic costs to each possible query plan. In absence of any
+ real statistics, some default values are assumed, which are
+ almost certain to be inaccurate. Examining an application's
+ index usage without having run ANALYZE is
+ therefore a lost cause.
+ See Section 25.1.3
+ and Section 25.1.6 for more information.
+
+ Use real data for experimentation. Using test data for setting
+ up indexes will tell you what indexes you need for the test data,
+ but that is all.
+
+ It is especially fatal to use very small test data sets.
+ While selecting 1000 out of 100000 rows could be a candidate for
+ an index, selecting 1 out of 100 rows will hardly be, because the
+ 100 rows probably fit within a single disk page, and there
+ is no plan that can beat sequentially fetching 1 disk page.
+
+ Also be careful when making up test data, which is often
+ unavoidable when the application is not yet in production.
+ Values that are very similar, completely random, or inserted in
+ sorted order will skew the statistics away from the distribution
+ that real data would have.
+
+ When indexes are not used, it can be useful for testing to force
+ their use. There are run-time parameters that can turn off
+ various plan types (see Section 20.7.1).
+ For instance, turning off sequential scans
+ (enable_seqscan) and nested-loop joins
+ (enable_nestloop), which are the most basic plans,
+ will force the system to use a different plan. If the system
+ still chooses a sequential scan or nested-loop join then there is
+ probably a more fundamental reason why the index is not being
+ used; for example, the query condition does not match the index.
+ (What kind of query can use what kind of index is explained in
+ the previous sections.)
+
+ If forcing index usage does use the index, then there are two
+ possibilities: Either the system is right and using the index is
+ indeed not appropriate, or the cost estimates of the query plans
+ are not reflecting reality. So you should time your query with
+ and without indexes. The EXPLAIN ANALYZE
+ command can be useful here.
+
+ If it turns out that the cost estimates are wrong, there are,
+ again, two possibilities. The total cost is computed from the
+ per-row costs of each plan node times the selectivity estimate of
+ the plan node. The costs estimated for the plan nodes can be adjusted
+ via run-time parameters (described in Section 20.7.2).
+ An inaccurate selectivity estimate is due to
+ insufficient statistics. It might be possible to improve this by
+ tuning the statistics-gathering parameters (see
+ ALTER TABLE).
+
+ If you do not succeed in adjusting the costs to be more
+ appropriate, then you might have to resort to forcing index usage
+ explicitly. You might also want to contact the
+ PostgreSQL developers to examine the issue.
+
11.7. Indexes on Expressions #
+ An index column need not be just a column of the underlying table,
+ but can be a function or scalar expression computed from one or
+ more columns of the table. This feature is useful to obtain fast
+ access to tables based on the results of computations.
+
+ For example, a common way to do case-insensitive comparisons is to
+ use the lower function:
+
+SELECT * FROM test1 WHERE lower(col1) = 'value';
+
+ This query can use an index if one has been
+ defined on the result of the lower(col1)
+ function:
+
+CREATE INDEX test1_lower_col1_idx ON test1 (lower(col1));
+
+
+ If we were to declare this index UNIQUE, it would prevent
+ creation of rows whose col1 values differ only in case,
+ as well as rows whose col1 values are actually identical.
+ Thus, indexes on expressions can be used to enforce constraints that
+ are not definable as simple unique constraints.
+
+ As another example, if one often does queries like:
+
+SELECT * FROM people WHERE (first_name || ' ' || last_name) = 'John Smith';
+
+ then it might be worth creating an index like this:
+
+CREATE INDEX people_names ON people ((first_name || ' ' || last_name));
+
+
+ The syntax of the CREATE INDEX command normally requires
+ writing parentheses around index expressions, as shown in the second
+ example. The parentheses can be omitted when the expression is just
+ a function call, as in the first example.
+
+ Index expressions are relatively expensive to maintain, because the
+ derived expression(s) must be computed for each row insertion
+ and non-HOT update. However, the index expressions are
+ not recomputed during an indexed search, since they are
+ already stored in the index. In both examples above, the system
+ sees the query as just WHERE indexedcolumn = 'constant'
+ and so the speed of the search is equivalent to any other simple index
+ query. Thus, indexes on expressions are useful when retrieval speed
+ is more important than insertion and update speed.
+
11.9. Index-Only Scans and Covering Indexes #
+ All indexes in PostgreSQL
+ are secondary indexes, meaning that each index is
+ stored separately from the table's main data area (which is called the
+ table's heap
+ in PostgreSQL terminology). This means that
+ in an ordinary index scan, each row retrieval requires fetching data from
+ both the index and the heap. Furthermore, while the index entries that
+ match a given indexable WHERE condition are usually
+ close together in the index, the table rows they reference might be
+ anywhere in the heap. The heap-access portion of an index scan thus
+ involves a lot of random access into the heap, which can be slow,
+ particularly on traditional rotating media. (As described in
+ Section 11.5, bitmap scans try to alleviate
+ this cost by doing the heap accesses in sorted order, but that only goes
+ so far.)
+
+ To solve this performance problem, PostgreSQL
+ supports index-only scans, which can answer
+ queries from an index alone without any heap access. The basic idea is
+ to return values directly out of each index entry instead of consulting
+ the associated heap entry. There are two fundamental restrictions on
+ when this method can be used:
+
+
+ The index type must support index-only scans. B-tree indexes always
+ do. GiST and SP-GiST indexes support index-only scans for some
+ operator classes but not others. Other index types have no support.
+ The underlying requirement is that the index must physically store, or
+ else be able to reconstruct, the original data value for each index
+ entry. As a counterexample, GIN indexes cannot support index-only
+ scans because each index entry typically holds only part of the
+ original data value.
+
+ The query must reference only columns stored in the index. For
+ example, given an index on columns x
+ and y of a table that also has a
+ column z, these queries could use index-only scans:
+
+SELECT x, y FROM tab WHERE x = 'key';
+SELECT x FROM tab WHERE x = 'key' AND y < 42;
+
+ but these queries could not:
+
+SELECT x, z FROM tab WHERE x = 'key';
+SELECT x FROM tab WHERE x = 'key' AND z < 42;
+
+ (Expression indexes and partial indexes complicate this rule,
+ as discussed below.)
+
+
+ If these two fundamental requirements are met, then all the data values
+ required by the query are available from the index, so an index-only scan
+ is physically possible. But there is an additional requirement for any
+ table scan in PostgreSQL: it must verify that
+ each retrieved row be “visible” to the query's MVCC
+ snapshot, as discussed in Chapter 13. Visibility information
+ is not stored in index entries, only in heap entries; so at first glance
+ it would seem that every row retrieval would require a heap access
+ anyway. And this is indeed the case, if the table row has been modified
+ recently. However, for seldom-changing data there is a way around this
+ problem. PostgreSQL tracks, for each page in
+ a table's heap, whether all rows stored in that page are old enough to be
+ visible to all current and future transactions. This information is
+ stored in a bit in the table's visibility map. An
+ index-only scan, after finding a candidate index entry, checks the
+ visibility map bit for the corresponding heap page. If it's set, the row
+ is known visible and so the data can be returned with no further work.
+ If it's not set, the heap entry must be visited to find out whether it's
+ visible, so no performance advantage is gained over a standard index
+ scan. Even in the successful case, this approach trades visibility map
+ accesses for heap accesses; but since the visibility map is four orders
+ of magnitude smaller than the heap it describes, far less physical I/O is
+ needed to access it. In most situations the visibility map remains
+ cached in memory all the time.
+
+ In short, while an index-only scan is possible given the two fundamental
+ requirements, it will be a win only if a significant fraction of the
+ table's heap pages have their all-visible map bits set. But tables in
+ which a large fraction of the rows are unchanging are common enough to
+ make this type of scan very useful in practice.
+
+
+ To make effective use of the index-only scan feature, you might choose to
+ create a covering index, which is an index
+ specifically designed to include the columns needed by a particular
+ type of query that you run frequently. Since queries typically need to
+ retrieve more columns than just the ones they search
+ on, PostgreSQL allows you to create an index
+ in which some columns are just “payload” and are not part
+ of the search key. This is done by adding an INCLUDE
+ clause listing the extra columns. For example, if you commonly run
+ queries like
+
+SELECT y FROM tab WHERE x = 'key';
+
+ the traditional approach to speeding up such queries would be to create
+ an index on x only. However, an index defined as
+
+CREATE INDEX tab_x_y ON tab(x) INCLUDE (y);
+
+ could handle these queries as index-only scans,
+ because y can be obtained from the index without
+ visiting the heap.
+
+ Because column y is not part of the index's search
+ key, it does not have to be of a data type that the index can handle;
+ it's merely stored in the index and is not interpreted by the index
+ machinery. Also, if the index is a unique index, that is
+
+CREATE UNIQUE INDEX tab_x_y ON tab(x) INCLUDE (y);
+
+ the uniqueness condition applies to just column x,
+ not to the combination of x and y.
+ (An INCLUDE clause can also be written
+ in UNIQUE and PRIMARY KEY
+ constraints, providing alternative syntax for setting up an index like
+ this.)
+
+ It's wise to be conservative about adding non-key payload columns to an
+ index, especially wide columns. If an index tuple exceeds the
+ maximum size allowed for the index type, data insertion will fail.
+ In any case, non-key columns duplicate data from the index's table
+ and bloat the size of the index, thus potentially slowing searches.
+ And remember that there is little point in including payload columns in an
+ index unless the table changes slowly enough that an index-only scan is
+ likely to not need to access the heap. If the heap tuple must be visited
+ anyway, it costs nothing more to get the column's value from there.
+ Other restrictions are that expressions are not currently supported as
+ included columns, and that only B-tree, GiST and SP-GiST indexes currently
+ support included columns.
+
+ Before PostgreSQL had
+ the INCLUDE feature, people sometimes made covering
+ indexes by writing the payload columns as ordinary index columns,
+ that is writing
+
+CREATE INDEX tab_x_y ON tab(x, y);
+
+ even though they had no intention of ever using y as
+ part of a WHERE clause. This works fine as long as
+ the extra columns are trailing columns; making them be leading columns is
+ unwise for the reasons explained in Section 11.3.
+ However, this method doesn't support the case where you want the index to
+ enforce uniqueness on the key column(s).
+
+ Suffix truncation always removes non-key
+ columns from upper B-Tree levels. As payload columns, they are
+ never used to guide index scans. The truncation process also
+ removes one or more trailing key column(s) when the remaining
+ prefix of key column(s) happens to be sufficient to describe tuples
+ on the lowest B-Tree level. In practice, covering indexes without
+ an INCLUDE clause often avoid storing columns
+ that are effectively payload in the upper levels. However,
+ explicitly defining payload columns as non-key columns
+ reliably keeps the tuples in upper levels
+ small.
+
+ In principle, index-only scans can be used with expression indexes.
+ For example, given an index on f(x)
+ where x is a table column, it should be possible to
+ execute
+
+SELECT f(x) FROM tab WHERE f(x) < 1;
+
+ as an index-only scan; and this is very attractive
+ if f() is an expensive-to-compute function.
+ However, PostgreSQL's planner is currently not
+ very smart about such cases. It considers a query to be potentially
+ executable by index-only scan only when all columns
+ needed by the query are available from the index. In this
+ example, x is not needed except in the
+ context f(x), but the planner does not notice that and
+ concludes that an index-only scan is not possible. If an index-only scan
+ seems sufficiently worthwhile, this can be worked around by
+ adding x as an included column, for example
+
+CREATE INDEX tab_f_x ON tab (f(x)) INCLUDE (x);
+
+ An additional caveat, if the goal is to avoid
+ recalculating f(x), is that the planner won't
+ necessarily match uses of f(x) that aren't in
+ indexable WHERE clauses to the index column. It will
+ usually get this right in simple queries such as shown above, but not in
+ queries that involve joins. These deficiencies may be remedied in future
+ versions of PostgreSQL.
+
+ Partial indexes also have interesting interactions with index-only scans.
+ Consider the partial index shown in Example 11.3:
+
+CREATE UNIQUE INDEX tests_success_constraint ON tests (subject, target)
+ WHERE success;
+
+ In principle, we could do an index-only scan on this index to satisfy a
+ query like
+
+SELECT target FROM tests WHERE subject = 'some-subject' AND success;
+
+ But there's a problem: the WHERE clause refers
+ to success which is not available as a result column
+ of the index. Nonetheless, an index-only scan is possible because the
+ plan does not need to recheck that part of the WHERE
+ clause at run time: all entries found in the index necessarily
+ have success = true so this need not be explicitly
+ checked in the plan. PostgreSQL versions 9.6
+ and later will recognize such cases and allow index-only scans to be
+ generated, but older versions will not.
+
+ Suppose we have a table similar to this:
+
+CREATE TABLE test1 (
+ id integer,
+ content varchar
+);
+
+ and the application issues many queries of the form:
+
+SELECT content FROM test1 WHERE id = constant;
+
+ With no advance preparation, the system would have to scan the entire
+ test1 table, row by row, to find all
+ matching entries. If there are many rows in
+ test1 and only a few rows (perhaps zero
+ or one) that would be returned by such a query, this is clearly an
+ inefficient method. But if the system has been instructed to maintain an
+ index on the id column, it can use a more
+ efficient method for locating matching rows. For instance, it
+ might only have to walk a few levels deep into a search tree.
+
+ A similar approach is used in most non-fiction books: terms and
+ concepts that are frequently looked up by readers are collected in
+ an alphabetic index at the end of the book. The interested reader
+ can scan the index relatively quickly and flip to the appropriate
+ page(s), rather than having to read the entire book to find the
+ material of interest. Just as it is the task of the author to
+ anticipate the items that readers are likely to look up,
+ it is the task of the database programmer to foresee which indexes
+ will be useful.
+
+ The following command can be used to create an index on the
+ id column, as discussed:
+
+CREATE INDEX test1_id_index ON test1 (id);
+
+ The name test1_id_index can be chosen
+ freely, but you should pick something that enables you to remember
+ later what the index was for.
+
+ To remove an index, use the DROP INDEX command.
+ Indexes can be added to and removed from tables at any time.
+
+ Once an index is created, no further intervention is required: the
+ system will update the index when the table is modified, and it will
+ use the index in queries when it thinks doing so would be more efficient
+ than a sequential table scan. But you might have to run the
+ ANALYZE command regularly to update
+ statistics to allow the query planner to make educated decisions.
+ See Chapter 14 for information about
+ how to find out whether an index is used and when and why the
+ planner might choose not to use an index.
+
+ Indexes can also benefit UPDATE and
+ DELETE commands with search conditions.
+ Indexes can moreover be used in join searches. Thus,
+ an index defined on a column that is part of a join condition can
+ also significantly speed up queries with joins.
+
+ In general, PostgreSQL indexes can be used
+ to optimize queries that contain one or more WHERE
+ or JOIN clauses of the form
+
+
+indexed-column indexable-operator comparison-value
+
+
+ Here, the indexed-column is whatever
+ column or expression the index has been defined on.
+ The indexable-operator is an operator that
+ is a member of the index's operator class for
+ the indexed column. (More details about that appear below.)
+ And the comparison-value can be any
+ expression that is not volatile and does not reference the index's
+ table.
+
+ In some cases the query planner can extract an indexable clause of
+ this form from another SQL construct. A simple example is that if
+ the original clause was
+
+
+comparison-value operator indexed-column
+
+
+ then it can be flipped around into indexable form if the
+ original operator has a commutator
+ operator that is a member of the index's operator class.
+
+ Creating an index on a large table can take a long time. By default,
+ PostgreSQL allows reads (SELECT statements) to occur
+ on the table in parallel with index creation, but writes (INSERT,
+ UPDATE, DELETE) are blocked until the index build is finished.
+ In production environments this is often unacceptable.
+ It is possible to allow writes to occur in parallel with index
+ creation, but there are several caveats to be aware of —
+ for more information see Building Indexes Concurrently.
+
+ After an index is created, the system has to keep it synchronized with the
+ table. This adds overhead to data manipulation operations. Indexes can
+ also prevent the creation of heap-only
+ tuples.
+ Therefore indexes that are seldom or never used in queries
+ should be removed.
+
11.3. Multicolumn Indexes #
+ An index can be defined on more than one column of a table. For example, if
+ you have a table of this form:
+
+CREATE TABLE test2 (
+ major int,
+ minor int,
+ name varchar
+);
+
+ (say, you keep your /dev
+ directory in a database...) and you frequently issue queries like:
+
+SELECT name FROM test2 WHERE major = constant AND minor = constant;
+
+ then it might be appropriate to define an index on the columns
+ major and
+ minor together, e.g.:
+
+CREATE INDEX test2_mm_idx ON test2 (major, minor);
+
+
+ Currently, only the B-tree, GiST, GIN, and BRIN index types support
+ multiple-key-column indexes. Whether there can be multiple key
+ columns is independent of whether INCLUDE columns
+ can be added to the index. Indexes can have up to 32 columns,
+ including INCLUDE columns. (This limit can be
+ altered when building PostgreSQL; see the
+ file pg_config_manual.h.)
+
+ A multicolumn B-tree index can be used with query conditions that
+ involve any subset of the index's columns, but the index is most
+ efficient when there are constraints on the leading (leftmost) columns.
+ The exact rule is that equality constraints on leading columns, plus
+ any inequality constraints on the first column that does not have an
+ equality constraint, will be used to limit the portion of the index
+ that is scanned. Constraints on columns to the right of these columns
+ are checked in the index, so they save visits to the table proper, but
+ they do not reduce the portion of the index that has to be scanned.
+ For example, given an index on (a, b, c) and a
+ query condition WHERE a = 5 AND b >= 42 AND c < 77,
+ the index would have to be scanned from the first entry with
+ a = 5 and b = 42 up through the last entry with
+ a = 5. Index entries with c >= 77 would be
+ skipped, but they'd still have to be scanned through.
+ This index could in principle be used for queries that have constraints
+ on b and/or c with no constraint on a
+ — but the entire index would have to be scanned, so in most cases
+ the planner would prefer a sequential table scan over using the index.
+
+ A multicolumn GiST index can be used with query conditions that
+ involve any subset of the index's columns. Conditions on additional
+ columns restrict the entries returned by the index, but the condition on
+ the first column is the most important one for determining how much of
+ the index needs to be scanned. A GiST index will be relatively
+ ineffective if its first column has only a few distinct values, even if
+ there are many distinct values in additional columns.
+
+ A multicolumn GIN index can be used with query conditions that
+ involve any subset of the index's columns. Unlike B-tree or GiST,
+ index search effectiveness is the same regardless of which index column(s)
+ the query conditions use.
+
+ A multicolumn BRIN index can be used with query conditions that
+ involve any subset of the index's columns. Like GIN and unlike B-tree or
+ GiST, index search effectiveness is the same regardless of which index
+ column(s) the query conditions use. The only reason to have multiple BRIN
+ indexes instead of one multicolumn BRIN index on a single table is to have
+ a different pages_per_range storage parameter.
+
+ Of course, each column must be used with operators appropriate to the index
+ type; clauses that involve other operators will not be considered.
+
+ Multicolumn indexes should be used sparingly. In most situations,
+ an index on a single column is sufficient and saves space and time.
+ Indexes with more than three columns are unlikely to be helpful
+ unless the usage of the table is extremely stylized. See also
+ Section 11.5 and
+ Section 11.9 for some discussion of the
+ merits of different index configurations.
+
11.10. Operator Classes and Operator Families #
+ An index definition can specify an operator
+ class for each column of an index.
+
+CREATE INDEX name ON table (column opclass [ ( opclass_options ) ] [sort options] [, ...]);
+
+ The operator class identifies the operators to be used by the index
+ for that column. For example, a B-tree index on the type int4
+ would use the int4_ops class; this operator
+ class includes comparison functions for values of type int4.
+ In practice the default operator class for the column's data type is
+ usually sufficient. The main reason for having operator classes is
+ that for some data types, there could be more than one meaningful
+ index behavior. For example, we might want to sort a complex-number data
+ type either by absolute value or by real part. We could do this by
+ defining two operator classes for the data type and then selecting
+ the proper class when making an index. The operator class determines
+ the basic sort ordering (which can then be modified by adding sort options
+ COLLATE,
+ ASC/DESC and/or
+ NULLS FIRST/NULLS LAST).
+
+ There are also some built-in operator classes besides the default ones:
+
+
+ The operator classes text_pattern_ops,
+ varchar_pattern_ops, and
+ bpchar_pattern_ops support B-tree indexes on
+ the types text, varchar, and
+ char respectively. The
+ difference from the default operator classes is that the values
+ are compared strictly character by character rather than
+ according to the locale-specific collation rules. This makes
+ these operator classes suitable for use by queries involving
+ pattern matching expressions (LIKE or POSIX
+ regular expressions) when the database does not use the standard
+ “C” locale. As an example, you might index a
+ varchar column like this:
+
+CREATE INDEX test_index ON test_table (col varchar_pattern_ops);
+
+ Note that you should also create an index with the default operator
+ class if you want queries involving ordinary <,
+ <=, >, or >= comparisons
+ to use an index. Such queries cannot use the
+ xxx_pattern_opsxxx_pattern_ops
+
+ The following query shows all defined operator classes:
+
+
+SELECT am.amname AS index_method,
+ opc.opcname AS opclass_name,
+ opc.opcintype::regtype AS indexed_type,
+ opc.opcdefault AS is_default
+ FROM pg_am am, pg_opclass opc
+ WHERE opc.opcmethod = am.oid
+ ORDER BY index_method, opclass_name;
+
+
+ An operator class is actually just a subset of a larger structure called an
+ operator family. In cases where several data types have
+ similar behaviors, it is frequently useful to define cross-data-type
+ operators and allow these to work with indexes. To do this, the operator
+ classes for each of the types must be grouped into the same operator
+ family. The cross-type operators are members of the family, but are not
+ associated with any single class within the family.
+
+ This expanded version of the previous query shows the operator family
+ each operator class belongs to:
+
+SELECT am.amname AS index_method,
+ opc.opcname AS opclass_name,
+ opf.opfname AS opfamily_name,
+ opc.opcintype::regtype AS indexed_type,
+ opc.opcdefault AS is_default
+ FROM pg_am am, pg_opclass opc, pg_opfamily opf
+ WHERE opc.opcmethod = am.oid AND
+ opc.opcfamily = opf.oid
+ ORDER BY index_method, opclass_name;
+
+
+ This query shows all defined operator families and all
+ the operators included in each family:
+
+SELECT am.amname AS index_method,
+ opf.opfname AS opfamily_name,
+ amop.amopopr::regoperator AS opfamily_operator
+ FROM pg_am am, pg_opfamily opf, pg_amop amop
+ WHERE opf.opfmethod = am.oid AND
+ amop.amopfamily = opf.oid
+ ORDER BY index_method, opfamily_name, opfamily_operator;
+
+
Tip
+ psql has
+ commands \dAc, \dAf,
+ and \dAo, which provide slightly more sophisticated
+ versions of these queries.
+
11.4. Indexes and ORDER BY #
+ In addition to simply finding the rows to be returned by a query,
+ an index may be able to deliver them in a specific sorted order.
+ This allows a query's ORDER BY specification to be honored
+ without a separate sorting step. Of the index types currently
+ supported by PostgreSQL, only B-tree
+ can produce sorted output — the other index types return
+ matching rows in an unspecified, implementation-dependent order.
+
+ The planner will consider satisfying an ORDER BY specification
+ either by scanning an available index that matches the specification,
+ or by scanning the table in physical order and doing an explicit
+ sort. For a query that requires scanning a large fraction of the
+ table, an explicit sort is likely to be faster than using an index
+ because it requires
+ less disk I/O due to following a sequential access pattern. Indexes are
+ more useful when only a few rows need be fetched. An important
+ special case is ORDER BY in combination with
+ LIMIT n: an explicit sort will have to process
+ all the data to identify the first n rows, but if there is
+ an index matching the ORDER BY, the first n
+ rows can be retrieved directly, without scanning the remainder at all.
+
+ By default, B-tree indexes store their entries in ascending order
+ with nulls last (table TID is treated as a tiebreaker column among
+ otherwise equal entries). This means that a forward scan of an
+ index on column x produces output satisfying ORDER BY x
+ (or more verbosely, ORDER BY x ASC NULLS LAST). The
+ index can also be scanned backward, producing output satisfying
+ ORDER BY x DESC
+ (or more verbosely, ORDER BY x DESC NULLS FIRST, since
+ NULLS FIRST is the default for ORDER BY DESC).
+
+ You can adjust the ordering of a B-tree index by including the
+ options ASC, DESC, NULLS FIRST,
+ and/or NULLS LAST when creating the index; for example:
+
+CREATE INDEX test2_info_nulls_low ON test2 (info NULLS FIRST);
+CREATE INDEX test3_desc_index ON test3 (id DESC NULLS LAST);
+
+ An index stored in ascending order with nulls first can satisfy
+ either ORDER BY x ASC NULLS FIRST or
+ ORDER BY x DESC NULLS LAST depending on which direction
+ it is scanned in.
+
+ You might wonder why bother providing all four options, when two
+ options together with the possibility of backward scan would cover
+ all the variants of ORDER BY. In single-column indexes
+ the options are indeed redundant, but in multicolumn indexes they can be
+ useful. Consider a two-column index on (x, y): this can
+ satisfy ORDER BY x, y if we scan forward, or
+ ORDER BY x DESC, y DESC if we scan backward.
+ But it might be that the application frequently needs to use
+ ORDER BY x ASC, y DESC. There is no way to get that
+ ordering from a plain index, but it is possible if the index is defined
+ as (x ASC, y DESC) or (x DESC, y ASC).
+
+ Obviously, indexes with non-default sort orderings are a fairly
+ specialized feature, but sometimes they can produce tremendous
+ speedups for certain queries. Whether it's worth maintaining such an
+ index depends on how often you use queries that require a special
+ sort ordering.
+
+ A partial index is an index built over a
+ subset of a table; the subset is defined by a conditional
+ expression (called the predicate of the
+ partial index). The index contains entries only for those table
+ rows that satisfy the predicate. Partial indexes are a specialized
+ feature, but there are several situations in which they are useful.
+
+ One major reason for using a partial index is to avoid indexing common
+ values. Since a query searching for a common value (one that
+ accounts for more than a few percent of all the table rows) will not
+ use the index anyway, there is no point in keeping those rows in the
+ index at all. This reduces the size of the index, which will speed
+ up those queries that do use the index. It will also speed up many table
+ update operations because the index does not need to be
+ updated in all cases. Example 11.1 shows a
+ possible application of this idea.
+
Example 11.1. Setting up a Partial Index to Exclude Common Values
+ Suppose you are storing web server access logs in a database.
+ Most accesses originate from the IP address range of your organization but
+ some are from elsewhere (say, employees on dial-up connections).
+ If your searches by IP are primarily for outside accesses,
+ you probably do not need to index the IP range that corresponds to your
+ organization's subnet.
+
+ Assume a table like this:
+
+CREATE TABLE access_log (
+ url varchar,
+ client_ip inet,
+ ...
+);
+
+
+ To create a partial index that suits our example, use a command
+ such as this:
+
+CREATE INDEX access_log_client_ip_ix ON access_log (client_ip)
+WHERE NOT (client_ip > inet '192.168.100.0' AND
+ client_ip < inet '192.168.100.255');
+
+
+ A typical query that can use this index would be:
+
+SELECT *
+FROM access_log
+WHERE url = '/index.html' AND client_ip = inet '212.78.10.32';
+
+ Here the query's IP address is covered by the partial index. The
+ following query cannot use the partial index, as it uses an IP address
+ that is excluded from the index:
+
+SELECT *
+FROM access_log
+WHERE url = '/index.html' AND client_ip = inet '192.168.100.23';
+
+
+ Observe that this kind of partial index requires that the common
+ values be predetermined, so such partial indexes are best used for
+ data distributions that do not change. Such indexes can be recreated
+ occasionally to adjust for new data distributions, but this adds
+ maintenance effort.
+
+ Another possible use for a partial index is to exclude values from the
+ index that the
+ typical query workload is not interested in; this is shown in Example 11.2. This results in the same
+ advantages as listed above, but it prevents the
+ “uninteresting” values from being accessed via that
+ index, even if an index scan might be profitable in that
+ case. Obviously, setting up partial indexes for this kind of
+ scenario will require a lot of care and experimentation.
+
Example 11.2. Setting up a Partial Index to Exclude Uninteresting Values
+ If you have a table that contains both billed and unbilled orders,
+ where the unbilled orders take up a small fraction of the total
+ table and yet those are the most-accessed rows, you can improve
+ performance by creating an index on just the unbilled rows. The
+ command to create the index would look like this:
+
+CREATE INDEX orders_unbilled_index ON orders (order_nr)
+ WHERE billed is not true;
+
+
+ A possible query to use this index would be:
+
+SELECT * FROM orders WHERE billed is not true AND order_nr < 10000;
+
+ However, the index can also be used in queries that do not involve
+ order_nr at all, e.g.:
+
+SELECT * FROM orders WHERE billed is not true AND amount > 5000.00;
+
+ This is not as efficient as a partial index on the
+ amount column would be, since the system has to
+ scan the entire index. Yet, if there are relatively few unbilled
+ orders, using this partial index just to find the unbilled orders
+ could be a win.
+
+ Note that this query cannot use this index:
+
+SELECT * FROM orders WHERE order_nr = 3501;
+
+ The order 3501 might be among the billed or unbilled
+ orders.
+
+ Example 11.2 also illustrates that the
+ indexed column and the column used in the predicate do not need to
+ match. PostgreSQL supports partial
+ indexes with arbitrary predicates, so long as only columns of the
+ table being indexed are involved. However, keep in mind that the
+ predicate must match the conditions used in the queries that
+ are supposed to benefit from the index. To be precise, a partial
+ index can be used in a query only if the system can recognize that
+ the WHERE condition of the query mathematically implies
+ the predicate of the index.
+ PostgreSQL does not have a sophisticated
+ theorem prover that can recognize mathematically equivalent
+ expressions that are written in different forms. (Not
+ only is such a general theorem prover extremely difficult to
+ create, it would probably be too slow to be of any real use.)
+ The system can recognize simple inequality implications, for example
+ “x < 1” implies “x < 2”; otherwise
+ the predicate condition must exactly match part of the query's
+ WHERE condition
+ or the index will not be recognized as usable. Matching takes
+ place at query planning time, not at run time. As a result,
+ parameterized query clauses do not work with a partial index. For
+ example a prepared query with a parameter might specify
+ “x < ?” which will never imply
+ “x < 2” for all possible values of the parameter.
+
+ A third possible use for partial indexes does not require the
+ index to be used in queries at all. The idea here is to create
+ a unique index over a subset of a table, as in Example 11.3. This enforces uniqueness
+ among the rows that satisfy the index predicate, without constraining
+ those that do not.
+
Example 11.3. Setting up a Partial Unique Index
+ Suppose that we have a table describing test outcomes. We wish
+ to ensure that there is only one “successful” entry for
+ a given subject and target combination, but there might be any number of
+ “unsuccessful” entries. Here is one way to do it:
+
+CREATE TABLE tests (
+ subject text,
+ target text,
+ success boolean,
+ ...
+);
+
+CREATE UNIQUE INDEX tests_success_constraint ON tests (subject, target)
+ WHERE success;
+
+ This is a particularly efficient approach when there are few
+ successful tests and many unsuccessful ones. It is also possible to
+ allow only one null in a column by creating a unique partial index
+ with an IS NULL restriction.
+
+ Finally, a partial index can also be used to override the system's
+ query plan choices. Also, data sets with peculiar
+ distributions might cause the system to use an index when it really
+ should not. In that case the index can be set up so that it is not
+ available for the offending query. Normally,
+ PostgreSQL makes reasonable choices about index
+ usage (e.g., it avoids them when retrieving common values, so the
+ earlier example really only saves index size, it is not required to
+ avoid index usage), and grossly incorrect plan choices are cause
+ for a bug report.
+
+ Keep in mind that setting up a partial index indicates that you
+ know at least as much as the query planner knows, in particular you
+ know when an index might be profitable. Forming this knowledge
+ requires experience and understanding of how indexes in
+ PostgreSQL work. In most cases, the
+ advantage of a partial index over a regular index will be minimal.
+ There are cases where they are quite counterproductive, as in Example 11.4.
+
Example 11.4. Do Not Use Partial Indexes as a Substitute for Partitioning
+ You might be tempted to create a large set of non-overlapping partial
+ indexes, for example
+
+
+CREATE INDEX mytable_cat_1 ON mytable (data) WHERE category = 1;
+CREATE INDEX mytable_cat_2 ON mytable (data) WHERE category = 2;
+CREATE INDEX mytable_cat_3 ON mytable (data) WHERE category = 3;
+...
+CREATE INDEX mytable_cat_N ON mytable (data) WHERE category = N;
+
+
+ This is a bad idea! Almost certainly, you'll be better off with a
+ single non-partial index, declared like
+
+
+CREATE INDEX mytable_cat_data ON mytable (category, data);
+
+
+ (Put the category column first, for the reasons described in
+ Section 11.3.) While a search in this larger
+ index might have to descend through a couple more tree levels than a
+ search in a smaller index, that's almost certainly going to be cheaper
+ than the planner effort needed to select the appropriate one of the
+ partial indexes. The core of the problem is that the system does not
+ understand the relationship among the partial indexes, and will
+ laboriously test each one to see if it's applicable to the current
+ query.
+
+ If your table is large enough that a single index really is a bad idea,
+ you should look into using partitioning instead (see
+ Section 5.11). With that mechanism, the system
+ does understand that the tables and indexes are non-overlapping, so
+ far better performance is possible.
+
+ More information about partial indexes can be found in [ston89b], [olson93], and [seshadri95].
+
+ PostgreSQL provides several index types:
+ B-tree, Hash, GiST, SP-GiST, GIN, BRIN, and the extension bloom.
+ Each index type uses a different
+ algorithm that is best suited to different types of indexable clauses.
+ By default, the CREATE
+ INDEX command creates
+ B-tree indexes, which fit the most common situations.
+ The other index types are selected by writing the keyword
+ USING followed by the index type name.
+ For example, to create a Hash index:
+
+CREATE INDEX name ON table USING HASH (column);
+
+
+ B-trees can handle equality and range queries on data that can be sorted
+ into some ordering.
+ In particular, the PostgreSQL query planner
+ will consider using a B-tree index whenever an indexed column is
+ involved in a comparison using one of these operators:
+
+
+< <= = >= >
+
+
+ Constructs equivalent to combinations of these operators, such as
+ BETWEEN and IN, can also be implemented with
+ a B-tree index search. Also, an IS NULL or IS NOT
+ NULL condition on an index column can be used with a B-tree index.
+
+ The optimizer can also use a B-tree index for queries involving the
+ pattern matching operators LIKE and ~
+ if the pattern is a constant and is anchored to
+ the beginning of the string — for example, col LIKE
+ 'foo%' or col ~ '^foo', but not
+ col LIKE '%bar'. However, if your database does not
+ use the C locale you will need to create the index with a special
+ operator class to support indexing of pattern-matching queries; see
+ Section 11.10 below. It is also possible to use
+ B-tree indexes for ILIKE and
+ ~*, but only if the pattern starts with
+ non-alphabetic characters, i.e., characters that are not affected by
+ upper/lower case conversion.
+
+ B-tree indexes can also be used to retrieve data in sorted order.
+ This is not always faster than a simple scan and sort, but it is
+ often helpful.
+
+ Hash indexes store a 32-bit hash code derived from the
+ value of the indexed column. Hence,
+ such indexes can only handle simple equality comparisons.
+ The query planner will consider using a hash index whenever an
+ indexed column is involved in a comparison using the
+ equal operator:
+
+
+=
+
+
+ GiST indexes are not a single kind of index, but rather an infrastructure
+ within which many different indexing strategies can be implemented.
+ Accordingly, the particular operators with which a GiST index can be
+ used vary depending on the indexing strategy (the operator
+ class). As an example, the standard distribution of
+ PostgreSQL includes GiST operator classes
+ for several two-dimensional geometric data types, which support indexed
+ queries using these operators:
+
+
+<< &< &> >> <<| &<| |&> |>> @> <@ ~= &&
+
+
+ (See Section 9.11 for the meaning of
+ these operators.)
+ The GiST operator classes included in the standard distribution are
+ documented in Table 68.1.
+ Many other GiST operator
+ classes are available in the contrib collection or as separate
+ projects. For more information see Chapter 68.
+
+ GiST indexes are also capable of optimizing “nearest-neighbor”
+ searches, such as
+
+SELECT * FROM places ORDER BY location <-> point '(101,456)' LIMIT 10;
+
+
+ which finds the ten places closest to a given target point. The ability
+ to do this is again dependent on the particular operator class being used.
+ In Table 68.1, operators that can be
+ used in this way are listed in the column “Ordering Operators”.
+
+ SP-GiST indexes, like GiST indexes, offer an infrastructure that supports
+ various kinds of searches. SP-GiST permits implementation of a wide range
+ of different non-balanced disk-based data structures, such as quadtrees,
+ k-d trees, and radix trees (tries). As an example, the standard distribution of
+ PostgreSQL includes SP-GiST operator classes
+ for two-dimensional points, which support indexed
+ queries using these operators:
+
+
+<< >> ~= <@ <<| |>>
+
+
+ (See Section 9.11 for the meaning of
+ these operators.)
+ The SP-GiST operator classes included in the standard distribution are
+ documented in Table 69.1.
+ For more information see Chapter 69.
+
+ Like GiST, SP-GiST supports “nearest-neighbor” searches.
+ For SP-GiST operator classes that support distance ordering, the
+ corresponding operator is listed in the “Ordering Operators”
+ column in Table 69.1.
+
+ GIN indexes are “inverted indexes” which are appropriate for
+ data values that contain multiple component values, such as arrays. An
+ inverted index contains a separate entry for each component value, and
+ can efficiently handle queries that test for the presence of specific
+ component values.
+
+ Like GiST and SP-GiST, GIN can support
+ many different user-defined indexing strategies, and the particular
+ operators with which a GIN index can be used vary depending on the
+ indexing strategy.
+ As an example, the standard distribution of
+ PostgreSQL includes a GIN operator class
+ for arrays, which supports indexed queries using these operators:
+
+
+<@ @> = &&
+
+
+ (See Section 9.19 for the meaning of
+ these operators.)
+ The GIN operator classes included in the standard distribution are
+ documented in Table 70.1.
+ Many other GIN operator
+ classes are available in the contrib collection or as separate
+ projects. For more information see Chapter 70.
+
+ BRIN indexes (a shorthand for Block Range INdexes) store summaries about
+ the values stored in consecutive physical block ranges of a table.
+ Thus, they are most effective for columns whose values are well-correlated
+ with the physical order of the table rows.
+ Like GiST, SP-GiST and GIN,
+ BRIN can support many different indexing strategies,
+ and the particular operators with which a BRIN index can be used
+ vary depending on the indexing strategy.
+ For data types that have a linear sort order, the indexed data
+ corresponds to the minimum and maximum values of the
+ values in the column for each block range. This supports indexed queries
+ using these operators:
+
+
+< <= = >= >
+
+
+ The BRIN operator classes included in the standard distribution are
+ documented in Table 71.1.
+ For more information see Chapter 71.
+
+ Indexes can also be used to enforce uniqueness of a column's value,
+ or the uniqueness of the combined values of more than one column.
+
+CREATE UNIQUE INDEX name ON table (column [, ...]) [ NULLS [ NOT ] DISTINCT ];
+
+ Currently, only B-tree indexes can be declared unique.
+
+ When an index is declared unique, multiple table rows with equal
+ indexed values are not allowed. By default, null values in a unique column
+ are not considered equal, allowing multiple nulls in the column. The
+ NULLS NOT DISTINCT option modifies this and causes the
+ index to treat nulls as equal. A multicolumn unique index will only reject
+ cases where all indexed columns are equal in multiple rows.
+
+ PostgreSQL automatically creates a unique
+ index when a unique constraint or primary key is defined for a table.
+ The index covers the columns that make up the primary key or unique
+ constraint (a multicolumn index, if appropriate), and is the mechanism
+ that enforces the constraint.
+
Note
+ There's no need to manually
+ create indexes on unique columns; doing so would just duplicate
+ the automatically-created index.
+
+ Indexes are a common way to enhance database performance. An index
+ allows the database server to find and retrieve specific rows much
+ faster than it could do without an index. But indexes also add
+ overhead to the database system as a whole, so they should be used
+ sensibly.
+
37.4. administrable_role_authorizations #
+ The view administrable_role_authorizations
+ identifies all roles that the current user has the admin option
+ for.
+
Table 37.2. administrable_role_authorizations Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ grantee sql_identifier
+
+
+ Name of the role to which this role membership was granted (can
+ be the current user, or a different role in case of nested role
+ memberships)
+ |
+ role_name sql_identifier
+
+
+ Name of a role
+ |
+ is_grantable yes_or_no
+
+
+ Always YES
+ |
+ The view applicable_roles identifies all roles
+ whose privileges the current user can use. This means there is
+ some chain of role grants from the current user to the role in
+ question. The current user itself is also an applicable role. The
+ set of applicable roles is generally used for permission checking.
+
+
+
Table 37.3. applicable_roles Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ grantee sql_identifier
+
+
+ Name of the role to which this role membership was granted (can
+ be the current user, or a different role in case of nested role
+ memberships)
+ |
+ role_name sql_identifier
+
+
+ Name of a role
+ |
+ is_grantable yes_or_no
+
+
+ YES if the grantee has the admin option on
+ the role, NO if not
+ |
+ The view attributes contains information about
+ the attributes of composite data types defined in the database.
+ (Note that the view does not give information about table columns,
+ which are sometimes called attributes in PostgreSQL contexts.)
+ Only those attributes are shown that the current user has access to (by way
+ of being the owner of or having some privilege on the type).
+
Table 37.4. attributes Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ udt_catalog sql_identifier
+
+
+ Name of the database containing the data type (always the current database)
+ |
+ udt_schema sql_identifier
+
+
+ Name of the schema containing the data type
+ |
+ udt_name sql_identifier
+
+
+ Name of the data type
+ |
+ attribute_name sql_identifier
+
+
+ Name of the attribute
+ |
+ ordinal_position cardinal_number
+
+
+ Ordinal position of the attribute within the data type (count starts at 1)
+ |
+ attribute_default character_data
+
+
+ Default expression of the attribute
+ |
+ is_nullable yes_or_no
+
+
+ YES if the attribute is possibly nullable,
+ NO if it is known not nullable.
+ |
+ data_type character_data
+
+
+ Data type of the attribute, if it is a built-in type, or
+ ARRAY if it is some array (in that case, see
+ the view element_types), else
+ USER-DEFINED (in that case, the type is
+ identified in attribute_udt_name and
+ associated columns).
+ |
+ character_maximum_length cardinal_number
+
+
+ If data_type identifies a character or bit
+ string type, the declared maximum length; null for all other
+ data types or if no maximum length was declared.
+ |
+ character_octet_length cardinal_number
+
+
+ If data_type identifies a character type,
+ the maximum possible length in octets (bytes) of a datum; null
+ for all other data types. The maximum octet length depends on
+ the declared character maximum length (see above) and the
+ server encoding.
+ |
+ character_set_catalog sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ character_set_schema sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ character_set_name sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ collation_catalog sql_identifier
+
+
+ Name of the database containing the collation of the attribute
+ (always the current database), null if default or the data type
+ of the attribute is not collatable
+ |
+ collation_schema sql_identifier
+
+
+ Name of the schema containing the collation of the attribute,
+ null if default or the data type of the attribute is not
+ collatable
+ |
+ collation_name sql_identifier
+
+
+ Name of the collation of the attribute, null if default or the
+ data type of the attribute is not collatable
+ |
+ numeric_precision cardinal_number
+
+
+ If data_type identifies a numeric type, this
+ column contains the (declared or implicit) precision of the
+ type for this attribute. The precision indicates the number of
+ significant digits. It can be expressed in decimal (base 10)
+ or binary (base 2) terms, as specified in the column
+ numeric_precision_radix. For all other data
+ types, this column is null.
+ |
+ numeric_precision_radix cardinal_number
+
+
+ If data_type identifies a numeric type, this
+ column indicates in which base the values in the columns
+ numeric_precision and
+ numeric_scale are expressed. The value is
+ either 2 or 10. For all other data types, this column is null.
+ |
+ numeric_scale cardinal_number
+
+
+ If data_type identifies an exact numeric
+ type, this column contains the (declared or implicit) scale of
+ the type for this attribute. The scale indicates the number of
+ significant digits to the right of the decimal point. It can
+ be expressed in decimal (base 10) or binary (base 2) terms, as
+ specified in the column
+ numeric_precision_radix. For all other data
+ types, this column is null.
+ |
+ datetime_precision cardinal_number
+
+
+ If data_type identifies a date, time,
+ timestamp, or interval type, this column contains the (declared
+ or implicit) fractional seconds precision of the type for this
+ attribute, that is, the number of decimal digits maintained
+ following the decimal point in the seconds value. For all
+ other data types, this column is null.
+ |
+ interval_type character_data
+
+
+ If data_type identifies an interval type,
+ this column contains the specification which fields the
+ intervals include for this attribute, e.g., YEAR TO
+ MONTH, DAY TO SECOND, etc. If no
+ field restrictions were specified (that is, the interval
+ accepts all fields), and for all other data types, this field
+ is null.
+ |
+ interval_precision cardinal_number
+
+
+ Applies to a feature not available
+ in PostgreSQL
+ (see datetime_precision for the fractional
+ seconds precision of interval type attributes)
+ |
+ attribute_udt_catalog sql_identifier
+
+
+ Name of the database that the attribute data type is defined in
+ (always the current database)
+ |
+ attribute_udt_schema sql_identifier
+
+
+ Name of the schema that the attribute data type is defined in
+ |
+ attribute_udt_name sql_identifier
+
+
+ Name of the attribute data type
+ |
+ scope_catalog sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ scope_schema sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ scope_name sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ maximum_cardinality cardinal_number
+
+
+ Always null, because arrays always have unlimited maximum cardinality in PostgreSQL
+ |
+ dtd_identifier sql_identifier
+
+
+ An identifier of the data type descriptor of the column, unique
+ among the data type descriptors pertaining to the table. This
+ is mainly useful for joining with other instances of such
+ identifiers. (The specific format of the identifier is not
+ defined and not guaranteed to remain the same in future
+ versions.)
+ |
+ is_derived_reference_attribute yes_or_no
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ See also under Section 37.17, a similarly
+ structured view, for further information on some of the columns.
+
+ The view character_sets identifies the character
+ sets available in the current database. Since PostgreSQL does not
+ support multiple character sets within one database, this view only
+ shows one, which is the database encoding.
+
+ Take note of how the following terms are used in the SQL standard:
+
- character repertoire
+ An abstract collection of characters, for
+ example UNICODE, UCS, or
+ LATIN1. Not exposed as an SQL object, but
+ visible in this view.
+
- character encoding form
+ An encoding of some character repertoire. Most older character
+ repertoires only use one encoding form, and so there are no
+ separate names for them (e.g., LATIN2 is an
+ encoding form applicable to the LATIN2
+ repertoire). But for example Unicode has the encoding forms
+ UTF8, UTF16, etc. (not
+ all supported by PostgreSQL). Encoding forms are not exposed
+ as an SQL object, but are visible in this view.
+
- character set
+ A named SQL object that identifies a character repertoire, a
+ character encoding, and a default collation. A predefined
+ character set would typically have the same name as an encoding
+ form, but users could define other names. For example, the
+ character set UTF8 would typically identify
+ the character repertoire UCS, encoding
+ form UTF8, and some default collation.
+
+
+ You can think of an “encoding” in PostgreSQL either as
+ a character set or a character encoding form. They will have the
+ same name, and there can only be one in one database.
+
Table 37.5. character_sets Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ character_set_catalog sql_identifier
+
+
+ Character sets are currently not implemented as schema objects, so this column is null.
+ |
+ character_set_schema sql_identifier
+
+
+ Character sets are currently not implemented as schema objects, so this column is null.
+ |
+ character_set_name sql_identifier
+
+
+ Name of the character set, currently implemented as showing the name of the database encoding
+ |
+ character_repertoire sql_identifier
+
+
+ Character repertoire, showing UCS if the encoding is UTF8, else just the encoding name
+ |
+ form_of_use sql_identifier
+
+
+ Character encoding form, same as the database encoding
+ |
+ default_collate_catalog sql_identifier
+
+
+ Name of the database containing the default collation (always the current database, if any collation is identified)
+ |
+ default_collate_schema sql_identifier
+
+
+ Name of the schema containing the default collation
+ |
+ default_collate_name sql_identifier
+
+
+ Name of the default collation. The default collation is
+ identified as the collation that matches
+ the COLLATE and CTYPE
+ settings of the current database. If there is no such
+ collation, then this column and the associated schema and
+ catalog columns are null.
+ |
37.8. check_constraint_routine_usage #
+ The view check_constraint_routine_usage
+ identifies routines (functions and procedures) that are used by a
+ check constraint. Only those routines are shown that are owned by
+ a currently enabled role.
+
Table 37.6. check_constraint_routine_usage Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ constraint_catalog sql_identifier
+
+
+ Name of the database containing the constraint (always the current database)
+ |
+ constraint_schema sql_identifier
+
+
+ Name of the schema containing the constraint
+ |
+ constraint_name sql_identifier
+
+
+ Name of the constraint
+ |
+ specific_catalog sql_identifier
+
+
+ Name of the database containing the function (always the current database)
+ |
+ specific_schema sql_identifier
+
+
+ Name of the schema containing the function
+ |
+ specific_name sql_identifier
+
+
+ The “specific name” of the function. See Section 37.45 for more information.
+ |
37.9. check_constraints #
+ The view check_constraints contains all check
+ constraints, either defined on a table or on a domain, that are
+ owned by a currently enabled role. (The owner of the table or
+ domain is the owner of the constraint.)
+
Table 37.7. check_constraints Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ constraint_catalog sql_identifier
+
+
+ Name of the database containing the constraint (always the current database)
+ |
+ constraint_schema sql_identifier
+
+
+ Name of the schema containing the constraint
+ |
+ constraint_name sql_identifier
+
+
+ Name of the constraint
+ |
+ check_clause character_data
+
+
+ The check expression of the check constraint
+ |
37.11. collation_character_set_applicability #
+ The view collation_character_set_applicability
+ identifies which character set the available collations are
+ applicable to. In PostgreSQL, there is only one character set per
+ database (see explanation
+ in Section 37.7), so this view does
+ not provide much useful information.
+
Table 37.9. collation_character_set_applicability Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ collation_catalog sql_identifier
+
+
+ Name of the database containing the collation (always the current database)
+ |
+ collation_schema sql_identifier
+
+
+ Name of the schema containing the collation
+ |
+ collation_name sql_identifier
+
+
+ Name of the default collation
+ |
+ character_set_catalog sql_identifier
+
+
+ Character sets are currently not implemented as schema objects, so this column is null
+ |
+ character_set_schema sql_identifier
+
+
+ Character sets are currently not implemented as schema objects, so this column is null
+ |
+ character_set_name sql_identifier
+
+
+ Name of the character set
+ |
+ The view collations contains the collations
+ available in the current database.
+
Table 37.8. collations Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ collation_catalog sql_identifier
+
+
+ Name of the database containing the collation (always the current database)
+ |
+ collation_schema sql_identifier
+
+
+ Name of the schema containing the collation
+ |
+ collation_name sql_identifier
+
+
+ Name of the default collation
+ |
+ pad_attribute character_data
+
+
+ Always NO PAD (The alternative PAD
+ SPACE is not supported by PostgreSQL.)
+ |
37.12. column_column_usage #
+ The view column_column_usage identifies all generated
+ columns that depend on another base column in the same table. Only tables
+ owned by a currently enabled role are included.
+
Table 37.10. column_column_usage Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ table_catalog sql_identifier
+
+
+ Name of the database containing the table (always the current database)
+ |
+ table_schema sql_identifier
+
+
+ Name of the schema containing the table
+ |
+ table_name sql_identifier
+
+
+ Name of the table
+ |
+ column_name sql_identifier
+
+
+ Name of the base column that a generated column depends on
+ |
+ dependent_column sql_identifier
+
+
+ Name of the generated column
+ |
37.13. column_domain_usage #
+ The view column_domain_usage identifies all
+ columns (of a table or a view) that make use of some domain defined
+ in the current database and owned by a currently enabled role.
+
Table 37.11. column_domain_usage Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ domain_catalog sql_identifier
+
+
+ Name of the database containing the domain (always the current database)
+ |
+ domain_schema sql_identifier
+
+
+ Name of the schema containing the domain
+ |
+ domain_name sql_identifier
+
+
+ Name of the domain
+ |
+ table_catalog sql_identifier
+
+
+ Name of the database containing the table (always the current database)
+ |
+ table_schema sql_identifier
+
+
+ Name of the schema containing the table
+ |
+ table_name sql_identifier
+
+
+ Name of the table
+ |
+ column_name sql_identifier
+
+
+ Name of the column
+ |
+ The view column_options contains all the
+ options defined for foreign table columns in the current database. Only
+ those foreign table columns are shown that the current user has access to
+ (by way of being the owner or having some privilege).
+
Table 37.12. column_options Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ table_catalog sql_identifier
+
+
+ Name of the database that contains the foreign table (always the current database)
+ |
+ table_schema sql_identifier
+
+
+ Name of the schema that contains the foreign table
+ |
+ table_name sql_identifier
+
+
+ Name of the foreign table
+ |
+ column_name sql_identifier
+
+
+ Name of the column
+ |
+ option_name sql_identifier
+
+
+ Name of an option
+ |
+ option_value character_data
+
+
+ Value of the option
+ |
37.15. column_privileges #
+ The view column_privileges identifies all
+ privileges granted on columns to a currently enabled role or by a
+ currently enabled role. There is one row for each combination of
+ column, grantor, and grantee.
+
+ If a privilege has been granted on an entire table, it will show up in
+ this view as a grant for each column, but only for the
+ privilege types where column granularity is possible:
+ SELECT, INSERT,
+ UPDATE, REFERENCES.
+
Table 37.13. column_privileges Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ grantor sql_identifier
+
+
+ Name of the role that granted the privilege
+ |
+ grantee sql_identifier
+
+
+ Name of the role that the privilege was granted to
+ |
+ table_catalog sql_identifier
+
+
+ Name of the database that contains the table that contains the column (always the current database)
+ |
+ table_schema sql_identifier
+
+
+ Name of the schema that contains the table that contains the column
+ |
+ table_name sql_identifier
+
+
+ Name of the table that contains the column
+ |
+ column_name sql_identifier
+
+
+ Name of the column
+ |
+ privilege_type character_data
+
+
+ Type of the privilege: SELECT,
+ INSERT, UPDATE, or
+ REFERENCES
+ |
+ is_grantable yes_or_no
+
+
+ YES if the privilege is grantable, NO if not
+ |
37.16. column_udt_usage #
+ The view column_udt_usage identifies all columns
+ that use data types owned by a currently enabled role. Note that in
+ PostgreSQL, built-in data types behave
+ like user-defined types, so they are included here as well. See
+ also Section 37.17 for details.
+
Table 37.14. column_udt_usage Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ udt_catalog sql_identifier
+
+
+ Name of the database that the column data type (the underlying
+ type of the domain, if applicable) is defined in (always the
+ current database)
+ |
+ udt_schema sql_identifier
+
+
+ Name of the schema that the column data type (the underlying
+ type of the domain, if applicable) is defined in
+ |
+ udt_name sql_identifier
+
+
+ Name of the column data type (the underlying type of the
+ domain, if applicable)
+ |
+ table_catalog sql_identifier
+
+
+ Name of the database containing the table (always the current database)
+ |
+ table_schema sql_identifier
+
+
+ Name of the schema containing the table
+ |
+ table_name sql_identifier
+
+
+ Name of the table
+ |
+ column_name sql_identifier
+
+
+ Name of the column
+ |
+ The view columns contains information about all
+ table columns (or view columns) in the database. System columns
+ (ctid, etc.) are not included. Only those columns are
+ shown that the current user has access to (by way of being the
+ owner or having some privilege).
+
Table 37.15. columns Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ table_catalog sql_identifier
+
+
+ Name of the database containing the table (always the current database)
+ |
+ table_schema sql_identifier
+
+
+ Name of the schema containing the table
+ |
+ table_name sql_identifier
+
+
+ Name of the table
+ |
+ column_name sql_identifier
+
+
+ Name of the column
+ |
+ ordinal_position cardinal_number
+
+
+ Ordinal position of the column within the table (count starts at 1)
+ |
+ column_default character_data
+
+
+ Default expression of the column
+ |
+ is_nullable yes_or_no
+
+
+ YES if the column is possibly nullable,
+ NO if it is known not nullable. A not-null
+ constraint is one way a column can be known not nullable, but
+ there can be others.
+ |
+ data_type character_data
+
+
+ Data type of the column, if it is a built-in type, or
+ ARRAY if it is some array (in that case, see
+ the view element_types), else
+ USER-DEFINED (in that case, the type is
+ identified in udt_name and associated
+ columns). If the column is based on a domain, this column
+ refers to the type underlying the domain (and the domain is
+ identified in domain_name and associated
+ columns).
+ |
+ character_maximum_length cardinal_number
+
+
+ If data_type identifies a character or bit
+ string type, the declared maximum length; null for all other
+ data types or if no maximum length was declared.
+ |
+ character_octet_length cardinal_number
+
+
+ If data_type identifies a character type,
+ the maximum possible length in octets (bytes) of a datum; null
+ for all other data types. The maximum octet length depends on
+ the declared character maximum length (see above) and the
+ server encoding.
+ |
+ numeric_precision cardinal_number
+
+
+ If data_type identifies a numeric type, this
+ column contains the (declared or implicit) precision of the
+ type for this column. The precision indicates the number of
+ significant digits. It can be expressed in decimal (base 10)
+ or binary (base 2) terms, as specified in the column
+ numeric_precision_radix. For all other data
+ types, this column is null.
+ |
+ numeric_precision_radix cardinal_number
+
+
+ If data_type identifies a numeric type, this
+ column indicates in which base the values in the columns
+ numeric_precision and
+ numeric_scale are expressed. The value is
+ either 2 or 10. For all other data types, this column is null.
+ |
+ numeric_scale cardinal_number
+
+
+ If data_type identifies an exact numeric
+ type, this column contains the (declared or implicit) scale of
+ the type for this column. The scale indicates the number of
+ significant digits to the right of the decimal point. It can
+ be expressed in decimal (base 10) or binary (base 2) terms, as
+ specified in the column
+ numeric_precision_radix. For all other data
+ types, this column is null.
+ |
+ datetime_precision cardinal_number
+
+
+ If data_type identifies a date, time,
+ timestamp, or interval type, this column contains the (declared
+ or implicit) fractional seconds precision of the type for this
+ column, that is, the number of decimal digits maintained
+ following the decimal point in the seconds value. For all
+ other data types, this column is null.
+ |
+ interval_type character_data
+
+
+ If data_type identifies an interval type,
+ this column contains the specification which fields the
+ intervals include for this column, e.g., YEAR TO
+ MONTH, DAY TO SECOND, etc. If no
+ field restrictions were specified (that is, the interval
+ accepts all fields), and for all other data types, this field
+ is null.
+ |
+ interval_precision cardinal_number
+
+
+ Applies to a feature not available
+ in PostgreSQL
+ (see datetime_precision for the fractional
+ seconds precision of interval type columns)
+ |
+ character_set_catalog sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ character_set_schema sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ character_set_name sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ collation_catalog sql_identifier
+
+
+ Name of the database containing the collation of the column
+ (always the current database), null if default or the data type
+ of the column is not collatable
+ |
+ collation_schema sql_identifier
+
+
+ Name of the schema containing the collation of the column, null
+ if default or the data type of the column is not collatable
+ |
+ collation_name sql_identifier
+
+
+ Name of the collation of the column, null if default or the
+ data type of the column is not collatable
+ |
+ domain_catalog sql_identifier
+
+
+ If the column has a domain type, the name of the database that
+ the domain is defined in (always the current database), else
+ null.
+ |
+ domain_schema sql_identifier
+
+
+ If the column has a domain type, the name of the schema that
+ the domain is defined in, else null.
+ |
+ domain_name sql_identifier
+
+
+ If the column has a domain type, the name of the domain, else null.
+ |
+ udt_catalog sql_identifier
+
+
+ Name of the database that the column data type (the underlying
+ type of the domain, if applicable) is defined in (always the
+ current database)
+ |
+ udt_schema sql_identifier
+
+
+ Name of the schema that the column data type (the underlying
+ type of the domain, if applicable) is defined in
+ |
+ udt_name sql_identifier
+
+
+ Name of the column data type (the underlying type of the
+ domain, if applicable)
+ |
+ scope_catalog sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ scope_schema sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ scope_name sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ maximum_cardinality cardinal_number
+
+
+ Always null, because arrays always have unlimited maximum cardinality in PostgreSQL
+ |
+ dtd_identifier sql_identifier
+
+
+ An identifier of the data type descriptor of the column, unique
+ among the data type descriptors pertaining to the table. This
+ is mainly useful for joining with other instances of such
+ identifiers. (The specific format of the identifier is not
+ defined and not guaranteed to remain the same in future
+ versions.)
+ |
+ is_self_referencing yes_or_no
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ is_identity yes_or_no
+
+
+ If the column is an identity column, then YES,
+ else NO.
+ |
+ identity_generation character_data
+
+
+ If the column is an identity column, then ALWAYS
+ or BY DEFAULT, reflecting the definition of the
+ column.
+ |
+ identity_start character_data
+
+
+ If the column is an identity column, then the start value of the
+ internal sequence, else null.
+ |
+ identity_increment character_data
+
+
+ If the column is an identity column, then the increment of the internal
+ sequence, else null.
+ |
+ identity_maximum character_data
+
+
+ If the column is an identity column, then the maximum value of the
+ internal sequence, else null.
+ |
+ identity_minimum character_data
+
+
+ If the column is an identity column, then the minimum value of the
+ internal sequence, else null.
+ |
+ identity_cycle yes_or_no
+
+
+ If the column is an identity column, then YES if the
+ internal sequence cycles or NO if it does not;
+ otherwise null.
+ |
+ is_generated character_data
+
+
+ If the column is a generated column, then ALWAYS,
+ else NEVER.
+ |
+ generation_expression character_data
+
+
+ If the column is a generated column, then the generation expression,
+ else null.
+ |
+ is_updatable yes_or_no
+
+
+ YES if the column is updatable,
+ NO if not (Columns in base tables are always
+ updatable, columns in views not necessarily)
+ |
+ Since data types can be defined in a variety of ways in SQL, and
+ PostgreSQL contains additional ways to
+ define data types, their representation in the information schema
+ can be somewhat difficult. The column data_type
+ is supposed to identify the underlying built-in type of the column.
+ In PostgreSQL, this means that the type
+ is defined in the system catalog schema
+ pg_catalog. This column might be useful if the
+ application can handle the well-known built-in types specially (for
+ example, format the numeric types differently or use the data in
+ the precision columns). The columns udt_name,
+ udt_schema, and udt_catalog
+ always identify the underlying data type of the column, even if the
+ column is based on a domain. (Since
+ PostgreSQL treats built-in types like
+ user-defined types, built-in types appear here as well. This is an
+ extension of the SQL standard.) These columns should be used if an
+ application wants to process data differently according to the
+ type, because in that case it wouldn't matter if the column is
+ really based on a domain. If the column is based on a domain, the
+ identity of the domain is stored in the columns
+ domain_name, domain_schema,
+ and domain_catalog. If you want to pair up
+ columns with their associated data types and treat domains as
+ separate types, you could write coalesce(domain_name,
+ udt_name), etc.
+
37.18. constraint_column_usage #
+ The view constraint_column_usage identifies all
+ columns in the current database that are used by some constraint.
+ Only those columns are shown that are contained in a table owned by
+ a currently enabled role. For a check constraint, this view
+ identifies the columns that are used in the check expression. For
+ a foreign key constraint, this view identifies the columns that the
+ foreign key references. For a unique or primary key constraint,
+ this view identifies the constrained columns.
+
Table 37.16. constraint_column_usage Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ table_catalog sql_identifier
+
+
+ Name of the database that contains the table that contains the
+ column that is used by some constraint (always the current
+ database)
+ |
+ table_schema sql_identifier
+
+
+ Name of the schema that contains the table that contains the
+ column that is used by some constraint
+ |
+ table_name sql_identifier
+
+
+ Name of the table that contains the column that is used by some
+ constraint
+ |
+ column_name sql_identifier
+
+
+ Name of the column that is used by some constraint
+ |
+ constraint_catalog sql_identifier
+
+
+ Name of the database that contains the constraint (always the current database)
+ |
+ constraint_schema sql_identifier
+
+
+ Name of the schema that contains the constraint
+ |
+ constraint_name sql_identifier
+
+
+ Name of the constraint
+ |
37.19. constraint_table_usage #
+ The view constraint_table_usage identifies all
+ tables in the current database that are used by some constraint and
+ are owned by a currently enabled role. (This is different from the
+ view table_constraints, which identifies all
+ table constraints along with the table they are defined on.) For a
+ foreign key constraint, this view identifies the table that the
+ foreign key references. For a unique or primary key constraint,
+ this view simply identifies the table the constraint belongs to.
+ Check constraints and not-null constraints are not included in this
+ view.
+
Table 37.17. constraint_table_usage Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ table_catalog sql_identifier
+
+
+ Name of the database that contains the table that is used by
+ some constraint (always the current database)
+ |
+ table_schema sql_identifier
+
+
+ Name of the schema that contains the table that is used by some
+ constraint
+ |
+ table_name sql_identifier
+
+
+ Name of the table that is used by some constraint
+ |
+ constraint_catalog sql_identifier
+
+
+ Name of the database that contains the constraint (always the current database)
+ |
+ constraint_schema sql_identifier
+
+
+ Name of the schema that contains the constraint
+ |
+ constraint_name sql_identifier
+
+
+ Name of the constraint
+ |
37.20. data_type_privileges #
+ The view data_type_privileges identifies all
+ data type descriptors that the current user has access to, by way
+ of being the owner of the described object or having some privilege
+ for it. A data type descriptor is generated whenever a data type
+ is used in the definition of a table column, a domain, or a
+ function (as parameter or return type) and stores some information
+ about how the data type is used in that instance (for example, the
+ declared maximum length, if applicable). Each data type
+ descriptor is assigned an arbitrary identifier that is unique
+ among the data type descriptor identifiers assigned for one object
+ (table, domain, function). This view is probably not useful for
+ applications, but it is used to define some other views in the
+ information schema.
+
Table 37.18. data_type_privileges Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ object_catalog sql_identifier
+
+
+ Name of the database that contains the described object (always the current database)
+ |
+ object_schema sql_identifier
+
+
+ Name of the schema that contains the described object
+ |
+ object_name sql_identifier
+
+
+ Name of the described object
+ |
+ object_type character_data
+
+
+ The type of the described object: one of
+ TABLE (the data type descriptor pertains to
+ a column of that table), DOMAIN (the data
+ type descriptors pertains to that domain),
+ ROUTINE (the data type descriptor pertains
+ to a parameter or the return data type of that function).
+ |
+ dtd_identifier sql_identifier
+
+
+ The identifier of the data type descriptor, which is unique
+ among the data type descriptors for that same object.
+ |
+ The columns of the information schema views use special data types
+ that are defined in the information schema. These are defined as
+ simple domains over ordinary built-in types. You should not use
+ these types for work outside the information schema, but your
+ applications must be prepared for them if they select from the
+ information schema.
+
+ These types are:
+
+
cardinal_number
+ A nonnegative integer.
+
character_data
+ A character string (without specific maximum length).
+
sql_identifier
+ A character string. This type is used for SQL identifiers, the
+ type character_data is used for any other kind of
+ text data.
+
time_stamp
+ A domain over the type timestamp with time zone
+
yes_or_no
+ A character string domain that contains
+ either YES or NO. This
+ is used to represent Boolean (true/false) data in the
+ information schema. (The information schema was invented
+ before the type boolean was added to the SQL
+ standard, so this convention is necessary to keep the
+ information schema backward compatible.)
+
+
+ Every column in the information schema has one of these five types.
+
37.21. domain_constraints #
+ The view domain_constraints contains all constraints
+ belonging to domains defined in the current database. Only those domains
+ are shown that the current user has access to (by way of being the owner or
+ having some privilege).
+
Table 37.19. domain_constraints Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ constraint_catalog sql_identifier
+
+
+ Name of the database that contains the constraint (always the current database)
+ |
+ constraint_schema sql_identifier
+
+
+ Name of the schema that contains the constraint
+ |
+ constraint_name sql_identifier
+
+
+ Name of the constraint
+ |
+ domain_catalog sql_identifier
+
+
+ Name of the database that contains the domain (always the current database)
+ |
+ domain_schema sql_identifier
+
+
+ Name of the schema that contains the domain
+ |
+ domain_name sql_identifier
+
+
+ Name of the domain
+ |
+ is_deferrable yes_or_no
+
+
+ YES if the constraint is deferrable, NO if not
+ |
+ initially_deferred yes_or_no
+
+
+ YES if the constraint is deferrable and initially deferred, NO if not
+ |
37.22. domain_udt_usage #
+ The view domain_udt_usage identifies all domains
+ that are based on data types owned by a currently enabled role.
+ Note that in PostgreSQL, built-in data
+ types behave like user-defined types, so they are included here as
+ well.
+
Table 37.20. domain_udt_usage Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ udt_catalog sql_identifier
+
+
+ Name of the database that the domain data type is defined in (always the current database)
+ |
+ udt_schema sql_identifier
+
+
+ Name of the schema that the domain data type is defined in
+ |
+ udt_name sql_identifier
+
+
+ Name of the domain data type
+ |
+ domain_catalog sql_identifier
+
+
+ Name of the database that contains the domain (always the current database)
+ |
+ domain_schema sql_identifier
+
+
+ Name of the schema that contains the domain
+ |
+ domain_name sql_identifier
+
+
+ Name of the domain
+ |
+ The view domains contains all
+ domains defined in the
+ current database. Only those domains are shown that the current user has
+ access to (by way of being the owner or having some privilege).
+
Table 37.21. domains Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ domain_catalog sql_identifier
+
+
+ Name of the database that contains the domain (always the current database)
+ |
+ domain_schema sql_identifier
+
+
+ Name of the schema that contains the domain
+ |
+ domain_name sql_identifier
+
+
+ Name of the domain
+ |
+ data_type character_data
+
+
+ Data type of the domain, if it is a built-in type, or
+ ARRAY if it is some array (in that case, see
+ the view element_types), else
+ USER-DEFINED (in that case, the type is
+ identified in udt_name and associated
+ columns).
+ |
+ character_maximum_length cardinal_number
+
+
+ If the domain has a character or bit string type, the declared
+ maximum length; null for all other data types or if no maximum
+ length was declared.
+ |
+ character_octet_length cardinal_number
+
+
+ If the domain has a character type, the maximum possible length
+ in octets (bytes) of a datum; null for all other data types.
+ The maximum octet length depends on the declared character
+ maximum length (see above) and the server encoding.
+ |
+ character_set_catalog sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ character_set_schema sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ character_set_name sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ collation_catalog sql_identifier
+
+
+ Name of the database containing the collation of the domain
+ (always the current database), null if default or the data type
+ of the domain is not collatable
+ |
+ collation_schema sql_identifier
+
+
+ Name of the schema containing the collation of the domain, null
+ if default or the data type of the domain is not collatable
+ |
+ collation_name sql_identifier
+
+
+ Name of the collation of the domain, null if default or the
+ data type of the domain is not collatable
+ |
+ numeric_precision cardinal_number
+
+
+ If the domain has a numeric type, this column contains the
+ (declared or implicit) precision of the type for this domain.
+ The precision indicates the number of significant digits. It
+ can be expressed in decimal (base 10) or binary (base 2) terms,
+ as specified in the column
+ numeric_precision_radix. For all other data
+ types, this column is null.
+ |
+ numeric_precision_radix cardinal_number
+
+
+ If the domain has a numeric type, this column indicates in
+ which base the values in the columns
+ numeric_precision and
+ numeric_scale are expressed. The value is
+ either 2 or 10. For all other data types, this column is null.
+ |
+ numeric_scale cardinal_number
+
+
+ If the domain has an exact numeric type, this column contains
+ the (declared or implicit) scale of the type for this domain.
+ The scale indicates the number of significant digits to the
+ right of the decimal point. It can be expressed in decimal
+ (base 10) or binary (base 2) terms, as specified in the column
+ numeric_precision_radix. For all other data
+ types, this column is null.
+ |
+ datetime_precision cardinal_number
+
+
+ If data_type identifies a date, time,
+ timestamp, or interval type, this column contains the (declared
+ or implicit) fractional seconds precision of the type for this
+ domain, that is, the number of decimal digits maintained
+ following the decimal point in the seconds value. For all
+ other data types, this column is null.
+ |
+ interval_type character_data
+
+
+ If data_type identifies an interval type,
+ this column contains the specification which fields the
+ intervals include for this domain, e.g., YEAR TO
+ MONTH, DAY TO SECOND, etc. If no
+ field restrictions were specified (that is, the interval
+ accepts all fields), and for all other data types, this field
+ is null.
+ |
+ interval_precision cardinal_number
+
+
+ Applies to a feature not available
+ in PostgreSQL
+ (see datetime_precision for the fractional
+ seconds precision of interval type domains)
+ |
+ domain_default character_data
+
+
+ Default expression of the domain
+ |
+ udt_catalog sql_identifier
+
+
+ Name of the database that the domain data type is defined in (always the current database)
+ |
+ udt_schema sql_identifier
+
+
+ Name of the schema that the domain data type is defined in
+ |
+ udt_name sql_identifier
+
+
+ Name of the domain data type
+ |
+ scope_catalog sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ scope_schema sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ scope_name sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ maximum_cardinality cardinal_number
+
+
+ Always null, because arrays always have unlimited maximum cardinality in PostgreSQL
+ |
+ dtd_identifier sql_identifier
+
+
+ An identifier of the data type descriptor of the domain, unique
+ among the data type descriptors pertaining to the domain (which
+ is trivial, because a domain only contains one data type
+ descriptor). This is mainly useful for joining with other
+ instances of such identifiers. (The specific format of the
+ identifier is not defined and not guaranteed to remain the same
+ in future versions.)
+ |
+ The view element_types contains the data type
+ descriptors of the elements of arrays. When a table column, composite-type attribute,
+ domain, function parameter, or function return value is defined to
+ be of an array type, the respective information schema view only
+ contains ARRAY in the column
+ data_type. To obtain information on the element
+ type of the array, you can join the respective view with this view.
+ For example, to show the columns of a table with data types and
+ array element types, if applicable, you could do:
+
+SELECT c.column_name, c.data_type, e.data_type AS element_type
+FROM information_schema.columns c LEFT JOIN information_schema.element_types e
+ ON ((c.table_catalog, c.table_schema, c.table_name, 'TABLE', c.dtd_identifier)
+ = (e.object_catalog, e.object_schema, e.object_name, e.object_type, e.collection_type_identifier))
+WHERE c.table_schema = '...' AND c.table_name = '...'
+ORDER BY c.ordinal_position;
+
+ This view only includes objects that the current user has access
+ to, by way of being the owner or having some privilege.
+
Table 37.22. element_types Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ object_catalog sql_identifier
+
+
+ Name of the database that contains the object that uses the
+ array being described (always the current database)
+ |
+ object_schema sql_identifier
+
+
+ Name of the schema that contains the object that uses the array
+ being described
+ |
+ object_name sql_identifier
+
+
+ Name of the object that uses the array being described
+ |
+ object_type character_data
+
+
+ The type of the object that uses the array being described: one
+ of TABLE (the array is used by a column of
+ that table), USER-DEFINED TYPE (the array is
+ used by an attribute of that composite type),
+ DOMAIN (the array is used by that domain),
+ ROUTINE (the array is used by a parameter or
+ the return data type of that function).
+ |
+ collection_type_identifier sql_identifier
+
+
+ The identifier of the data type descriptor of the array being
+ described. Use this to join with the
+ dtd_identifier columns of other information
+ schema views.
+ |
+ data_type character_data
+
+
+ Data type of the array elements, if it is a built-in type, else
+ USER-DEFINED (in that case, the type is
+ identified in udt_name and associated
+ columns).
+ |
+ character_maximum_length cardinal_number
+
+
+ Always null, since this information is not applied to array element data types in PostgreSQL
+ |
+ character_octet_length cardinal_number
+
+
+ Always null, since this information is not applied to array element data types in PostgreSQL
+ |
+ character_set_catalog sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ character_set_schema sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ character_set_name sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ collation_catalog sql_identifier
+
+
+ Name of the database containing the collation of the element
+ type (always the current database), null if default or the data
+ type of the element is not collatable
+ |
+ collation_schema sql_identifier
+
+
+ Name of the schema containing the collation of the element
+ type, null if default or the data type of the element is not
+ collatable
+ |
+ collation_name sql_identifier
+
+
+ Name of the collation of the element type, null if default or
+ the data type of the element is not collatable
+ |
+ numeric_precision cardinal_number
+
+
+ Always null, since this information is not applied to array element data types in PostgreSQL
+ |
+ numeric_precision_radix cardinal_number
+
+
+ Always null, since this information is not applied to array element data types in PostgreSQL
+ |
+ numeric_scale cardinal_number
+
+
+ Always null, since this information is not applied to array element data types in PostgreSQL
+ |
+ datetime_precision cardinal_number
+
+
+ Always null, since this information is not applied to array element data types in PostgreSQL
+ |
+ interval_type character_data
+
+
+ Always null, since this information is not applied to array element data types in PostgreSQL
+ |
+ interval_precision cardinal_number
+
+
+ Always null, since this information is not applied to array element data types in PostgreSQL
+ |
+ domain_default character_data
+
+
+ Not yet implemented
+ |
+ udt_catalog sql_identifier
+
+
+ Name of the database that the data type of the elements is
+ defined in (always the current database)
+ |
+ udt_schema sql_identifier
+
+
+ Name of the schema that the data type of the elements is
+ defined in
+ |
+ udt_name sql_identifier
+
+
+ Name of the data type of the elements
+ |
+ scope_catalog sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ scope_schema sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ scope_name sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ maximum_cardinality cardinal_number
+
+
+ Always null, because arrays always have unlimited maximum cardinality in PostgreSQL
+ |
+ dtd_identifier sql_identifier
+
+
+ An identifier of the data type descriptor of the element. This
+ is currently not useful.
+ |
+ The view enabled_roles identifies the currently
+ “enabled roles”. The enabled roles are recursively
+ defined as the current user together with all roles that have been
+ granted to the enabled roles with automatic inheritance. In other
+ words, these are all roles that the current user has direct or
+ indirect, automatically inheriting membership in.
+
+
+
+ For permission checking, the set of “applicable roles”
+ is applied, which can be broader than the set of enabled roles. So
+ generally, it is better to use the view
+ applicable_roles instead of this one; See
+ Section 37.5 for details on
+ applicable_roles view.
+
Table 37.23. enabled_roles Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ role_name sql_identifier
+
+
+ Name of a role
+ |
37.26. foreign_data_wrapper_options #
+ The view foreign_data_wrapper_options contains
+ all the options defined for foreign-data wrappers in the current
+ database. Only those foreign-data wrappers are shown that the
+ current user has access to (by way of being the owner or having
+ some privilege).
+
Table 37.24. foreign_data_wrapper_options Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ foreign_data_wrapper_catalog sql_identifier
+
+
+ Name of the database that the foreign-data wrapper is defined in (always the current database)
+ |
+ foreign_data_wrapper_name sql_identifier
+
+
+ Name of the foreign-data wrapper
+ |
+ option_name sql_identifier
+
+
+ Name of an option
+ |
+ option_value character_data
+
+
+ Value of the option
+ |
37.27. foreign_data_wrappers #
+ The view foreign_data_wrappers contains all
+ foreign-data wrappers defined in the current database. Only those
+ foreign-data wrappers are shown that the current user has access to
+ (by way of being the owner or having some privilege).
+
Table 37.25. foreign_data_wrappers Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ foreign_data_wrapper_catalog sql_identifier
+
+
+ Name of the database that contains the foreign-data
+ wrapper (always the current database)
+ |
+ foreign_data_wrapper_name sql_identifier
+
+
+ Name of the foreign-data wrapper
+ |
+ authorization_identifier sql_identifier
+
+
+ Name of the owner of the foreign server
+ |
+ library_name character_data
+
+
+ File name of the library that implementing this foreign-data wrapper
+ |
+ foreign_data_wrapper_language character_data
+
+
+ Language used to implement this foreign-data wrapper
+ |
37.28. foreign_server_options #
+ The view foreign_server_options contains all the
+ options defined for foreign servers in the current database. Only
+ those foreign servers are shown that the current user has access to
+ (by way of being the owner or having some privilege).
+
Table 37.26. foreign_server_options Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ foreign_server_catalog sql_identifier
+
+
+ Name of the database that the foreign server is defined in (always the current database)
+ |
+ foreign_server_name sql_identifier
+
+
+ Name of the foreign server
+ |
+ option_name sql_identifier
+
+
+ Name of an option
+ |
+ option_value character_data
+
+
+ Value of the option
+ |
+ The view foreign_servers contains all foreign
+ servers defined in the current database. Only those foreign
+ servers are shown that the current user has access to (by way of
+ being the owner or having some privilege).
+
Table 37.27. foreign_servers Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ foreign_server_catalog sql_identifier
+
+
+ Name of the database that the foreign server is defined in (always the current database)
+ |
+ foreign_server_name sql_identifier
+
+
+ Name of the foreign server
+ |
+ foreign_data_wrapper_catalog sql_identifier
+
+
+ Name of the database that contains the foreign-data
+ wrapper used by the foreign server (always the current database)
+ |
+ foreign_data_wrapper_name sql_identifier
+
+
+ Name of the foreign-data wrapper used by the foreign server
+ |
+ foreign_server_type character_data
+
+
+ Foreign server type information, if specified upon creation
+ |
+ foreign_server_version character_data
+
+
+ Foreign server version information, if specified upon creation
+ |
+ authorization_identifier sql_identifier
+
+
+ Name of the owner of the foreign server
+ |
37.30. foreign_table_options #
+ The view foreign_table_options contains all the
+ options defined for foreign tables in the current database. Only
+ those foreign tables are shown that the current user has access to
+ (by way of being the owner or having some privilege).
+
Table 37.28. foreign_table_options Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ foreign_table_catalog sql_identifier
+
+
+ Name of the database that contains the foreign table (always the current database)
+ |
+ foreign_table_schema sql_identifier
+
+
+ Name of the schema that contains the foreign table
+ |
+ foreign_table_name sql_identifier
+
+
+ Name of the foreign table
+ |
+ option_name sql_identifier
+
+
+ Name of an option
+ |
+ option_value character_data
+
+
+ Value of the option
+ |
+ The view foreign_tables contains all foreign
+ tables defined in the current database. Only those foreign
+ tables are shown that the current user has access to (by way of
+ being the owner or having some privilege).
+
Table 37.29. foreign_tables Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ foreign_table_catalog sql_identifier
+
+
+ Name of the database that the foreign table is defined in (always the current database)
+ |
+ foreign_table_schema sql_identifier
+
+
+ Name of the schema that contains the foreign table
+ |
+ foreign_table_name sql_identifier
+
+
+ Name of the foreign table
+ |
+ foreign_server_catalog sql_identifier
+
+
+ Name of the database that the foreign server is defined in (always the current database)
+ |
+ foreign_server_name sql_identifier
+
+
+ Name of the foreign server
+ |
37.32. key_column_usage #
+ The view key_column_usage identifies all columns
+ in the current database that are restricted by some unique, primary
+ key, or foreign key constraint. Check constraints are not included
+ in this view. Only those columns are shown that the current user
+ has access to, by way of being the owner or having some privilege.
+
Table 37.30. key_column_usage Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ constraint_catalog sql_identifier
+
+
+ Name of the database that contains the constraint (always the current database)
+ |
+ constraint_schema sql_identifier
+
+
+ Name of the schema that contains the constraint
+ |
+ constraint_name sql_identifier
+
+
+ Name of the constraint
+ |
+ table_catalog sql_identifier
+
+
+ Name of the database that contains the table that contains the
+ column that is restricted by this constraint (always the
+ current database)
+ |
+ table_schema sql_identifier
+
+
+ Name of the schema that contains the table that contains the
+ column that is restricted by this constraint
+ |
+ table_name sql_identifier
+
+
+ Name of the table that contains the column that is restricted
+ by this constraint
+ |
+ column_name sql_identifier
+
+
+ Name of the column that is restricted by this constraint
+ |
+ ordinal_position cardinal_number
+
+
+ Ordinal position of the column within the constraint key (count
+ starts at 1)
+ |
+ position_in_unique_constraint cardinal_number
+
+
+ For a foreign-key constraint, ordinal position of the referenced
+ column within its unique constraint (count starts at 1);
+ otherwise null
+ |
+ The view parameters contains information about
+ the parameters (arguments) of all functions in the current database.
+ Only those functions are shown that the current user has access to
+ (by way of being the owner or having some privilege).
+
Table 37.31. parameters Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ specific_catalog sql_identifier
+
+
+ Name of the database containing the function (always the current database)
+ |
+ specific_schema sql_identifier
+
+
+ Name of the schema containing the function
+ |
+ specific_name sql_identifier
+
+
+ The “specific name” of the function. See Section 37.45 for more information.
+ |
+ ordinal_position cardinal_number
+
+
+ Ordinal position of the parameter in the argument list of the
+ function (count starts at 1)
+ |
+ parameter_mode character_data
+
+
+ IN for input parameter,
+ OUT for output parameter,
+ and INOUT for input/output parameter.
+ |
+ is_result yes_or_no
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ as_locator yes_or_no
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ parameter_name sql_identifier
+
+
+ Name of the parameter, or null if the parameter has no name
+ |
+ data_type character_data
+
+
+ Data type of the parameter, if it is a built-in type, or
+ ARRAY if it is some array (in that case, see
+ the view element_types), else
+ USER-DEFINED (in that case, the type is
+ identified in udt_name and associated
+ columns).
+ |
+ character_maximum_length cardinal_number
+
+
+ Always null, since this information is not applied to parameter data types in PostgreSQL
+ |
+ character_octet_length cardinal_number
+
+
+ Always null, since this information is not applied to parameter data types in PostgreSQL
+ |
+ character_set_catalog sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ character_set_schema sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ character_set_name sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ collation_catalog sql_identifier
+
+
+ Always null, since this information is not applied to parameter data types in PostgreSQL
+ |
+ collation_schema sql_identifier
+
+
+ Always null, since this information is not applied to parameter data types in PostgreSQL
+ |
+ collation_name sql_identifier
+
+
+ Always null, since this information is not applied to parameter data types in PostgreSQL
+ |
+ numeric_precision cardinal_number
+
+
+ Always null, since this information is not applied to parameter data types in PostgreSQL
+ |
+ numeric_precision_radix cardinal_number
+
+
+ Always null, since this information is not applied to parameter data types in PostgreSQL
+ |
+ numeric_scale cardinal_number
+
+
+ Always null, since this information is not applied to parameter data types in PostgreSQL
+ |
+ datetime_precision cardinal_number
+
+
+ Always null, since this information is not applied to parameter data types in PostgreSQL
+ |
+ interval_type character_data
+
+
+ Always null, since this information is not applied to parameter data types in PostgreSQL
+ |
+ interval_precision cardinal_number
+
+
+ Always null, since this information is not applied to parameter data types in PostgreSQL
+ |
+ udt_catalog sql_identifier
+
+
+ Name of the database that the data type of the parameter is
+ defined in (always the current database)
+ |
+ udt_schema sql_identifier
+
+
+ Name of the schema that the data type of the parameter is
+ defined in
+ |
+ udt_name sql_identifier
+
+
+ Name of the data type of the parameter
+ |
+ scope_catalog sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ scope_schema sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ scope_name sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ maximum_cardinality cardinal_number
+
+
+ Always null, because arrays always have unlimited maximum cardinality in PostgreSQL
+ |
+ dtd_identifier sql_identifier
+
+
+ An identifier of the data type descriptor of the parameter,
+ unique among the data type descriptors pertaining to the
+ function. This is mainly useful for joining with other
+ instances of such identifiers. (The specific format of the
+ identifier is not defined and not guaranteed to remain the same
+ in future versions.)
+ |
+ parameter_default character_data
+
+
+ The default expression of the parameter, or null if none or if the
+ function is not owned by a currently enabled role.
+ |
37.34. referential_constraints #
+ The view referential_constraints contains all
+ referential (foreign key) constraints in the current database.
+ Only those constraints are shown for which the current user has
+ write access to the referencing table (by way of being the
+ owner or having some privilege other than SELECT).
+
Table 37.32. referential_constraints Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ constraint_catalog sql_identifier
+
+
+ Name of the database containing the constraint (always the current database)
+ |
+ constraint_schema sql_identifier
+
+
+ Name of the schema containing the constraint
+ |
+ constraint_name sql_identifier
+
+
+ Name of the constraint
+ |
+ unique_constraint_catalog sql_identifier
+
+
+ Name of the database that contains the unique or primary key
+ constraint that the foreign key constraint references (always
+ the current database)
+ |
+ unique_constraint_schema sql_identifier
+
+
+ Name of the schema that contains the unique or primary key
+ constraint that the foreign key constraint references
+ |
+ unique_constraint_name sql_identifier
+
+
+ Name of the unique or primary key constraint that the foreign
+ key constraint references
+ |
+ match_option character_data
+
+
+ Match option of the foreign key constraint:
+ FULL, PARTIAL, or
+ NONE.
+ |
+ update_rule character_data
+
+
+ Update rule of the foreign key constraint:
+ CASCADE, SET NULL,
+ SET DEFAULT, RESTRICT, or
+ NO ACTION.
+ |
+ delete_rule character_data
+
+
+ Delete rule of the foreign key constraint:
+ CASCADE, SET NULL,
+ SET DEFAULT, RESTRICT, or
+ NO ACTION.
+ |
37.35. role_column_grants #
+ The view role_column_grants identifies all
+ privileges granted on columns where the grantor or grantee is a
+ currently enabled role. Further information can be found under
+ column_privileges. The only effective
+ difference between this view
+ and column_privileges is that this view omits
+ columns that have been made accessible to the current user by way
+ of a grant to PUBLIC.
+
Table 37.33. role_column_grants Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ grantor sql_identifier
+
+
+ Name of the role that granted the privilege
+ |
+ grantee sql_identifier
+
+
+ Name of the role that the privilege was granted to
+ |
+ table_catalog sql_identifier
+
+
+ Name of the database that contains the table that contains the column (always the current database)
+ |
+ table_schema sql_identifier
+
+
+ Name of the schema that contains the table that contains the column
+ |
+ table_name sql_identifier
+
+
+ Name of the table that contains the column
+ |
+ column_name sql_identifier
+
+
+ Name of the column
+ |
+ privilege_type character_data
+
+
+ Type of the privilege: SELECT,
+ INSERT, UPDATE, or
+ REFERENCES
+ |
+ is_grantable yes_or_no
+
+
+ YES if the privilege is grantable, NO if not
+ |
37.36. role_routine_grants #
+ The view role_routine_grants identifies all
+ privileges granted on functions where the grantor or grantee is a
+ currently enabled role. Further information can be found under
+ routine_privileges. The only effective
+ difference between this view
+ and routine_privileges is that this view omits
+ functions that have been made accessible to the current user by way
+ of a grant to PUBLIC.
+
Table 37.34. role_routine_grants Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ grantor sql_identifier
+
+
+ Name of the role that granted the privilege
+ |
+ grantee sql_identifier
+
+
+ Name of the role that the privilege was granted to
+ |
+ specific_catalog sql_identifier
+
+
+ Name of the database containing the function (always the current database)
+ |
+ specific_schema sql_identifier
+
+
+ Name of the schema containing the function
+ |
+ specific_name sql_identifier
+
+
+ The “specific name” of the function. See Section 37.45 for more information.
+ |
+ routine_catalog sql_identifier
+
+
+ Name of the database containing the function (always the current database)
+ |
+ routine_schema sql_identifier
+
+
+ Name of the schema containing the function
+ |
+ routine_name sql_identifier
+
+
+ Name of the function (might be duplicated in case of overloading)
+ |
+ privilege_type character_data
+
+
+ Always EXECUTE (the only privilege type for functions)
+ |
+ is_grantable yes_or_no
+
+
+ YES if the privilege is grantable, NO if not
+ |
37.37. role_table_grants #
+ The view role_table_grants identifies all
+ privileges granted on tables or views where the grantor or grantee
+ is a currently enabled role. Further information can be found
+ under table_privileges. The only effective
+ difference between this view
+ and table_privileges is that this view omits
+ tables that have been made accessible to the current user by way of
+ a grant to PUBLIC.
+
Table 37.35. role_table_grants Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ grantor sql_identifier
+
+
+ Name of the role that granted the privilege
+ |
+ grantee sql_identifier
+
+
+ Name of the role that the privilege was granted to
+ |
+ table_catalog sql_identifier
+
+
+ Name of the database that contains the table (always the current database)
+ |
+ table_schema sql_identifier
+
+
+ Name of the schema that contains the table
+ |
+ table_name sql_identifier
+
+
+ Name of the table
+ |
+ privilege_type character_data
+
+
+ Type of the privilege: SELECT,
+ INSERT, UPDATE,
+ DELETE, TRUNCATE,
+ REFERENCES, or TRIGGER
+ |
+ is_grantable yes_or_no
+
+
+ YES if the privilege is grantable, NO if not
+ |
+ with_hierarchy yes_or_no
+
+
+ In the SQL standard, WITH HIERARCHY OPTION
+ is a separate (sub-)privilege allowing certain operations on
+ table inheritance hierarchies. In PostgreSQL, this is included
+ in the SELECT privilege, so this column
+ shows YES if the privilege
+ is SELECT, else NO.
+ |
+ The view role_udt_grants is intended to identify
+ USAGE privileges granted on user-defined types
+ where the grantor or grantee is a currently enabled role. Further
+ information can be found under
+ udt_privileges. The only effective difference
+ between this view and udt_privileges is that
+ this view omits objects that have been made accessible to the
+ current user by way of a grant to PUBLIC. Since
+ data types do not have real privileges in PostgreSQL, but only an
+ implicit grant to PUBLIC, this view is empty.
+
Table 37.36. role_udt_grants Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ grantor sql_identifier
+
+
+ The name of the role that granted the privilege
+ |
+ grantee sql_identifier
+
+
+ The name of the role that the privilege was granted to
+ |
+ udt_catalog sql_identifier
+
+
+ Name of the database containing the type (always the current database)
+ |
+ udt_schema sql_identifier
+
+
+ Name of the schema containing the type
+ |
+ udt_name sql_identifier
+
+
+ Name of the type
+ |
+ privilege_type character_data
+
+
+ Always TYPE USAGE
+ |
+ is_grantable yes_or_no
+
+
+ YES if the privilege is grantable, NO if not
+ |
37.39. role_usage_grants #
+ The view role_usage_grants identifies
+ USAGE privileges granted on various kinds of
+ objects where the grantor or grantee is a currently enabled role.
+ Further information can be found under
+ usage_privileges. The only effective difference
+ between this view and usage_privileges is that
+ this view omits objects that have been made accessible to the
+ current user by way of a grant to PUBLIC.
+
Table 37.37. role_usage_grants Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ grantor sql_identifier
+
+
+ The name of the role that granted the privilege
+ |
+ grantee sql_identifier
+
+
+ The name of the role that the privilege was granted to
+ |
+ object_catalog sql_identifier
+
+
+ Name of the database containing the object (always the current database)
+ |
+ object_schema sql_identifier
+
+
+ Name of the schema containing the object, if applicable,
+ else an empty string
+ |
+ object_name sql_identifier
+
+
+ Name of the object
+ |
+ object_type character_data
+
+
+ COLLATION or DOMAIN or FOREIGN DATA WRAPPER or FOREIGN SERVER or SEQUENCE
+ |
+ privilege_type character_data
+
+
+ Always USAGE
+ |
+ is_grantable yes_or_no
+
+
+ YES if the privilege is grantable, NO if not
+ |
37.40. routine_column_usage #
+ The view routine_column_usage identifies all columns
+ that are used by a function or procedure, either in the SQL body or in
+ parameter default expressions. (This only works for unquoted SQL bodies,
+ not quoted bodies or functions in other languages.) A column is only
+ included if its table is owned by a currently enabled role.
+
Table 37.38. routine_column_usage Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ specific_catalog sql_identifier
+
+
+ Name of the database containing the function (always the current database)
+ |
+ specific_schema sql_identifier
+
+
+ Name of the schema containing the function
+ |
+ specific_name sql_identifier
+
+
+ The “specific name” of the function. See Section 37.45 for more information.
+ |
+ routine_catalog sql_identifier
+
+
+ Name of the database containing the function (always the current database)
+ |
+ routine_schema sql_identifier
+
+
+ Name of the schema containing the function
+ |
+ routine_name sql_identifier
+
+
+ Name of the function (might be duplicated in case of overloading)
+ |
+ table_catalog sql_identifier
+
+
+ Name of the database that contains the table that is used by the
+ function (always the current database)
+ |
+ table_schema sql_identifier
+
+
+ Name of the schema that contains the table that is used by the function
+ |
+ table_name sql_identifier
+
+
+ Name of the table that is used by the function
+ |
+ column_name sql_identifier
+
+
+ Name of the column that is used by the function
+ |
37.41. routine_privileges #
+ The view routine_privileges identifies all
+ privileges granted on functions to a currently enabled role or by a
+ currently enabled role. There is one row for each combination of function,
+ grantor, and grantee.
+
Table 37.39. routine_privileges Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ grantor sql_identifier
+
+
+ Name of the role that granted the privilege
+ |
+ grantee sql_identifier
+
+
+ Name of the role that the privilege was granted to
+ |
+ specific_catalog sql_identifier
+
+
+ Name of the database containing the function (always the current database)
+ |
+ specific_schema sql_identifier
+
+
+ Name of the schema containing the function
+ |
+ specific_name sql_identifier
+
+
+ The “specific name” of the function. See Section 37.45 for more information.
+ |
+ routine_catalog sql_identifier
+
+
+ Name of the database containing the function (always the current database)
+ |
+ routine_schema sql_identifier
+
+
+ Name of the schema containing the function
+ |
+ routine_name sql_identifier
+
+
+ Name of the function (might be duplicated in case of overloading)
+ |
+ privilege_type character_data
+
+
+ Always EXECUTE (the only privilege type for functions)
+ |
+ is_grantable yes_or_no
+
+
+ YES if the privilege is grantable, NO if not
+ |
37.42. routine_routine_usage #
+ The view routine_routine_usage identifies all functions
+ or procedures that are used by another (or the same) function or procedure,
+ either in the SQL body or in parameter default expressions. (This only
+ works for unquoted SQL bodies, not quoted bodies or functions in other
+ languages.) An entry is included here only if the used function is owned
+ by a currently enabled role. (There is no such restriction on the using
+ function.)
+
+ Note that the entries for both functions in the view refer to the
+ “specific” name of the routine, even though the column names
+ are used in a way that is inconsistent with other information schema views
+ about routines. This is per SQL standard, although it is arguably a
+ misdesign. See Section 37.45 for more information
+ about specific names.
+
Table 37.40. routine_routine_usage Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ specific_catalog sql_identifier
+
+
+ Name of the database containing the using function (always the current database)
+ |
+ specific_schema sql_identifier
+
+
+ Name of the schema containing the using function
+ |
+ specific_name sql_identifier
+
+
+ The “specific name” of the using function.
+ |
+ routine_catalog sql_identifier
+
+
+ Name of the database that contains the function that is used by the
+ first function (always the current database)
+ |
+ routine_schema sql_identifier
+
+
+ Name of the schema that contains the function that is used by the first
+ function
+ |
+ routine_name sql_identifier
+
+
+ The “specific name” of the function that is used by the
+ first function.
+ |
37.43. routine_sequence_usage #
+ The view routine_sequence_usage identifies all sequences
+ that are used by a function or procedure, either in the SQL body or in
+ parameter default expressions. (This only works for unquoted SQL bodies,
+ not quoted bodies or functions in other languages.) A sequence is only
+ included if that sequence is owned by a currently enabled role.
+
Table 37.41. routine_sequence_usage Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ specific_catalog sql_identifier
+
+
+ Name of the database containing the function (always the current database)
+ |
+ specific_schema sql_identifier
+
+
+ Name of the schema containing the function
+ |
+ specific_name sql_identifier
+
+
+ The “specific name” of the function. See Section 37.45 for more information.
+ |
+ routine_catalog sql_identifier
+
+
+ Name of the database containing the function (always the current database)
+ |
+ routine_schema sql_identifier
+
+
+ Name of the schema containing the function
+ |
+ routine_name sql_identifier
+
+
+ Name of the function (might be duplicated in case of overloading)
+ |
+ schema_catalog sql_identifier
+
+
+ Name of the database that contains the sequence that is used by the
+ function (always the current database)
+ |
+ sequence_schema sql_identifier
+
+
+ Name of the schema that contains the sequence that is used by the function
+ |
+ sequence_name sql_identifier
+
+
+ Name of the sequence that is used by the function
+ |
37.44. routine_table_usage #
+ The view routine_table_usage is meant to identify all
+ tables that are used by a function or procedure. This information is
+ currently not tracked by PostgreSQL.
+
Table 37.42. routine_table_usage Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ specific_catalog sql_identifier
+
+
+ Name of the database containing the function (always the current database)
+ |
+ specific_schema sql_identifier
+
+
+ Name of the schema containing the function
+ |
+ specific_name sql_identifier
+
+
+ The “specific name” of the function. See Section 37.45 for more information.
+ |
+ routine_catalog sql_identifier
+
+
+ Name of the database containing the function (always the current database)
+ |
+ routine_schema sql_identifier
+
+
+ Name of the schema containing the function
+ |
+ routine_name sql_identifier
+
+
+ Name of the function (might be duplicated in case of overloading)
+ |
+ table_catalog sql_identifier
+
+
+ Name of the database that contains the table that is used by the
+ function (always the current database)
+ |
+ table_schema sql_identifier
+
+
+ Name of the schema that contains the table that is used by the function
+ |
+ table_name sql_identifier
+
+
+ Name of the table that is used by the function
+ |
+ The view routines contains all functions and procedures in the
+ current database. Only those functions and procedures are shown that the current
+ user has access to (by way of being the owner or having some
+ privilege).
+
Table 37.43. routines Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ specific_catalog sql_identifier
+
+
+ Name of the database containing the function (always the current database)
+ |
+ specific_schema sql_identifier
+
+
+ Name of the schema containing the function
+ |
+ specific_name sql_identifier
+
+
+ The “specific name” of the function. This is a
+ name that uniquely identifies the function in the schema, even
+ if the real name of the function is overloaded. The format of
+ the specific name is not defined, it should only be used to
+ compare it to other instances of specific routine names.
+ |
+ routine_catalog sql_identifier
+
+
+ Name of the database containing the function (always the current database)
+ |
+ routine_schema sql_identifier
+
+
+ Name of the schema containing the function
+ |
+ routine_name sql_identifier
+
+
+ Name of the function (might be duplicated in case of overloading)
+ |
+ routine_type character_data
+
+
+ FUNCTION for a
+ function, PROCEDURE for a procedure
+ |
+ module_catalog sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ module_schema sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ module_name sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ udt_catalog sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ udt_schema sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ udt_name sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ data_type character_data
+
+
+ Return data type of the function, if it is a built-in type, or
+ ARRAY if it is some array (in that case, see
+ the view element_types), else
+ USER-DEFINED (in that case, the type is
+ identified in type_udt_name and associated
+ columns). Null for a procedure.
+ |
+ character_maximum_length cardinal_number
+
+
+ Always null, since this information is not applied to return data types in PostgreSQL
+ |
+ character_octet_length cardinal_number
+
+
+ Always null, since this information is not applied to return data types in PostgreSQL
+ |
+ character_set_catalog sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ character_set_schema sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ character_set_name sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ collation_catalog sql_identifier
+
+
+ Always null, since this information is not applied to return data types in PostgreSQL
+ |
+ collation_schema sql_identifier
+
+
+ Always null, since this information is not applied to return data types in PostgreSQL
+ |
+ collation_name sql_identifier
+
+
+ Always null, since this information is not applied to return data types in PostgreSQL
+ |
+ numeric_precision cardinal_number
+
+
+ Always null, since this information is not applied to return data types in PostgreSQL
+ |
+ numeric_precision_radix cardinal_number
+
+
+ Always null, since this information is not applied to return data types in PostgreSQL
+ |
+ numeric_scale cardinal_number
+
+
+ Always null, since this information is not applied to return data types in PostgreSQL
+ |
+ datetime_precision cardinal_number
+
+
+ Always null, since this information is not applied to return data types in PostgreSQL
+ |
+ interval_type character_data
+
+
+ Always null, since this information is not applied to return data types in PostgreSQL
+ |
+ interval_precision cardinal_number
+
+
+ Always null, since this information is not applied to return data types in PostgreSQL
+ |
+ type_udt_catalog sql_identifier
+
+
+ Name of the database that the return data type of the function
+ is defined in (always the current database). Null for a procedure.
+ |
+ type_udt_schema sql_identifier
+
+
+ Name of the schema that the return data type of the function is
+ defined in. Null for a procedure.
+ |
+ type_udt_name sql_identifier
+
+
+ Name of the return data type of the function. Null for a procedure.
+ |
+ scope_catalog sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ scope_schema sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ scope_name sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ maximum_cardinality cardinal_number
+
+
+ Always null, because arrays always have unlimited maximum cardinality in PostgreSQL
+ |
+ dtd_identifier sql_identifier
+
+
+ An identifier of the data type descriptor of the return data
+ type of this function, unique among the data type descriptors
+ pertaining to the function. This is mainly useful for joining
+ with other instances of such identifiers. (The specific format
+ of the identifier is not defined and not guaranteed to remain
+ the same in future versions.)
+ |
+ routine_body character_data
+
+
+ If the function is an SQL function, then
+ SQL, else EXTERNAL.
+ |
+ routine_definition character_data
+
+
+ The source text of the function (null if the function is not
+ owned by a currently enabled role). (According to the SQL
+ standard, this column is only applicable if
+ routine_body is SQL, but
+ in PostgreSQL it will contain
+ whatever source text was specified when the function was
+ created.)
+ |
+ external_name character_data
+
+
+ If this function is a C function, then the external name (link
+ symbol) of the function; else null. (This works out to be the
+ same value that is shown in
+ routine_definition.)
+ |
+ external_language character_data
+
+
+ The language the function is written in
+ |
+ parameter_style character_data
+
+
+ Always GENERAL (The SQL standard defines
+ other parameter styles, which are not available in PostgreSQL.)
+ |
+ is_deterministic yes_or_no
+
+
+ If the function is declared immutable (called deterministic in
+ the SQL standard), then YES, else
+ NO. (You cannot query the other volatility
+ levels available in PostgreSQL through the information schema.)
+ |
+ sql_data_access character_data
+
+
+ Always MODIFIES, meaning that the function
+ possibly modifies SQL data. This information is not useful for
+ PostgreSQL.
+ |
+ is_null_call yes_or_no
+
+
+ If the function automatically returns null if any of its
+ arguments are null, then YES, else
+ NO. Null for a procedure.
+ |
+ sql_path character_data
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ schema_level_routine yes_or_no
+
+
+ Always YES (The opposite would be a method
+ of a user-defined type, which is a feature not available in
+ PostgreSQL.)
+ |
+ max_dynamic_result_sets cardinal_number
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ is_user_defined_cast yes_or_no
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ is_implicitly_invocable yes_or_no
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ security_type character_data
+
+
+ If the function runs with the privileges of the current user,
+ then INVOKER, if the function runs with the
+ privileges of the user who defined it, then
+ DEFINER.
+ |
+ to_sql_specific_catalog sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ to_sql_specific_schema sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ to_sql_specific_name sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ as_locator yes_or_no
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ created time_stamp
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ last_altered time_stamp
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ new_savepoint_level yes_or_no
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ is_udt_dependent yes_or_no
+
+
+ Currently always NO. The alternative
+ YES applies to a feature not available in
+ PostgreSQL.
+ |
+ result_cast_from_data_type character_data
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ result_cast_as_locator yes_or_no
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ result_cast_char_max_length cardinal_number
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ result_cast_char_octet_length cardinal_number
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ result_cast_char_set_catalog sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ result_cast_char_set_schema sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ result_cast_char_set_name sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ result_cast_collation_catalog sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ result_cast_collation_schema sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ result_cast_collation_name sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ result_cast_numeric_precision cardinal_number
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ result_cast_numeric_precision_radix cardinal_number
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ result_cast_numeric_scale cardinal_number
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ result_cast_datetime_precision cardinal_number
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ result_cast_interval_type character_data
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ result_cast_interval_precision cardinal_number
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ result_cast_type_udt_catalog sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ result_cast_type_udt_schema sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ result_cast_type_udt_name sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ result_cast_scope_catalog sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ result_cast_scope_schema sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ result_cast_scope_name sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ result_cast_maximum_cardinality cardinal_number
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ result_cast_dtd_identifier sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ The information schema itself is a schema named
+ information_schema. This schema automatically
+ exists in all databases. The owner of this schema is the initial
+ database user in the cluster, and that user naturally has all the
+ privileges on this schema, including the ability to drop it (but
+ the space savings achieved by that are minuscule).
+
+ By default, the information schema is not in the schema search
+ path, so you need to access all objects in it through qualified
+ names. Since the names of some of the objects in the information
+ schema are generic names that might occur in user applications, you
+ should be careful if you want to put the information schema in the
+ path.
+
+ The view schemata contains all schemas in the current
+ database that the current user has access to (by way of being the owner or
+ having some privilege).
+
Table 37.44. schemata Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ catalog_name sql_identifier
+
+
+ Name of the database that the schema is contained in (always the current database)
+ |
+ schema_name sql_identifier
+
+
+ Name of the schema
+ |
+ schema_owner sql_identifier
+
+
+ Name of the owner of the schema
+ |
+ default_character_set_catalog sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ default_character_set_schema sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ default_character_set_name sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ sql_path character_data
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ The view sequences contains all sequences
+ defined in the current database. Only those sequences are shown
+ that the current user has access to (by way of being the owner or
+ having some privilege).
+
Table 37.45. sequences Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ sequence_catalog sql_identifier
+
+
+ Name of the database that contains the sequence (always the current database)
+ |
+ sequence_schema sql_identifier
+
+
+ Name of the schema that contains the sequence
+ |
+ sequence_name sql_identifier
+
+
+ Name of the sequence
+ |
+ data_type character_data
+
+
+ The data type of the sequence.
+ |
+ numeric_precision cardinal_number
+
+
+ This column contains the (declared or implicit) precision of
+ the sequence data type (see above). The precision indicates
+ the number of significant digits. It can be expressed in
+ decimal (base 10) or binary (base 2) terms, as specified in the
+ column numeric_precision_radix.
+ |
+ numeric_precision_radix cardinal_number
+
+
+ This column indicates in which base the values in the columns
+ numeric_precision and
+ numeric_scale are expressed. The value is
+ either 2 or 10.
+ |
+ numeric_scale cardinal_number
+
+
+ This column contains the (declared or implicit) scale of the
+ sequence data type (see above). The scale indicates the number
+ of significant digits to the right of the decimal point. It
+ can be expressed in decimal (base 10) or binary (base 2) terms,
+ as specified in the column
+ numeric_precision_radix.
+ |
+ start_value character_data
+
+
+ The start value of the sequence
+ |
+ minimum_value character_data
+
+
+ The minimum value of the sequence
+ |
+ maximum_value character_data
+
+
+ The maximum value of the sequence
+ |
+ increment character_data
+
+
+ The increment of the sequence
+ |
+ cycle_option yes_or_no
+
+
+ YES if the sequence cycles, else NO
+ |
+ Note that in accordance with the SQL standard, the start, minimum,
+ maximum, and increment values are returned as character strings.
+
+ The table sql_features contains information
+ about which formal features defined in the SQL standard are
+ supported by PostgreSQL. This is the
+ same information that is presented in Appendix D.
+ There you can also find some additional background information.
+
Table 37.46. sql_features Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ feature_id character_data
+
+
+ Identifier string of the feature
+ |
+ feature_name character_data
+
+
+ Descriptive name of the feature
+ |
+ sub_feature_id character_data
+
+
+ Identifier string of the subfeature, or a zero-length string if not a subfeature
+ |
+ sub_feature_name character_data
+
+
+ Descriptive name of the subfeature, or a zero-length string if not a subfeature
+ |
+ is_supported yes_or_no
+
+
+ YES if the feature is fully supported by the
+ current version of PostgreSQL, NO if not
+ |
+ is_verified_by character_data
+
+
+ Always null, since the PostgreSQL development group does not
+ perform formal testing of feature conformance
+ |
+ comments character_data
+
+
+ Possibly a comment about the supported status of the feature
+ |
37.49. sql_implementation_info #
+ The table sql_implementation_info contains
+ information about various aspects that are left
+ implementation-defined by the SQL standard. This information is
+ primarily intended for use in the context of the ODBC interface;
+ users of other interfaces will probably find this information to be
+ of little use. For this reason, the individual implementation
+ information items are not described here; you will find them in the
+ description of the ODBC interface.
+
Table 37.47. sql_implementation_info Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ implementation_info_id character_data
+
+
+ Identifier string of the implementation information item
+ |
+ implementation_info_name character_data
+
+
+ Descriptive name of the implementation information item
+ |
+ integer_value cardinal_number
+
+
+ Value of the implementation information item, or null if the
+ value is contained in the column
+ character_value
+ |
+ character_value character_data
+
+
+ Value of the implementation information item, or null if the
+ value is contained in the column
+ integer_value
+ |
+ comments character_data
+
+
+ Possibly a comment pertaining to the implementation information item
+ |
+ The table sql_parts contains information about
+ which of the several parts of the SQL standard are supported by
+ PostgreSQL.
+
Table 37.48. sql_parts Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ feature_id character_data
+
+
+ An identifier string containing the number of the part
+ |
+ feature_name character_data
+
+
+ Descriptive name of the part
+ |
+ is_supported yes_or_no
+
+
+ YES if the part is fully supported by the
+ current version of PostgreSQL,
+ NO if not
+ |
+ is_verified_by character_data
+
+
+ Always null, since the PostgreSQL development group does not
+ perform formal testing of feature conformance
+ |
+ comments character_data
+
+
+ Possibly a comment about the supported status of the part
+ |
+ The table sql_sizing contains information about
+ various size limits and maximum values in
+ PostgreSQL. This information is
+ primarily intended for use in the context of the ODBC interface;
+ users of other interfaces will probably find this information to be
+ of little use. For this reason, the individual sizing items are
+ not described here; you will find them in the description of the
+ ODBC interface.
+
Table 37.49. sql_sizing Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ sizing_id cardinal_number
+
+
+ Identifier of the sizing item
+ |
+ sizing_name character_data
+
+
+ Descriptive name of the sizing item
+ |
+ supported_value cardinal_number
+
+
+ Value of the sizing item, or 0 if the size is unlimited or
+ cannot be determined, or null if the features for which the
+ sizing item is applicable are not supported
+ |
+ comments character_data
+
+
+ Possibly a comment pertaining to the sizing item
+ |
37.52. table_constraints #
+ The view table_constraints contains all
+ constraints belonging to tables that the current user owns or has
+ some privilege other than SELECT on.
+
Table 37.50. table_constraints Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ constraint_catalog sql_identifier
+
+
+ Name of the database that contains the constraint (always the current database)
+ |
+ constraint_schema sql_identifier
+
+
+ Name of the schema that contains the constraint
+ |
+ constraint_name sql_identifier
+
+
+ Name of the constraint
+ |
+ table_catalog sql_identifier
+
+
+ Name of the database that contains the table (always the current database)
+ |
+ table_schema sql_identifier
+
+
+ Name of the schema that contains the table
+ |
+ table_name sql_identifier
+
+
+ Name of the table
+ |
+ constraint_type character_data
+
+
+ Type of the constraint: CHECK,
+ FOREIGN KEY, PRIMARY KEY,
+ or UNIQUE
+ |
+ is_deferrable yes_or_no
+
+
+ YES if the constraint is deferrable, NO if not
+ |
+ initially_deferred yes_or_no
+
+
+ YES if the constraint is deferrable and initially deferred, NO if not
+ |
+ enforced yes_or_no
+
+
+ Applies to a feature not available in
+ PostgreSQL (currently always
+ YES)
+ |
+ nulls_distinct yes_or_no
+
+
+ If the constraint is a unique constraint, then YES
+ if the constraint treats nulls as distinct or NO if
+ it treats nulls as not distinct, otherwise null for other types of
+ constraints.
+ |
37.53. table_privileges #
+ The view table_privileges identifies all
+ privileges granted on tables or views to a currently enabled role
+ or by a currently enabled role. There is one row for each
+ combination of table, grantor, and grantee.
+
Table 37.51. table_privileges Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ grantor sql_identifier
+
+
+ Name of the role that granted the privilege
+ |
+ grantee sql_identifier
+
+
+ Name of the role that the privilege was granted to
+ |
+ table_catalog sql_identifier
+
+
+ Name of the database that contains the table (always the current database)
+ |
+ table_schema sql_identifier
+
+
+ Name of the schema that contains the table
+ |
+ table_name sql_identifier
+
+
+ Name of the table
+ |
+ privilege_type character_data
+
+
+ Type of the privilege: SELECT,
+ INSERT, UPDATE,
+ DELETE, TRUNCATE,
+ REFERENCES, or TRIGGER
+ |
+ is_grantable yes_or_no
+
+
+ YES if the privilege is grantable, NO if not
+ |
+ with_hierarchy yes_or_no
+
+
+ In the SQL standard, WITH HIERARCHY OPTION
+ is a separate (sub-)privilege allowing certain operations on
+ table inheritance hierarchies. In PostgreSQL, this is included
+ in the SELECT privilege, so this column
+ shows YES if the privilege
+ is SELECT, else NO.
+ |
+ The view tables contains all tables and views
+ defined in the current database. Only those tables and views are
+ shown that the current user has access to (by way of being the
+ owner or having some privilege).
+
Table 37.52. tables Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ table_catalog sql_identifier
+
+
+ Name of the database that contains the table (always the current database)
+ |
+ table_schema sql_identifier
+
+
+ Name of the schema that contains the table
+ |
+ table_name sql_identifier
+
+
+ Name of the table
+ |
+ table_type character_data
+
+
+ Type of the table: BASE TABLE for a
+ persistent base table (the normal table type),
+ VIEW for a view, FOREIGN
+ for a foreign table, or
+ LOCAL TEMPORARY for a temporary table
+ |
+ self_referencing_column_name sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ reference_generation character_data
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ user_defined_type_catalog sql_identifier
+
+
+ If the table is a typed table, the name of the database that
+ contains the underlying data type (always the current
+ database), else null.
+ |
+ user_defined_type_schema sql_identifier
+
+
+ If the table is a typed table, the name of the schema that
+ contains the underlying data type, else null.
+ |
+ user_defined_type_name sql_identifier
+
+
+ If the table is a typed table, the name of the underlying data
+ type, else null.
+ |
+ is_insertable_into yes_or_no
+
+
+ YES if the table is insertable into,
+ NO if not (Base tables are always insertable
+ into, views not necessarily.)
+ |
+ is_typed yes_or_no
+
+
+ YES if the table is a typed table, NO if not
+ |
+ commit_action character_data
+
+
+ Not yet implemented
+ |
37.56. triggered_update_columns #
+ For triggers in the current database that specify a column list
+ (like UPDATE OF column1, column2), the
+ view triggered_update_columns identifies these
+ columns. Triggers that do not specify a column list are not
+ included in this view. Only those columns are shown that the
+ current user owns or has some privilege other than
+ SELECT on.
+
Table 37.54. triggered_update_columns Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ trigger_catalog sql_identifier
+
+
+ Name of the database that contains the trigger (always the current database)
+ |
+ trigger_schema sql_identifier
+
+
+ Name of the schema that contains the trigger
+ |
+ trigger_name sql_identifier
+
+
+ Name of the trigger
+ |
+ event_object_catalog sql_identifier
+
+
+ Name of the database that contains the table that the trigger
+ is defined on (always the current database)
+ |
+ event_object_schema sql_identifier
+
+
+ Name of the schema that contains the table that the trigger is defined on
+ |
+ event_object_table sql_identifier
+
+
+ Name of the table that the trigger is defined on
+ |
+ event_object_column sql_identifier
+
+
+ Name of the column that the trigger is defined on
+ |
+ The view triggers contains all triggers defined
+ in the current database on tables and views that the current user owns
+ or has some privilege other than SELECT on.
+
Table 37.55. triggers Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ trigger_catalog sql_identifier
+
+
+ Name of the database that contains the trigger (always the current database)
+ |
+ trigger_schema sql_identifier
+
+
+ Name of the schema that contains the trigger
+ |
+ trigger_name sql_identifier
+
+
+ Name of the trigger
+ |
+ event_manipulation character_data
+
+
+ Event that fires the trigger (INSERT,
+ UPDATE, or DELETE)
+ |
+ event_object_catalog sql_identifier
+
+
+ Name of the database that contains the table that the trigger
+ is defined on (always the current database)
+ |
+ event_object_schema sql_identifier
+
+
+ Name of the schema that contains the table that the trigger is defined on
+ |
+ event_object_table sql_identifier
+
+
+ Name of the table that the trigger is defined on
+ |
+ action_order cardinal_number
+
+
+ Firing order among triggers on the same table having the same
+ event_manipulation,
+ action_timing, and
+ action_orientation. In
+ PostgreSQL, triggers are fired in name
+ order, so this column reflects that.
+ |
+ action_condition character_data
+
+
+ WHEN condition of the trigger, null if none
+ (also null if the table is not owned by a currently enabled
+ role)
+ |
+ action_statement character_data
+
+
+ Statement that is executed by the trigger (currently always
+ EXECUTE FUNCTION
+ function(...))
+ |
+ action_orientation character_data
+
+
+ Identifies whether the trigger fires once for each processed
+ row or once for each statement (ROW or
+ STATEMENT)
+ |
+ action_timing character_data
+
+
+ Time at which the trigger fires (BEFORE,
+ AFTER, or INSTEAD OF)
+ |
+ action_reference_old_table sql_identifier
+
+
+ Name of the “old” transition table, or null if none
+ |
+ action_reference_new_table sql_identifier
+
+
+ Name of the “new” transition table, or null if none
+ |
+ action_reference_old_row sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ action_reference_new_row sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ created time_stamp
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ Triggers in PostgreSQL have two
+ incompatibilities with the SQL standard that affect the
+ representation in the information schema. First, trigger names are
+ local to each table in PostgreSQL, rather
+ than being independent schema objects. Therefore there can be duplicate
+ trigger names defined in one schema, so long as they belong to
+ different tables. (trigger_catalog and
+ trigger_schema are really the values pertaining
+ to the table that the trigger is defined on.) Second, triggers can
+ be defined to fire on multiple events in
+ PostgreSQL (e.g., ON INSERT OR
+ UPDATE), whereas the SQL standard only allows one. If a
+ trigger is defined to fire on multiple events, it is represented as
+ multiple rows in the information schema, one for each type of
+ event. As a consequence of these two issues, the primary key of
+ the view triggers is really
+ (trigger_catalog, trigger_schema, event_object_table,
+ trigger_name, event_manipulation) instead of
+ (trigger_catalog, trigger_schema, trigger_name),
+ which is what the SQL standard specifies. Nonetheless, if you
+ define your triggers in a manner that conforms with the SQL
+ standard (trigger names unique in the schema and only one event
+ type per trigger), this will not affect you.
+
Note
+ Prior to PostgreSQL 9.1, this view's columns
+ action_timing,
+ action_reference_old_table,
+ action_reference_new_table,
+ action_reference_old_row, and
+ action_reference_new_row
+ were named
+ condition_timing,
+ condition_reference_old_table,
+ condition_reference_new_table,
+ condition_reference_old_row, and
+ condition_reference_new_row
+ respectively.
+ That was how they were named in the SQL:1999 standard.
+ The new naming conforms to SQL:2003 and later.
+
+ The view udt_privileges identifies
+ USAGE privileges granted on user-defined types to a
+ currently enabled role or by a currently enabled role. There is one row for
+ each combination of type, grantor, and grantee. This view shows only
+ composite types (see under Section 37.60
+ for why); see
+ Section 37.59 for domain privileges.
+
Table 37.56. udt_privileges Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ grantor sql_identifier
+
+
+ Name of the role that granted the privilege
+ |
+ grantee sql_identifier
+
+
+ Name of the role that the privilege was granted to
+ |
+ udt_catalog sql_identifier
+
+
+ Name of the database containing the type (always the current database)
+ |
+ udt_schema sql_identifier
+
+
+ Name of the schema containing the type
+ |
+ udt_name sql_identifier
+
+
+ Name of the type
+ |
+ privilege_type character_data
+
+
+ Always TYPE USAGE
+ |
+ is_grantable yes_or_no
+
+
+ YES if the privilege is grantable, NO if not
+ |
37.59. usage_privileges #
+ The view usage_privileges identifies
+ USAGE privileges granted on various kinds of
+ objects to a currently enabled role or by a currently enabled role.
+ In PostgreSQL, this currently applies to
+ collations, domains, foreign-data wrappers, foreign servers, and sequences. There is one
+ row for each combination of object, grantor, and grantee.
+
+ Since collations do not have real privileges
+ in PostgreSQL, this view shows implicit
+ non-grantable USAGE privileges granted by the
+ owner to PUBLIC for all collations. The other
+ object types, however, show real privileges.
+
+ In PostgreSQL, sequences also support SELECT
+ and UPDATE privileges in addition to
+ the USAGE privilege. These are nonstandard and therefore
+ not visible in the information schema.
+
Table 37.57. usage_privileges Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ grantor sql_identifier
+
+
+ Name of the role that granted the privilege
+ |
+ grantee sql_identifier
+
+
+ Name of the role that the privilege was granted to
+ |
+ object_catalog sql_identifier
+
+
+ Name of the database containing the object (always the current database)
+ |
+ object_schema sql_identifier
+
+
+ Name of the schema containing the object, if applicable,
+ else an empty string
+ |
+ object_name sql_identifier
+
+
+ Name of the object
+ |
+ object_type character_data
+
+
+ COLLATION or DOMAIN or FOREIGN DATA WRAPPER or FOREIGN SERVER or SEQUENCE
+ |
+ privilege_type character_data
+
+
+ Always USAGE
+ |
+ is_grantable yes_or_no
+
+
+ YES if the privilege is grantable, NO if not
+ |
37.60. user_defined_types #
+ The view user_defined_types currently contains
+ all composite types defined in the current database.
+ Only those types are shown that the current user has access to (by way
+ of being the owner or having some privilege).
+
+ SQL knows about two kinds of user-defined types: structured types
+ (also known as composite types
+ in PostgreSQL) and distinct types (not
+ implemented in PostgreSQL). To be
+ future-proof, use the
+ column user_defined_type_category to
+ differentiate between these. Other user-defined types such as base
+ types and enums, which are PostgreSQL
+ extensions, are not shown here. For domains,
+ see Section 37.23 instead.
+
Table 37.58. user_defined_types Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ user_defined_type_catalog sql_identifier
+
+
+ Name of the database that contains the type (always the current database)
+ |
+ user_defined_type_schema sql_identifier
+
+
+ Name of the schema that contains the type
+ |
+ user_defined_type_name sql_identifier
+
+
+ Name of the type
+ |
+ user_defined_type_category character_data
+
+
+ Currently always STRUCTURED
+ |
+ is_instantiable yes_or_no
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ is_final yes_or_no
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ ordering_form character_data
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ ordering_category character_data
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ ordering_routine_catalog sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ ordering_routine_schema sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ ordering_routine_name sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ reference_type character_data
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ data_type character_data
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ character_maximum_length cardinal_number
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ character_octet_length cardinal_number
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ character_set_catalog sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ character_set_schema sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ character_set_name sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ collation_catalog sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ collation_schema sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ collation_name sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ numeric_precision cardinal_number
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ numeric_precision_radix cardinal_number
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ numeric_scale cardinal_number
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ datetime_precision cardinal_number
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ interval_type character_data
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ interval_precision cardinal_number
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ source_dtd_identifier sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
+ ref_dtd_identifier sql_identifier
+
+
+ Applies to a feature not available in PostgreSQL
+ |
37.61. user_mapping_options #
+ The view user_mapping_options contains all the
+ options defined for user mappings in the current database. Only
+ those user mappings are shown where the current user has access to
+ the corresponding foreign server (by way of being the owner or
+ having some privilege).
+
Table 37.59. user_mapping_options Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ authorization_identifier sql_identifier
+
+
+ Name of the user being mapped,
+ or PUBLIC if the mapping is public
+ |
+ foreign_server_catalog sql_identifier
+
+
+ Name of the database that the foreign server used by this
+ mapping is defined in (always the current database)
+ |
+ foreign_server_name sql_identifier
+
+
+ Name of the foreign server used by this mapping
+ |
+ option_name sql_identifier
+
+
+ Name of an option
+ |
+ option_value character_data
+
+
+ Value of the option. This column will show as null
+ unless the current user is the user being mapped, or the mapping
+ is for PUBLIC and the current user is the
+ server owner, or the current user is a superuser. The intent is
+ to protect password information stored as user mapping
+ option.
+ |
+ The view user_mappings contains all user
+ mappings defined in the current database. Only those user mappings
+ are shown where the current user has access to the corresponding
+ foreign server (by way of being the owner or having some
+ privilege).
+
Table 37.60. user_mappings Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ authorization_identifier sql_identifier
+
+
+ Name of the user being mapped,
+ or PUBLIC if the mapping is public
+ |
+ foreign_server_catalog sql_identifier
+
+
+ Name of the database that the foreign server used by this
+ mapping is defined in (always the current database)
+ |
+ foreign_server_name sql_identifier
+
+
+ Name of the foreign server used by this mapping
+ |
37.63. view_column_usage #
+ The view view_column_usage identifies all
+ columns that are used in the query expression of a view (the
+ SELECT statement that defines the view). A
+ column is only included if the table that contains the column is
+ owned by a currently enabled role.
+
Note
+ Columns of system tables are not included. This should be fixed
+ sometime.
+
Table 37.61. view_column_usage Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ view_catalog sql_identifier
+
+
+ Name of the database that contains the view (always the current database)
+ |
+ view_schema sql_identifier
+
+
+ Name of the schema that contains the view
+ |
+ view_name sql_identifier
+
+
+ Name of the view
+ |
+ table_catalog sql_identifier
+
+
+ Name of the database that contains the table that contains the
+ column that is used by the view (always the current database)
+ |
+ table_schema sql_identifier
+
+
+ Name of the schema that contains the table that contains the
+ column that is used by the view
+ |
+ table_name sql_identifier
+
+
+ Name of the table that contains the column that is used by the
+ view
+ |
+ column_name sql_identifier
+
+
+ Name of the column that is used by the view
+ |
37.64. view_routine_usage #
+ The view view_routine_usage identifies all
+ routines (functions and procedures) that are used in the query
+ expression of a view (the SELECT statement that
+ defines the view). A routine is only included if that routine is
+ owned by a currently enabled role.
+
Table 37.62. view_routine_usage Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ table_catalog sql_identifier
+
+
+ Name of the database containing the view (always the current database)
+ |
+ table_schema sql_identifier
+
+
+ Name of the schema containing the view
+ |
+ table_name sql_identifier
+
+
+ Name of the view
+ |
+ specific_catalog sql_identifier
+
+
+ Name of the database containing the function (always the current database)
+ |
+ specific_schema sql_identifier
+
+
+ Name of the schema containing the function
+ |
+ specific_name sql_identifier
+
+
+ The “specific name” of the function. See Section 37.45 for more information.
+ |
37.65. view_table_usage #
+ The view view_table_usage identifies all tables
+ that are used in the query expression of a view (the
+ SELECT statement that defines the view). A
+ table is only included if that table is owned by a currently
+ enabled role.
+
Note
+ System tables are not included. This should be fixed sometime.
+
Table 37.63. view_table_usage Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ view_catalog sql_identifier
+
+
+ Name of the database that contains the view (always the current database)
+ |
+ view_schema sql_identifier
+
+
+ Name of the schema that contains the view
+ |
+ view_name sql_identifier
+
+
+ Name of the view
+ |
+ table_catalog sql_identifier
+
+
+ Name of the database that contains the table that is
+ used by the view (always the current database)
+ |
+ table_schema sql_identifier
+
+
+ Name of the schema that contains the table that is used by the
+ view
+ |
+ table_name sql_identifier
+
+
+ Name of the table that is used by the view
+ |
+ The view views contains all views defined in the
+ current database. Only those views are shown that the current user
+ has access to (by way of being the owner or having some privilege).
+
Table 37.64. views Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ table_catalog sql_identifier
+
+
+ Name of the database that contains the view (always the current database)
+ |
+ table_schema sql_identifier
+
+
+ Name of the schema that contains the view
+ |
+ table_name sql_identifier
+
+
+ Name of the view
+ |
+ view_definition character_data
+
+
+ Query expression defining the view (null if the view is not
+ owned by a currently enabled role)
+ |
+ check_option character_data
+
+
+ CASCADED or LOCAL if the view
+ has a CHECK OPTION defined on it,
+ NONE if not
+ |
+ is_updatable yes_or_no
+
+
+ YES if the view is updatable (allows
+ UPDATE and DELETE),
+ NO if not
+ |
+ is_insertable_into yes_or_no
+
+
+ YES if the view is insertable into (allows
+ INSERT), NO if not
+ |
+ is_trigger_updatable yes_or_no
+
+
+ YES if the view has an INSTEAD OF
+ UPDATE trigger defined on it, NO if not
+ |
+ is_trigger_deletable yes_or_no
+
+
+ YES if the view has an INSTEAD OF
+ DELETE trigger defined on it, NO if not
+ |
+ is_trigger_insertable_into yes_or_no
+
+
+ YES if the view has an INSTEAD OF
+ INSERT trigger defined on it, NO if not
+ |
Chapter 16. Installation from Binaries
+ PostgreSQL is available in the form of binary
+ packages for most common operating systems today. When available, this is
+ the recommended way to install PostgreSQL for users of the system. Building
+ from source (see Chapter 17) is only recommended for
+ people developing PostgreSQL or extensions.
+
+ For an updated list of platforms providing binary packages, please visit
+ the download section on the PostgreSQL website at
+ https://www.postgresql.org/download/ and follow the
+ instructions for the specific platform.
+
17.2. Getting the Source #
+ The PostgreSQL source code for released versions
+ can be obtained from the download section of our website:
+ https://www.postgresql.org/ftp/source/.
+ Download the
+ postgresql-version.tar.gz
+ or postgresql-version.tar.bz2
+ file you're interested in, then unpack it:
+
+tar xf postgresql-version.tar.bz2
+
+ This will create a directory
+ postgresql-version under
+ the current directory with the PostgreSQL sources.
+ Change into that directory for the rest of the installation procedure.
+
+ Alternatively, you can use the Git version control system; see
+ Section I.1 for more information.
+
17.3. Building and Installation with Autoconf and Make #
+
+./configure
+make
+su
+make install
+adduser postgres
+mkdir -p /usr/local/pgsql/data
+chown postgres /usr/local/pgsql/data
+su - postgres
+/usr/local/pgsql/bin/initdb -D /usr/local/pgsql/data
+/usr/local/pgsql/bin/pg_ctl -D /usr/local/pgsql/data -l logfile start
+/usr/local/pgsql/bin/createdb test
+/usr/local/pgsql/bin/psql test
+
+ The long version is the rest of this
+ section.
+
17.3.2. Installation Procedure #
Configuration
+ The first step of the installation procedure is to configure the
+ source tree for your system and choose the options you would like.
+ This is done by running the configure script. For a
+ default installation simply enter:
+
+./configure
+
+ This script will run a number of tests to determine values for various
+ system dependent variables and detect any quirks of your
+ operating system, and finally will create several files in the
+ build tree to record what it found.
+
+ You can also run configure in a directory outside
+ the source tree, and then build there, if you want to keep the build
+ directory separate from the original source files. This procedure is
+ called a
+ VPATH
+ build. Here's how:
+
+mkdir build_dir
+cd build_dir
+/path/to/source/tree/configure [options go here]
+make
+
+
+ The default configuration will build the server and utilities, as
+ well as all client applications and interfaces that require only a
+ C compiler. All files will be installed under
+ /usr/local/pgsql by default.
+
+ You can customize the build and installation process by supplying one
+ or more command line options to configure.
+ Typically you would customize the install location, or the set of
+ optional features that are built. configure
+ has a large number of options, which are described in
+ Section 17.3.3.
+
+ Also, configure responds to certain environment
+ variables, as described in Section 17.3.4.
+ These provide additional ways to customize the configuration.
+
Build
+ To start the build, type either of:
+
+make
+make all
+
+ (Remember to use GNU make.)
+ The build will take a few minutes depending on your
+ hardware.
+
+ If you want to build everything that can be built, including the
+ documentation (HTML and man pages), and the additional modules
+ (contrib), type instead:
+
+make world
+
+
+ If you want to build everything that can be built, including the
+ additional modules (contrib), but without
+ the documentation, type instead:
+
+make world-bin
+
+
+ If you want to invoke the build from another makefile rather than
+ manually, you must unset MAKELEVEL or set it to zero,
+ for instance like this:
+
+build-postgresql:
+ $(MAKE) -C postgresql MAKELEVEL=0 all
+
+ Failure to do that can lead to strange error messages, typically about
+ missing header files.
+
Regression Tests
+ If you want to test the newly built server before you install it,
+ you can run the regression tests at this point. The regression
+ tests are a test suite to verify that PostgreSQL
+ runs on your machine in the way the developers expected it
+ to. Type:
+
+make check
+
+ (This won't work as root; do it as an unprivileged user.)
+ See Chapter 33 for
+ detailed information about interpreting the test results. You can
+ repeat this test at any later time by issuing the same command.
+
Installing the Files
Note
+ If you are upgrading an existing system be sure to read
+ Section 19.6,
+ which has instructions about upgrading a
+ cluster.
+
+ To install PostgreSQL enter:
+
+make install
+
+ This will install files into the directories that were specified
+ in Step 1. Make sure that you have appropriate
+ permissions to write into that area. Normally you need to do this
+ step as root. Alternatively, you can create the target
+ directories in advance and arrange for appropriate permissions to
+ be granted.
+
+ To install the documentation (HTML and man pages), enter:
+
+make install-docs
+
+
+ If you built the world above, type instead:
+
+make install-world
+
+ This also installs the documentation.
+
+ If you built the world without the documentation above, type instead:
+
+make install-world-bin
+
+
+ You can use make install-strip instead of
+ make install to strip the executable files and
+ libraries as they are installed. This will save some space. If
+ you built with debugging support, stripping will effectively
+ remove the debugging support, so it should only be done if
+ debugging is no longer needed. install-strip
+ tries to do a reasonable job saving space, but it does not have
+ perfect knowledge of how to strip every unneeded byte from an
+ executable file, so if you want to save all the disk space you
+ possibly can, you will have to do manual work.
+
+ The standard installation provides all the header files needed for client
+ application development as well as for server-side program
+ development, such as custom functions or data types written in C.
+
Client-only installation:
+ If you want to install only the client applications and
+ interface libraries, then you can use these commands:
+
+make -C src/bin install
+make -C src/include install
+make -C src/interfaces install
+make -C doc install
+
+ src/bin has a few binaries for server-only use,
+ but they are small.
+
Uninstallation:
+ To undo the installation use the command make
+ uninstall. However, this will not remove any created directories.
+
Cleaning:
+ After the installation you can free disk space by removing the built
+ files from the source tree with the command make
+ clean. This will preserve the files made by the configure
+ program, so that you can rebuild everything with make
+ later on. To reset the source tree to the state in which it was
+ distributed, use make distclean. If you are going to
+ build for several platforms within the same source tree you must do
+ this and re-configure for each platform. (Alternatively, use
+ a separate build tree for each platform, so that the source tree
+ remains unmodified.)
+
+ If you perform a build and then discover that your configure
+ options were wrong, or if you change anything that configure
+ investigates (for example, software upgrades), then it's a good
+ idea to do make distclean before reconfiguring and
+ rebuilding. Without this, your changes in configuration choices
+ might not propagate everywhere they need to.
+
17.3.4. configure Environment Variables #
+ In addition to the ordinary command-line options described above,
+ configure responds to a number of environment
+ variables.
+ You can specify environment variables on the
+ configure command line, for example:
+
+./configure CC=/opt/bin/gcc CFLAGS='-O2 -pipe'
+
+ In this usage an environment variable is little different from a
+ command-line option.
+ You can also set such variables beforehand:
+
+export CC=/opt/bin/gcc
+export CFLAGS='-O2 -pipe'
+./configure
+
+ This usage can be convenient because many programs' configuration
+ scripts respond to these variables in similar ways.
+
+ The most commonly used of these environment variables are
+ CC and CFLAGS.
+ If you prefer a C compiler different from the one
+ configure picks, you can set the
+ variable CC to the program of your choice.
+ By default, configure will pick
+ gcc if available, else the platform's
+ default (usually cc). Similarly, you can override the
+ default compiler flags if needed with the CFLAGS variable.
+
+ Here is a list of the significant variables that can be set in
+ this manner:
+
+
BISON #
+ Bison program
+
CC #
+ C compiler
+
CFLAGS #
+ options to pass to the C compiler
+
CLANG #
+ path to clang program used to process source code
+ for inlining when compiling with --with-llvm
+
CPP #
+ C preprocessor
+
CPPFLAGS #
+ options to pass to the C preprocessor
+
CXX #
+ C++ compiler
+
CXXFLAGS #
+ options to pass to the C++ compiler
+
DTRACE #
+ location of the dtrace program
+
DTRACEFLAGS #
+ options to pass to the dtrace program
+
FLEX #
+ Flex program
+
LDFLAGS #
+ options to use when linking either executables or shared libraries
+
LDFLAGS_EX #
+ additional options for linking executables only
+
LDFLAGS_SL #
+ additional options for linking shared libraries only
+
LLVM_CONFIG #
+ llvm-config program used to locate the
+ LLVM installation
+
MSGFMT #
+ msgfmt program for native language support
+
PERL #
+ Perl interpreter program. This will be used to determine the
+ dependencies for building PL/Perl. The default is
+ perl.
+
PYTHON #
+ Python interpreter program. This will be used to determine the
+ dependencies for building PL/Python. If this is not set, the
+ following are probed in this order:
+ python3 python.
+
TCLSH #
+ Tcl interpreter program. This will be used to
+ determine the dependencies for building PL/Tcl.
+ If this is not set, the following are probed in this
+ order: tclsh tcl tclsh8.6 tclsh86 tclsh8.5 tclsh85
+ tclsh8.4 tclsh84.
+
XML2_CONFIG #
+ xml2-config program used to locate the
+ libxml2 installation
+
+
+ Sometimes it is useful to add compiler flags after-the-fact to the set
+ that were chosen by configure. An important example is
+ that gcc's -Werror option cannot be included
+ in the CFLAGS passed to configure, because
+ it will break many of configure's built-in tests. To add
+ such flags, include them in the COPT environment variable
+ while running make. The contents of COPT
+ are added to both the CFLAGS and LDFLAGS
+ options set up by configure. For example, you could do
+
+make COPT='-Werror'
+
+ or
+
+export COPT='-Werror'
+make
+
+
Note
+ If using GCC, it is best to build with an optimization level of
+ at least -O1, because using no optimization
+ (-O0) disables some important compiler warnings (such
+ as the use of uninitialized variables). However, non-zero
+ optimization levels can complicate debugging because stepping
+ through compiled code will usually not match up one-to-one with
+ source code lines. If you get confused while trying to debug
+ optimized code, recompile the specific files of interest with
+ -O0. An easy way to do this is by passing an option
+ to make: make PROFILE=-O0 file.o.
+
+ The COPT and PROFILE environment variables are
+ actually handled identically by the PostgreSQL
+ makefiles. Which to use is a matter of preference, but a common habit
+ among developers is to use PROFILE for one-time flag
+ adjustments, while COPT might be kept set all the time.
+
17.4. Building and Installation with Meson #
+
+meson setup build --prefix=/usr/local/pgsql
+cd build
+ninja
+su
+ninja install
+adduser postgres
+mkdir -p /usr/local/pgsql/data
+chown postgres /usr/local/pgsql/data
+su - postgres
+/usr/local/pgsql/bin/initdb -D /usr/local/pgsql/data
+/usr/local/pgsql/bin/pg_ctl -D /usr/local/pgsql/data -l logfile start
+/usr/local/pgsql/bin/createdb test
+/usr/local/pgsql/bin/psql test
+
+ The long version is the rest of this
+ section.
+
17.4.2. Installation Procedure #
Configuration
+ The first step of the installation procedure is to configure the
+ build tree for your system and choose the options you would like. To
+ create and configure the build directory, you can start with the
+ meson setup command.
+
+meson setup build
+
+ The setup command takes a builddir and a srcdir
+ argument. If no srcdir is given, Meson will deduce the
+ srcdir based on the current directory and the location
+ of meson.build. The builddir is mandatory.
+
+ Running meson setup loads the build configuration file and sets up the build directory.
+ Additionally, you can also pass several build options to Meson. Some commonly
+ used options are mentioned in the subsequent sections. For example:
+
+
+# configure with a different installation prefix
+meson setup build --prefix=/home/user/pg-install
+
+# configure to generate a debug build
+meson setup build --buildtype=debug
+
+# configure to build with OpenSSL support
+meson setup build -Dssl=openssl
+
+
+ Setting up the build directory is a one-time step. To reconfigure before a
+ new build, you can simply use the meson configure command
+
+meson configure -Dcassert=true
+
+ meson configure's commonly used command-line options
+ are explained in Section 17.4.3.
+
Build
+ By default, Meson uses the Ninja build tool. To build
+ PostgreSQL from source using Meson, you can
+ simply use the ninja command in the build directory.
+
+ninja
+
+ Ninja will automatically detect the number of CPUs in your computer and
+ parallelize itself accordingly. You can override the number of parallel
+ processes used with the command line argument -j.
+
+ It should be noted that after the initial configure step,
+ ninja is the only command you ever need to type to
+ compile. No matter how you alter your source tree (short of moving it to a
+ completely new location), Meson will detect the changes and regenerate
+ itself accordingly. This is especially handy if you have multiple build
+ directories. Often one of them is used for development (the "debug" build)
+ and others only every now and then (such as a "static analysis" build).
+ Any configuration can be built just by cd'ing to the corresponding
+ directory and running Ninja.
+
+ If you'd like to build with a backend other than ninja, you can use
+ configure with the --backend option to select the one you
+ want to use and then build using meson compile. To
+ learn more about these backends and other arguments you can provide to
+ ninja, you can refer to the
+ Meson documentation.
+
Regression Tests
+ If you want to test the newly built server before you install it,
+ you can run the regression tests at this point. The regression
+ tests are a test suite to verify that PostgreSQL
+ runs on your machine in the way the developers expected it
+ to. Type:
+
+meson test
+
+ (This won't work as root; do it as an unprivileged user.)
+ See Chapter 33 for
+ detailed information about interpreting the test results. You can
+ repeat this test at any later time by issuing the same command.
+
+ To run pg_regress and pg_isolation_regress tests against a running
+ postgres instance, specify --setup running as an
+ argument to meson test.
+
Installing the Files
Note
+ If you are upgrading an existing system be sure to read
+ Section 19.6,
+ which has instructions about upgrading a
+ cluster.
+
+ Once PostgreSQL is built, you can install it by simply running the
+ ninja install command.
+
+ninja install
+
+
+ This will install files into the directories that were specified
+ in Step 1. Make sure that you have appropriate
+ permissions to write into that area. You might need to do this
+ step as root. Alternatively, you can create the target directories
+ in advance and arrange for appropriate permissions to be granted.
+ The standard installation provides all the header files needed for client
+ application development as well as for server-side program
+ development, such as custom functions or data types written in C.
+
+ ninja install should work for most cases, but if you'd
+ like to use more options (such as --quiet to suppress
+ extra output), you could also use meson install
+ instead. You can learn more about meson install
+ and its options in the Meson documentation.
+
Uninstallation:
+ To undo the installation, you can use the ninja
+ uninstall command.
+
Cleaning:
+ After the installation, you can free disk space by removing the built
+ files from the source tree with the ninja clean
+ command.
+
17.4.3. meson setup Options #
+ meson setup's command-line options are explained below.
+ This list is not exhaustive (use meson configure --help
+ to get one that is). The options not covered here are meant for advanced
+ use-cases, and are documented in the standard Meson
+ documentation. These arguments can be used with meson
+ setup as well.
+
17.4.3.1. Installation Locations #
+ These options control where ninja install (or meson install) will put
+ the files. The --prefix option (example
+ Section 17.4.1) is sufficient for
+ most cases. If you have special needs, you can customize the
+ installation subdirectories with the other options described in this
+ section. Beware however that changing the relative locations of the
+ different subdirectories may render the installation non-relocatable,
+ meaning you won't be able to move it after installation.
+ (The man and doc locations are
+ not affected by this restriction.) For relocatable installs, you
+ might want to use the -Drpath=false option
+ described later.
+
--prefix=PREFIX #
+ Install all files under the directory PREFIX
+ instead of /usr/local/pgsql (on Unix based systems) or
+ current drive letter:/usr/local/pgsqlPREFIX directory.
+
--bindir=DIRECTORY #
+ Specifies the directory for executable programs. The default
+ is PREFIX/bin
--sysconfdir=DIRECTORY #
+ Sets the directory for various configuration files,
+ PREFIX/etc
--libdir=DIRECTORY #
+ Sets the location to install libraries and dynamically loadable
+ modules. The default is
+ PREFIX/lib
--includedir=DIRECTORY #
+ Sets the directory for installing C and C++ header files. The
+ default is PREFIX/include
--datadir=DIRECTORY #
+ Sets the directory for read-only data files used by the
+ installed programs. The default is
+ PREFIX/share
--localedir=DIRECTORY #
+ Sets the directory for installing locale data, in particular
+ message translation catalog files. The default is
+ DATADIR/locale
--mandir=DIRECTORY #
+ The man pages that come with PostgreSQL will be installed under
+ this directory, in their respective
+ manx subdirectories.
+ The default is DATADIR/man
Note
+ Care has been taken to make it possible to install
+ PostgreSQL into shared installation locations
+ (such as /usr/local/include) without
+ interfering with the namespace of the rest of the system. First,
+ the string “/postgresql” is
+ automatically appended to datadir,
+ sysconfdir, and docdir,
+ unless the fully expanded directory name already contains the
+ string “postgres” or
+ “pgsql”. For example, if you choose
+ /usr/local as prefix, the documentation will
+ be installed in /usr/local/doc/postgresql,
+ but if the prefix is /opt/postgres, then it
+ will be in /opt/postgres/doc. The public C
+ header files of the client interfaces are installed into
+ includedir and are namespace-clean. The
+ internal header files and the server header files are installed
+ into private directories under includedir. See
+ the documentation of each interface for information about how to
+ access its header files. Finally, a private subdirectory will
+ also be created, if appropriate, under libdir
+ for dynamically loadable modules.
+
17.4.3.2. PostgreSQL Features #
+ The options described in this section enable building of
+ various optional PostgreSQL features.
+ Most of these require additional software, as described in
+ Section 17.1, and will be automatically enabled if the
+ required software is found. You can change this behavior by manually
+ setting these features to enabled to require them
+ or disabled to not build with them.
+
+ To specify PostgreSQL-specific options, the name of the option
+ must be prefixed by -D.
+
-Dnls={ auto | enabled | disabled } #
+ Enables or disables Native Language Support (NLS),
+ that is, the ability to display a program's messages in a language
+ other than English. Defaults to auto and will be enabled
+ automatically if an implementation of the Gettext
+ API is found.
+
-Dplperl={ auto | enabled | disabled } #
+ Build the PL/Perl server-side language.
+ Defaults to auto.
+
-Dplpython={ auto | enabled | disabled } #
+ Build the PL/Python server-side language.
+ Defaults to auto.
+
-Dpltcl={ auto | enabled | disabled } #
+ Build the PL/Tcl server-side language.
+ Defaults to auto.
+
-Dtcl_version=TCL_VERSION #
+ Specifies the Tcl version to use when building PL/Tcl.
+
-Dicu={ auto | enabled | disabled } #
+ Build with support for the
+ ICU
+ library, enabling use of ICU collation features (see Section 24.2). Defaults to auto and requires the
+ ICU4C package to be installed. The minimum
+ required version of ICU4C is currently 4.2.
+
-Dllvm={ auto | enabled | disabled } #
+ Build with support for LLVM based
+ JIT compilation (see Chapter 32).
+ This requires the LLVM library to be
+ installed. The minimum required version of
+ LLVM is currently 3.9. Disabled by
+ default.
+
+ llvm-config
+ will be used to find the required compilation options.
+ llvm-config, and then
+ llvm-config-$version for all supported versions,
+ will be searched for in your PATH. If that would not
+ yield the desired program, use LLVM_CONFIG to specify a
+ path to the correct llvm-config.
+
-Dlz4={ auto | enabled | disabled } #
+ Build with LZ4 compression support.
+ Defaults to auto.
+
-Dzstd={ auto | enabled | disabled } #
+ Build with Zstandard compression support.
+ Defaults to auto.
+
-Dssl={ auto | LIBRARY }
+
+ #
+ Build with support for SSL (encrypted) connections.
+ The only LIBRARY supported is
+ openssl. This requires the
+ OpenSSL package to be installed. Building
+ with this will check for the required header files and libraries to
+ make sure that your OpenSSL installation is
+ sufficient before proceeding. The default for this option is auto.
+
-Dgssapi={ auto | enabled | disabled } #
+ Build with support for GSSAPI authentication. MIT Kerberos is required
+ to be installed for GSSAPI. On many systems, the GSSAPI system (a part
+ of the MIT Kerberos installation) is not installed in a location
+ that is searched by default (e.g., /usr/include,
+ /usr/lib). In
+ those cases, PostgreSQL will query pkg-config to
+ detect the required compiler and linker options. Defaults to auto.
+ meson configure will check for the required
+ header files and libraries to make sure that your GSSAPI installation
+ is sufficient before proceeding.
+
-Dldap={ auto | enabled | disabled } #
+ Build with
+ LDAP
+ support for authentication and connection parameter lookup (see
+ Section 34.18 and
+ Section 21.10 for more information). On Unix,
+ this requires the OpenLDAP package to be
+ installed. On Windows, the default WinLDAP
+ library is used. Defaults to auto. meson
+ configure will check for the required header files and
+ libraries to make sure that your OpenLDAP
+ installation is sufficient before proceeding.
+
-Dpam={ auto | enabled | disabled } #
+ Build with
+ PAM
+ (Pluggable Authentication Modules) support. Defaults to auto.
+
-Dbsd_auth={ auto | enabled | disabled } #
+ Build with BSD Authentication support. (The BSD Authentication
+ framework is currently only available on OpenBSD.) Defaults to auto.
+
-Dsystemd={ auto | enabled | disabled } #
+ Build with support for
+ systemd
+ service notifications. This improves integration if the server is
+ started under systemd but has no impact
+ otherwise; see Section 19.3 for more information. Defaults to
+ auto. libsystemd and the associated header
+ files need to be installed to use this option.
+
-Dbonjour={ auto | enabled | disabled } #
+ Build with support for Bonjour automatic service discovery. Defaults
+ to auto and requires Bonjour support in your operating system.
+ Recommended on macOS.
+
-Duuid=LIBRARY #
+ Build the uuid-ossp module
+ (which provides functions to generate UUIDs), using the specified
+ UUID library.
+ LIBRARY must be one of:
+
+ none to not build the uuid module. This is the default.
+
+ bsd to use the UUID functions found in FreeBSD,
+ and some other BSD-derived systems
+
+ e2fs to use the UUID library created by
+ the e2fsprogs project; this library is present in most
+ Linux systems and in macOS, and can be obtained for other
+ platforms as well
+
+ ossp to use the OSSP UUID library
+
-Dlibxml={ auto | enabled | disabled } #
+ Build with libxml2, enabling SQL/XML support. Defaults to
+ auto. Libxml2 version 2.6.23 or later is required for this feature.
+
+ To use a libxml2 installation that is in an unusual location, you
+ can set pkg-config-related environment
+ variables (see its documentation).
+
-Dlibxslt={ auto | enabled | disabled } #
+ Build with libxslt, enabling the
+ xml2
+ module to perform XSL transformations of XML.
+ -Dlibxml must be specified as well. Defaults to
+ auto.
+
17.4.3.3. Anti-Features #
-Dreadline={ auto | enabled | disabled } #
+ Allows use of the Readline library (and
+ libedit as well). This option defaults to
+ auto and enables command-line editing and history in
+ psql and is strongly recommended.
+
-Dlibedit_preferred={ true | false } #
+ Setting this to true favors the use of the BSD-licensed
+ libedit library rather than GPL-licensed
+ Readline. This option is significant only
+ if you have both libraries installed; the default is false, that is to
+ use Readline.
+
-Dzlib={ auto | enabled | disabled } #
+
+ Enables use of the Zlib library.
+ It defaults to auto and enables
+ support for compressed archives in pg_dump,
+ pg_restore and pg_basebackup and is recommended.
+
-Dspinlocks={ true | false } #
+ This option is set to true by default; setting it to false will
+ allow the build to succeed even if PostgreSQL
+ has no CPU spinlock support for the platform. The lack of
+ spinlock support will result in very poor performance; therefore,
+ this option should only be changed if the build aborts and
+ informs you that the platform lacks spinlock support. If setting this
+ option to false is required to build PostgreSQL on
+ your platform, please report the problem to the
+ PostgreSQL developers.
+
-Datomics={ true | false } #
+ This option is set to true by default; setting it to false will
+ disable use of CPU atomic operations. The option does nothing on
+ platforms that lack such operations. On platforms that do have
+ them, disabling atomics will result in poor performance. Changing
+ this option is only useful for debugging or making performance comparisons.
+
17.4.3.4. Build Process Details #
--auto_features={ auto | enabled | disabled } #
+ Setting this option allows you to override the value of all
+ “auto” features (features that are enabled automatically
+ if the required software is found). This can be useful when you want
+ to disable or enable all the “optional” features at once
+ without having to set each of them manually. The default value for
+ this parameter is auto.
+
--backend=BACKEND #
+ The default backend Meson uses is ninja and that should suffice for
+ most use cases. However, if you'd like to fully integrate with Visual
+ Studio, you can set the BACKEND to
+ vs.
+
-Dc_args=OPTIONS #
+ This option can be used to pass extra options to the C compiler.
+
-Dc_link_args=OPTIONS #
+ This option can be used to pass extra options to the C linker.
+
+ DIRECTORIES is a comma-separated list of
+ directories that will be added to the list the compiler searches for
+ header files. If you have optional packages (such as GNU
+ Readline) installed in a non-standard
+ location, you have to use this option and probably also the
+ corresponding -Dextra_lib_dirs option.
+
+ Example: -Dextra_include_dirs=/opt/gnu/include,/usr/sup/include.
+
+ DIRECTORIES is a comma-separated list of
+ directories to search for libraries. You will probably have to use
+ this option (and the corresponding
+ -Dextra_include_dirs option) if you have packages
+ installed in non-standard locations.
+
+ Example: -Dextra_lib_dirs=/opt/gnu/lib,/usr/sup/lib.
+
-Dsystem_tzdata=DIRECTORY
+
+ #
+ PostgreSQL includes its own time zone
+ database, which it requires for date and time operations. This time
+ zone database is in fact compatible with the IANA time zone database
+ provided by many operating systems such as FreeBSD, Linux, and
+ Solaris, so it would be redundant to install it again. When this
+ option is used, the system-supplied time zone database in
+ DIRECTORY is used instead of the one
+ included in the PostgreSQL source distribution.
+ DIRECTORY must be specified as an absolute
+ path. /usr/share/zoneinfo is a likely directory
+ on some operating systems. Note that the installation routine will
+ not detect mismatching or erroneous time zone data. If you use this
+ option, you are advised to run the regression tests to verify that the
+ time zone data you have pointed to works correctly with
+ PostgreSQL.
+
+ This option is mainly aimed at binary package distributors who know
+ their target operating system well. The main advantage of using this
+ option is that the PostgreSQL package won't need to be upgraded
+ whenever any of the many local daylight-saving time rules change.
+ Another advantage is that PostgreSQL can be cross-compiled more
+ straightforwardly if the time zone database files do not need to be
+ built during the installation.
+
+ Append STRING to the PostgreSQL version
+ number. You can use this, for example, to mark binaries built from
+ unreleased Git snapshots or containing
+ custom patches with an extra version string, such as a git
+ describe identifier or a distribution package release
+ number.
+
-Drpath={ true | false } #
+ This option is set to true by default. If set to false,
+ do not mark PostgreSQL's executables
+ to indicate that they should search for shared libraries in the
+ installation's library directory (see --libdir).
+ On most platforms, this marking uses an absolute path to the
+ library directory, so that it will be unhelpful if you relocate
+ the installation later. However, you will then need to provide
+ some other way for the executables to find the shared libraries.
+ Typically this requires configuring the operating system's
+ dynamic linker to search the library directory; see
+ Section 17.5.1 for more detail.
+
-DBINARY_NAME=PATH #
+ If a program required to build PostgreSQL (with or without optional
+ flags) is stored at a non-standard path, you can specify it manually
+ to meson configure. The complete list of programs
+ for which this is supported can be found by running meson
+ configure. Example:
+
meson configure -DBISON=PATH_TO_BISON
+
17.4.3.5. Documentation #
+ See Section J.2 for the tools needed for building
+ the documentation.
+
-Ddocs={ auto | enabled | disabled } #
+ Enables building the documentation in HTML and
+ man format. It defaults to auto.
+
-Ddocs_pdf={ auto | enabled | disabled } #
+ Enables building the documentation in PDF
+ format. It defaults to auto.
+
-Ddocs_html_style={ simple | website } #
+ Controls which CSS stylesheet is used. The default
+ is simple. If set to website,
+ the HTML documentation will reference the stylesheet for postgresql.org.
+
17.4.3.6. Miscellaneous #
-Dpgport=NUMBER #
+ Set NUMBER as the default port number for
+ server and clients. The default is 5432. The port can always
+ be changed later on, but if you specify it here then both
+ server and clients will have the same default compiled in,
+ which can be very convenient. Usually the only good reason
+ to select a non-default value is if you intend to run multiple
+ PostgreSQL servers on the same machine.
+
-Dkrb_srvnam=NAME #
+ The default name of the Kerberos service principal used
+ by GSSAPI.
+ postgres is the default. There's usually no
+ reason to change this unless you are building for a Windows
+ environment, in which case it must be set to upper case
+ POSTGRES.
+
-Dsegsize=SEGSIZE #
+ Set the segment size, in gigabytes. Large tables are
+ divided into multiple operating-system files, each of size equal
+ to the segment size. This avoids problems with file size limits
+ that exist on many platforms. The default segment size, 1 gigabyte,
+ is safe on all supported platforms. If your operating system has
+ “largefile” support (which most do, nowadays), you can use
+ a larger segment size. This can be helpful to reduce the number of
+ file descriptors consumed when working with very large tables.
+ But be careful not to select a value larger than is supported
+ by your platform and the file systems you intend to use. Other
+ tools you might wish to use, such as tar, could
+ also set limits on the usable file size.
+ It is recommended, though not absolutely required, that this value
+ be a power of 2.
+
-Dblocksize=BLOCKSIZE #
+ Set the block size, in kilobytes. This is the unit
+ of storage and I/O within tables. The default, 8 kilobytes,
+ is suitable for most situations; but other values may be useful
+ in special cases.
+ The value must be a power of 2 between 1 and 32 (kilobytes).
+
-Dwal_blocksize=BLOCKSIZE #
+ Set the WAL block size, in kilobytes. This is the unit
+ of storage and I/O within the WAL log. The default, 8 kilobytes,
+ is suitable for most situations; but other values may be useful
+ in special cases.
+ The value must be a power of 2 between 1 and 64 (kilobytes).
+
17.4.3.7. Developer Options #
+ Most of the options in this section are only of interest for
+ developing or debugging PostgreSQL.
+ They are not recommended for production builds, except
+ for --debug, which can be useful to enable
+ detailed bug reports in the unlucky event that you encounter a bug.
+ On platforms supporting DTrace, -Ddtrace
+ may also be reasonable to use in production.
+
+ When building an installation that will be used to develop code inside
+ the server, it is recommended to use at least the --buildtype=debug
+ and -Dcassert options.
+
--buildtype=BUILDTYPE #
+ This option can be used to specify the buildtype to use; defaults to
+ debugoptimized. If you'd like finer control on the debug
+ symbols and optimization levels than what this option provides, you
+ can refer to the --debug and
+ --optimization flags.
+
+ The following build types are generally used: plain,
+ debug, debugoptimized and
+ release. More information about them can be found in
+ the Meson
+ documentation.
+
--debug #
+ Compiles all programs and libraries with debugging symbols. This
+ means that you can run the programs in a debugger to analyze
+ problems. This enlarges the size of the installed executables
+ considerably, and on non-GCC compilers it usually also disables
+ compiler optimization, causing slowdowns. However, having the symbols
+ available is extremely helpful for dealing with any problems that
+ might arise. Currently, this option is recommended for production
+ installations only if you use GCC. But you should always have it on
+ if you are doing development work or running a beta version.
+
--optimization=LEVEL #
+ Specify the optimization level. LEVEL can be set to any of {0,g,1,2,3,s}.
+
--werror #
+ Setting this option asks the compiler to treat warnings as
+ errors. This can be useful for code development.
+
-Dcassert={ true | false } #
+ Enables assertion checks in the server, which
+ test for many “cannot happen” conditions. This is
+ invaluable for code development purposes, but the tests slow down the
+ server significantly. Also, having the tests turned on won't
+ necessarily enhance the stability of your server! The assertion
+ checks are not categorized for severity, and so what might be a
+ relatively harmless bug will still lead to server restarts if it
+ triggers an assertion failure. This option is not recommended for
+ production use, but you should have it on for development work or when
+ running a beta version.
+
-Dtap_tests={ auto | enabled | disabled } #
+ Enable tests using the Perl TAP tools. Defaults to auto and requires
+ a Perl installation and the Perl module IPC::Run.
+ See Section 33.4 for more information.
+
+ Enable test suites which require special software to run. This option
+ accepts arguments via a whitespace-separated list. See Section 33.1.3 for details.
+
-Db_coverage={ true | false } #
+ If using GCC, all programs and libraries are compiled with
+ code coverage testing instrumentation. When run, they
+ generate files in the build directory with code coverage
+ metrics.
+ See Section 33.5
+ for more information. This option is for use only with GCC
+ and when doing development work.
+
-Ddtrace={ auto | enabled | disabled } #
+
+ Enabling this compiles PostgreSQL with support for the
+ dynamic tracing tool DTrace.
+ See Section 28.5
+ for more information.
+
+ To point to the dtrace program, the
+ DTRACE option can be set. This
+ will often be necessary because dtrace is
+ typically installed under /usr/sbin,
+ which might not be in your PATH.
+
-Dsegsize_blocks=SEGSIZE_BLOCKS #
+ Specify the relation segment size in blocks. If both
+ -Dsegsize and this option are specified, this option
+ wins.
+
+ This option is only for developers, to test segment related code.
+
17.5. Post-Installation Setup #
17.5.1. Shared Libraries #
+ On some systems with shared libraries
+ you need to tell the system how to find the newly installed
+ shared libraries. The systems on which this is
+ not necessary include
+ FreeBSD,
+ Linux,
+ NetBSD, OpenBSD, and
+ Solaris.
+
+ The method to set the shared library search path varies between
+ platforms, but the most widely-used method is to set the
+ environment variable LD_LIBRARY_PATH like so: In Bourne
+ shells (sh, ksh, bash, zsh):
+
+LD_LIBRARY_PATH=/usr/local/pgsql/lib
+export LD_LIBRARY_PATH
+
+ or in csh or tcsh:
+
+setenv LD_LIBRARY_PATH /usr/local/pgsql/lib
+
+ Replace /usr/local/pgsql/lib with whatever you set
+ --libdir/etc/profile or ~/.bash_profile. Some
+ good information about the caveats associated with this method can
+ be found at http://xahlee.info/UnixResource_dir/_/ldpath.html.
+
+ On some systems it might be preferable to set the environment
+ variable LD_RUN_PATH before
+ building.
+
+ On Cygwin, put the library
+ directory in the PATH or move the
+ .dll files into the bin
+ directory.
+
+ If in doubt, refer to the manual pages of your system (perhaps
+ ld.so or rld). If you later
+ get a message like:
+
+psql: error in loading shared libraries
+libpq.so.2.1: cannot open shared object file: No such file or directory
+
+ then this step was necessary. Simply take care of it then.
+
+
+ If you are on Linux and you have root
+ access, you can run:
+
+/sbin/ldconfig /usr/local/pgsql/lib
+
+ (or equivalent directory) after installation to enable the
+ run-time linker to find the shared libraries faster. Refer to the
+ manual page of ldconfig for more information. On
+ FreeBSD, NetBSD, and OpenBSD the command is:
+
+/sbin/ldconfig -m /usr/local/pgsql/lib
+
+ instead. Other systems are not known to have an equivalent
+ command.
+
17.5.2. Environment Variables #
+ If you installed into /usr/local/pgsql or some other
+ location that is not searched for programs by default, you should
+ add /usr/local/pgsql/bin (or whatever you set
+ --bindirPATH. Strictly speaking, this is not
+ necessary, but it will make the use of PostgreSQL
+ much more convenient.
+
+ To do this, add the following to your shell start-up file, such as
+ ~/.bash_profile (or /etc/profile, if you
+ want it to affect all users):
+
+PATH=/usr/local/pgsql/bin:$PATH
+export PATH
+
+ If you are using csh or tcsh, then use this command:
+
+set path = ( /usr/local/pgsql/bin $path )
+
+
+
+ To enable your system to find the man
+ documentation, you need to add lines like the following to a
+ shell start-up file unless you installed into a location that is
+ searched by default:
+
+MANPATH=/usr/local/pgsql/share/man:$MANPATH
+export MANPATH
+
+
+ The environment variables PGHOST and PGPORT
+ specify to client applications the host and port of the database
+ server, overriding the compiled-in defaults. If you are going to
+ run client applications remotely then it is convenient if every
+ user that plans to use the database sets PGHOST. This
+ is not required, however; the settings can be communicated via command
+ line options to most client programs.
+
+ In general, a modern Unix-compatible platform should be able to run
+ PostgreSQL.
+ The platforms that had received specific testing at the
+ time of release are described in Section 17.6
+ below.
+
+ The following software packages are required for building
+ PostgreSQL:
+
+
+
+
+ GNU make version 3.81 or newer is required; other
+ make programs or older GNU make versions will not work.
+ (GNU make is sometimes installed under
+ the name gmake.) To test for GNU
+ make enter:
+
+make --version
+
+
+
+
+ Alternatively, PostgreSQL can be built using
+ Meson. This is currently
+ experimental and only works when building from a Git checkout (not from
+ a distribution tarball). If you choose to use
+ Meson, then you don't need
+ GNU make, but the other
+ requirements below still apply.
+
+ The minimum required version of Meson is 0.54.
+
+ You need an ISO/ANSI C compiler (at least
+ C99-compliant). Recent
+ versions of GCC are recommended, but
+ PostgreSQL is known to build using a wide variety
+ of compilers from different vendors.
+
+ tar is required to unpack the source
+ distribution, in addition to either
+ gzip or bzip2.
+
+
+
+
+ The GNU Readline library is used by
+ default. It allows psql (the
+ PostgreSQL command line SQL interpreter) to remember each
+ command you type, and allows you to use arrow keys to recall and
+ edit previous commands. This is very helpful and is strongly
+ recommended. If you don't want to use it then you must specify
+ the --without-readline option to
+ configure. As an alternative, you can often use the
+ BSD-licensed libedit library, originally
+ developed on NetBSD. The
+ libedit library is
+ GNU Readline-compatible and is used if
+ libreadline is not found, or if
+ --with-libedit-preferred is used as an
+ option to configure. If you are using a package-based
+ Linux distribution, be aware that you need both the
+ readline and readline-devel packages, if
+ those are separate in your distribution.
+
+
+
+ The zlib compression library is
+ used by default. If you don't want to use it then you must
+ specify the --without-zlib option to
+ configure. Using this option disables
+ support for compressed archives in pg_dump and
+ pg_restore.
+
+ The ICU library is used by default. If you don't want to use it then you must specify the --without-icu option to configure. Using this option disables support for ICU collation features (see Section 24.2).
+
+ ICU support requires the ICU4C package to be
+ installed. The minimum required version of
+ ICU4C is currently 4.2.
+
+ By default,
+ pkg-config
+ will be used to find the required compilation options. This is
+ supported for ICU4C version 4.6 and later.
+ For older versions, or if pkg-config is not
+ available, the variables ICU_CFLAGS and
+ ICU_LIBS can be specified to
+ configure, like in this example:
+
+./configure ... ICU_CFLAGS='-I/some/where/include' ICU_LIBS='-L/some/where/lib -licui18n -licuuc -licudata'
+
+ (If ICU4C is in the default search path
+ for the compiler, then you still need to specify nonempty strings in
+ order to avoid use of pkg-config, for
+ example, ICU_CFLAGS=' '.)
+
+
+ The following packages are optional. They are not required in the
+ default configuration, but they are needed when certain build
+ options are enabled, as explained below:
+
+
+ To build the server programming language
+ PL/Perl you need a full
+ Perl installation, including the
+ libperl library and the header files.
+ The minimum required version is Perl 5.14.
+ Since PL/Perl will be a shared
+ library, the
+ libperl library must be a shared library
+ also on most platforms. This appears to be the default in
+ recent Perl versions, but it was not
+ in earlier versions, and in any case it is the choice of whomever
+ installed Perl at your site. configure will fail
+ if building PL/Perl is selected but it cannot
+ find a shared libperl. In that case, you will have
+ to rebuild and install Perl manually to be
+ able to build PL/Perl. During the
+ configuration process for Perl, request a
+ shared library.
+
+ If you intend to make more than incidental use of
+ PL/Perl, you should ensure that the
+ Perl installation was built with the
+ usemultiplicity option enabled (perl -V
+ will show whether this is the case).
+
+ To build the PL/Python server programming
+ language, you need a Python
+ installation with the header files and
+ the sysconfig module. The minimum
+ required version is Python 3.2.
+
+ Since PL/Python will be a shared
+ library, the
+ libpython library must be a shared library
+ also on most platforms. This is not the case in a default
+ Python installation built from source, but a
+ shared library is available in many operating system
+ distributions. configure will fail if
+ building PL/Python is selected but it cannot
+ find a shared libpython. That might mean that you
+ either have to install additional packages or rebuild (part of) your
+ Python installation to provide this shared
+ library. When building from source, run Python's
+ configure with the --enable-shared flag.
+
+ To build the PL/Tcl
+ procedural language, you of course need a Tcl
+ installation. The minimum required version is
+ Tcl 8.4.
+
+ To enable Native Language Support (NLS), that
+ is, the ability to display a program's messages in a language
+ other than English, you need an implementation of the
+ Gettext API. Some operating
+ systems have this built-in (e.g., Linux, NetBSD,
+ Solaris), for other systems you
+ can download an add-on package from https://www.gnu.org/software/gettext/.
+ If you are using the Gettext implementation in
+ the GNU C library, then you will additionally
+ need the GNU Gettext package for some
+ utility programs. For any of the other implementations you will
+ not need it.
+
+ You need OpenSSL, if you want to support
+ encrypted client connections. OpenSSL is
+ also required for random number generation on platforms that do not
+ have /dev/urandom (except Windows). The minimum
+ required version is 1.0.1.
+
+ You need MIT Kerberos (for GSSAPI),
+ OpenLDAP, and/or PAM,
+ if you want to support authentication using those services.
+
+ You need LZ4, if you want to support
+ compression of data with that method; see
+ default_toast_compression and
+ wal_compression.
+
+ You need Zstandard, if you want to support
+ compression of data with that method; see
+ wal_compression.
+ The minimum required version is 1.4.0.
+
+ To build the PostgreSQL documentation,
+ there is a separate set of requirements; see
+ Section J.2.
+
+
+ If you are building from a Git tree instead of
+ using a released source package, or if you want to do server development,
+ you also need the following packages:
+
+
+
+
+
+
+
+ Flex and Bison
+ are needed to build from a Git checkout, or if you changed the actual
+ scanner and parser definition files. If you need them, be sure
+ to get Flex 2.5.35 or later and
+ Bison 2.3 or later. Other lex
+ and yacc programs cannot be used.
+
+
+
+ Perl 5.14 or later is needed to build from a Git checkout,
+ or if you changed the input files for any of the build steps that
+ use Perl scripts. If building on Windows you will need
+ Perl in any case. Perl is
+ also required to run some test suites.
+
+
+ If you need to get a GNU package, you can find
+ it at your local GNU mirror site (see https://www.gnu.org/prep/ftp
+ for a list) or at ftp://ftp.gnu.org/gnu/.
+
18.1. Building with Visual C++ or the
+ Microsoft Windows SDK #
+ PostgreSQL can be built using the Visual C++ compiler suite from Microsoft.
+ These compilers can be either from Visual Studio,
+ Visual Studio Express or some versions of the
+ Microsoft Windows SDK. If you do not already have a
+ Visual Studio environment set up, the easiest
+ ways are to use the compilers from
+ Visual Studio 2022 or those in the
+ Windows SDK 10, which are both free downloads
+ from Microsoft.
+
+ Both 32-bit and 64-bit builds are possible with the Microsoft Compiler suite.
+ 32-bit PostgreSQL builds are possible with
+ Visual Studio 2015 to
+ Visual Studio 2022,
+ as well as standalone Windows SDK releases 10 and above.
+ 64-bit PostgreSQL builds are supported with
+ Microsoft Windows SDK version 10 and above or
+ Visual Studio 2015 and above.
+
+
+ The tools for building using Visual C++ or
+ Platform SDK are in the
+ src\tools\msvc directory. When building, make sure
+ there are no tools from MinGW or
+ Cygwin present in your system PATH. Also, make
+ sure you have all the required Visual C++ tools available in the PATH. In
+ Visual Studio, start the
+ Visual Studio Command Prompt.
+ If you wish to build a 64-bit version, you must use the 64-bit version of
+ the command, and vice versa.
+ Starting with Visual Studio 2017 this can be
+ done from the command line using VsDevCmd.bat, see
+ -help for the available options and their default values.
+ vsvars32.bat is available in
+ Visual Studio 2015 and earlier versions for the
+ same purpose.
+ From the Visual Studio Command Prompt, you can
+ change the targeted CPU architecture, build type, and target OS by using the
+ vcvarsall.bat command, e.g.,
+ vcvarsall.bat x64 10.0.10240.0 to target Windows 10
+ with a 64-bit release build. See -help for the other
+ options of vcvarsall.bat. All commands should be run from
+ the src\tools\msvc directory.
+
+ Before you build, you can create the file config.pl
+ to reflect any configuration options you want to change, or the paths to
+ any third party libraries to use. The complete configuration is determined
+ by first reading and parsing the file config_default.pl,
+ and then apply any changes from config.pl. For example,
+ to specify the location of your Python installation,
+ put the following in config.pl:
+
+$config->{python} = 'c:\python310';
+
+ You only need to specify those parameters that are different from what's in
+ config_default.pl.
+
+ If you need to set any other environment variables, create a file called
+ buildenv.pl and put the required commands there. For
+ example, to add the path for bison when it's not in the PATH, create a file
+ containing:
+
+$ENV{PATH}=$ENV{PATH} . ';c:\some\where\bison\bin';
+
+
+ To pass additional command line arguments to the Visual Studio build
+ command (msbuild or vcbuild):
+
+$ENV{MSBFLAGS}="/m";
+
+
+ The following additional products are required to build
+ PostgreSQL. Use the
+ config.pl file to specify which directories the libraries
+ are available in.
+
+
- Microsoft Windows SDK
+ If your build environment doesn't ship with a supported version of the
+ Microsoft Windows SDK it
+ is recommended that you upgrade to the latest version (currently
+ version 10), available for download from
+ https://www.microsoft.com/download.
+
+ You must always include the
+ Windows Headers and Libraries part of the SDK.
+ If you install a Windows SDK
+ including the Visual C++ Compilers,
+ you don't need Visual Studio to build.
+ Note that as of Version 8.0a the Windows SDK no longer ships with a
+ complete command-line build environment.
+
- ActiveState Perl
+ ActiveState Perl is required to run the build generation scripts. MinGW
+ or Cygwin Perl will not work. It must also be present in the PATH.
+ Binaries can be downloaded from
+ https://www.activestate.com
+ (Note: version 5.14 or later is required,
+ the free Standard Distribution is sufficient).
+
+
+ The following additional products are not required to get started,
+ but are required to build the complete package. Use the
+ config.pl file to specify which directories the libraries
+ are available in.
+
+
- ActiveState TCL
+ Required for building PL/Tcl (Note: version
+ 8.4 is required, the free Standard Distribution is sufficient).
+
- Bison and
+ Flex
+ Bison and Flex are
+ required to build from Git, but not required when building from a release
+ file. Only Bison versions 2.3 and later
+ will work. Flex must be version 2.5.35 or later.
+
+ Both Bison and Flex
+ are included in the msys tool suite, available
+ from http://www.mingw.org/wiki/MSYS as part of the
+ MinGW compiler suite.
+
+ You will need to add the directory containing
+ flex.exe and bison.exe to the
+ PATH environment variable in buildenv.pl unless
+ they are already in PATH. In the case of MinGW, the directory is the
+ \msys\1.0\bin subdirectory of your MinGW
+ installation directory.
+
Note
+ The Bison distribution from GnuWin32 appears to have a bug that
+ causes Bison to malfunction when installed in a directory with
+ spaces in the name, such as the default location on English
+ installations C:\Program Files\GnuWin32.
+ Consider installing into C:\GnuWin32 or use the
+ NTFS short name path to GnuWin32 in your PATH environment setting
+ (e.g., C:\PROGRA~1\GnuWin32).
+
- Diff
+ Diff is required to run the regression tests, and can be downloaded
+ from http://gnuwin32.sourceforge.net.
+
- Gettext
+ Gettext is required to build with NLS support, and can be downloaded
+ from http://gnuwin32.sourceforge.net. Note that binaries,
+ dependencies and developer files are all needed.
+
- MIT Kerberos
+ Required for GSSAPI authentication support. MIT Kerberos can be
+ downloaded from
+ https://web.mit.edu/Kerberos/dist/index.html.
+
- libxml2 and
+ libxslt
+ Required for XML support. Binaries can be downloaded from
+ https://zlatkovic.com/pub/libxml or source from
+ http://xmlsoft.org. Note that libxml2 requires iconv,
+ which is available from the same download location.
+
- LZ4
+ Required for supporting LZ4 compression.
+ Binaries and source can be downloaded from
+ https://github.com/lz4/lz4/releases.
+
- Zstandard
+ Required for supporting Zstandard compression.
+ Binaries and source can be downloaded from
+ https://github.com/facebook/zstd/releases.
+
- OpenSSL
+ Required for SSL support. Binaries can be downloaded from
+ https://slproweb.com/products/Win32OpenSSL.html
+ or source from https://www.openssl.org.
+
- ossp-uuid
+ Required for UUID-OSSP support (contrib only). Source can be
+ downloaded from
+ http://www.ossp.org/pkg/lib/uuid/.
+
- Python
+ Required for building PL/Python. Binaries can
+ be downloaded from https://www.python.org.
+
- zlib
+ Required for compression support in pg_dump
+ and pg_restore. Binaries can be downloaded
+ from https://www.zlib.net.
+
+
18.1.2. Special Considerations for 64-Bit Windows #
+ PostgreSQL will only build for the x64 architecture on 64-bit Windows.
+
+ Mixing 32- and 64-bit versions in the same build tree is not supported.
+ The build system will automatically detect if it's running in a 32- or
+ 64-bit environment, and build PostgreSQL accordingly. For this reason, it
+ is important to start the correct command prompt before building.
+
+ To use a server-side third party library such as Python or
+ OpenSSL, this library must also be
+ 64-bit. There is no support for loading a 32-bit library in a 64-bit
+ server. Several of the third party libraries that PostgreSQL supports may
+ only be available in 32-bit versions, in which case they cannot be used with
+ 64-bit PostgreSQL.
+
+ To build all of PostgreSQL in release configuration (the default), run the
+ command:
+
+build
+
+ To build all of PostgreSQL in debug configuration, run the command:
+
+build DEBUG
+
+ To build just a single project, for example psql, run the commands:
+
+build psql
+build DEBUG psql
+
+ To change the default build configuration to debug, put the following
+ in the buildenv.pl file:
+
+$ENV{CONFIG}="Debug";
+
+
+ It is also possible to build from inside the Visual Studio GUI. In this
+ case, you need to run:
+
+perl mkvcbuild.pl
+
+ from the command prompt, and then open the generated
+ pgsql.sln (in the root directory of the source tree)
+ in Visual Studio.
+
18.1.4. Cleaning and Installing #
+ Most of the time, the automatic dependency tracking in Visual Studio will
+ handle changed files. But if there have been large changes, you may need
+ to clean the installation. To do this, simply run the
+ clean.bat command, which will automatically clean out
+ all generated files. You can also run it with the
+ dist parameter, in which case it will behave like
+ make distclean and remove the flex/bison output files
+ as well.
+
+ By default, all files are written into a subdirectory of the
+ debug or release directories. To
+ install these files using the standard layout, and also generate the files
+ required to initialize and use the database, run the command:
+
+install c:\destination\directory
+
+
+ If you want to install only the client applications and
+ interface libraries, then you can use these commands:
+
+install c:\destination\directory client
+
+
18.1.5. Running the Regression Tests #
+ To run the regression tests, make sure you have completed the build of all
+ required parts first. Also, make sure that the DLLs required to load all
+ parts of the system (such as the Perl and Python DLLs for the procedural
+ languages) are present in the system path. If they are not, set it through
+ the buildenv.pl file. To run the tests, run one of
+ the following commands from the src\tools\msvc
+ directory:
+
+vcregress check
+vcregress installcheck
+vcregress plcheck
+vcregress contribcheck
+vcregress modulescheck
+vcregress ecpgcheck
+vcregress isolationcheck
+vcregress bincheck
+vcregress recoverycheck
+vcregress taptest
+
+
+ To change the schedule used (default is parallel), append it to the
+ command line like:
+
+vcregress check serial
+
+
+ vcregress taptest can be used to run the TAP tests
+ of a target directory, like:
+
+vcregress taptest src\bin\initdb\
+
+
+ For more information about the regression tests, see
+ Chapter 33.
+
+ Running the regression tests on client programs with
+ vcregress bincheck, on recovery tests with
+ vcregress recoverycheck, or TAP tests specified with
+ vcregress taptest requires an additional Perl module
+ to be installed:
+
- IPC::Run
+ As of this writing, IPC::Run is not included in the
+ ActiveState Perl installation, nor in the ActiveState Perl Package
+ Manager (PPM) library. To install, download the
+ IPC-Run-<version>.tar.gz source archive from
+ CPAN,
+ at https://metacpan.org/dist/IPC-Run, and
+ uncompress. Edit the buildenv.pl file, and add a PERL5LIB
+ variable to point to the lib subdirectory from the
+ extracted archive. For example:
+
+$ENV{PERL5LIB}=$ENV{PERL5LIB} . ';c:\IPC-Run-0.94\lib';
+
+
+
+ The TAP tests run with vcregress support the
+ environment variables PROVE_TESTS, that is expanded
+ automatically using the name patterns given, and
+ PROVE_FLAGS. These can be set on a Windows terminal,
+ before running vcregress:
+
+set PROVE_FLAGS=--timer --jobs 2
+set PROVE_TESTS=t/020*.pl t/010*.pl
+
+ It is also possible to set up those parameters in
+ buildenv.pl:
+
+$ENV{PROVE_FLAGS}='--timer --jobs 2'
+$ENV{PROVE_TESTS}='t/020*.pl t/010*.pl'
+
+
+ Additionally, the behavior of TAP tests can be controlled by a set of
+ environment variables, see Section 33.4.1.
+
+ Some of the TAP tests depend on a set of external commands that would
+ optionally trigger tests related to them. Each one of those variables
+ can be set or unset in buildenv.pl:
+
GZIP_PROGRAM
+ Path to a gzip command. The default is
+ gzip, which will search for a command by that
+ name in the configured PATH.
+
LZ4
+ Path to a lz4 command. The default is
+ lz4, which will search for a command by that
+ name in the configured PATH.
+
OPENSSL
+ Path to an openssl command. The default is
+ openssl, which will search for a command by that
+ name in the configured PATH.
+
TAR
+ Path to a tar command. The default is
+ tar, which will search for a command by that
+ name in the configured PATH.
+
ZSTD
+ Path to a zstd command. The default is
+ zstd, which will search for a command by that
+ name in the configured PATH.
+
+
Chapter 18. Installation from Source Code on Windows
+ It is recommended that most users download the binary distribution for
+ Windows, available as a graphical installer package
+ from the PostgreSQL website at
+ https://www.postgresql.org/download/. Building from source
+ is only intended for people developing PostgreSQL
+ or extensions.
+
+ There are several different ways of building PostgreSQL on
+ Windows. The simplest way to build with
+ Microsoft tools is to install Visual Studio 2022
+ and use the included compiler. It is also possible to build with the full
+ Microsoft Visual C++ 2015 to 2022.
+ In some cases that requires the installation of the
+ Windows SDK in addition to the compiler.
+
+ It is also possible to build PostgreSQL using the GNU compiler tools
+ provided by MinGW, or using
+ Cygwin for older versions of
+ Windows.
+
+ Building using MinGW or
+ Cygwin uses the normal build system, see
+ Chapter 17 and the specific notes in
+ Section 17.7.4 and Section 17.7.2.
+ To produce native 64 bit binaries in these environments, use the tools from
+ MinGW-w64. These tools can also be used to
+ cross-compile for 32 bit and 64 bit Windows
+ targets on other hosts, such as Linux and
+ macOS.
+ Cygwin is not recommended for running a
+ production server, and it should only be used for running on
+ older versions of Windows where
+ the native build does not work. The official
+ binaries are built using Visual Studio.
+
+ Native builds of psql don't support command
+ line editing. The Cygwin build does support
+ command line editing, so it should be used where psql is needed for
+ interactive use on Windows.
+
17.7. Platform-Specific Notes #
+ This section documents additional platform-specific issues
+ regarding the installation and setup of PostgreSQL. Be sure to
+ read the installation instructions, and in
+ particular Section 17.1 as well. Also,
+ check Chapter 33 regarding the
+ interpretation of regression test results.
+
+ Platforms that are not covered here have no known platform-specific
+ installation issues.
+
+ You can use GCC or the native IBM compiler xlc
+ to build PostgreSQL
+ on AIX.
+
+ AIX versions before 7.1 are no longer
+ tested nor supported by the PostgreSQL
+ community.
+
17.7.1.1. Memory Management #
+ AIX can be somewhat peculiar with regards to the way it does
+ memory management. You can have a server with many multiples of
+ gigabytes of RAM free, but still get out of memory or address
+ space errors when running applications. One example
+ is loading of extensions failing with unusual errors.
+ For example, running as the owner of the PostgreSQL installation:
+
+=# CREATE EXTENSION plperl;
+ERROR: could not load library "/opt/dbs/pgsql/lib/plperl.so": A memory address is not in the address space for the process.
+
+ Running as a non-owner in the group possessing the PostgreSQL
+ installation:
+
+=# CREATE EXTENSION plperl;
+ERROR: could not load library "/opt/dbs/pgsql/lib/plperl.so": Bad address
+
+ Another example is out of memory errors in the PostgreSQL server
+ logs, with every memory allocation near or greater than 256 MB
+ failing.
+
+ The overall cause of all these problems is the default bittedness
+ and memory model used by the server process. By default, all
+ binaries built on AIX are 32-bit. This does not depend upon
+ hardware type or kernel in use. These 32-bit processes are
+ limited to 4 GB of memory laid out in 256 MB segments using one
+ of a few models. The default allows for less than 256 MB in the
+ heap as it shares a single segment with the stack.
+
+ In the case of the plperl example, above,
+ check your umask and the permissions of the binaries in your
+ PostgreSQL installation. The binaries involved in that example
+ were 32-bit and installed as mode 750 instead of 755. Due to the
+ permissions being set in this fashion, only the owner or a member
+ of the possessing group can load the library. Since it isn't
+ world-readable, the loader places the object into the process'
+ heap instead of the shared library segments where it would
+ otherwise be placed.
+
+ The “ideal” solution for this is to use a 64-bit
+ build of PostgreSQL, but that is not always practical, because
+ systems with 32-bit processors can build, but not run, 64-bit
+ binaries.
+
+ If a 32-bit binary is desired, set LDR_CNTRL to
+ MAXDATA=0xn0000000,
+ where 1 <= n <= 8, before starting the PostgreSQL server,
+ and try different values and postgresql.conf
+ settings to find a configuration that works satisfactorily. This
+ use of LDR_CNTRL tells AIX that you want the
+ server to have MAXDATA bytes set aside for the
+ heap, allocated in 256 MB segments. When you find a workable
+ configuration,
+ ldedit can be used to modify the binaries so
+ that they default to using the desired heap size. PostgreSQL can
+ also be rebuilt, passing configure
+ LDFLAGS="-Wl,-bmaxdata:0xn0000000"
+ to achieve the same effect.
+
+ For a 64-bit build, set OBJECT_MODE to 64 and
+ pass CC="gcc -maix64"
+ and LDFLAGS="-Wl,-bbigtoc"
+ to configure. (Options for
+ xlc might differ.) If you omit the export of
+ OBJECT_MODE, your build may fail with linker errors. When
+ OBJECT_MODE is set, it tells AIX's build utilities
+ such as ar, as, and ld what
+ type of objects to default to handling.
+
+ By default, overcommit of paging space can happen. While we have
+ not seen this occur, AIX will kill processes when it runs out of
+ memory and the overcommit is accessed. The closest to this that
+ we have seen is fork failing because the system decided that
+ there was not enough memory for another process. Like many other
+ parts of AIX, the paging space allocation method and
+ out-of-memory kill is configurable on a system- or process-wide
+ basis if this becomes a problem.
+
+ PostgreSQL can be built using Cygwin, a Linux-like environment for
+ Windows, but that method is inferior to the native Windows build
+ (see Chapter 18) and
+ running a server under Cygwin is no longer recommended.
+
+ When building from source, proceed according to the Unix-style
+ installation procedure (i.e., ./configure;
+ make; etc.), noting the following Cygwin-specific
+ differences:
+
+
+ Set your path to use the Cygwin bin directory before the
+ Windows utilities. This will help prevent problems with
+ compilation.
+
+ The adduser command is not supported; use
+ the appropriate user management application on Windows.
+ Otherwise, skip this step.
+
+ The su command is not supported; use ssh to
+ simulate su on Windows. Otherwise, skip this step.
+
+ OpenSSL is not supported.
+
+ Start cygserver for shared memory support.
+ To do this, enter the command /usr/sbin/cygserver
+ &. This program needs to be running anytime you
+ start the PostgreSQL server or initialize a database cluster
+ (initdb). The
+ default cygserver configuration may need to
+ be changed (e.g., increase SEMMNS) to prevent
+ PostgreSQL from failing due to a lack of system resources.
+
+ Building might fail on some systems where a locale other than
+ C is in use. To fix this, set the locale to C by doing
+ export LANG=C.utf8 before building, and then
+ setting it back to the previous setting after you have installed
+ PostgreSQL.
+
+ The parallel regression tests (make check)
+ can generate spurious regression test failures due to
+ overflowing the listen() backlog queue
+ which causes connection refused errors or hangs. You can limit
+ the number of connections using the make
+ variable MAX_CONNECTIONS thus:
+
+make MAX_CONNECTIONS=5 check
+
+ (On some systems you can have up to about 10 simultaneous
+ connections.)
+
+
+ It is possible to install cygserver and the
+ PostgreSQL server as Windows NT services. For information on how
+ to do this, please refer to the README
+ document included with the PostgreSQL binary package on Cygwin.
+ It is installed in the
+ directory /usr/share/doc/Cygwin.
+
+ To build PostgreSQL from source
+ on macOS, you will need to install Apple's
+ command line developer tools, which can be done by issuing
+
+xcode-select --install
+
+ (note that this will pop up a GUI dialog window for confirmation).
+ You may or may not wish to also install Xcode.
+
+ On recent macOS releases, it's necessary to
+ embed the “sysroot” path in the include switches used to
+ find some system header files. This results in the outputs of
+ the configure script varying depending on
+ which SDK version was used during configure.
+ That shouldn't pose any problem in simple scenarios, but if you are
+ trying to do something like building an extension on a different machine
+ than the server code was built on, you may need to force use of a
+ different sysroot path. To do that, set PG_SYSROOT,
+ for example
+
+make PG_SYSROOT=/desired/path all
+
+ To find out the appropriate path on your machine, run
+
+xcrun --show-sdk-path
+
+ Note that building an extension using a different sysroot version than
+ was used to build the core server is not really recommended; in the
+ worst case it could result in hard-to-debug ABI inconsistencies.
+
+ You can also select a non-default sysroot path when configuring, by
+ specifying PG_SYSROOT
+ to configure:
+
+./configure ... PG_SYSROOT=/desired/path
+
+ This would primarily be useful to cross-compile for some other
+ macOS version. There is no guarantee that the resulting executables
+ will run on the current host.
+
+ To suppress the -isysroot options altogether, use
+
+./configure ... PG_SYSROOT=none
+
+ (any nonexistent pathname will work). This might be useful if you wish
+ to build with a non-Apple compiler, but beware that that case is not
+ tested or supported by the PostgreSQL developers.
+
+ macOS's “System Integrity
+ Protection” (SIP) feature breaks make check,
+ because it prevents passing the needed setting
+ of DYLD_LIBRARY_PATH down to the executables being
+ tested. You can work around that by doing make
+ install before make check.
+ Most PostgreSQL developers just turn off SIP, though.
+
17.7.4. MinGW/Native Windows #
+ PostgreSQL for Windows can be built using MinGW, a Unix-like build
+ environment for Microsoft operating systems, or using
+ Microsoft's Visual C++ compiler suite.
+ The MinGW build procedure uses the normal build system described in
+ this chapter; the Visual C++ build works completely differently
+ and is described in Chapter 18.
+
+ The native Windows port requires a 32 or 64-bit version of Windows
+ 2000 or later. Earlier operating systems do
+ not have sufficient infrastructure (but Cygwin may be used on
+ those). MinGW, the Unix-like build tools, and MSYS, a collection
+ of Unix tools required to run shell scripts
+ like configure, can be downloaded
+ from http://www.mingw.org/. Neither is
+ required to run the resulting binaries; they are needed only for
+ creating the binaries.
+
+ To build 64 bit binaries using MinGW, install the 64 bit tool set
+ from https://mingw-w64.org/, put its bin
+ directory in the PATH, and run
+ configure with the
+ --host=x86_64-w64-mingw32 option.
+
+ After you have everything installed, it is suggested that you
+ run psql
+ under CMD.EXE, as the MSYS console has
+ buffering issues.
+
17.7.4.1. Collecting Crash Dumps on Windows #
+ If PostgreSQL on Windows crashes, it has the ability to generate
+ minidumps that can be used to track down the cause
+ for the crash, similar to core dumps on Unix. These dumps can be
+ read using the Windows Debugger Tools or using
+ Visual Studio. To enable the generation of dumps
+ on Windows, create a subdirectory named crashdumps
+ inside the cluster data directory. The dumps will then be written
+ into this directory with a unique name based on the identifier of
+ the crashing process and the current time of the crash.
+
+ PostgreSQL is well-supported on Solaris. The more up to date your
+ operating system, the fewer issues you will experience.
+
17.7.5.3. Compiling for Optimal Performance #
+ On the SPARC architecture, Sun Studio is strongly recommended for
+ compilation. Try using the -xO5 optimization
+ flag to generate significantly faster binaries. Do not use any
+ flags that modify behavior of floating-point operations
+ and errno processing (e.g.,
+ -fast).
+
+ If you do not have a reason to use 64-bit binaries on SPARC,
+ prefer the 32-bit version. The 64-bit operations are slower and
+ 64-bit binaries are slower than the 32-bit variants. On the
+ other hand, 32-bit code on the AMD64 CPU family is not native,
+ so 32-bit code is significantly slower on that CPU family.
+
17.7.5.4. Using DTrace for Tracing PostgreSQL #
+ Yes, using DTrace is possible. See Section 28.5 for
+ further information.
+
+ If you see the linking of the postgres executable abort with an
+ error message like:
+
+Undefined first referenced
+ symbol in file
+AbortTransaction utils/probes.o
+CommitTransaction utils/probes.o
+ld: fatal: Symbol referencing errors. No output written to postgres
+collect2: ld returned 1 exit status
+make: *** [postgres] Error 1
+
+ your DTrace installation is too old to handle probes in static
+ functions. You need Solaris 10u4 or newer to use DTrace.
+
Chapter 17. Installation from Source Code
+ This chapter describes the installation of
+ PostgreSQL using the source code
+ distribution. If you are installing a pre-packaged distribution,
+ such as an RPM or Debian package, ignore this chapter
+ and see Chapter 16 instead.
+
+ If you are building PostgreSQL for Microsoft
+ Windows, read this chapter if you intend to build with MinGW or Cygwin;
+ but if you intend to build with Microsoft's Visual
+ C++, see Chapter 18 instead.
+
F.19. intagg — integer aggregator and enumerator #
+ The intagg module provides an integer aggregator and an
+ enumerator. intagg is now obsolete, because there
+ are built-in functions that provide a superset of its capabilities.
+ However, the module is still provided as a compatibility wrapper around
+ the built-in functions.
+
+ The aggregator is an aggregate function
+ int_array_aggregate(integer)
+ that produces an integer array
+ containing exactly the integers it is fed.
+ This is a wrapper around array_agg,
+ which does the same thing for any array type.
+
+ The enumerator is a function
+ int_array_enum(integer[])
+ that returns setof integer. It is essentially the reverse
+ operation of the aggregator: given an array of integers, expand it
+ into a set of rows. This is a wrapper around unnest,
+ which does the same thing for any array type.
+
+ Many database systems have the notion of a one to many table. Such a table
+ usually sits between two indexed tables, for example:
+
+
+CREATE TABLE left (id INT PRIMARY KEY, ...);
+CREATE TABLE right (id INT PRIMARY KEY, ...);
+CREATE TABLE one_to_many(left INT REFERENCES left, right INT REFERENCES right);
+
+
+ It is typically used like this:
+
+
+SELECT right.* from right JOIN one_to_many ON (right.id = one_to_many.right)
+ WHERE one_to_many.left = item;
+
+
+ This will return all the items in the right hand table for an entry
+ in the left hand table. This is a very common construct in SQL.
+
+ Now, this methodology can be cumbersome with a very large number of
+ entries in the one_to_many table. Often,
+ a join like this would result in an index scan
+ and a fetch for each right hand entry in the table for a particular
+ left hand entry. If you have a very dynamic system, there is not much you
+ can do. However, if you have some data which is fairly static, you can
+ create a summary table with the aggregator.
+
+
+CREATE TABLE summary AS
+ SELECT left, int_array_aggregate(right) AS right
+ FROM one_to_many
+ GROUP BY left;
+
+
+ This will create a table with one row per left item, and an array
+ of right items. Now this is pretty useless without some way of using
+ the array; that's why there is an array enumerator. You can do
+
+
+SELECT left, int_array_enum(right) FROM summary WHERE left = item;
+
+
+ The above query using int_array_enum produces the same results
+ as
+
+
+SELECT left, right FROM one_to_many WHERE left = item;
+
+
+ The difference is that the query against the summary table has to get
+ only one row from the table, whereas the direct query against
+ one_to_many must index scan and fetch a row for each entry.
+
+ On one system, an EXPLAIN showed a query with a cost of 8488 was
+ reduced to a cost of 329. The original query was a join involving the
+ one_to_many table, which was replaced by:
+
+
+SELECT right, count(right) FROM
+ ( SELECT left, int_array_enum(right) AS right
+ FROM summary JOIN (SELECT left FROM left_table WHERE left = item) AS lefts
+ ON (summary.left = lefts.left)
+ ) AS list
+ GROUP BY right
+ ORDER BY count DESC;
+
+
F.20. intarray — manipulate arrays of integers #
+ The intarray module provides a number of useful functions
+ and operators for manipulating null-free arrays of integers.
+ There is also support for indexed searches using some of the operators.
+
+ All of these operations will throw an error if a supplied array contains any
+ NULL elements.
+
+ Many of these operations are only sensible for one-dimensional arrays.
+ Although they will accept input arrays of more dimensions, the data is
+ treated as though it were a linear array in storage order.
+
+ This module is considered “trusted”, that is, it can be
+ installed by non-superusers who have CREATE privilege
+ on the current database.
+
F.20.1. intarray Functions and Operators #
+ The functions provided by the intarray module
+ are shown in Table F.9, the operators
+ in Table F.10.
+
Table F.9. intarray Functions
+ Function
+
+
+ Description
+
+
+ Example(s)
+ |
|---|
+
+ icount ( integer[] )
+ → integer
+
+
+ Returns the number of elements in the array.
+
+
+ icount('{1,2,3}'::integer[])
+ → 3
+ |
+
+ sort ( integer[], dir text )
+ → integer[]
+
+
+ Sorts the array in either ascending or descending order.
+ dir must be asc
+ or desc.
+
+
+ sort('{1,3,2}'::integer[], 'desc')
+ → {3,2,1}
+ |
+ sort ( integer[] )
+ → integer[]
+
+
+
+ sort_asc ( integer[] )
+ → integer[]
+
+
+ Sorts in ascending order.
+
+
+ sort(array[11,77,44])
+ → {11,44,77}
+ |
+
+ sort_desc ( integer[] )
+ → integer[]
+
+
+ Sorts in descending order.
+
+
+ sort_desc(array[11,77,44])
+ → {77,44,11}
+ |
+
+ uniq ( integer[] )
+ → integer[]
+
+
+ Removes adjacent duplicates.
+ Often used with sort to remove all duplicates.
+
+
+ uniq('{1,2,2,3,1,1}'::integer[])
+ → {1,2,3,1}
+
+
+ uniq(sort('{1,2,3,2,1}'::integer[]))
+ → {1,2,3}
+ |
+
+ idx ( integer[], item integer )
+ → integer
+
+
+ Returns index of the first array element
+ matching item, or 0 if no match.
+
+
+ idx(array[11,22,33,22,11], 22)
+ → 2
+ |
+
+ subarray ( integer[], start integer, len integer )
+ → integer[]
+
+
+ Extracts the portion of the array starting at
+ position start, with len
+ elements.
+
+
+ subarray('{1,2,3,2,1}'::integer[], 2, 3)
+ → {2,3,2}
+ |
+ subarray ( integer[], start integer )
+ → integer[]
+
+
+ Extracts the portion of the array starting at
+ position start.
+
+
+ subarray('{1,2,3,2,1}'::integer[], 2)
+ → {2,3,2,1}
+ |
+
+ intset ( integer )
+ → integer[]
+
+
+ Makes a single-element array.
+
+
+ intset(42)
+ → {42}
+ |
Table F.10. intarray Operators
+ Operator
+
+
+ Description
+ |
|---|
+ integer[] && integer[]
+ → boolean
+
+
+ Do arrays overlap (have at least one element in common)?
+ |
+ integer[] @> integer[]
+ → boolean
+
+
+ Does left array contain right array?
+ |
+ integer[] <@ integer[]
+ → boolean
+
+
+ Is left array contained in right array?
+ |
+ # integer[]
+ → integer
+
+
+ Returns the number of elements in the array.
+ |
+ integer[] # integer
+ → integer
+
+
+ Returns index of the first array element
+ matching the right argument, or 0 if no match.
+ (Same as idx function.)
+ |
+ integer[] + integer
+ → integer[]
+
+
+ Adds element to end of array.
+ |
+ integer[] + integer[]
+ → integer[]
+
+
+ Concatenates the arrays.
+ |
+ integer[] - integer
+ → integer[]
+
+
+ Removes entries matching the right argument from the array.
+ |
+ integer[] - integer[]
+ → integer[]
+
+
+ Removes elements of the right array from the left array.
+ |
+ integer[] | integer
+ → integer[]
+
+
+ Computes the union of the arguments.
+ |
+ integer[] | integer[]
+ → integer[]
+
+
+ Computes the union of the arguments.
+ |
+ integer[] & integer[]
+ → integer[]
+
+
+ Computes the intersection of the arguments.
+ |
+ integer[] @@ query_int
+ → boolean
+
+
+ Does array satisfy query? (see below)
+ |
+ query_int ~~ integer[]
+ → boolean
+
+
+ Does array satisfy query? (commutator of @@)
+ |
+ The operators &&, @> and
+ <@ are equivalent to PostgreSQL's built-in
+ operators of the same names, except that they work only on integer arrays
+ that do not contain nulls, while the built-in operators work for any array
+ type. This restriction makes them faster than the built-in operators
+ in many cases.
+
+ The @@ and ~~ operators test whether an array
+ satisfies a query, which is expressed as a value of a
+ specialized data type query_int. A query
+ consists of integer values that are checked against the elements of
+ the array, possibly combined using the operators &
+ (AND), | (OR), and ! (NOT). Parentheses
+ can be used as needed. For example,
+ the query 1&(2|3) matches arrays that contain 1
+ and also contain either 2 or 3.
+
+ intarray provides index support for the
+ &&, @>,
+ and @@ operators, as well as regular array equality.
+
+ Two parameterized GiST index operator classes are provided:
+ gist__int_ops (used by default) is suitable for
+ small- to medium-size data sets, while
+ gist__intbig_ops uses a larger signature and is more
+ suitable for indexing large data sets (i.e., columns containing
+ a large number of distinct array values).
+ The implementation uses an RD-tree data structure with
+ built-in lossy compression.
+
+ gist__int_ops approximates an integer set as an array of
+ integer ranges. Its optional integer parameter numranges
+ determines the maximum number of ranges in
+ one index key. The default value of numranges is 100.
+ Valid values are between 1 and 253. Using larger arrays as GiST index
+ keys leads to a more precise search (scanning a smaller fraction of the index and
+ fewer heap pages), at the cost of a larger index.
+
+ gist__intbig_ops approximates an integer set as a bitmap
+ signature. Its optional integer parameter siglen
+ determines the signature length in bytes.
+ The default signature length is 16 bytes. Valid values of signature length
+ are between 1 and 2024 bytes. Longer signatures lead to a more precise
+ search (scanning a smaller fraction of the index and fewer heap pages), at
+ the cost of a larger index.
+
+ There is also a non-default GIN operator class
+ gin__int_ops, which supports these operators as well
+ as <@.
+
+ The choice between GiST and GIN indexing depends on the relative
+ performance characteristics of GiST and GIN, which are discussed elsewhere.
+
+-- a message can be in one or more “sections”
+CREATE TABLE message (mid INT PRIMARY KEY, sections INT[], ...);
+
+-- create specialized index with signature length of 32 bytes
+CREATE INDEX message_rdtree_idx ON message USING GIST (sections gist__intbig_ops (siglen = 32));
+
+-- select messages in section 1 OR 2 - OVERLAP operator
+SELECT message.mid FROM message WHERE message.sections && '{1,2}';
+
+-- select messages in sections 1 AND 2 - CONTAINS operator
+SELECT message.mid FROM message WHERE message.sections @> '{1,2}';
+
+-- the same, using QUERY operator
+SELECT message.mid FROM message WHERE message.sections @@ '1&2'::query_int;
+
+ The source directory contrib/intarray/bench contains a
+ benchmark test suite, which can be run against an installed
+ PostgreSQL server. (It also requires DBD::Pg
+ to be installed.) To run:
+
+cd .../contrib/intarray/bench
+createdb TEST
+psql -c "CREATE EXTENSION intarray" TEST
+./create_test.pl | psql TEST
+./bench.pl
+
+ The bench.pl script has numerous options, which
+ are displayed when it is run without any arguments.
+
+ This part contains assorted information that might be of use to
+ PostgreSQL developers.
+
+ PostgreSQL is an object-relational
+ database management system (ORDBMS) based on
+
+ POSTGRES, Version 4.2,
+ developed at the University of California at Berkeley Computer Science
+ Department. POSTGRES pioneered many concepts that only became
+ available in some commercial database systems much later.
+
+ PostgreSQL is an open-source descendant
+ of this original Berkeley code. It supports a large part of the SQL
+ standard and offers many modern features:
+
+
- complex queries
- foreign keys
- triggers
- updatable views
- transactional integrity
- multiversion concurrency control
+
+ Also, PostgreSQL can be extended by the
+ user in many ways, for example by adding new
+
+
- data types
- functions
- operators
- aggregate functions
- index methods
- procedural languages
+
+ And because of the liberal license,
+ PostgreSQL can be used, modified, and
+ distributed by anyone free of charge for any purpose, be it
+ private, commercial, or academic.
+
F.21. isn — data types for international standard numbers (ISBN, EAN, UPC, etc.) #
+ The isn module provides data types for the following
+ international product numbering standards: EAN13, UPC, ISBN (books), ISMN
+ (music), and ISSN (serials). Numbers are validated on input according to a
+ hard-coded list of prefixes; this list of prefixes is also used to hyphenate
+ numbers on output. Since new prefixes are assigned from time to time, the
+ list of prefixes may be out of date. It is hoped that a future version of
+ this module will obtain the prefix list from one or more tables that
+ can be easily updated by users as needed; however, at present, the
+ list can only be updated by modifying the source code and recompiling.
+ Alternatively, prefix validation and hyphenation support may be
+ dropped from a future version of this module.
+
+ This module is considered “trusted”, that is, it can be
+ installed by non-superusers who have CREATE privilege
+ on the current database.
+
+ Table F.11 shows the data types provided by
+ the isn module.
+
Table F.11. isn Data Types
| Data Type | Description |
|---|
EAN13 |
+ European Article Numbers, always displayed in the EAN13 display format
+ |
ISBN13 |
+ International Standard Book Numbers to be displayed in
+ the new EAN13 display format
+ |
ISMN13 |
+ International Standard Music Numbers to be displayed in
+ the new EAN13 display format
+ |
ISSN13 |
+ International Standard Serial Numbers to be displayed in the new
+ EAN13 display format
+ |
ISBN |
+ International Standard Book Numbers to be displayed in the old
+ short display format
+ |
ISMN |
+ International Standard Music Numbers to be displayed in the
+ old short display format
+ |
ISSN |
+ International Standard Serial Numbers to be displayed in the
+ old short display format
+ |
UPC |
+ Universal Product Codes
+ |
+ Some notes:
+
ISBN13, ISMN13, ISSN13 numbers are all EAN13 numbers.
EAN13 numbers aren't always ISBN13, ISMN13 or ISSN13 (some
+ are).
Some ISBN13 numbers can be displayed as ISBN.
Some ISMN13 numbers can be displayed as ISMN.
Some ISSN13 numbers can be displayed as ISSN.
UPC numbers are a subset of the EAN13 numbers (they are basically
+ EAN13 without the first 0 digit).
All UPC, ISBN, ISMN and ISSN numbers can be represented as EAN13
+ numbers.
+ Internally, all these types use the same representation (a 64-bit
+ integer), and all are interchangeable. Multiple types are provided
+ to control display formatting and to permit tighter validity checking
+ of input that is supposed to denote one particular type of number.
+
+ The ISBN, ISMN, and ISSN types will display the
+ short version of the number (ISxN 10) whenever it's possible, and will show
+ ISxN 13 format for numbers that do not fit in the short version.
+ The EAN13, ISBN13, ISMN13 and
+ ISSN13 types will always display the long version of the ISxN
+ (EAN13).
+
+ The isn module provides the following pairs of type casts:
+
+ ISBN13 <=> EAN13
+
+ ISMN13 <=> EAN13
+
+ ISSN13 <=> EAN13
+
+ ISBN <=> EAN13
+
+ ISMN <=> EAN13
+
+ ISSN <=> EAN13
+
+ UPC <=> EAN13
+
+ ISBN <=> ISBN13
+
+ ISMN <=> ISMN13
+
+ ISSN <=> ISSN13
+
+ When casting from EAN13 to another type, there is a run-time
+ check that the value is within the domain of the other type, and an error
+ is thrown if not. The other casts are simply relabelings that will
+ always succeed.
+
F.21.3. Functions and Operators #
+ The isn module provides the standard comparison operators,
+ plus B-tree and hash indexing support for all these data types. In
+ addition there are several specialized functions; shown in Table F.12.
+ In this table,
+ isn means any one of the module's data types.
+
Table F.12. isn Functions
+ Function
+
+
+ Description
+ |
|---|
+
+ isn_weak ( boolean )
+ → boolean
+
+
+ Sets the weak input mode, and returns new setting.
+ |
+ isn_weak ()
+ → boolean
+
+
+ Returns the current status of the weak mode.
+ |
+
+ make_valid ( isn )
+ → isn
+
+
+ Validates an invalid number (clears the invalid flag).
+ |
+
+ is_valid ( isn )
+ → boolean
+
+
+ Checks for the presence of the invalid flag.
+ |
+ Weak mode is used to be able to insert invalid data
+ into a table. Invalid means the check digit is wrong, not that there are
+ missing numbers.
+
+ Why would you want to use the weak mode? Well, it could be that
+ you have a huge collection of ISBN numbers, and that there are so many of
+ them that for weird reasons some have the wrong check digit (perhaps the
+ numbers were scanned from a printed list and the OCR got the numbers wrong,
+ perhaps the numbers were manually captured... who knows). Anyway, the point
+ is you might want to clean the mess up, but you still want to be able to
+ have all the numbers in your database and maybe use an external tool to
+ locate the invalid numbers in the database so you can verify the
+ information and validate it more easily; so for example you'd want to
+ select all the invalid numbers in the table.
+
+ When you insert invalid numbers in a table using the weak mode, the number
+ will be inserted with the corrected check digit, but it will be displayed
+ with an exclamation mark (!) at the end, for example
+ 0-11-000322-5!. This invalid marker can be checked with
+ the is_valid function and cleared with the
+ make_valid function.
+
+ You can also force the insertion of invalid numbers even when not in the
+ weak mode, by appending the ! character at the end of the
+ number.
+
+ Another special feature is that during input, you can write
+ ? in place of the check digit, and the correct check digit
+ will be inserted automatically.
+
+--Using the types directly:
+SELECT isbn('978-0-393-04002-9');
+SELECT isbn13('0901690546');
+SELECT issn('1436-4522');
+
+--Casting types:
+-- note that you can only cast from ean13 to another type when the
+-- number would be valid in the realm of the target type;
+-- thus, the following will NOT work: select isbn(ean13('0220356483481'));
+-- but these will:
+SELECT upc(ean13('0220356483481'));
+SELECT ean13(upc('220356483481'));
+
+--Create a table with a single column to hold ISBN numbers:
+CREATE TABLE test (id isbn);
+INSERT INTO test VALUES('9780393040029');
+
+--Automatically calculate check digits (observe the '?'):
+INSERT INTO test VALUES('220500896?');
+INSERT INTO test VALUES('978055215372?');
+
+SELECT issn('3251231?');
+SELECT ismn('979047213542?');
+
+--Using the weak mode:
+SELECT isn_weak(true);
+INSERT INTO test VALUES('978-0-11-000533-4');
+INSERT INTO test VALUES('9780141219307');
+INSERT INTO test VALUES('2-205-00876-X');
+SELECT isn_weak(false);
+
+SELECT id FROM test WHERE NOT is_valid(id);
+UPDATE test SET id = make_valid(id) WHERE id = '2-205-00876-X!';
+
+SELECT * FROM test;
+
+SELECT isbn13(id) FROM test;
+
+ The information to implement this module was collected from
+ several sites, including:
+
+
+ The prefixes used for hyphenation were also compiled from:
+
+
+ Care was taken during the creation of the algorithms and they
+ were meticulously verified against the suggested algorithms
+ in the official ISBN, ISMN, ISSN User Manuals.
+
+ Germán Méndez Bravo (Kronuz), 2004–2006
+
+ This module was inspired by Garrett A. Wollman's
+ isbn_issn code.
+
+ The configuration variable
+ jit determines whether JIT
+ compilation is enabled or disabled.
+ If it is enabled, the configuration variables
+ jit_above_cost, jit_inline_above_cost, and jit_optimize_above_cost determine
+ whether JIT compilation is performed for a query,
+ and how much effort is spent doing so.
+
+ jit_provider determines which JIT
+ implementation is used. It is rarely required to be changed. See Section 32.4.2.
+
+ For development and debugging purposes a few additional configuration
+ parameters exist, as described in
+ Section 20.17.
+
+ JIT compilation is beneficial primarily for long-running
+ CPU-bound queries. Frequently these will be analytical queries. For short
+ queries the added overhead of performing JIT compilation
+ will often be higher than the time it can save.
+
+ To determine whether JIT compilation should be used,
+ the total estimated cost of a query (see
+ Chapter 76 and
+ Section 20.7.2) is used.
+ The estimated cost of the query will be compared with the setting of jit_above_cost. If the cost is higher,
+ JIT compilation will be performed.
+ Two further decisions are then needed.
+ Firstly, if the estimated cost is more
+ than the setting of jit_inline_above_cost, short
+ functions and operators used in the query will be inlined.
+ Secondly, if the estimated cost is more than the setting of jit_optimize_above_cost, expensive optimizations are
+ applied to improve the generated code.
+ Each of these options increases the JIT compilation
+ overhead, but can reduce query execution time considerably.
+
+ These cost-based decisions will be made at plan time, not execution
+ time. This means that when prepared statements are in use, and a generic
+ plan is used (see PREPARE), the values of the
+ configuration parameters in effect at prepare time control the decisions,
+ not the settings at execution time.
+
Note
+ If jit is set to off, or if no
+ JIT implementation is available (for example because
+ the server was compiled without --with-llvm),
+ JIT will not be performed, even if it would be
+ beneficial based on the above criteria. Setting jit
+ to off has effects at both plan and execution time.
+
+ EXPLAIN can be used to see whether
+ JIT is used or not. As an example, here is a query that
+ is not using JIT:
+
+=# EXPLAIN ANALYZE SELECT SUM(relpages) FROM pg_class;
+ QUERY PLAN
+-------------------------------------------------------------------------------------------------------------
+ Aggregate (cost=16.27..16.29 rows=1 width=8) (actual time=0.303..0.303 rows=1 loops=1)
+ -> Seq Scan on pg_class (cost=0.00..15.42 rows=342 width=4) (actual time=0.017..0.111 rows=356 loops=1)
+ Planning Time: 0.116 ms
+ Execution Time: 0.365 ms
+(4 rows)
+
+ Given the cost of the plan, it is entirely reasonable that no
+ JIT was used; the cost of JIT would
+ have been bigger than the potential savings. Adjusting the cost limits
+ will lead to JIT use:
+
+=# SET jit_above_cost = 10;
+SET
+=# EXPLAIN ANALYZE SELECT SUM(relpages) FROM pg_class;
+ QUERY PLAN
+-------------------------------------------------------------------------------------------------------------
+ Aggregate (cost=16.27..16.29 rows=1 width=8) (actual time=6.049..6.049 rows=1 loops=1)
+ -> Seq Scan on pg_class (cost=0.00..15.42 rows=342 width=4) (actual time=0.019..0.052 rows=356 loops=1)
+ Planning Time: 0.133 ms
+ JIT:
+ Functions: 3
+ Options: Inlining false, Optimization false, Expressions true, Deforming true
+ Timing: Generation 1.259 ms, Inlining 0.000 ms, Optimization 0.797 ms, Emission 5.048 ms, Total 7.104 ms
+ Execution Time: 7.416 ms
+
+ As visible here, JIT was used, but inlining and
+ expensive optimization were not. If jit_inline_above_cost or jit_optimize_above_cost were also lowered,
+ that would change.
+
32.4.1. Inlining Support for Extensions #
+ PostgreSQL's JIT
+ implementation can inline the bodies of functions
+ of types C and internal, as well as
+ operators based on such functions. To do so for functions in extensions,
+ the definitions of those functions need to be made available.
+ When using PGXS to build an extension
+ against a server that has been compiled with LLVM JIT support, the
+ relevant files will be built and installed automatically.
+
+ The relevant files have to be installed into
+ $pkglibdir/bitcode/$extension/ and a summary of them
+ into $pkglibdir/bitcode/$extension.index.bc, where
+ $pkglibdir is the directory returned by
+ pg_config --pkglibdir and $extension
+ is the base name of the extension's shared library.
+
+
Note
+ For functions built into PostgreSQL itself,
+ the bitcode is installed into
+ $pkglibdir/bitcode/postgres.
+
+
32.4.2. Pluggable JIT Providers #
+ PostgreSQL provides a JIT
+ implementation based on LLVM. The interface to
+ the JIT provider is pluggable and the provider can be
+ changed without recompiling (although currently, the build process only
+ provides inlining support data for LLVM).
+ The active provider is chosen via the setting
+ jit_provider.
+
32.4.2.1. JIT Provider Interface #
+ A JIT provider is loaded by dynamically loading the
+ named shared library. The normal library search path is used to locate
+ the library. To provide the required JIT provider
+ callbacks and to indicate that the library is actually a
+ JIT provider, it needs to provide a C function named
+ _PG_jit_provider_init. This function is passed a
+ struct that needs to be filled with the callback function pointers for
+ individual actions:
+
+struct JitProviderCallbacks
+{
+ JitProviderResetAfterErrorCB reset_after_error;
+ JitProviderReleaseContextCB release_context;
+ JitProviderCompileExprCB compile_expr;
+};
+
+extern void _PG_jit_provider_init(JitProviderCallbacks *cb);
+
+
32.1. What Is JIT compilation? #
+ Just-in-Time (JIT) compilation is the process of turning
+ some form of interpreted program evaluation into a native program, and
+ doing so at run time.
+ For example, instead of using general-purpose code that can evaluate
+ arbitrary SQL expressions to evaluate a particular SQL predicate
+ like WHERE a.col = 3, it is possible to generate a
+ function that is specific to that expression and can be natively executed
+ by the CPU, yielding a speedup.
+
+ PostgreSQL has builtin support to perform
+ JIT compilation using LLVM when
+ PostgreSQL is built with
+ --with-llvm.
+
+ See src/backend/jit/README for further details.
+
32.1.1. JIT Accelerated Operations #
+ Currently PostgreSQL's JIT
+ implementation has support for accelerating expression evaluation and
+ tuple deforming. Several other operations could be accelerated in the
+ future.
+
+ Expression evaluation is used to evaluate WHERE
+ clauses, target lists, aggregates and projections. It can be accelerated
+ by generating code specific to each case.
+
+ Tuple deforming is the process of transforming an on-disk tuple (see Section 73.6.1) into its in-memory representation.
+ It can be accelerated by creating a function specific to the table layout
+ and the number of columns to be extracted.
+
+ PostgreSQL is very extensible and allows new
+ data types, functions, operators and other database objects to be defined;
+ see Chapter 38. In fact the built-in objects are implemented
+ using nearly the same mechanisms. This extensibility implies some
+ overhead, for example due to function calls (see Section 38.3).
+ To reduce that overhead, JIT compilation can inline the
+ bodies of small functions into the expressions using them. That allows a
+ significant percentage of the overhead to be optimized away.
+
+ LLVM has support for optimizing generated
+ code. Some of the optimizations are cheap enough to be performed whenever
+ JIT is used, while others are only beneficial for
+ longer-running queries.
+ See https://llvm.org/docs/Passes.html#transform-passes for
+ more details about optimizations.
+
Chapter 32. Just-in-Time Compilation (JIT)
+ This chapter explains what just-in-time compilation is, and how it can be
+ configured in PostgreSQL.
+
19.4. Managing Kernel Resources #
+ PostgreSQL can sometimes exhaust various operating system
+ resource limits, especially when multiple copies of the server are running
+ on the same system, or in very large installations. This section explains
+ the kernel resources used by PostgreSQL and the steps you
+ can take to resolve problems related to kernel resource consumption.
+
19.4.1. Shared Memory and Semaphores #
+ PostgreSQL requires the operating system to provide
+ inter-process communication (IPC) features, specifically
+ shared memory and semaphores. Unix-derived systems typically provide
+ “System V” IPC,
+ “POSIX” IPC, or both.
+ Windows has its own implementation of
+ these features and is not discussed here.
+
+ By default, PostgreSQL allocates
+ a very small amount of System V shared memory, as well as a much larger
+ amount of anonymous mmap shared memory.
+ Alternatively, a single large System V shared memory region can be used
+ (see shared_memory_type).
+
+ In addition a significant number of semaphores, which can be either
+ System V or POSIX style, are created at server startup. Currently,
+ POSIX semaphores are used on Linux and FreeBSD systems while other
+ platforms use System V semaphores.
+
+ System V IPC features are typically constrained by
+ system-wide allocation limits.
+ When PostgreSQL exceeds one of these limits,
+ the server will refuse to start and
+ should leave an instructive error message describing the problem
+ and what to do about it. (See also Section 19.3.1.) The relevant kernel
+ parameters are named consistently across different systems; Table 19.1 gives an overview. The methods to set
+ them, however, vary. Suggestions for some platforms are given below.
+
Table 19.1. System V IPC Parameters
| Name | Description | Values needed to run one PostgreSQL instance |
|---|
SHMMAX | Maximum size of shared memory segment (bytes) | at least 1kB, but the default is usually much higher |
SHMMIN | Minimum size of shared memory segment (bytes) | 1 |
SHMALL | Total amount of shared memory available (bytes or pages) | same as SHMMAX if bytes,
+ or ceil(SHMMAX/PAGE_SIZE) if pages,
+ plus room for other applications |
SHMSEG | Maximum number of shared memory segments per process | only 1 segment is needed, but the default is much higher |
SHMMNI | Maximum number of shared memory segments system-wide | like SHMSEG plus room for other applications |
SEMMNI | Maximum number of semaphore identifiers (i.e., sets) | at least ceil((max_connections + autovacuum_max_workers + max_wal_senders + max_worker_processes + 5) / 16) plus room for other applications |
SEMMNS | Maximum number of semaphores system-wide | ceil((max_connections + autovacuum_max_workers + max_wal_senders + max_worker_processes + 5) / 16) * 17 plus room for other applications |
SEMMSL | Maximum number of semaphores per set | at least 17 |
SEMMAP | Number of entries in semaphore map | see text |
SEMVMX | Maximum value of semaphore | at least 1000 (The default is often 32767; do not change unless necessary) |
+ PostgreSQL requires a few bytes of System V shared memory
+ (typically 48 bytes, on 64-bit platforms) for each copy of the server.
+ On most modern operating systems, this amount can easily be allocated.
+ However, if you are running many copies of the server or you explicitly
+ configure the server to use large amounts of System V shared memory (see
+ shared_memory_type and dynamic_shared_memory_type), it may be necessary to
+ increase SHMALL, which is the total amount of System V shared
+ memory system-wide. Note that SHMALL is measured in pages
+ rather than bytes on many systems.
+
+ Less likely to cause problems is the minimum size for shared
+ memory segments (SHMMIN), which should be at most
+ approximately 32 bytes for PostgreSQL (it is
+ usually just 1). The maximum number of segments system-wide
+ (SHMMNI) or per-process (SHMSEG) are unlikely
+ to cause a problem unless your system has them set to zero.
+
+ When using System V semaphores,
+ PostgreSQL uses one semaphore per allowed connection
+ (max_connections), allowed autovacuum worker process
+ (autovacuum_max_workers) and allowed background
+ process (max_worker_processes), in sets of 16.
+ Each such set will
+ also contain a 17th semaphore which contains a “magic
+ number”, to detect collision with semaphore sets used by
+ other applications. The maximum number of semaphores in the system
+ is set by SEMMNS, which consequently must be at least
+ as high as max_connections plus
+ autovacuum_max_workers plus max_wal_senders,
+ plus max_worker_processes, plus one extra for each 16
+ allowed connections plus workers (see the formula in Table 19.1). The parameter SEMMNI
+ determines the limit on the number of semaphore sets that can
+ exist on the system at one time. Hence this parameter must be at
+ least ceil((max_connections + autovacuum_max_workers + max_wal_senders + max_worker_processes + 5) / 16).
+ Lowering the number
+ of allowed connections is a temporary workaround for failures,
+ which are usually confusingly worded “No space
+ left on device”, from the function semget.
+
+ In some cases it might also be necessary to increase
+ SEMMAP to be at least on the order of
+ SEMMNS. If the system has this parameter
+ (many do not), it defines the size of the semaphore
+ resource map, in which each contiguous block of available semaphores
+ needs an entry. When a semaphore set is freed it is either added to
+ an existing entry that is adjacent to the freed block or it is
+ registered under a new map entry. If the map is full, the freed
+ semaphores get lost (until reboot). Fragmentation of the semaphore
+ space could over time lead to fewer available semaphores than there
+ should be.
+
+ Various other settings related to “semaphore undo”, such as
+ SEMMNU and SEMUME, do not affect
+ PostgreSQL.
+
+ When using POSIX semaphores, the number of semaphores needed is the
+ same as for System V, that is one semaphore per allowed connection
+ (max_connections), allowed autovacuum worker process
+ (autovacuum_max_workers) and allowed background
+ process (max_worker_processes).
+ On the platforms where this option is preferred, there is no specific
+ kernel limit on the number of POSIX semaphores.
+
- AIX
+
+
+ It should not be necessary to do
+ any special configuration for such parameters as
+ SHMMAX, as it appears this is configured to
+ allow all memory to be used as shared memory. That is the
+ sort of configuration commonly used for other databases such
+ as DB/2.
It might, however, be necessary to modify the global
+ ulimit information in
+ /etc/security/limits, as the default hard
+ limits for file sizes (fsize) and numbers of
+ files (nofiles) might be too low.
+
- FreeBSD
+
+
+ The default shared memory settings are usually good enough, unless
+ you have set shared_memory_type to sysv.
+ System V semaphores are not used on this platform.
+
+ The default IPC settings can be changed using
+ the sysctl or
+ loader interfaces. The following
+ parameters can be set using sysctl:
+
+# sysctl kern.ipc.shmall=32768
+# sysctl kern.ipc.shmmax=134217728
+
+ To make these settings persist over reboots, modify
+ /etc/sysctl.conf.
+
+ If you have set shared_memory_type to
+ sysv, you might also want to configure your kernel
+ to lock System V shared memory into RAM and prevent it from being paged
+ out to swap. This can be accomplished using the sysctl
+ setting kern.ipc.shm_use_phys.
+
+ If running in a FreeBSD jail, you should set its
+ sysvshm parameter to new, so that
+ it has its own separate System V shared memory namespace.
+ (Before FreeBSD 11.0, it was necessary to enable shared access to
+ the host's IPC namespace from jails, and take measures to avoid
+ collisions.)
+
- NetBSD
+
+
+ The default shared memory settings are usually good enough, unless
+ you have set shared_memory_type to sysv.
+ You will usually want to increase kern.ipc.semmni
+ and kern.ipc.semmns,
+ as NetBSD's default settings
+ for these are uncomfortably small.
+
+ IPC parameters can be adjusted using sysctl,
+ for example:
+
+# sysctl -w kern.ipc.semmni=100
+
+ To make these settings persist over reboots, modify
+ /etc/sysctl.conf.
+
+ If you have set shared_memory_type to
+ sysv, you might also want to configure your kernel
+ to lock System V shared memory into RAM and prevent it from being paged
+ out to swap. This can be accomplished using the sysctl
+ setting kern.ipc.shm_use_phys.
+
- OpenBSD
+
+
+ The default shared memory settings are usually good enough, unless
+ you have set shared_memory_type to sysv.
+ You will usually want to
+ increase kern.seminfo.semmni
+ and kern.seminfo.semmns,
+ as OpenBSD's default settings
+ for these are uncomfortably small.
+
+ IPC parameters can be adjusted using sysctl,
+ for example:
+
+# sysctl kern.seminfo.semmni=100
+
+ To make these settings persist over reboots, modify
+ /etc/sysctl.conf.
+
- Linux
+
+
+ The default shared memory settings are usually good enough, unless
+ you have set shared_memory_type to sysv,
+ and even then only on older kernel versions that shipped with low defaults.
+ System V semaphores are not used on this platform.
+
+ The shared memory size settings can be changed via the
+ sysctl interface. For example, to allow 16 GB:
+
+$ sysctl -w kernel.shmmax=17179869184
+$ sysctl -w kernel.shmall=4194304
+
+ To make these settings persist over reboots, see
+ /etc/sysctl.conf.
+
- macOS
+
+
+ The default shared memory and semaphore settings are usually good enough, unless
+ you have set shared_memory_type to sysv.
+
+ The recommended method for configuring shared memory in macOS
+ is to create a file named /etc/sysctl.conf,
+ containing variable assignments such as:
+
+kern.sysv.shmmax=4194304
+kern.sysv.shmmin=1
+kern.sysv.shmmni=32
+kern.sysv.shmseg=8
+kern.sysv.shmall=1024
+
+ Note that in some macOS versions,
+ all five shared-memory parameters must be set in
+ /etc/sysctl.conf, else the values will be ignored.
+
+ SHMMAX can only be set to a multiple of 4096.
+
+ SHMALL is measured in 4 kB pages on this platform.
+
+ It is possible to change all but SHMMNI on the fly, using
+ sysctl. But it's still best to set up your preferred
+ values via /etc/sysctl.conf, so that the values will be
+ kept across reboots.
+
- Solaris
illumos
+ The default shared memory and semaphore settings are usually good enough for most
+ PostgreSQL applications. Solaris defaults
+ to a SHMMAX of one-quarter of system RAM.
+ To further adjust this setting, use a project setting associated
+ with the postgres user. For example, run the
+ following as root:
+
+projadd -c "PostgreSQL DB User" -K "project.max-shm-memory=(privileged,8GB,deny)" -U postgres -G postgres user.postgres
+
+
+ This command adds the user.postgres project and
+ sets the shared memory maximum for the postgres
+ user to 8GB, and takes effect the next time that user logs
+ in, or when you restart PostgreSQL (not reload).
+ The above assumes that PostgreSQL is run by
+ the postgres user in the postgres
+ group. No server reboot is required.
+
+ Other recommended kernel setting changes for database servers which will
+ have a large number of connections are:
+
+project.max-shm-ids=(priv,32768,deny)
+project.max-sem-ids=(priv,4096,deny)
+project.max-msg-ids=(priv,4096,deny)
+
+
+ Additionally, if you are running PostgreSQL
+ inside a zone, you may need to raise the zone resource usage
+ limits as well. See "Chapter2: Projects and Tasks" in the
+ System Administrator's Guide for more
+ information on projects and prctl.
+
19.4.2. systemd RemoveIPC #
+ If systemd is in use, some care must be taken
+ that IPC resources (including shared memory) are not prematurely
+ removed by the operating system. This is especially of concern when
+ installing PostgreSQL from source. Users of distribution packages of
+ PostgreSQL are less likely to be affected, as
+ the postgres user is then normally created as a system
+ user.
+
+ The setting RemoveIPC
+ in logind.conf controls whether IPC objects are
+ removed when a user fully logs out. System users are exempt. This
+ setting defaults to on in stock systemd, but
+ some operating system distributions default it to off.
+
+ A typical observed effect when this setting is on is that shared memory
+ objects used for parallel query execution are removed at apparently random
+ times, leading to errors and warnings while attempting to open and remove
+ them, like
+
+WARNING: could not remove shared memory segment "/PostgreSQL.1450751626": No such file or directory
+
+ Different types of IPC objects (shared memory vs. semaphores, System V
+ vs. POSIX) are treated slightly differently
+ by systemd, so one might observe that some IPC
+ resources are not removed in the same way as others. But it is not
+ advisable to rely on these subtle differences.
+
+ A “user logging out” might happen as part of a maintenance
+ job or manually when an administrator logs in as
+ the postgres user or something similar, so it is hard
+ to prevent in general.
+
+ What is a “system user” is determined
+ at systemd compile time from
+ the SYS_UID_MAX setting
+ in /etc/login.defs.
+
+ Packaging and deployment scripts should be careful to create
+ the postgres user as a system user by
+ using useradd -r, adduser --system,
+ or equivalent.
+
+ Alternatively, if the user account was created incorrectly or cannot be
+ changed, it is recommended to set
+
+RemoveIPC=no
+
+ in /etc/systemd/logind.conf or another appropriate
+ configuration file.
+
Caution
+ At least one of these two things has to be ensured, or the PostgreSQL
+ server will be very unreliable.
+
19.4.3. Resource Limits #
+ Unix-like operating systems enforce various kinds of resource limits
+ that might interfere with the operation of your
+ PostgreSQL server. Of particular
+ importance are limits on the number of processes per user, the
+ number of open files per process, and the amount of memory available
+ to each process. Each of these have a “hard” and a
+ “soft” limit. The soft limit is what actually counts
+ but it can be changed by the user up to the hard limit. The hard
+ limit can only be changed by the root user. The system call
+ setrlimit is responsible for setting these
+ parameters. The shell's built-in command ulimit
+ (Bourne shells) or limit (csh) is
+ used to control the resource limits from the command line. On
+ BSD-derived systems the file /etc/login.conf
+ controls the various resource limits set during login. See the
+ operating system documentation for details. The relevant
+ parameters are maxproc,
+ openfiles, and datasize. For
+ example:
+
+default:\
+...
+ :datasize-cur=256M:\
+ :maxproc-cur=256:\
+ :openfiles-cur=256:\
+...
+
+ (-cur is the soft limit. Append
+ -max to set the hard limit.)
+
+ Kernels can also have system-wide limits on some resources.
+
+ On Linux the kernel parameter
+ fs.file-max determines the maximum number of open
+ files that the kernel will support. It can be changed with
+ sysctl -w fs.file-max=N.
+ To make the setting persist across reboots, add an assignment
+ in /etc/sysctl.conf.
+ The maximum limit of files per process is fixed at the time the
+ kernel is compiled; see
+ /usr/src/linux/Documentation/proc.txt for
+ more information.
+
+
+ The PostgreSQL server uses one process
+ per connection so you should provide for at least as many processes
+ as allowed connections, in addition to what you need for the rest
+ of your system. This is usually not a problem but if you run
+ several servers on one machine things might get tight.
+
+ The factory default limit on open files is often set to
+ “socially friendly” values that allow many users to
+ coexist on a machine without using an inappropriate fraction of
+ the system resources. If you run many servers on a machine this
+ is perhaps what you want, but on dedicated servers you might want to
+ raise this limit.
+
+ On the other side of the coin, some systems allow individual
+ processes to open large numbers of files; if more than a few
+ processes do so then the system-wide limit can easily be exceeded.
+ If you find this happening, and you do not want to alter the
+ system-wide limit, you can set PostgreSQL's max_files_per_process configuration parameter to
+ limit the consumption of open files.
+
+ Another kernel limit that may be of concern when supporting large
+ numbers of client connections is the maximum socket connection queue
+ length. If more than that many connection requests arrive within a very
+ short period, some may get rejected before the PostgreSQL server can service
+ the requests, with those clients receiving unhelpful connection failure
+ errors such as “Resource temporarily unavailable” or
+ “Connection refused”. The default queue length limit is 128
+ on many platforms. To raise it, adjust the appropriate kernel parameter
+ via sysctl, then restart the PostgreSQL server.
+ The parameter is variously named net.core.somaxconn
+ on Linux, kern.ipc.soacceptqueue on newer FreeBSD,
+ and kern.ipc.somaxconn on macOS and other BSD
+ variants.
+
19.4.4. Linux Memory Overcommit #
+ The default virtual memory behavior on Linux is not
+ optimal for PostgreSQL. Because of the
+ way that the kernel implements memory overcommit, the kernel might
+ terminate the PostgreSQL postmaster (the
+ supervisor server process) if the memory demands of either
+ PostgreSQL or another process cause the
+ system to run out of virtual memory.
+
+ If this happens, you will see a kernel message that looks like
+ this (consult your system documentation and configuration on where
+ to look for such a message):
+
+Out of Memory: Killed process 12345 (postgres).
+
+ This indicates that the postgres process
+ has been terminated due to memory pressure.
+ Although existing database connections will continue to function
+ normally, no new connections will be accepted. To recover,
+ PostgreSQL will need to be restarted.
+
+ One way to avoid this problem is to run
+ PostgreSQL on a machine where you can
+ be sure that other processes will not run the machine out of
+ memory. If memory is tight, increasing the swap space of the
+ operating system can help avoid the problem, because the
+ out-of-memory (OOM) killer is invoked only when physical memory and
+ swap space are exhausted.
+
+ If PostgreSQL itself is the cause of the
+ system running out of memory, you can avoid the problem by changing
+ your configuration. In some cases, it may help to lower memory-related
+ configuration parameters, particularly
+ shared_buffers,
+ work_mem, and
+ hash_mem_multiplier.
+ In other cases, the problem may be caused by allowing too many
+ connections to the database server itself. In many cases, it may
+ be better to reduce
+ max_connections
+ and instead make use of external connection-pooling software.
+
+ It is possible to modify the
+ kernel's behavior so that it will not “overcommit” memory.
+ Although this setting will not prevent the OOM killer from being invoked
+ altogether, it will lower the chances significantly and will therefore
+ lead to more robust system behavior. This is done by selecting strict
+ overcommit mode via sysctl:
+
+sysctl -w vm.overcommit_memory=2
+
+ or placing an equivalent entry in /etc/sysctl.conf.
+ You might also wish to modify the related setting
+ vm.overcommit_ratio. For details see the kernel documentation
+ file https://www.kernel.org/doc/Documentation/vm/overcommit-accounting.
+
+ Another approach, which can be used with or without altering
+ vm.overcommit_memory, is to set the process-specific
+ OOM score adjustment value for the postmaster process to
+ -1000, thereby guaranteeing it will not be targeted by the OOM
+ killer. The simplest way to do this is to execute
+
+echo -1000 > /proc/self/oom_score_adj
+
+ in the PostgreSQL startup script just before
+ invoking postgres.
+ Note that this action must be done as root, or it will have no effect;
+ so a root-owned startup script is the easiest place to do it. If you
+ do this, you should also set these environment variables in the startup
+ script before invoking postgres:
+
+export PG_OOM_ADJUST_FILE=/proc/self/oom_score_adj
+export PG_OOM_ADJUST_VALUE=0
+
+ These settings will cause postmaster child processes to run with the
+ normal OOM score adjustment of zero, so that the OOM killer can still
+ target them at need. You could use some other value for
+ PG_OOM_ADJUST_VALUE if you want the child processes to run
+ with some other OOM score adjustment. (PG_OOM_ADJUST_VALUE
+ can also be omitted, in which case it defaults to zero.) If you do not
+ set PG_OOM_ADJUST_FILE, the child processes will run with the
+ same OOM score adjustment as the postmaster, which is unwise since the
+ whole point is to ensure that the postmaster has a preferential setting.
+
19.4.5. Linux Huge Pages #
+ Using huge pages reduces overhead when using large contiguous chunks of
+ memory, as PostgreSQL does, particularly when
+ using large values of shared_buffers. To use this
+ feature in PostgreSQL you need a kernel
+ with CONFIG_HUGETLBFS=y and
+ CONFIG_HUGETLB_PAGE=y. You will also have to configure
+ the operating system to provide enough huge pages of the desired size.
+ To determine the number of huge pages needed, use the
+ postgres command to see the value of
+ shared_memory_size_in_huge_pages. Note that the
+ server must be shut down to view this runtime-computed parameter.
+ This might look like:
+
+$ postgres -D $PGDATA -C shared_memory_size_in_huge_pages
+3170
+$ grep ^Hugepagesize /proc/meminfo
+Hugepagesize: 2048 kB
+$ ls /sys/kernel/mm/hugepages
+hugepages-1048576kB hugepages-2048kB
+
+
+ In this example the default is 2MB, but you can also explicitly request
+ either 2MB or 1GB with huge_page_size to adapt
+ the number of pages calculated by
+ shared_memory_size_in_huge_pages.
+
+ While we need at least 3170 huge pages in this example,
+ a larger setting would be appropriate if other programs on the machine
+ also need huge pages.
+ We can set this with:
+
+# sysctl -w vm.nr_hugepages=3170
+
+ Don't forget to add this setting to /etc/sysctl.conf
+ so that it is reapplied after reboots. For non-default huge page sizes,
+ we can instead use:
+
+# echo 3170 > /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages
+
+ It is also possible to provide these settings at boot time using
+ kernel parameters such as hugepagesz=2M hugepages=3170.
+
+ Sometimes the kernel is not able to allocate the desired number of huge
+ pages immediately due to fragmentation, so it might be necessary
+ to repeat the command or to reboot. (Immediately after a reboot, most of
+ the machine's memory should be available to convert into huge pages.)
+ To verify the huge page allocation situation for a given size, use:
+
+$ cat /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages
+
+
+ It may also be necessary to give the database server's operating system
+ user permission to use huge pages by setting
+ vm.hugetlb_shm_group via sysctl, and/or
+ give permission to lock memory with ulimit -l.
+
+ The default behavior for huge pages in
+ PostgreSQL is to use them when possible, with
+ the system's default huge page size, and
+ to fall back to normal pages on failure. To enforce the use of huge
+ pages, you can set huge_pages
+ to on in postgresql.conf.
+ Note that with this setting PostgreSQL will fail to
+ start if not enough huge pages are available.
+
+ For a detailed description of the Linux huge
+ pages feature have a look
+ at https://www.kernel.org/doc/Documentation/vm/hugetlbpage.txt.
+
Chapter 35. Large Objects
+ PostgreSQL has a large object
+ facility, which provides stream-style access to user data that is stored
+ in a special large-object structure. Streaming access is useful
+ when working with data values that are too large to manipulate
+ conveniently as a whole.
+
+ This chapter describes the implementation and the programming and
+ query language interfaces to PostgreSQL
+ large object data. We use the libpq C
+ library for the examples in this chapter, but most programming
+ interfaces native to PostgreSQL support
+ equivalent functionality. Other interfaces might use the large
+ object interface internally to provide generic support for large
+ values. This is not described here.
+
Legal Notice
+ PostgreSQL is Copyright © 1996–2024
+ by the PostgreSQL Global Development Group.
+
+ Postgres95 is Copyright © 1994–5
+ by the Regents of the University of California.
+
+ Permission to use, copy, modify, and distribute this software and
+ its documentation for any purpose, without fee, and without a
+ written agreement is hereby granted, provided that the above
+ copyright notice and this paragraph and the following two paragraphs
+ appear in all copies.
+
+ IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY
+ PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL
+ DAMAGES, INCLUDING LOST PROFITS, ARISING OUT OF THE USE OF THIS
+ SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF CALIFORNIA
+ HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
+ INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE
+ PROVIDED HEREUNDER IS ON AN “AS-IS” BASIS, AND THE UNIVERSITY OF
+ CALIFORNIA HAS NO OBLIGATIONS TO PROVIDE MAINTENANCE, SUPPORT,
+ UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
+
34.4. Asynchronous Command Processing #
+ The PQexec function is adequate for submitting
+ commands in normal, synchronous applications. It has a few
+ deficiencies, however, that can be of importance to some users:
+
+
+ PQexec waits for the command to be completed.
+ The application might have other work to do (such as maintaining a
+ user interface), in which case it won't want to block waiting for
+ the response.
+
+ Since the execution of the client application is suspended while it
+ waits for the result, it is hard for the application to decide that
+ it would like to try to cancel the ongoing command. (It can be done
+ from a signal handler, but not otherwise.)
+
+ PQexec can return only one
+ PGresult structure. If the submitted command
+ string contains multiple SQL commands, all but
+ the last PGresult are discarded by
+ PQexec.
+
+ PQexec always collects the command's entire result,
+ buffering it in a single PGresult. While
+ this simplifies error-handling logic for the application, it can be
+ impractical for results containing many rows.
+
+
+ Applications that do not like these limitations can instead use the
+ underlying functions that PQexec is built from:
+ PQsendQuery and PQgetResult.
+ There are also
+ PQsendQueryParams,
+ PQsendPrepare,
+ PQsendQueryPrepared,
+ PQsendDescribePrepared, and
+ PQsendDescribePortal,
+ which can be used with PQgetResult to duplicate
+ the functionality of
+ PQexecParams,
+ PQprepare,
+ PQexecPrepared,
+ PQdescribePrepared, and
+ PQdescribePortal
+ respectively.
+
+
PQsendQuery #
+ Submits a command to the server without waiting for the result(s).
+ 1 is returned if the command was successfully dispatched and 0 if
+ not (in which case, use PQerrorMessage to get more
+ information about the failure).
+
+int PQsendQuery(PGconn *conn, const char *command);
+
+
+ After successfully calling PQsendQuery, call
+ PQgetResult one or more times to obtain the
+ results. PQsendQuery cannot be called again
+ (on the same connection) until PQgetResult
+ has returned a null pointer, indicating that the command is done.
+
+ In pipeline mode, this function is disallowed.
+
PQsendQueryParams #
+ Submits a command and separate parameters to the server without
+ waiting for the result(s).
+
+int PQsendQueryParams(PGconn *conn,
+ const char *command,
+ int nParams,
+ const Oid *paramTypes,
+ const char * const *paramValues,
+ const int *paramLengths,
+ const int *paramFormats,
+ int resultFormat);
+
+
+ This is equivalent to PQsendQuery except that
+ query parameters can be specified separately from the query string.
+ The function's parameters are handled identically to
+ PQexecParams. Like
+ PQexecParams, it allows only one command in the
+ query string.
+
PQsendPrepare #
+ Sends a request to create a prepared statement with the given
+ parameters, without waiting for completion.
+
+int PQsendPrepare(PGconn *conn,
+ const char *stmtName,
+ const char *query,
+ int nParams,
+ const Oid *paramTypes);
+
+
+ This is an asynchronous version of PQprepare: it
+ returns 1 if it was able to dispatch the request, and 0 if not.
+ After a successful call, call PQgetResult to
+ determine whether the server successfully created the prepared
+ statement. The function's parameters are handled identically to
+ PQprepare.
+
PQsendQueryPrepared #
+ Sends a request to execute a prepared statement with given
+ parameters, without waiting for the result(s).
+
+int PQsendQueryPrepared(PGconn *conn,
+ const char *stmtName,
+ int nParams,
+ const char * const *paramValues,
+ const int *paramLengths,
+ const int *paramFormats,
+ int resultFormat);
+
+
+ This is similar to PQsendQueryParams, but
+ the command to be executed is specified by naming a
+ previously-prepared statement, instead of giving a query string.
+ The function's parameters are handled identically to
+ PQexecPrepared.
+
PQsendDescribePrepared #
+ Submits a request to obtain information about the specified
+ prepared statement, without waiting for completion.
+
+int PQsendDescribePrepared(PGconn *conn, const char *stmtName);
+
+
+ This is an asynchronous version of PQdescribePrepared:
+ it returns 1 if it was able to dispatch the request, and 0 if not.
+ After a successful call, call PQgetResult to
+ obtain the results. The function's parameters are handled
+ identically to PQdescribePrepared.
+
PQsendDescribePortal #
+ Submits a request to obtain information about the specified
+ portal, without waiting for completion.
+
+int PQsendDescribePortal(PGconn *conn, const char *portalName);
+
+
+ This is an asynchronous version of PQdescribePortal:
+ it returns 1 if it was able to dispatch the request, and 0 if not.
+ After a successful call, call PQgetResult to
+ obtain the results. The function's parameters are handled
+ identically to PQdescribePortal.
+
PQgetResult #
+ Waits for the next result from a prior
+ PQsendQuery,
+ PQsendQueryParams,
+ PQsendPrepare,
+ PQsendQueryPrepared,
+ PQsendDescribePrepared,
+ PQsendDescribePortal, or
+ PQpipelineSync
+ call, and returns it.
+ A null pointer is returned when the command is complete and there
+ will be no more results.
+
+PGresult *PQgetResult(PGconn *conn);
+
+
+ PQgetResult must be called repeatedly until
+ it returns a null pointer, indicating that the command is done.
+ (If called when no command is active,
+ PQgetResult will just return a null pointer
+ at once.) Each non-null result from
+ PQgetResult should be processed using the
+ same PGresult accessor functions previously
+ described. Don't forget to free each result object with
+ PQclear when done with it. Note that
+ PQgetResult will block only if a command is
+ active and the necessary response data has not yet been read by
+ PQconsumeInput
+ .
+
+ In pipeline mode, PQgetResult will return normally
+ unless an error occurs; for any subsequent query sent after the one
+ that caused the error until (and excluding) the next synchronization point,
+ a special result of type PGRES_PIPELINE_ABORTED will
+ be returned, and a null pointer will be returned after it.
+ When the pipeline synchronization point is reached, a result of type
+ PGRES_PIPELINE_SYNC will be returned.
+ The result of the next query after the synchronization point follows
+ immediately (that is, no null pointer is returned after
+ the synchronization point.)
+
Note
+ Even when PQresultStatus indicates a fatal
+ error, PQgetResult should be called until it
+ returns a null pointer, to allow libpq to
+ process the error information completely.
+
+
+ Using PQsendQuery and
+ PQgetResult solves one of
+ PQexec's problems: If a command string contains
+ multiple SQL commands, the results of those commands
+ can be obtained individually. (This allows a simple form of overlapped
+ processing, by the way: the client can be handling the results of one
+ command while the server is still working on later queries in the same
+ command string.)
+
+ Another frequently-desired feature that can be obtained with
+ PQsendQuery and PQgetResult
+ is retrieving large query results a row at a time. This is discussed
+ in Section 34.6.
+
+ By itself, calling PQgetResult
+ will still cause the client to block until the server completes the
+ next SQL command. This can be avoided by proper
+ use of two more functions:
+
+
PQconsumeInput
+ #
+ If input is available from the server, consume it.
+
+int PQconsumeInput(PGconn *conn);
+
+
+ PQconsumeInput
+ normally returns 1 indicating
+ “no error”, but returns 0 if there was some kind of
+ trouble (in which case PQerrorMessage can be
+ consulted). Note that the result does not say whether any input
+ data was actually collected. After calling
+ PQconsumeInput
+ , the application can check
+ PQisBusy and/or
+ PQnotifies to see if their state has changed.
+
+ PQconsumeInput
+ can be called even if the
+ application is not prepared to deal with a result or notification
+ just yet. The function will read available data and save it in
+ a buffer, thereby causing a select()
+ read-ready indication to go away. The application can thus use
+ PQconsumeInput
+ to clear the
+ select() condition immediately, and then
+ examine the results at leisure.
+
PQisBusy #
+ Returns 1 if a command is busy, that is,
+ PQgetResult would block waiting for input.
+ A 0 return indicates that PQgetResult can be
+ called with assurance of not blocking.
+
+int PQisBusy(PGconn *conn);
+
+
+ PQisBusy will not itself attempt to read data
+ from the server; therefore PQconsumeInput
+
+ must be invoked first, or the busy state will never end.
+
+
+ A typical application using these functions will have a main loop that
+ uses select() or poll() to wait for
+ all the conditions that it must respond to. One of the conditions
+ will be input available from the server, which in terms of
+ select() means readable data on the file
+ descriptor identified by PQsocket. When the main
+ loop detects input ready, it should call
+ PQconsumeInput
+ to read the input. It can then
+ call PQisBusy, followed by
+ PQgetResult if PQisBusy
+ returns false (0). It can also call PQnotifies
+ to detect NOTIFY messages (see Section 34.9).
+
+ A client that uses
+ PQsendQuery/PQgetResult
+ can also attempt to cancel a command that is still being processed
+ by the server; see Section 34.7. But regardless of
+ the return value of PQcancel, the application
+ must continue with the normal result-reading sequence using
+ PQgetResult. A successful cancellation will
+ simply cause the command to terminate sooner than it would have
+ otherwise.
+
+ By using the functions described above, it is possible to avoid
+ blocking while waiting for input from the database server. However,
+ it is still possible that the application will block waiting to send
+ output to the server. This is relatively uncommon but can happen if
+ very long SQL commands or data values are sent. (It is much more
+ probable if the application sends data via COPY IN,
+ however.) To prevent this possibility and achieve completely
+ nonblocking database operation, the following additional functions
+ can be used.
+
+
PQsetnonblocking #
+ Sets the nonblocking status of the connection.
+
+int PQsetnonblocking(PGconn *conn, int arg);
+
+
+ Sets the state of the connection to nonblocking if
+ arg is 1, or blocking if
+ arg is 0. Returns 0 if OK, -1 if error.
+
+ In the nonblocking state, successful calls to
+ PQsendQuery, PQputline,
+ PQputnbytes, PQputCopyData,
+ and PQendcopy will not block; their changes
+ are stored in the local output buffer until they are flushed.
+ Unsuccessful calls will return an error and must be retried.
+
+ Note that PQexec does not honor nonblocking
+ mode; if it is called, it will act in blocking fashion anyway.
+
PQisnonblocking #
+ Returns the blocking status of the database connection.
+
+int PQisnonblocking(const PGconn *conn);
+
+
+ Returns 1 if the connection is set to nonblocking mode and 0 if
+ blocking.
+
PQflush #
+ Attempts to flush any queued output data to the server. Returns
+ 0 if successful (or if the send queue is empty), -1 if it failed
+ for some reason, or 1 if it was unable to send all the data in
+ the send queue yet (this case can only occur if the connection
+ is nonblocking).
+
+int PQflush(PGconn *conn);
+
+
+
+ After sending any command or data on a nonblocking connection, call
+ PQflush. If it returns 1, wait for the socket
+ to become read- or write-ready. If it becomes write-ready, call
+ PQflush again. If it becomes read-ready, call
+ PQconsumeInput
+ , then call
+ PQflush again. Repeat until
+ PQflush returns 0. (It is necessary to check for
+ read-ready and drain the input with PQconsumeInput
+ ,
+ because the server can block trying to send us data, e.g., NOTICE
+ messages, and won't read our data until we read its.) Once
+ PQflush returns 0, wait for the socket to be
+ read-ready and then read the response as described above.
+
34.21. Building libpq Programs #
+ To build (i.e., compile and link) a program using
+ libpq you need to do all of the following
+ things:
+
+
+ Include the libpq-fe.h header file:
+
+#include <libpq-fe.h>
+
+ If you failed to do that then you will normally get error messages
+ from your compiler similar to:
+
+foo.c: In function `main':
+foo.c:34: `PGconn' undeclared (first use in this function)
+foo.c:35: `PGresult' undeclared (first use in this function)
+foo.c:54: `CONNECTION_BAD' undeclared (first use in this function)
+foo.c:68: `PGRES_COMMAND_OK' undeclared (first use in this function)
+foo.c:95: `PGRES_TUPLES_OK' undeclared (first use in this function)
+
+
+ Point your compiler to the directory where the PostgreSQL header
+ files were installed, by supplying the
+ -Idirectory option
+ to your compiler. (In some cases the compiler will look into
+ the directory in question by default, so you can omit this
+ option.) For instance, your compile command line could look
+ like:
+
+cc -c -I/usr/local/pgsql/include testprog.c
+
+ If you are using makefiles then add the option to the
+ CPPFLAGS variable:
+
+CPPFLAGS += -I/usr/local/pgsql/include
+
+
+ If there is any chance that your program might be compiled by
+ other users then you should not hardcode the directory location
+ like that. Instead, you can run the utility
+ pg_config to find out where the header
+ files are on the local system:
+
+$ pg_config --includedir
+/usr/local/include
+
+
+ If you
+ have pkg-config installed, you can run instead:
+
+$ pkg-config --cflags libpq
+-I/usr/local/include
+
+ Note that this will already include the -I in front of
+ the path.
+
+ Failure to specify the correct option to the compiler will
+ result in an error message such as:
+
+testlibpq.c:8:22: libpq-fe.h: No such file or directory
+
+
+ When linking the final program, specify the option
+ -lpq so that the libpq
+ library gets pulled in, as well as the option
+ -Ldirectory to point
+ the compiler to the directory where the
+ libpq library resides. (Again, the
+ compiler will search some directories by default.) For maximum
+ portability, put the -L option before the
+ -lpq option. For example:
+
+cc -o testprog testprog1.o testprog2.o -L/usr/local/pgsql/lib -lpq
+
+
+ You can find out the library directory using
+ pg_config as well:
+
+$ pg_config --libdir
+/usr/local/pgsql/lib
+
+
+ Or again use pkg-config:
+
+$ pkg-config --libs libpq
+-L/usr/local/pgsql/lib -lpq
+
+ Note again that this prints the full options, not only the path.
+
+ Error messages that point to problems in this area could look like
+ the following:
+
+testlibpq.o: In function `main':
+testlibpq.o(.text+0x60): undefined reference to `PQsetdbLogin'
+testlibpq.o(.text+0x71): undefined reference to `PQstatus'
+testlibpq.o(.text+0xa4): undefined reference to `PQerrorMessage'
+
+ This means you forgot -lpq.
+
+/usr/bin/ld: cannot find -lpq
+
+ This means you forgot the -L option or did not
+ specify the right directory.
+
+
34.7. Canceling Queries in Progress #
+ A client application can request cancellation of a command that is
+ still being processed by the server, using the functions described in
+ this section.
+
+
PQgetCancel #
+ Creates a data structure containing the information needed to cancel
+ a command issued through a particular database connection.
+
+PGcancel *PQgetCancel(PGconn *conn);
+
+
+ PQgetCancel creates a
+ PGcancel object
+ given a PGconn connection object. It will return
+ NULL if the given conn is NULL or an invalid
+ connection. The PGcancel object is an opaque
+ structure that is not meant to be accessed directly by the
+ application; it can only be passed to PQcancel
+ or PQfreeCancel.
+
PQfreeCancel #
+ Frees a data structure created by PQgetCancel.
+
+void PQfreeCancel(PGcancel *cancel);
+
+
+ PQfreeCancel frees a data object previously created
+ by PQgetCancel.
+
PQcancel #
+ Requests that the server abandon processing of the current command.
+
+int PQcancel(PGcancel *cancel, char *errbuf, int errbufsize);
+
+
+ The return value is 1 if the cancel request was successfully
+ dispatched and 0 if not. If not, errbuf is filled
+ with an explanatory error message. errbuf
+ must be a char array of size errbufsize (the
+ recommended size is 256 bytes).
+
+ Successful dispatch is no guarantee that the request will have
+ any effect, however. If the cancellation is effective, the current
+ command will terminate early and return an error result. If the
+ cancellation fails (say, because the server was already done
+ processing the command), then there will be no visible result at
+ all.
+
+ PQcancel can safely be invoked from a signal
+ handler, if the errbuf is a local variable in the
+ signal handler. The PGcancel object is read-only
+ as far as PQcancel is concerned, so it can
+ also be invoked from a thread that is separate from the one
+ manipulating the PGconn object.
+
+
+
PQrequestCancel #
+ PQrequestCancel is a deprecated variant of
+ PQcancel.
+
+int PQrequestCancel(PGconn *conn);
+
+
+ Requests that the server abandon processing of the current
+ command. It operates directly on the
+ PGconn object, and in case of failure stores the
+ error message in the PGconn object (whence it can
+ be retrieved by PQerrorMessage). Although
+ the functionality is the same, this approach is not safe within
+ multiple-thread programs or signal handlers, since it is possible
+ that overwriting the PGconn's error message will
+ mess up the operation currently in progress on the connection.
+
+
34.1. Database Connection Control Functions #
+ The following functions deal with making a connection to a
+ PostgreSQL backend server. An
+ application program can have several backend connections open at
+ one time. (One reason to do that is to access more than one
+ database.) Each connection is represented by a
+ PGconn object, which
+ is obtained from the function PQconnectdb,
+ PQconnectdbParams, or
+ PQsetdbLogin. Note that these functions will always
+ return a non-null object pointer, unless perhaps there is too
+ little memory even to allocate the PGconn object.
+ The PQstatus function should be called to check
+ the return value for a successful connection before queries are sent
+ via the connection object.
+
+
Warning
+ If untrusted users have access to a database that has not adopted a
+ secure schema usage pattern,
+ begin each session by removing publicly-writable schemas from
+ search_path. One can set parameter key
+ word options to
+ value -csearch_path=. Alternately, one can
+ issue PQexec(conn, "SELECT
+ pg_catalog.set_config('search_path', '', false)") after
+ connecting. This consideration is not specific
+ to libpq; it applies to every interface for
+ executing arbitrary SQL commands.
+
+
+
Warning
+ On Unix, forking a process with open libpq connections can lead to
+ unpredictable results because the parent and child processes share
+ the same sockets and operating system resources. For this reason,
+ such usage is not recommended, though doing an exec from
+ the child process to load a new executable is safe.
+
+
+
PQconnectdbParams #
+ Makes a new connection to the database server.
+
+
+PGconn *PQconnectdbParams(const char * const *keywords,
+ const char * const *values,
+ int expand_dbname);
+
+
+ This function opens a new database connection using the parameters taken
+ from two NULL-terminated arrays. The first,
+ keywords, is defined as an array of strings, each one
+ being a key word. The second, values, gives the value
+ for each key word. Unlike PQsetdbLogin below, the parameter
+ set can be extended without changing the function signature, so use of
+ this function (or its nonblocking analogs PQconnectStartParams
+ and PQconnectPoll) is preferred for new application
+ programming.
+
+ The currently recognized parameter key words are listed in
+ Section 34.1.2.
+
+ The passed arrays can be empty to use all default parameters, or can
+ contain one or more parameter settings. They must be matched in length.
+ Processing will stop at the first NULL entry
+ in the keywords array.
+ Also, if the values entry associated with a
+ non-NULL keywords entry is
+ NULL or an empty string, that entry is ignored and
+ processing continues with the next pair of array entries.
+
+ When expand_dbname is non-zero, the value for
+ the first dbname key word is checked to see
+ if it is a connection string. If so, it
+ is “expanded” into the individual connection
+ parameters extracted from the string. The value is considered to
+ be a connection string, rather than just a database name, if it
+ contains an equal sign (=) or it begins with a
+ URI scheme designator. (More details on connection string formats
+ appear in Section 34.1.1.) Only the first
+ occurrence of dbname is treated in this way;
+ any subsequent dbname parameter is processed
+ as a plain database name.
+
+ In general the parameter arrays are processed from start to end.
+ If any key word is repeated, the last value (that is
+ not NULL or empty) is used. This rule applies in
+ particular when a key word found in a connection string conflicts
+ with one appearing in the keywords array. Thus,
+ the programmer may determine whether array entries can override or
+ be overridden by values taken from a connection string. Array
+ entries appearing before an expanded dbname
+ entry can be overridden by fields of the connection string, and in
+ turn those fields are overridden by array entries appearing
+ after dbname (but, again, only if those
+ entries supply non-empty values).
+
+ After processing all the array entries and any expanded connection
+ string, any connection parameters that remain unset are filled with
+ default values. If an unset parameter's corresponding environment
+ variable (see Section 34.15) is set, its value is
+ used. If the environment variable is not set either, then the
+ parameter's built-in default value is used.
+
PQconnectdb #
+ Makes a new connection to the database server.
+
+
+PGconn *PQconnectdb(const char *conninfo);
+
+
+ This function opens a new database connection using the parameters taken
+ from the string conninfo.
+
+ The passed string can be empty to use all default parameters, or it can
+ contain one or more parameter settings separated by whitespace,
+ or it can contain a URI.
+ See Section 34.1.1 for details.
+
PQsetdbLogin #
+ Makes a new connection to the database server.
+
+PGconn *PQsetdbLogin(const char *pghost,
+ const char *pgport,
+ const char *pgoptions,
+ const char *pgtty,
+ const char *dbName,
+ const char *login,
+ const char *pwd);
+
+
+ This is the predecessor of PQconnectdb with a fixed
+ set of parameters. It has the same functionality except that the
+ missing parameters will always take on default values. Write NULL or an
+ empty string for any one of the fixed parameters that is to be defaulted.
+
+ If the dbName contains
+ an = sign or has a valid connection URI prefix, it
+ is taken as a conninfo string in exactly the same way as
+ if it had been passed to PQconnectdb, and the remaining
+ parameters are then applied as specified for PQconnectdbParams.
+
+ pgtty is no longer used and any value passed will
+ be ignored.
+
PQsetdb #
+ Makes a new connection to the database server.
+
+PGconn *PQsetdb(char *pghost,
+ char *pgport,
+ char *pgoptions,
+ char *pgtty,
+ char *dbName);
+
+
+ This is a macro that calls PQsetdbLogin with null pointers
+ for the login and pwd parameters. It is provided
+ for backward compatibility with very old programs.
+
PQconnectStartParams
PQconnectStart
PQconnectPoll #
+
+ Make a connection to the database server in a nonblocking manner.
+
+
+PGconn *PQconnectStartParams(const char * const *keywords,
+ const char * const *values,
+ int expand_dbname);
+
+PGconn *PQconnectStart(const char *conninfo);
+
+PostgresPollingStatusType PQconnectPoll(PGconn *conn);
+
+
+ These three functions are used to open a connection to a database server such
+ that your application's thread of execution is not blocked on remote I/O
+ whilst doing so. The point of this approach is that the waits for I/O to
+ complete can occur in the application's main loop, rather than down inside
+ PQconnectdbParams or PQconnectdb, and so the
+ application can manage this operation in parallel with other activities.
+
+ With PQconnectStartParams, the database connection is made
+ using the parameters taken from the keywords and
+ values arrays, and controlled by expand_dbname,
+ as described above for PQconnectdbParams.
+
+ With PQconnectStart, the database connection is made
+ using the parameters taken from the string conninfo as
+ described above for PQconnectdb.
+
+ Neither PQconnectStartParams nor PQconnectStart
+ nor PQconnectPoll will block, so long as a number of
+ restrictions are met:
+
+ The hostaddr parameter must be used appropriately
+ to prevent DNS queries from being made. See the documentation of
+ this parameter in Section 34.1.2 for details.
+
+ If you call PQtrace, ensure that the stream object
+ into which you trace will not block.
+
+ You must ensure that the socket is in the appropriate state
+ before calling PQconnectPoll, as described below.
+
+
+ To begin a nonblocking connection request,
+ call PQconnectStart
+ or PQconnectStartParams. If the result is null,
+ then libpq has been unable to allocate a
+ new PGconn structure. Otherwise, a
+ valid PGconn pointer is returned (though not
+ yet representing a valid connection to the database). Next
+ call PQstatus(conn). If the result
+ is CONNECTION_BAD, the connection attempt has already
+ failed, typically because of invalid connection parameters.
+
+ If PQconnectStart
+ or PQconnectStartParams succeeds, the next stage
+ is to poll libpq so that it can proceed with
+ the connection sequence.
+ Use PQsocket(conn) to obtain the descriptor of the
+ socket underlying the database connection.
+ (Caution: do not assume that the socket remains the same
+ across PQconnectPoll calls.)
+ Loop thus: If PQconnectPoll(conn) last returned
+ PGRES_POLLING_READING, wait until the socket is ready to
+ read (as indicated by select(), poll(), or
+ similar system function).
+ Then call PQconnectPoll(conn) again.
+ Conversely, if PQconnectPoll(conn) last returned
+ PGRES_POLLING_WRITING, wait until the socket is ready
+ to write, then call PQconnectPoll(conn) again.
+ On the first iteration, i.e., if you have yet to call
+ PQconnectPoll, behave as if it last returned
+ PGRES_POLLING_WRITING. Continue this loop until
+ PQconnectPoll(conn) returns
+ PGRES_POLLING_FAILED, indicating the connection procedure
+ has failed, or PGRES_POLLING_OK, indicating the connection
+ has been successfully made.
+
+ At any time during connection, the status of the connection can be
+ checked by calling PQstatus. If this call returns CONNECTION_BAD, then the
+ connection procedure has failed; if the call returns CONNECTION_OK, then the
+ connection is ready. Both of these states are equally detectable
+ from the return value of PQconnectPoll, described above. Other states might also occur
+ during (and only during) an asynchronous connection procedure. These
+ indicate the current stage of the connection procedure and might be useful
+ to provide feedback to the user for example. These statuses are:
+
+
CONNECTION_STARTED #
+ Waiting for connection to be made.
+
CONNECTION_MADE #
+ Connection OK; waiting to send.
+
CONNECTION_AWAITING_RESPONSE #
+ Waiting for a response from the server.
+
CONNECTION_AUTH_OK #
+ Received authentication; waiting for backend start-up to finish.
+
CONNECTION_SSL_STARTUP #
+ Negotiating SSL encryption.
+
CONNECTION_SETENV #
+ Negotiating environment-driven parameter settings.
+
CONNECTION_CHECK_WRITABLE #
+ Checking if connection is able to handle write transactions.
+
CONNECTION_CONSUME #
+ Consuming any remaining response messages on connection.
+
+
+ Note that, although these constants will remain (in order to maintain
+ compatibility), an application should never rely upon these occurring in a
+ particular order, or at all, or on the status always being one of these
+ documented values. An application might do something like this:
+
+switch(PQstatus(conn))
+{
+ case CONNECTION_STARTED:
+ feedback = "Connecting...";
+ break;
+
+ case CONNECTION_MADE:
+ feedback = "Connected to server...";
+ break;
+.
+.
+.
+ default:
+ feedback = "Connecting...";
+}
+
+
+ The connect_timeout connection parameter is ignored
+ when using PQconnectPoll; it is the application's
+ responsibility to decide whether an excessive amount of time has elapsed.
+ Otherwise, PQconnectStart followed by a
+ PQconnectPoll loop is equivalent to
+ PQconnectdb.
+
+ Note that when PQconnectStart
+ or PQconnectStartParams returns a non-null
+ pointer, you must call PQfinish when you are
+ finished with it, in order to dispose of the structure and any
+ associated memory blocks. This must be done even if the connection
+ attempt fails or is abandoned.
+
PQconndefaults #
+ Returns the default connection options.
+
+PQconninfoOption *PQconndefaults(void);
+
+typedef struct
+{
+ char *keyword; /* The keyword of the option */
+ char *envvar; /* Fallback environment variable name */
+ char *compiled; /* Fallback compiled in default value */
+ char *val; /* Option's current value, or NULL */
+ char *label; /* Label for field in connect dialog */
+ char *dispchar; /* Indicates how to display this field
+ in a connect dialog. Values are:
+ "" Display entered value as is
+ "*" Password field - hide value
+ "D" Debug option - don't show by default */
+ int dispsize; /* Field size in characters for dialog */
+} PQconninfoOption;
+
+
+ Returns a connection options array. This can be used to determine
+ all possible PQconnectdb options and their
+ current default values. The return value points to an array of
+ PQconninfoOption structures, which ends
+ with an entry having a null keyword pointer. The
+ null pointer is returned if memory could not be allocated. Note that
+ the current default values (val fields)
+ will depend on environment variables and other context. A
+ missing or invalid service file will be silently ignored. Callers
+ must treat the connection options data as read-only.
+
+ After processing the options array, free it by passing it to
+ PQconninfoFree. If this is not done, a small amount of memory
+ is leaked for each call to PQconndefaults.
+
PQconninfo #
+ Returns the connection options used by a live connection.
+
+PQconninfoOption *PQconninfo(PGconn *conn);
+
+
+ Returns a connection options array. This can be used to determine
+ all possible PQconnectdb options and the
+ values that were used to connect to the server. The return
+ value points to an array of PQconninfoOption
+ structures, which ends with an entry having a null keyword
+ pointer. All notes above for PQconndefaults also
+ apply to the result of PQconninfo.
+
PQconninfoParse #
+ Returns parsed connection options from the provided connection string.
+
+
+PQconninfoOption *PQconninfoParse(const char *conninfo, char **errmsg);
+
+
+ Parses a connection string and returns the resulting options as an
+ array; or returns NULL if there is a problem with the connection
+ string. This function can be used to extract
+ the PQconnectdb options in the provided
+ connection string. The return value points to an array of
+ PQconninfoOption structures, which ends
+ with an entry having a null keyword pointer.
+
+ All legal options will be present in the result array, but the
+ PQconninfoOption for any option not present
+ in the connection string will have val set to
+ NULL; default values are not inserted.
+
+ If errmsg is not NULL, then *errmsg is set
+ to NULL on success, else to a malloc'd error string explaining
+ the problem. (It is also possible for *errmsg to be
+ set to NULL and the function to return NULL;
+ this indicates an out-of-memory condition.)
+
+ After processing the options array, free it by passing it to
+ PQconninfoFree. If this is not done, some memory
+ is leaked for each call to PQconninfoParse.
+ Conversely, if an error occurs and errmsg is not NULL,
+ be sure to free the error string using PQfreemem.
+
PQfinish #
+ Closes the connection to the server. Also frees
+ memory used by the PGconn object.
+
+void PQfinish(PGconn *conn);
+
+
+ Note that even if the server connection attempt fails (as
+ indicated by PQstatus), the application should call PQfinish
+ to free the memory used by the PGconn object.
+ The PGconn pointer must not be used again after
+ PQfinish has been called.
+
PQreset #
+ Resets the communication channel to the server.
+
+void PQreset(PGconn *conn);
+
+
+ This function will close the connection
+ to the server and attempt to establish a new
+ connection, using all the same
+ parameters previously used. This might be useful for
+ error recovery if a working connection is lost.
+
PQresetStart
PQresetPoll #
+ Reset the communication channel to the server, in a nonblocking manner.
+
+
+int PQresetStart(PGconn *conn);
+
+PostgresPollingStatusType PQresetPoll(PGconn *conn);
+
+
+ These functions will close the connection to the server and attempt to
+ establish a new connection, using all the same
+ parameters previously used. This can be useful for error recovery if a
+ working connection is lost. They differ from PQreset (above) in that they
+ act in a nonblocking manner. These functions suffer from the same
+ restrictions as PQconnectStartParams, PQconnectStart
+ and PQconnectPoll.
+
+ To initiate a connection reset, call
+ PQresetStart. If it returns 0, the reset has
+ failed. If it returns 1, poll the reset using
+ PQresetPoll in exactly the same way as you
+ would create the connection using PQconnectPoll.
+
PQpingParams #
+ PQpingParams reports the status of the
+ server. It accepts connection parameters identical to those of
+ PQconnectdbParams, described above. It is not
+ necessary to supply correct user name, password, or database name
+ values to obtain the server status; however, if incorrect values
+ are provided, the server will log a failed connection attempt.
+
+
+PGPing PQpingParams(const char * const *keywords,
+ const char * const *values,
+ int expand_dbname);
+
+
+ The function returns one of the following values:
+
+
PQPING_OK #
+ The server is running and appears to be accepting connections.
+
PQPING_REJECT #
+ The server is running but is in a state that disallows connections
+ (startup, shutdown, or crash recovery).
+
PQPING_NO_RESPONSE #
+ The server could not be contacted. This might indicate that the
+ server is not running, or that there is something wrong with the
+ given connection parameters (for example, wrong port number), or
+ that there is a network connectivity problem (for example, a
+ firewall blocking the connection request).
+
PQPING_NO_ATTEMPT #
+ No attempt was made to contact the server, because the supplied
+ parameters were obviously incorrect or there was some client-side
+ problem (for example, out of memory).
+
+
+
PQping #
+ PQping reports the status of the
+ server. It accepts connection parameters identical to those of
+ PQconnectdb, described above. It is not
+ necessary to supply correct user name, password, or database name
+ values to obtain the server status; however, if incorrect values
+ are provided, the server will log a failed connection attempt.
+
+
+PGPing PQping(const char *conninfo);
+
+
+ The return values are the same as for PQpingParams.
+
PQsetSSLKeyPassHook_OpenSSL #
+ PQsetSSLKeyPassHook_OpenSSL lets an application override
+ libpq's default
+ handling of encrypted client certificate key files using
+ sslpassword or interactive prompting.
+
+
+void PQsetSSLKeyPassHook_OpenSSL(PQsslKeyPassHook_OpenSSL_type hook);
+
+
+ The application passes a pointer to a callback function with signature:
+
+int callback_fn(char *buf, int size, PGconn *conn);
+
+ which libpq will then call
+ instead of its default
+ PQdefaultSSLKeyPassHook_OpenSSL handler. The
+ callback should determine the password for the key and copy it to
+ result-buffer buf of size
+ size. The string in buf
+ must be null-terminated. The callback must return the length of the
+ password stored in buf excluding the null
+ terminator. On failure, the callback should set
+ buf[0] = '\0' and return 0. See
+ PQdefaultSSLKeyPassHook_OpenSSL in
+ libpq's source code for an example.
+
+ If the user specified an explicit key location,
+ its path will be in conn->sslkey when the callback
+ is invoked. This will be empty if the default key path is being used.
+ For keys that are engine specifiers, it is up to engine implementations
+ whether they use the OpenSSL password
+ callback or define their own handling.
+
+ The app callback may choose to delegate unhandled cases to
+ PQdefaultSSLKeyPassHook_OpenSSL,
+ or call it first and try something else if it returns 0, or completely override it.
+
+ The callback must not escape normal flow control with exceptions,
+ longjmp(...), etc. It must return normally.
+
PQgetSSLKeyPassHook_OpenSSL #
+ PQgetSSLKeyPassHook_OpenSSL returns the current
+ client certificate key password hook, or NULL
+ if none has been set.
+
+
+PQsslKeyPassHook_OpenSSL_type PQgetSSLKeyPassHook_OpenSSL(void);
+
+
+
34.1.1. Connection Strings #
+ Several libpq functions parse a user-specified string to obtain
+ connection parameters. There are two accepted formats for these strings:
+ plain keyword/value strings
+ and URIs. URIs generally follow
+ RFC
+ 3986, except that multi-host connection strings are allowed
+ as further described below.
+
34.1.1.1. Keyword/Value Connection Strings #
+ In the keyword/value format, each parameter setting is in the form
+ keyword =
+ value, with space(s) between settings.
+ Spaces around a setting's equal sign are
+ optional. To write an empty value, or a value containing spaces, surround it
+ with single quotes, for example keyword = 'a value'.
+ Single quotes and backslashes within
+ a value must be escaped with a backslash, i.e., \' and
+ \\.
+
+ Example:
+
+host=localhost port=5432 dbname=mydb connect_timeout=10
+
+
+ The recognized parameter key words are listed in Section 34.1.2.
+
34.1.1.2. Connection URIs #
+ The general form for a connection URI is:
+
+postgresql://[userspec@][hostspec][/dbname][?paramspec]
+
+where userspec is:
+
+user[:password]
+
+and hostspec is:
+
+[host][:port][,...]
+
+and paramspec is:
+
+name=value[&...]
+
+
+ The URI scheme designator can be either
+ postgresql:// or postgres://. Each
+ of the remaining URI parts is optional. The
+ following examples illustrate valid URI syntax:
+
+postgresql://
+postgresql://localhost
+postgresql://localhost:5433
+postgresql://localhost/mydb
+postgresql://user@localhost
+postgresql://user:secret@localhost
+postgresql://other@localhost/otherdb?connect_timeout=10&application_name=myapp
+postgresql://host1:123,host2:456/somedb?target_session_attrs=any&application_name=myapp
+
+ Values that would normally appear in the hierarchical part of
+ the URI can alternatively be given as named
+ parameters. For example:
+
+postgresql:///mydb?host=localhost&port=5433
+
+ All named parameters must match key words listed in
+ Section 34.1.2, except that for compatibility
+ with JDBC connection URIs, instances
+ of ssl=true are translated into
+ sslmode=require.
+
+ The connection URI needs to be encoded with percent-encoding
+ if it includes symbols with special meaning in any of its parts. Here is
+ an example where the equal sign (=) is replaced with
+ %3D and the space character with
+ %20:
+
+postgresql://user@localhost:5433/mydb?options=-c%20synchronous_commit%3Doff
+
+
+ The host part may be either a host name or an IP address. To specify an
+ IPv6 address, enclose it in square brackets:
+
+postgresql://[2001:db8::1234]/database
+
+
+ The host part is interpreted as described for the parameter host. In particular, a Unix-domain socket
+ connection is chosen if the host part is either empty or looks like an
+ absolute path name,
+ otherwise a TCP/IP connection is initiated. Note, however, that the
+ slash is a reserved character in the hierarchical part of the URI. So, to
+ specify a non-standard Unix-domain socket directory, either omit the host
+ part of the URI and specify the host as a named parameter, or
+ percent-encode the path in the host part of the URI:
+
+postgresql:///dbname?host=/var/lib/postgresql
+postgresql://%2Fvar%2Flib%2Fpostgresql/dbname
+
+
+ It is possible to specify multiple host components, each with an optional
+ port component, in a single URI. A URI of the form
+ postgresql://host1:port1,host2:port2,host3:port3/
+ is equivalent to a connection string of the form
+ host=host1,host2,host3 port=port1,port2,port3.
+ As further described below, each
+ host will be tried in turn until a connection is successfully established.
+
34.1.1.3. Specifying Multiple Hosts #
+ It is possible to specify multiple hosts to connect to, so that they are
+ tried in the given order. In the Keyword/Value format, the host,
+ hostaddr, and port options accept comma-separated
+ lists of values. The same number of elements must be given in each
+ option that is specified, such
+ that e.g., the first hostaddr corresponds to the first host name,
+ the second hostaddr corresponds to the second host name, and so
+ forth. As an exception, if only one port is specified, it
+ applies to all the hosts.
+
+ In the connection URI format, you can list multiple host:port pairs
+ separated by commas in the host component of the URI.
+
+ In either format, a single host name can translate to multiple network
+ addresses. A common example of this is a host that has both an IPv4 and
+ an IPv6 address.
+
+ When multiple hosts are specified, or when a single host name is
+ translated to multiple addresses, all the hosts and addresses will be
+ tried in order, until one succeeds. If none of the hosts can be reached,
+ the connection fails. If a connection is established successfully, but
+ authentication fails, the remaining hosts in the list are not tried.
+
+ If a password file is used, you can have different passwords for
+ different hosts. All the other connection options are the same for every
+ host in the list; it is not possible to e.g., specify different
+ usernames for different hosts.
+
34.1.2. Parameter Key Words #
+ The currently recognized parameter key words are:
+
+
host #
+ Name of host to connect to. If a host name looks like an absolute path
+ name, it specifies Unix-domain communication rather than TCP/IP
+ communication; the value is the name of the directory in which the
+ socket file is stored. (On Unix, an absolute path name begins with a
+ slash. On Windows, paths starting with drive letters are also
+ recognized.) If the host name starts with @, it is
+ taken as a Unix-domain socket in the abstract namespace (currently
+ supported on Linux and Windows).
+ The default behavior when host is not
+ specified, or is empty, is to connect to a Unix-domain
+ socket in
+ /tmp (or whatever socket directory was specified
+ when PostgreSQL was built). On Windows,
+ the default is to connect to localhost.
+
+ A comma-separated list of host names is also accepted, in which case
+ each host name in the list is tried in order; an empty item in the
+ list selects the default behavior as explained above. See
+ Section 34.1.1.3 for details.
+
hostaddr #
+ Numeric IP address of host to connect to. This should be in the
+ standard IPv4 address format, e.g., 172.28.40.9. If
+ your machine supports IPv6, you can also use those addresses.
+ TCP/IP communication is
+ always used when a nonempty string is specified for this parameter.
+ If this parameter is not specified, the value of host
+ will be looked up to find the corresponding IP address — or, if
+ host specifies an IP address, that value will be
+ used directly.
+
+ Using hostaddr allows the
+ application to avoid a host name look-up, which might be important
+ in applications with time constraints. However, a host name is
+ required for GSSAPI or SSPI authentication
+ methods, as well as for verify-full SSL
+ certificate verification. The following rules are used:
+
+ If host is specified
+ without hostaddr, a host name lookup occurs.
+ (When using PQconnectPoll, the lookup occurs
+ when PQconnectPoll first considers this host
+ name, and it may cause PQconnectPoll to block
+ for a significant amount of time.)
+
+ If hostaddr is specified without host,
+ the value for hostaddr gives the server network address.
+ The connection attempt will fail if the authentication
+ method requires a host name.
+
+ If both host and hostaddr are specified,
+ the value for hostaddr gives the server network address.
+ The value for host is ignored unless the
+ authentication method requires it, in which case it will be
+ used as the host name.
+
+ Note that authentication is likely to fail if host
+ is not the name of the server at network address hostaddr.
+ Also, when both host and hostaddr
+ are specified, host
+ is used to identify the connection in a password file (see
+ Section 34.16).
+
+ A comma-separated list of hostaddr values is also
+ accepted, in which case each host in the list is tried in order.
+ An empty item in the list causes the corresponding host name to be
+ used, or the default host name if that is empty as well. See
+ Section 34.1.1.3 for details.
+
+ Without either a host name or host address,
+ libpq will connect using a local
+ Unix-domain socket; or on Windows, it will attempt to connect to
+ localhost.
+
port #
+ Port number to connect to at the server host, or socket file
+ name extension for Unix-domain
+ connections.
+ If multiple hosts were given in the host or
+ hostaddr parameters, this parameter may specify a
+ comma-separated list of ports of the same length as the host list, or
+ it may specify a single port number to be used for all hosts.
+ An empty string, or an empty item in a comma-separated list,
+ specifies the default port number established
+ when PostgreSQL was built.
+
dbname #
+ The database name. Defaults to be the same as the user name.
+ In certain contexts, the value is checked for extended
+ formats; see Section 34.1.1 for more details on
+ those.
+
user #
+ PostgreSQL user name to connect as.
+ Defaults to be the same as the operating system name of the user
+ running the application.
+
password #
+ Password to be used if the server demands password authentication.
+
passfile #
+ Specifies the name of the file used to store passwords
+ (see Section 34.16).
+ Defaults to ~/.pgpass, or
+ %APPDATA%\postgresql\pgpass.conf on Microsoft Windows.
+ (No error is reported if this file does not exist.)
+
require_auth #
+ Specifies the authentication method that the client requires from the
+ server. If the server does not use the required method to authenticate
+ the client, or if the authentication handshake is not fully completed by
+ the server, the connection will fail. A comma-separated list of methods
+ may also be provided, of which the server must use exactly one in order
+ for the connection to succeed. By default, any authentication method is
+ accepted, and the server is free to skip authentication altogether.
+
+ Methods may be negated with the addition of a !
+ prefix, in which case the server must not attempt
+ the listed method; any other method is accepted, and the server is free
+ not to authenticate the client at all. If a comma-separated list is
+ provided, the server may not attempt any of the
+ listed negated methods. Negated and non-negated forms may not be
+ combined in the same setting.
+
+ As a final special case, the none method requires the
+ server not to use an authentication challenge. (It may also be negated,
+ to require some form of authentication.)
+
+ The following methods may be specified:
+
+
password
+ The server must request plaintext password authentication.
+
md5
+ The server must request MD5 hashed password authentication.
+
gss
+ The server must either request a Kerberos handshake via
+ GSSAPI or establish a
+ GSS-encrypted channel (see also
+ gssencmode).
+
sspi
+ The server must request Windows SSPI
+ authentication.
+
scram-sha-256
+ The server must successfully complete a SCRAM-SHA-256 authentication
+ exchange with the client.
+
none
+ The server must not prompt the client for an authentication
+ exchange. (This does not prohibit client certificate authentication
+ via TLS, nor GSS authentication via its encrypted transport.)
+
+
channel_binding #
+ This option controls the client's use of channel binding. A setting
+ of require means that the connection must employ
+ channel binding, prefer means that the client will
+ choose channel binding if available, and disable
+ prevents the use of channel binding. The default
+ is prefer if
+ PostgreSQL is compiled with SSL support;
+ otherwise the default is disable.
+
+ Channel binding is a method for the server to authenticate itself to
+ the client. It is only supported over SSL connections
+ with PostgreSQL 11 or later servers using
+ the SCRAM authentication method.
+
connect_timeout #
+ Maximum time to wait while connecting, in seconds (write as a decimal integer,
+ e.g., 10). Zero, negative, or not specified means
+ wait indefinitely. The minimum allowed timeout is 2 seconds, therefore
+ a value of 1 is interpreted as 2.
+ This timeout applies separately to each host name or IP address.
+ For example, if you specify two hosts and connect_timeout
+ is 5, each host will time out if no connection is made within 5
+ seconds, so the total time spent waiting for a connection might be
+ up to 10 seconds.
+
client_encoding #
+ This sets the client_encoding
+ configuration parameter for this connection. In addition to
+ the values accepted by the corresponding server option, you
+ can use auto to determine the right
+ encoding from the current locale in the client
+ (LC_CTYPE environment variable on Unix
+ systems).
+
options #
+ Specifies command-line options to send to the server at connection
+ start. For example, setting this to -c geqo=off sets the
+ session's value of the geqo parameter to
+ off. Spaces within this string are considered to
+ separate command-line arguments, unless escaped with a backslash
+ (\); write \\ to represent a literal
+ backslash. For a detailed discussion of the available
+ options, consult Chapter 20.
+
application_name #
+ Specifies a value for the application_name
+ configuration parameter.
+
fallback_application_name #
+ Specifies a fallback value for the application_name configuration parameter.
+ This value will be used if no value has been given for
+ application_name via a connection parameter or the
+ PGAPPNAME environment variable. Specifying
+ a fallback name is useful in generic utility programs that
+ wish to set a default application name but allow it to be
+ overridden by the user.
+
keepalives #
+ Controls whether client-side TCP keepalives are used. The default
+ value is 1, meaning on, but you can change this to 0, meaning off,
+ if keepalives are not wanted. This parameter is ignored for
+ connections made via a Unix-domain socket.
+
keepalives_idle #
+ Controls the number of seconds of inactivity after which TCP should
+ send a keepalive message to the server. A value of zero uses the
+ system default. This parameter is ignored for connections made via a
+ Unix-domain socket, or if keepalives are disabled.
+ It is only supported on systems where TCP_KEEPIDLE or
+ an equivalent socket option is available, and on Windows; on other
+ systems, it has no effect.
+
keepalives_interval #
+ Controls the number of seconds after which a TCP keepalive message
+ that is not acknowledged by the server should be retransmitted. A
+ value of zero uses the system default. This parameter is ignored for
+ connections made via a Unix-domain socket, or if keepalives are disabled.
+ It is only supported on systems where TCP_KEEPINTVL or
+ an equivalent socket option is available, and on Windows; on other
+ systems, it has no effect.
+
keepalives_count #
+ Controls the number of TCP keepalives that can be lost before the
+ client's connection to the server is considered dead. A value of
+ zero uses the system default. This parameter is ignored for
+ connections made via a Unix-domain socket, or if keepalives are disabled.
+ It is only supported on systems where TCP_KEEPCNT or
+ an equivalent socket option is available; on other systems, it has no
+ effect.
+
tcp_user_timeout #
+ Controls the number of milliseconds that transmitted data may
+ remain unacknowledged before a connection is forcibly closed.
+ A value of zero uses the system default. This parameter is
+ ignored for connections made via a Unix-domain socket.
+ It is only supported on systems where TCP_USER_TIMEOUT
+ is available; on other systems, it has no effect.
+
replication #
+ This option determines whether the connection should use the
+ replication protocol instead of the normal protocol. This is what
+ PostgreSQL replication connections as well as tools such as
+ pg_basebackup use internally, but it can
+ also be used by third-party applications. For a description of the
+ replication protocol, consult Section 55.4.
+
+ The following values, which are case-insensitive, are supported:
+
-
+
true, on,
+ yes, 1
+
+ The connection goes into physical replication mode.
+
database
+ The connection goes into logical replication mode, connecting to
+ the database specified in the dbname parameter.
+
-
+
false, off,
+ no, 0
+
+ The connection is a regular one, which is the default behavior.
+
+
+ In physical or logical replication mode, only the simple query protocol
+ can be used.
+
gssencmode #
+ This option determines whether or with what priority a secure
+ GSS TCP/IP connection will be negotiated with the
+ server. There are three modes:
+
+
disable
+ only try a non-GSSAPI-encrypted connection
+
prefer (default)
+ if there are GSSAPI credentials present (i.e.,
+ in a credentials cache), first try
+ a GSSAPI-encrypted connection; if that fails or
+ there are no credentials, try a
+ non-GSSAPI-encrypted connection. This is the
+ default when PostgreSQL has been
+ compiled with GSSAPI support.
+
require
+ only try a GSSAPI-encrypted connection
+
+
+ gssencmode is ignored for Unix domain socket
+ communication. If PostgreSQL is compiled
+ without GSSAPI support, using the require option
+ will cause an error, while prefer will be accepted
+ but libpq will not actually attempt
+ a GSSAPI-encrypted
+ connection.
+
sslmode #
+ This option determines whether or with what priority a secure
+ SSL TCP/IP connection will be negotiated with the
+ server. There are six modes:
+
+
disable
+ only try a non-SSL connection
+
allow
+ first try a non-SSL connection; if that
+ fails, try an SSL connection
+
prefer (default)
+ first try an SSL connection; if that fails,
+ try a non-SSL connection
+
require
+ only try an SSL connection. If a root CA
+ file is present, verify the certificate in the same way as
+ if verify-ca was specified
+
verify-ca
+ only try an SSL connection, and verify that
+ the server certificate is issued by a trusted
+ certificate authority (CA)
+
verify-full
+ only try an SSL connection, verify that the
+ server certificate is issued by a
+ trusted CA and that the requested server host name
+ matches that in the certificate
+
+
+ See Section 34.19 for a detailed description of how
+ these options work.
+
+ sslmode is ignored for Unix domain socket
+ communication.
+ If PostgreSQL is compiled without SSL support,
+ using options require, verify-ca, or
+ verify-full will cause an error, while
+ options allow and prefer will be
+ accepted but libpq will not actually attempt
+ an SSL
+ connection.
+
+ Note that if GSSAPI encryption is possible,
+ that will be used in preference to SSL
+ encryption, regardless of the value of sslmode.
+ To force use of SSL encryption in an
+ environment that has working GSSAPI
+ infrastructure (such as a Kerberos server), also
+ set gssencmode to disable.
+
requiressl #
+ This option is deprecated in favor of the sslmode
+ setting.
+
+ If set to 1, an SSL connection to the server
+ is required (this is equivalent to sslmode
+ require). libpq will then refuse
+ to connect if the server does not accept an
+ SSL connection. If set to 0 (default),
+ libpq will negotiate the connection type with
+ the server (equivalent to sslmode
+ prefer). This option is only available if
+ PostgreSQL is compiled with SSL support.
+
sslcompression #
+ If set to 1, data sent over SSL connections will be compressed. If
+ set to 0, compression will be disabled. The default is 0. This
+ parameter is ignored if a connection without SSL is made.
+
+ SSL compression is nowadays considered insecure and its use is no
+ longer recommended. OpenSSL 1.1.0 disables
+ compression by default, and many operating system distributions
+ disable it in prior versions as well, so setting this parameter to on
+ will not have any effect if the server does not accept compression.
+ PostgreSQL 14 disables compression
+ completely in the backend.
+
+ If security is not a primary concern, compression can improve
+ throughput if the network is the bottleneck. Disabling compression
+ can improve response time and throughput if CPU performance is the
+ limiting factor.
+
sslcert #
+ This parameter specifies the file name of the client SSL
+ certificate, replacing the default
+ ~/.postgresql/postgresql.crt.
+ This parameter is ignored if an SSL connection is not made.
+
sslkey #
+ This parameter specifies the location for the secret key used for
+ the client certificate. It can either specify a file name that will
+ be used instead of the default
+ ~/.postgresql/postgresql.key, or it can specify a key
+ obtained from an external “engine” (engines are
+ OpenSSL loadable modules). An external engine
+ specification should consist of a colon-separated engine name and
+ an engine-specific key identifier. This parameter is ignored if an
+ SSL connection is not made.
+
sslpassword #
+ This parameter specifies the password for the secret key specified in
+ sslkey, allowing client certificate private keys
+ to be stored in encrypted form on disk even when interactive passphrase
+ input is not practical.
+
+ Specifying this parameter with any non-empty value suppresses the
+ Enter PEM pass phrase:
+ prompt that OpenSSL will emit by default
+ when an encrypted client certificate key is provided to
+ libpq.
+
+ If the key is not encrypted this parameter is ignored. The parameter
+ has no effect on keys specified by OpenSSL
+ engines unless the engine uses the OpenSSL
+ password callback mechanism for prompts.
+
+ There is no environment variable equivalent to this option, and no
+ facility for looking it up in .pgpass. It can be
+ used in a service file connection definition. Users with
+ more sophisticated uses should consider using OpenSSL engines and
+ tools like PKCS#11 or USB crypto offload devices.
+
sslcertmode #
+ This option determines whether a client certificate may be sent to the
+ server, and whether the server is required to request one. There are
+ three modes:
+
+
disable
+ A client certificate is never sent, even if one is available
+ (default location or provided via
+ sslcert).
+
allow (default)
+ A certificate may be sent, if the server requests one and the
+ client has one to send.
+
require
+ The server must request a certificate. The
+ connection will fail if the client does not send a certificate and
+ the server successfully authenticates the client anyway.
+
+
Note
+ sslcertmode=require doesn't add any additional
+ security, since there is no guarantee that the server is validating
+ the certificate correctly; PostgreSQL servers generally request TLS
+ certificates from clients whether they validate them or not. The
+ option may be useful when troubleshooting more complicated TLS
+ setups.
+
sslrootcert #
+ This parameter specifies the name of a file containing SSL
+ certificate authority (CA) certificate(s).
+ If the file exists, the server's certificate will be verified
+ to be signed by one of these authorities. The default is
+ ~/.postgresql/root.crt.
+
+ The special value system may be specified instead, in
+ which case the system's trusted CA roots will be loaded. The exact
+ locations of these root certificates differ by SSL implementation and
+ platform. For OpenSSL in particular, the
+ locations may be further modified by the SSL_CERT_DIR
+ and SSL_CERT_FILE environment variables.
+
Note
+ When using sslrootcert=system, the default
+ sslmode is changed to verify-full,
+ and any weaker setting will result in an error. In most cases it is
+ trivial for anyone to obtain a certificate trusted by the system for a
+ hostname they control, rendering verify-ca and all
+ weaker modes useless.
+
+ The magic system value will take precedence over a
+ local certificate file with the same name. If for some reason you find
+ yourself in this situation, use an alternative path like
+ sslrootcert=./system instead.
+
sslcrl #
+ This parameter specifies the file name of the SSL server certificate
+ revocation list (CRL). Certificates listed in this file, if it
+ exists, will be rejected while attempting to authenticate the
+ server's certificate. If neither
+ sslcrl nor
+ sslcrldir is set, this setting is
+ taken as
+ ~/.postgresql/root.crl.
+
sslcrldir #
+ This parameter specifies the directory name of the SSL server certificate
+ revocation list (CRL). Certificates listed in the files in this
+ directory, if it exists, will be rejected while attempting to
+ authenticate the server's certificate.
+
+ The directory needs to be prepared with the
+ OpenSSL command
+ openssl rehash or c_rehash. See
+ its documentation for details.
+
+ Both sslcrl and sslcrldir can be
+ specified together.
+
sslsni #
+ If set to 1 (default), libpq sets the TLS extension “Server Name
+ Indication” (SNI) on SSL-enabled connections.
+ By setting this parameter to 0, this is turned off.
+
+ The Server Name Indication can be used by SSL-aware proxies to route
+ connections without having to decrypt the SSL stream. (Note that this
+ requires a proxy that is aware of the PostgreSQL protocol handshake,
+ not just any SSL proxy.) However, SNI makes the
+ destination host name appear in cleartext in the network traffic, so
+ it might be undesirable in some cases.
+
requirepeer #
+ This parameter specifies the operating-system user name of the
+ server, for example requirepeer=postgres.
+ When making a Unix-domain socket connection, if this
+ parameter is set, the client checks at the beginning of the
+ connection that the server process is running under the specified
+ user name; if it is not, the connection is aborted with an error.
+ This parameter can be used to provide server authentication similar
+ to that available with SSL certificates on TCP/IP connections.
+ (Note that if the Unix-domain socket is in
+ /tmp or another publicly writable location,
+ any user could start a server listening there. Use this parameter
+ to ensure that you are connected to a server run by a trusted user.)
+ This option is only supported on platforms for which the
+ peer authentication method is implemented; see
+ Section 21.9.
+
ssl_min_protocol_version #
+ This parameter specifies the minimum SSL/TLS protocol version to allow
+ for the connection. Valid values are TLSv1,
+ TLSv1.1, TLSv1.2 and
+ TLSv1.3. The supported protocols depend on the
+ version of OpenSSL used, older versions
+ not supporting the most modern protocol versions. If not specified,
+ the default is TLSv1.2, which satisfies industry
+ best practices as of this writing.
+
ssl_max_protocol_version #
+ This parameter specifies the maximum SSL/TLS protocol version to allow
+ for the connection. Valid values are TLSv1,
+ TLSv1.1, TLSv1.2 and
+ TLSv1.3. The supported protocols depend on the
+ version of OpenSSL used, older versions
+ not supporting the most modern protocol versions. If not set, this
+ parameter is ignored and the connection will use the maximum bound
+ defined by the backend, if set. Setting the maximum protocol version
+ is mainly useful for testing or if some component has issues working
+ with a newer protocol.
+
krbsrvname #
+ Kerberos service name to use when authenticating with GSSAPI.
+ This must match the service name specified in the server
+ configuration for Kerberos authentication to succeed. (See also
+ Section 21.6.)
+ The default value is normally postgres,
+ but that can be changed when
+ building PostgreSQL via
+ the --with-krb-srvnam option
+ of configure.
+ In most environments, this parameter never needs to be changed.
+ Some Kerberos implementations might require a different service name,
+ such as Microsoft Active Directory which requires the service name
+ to be in upper case (POSTGRES).
+
gsslib #
+ GSS library to use for GSSAPI authentication.
+ Currently this is disregarded except on Windows builds that include
+ both GSSAPI and SSPI support. In that case, set
+ this to gssapi to cause libpq to use the GSSAPI
+ library for authentication instead of the default SSPI.
+
gssdelegation #
+ Forward (delegate) GSS credentials to the server. The default is
+ 0 which means credentials will not be forwarded
+ to the server. Set this to 1 to have credentials
+ forwarded when possible.
+
service #
+ Service name to use for additional parameters. It specifies a service
+ name in pg_service.conf that holds additional connection parameters.
+ This allows applications to specify only a service name so connection parameters
+ can be centrally maintained. See Section 34.17.
+
target_session_attrs #
+ This option determines whether the session must have certain
+ properties to be acceptable. It's typically used in combination
+ with multiple host names to select the first acceptable alternative
+ among several hosts. There are six modes:
+
+
any (default)
+ any successful connection is acceptable
+
read-write
+ session must accept read-write transactions by default (that
+ is, the server must not be in hot standby mode and
+ the default_transaction_read_only parameter
+ must be off)
+
read-only
+ session must not accept read-write transactions by default (the
+ converse)
+
primary
+ server must not be in hot standby mode
+
standby
+ server must be in hot standby mode
+
prefer-standby
+ first try to find a standby server, but if none of the listed
+ hosts is a standby server, try again in any
+ mode
+
+
load_balance_hosts #
+ Controls the order in which the client tries to connect to the available
+ hosts and addresses. Once a connection attempt is successful no other
+ hosts and addresses will be tried. This parameter is typically used in
+ combination with multiple host names or a DNS record that returns
+ multiple IPs. This parameter can be used in combination with
+ target_session_attrs
+ to, for example, load balance over standby servers only. Once successfully
+ connected, subsequent queries on the returned connection will all be
+ sent to the same server. There are currently two modes:
+
disable (default)
+ No load balancing across hosts is performed. Hosts are tried in
+ the order in which they are provided and addresses are tried in
+ the order they are received from DNS or a hosts file.
+
random
+ Hosts and addresses are tried in random order. This value is mostly
+ useful when opening multiple connections at the same time, possibly
+ from different machines. This way connections can be load balanced
+ across multiple PostgreSQL servers.
+
+ While random load balancing, due to its random nature, will almost
+ never result in a completely uniform distribution, it statistically
+ gets quite close. One important aspect here is that this algorithm
+ uses two levels of random choices: First the hosts
+ will be resolved in random order. Then secondly, before resolving
+ the next host, all resolved addresses for the current host will be
+ tried in random order. This behaviour can skew the amount of
+ connections each node gets greatly in certain cases, for instance
+ when some hosts resolve to more addresses than others. But such a
+ skew can also be used on purpose, e.g. to increase the number of
+ connections a larger server gets by providing its hostname multiple
+ times in the host string.
+
+ When using this value it's recommended to also configure a reasonable
+ value for connect_timeout. Because then,
+ if one of the nodes that are used for load balancing is not responding,
+ a new node will be tried.
+
+
+
34.11. Control Functions #
+ These functions control miscellaneous details of libpq's
+ behavior.
+
PQclientEncoding #
+ Returns the client encoding.
+
+int PQclientEncoding(const PGconn *conn);
+
+
+ Note that it returns the encoding ID, not a symbolic string
+ such as EUC_JP. If unsuccessful, it returns -1.
+ To convert an encoding ID to an encoding name, you
+ can use:
+
+
+char *pg_encoding_to_char(int encoding_id);
+
+
PQsetClientEncoding #
+ Sets the client encoding.
+
+int PQsetClientEncoding(PGconn *conn, const char *encoding);
+
+
+ conn is a connection to the server,
+ and encoding is the encoding you want to
+ use. If the function successfully sets the encoding, it returns 0,
+ otherwise -1. The current encoding for this connection can be
+ determined by using PQclientEncoding.
+
PQsetErrorVerbosity #
+ Determines the verbosity of messages returned by
+ PQerrorMessage and PQresultErrorMessage.
+
+typedef enum
+{
+ PQERRORS_TERSE,
+ PQERRORS_DEFAULT,
+ PQERRORS_VERBOSE,
+ PQERRORS_SQLSTATE
+} PGVerbosity;
+
+PGVerbosity PQsetErrorVerbosity(PGconn *conn, PGVerbosity verbosity);
+
+
+ PQsetErrorVerbosity sets the verbosity mode,
+ returning the connection's previous setting.
+ In TERSE mode, returned messages include
+ severity, primary text, and position only; this will normally fit on a
+ single line. The DEFAULT mode produces messages
+ that include the above plus any detail, hint, or context fields (these
+ might span multiple lines). The VERBOSE mode
+ includes all available fields. The SQLSTATE
+ mode includes only the error severity and the SQLSTATE
+ error code, if one is available (if not, the output is like
+ TERSE mode).
+
+ Changing the verbosity setting does not affect the messages available
+ from already-existing PGresult objects, only
+ subsequently-created ones.
+ (But see PQresultVerboseErrorMessage if you
+ want to print a previous error with a different verbosity.)
+
PQsetErrorContextVisibility #
+ Determines the handling of CONTEXT fields in messages
+ returned by PQerrorMessage
+ and PQresultErrorMessage.
+
+typedef enum
+{
+ PQSHOW_CONTEXT_NEVER,
+ PQSHOW_CONTEXT_ERRORS,
+ PQSHOW_CONTEXT_ALWAYS
+} PGContextVisibility;
+
+PGContextVisibility PQsetErrorContextVisibility(PGconn *conn, PGContextVisibility show_context);
+
+
+ PQsetErrorContextVisibility sets the context display mode,
+ returning the connection's previous setting. This mode controls
+ whether the CONTEXT field is included in messages.
+ The NEVER mode
+ never includes CONTEXT, while ALWAYS always
+ includes it if available. In ERRORS mode (the
+ default), CONTEXT fields are included only in error
+ messages, not in notices and warnings.
+ (However, if the verbosity setting is TERSE
+ or SQLSTATE, CONTEXT fields
+ are omitted regardless of the context display mode.)
+
+ Changing this mode does not
+ affect the messages available from
+ already-existing PGresult objects, only
+ subsequently-created ones.
+ (But see PQresultVerboseErrorMessage if you
+ want to print a previous error with a different display mode.)
+
PQtrace #
+ Enables tracing of the client/server communication to a debugging file
+ stream.
+
+void PQtrace(PGconn *conn, FILE *stream);
+
+
+ Each line consists of: an optional timestamp, a direction indicator
+ (F for messages from client to server
+ or B for messages from server to client),
+ message length, message type, and message contents.
+ Non-message contents fields (timestamp, direction, length and message type)
+ are separated by a tab. Message contents are separated by a space.
+ Protocol strings are enclosed in double quotes, while strings used as data
+ values are enclosed in single quotes. Non-printable chars are printed as
+ hexadecimal escapes.
+ Further message-type-specific detail can be found in
+ Section 55.7.
+
Note
+ On Windows, if the libpq library and an application are
+ compiled with different flags, this function call will crash the
+ application because the internal representation of the FILE
+ pointers differ. Specifically, multithreaded/single-threaded,
+ release/debug, and static/dynamic flags should be the same for the
+ library and all applications using that library.
+
PQsetTraceFlags #
+ Controls the tracing behavior of client/server communication.
+
+void PQsetTraceFlags(PGconn *conn, int flags);
+
+
+ flags contains flag bits describing the operating mode
+ of tracing.
+ If flags contains PQTRACE_SUPPRESS_TIMESTAMPS,
+ then the timestamp is not included when printing each message.
+ If flags contains PQTRACE_REGRESS_MODE,
+ then some fields are redacted when printing each message, such as object
+ OIDs, to make the output more convenient to use in testing frameworks.
+ This function must be called after calling PQtrace.
+
PQuntrace #
+ Disables tracing started by PQtrace.
+
+void PQuntrace(PGconn *conn);
+
+
34.10. Functions Associated with the COPY Command #
+ The COPY command in
+ PostgreSQL has options to read from or write
+ to the network connection used by libpq.
+ The functions described in this section allow applications to take
+ advantage of this capability by supplying or consuming copied data.
+
+ The overall process is that the application first issues the SQL
+ COPY command via PQexec or one
+ of the equivalent functions. The response to this (if there is no
+ error in the command) will be a PGresult object bearing
+ a status code of PGRES_COPY_OUT or
+ PGRES_COPY_IN (depending on the specified copy
+ direction). The application should then use the functions of this
+ section to receive or transmit data rows. When the data transfer is
+ complete, another PGresult object is returned to indicate
+ success or failure of the transfer. Its status will be
+ PGRES_COMMAND_OK for success or
+ PGRES_FATAL_ERROR if some problem was encountered.
+ At this point further SQL commands can be issued via
+ PQexec. (It is not possible to execute other SQL
+ commands using the same connection while the COPY
+ operation is in progress.)
+
+ If a COPY command is issued via
+ PQexec in a string that could contain additional
+ commands, the application must continue fetching results via
+ PQgetResult after completing the COPY
+ sequence. Only when PQgetResult returns
+ NULL is it certain that the PQexec
+ command string is done and it is safe to issue more commands.
+
+ The functions of this section should be executed only after obtaining
+ a result status of PGRES_COPY_OUT or
+ PGRES_COPY_IN from PQexec or
+ PQgetResult.
+
+ A PGresult object bearing one of these status values
+ carries some additional data about the COPY operation
+ that is starting. This additional data is available using functions
+ that are also used in connection with query results:
+
+
PQnfields #
+ Returns the number of columns (fields) to be copied.
+
PQbinaryTuples #
+ 0 indicates the overall copy format is textual (rows separated by
+ newlines, columns separated by separator characters, etc.). 1
+ indicates the overall copy format is binary. See COPY for more information.
+
PQfformat #
+ Returns the format code (0 for text, 1 for binary) associated with
+ each column of the copy operation. The per-column format codes
+ will always be zero when the overall copy format is textual, but
+ the binary format can support both text and binary columns.
+ (However, as of the current implementation of COPY,
+ only binary columns appear in a binary copy; so the per-column
+ formats always match the overall format at present.)
+
+
34.10.1. Functions for Sending COPY Data #
+ These functions are used to send data during COPY FROM
+ STDIN. They will fail if called when the connection is not in
+ COPY_IN state.
+
PQputCopyData #
+ Sends data to the server during COPY_IN state.
+
+int PQputCopyData(PGconn *conn,
+ const char *buffer,
+ int nbytes);
+
+
+ Transmits the COPY data in the specified
+ buffer, of length nbytes, to the server.
+ The result is 1 if the data was queued, zero if it was not queued
+ because of full buffers (this will only happen in nonblocking mode),
+ or -1 if an error occurred.
+ (Use PQerrorMessage to retrieve details if
+ the return value is -1. If the value is zero, wait for write-ready
+ and try again.)
+
+ The application can divide the COPY data stream
+ into buffer loads of any convenient size. Buffer-load boundaries
+ have no semantic significance when sending. The contents of the
+ data stream must match the data format expected by the
+ COPY command; see COPY for details.
+
PQputCopyEnd #
+ Sends end-of-data indication to the server during COPY_IN state.
+
+int PQputCopyEnd(PGconn *conn,
+ const char *errormsg);
+
+
+ Ends the COPY_IN operation successfully if
+ errormsg is NULL. If
+ errormsg is not NULL then the
+ COPY is forced to fail, with the string pointed to by
+ errormsg used as the error message. (One should not
+ assume that this exact error message will come back from the server,
+ however, as the server might have already failed the
+ COPY for its own reasons.)
+
+ The result is 1 if the termination message was sent; or in
+ nonblocking mode, this may only indicate that the termination
+ message was successfully queued. (In nonblocking mode, to be
+ certain that the data has been sent, you should next wait for
+ write-ready and call PQflush, repeating until it
+ returns zero.) Zero indicates that the function could not queue
+ the termination message because of full buffers; this will only
+ happen in nonblocking mode. (In this case, wait for
+ write-ready and try the PQputCopyEnd call
+ again.) If a hard error occurs, -1 is returned; you can use
+ PQerrorMessage to retrieve details.
+
+ After successfully calling PQputCopyEnd, call
+ PQgetResult to obtain the final result status of the
+ COPY command. One can wait for this result to be
+ available in the usual way. Then return to normal operation.
+
34.10.2. Functions for Receiving COPY Data #
+ These functions are used to receive data during COPY TO
+ STDOUT. They will fail if called when the connection is not in
+ COPY_OUT state.
+
PQgetCopyData #
+ Receives data from the server during COPY_OUT state.
+
+int PQgetCopyData(PGconn *conn,
+ char **buffer,
+ int async);
+
+
+ Attempts to obtain another row of data from the server during a
+ COPY. Data is always returned one data row at
+ a time; if only a partial row is available, it is not returned.
+ Successful return of a data row involves allocating a chunk of
+ memory to hold the data. The buffer parameter must
+ be non-NULL. *buffer is set to
+ point to the allocated memory, or to NULL in cases
+ where no buffer is returned. A non-NULL result
+ buffer should be freed using PQfreemem when no longer
+ needed.
+
+ When a row is successfully returned, the return value is the number
+ of data bytes in the row (this will always be greater than zero).
+ The returned string is always null-terminated, though this is
+ probably only useful for textual COPY. A result
+ of zero indicates that the COPY is still in
+ progress, but no row is yet available (this is only possible when
+ async is true). A result of -1 indicates that the
+ COPY is done. A result of -2 indicates that an
+ error occurred (consult PQerrorMessage for the reason).
+
+ When async is true (not zero),
+ PQgetCopyData will not block waiting for input; it
+ will return zero if the COPY is still in progress
+ but no complete row is available. (In this case wait for read-ready
+ and then call PQconsumeInput
+ before calling
+ PQgetCopyData again.) When async is
+ false (zero), PQgetCopyData will block until data is
+ available or the operation completes.
+
+ After PQgetCopyData returns -1, call
+ PQgetResult to obtain the final result status of the
+ COPY command. One can wait for this result to be
+ available in the usual way. Then return to normal operation.
+
34.10.3. Obsolete Functions for COPY #
+ These functions represent older methods of handling COPY.
+ Although they still work, they are deprecated due to poor error handling,
+ inconvenient methods of detecting end-of-data, and lack of support for binary
+ or nonblocking transfers.
+
PQgetline #
+ Reads a newline-terminated line of characters (transmitted
+ by the server) into a buffer string of size length.
+
+int PQgetline(PGconn *conn,
+ char *buffer,
+ int length);
+
+
+ This function copies up to length-1 characters into
+ the buffer and converts the terminating newline into a zero byte.
+ PQgetline returns EOF at the
+ end of input, 0 if the entire line has been read, and 1 if the
+ buffer is full but the terminating newline has not yet been read.
+
+ Note that the application must check to see if a new line consists
+ of the two characters \., which indicates
+ that the server has finished sending the results of the
+ COPY command. If the application might receive
+ lines that are more than length-1 characters long,
+ care is needed to be sure it recognizes the \.
+ line correctly (and does not, for example, mistake the end of a
+ long data line for a terminator line).
+
PQgetlineAsync #
+ Reads a row of COPY data (transmitted by the
+ server) into a buffer without blocking.
+
+int PQgetlineAsync(PGconn *conn,
+ char *buffer,
+ int bufsize);
+
+
+ This function is similar to PQgetline, but it can be used
+ by applications
+ that must read COPY data asynchronously, that is, without blocking.
+ Having issued the COPY command and gotten a PGRES_COPY_OUT
+ response, the
+ application should call PQconsumeInput
+ and
+ PQgetlineAsync until the
+ end-of-data signal is detected.
+
+ Unlike PQgetline, this function takes
+ responsibility for detecting end-of-data.
+
+ On each call, PQgetlineAsync will return data if a
+ complete data row is available in libpq's input buffer.
+ Otherwise, no data is returned until the rest of the row arrives.
+ The function returns -1 if the end-of-copy-data marker has been recognized,
+ or 0 if no data is available, or a positive number giving the number of
+ bytes of data returned. If -1 is returned, the caller must next call
+ PQendcopy, and then return to normal processing.
+
+ The data returned will not extend beyond a data-row boundary. If possible
+ a whole row will be returned at one time. But if the buffer offered by
+ the caller is too small to hold a row sent by the server, then a partial
+ data row will be returned. With textual data this can be detected by testing
+ whether the last returned byte is \n or not. (In a binary
+ COPY, actual parsing of the COPY data format will be needed to make the
+ equivalent determination.)
+ The returned string is not null-terminated. (If you want to add a
+ terminating null, be sure to pass a bufsize one smaller
+ than the room actually available.)
+
PQputline #
+ Sends a null-terminated string to the server. Returns 0 if
+ OK and EOF if unable to send the string.
+
+int PQputline(PGconn *conn,
+ const char *string);
+
+
+ The COPY data stream sent by a series of calls
+ to PQputline has the same format as that
+ returned by PQgetlineAsync, except that
+ applications are not obliged to send exactly one data row per
+ PQputline call; it is okay to send a partial
+ line or multiple lines per call.
+
Note
+ Before PostgreSQL protocol 3.0, it was necessary
+ for the application to explicitly send the two characters
+ \. as a final line to indicate to the server that it had
+ finished sending COPY data. While this still works, it is deprecated and the
+ special meaning of \. can be expected to be removed in a
+ future release. It is sufficient to call PQendcopy after
+ having sent the actual data.
+
PQputnbytes #
+ Sends a non-null-terminated string to the server. Returns
+ 0 if OK and EOF if unable to send the string.
+
+int PQputnbytes(PGconn *conn,
+ const char *buffer,
+ int nbytes);
+
+
+ This is exactly like PQputline, except that the data
+ buffer need not be null-terminated since the number of bytes to send is
+ specified directly. Use this procedure when sending binary data.
+
PQendcopy #
+ Synchronizes with the server.
+
+int PQendcopy(PGconn *conn);
+
+ This function waits until the server has finished the copying.
+ It should either be issued when the last string has been sent
+ to the server using PQputline or when the
+ last string has been received from the server using
+ PQgetline. It must be issued or the server
+ will get “out of sync” with the client. Upon return
+ from this function, the server is ready to receive the next SQL
+ command. The return value is 0 on successful completion,
+ nonzero otherwise. (Use PQerrorMessage to
+ retrieve details if the return value is nonzero.)
+
+ When using PQgetResult, the application should
+ respond to a PGRES_COPY_OUT result by executing
+ PQgetline repeatedly, followed by
+ PQendcopy after the terminator line is seen.
+ It should then return to the PQgetResult loop
+ until PQgetResult returns a null pointer.
+ Similarly a PGRES_COPY_IN result is processed
+ by a series of PQputline calls followed by
+ PQendcopy, then return to the
+ PQgetResult loop. This arrangement will
+ ensure that a COPY command embedded in a series
+ of SQL commands will be executed correctly.
+
+ Older applications are likely to submit a COPY
+ via PQexec and assume that the transaction
+ is done after PQendcopy. This will work
+ correctly only if the COPY is the only
+ SQL command in the command string.
+
34.15. Environment Variables #
+ The following environment variables can be used to select default
+ connection parameter values, which will be used by
+ PQconnectdb, PQsetdbLogin and
+ PQsetdb if no value is directly specified by the calling
+ code. These are useful to avoid hard-coding database connection
+ information into simple client applications, for example.
+
+
+
+ PGHOST behaves the same as the host connection parameter.
+
+
+ PGHOSTADDR behaves the same as the hostaddr connection parameter.
+ This can be set instead of or in addition to PGHOST
+ to avoid DNS lookup overhead.
+
+
+ PGPORT behaves the same as the port connection parameter.
+
+
+ PGDATABASE behaves the same as the dbname connection parameter.
+
+
+ PGUSER behaves the same as the user connection parameter.
+
+
+ PGPASSWORD behaves the same as the password connection parameter.
+ Use of this environment variable
+ is not recommended for security reasons, as some operating systems
+ allow non-root users to see process environment variables via
+ ps; instead consider using a password file
+ (see Section 34.16).
+
+
+ PGPASSFILE behaves the same as the passfile connection parameter.
+
+
+ PGREQUIREAUTH behaves the same as the require_auth connection parameter.
+
+
+ PGCHANNELBINDING behaves the same as the channel_binding connection parameter.
+
+
+ PGSERVICE behaves the same as the service connection parameter.
+
+
+ PGSERVICEFILE specifies the name of the per-user
+ connection service file
+ (see Section 34.17).
+ Defaults to ~/.pg_service.conf, or
+ %APPDATA%\postgresql\.pg_service.conf on
+ Microsoft Windows.
+
+
+ PGOPTIONS behaves the same as the options connection parameter.
+
+
+ PGAPPNAME behaves the same as the application_name connection parameter.
+
+
+ PGSSLMODE behaves the same as the sslmode connection parameter.
+
+
+ PGREQUIRESSL behaves the same as the requiressl connection parameter.
+ This environment variable is deprecated in favor of the
+ PGSSLMODE variable; setting both variables suppresses the
+ effect of this one.
+
+
+ PGSSLCOMPRESSION behaves the same as the sslcompression connection parameter.
+
+
+ PGSSLCERT behaves the same as the sslcert connection parameter.
+
+
+ PGSSLKEY behaves the same as the sslkey connection parameter.
+
+
+ PGSSLCERTMODE behaves the same as the sslcertmode connection parameter.
+
+
+ PGSSLROOTCERT behaves the same as the sslrootcert connection parameter.
+
+
+ PGSSLCRL behaves the same as the sslcrl connection parameter.
+
+
+ PGSSLCRLDIR behaves the same as the sslcrldir connection parameter.
+
+
+ PGSSLSNI behaves the same as the sslsni connection parameter.
+
+
+ PGREQUIREPEER behaves the same as the requirepeer connection parameter.
+
+
+ PGSSLMINPROTOCOLVERSION behaves the same as the ssl_min_protocol_version connection parameter.
+
+
+ PGSSLMAXPROTOCOLVERSION behaves the same as the ssl_max_protocol_version connection parameter.
+
+
+ PGGSSENCMODE behaves the same as the gssencmode connection parameter.
+
+
+ PGKRBSRVNAME behaves the same as the krbsrvname connection parameter.
+
+
+ PGGSSLIB behaves the same as the gsslib connection parameter.
+
+
+ PGGSSDELEGATION behaves the same as the gssdelegation connection parameter.
+
+
+ PGCONNECT_TIMEOUT behaves the same as the connect_timeout connection parameter.
+
+
+ PGCLIENTENCODING behaves the same as the client_encoding connection parameter.
+
+
+ PGTARGETSESSIONATTRS behaves the same as the target_session_attrs connection parameter.
+
+
+ PGLOADBALANCEHOSTS behaves the same as the load_balance_hosts connection parameter.
+
+
+ The following environment variables can be used to specify default
+ behavior for each PostgreSQL session. (See
+ also the ALTER ROLE
+ and ALTER DATABASE
+ commands for ways to set default behavior on a per-user or per-database
+ basis.)
+
+
+
+ PGDATESTYLE sets the default style of date/time
+ representation. (Equivalent to SET datestyle TO
+ ....)
+
+
+ PGTZ sets the default time zone. (Equivalent to
+ SET timezone TO ....)
+
+
+ PGGEQO sets the default mode for the genetic query
+ optimizer. (Equivalent to SET geqo TO ....)
+
+
+ Refer to the SQL command SET
+ for information on correct values for these
+ environment variables.
+
+ The following environment variables determine internal behavior of
+ libpq; they override compiled-in defaults.
+
+
+
+ PGSYSCONFDIR sets the directory containing the
+ pg_service.conf file and in a future version
+ possibly other system-wide configuration files.
+
+
+ PGLOCALEDIR sets the directory containing the
+ locale files for message localization.
+
+
+ libpq's event system is designed to notify
+ registered event handlers about interesting
+ libpq events, such as the creation or
+ destruction of PGconn and
+ PGresult objects. A principal use case is that
+ this allows applications to associate their own data with a
+ PGconn or PGresult
+ and ensure that that data is freed at an appropriate time.
+
+ Each registered event handler is associated with two pieces of data,
+ known to libpq only as opaque void *
+ pointers. There is a pass-through pointer that is provided
+ by the application when the event handler is registered with a
+ PGconn. The pass-through pointer never changes for the
+ life of the PGconn and all PGresults
+ generated from it; so if used, it must point to long-lived data.
+ In addition there is an instance data pointer, which starts
+ out NULL in every PGconn and PGresult.
+ This pointer can be manipulated using the
+ PQinstanceData,
+ PQsetInstanceData,
+ PQresultInstanceData and
+ PQresultSetInstanceData functions. Note that
+ unlike the pass-through pointer, instance data of a PGconn
+ is not automatically inherited by PGresults created from
+ it. libpq does not know what pass-through
+ and instance data pointers point to (if anything) and will never attempt
+ to free them — that is the responsibility of the event handler.
+
+ The enum PGEventId names the types of events handled by
+ the event system. All its values have names beginning with
+ PGEVT. For each event type, there is a corresponding
+ event info structure that carries the parameters passed to the event
+ handlers. The event types are:
+
PGEVT_REGISTER #
+ The register event occurs when PQregisterEventProc
+ is called. It is the ideal time to initialize any
+ instanceData an event procedure may need. Only one
+ register event will be fired per event handler per connection. If the
+ event procedure fails (returns zero), the registration is cancelled.
+
+
+typedef struct
+{
+ PGconn *conn;
+} PGEventRegister;
+
+
+ When a PGEVT_REGISTER event is received, the
+ evtInfo pointer should be cast to a
+ PGEventRegister *. This structure contains a
+ PGconn that should be in the
+ CONNECTION_OK status; guaranteed if one calls
+ PQregisterEventProc right after obtaining a good
+ PGconn. When returning a failure code, all
+ cleanup must be performed as no PGEVT_CONNDESTROY
+ event will be sent.
+
PGEVT_CONNRESET #
+ The connection reset event is fired on completion of
+ PQreset or PQresetPoll. In
+ both cases, the event is only fired if the reset was successful.
+ The return value of the event procedure is ignored
+ in PostgreSQL v15 and later.
+ With earlier versions, however, it's important to return success
+ (nonzero) or the connection will be aborted.
+
+
+typedef struct
+{
+ PGconn *conn;
+} PGEventConnReset;
+
+
+ When a PGEVT_CONNRESET event is received, the
+ evtInfo pointer should be cast to a
+ PGEventConnReset *. Although the contained
+ PGconn was just reset, all event data remains
+ unchanged. This event should be used to reset/reload/requery any
+ associated instanceData. Note that even if the
+ event procedure fails to process PGEVT_CONNRESET, it will
+ still receive a PGEVT_CONNDESTROY event when the connection
+ is closed.
+
PGEVT_CONNDESTROY #
+ The connection destroy event is fired in response to
+ PQfinish. It is the event procedure's
+ responsibility to properly clean up its event data as libpq has no
+ ability to manage this memory. Failure to clean up will lead
+ to memory leaks.
+
+
+typedef struct
+{
+ PGconn *conn;
+} PGEventConnDestroy;
+
+
+ When a PGEVT_CONNDESTROY event is received, the
+ evtInfo pointer should be cast to a
+ PGEventConnDestroy *. This event is fired
+ prior to PQfinish performing any other cleanup.
+ The return value of the event procedure is ignored since there is no
+ way of indicating a failure from PQfinish. Also,
+ an event procedure failure should not abort the process of cleaning up
+ unwanted memory.
+
PGEVT_RESULTCREATE #
+ The result creation event is fired in response to any query execution
+ function that generates a result, including
+ PQgetResult. This event will only be fired after
+ the result has been created successfully.
+
+
+typedef struct
+{
+ PGconn *conn;
+ PGresult *result;
+} PGEventResultCreate;
+
+
+ When a PGEVT_RESULTCREATE event is received, the
+ evtInfo pointer should be cast to a
+ PGEventResultCreate *. The
+ conn is the connection used to generate the
+ result. This is the ideal place to initialize any
+ instanceData that needs to be associated with the
+ result. If an event procedure fails (returns zero), that event
+ procedure will be ignored for the remaining lifetime of the result;
+ that is, it will not receive PGEVT_RESULTCOPY
+ or PGEVT_RESULTDESTROY events for this result or
+ results copied from it.
+
PGEVT_RESULTCOPY #
+ The result copy event is fired in response to
+ PQcopyResult. This event will only be fired after
+ the copy is complete. Only event procedures that have
+ successfully handled the PGEVT_RESULTCREATE
+ or PGEVT_RESULTCOPY event for the source result
+ will receive PGEVT_RESULTCOPY events.
+
+
+typedef struct
+{
+ const PGresult *src;
+ PGresult *dest;
+} PGEventResultCopy;
+
+
+ When a PGEVT_RESULTCOPY event is received, the
+ evtInfo pointer should be cast to a
+ PGEventResultCopy *. The
+ src result is what was copied while the
+ dest result is the copy destination. This event
+ can be used to provide a deep copy of instanceData,
+ since PQcopyResult cannot do that. If an event
+ procedure fails (returns zero), that event procedure will be
+ ignored for the remaining lifetime of the new result; that is, it
+ will not receive PGEVT_RESULTCOPY
+ or PGEVT_RESULTDESTROY events for that result or
+ results copied from it.
+
PGEVT_RESULTDESTROY #
+ The result destroy event is fired in response to a
+ PQclear. It is the event procedure's
+ responsibility to properly clean up its event data as libpq has no
+ ability to manage this memory. Failure to clean up will lead
+ to memory leaks.
+
+
+typedef struct
+{
+ PGresult *result;
+} PGEventResultDestroy;
+
+
+ When a PGEVT_RESULTDESTROY event is received, the
+ evtInfo pointer should be cast to a
+ PGEventResultDestroy *. This event is fired
+ prior to PQclear performing any other cleanup.
+ The return value of the event procedure is ignored since there is no
+ way of indicating a failure from PQclear. Also,
+ an event procedure failure should not abort the process of cleaning up
+ unwanted memory.
+
34.14.2. Event Callback Procedure #
PGEventProc #
+ PGEventProc is a typedef for a pointer to an
+ event procedure, that is, the user callback function that receives
+ events from libpq. The signature of an event procedure must be
+
+
+int eventproc(PGEventId evtId, void *evtInfo, void *passThrough)
+
+
+ The evtId parameter indicates which
+ PGEVT event occurred. The
+ evtInfo pointer must be cast to the appropriate
+ structure type to obtain further information about the event.
+ The passThrough parameter is the pointer
+ provided to PQregisterEventProc when the event
+ procedure was registered. The function should return a non-zero value
+ if it succeeds and zero if it fails.
+
+ A particular event procedure can be registered only once in any
+ PGconn. This is because the address of the procedure
+ is used as a lookup key to identify the associated instance data.
+
Caution
+ On Windows, functions can have two different addresses: one visible
+ from outside a DLL and another visible from inside the DLL. One
+ should be careful that only one of these addresses is used with
+ libpq's event-procedure functions, else confusion will
+ result. The simplest rule for writing code that will work is to
+ ensure that event procedures are declared static. If the
+ procedure's address must be available outside its own source file,
+ expose a separate function to return the address.
+
34.14.3. Event Support Functions #
PQregisterEventProc #
+ Registers an event callback procedure with libpq.
+
+
+int PQregisterEventProc(PGconn *conn, PGEventProc proc,
+ const char *name, void *passThrough);
+
+
+ An event procedure must be registered once on each
+ PGconn you want to receive events about. There is no
+ limit, other than memory, on the number of event procedures that
+ can be registered with a connection. The function returns a non-zero
+ value if it succeeds and zero if it fails.
+
+ The proc argument will be called when a libpq
+ event is fired. Its memory address is also used to lookup
+ instanceData. The name
+ argument is used to refer to the event procedure in error messages.
+ This value cannot be NULL or a zero-length string. The name string is
+ copied into the PGconn, so what is passed need not be
+ long-lived. The passThrough pointer is passed
+ to the proc whenever an event occurs. This
+ argument can be NULL.
+
PQsetInstanceData #
+ Sets the connection conn's instanceData
+ for procedure proc to data. This
+ returns non-zero for success and zero for failure. (Failure is
+ only possible if proc has not been properly
+ registered in conn.)
+
+
+int PQsetInstanceData(PGconn *conn, PGEventProc proc, void *data);
+
+
PQinstanceData #
+ Returns the
+ connection conn's instanceData
+ associated with procedure proc,
+ or NULL if there is none.
+
+
+void *PQinstanceData(const PGconn *conn, PGEventProc proc);
+
+
PQresultSetInstanceData #
+ Sets the result's instanceData
+ for proc to data. This returns
+ non-zero for success and zero for failure. (Failure is only
+ possible if proc has not been properly registered
+ in the result.)
+
+
+int PQresultSetInstanceData(PGresult *res, PGEventProc proc, void *data);
+
+
+ Beware that any storage represented by data
+ will not be accounted for by PQresultMemorySize,
+ unless it is allocated using PQresultAlloc.
+ (Doing so is recommendable because it eliminates the need to free
+ such storage explicitly when the result is destroyed.)
+
PQresultInstanceData #
+ Returns the result's instanceData associated with proc, or NULL
+ if there is none.
+
+
+void *PQresultInstanceData(const PGresult *res, PGEventProc proc);
+
+
+ Here is a skeleton example of managing private data associated with
+ libpq connections and results.
+
+
+/* required header for libpq events (note: includes libpq-fe.h) */
+#include <libpq-events.h>
+
+/* The instanceData */
+typedef struct
+{
+ int n;
+ char *str;
+} mydata;
+
+/* PGEventProc */
+static int myEventProc(PGEventId evtId, void *evtInfo, void *passThrough);
+
+int
+main(void)
+{
+ mydata *data;
+ PGresult *res;
+ PGconn *conn =
+ PQconnectdb("dbname=postgres options=-csearch_path=");
+
+ if (PQstatus(conn) != CONNECTION_OK)
+ {
+ /* PQerrorMessage's result includes a trailing newline */
+ fprintf(stderr, "%s", PQerrorMessage(conn));
+ PQfinish(conn);
+ return 1;
+ }
+
+ /* called once on any connection that should receive events.
+ * Sends a PGEVT_REGISTER to myEventProc.
+ */
+ if (!PQregisterEventProc(conn, myEventProc, "mydata_proc", NULL))
+ {
+ fprintf(stderr, "Cannot register PGEventProc\n");
+ PQfinish(conn);
+ return 1;
+ }
+
+ /* conn instanceData is available */
+ data = PQinstanceData(conn, myEventProc);
+
+ /* Sends a PGEVT_RESULTCREATE to myEventProc */
+ res = PQexec(conn, "SELECT 1 + 1");
+
+ /* result instanceData is available */
+ data = PQresultInstanceData(res, myEventProc);
+
+ /* If PG_COPYRES_EVENTS is used, sends a PGEVT_RESULTCOPY to myEventProc */
+ res_copy = PQcopyResult(res, PG_COPYRES_TUPLES | PG_COPYRES_EVENTS);
+
+ /* result instanceData is available if PG_COPYRES_EVENTS was
+ * used during the PQcopyResult call.
+ */
+ data = PQresultInstanceData(res_copy, myEventProc);
+
+ /* Both clears send a PGEVT_RESULTDESTROY to myEventProc */
+ PQclear(res);
+ PQclear(res_copy);
+
+ /* Sends a PGEVT_CONNDESTROY to myEventProc */
+ PQfinish(conn);
+
+ return 0;
+}
+
+static int
+myEventProc(PGEventId evtId, void *evtInfo, void *passThrough)
+{
+ switch (evtId)
+ {
+ case PGEVT_REGISTER:
+ {
+ PGEventRegister *e = (PGEventRegister *)evtInfo;
+ mydata *data = get_mydata(e->conn);
+
+ /* associate app specific data with connection */
+ PQsetInstanceData(e->conn, myEventProc, data);
+ break;
+ }
+
+ case PGEVT_CONNRESET:
+ {
+ PGEventConnReset *e = (PGEventConnReset *)evtInfo;
+ mydata *data = PQinstanceData(e->conn, myEventProc);
+
+ if (data)
+ memset(data, 0, sizeof(mydata));
+ break;
+ }
+
+ case PGEVT_CONNDESTROY:
+ {
+ PGEventConnDestroy *e = (PGEventConnDestroy *)evtInfo;
+ mydata *data = PQinstanceData(e->conn, myEventProc);
+
+ /* free instance data because the conn is being destroyed */
+ if (data)
+ free_mydata(data);
+ break;
+ }
+
+ case PGEVT_RESULTCREATE:
+ {
+ PGEventResultCreate *e = (PGEventResultCreate *)evtInfo;
+ mydata *conn_data = PQinstanceData(e->conn, myEventProc);
+ mydata *res_data = dup_mydata(conn_data);
+
+ /* associate app specific data with result (copy it from conn) */
+ PQresultSetInstanceData(e->result, myEventProc, res_data);
+ break;
+ }
+
+ case PGEVT_RESULTCOPY:
+ {
+ PGEventResultCopy *e = (PGEventResultCopy *)evtInfo;
+ mydata *src_data = PQresultInstanceData(e->src, myEventProc);
+ mydata *dest_data = dup_mydata(src_data);
+
+ /* associate app specific data with result (copy it from a result) */
+ PQresultSetInstanceData(e->dest, myEventProc, dest_data);
+ break;
+ }
+
+ case PGEVT_RESULTDESTROY:
+ {
+ PGEventResultDestroy *e = (PGEventResultDestroy *)evtInfo;
+ mydata *data = PQresultInstanceData(e->result, myEventProc);
+
+ /* free instance data because the result is being destroyed */
+ if (data)
+ free_mydata(data);
+ break;
+ }
+
+ /* unknown event ID, just return true. */
+ default:
+ break;
+ }
+
+ return true; /* event processing succeeded */
+}
+
+34.22. Example Programs #
+ These examples and others can be found in the
+ directory src/test/examples in the source code
+ distribution.
+
Example 34.1. libpq Example Program 1
+
+/*
+ * src/test/examples/testlibpq.c
+ *
+ *
+ * testlibpq.c
+ *
+ * Test the C version of libpq, the PostgreSQL frontend library.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include "libpq-fe.h"
+
+static void
+exit_nicely(PGconn *conn)
+{
+ PQfinish(conn);
+ exit(1);
+}
+
+int
+main(int argc, char **argv)
+{
+ const char *conninfo;
+ PGconn *conn;
+ PGresult *res;
+ int nFields;
+ int i,
+ j;
+
+ /*
+ * If the user supplies a parameter on the command line, use it as the
+ * conninfo string; otherwise default to setting dbname=postgres and using
+ * environment variables or defaults for all other connection parameters.
+ */
+ if (argc > 1)
+ conninfo = argv[1];
+ else
+ conninfo = "dbname = postgres";
+
+ /* Make a connection to the database */
+ conn = PQconnectdb(conninfo);
+
+ /* Check to see that the backend connection was successfully made */
+ if (PQstatus(conn) != CONNECTION_OK)
+ {
+ fprintf(stderr, "%s", PQerrorMessage(conn));
+ exit_nicely(conn);
+ }
+
+ /* Set always-secure search path, so malicious users can't take control. */
+ res = PQexec(conn,
+ "SELECT pg_catalog.set_config('search_path', '', false)");
+ if (PQresultStatus(res) != PGRES_TUPLES_OK)
+ {
+ fprintf(stderr, "SET failed: %s", PQerrorMessage(conn));
+ PQclear(res);
+ exit_nicely(conn);
+ }
+
+ /*
+ * Should PQclear PGresult whenever it is no longer needed to avoid memory
+ * leaks
+ */
+ PQclear(res);
+
+ /*
+ * Our test case here involves using a cursor, for which we must be inside
+ * a transaction block. We could do the whole thing with a single
+ * PQexec() of "select * from pg_database", but that's too trivial to make
+ * a good example.
+ */
+
+ /* Start a transaction block */
+ res = PQexec(conn, "BEGIN");
+ if (PQresultStatus(res) != PGRES_COMMAND_OK)
+ {
+ fprintf(stderr, "BEGIN command failed: %s", PQerrorMessage(conn));
+ PQclear(res);
+ exit_nicely(conn);
+ }
+ PQclear(res);
+
+ /*
+ * Fetch rows from pg_database, the system catalog of databases
+ */
+ res = PQexec(conn, "DECLARE myportal CURSOR FOR select * from pg_database");
+ if (PQresultStatus(res) != PGRES_COMMAND_OK)
+ {
+ fprintf(stderr, "DECLARE CURSOR failed: %s", PQerrorMessage(conn));
+ PQclear(res);
+ exit_nicely(conn);
+ }
+ PQclear(res);
+
+ res = PQexec(conn, "FETCH ALL in myportal");
+ if (PQresultStatus(res) != PGRES_TUPLES_OK)
+ {
+ fprintf(stderr, "FETCH ALL failed: %s", PQerrorMessage(conn));
+ PQclear(res);
+ exit_nicely(conn);
+ }
+
+ /* first, print out the attribute names */
+ nFields = PQnfields(res);
+ for (i = 0; i < nFields; i++)
+ printf("%-15s", PQfname(res, i));
+ printf("\n\n");
+
+ /* next, print out the rows */
+ for (i = 0; i < PQntuples(res); i++)
+ {
+ for (j = 0; j < nFields; j++)
+ printf("%-15s", PQgetvalue(res, i, j));
+ printf("\n");
+ }
+
+ PQclear(res);
+
+ /* close the portal ... we don't bother to check for errors ... */
+ res = PQexec(conn, "CLOSE myportal");
+ PQclear(res);
+
+ /* end the transaction */
+ res = PQexec(conn, "END");
+ PQclear(res);
+
+ /* close the connection to the database and cleanup */
+ PQfinish(conn);
+
+ return 0;
+}
+
+Example 34.2. libpq Example Program 2
+
+/*
+ * src/test/examples/testlibpq2.c
+ *
+ *
+ * testlibpq2.c
+ * Test of the asynchronous notification interface
+ *
+ * Start this program, then from psql in another window do
+ * NOTIFY TBL2;
+ * Repeat four times to get this program to exit.
+ *
+ * Or, if you want to get fancy, try this:
+ * populate a database with the following commands
+ * (provided in src/test/examples/testlibpq2.sql):
+ *
+ * CREATE SCHEMA TESTLIBPQ2;
+ * SET search_path = TESTLIBPQ2;
+ * CREATE TABLE TBL1 (i int4);
+ * CREATE TABLE TBL2 (i int4);
+ * CREATE RULE r1 AS ON INSERT TO TBL1 DO
+ * (INSERT INTO TBL2 VALUES (new.i); NOTIFY TBL2);
+ *
+ * Start this program, then from psql do this four times:
+ *
+ * INSERT INTO TESTLIBPQ2.TBL1 VALUES (10);
+ */
+
+#ifdef WIN32
+#include <windows.h>
+#endif
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/select.h>
+#include <sys/time.h>
+#include <sys/types.h>
+
+#include "libpq-fe.h"
+
+static void
+exit_nicely(PGconn *conn)
+{
+ PQfinish(conn);
+ exit(1);
+}
+
+int
+main(int argc, char **argv)
+{
+ const char *conninfo;
+ PGconn *conn;
+ PGresult *res;
+ PGnotify *notify;
+ int nnotifies;
+
+ /*
+ * If the user supplies a parameter on the command line, use it as the
+ * conninfo string; otherwise default to setting dbname=postgres and using
+ * environment variables or defaults for all other connection parameters.
+ */
+ if (argc > 1)
+ conninfo = argv[1];
+ else
+ conninfo = "dbname = postgres";
+
+ /* Make a connection to the database */
+ conn = PQconnectdb(conninfo);
+
+ /* Check to see that the backend connection was successfully made */
+ if (PQstatus(conn) != CONNECTION_OK)
+ {
+ fprintf(stderr, "%s", PQerrorMessage(conn));
+ exit_nicely(conn);
+ }
+
+ /* Set always-secure search path, so malicious users can't take control. */
+ res = PQexec(conn,
+ "SELECT pg_catalog.set_config('search_path', '', false)");
+ if (PQresultStatus(res) != PGRES_TUPLES_OK)
+ {
+ fprintf(stderr, "SET failed: %s", PQerrorMessage(conn));
+ PQclear(res);
+ exit_nicely(conn);
+ }
+
+ /*
+ * Should PQclear PGresult whenever it is no longer needed to avoid memory
+ * leaks
+ */
+ PQclear(res);
+
+ /*
+ * Issue LISTEN command to enable notifications from the rule's NOTIFY.
+ */
+ res = PQexec(conn, "LISTEN TBL2");
+ if (PQresultStatus(res) != PGRES_COMMAND_OK)
+ {
+ fprintf(stderr, "LISTEN command failed: %s", PQerrorMessage(conn));
+ PQclear(res);
+ exit_nicely(conn);
+ }
+ PQclear(res);
+
+ /* Quit after four notifies are received. */
+ nnotifies = 0;
+ while (nnotifies < 4)
+ {
+ /*
+ * Sleep until something happens on the connection. We use select(2)
+ * to wait for input, but you could also use poll() or similar
+ * facilities.
+ */
+ int sock;
+ fd_set input_mask;
+
+ sock = PQsocket(conn);
+
+ if (sock < 0)
+ break; /* shouldn't happen */
+
+ FD_ZERO(&input_mask);
+ FD_SET(sock, &input_mask);
+
+ if (select(sock + 1, &input_mask, NULL, NULL, NULL) < 0)
+ {
+ fprintf(stderr, "select() failed: %s\n", strerror(errno));
+ exit_nicely(conn);
+ }
+
+ /* Now check for input */
+ PQconsumeInput(conn);
+ while ((notify = PQnotifies(conn)) != NULL)
+ {
+ fprintf(stderr,
+ "ASYNC NOTIFY of '%s' received from backend PID %d\n",
+ notify->relname, notify->be_pid);
+ PQfreemem(notify);
+ nnotifies++;
+ PQconsumeInput(conn);
+ }
+ }
+
+ fprintf(stderr, "Done.\n");
+
+ /* close the connection to the database and cleanup */
+ PQfinish(conn);
+
+ return 0;
+}
+
+Example 34.3. libpq Example Program 3
+
+/*
+ * src/test/examples/testlibpq3.c
+ *
+ *
+ * testlibpq3.c
+ * Test out-of-line parameters and binary I/O.
+ *
+ * Before running this, populate a database with the following commands
+ * (provided in src/test/examples/testlibpq3.sql):
+ *
+ * CREATE SCHEMA testlibpq3;
+ * SET search_path = testlibpq3;
+ * SET standard_conforming_strings = ON;
+ * CREATE TABLE test1 (i int4, t text, b bytea);
+ * INSERT INTO test1 values (1, 'joe''s place', '\000\001\002\003\004');
+ * INSERT INTO test1 values (2, 'ho there', '\004\003\002\001\000');
+ *
+ * The expected output is:
+ *
+ * tuple 0: got
+ * i = (4 bytes) 1
+ * t = (11 bytes) 'joe's place'
+ * b = (5 bytes) \000\001\002\003\004
+ *
+ * tuple 0: got
+ * i = (4 bytes) 2
+ * t = (8 bytes) 'ho there'
+ * b = (5 bytes) \004\003\002\001\000
+ */
+
+#ifdef WIN32
+#include <windows.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <sys/types.h>
+#include "libpq-fe.h"
+
+/* for ntohl/htonl */
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+
+static void
+exit_nicely(PGconn *conn)
+{
+ PQfinish(conn);
+ exit(1);
+}
+
+/*
+ * This function prints a query result that is a binary-format fetch from
+ * a table defined as in the comment above. We split it out because the
+ * main() function uses it twice.
+ */
+static void
+show_binary_results(PGresult *res)
+{
+ int i,
+ j;
+ int i_fnum,
+ t_fnum,
+ b_fnum;
+
+ /* Use PQfnumber to avoid assumptions about field order in result */
+ i_fnum = PQfnumber(res, "i");
+ t_fnum = PQfnumber(res, "t");
+ b_fnum = PQfnumber(res, "b");
+
+ for (i = 0; i < PQntuples(res); i++)
+ {
+ char *iptr;
+ char *tptr;
+ char *bptr;
+ int blen;
+ int ival;
+
+ /* Get the field values (we ignore possibility they are null!) */
+ iptr = PQgetvalue(res, i, i_fnum);
+ tptr = PQgetvalue(res, i, t_fnum);
+ bptr = PQgetvalue(res, i, b_fnum);
+
+ /*
+ * The binary representation of INT4 is in network byte order, which
+ * we'd better coerce to the local byte order.
+ */
+ ival = ntohl(*((uint32_t *) iptr));
+
+ /*
+ * The binary representation of TEXT is, well, text, and since libpq
+ * was nice enough to append a zero byte to it, it'll work just fine
+ * as a C string.
+ *
+ * The binary representation of BYTEA is a bunch of bytes, which could
+ * include embedded nulls so we have to pay attention to field length.
+ */
+ blen = PQgetlength(res, i, b_fnum);
+
+ printf("tuple %d: got\n", i);
+ printf(" i = (%d bytes) %d\n",
+ PQgetlength(res, i, i_fnum), ival);
+ printf(" t = (%d bytes) '%s'\n",
+ PQgetlength(res, i, t_fnum), tptr);
+ printf(" b = (%d bytes) ", blen);
+ for (j = 0; j < blen; j++)
+ printf("\\%03o", bptr[j]);
+ printf("\n\n");
+ }
+}
+
+int
+main(int argc, char **argv)
+{
+ const char *conninfo;
+ PGconn *conn;
+ PGresult *res;
+ const char *paramValues[1];
+ int paramLengths[1];
+ int paramFormats[1];
+ uint32_t binaryIntVal;
+
+ /*
+ * If the user supplies a parameter on the command line, use it as the
+ * conninfo string; otherwise default to setting dbname=postgres and using
+ * environment variables or defaults for all other connection parameters.
+ */
+ if (argc > 1)
+ conninfo = argv[1];
+ else
+ conninfo = "dbname = postgres";
+
+ /* Make a connection to the database */
+ conn = PQconnectdb(conninfo);
+
+ /* Check to see that the backend connection was successfully made */
+ if (PQstatus(conn) != CONNECTION_OK)
+ {
+ fprintf(stderr, "%s", PQerrorMessage(conn));
+ exit_nicely(conn);
+ }
+
+ /* Set always-secure search path, so malicious users can't take control. */
+ res = PQexec(conn, "SET search_path = testlibpq3");
+ if (PQresultStatus(res) != PGRES_COMMAND_OK)
+ {
+ fprintf(stderr, "SET failed: %s", PQerrorMessage(conn));
+ PQclear(res);
+ exit_nicely(conn);
+ }
+ PQclear(res);
+
+ /*
+ * The point of this program is to illustrate use of PQexecParams() with
+ * out-of-line parameters, as well as binary transmission of data.
+ *
+ * This first example transmits the parameters as text, but receives the
+ * results in binary format. By using out-of-line parameters we can avoid
+ * a lot of tedious mucking about with quoting and escaping, even though
+ * the data is text. Notice how we don't have to do anything special with
+ * the quote mark in the parameter value.
+ */
+
+ /* Here is our out-of-line parameter value */
+ paramValues[0] = "joe's place";
+
+ res = PQexecParams(conn,
+ "SELECT * FROM test1 WHERE t = $1",
+ 1, /* one param */
+ NULL, /* let the backend deduce param type */
+ paramValues,
+ NULL, /* don't need param lengths since text */
+ NULL, /* default to all text params */
+ 1); /* ask for binary results */
+
+ if (PQresultStatus(res) != PGRES_TUPLES_OK)
+ {
+ fprintf(stderr, "SELECT failed: %s", PQerrorMessage(conn));
+ PQclear(res);
+ exit_nicely(conn);
+ }
+
+ show_binary_results(res);
+
+ PQclear(res);
+
+ /*
+ * In this second example we transmit an integer parameter in binary form,
+ * and again retrieve the results in binary form.
+ *
+ * Although we tell PQexecParams we are letting the backend deduce
+ * parameter type, we really force the decision by casting the parameter
+ * symbol in the query text. This is a good safety measure when sending
+ * binary parameters.
+ */
+
+ /* Convert integer value "2" to network byte order */
+ binaryIntVal = htonl((uint32_t) 2);
+
+ /* Set up parameter arrays for PQexecParams */
+ paramValues[0] = (char *) &binaryIntVal;
+ paramLengths[0] = sizeof(binaryIntVal);
+ paramFormats[0] = 1; /* binary */
+
+ res = PQexecParams(conn,
+ "SELECT * FROM test1 WHERE i = $1::int4",
+ 1, /* one param */
+ NULL, /* let the backend deduce param type */
+ paramValues,
+ paramLengths,
+ paramFormats,
+ 1); /* ask for binary results */
+
+ if (PQresultStatus(res) != PGRES_TUPLES_OK)
+ {
+ fprintf(stderr, "SELECT failed: %s", PQerrorMessage(conn));
+ PQclear(res);
+ exit_nicely(conn);
+ }
+
+ show_binary_results(res);
+
+ PQclear(res);
+
+ /* close the connection to the database and cleanup */
+ PQfinish(conn);
+
+ return 0;
+}
+
+34.3. Command Execution Functions #
+ Once a connection to a database server has been successfully
+ established, the functions described here are used to perform
+ SQL queries and commands.
+
+
PQexec #
+ Submits a command to the server and waits for the result.
+
+
+PGresult *PQexec(PGconn *conn, const char *command);
+
+
+ Returns a PGresult pointer or possibly a null
+ pointer. A non-null pointer will generally be returned except in
+ out-of-memory conditions or serious errors such as inability to send
+ the command to the server. The PQresultStatus function
+ should be called to check the return value for any errors (including
+ the value of a null pointer, in which case it will return
+ PGRES_FATAL_ERROR). Use
+ PQerrorMessage to get more information about such
+ errors.
+
+
+ The command string can include multiple SQL commands
+ (separated by semicolons). Multiple queries sent in a single
+ PQexec call are processed in a single transaction, unless
+ there are explicit BEGIN/COMMIT
+ commands included in the query string to divide it into multiple
+ transactions. (See Section 55.2.2.1
+ for more details about how the server handles multi-query strings.)
+ Note however that the returned
+ PGresult structure describes only the result
+ of the last command executed from the string. Should one of the
+ commands fail, processing of the string stops with it and the returned
+ PGresult describes the error condition.
+
+
PQexecParams #
+ Submits a command to the server and waits for the result,
+ with the ability to pass parameters separately from the SQL
+ command text.
+
+
+PGresult *PQexecParams(PGconn *conn,
+ const char *command,
+ int nParams,
+ const Oid *paramTypes,
+ const char * const *paramValues,
+ const int *paramLengths,
+ const int *paramFormats,
+ int resultFormat);
+
+
+ PQexecParams is like PQexec, but offers additional
+ functionality: parameter values can be specified separately from the command
+ string proper, and query results can be requested in either text or binary
+ format.
+
+ The function arguments are:
+
+
conn
+ The connection object to send the command through.
+
command
+ The SQL command string to be executed. If parameters are used,
+ they are referred to in the command string as $1,
+ $2, etc.
+
nParams
+ The number of parameters supplied; it is the length of the arrays
+ paramTypes[], paramValues[],
+ paramLengths[], and paramFormats[]. (The
+ array pointers can be NULL when nParams
+ is zero.)
+
paramTypes[]
+ Specifies, by OID, the data types to be assigned to the
+ parameter symbols. If paramTypes is
+ NULL, or any particular element in the array
+ is zero, the server infers a data type for the parameter symbol
+ in the same way it would do for an untyped literal string.
+
paramValues[]
+ Specifies the actual values of the parameters. A null pointer
+ in this array means the corresponding parameter is null;
+ otherwise the pointer points to a zero-terminated text string
+ (for text format) or binary data in the format expected by the
+ server (for binary format).
+
paramLengths[]
+ Specifies the actual data lengths of binary-format parameters.
+ It is ignored for null parameters and text-format parameters.
+ The array pointer can be null when there are no binary parameters.
+
paramFormats[]
+ Specifies whether parameters are text (put a zero in the
+ array entry for the corresponding parameter) or binary (put
+ a one in the array entry for the corresponding parameter).
+ If the array pointer is null then all parameters are presumed
+ to be text strings.
+
+ Values passed in binary format require knowledge of
+ the internal representation expected by the backend.
+ For example, integers must be passed in network byte
+ order. Passing numeric values requires
+ knowledge of the server storage format, as implemented
+ in
+ src/backend/utils/adt/numeric.c::numeric_send() and
+ src/backend/utils/adt/numeric.c::numeric_recv().
+
resultFormat
+ Specify zero to obtain results in text format, or one to obtain
+ results in binary format. (There is not currently a provision
+ to obtain different result columns in different formats,
+ although that is possible in the underlying protocol.)
+
+
+
+ The primary advantage of PQexecParams over
+ PQexec is that parameter values can be separated from the
+ command string, thus avoiding the need for tedious and error-prone
+ quoting and escaping.
+
+ Unlike PQexec, PQexecParams allows at most
+ one SQL command in the given string. (There can be semicolons in it,
+ but not more than one nonempty command.) This is a limitation of the
+ underlying protocol, but has some usefulness as an extra defense against
+ SQL-injection attacks.
+
Tip
+ Specifying parameter types via OIDs is tedious, particularly if you prefer
+ not to hard-wire particular OID values into your program. However, you can
+ avoid doing so even in cases where the server by itself cannot determine the
+ type of the parameter, or chooses a different type than you want. In the
+ SQL command text, attach an explicit cast to the parameter symbol to show what
+ data type you will send. For example:
+
+SELECT * FROM mytable WHERE x = $1::bigint;
+
+ This forces parameter $1 to be treated as bigint, whereas
+ by default it would be assigned the same type as x. Forcing the
+ parameter type decision, either this way or by specifying a numeric type OID,
+ is strongly recommended when sending parameter values in binary format, because
+ binary format has less redundancy than text format and so there is less chance
+ that the server will detect a type mismatch mistake for you.
+
+
PQprepare #
+ Submits a request to create a prepared statement with the
+ given parameters, and waits for completion.
+
+PGresult *PQprepare(PGconn *conn,
+ const char *stmtName,
+ const char *query,
+ int nParams,
+ const Oid *paramTypes);
+
+
+ PQprepare creates a prepared statement for later
+ execution with PQexecPrepared. This feature allows
+ commands to be executed repeatedly without being parsed and
+ planned each time; see PREPARE for details.
+
+ The function creates a prepared statement named
+ stmtName from the query string, which
+ must contain a single SQL command. stmtName can be
+ "" to create an unnamed statement, in which case any
+ pre-existing unnamed statement is automatically replaced; otherwise
+ it is an error if the statement name is already defined in the
+ current session. If any parameters are used, they are referred
+ to in the query as $1, $2, etc.
+ nParams is the number of parameters for which types
+ are pre-specified in the array paramTypes[]. (The
+ array pointer can be NULL when
+ nParams is zero.) paramTypes[]
+ specifies, by OID, the data types to be assigned to the parameter
+ symbols. If paramTypes is NULL,
+ or any particular element in the array is zero, the server assigns
+ a data type to the parameter symbol in the same way it would do
+ for an untyped literal string. Also, the query can use parameter
+ symbols with numbers higher than nParams; data types
+ will be inferred for these symbols as well. (See
+ PQdescribePrepared for a means to find out
+ what data types were inferred.)
+
+ As with PQexec, the result is normally a
+ PGresult object whose contents indicate
+ server-side success or failure. A null result indicates
+ out-of-memory or inability to send the command at all. Use
+ PQerrorMessage to get more information about
+ such errors.
+
+
+ Prepared statements for use with PQexecPrepared can also
+ be created by executing SQL PREPARE
+ statements. Also, although there is no libpq
+ function for deleting a prepared statement, the SQL DEALLOCATE statement
+ can be used for that purpose.
+
+
PQexecPrepared #
+ Sends a request to execute a prepared statement with given
+ parameters, and waits for the result.
+
+PGresult *PQexecPrepared(PGconn *conn,
+ const char *stmtName,
+ int nParams,
+ const char * const *paramValues,
+ const int *paramLengths,
+ const int *paramFormats,
+ int resultFormat);
+
+
+ PQexecPrepared is like PQexecParams,
+ but the command to be executed is specified by naming a
+ previously-prepared statement, instead of giving a query string.
+ This feature allows commands that will be used repeatedly to be
+ parsed and planned just once, rather than each time they are
+ executed. The statement must have been prepared previously in
+ the current session.
+
+ The parameters are identical to PQexecParams, except that the
+ name of a prepared statement is given instead of a query string, and the
+ paramTypes[] parameter is not present (it is not needed since
+ the prepared statement's parameter types were determined when it was created).
+
PQdescribePrepared #
+ Submits a request to obtain information about the specified
+ prepared statement, and waits for completion.
+
+PGresult *PQdescribePrepared(PGconn *conn, const char *stmtName);
+
+
+ PQdescribePrepared allows an application to obtain
+ information about a previously prepared statement.
+
+ stmtName can be "" or NULL to reference
+ the unnamed statement, otherwise it must be the name of an existing
+ prepared statement. On success, a PGresult with
+ status PGRES_COMMAND_OK is returned. The
+ functions PQnparams and
+ PQparamtype can be applied to this
+ PGresult to obtain information about the parameters
+ of the prepared statement, and the functions
+ PQnfields, PQfname,
+ PQftype, etc. provide information about the
+ result columns (if any) of the statement.
+
PQdescribePortal #
+ Submits a request to obtain information about the specified
+ portal, and waits for completion.
+
+PGresult *PQdescribePortal(PGconn *conn, const char *portalName);
+
+
+ PQdescribePortal allows an application to obtain
+ information about a previously created portal.
+ (libpq does not provide any direct access to
+ portals, but you can use this function to inspect the properties
+ of a cursor created with a DECLARE CURSOR SQL command.)
+
+ portalName can be "" or NULL to reference
+ the unnamed portal, otherwise it must be the name of an existing
+ portal. On success, a PGresult with status
+ PGRES_COMMAND_OK is returned. The functions
+ PQnfields, PQfname,
+ PQftype, etc. can be applied to the
+ PGresult to obtain information about the result
+ columns (if any) of the portal.
+
+
+ The PGresult
+ structure encapsulates the result returned by the server.
+ libpq application programmers should be
+ careful to maintain the PGresult abstraction.
+ Use the accessor functions below to get at the contents of
+ PGresult. Avoid directly referencing the
+ fields of the PGresult structure because they
+ are subject to change in the future.
+
+
PQresultStatus #
+ Returns the result status of the command.
+
+ExecStatusType PQresultStatus(const PGresult *res);
+
+
+ PQresultStatus can return one of the following values:
+
+
PGRES_EMPTY_QUERY #
+ The string sent to the server was empty.
+
PGRES_COMMAND_OK #
+ Successful completion of a command returning no data.
+
PGRES_TUPLES_OK #
+ Successful completion of a command returning data (such as
+ a SELECT or SHOW).
+
PGRES_COPY_OUT #
+ Copy Out (from server) data transfer started.
+
PGRES_COPY_IN #
+ Copy In (to server) data transfer started.
+
PGRES_BAD_RESPONSE #
+ The server's response was not understood.
+
PGRES_NONFATAL_ERROR #
+ A nonfatal error (a notice or warning) occurred.
+
PGRES_FATAL_ERROR #
+ A fatal error occurred.
+
PGRES_COPY_BOTH #
+ Copy In/Out (to and from server) data transfer started. This
+ feature is currently used only for streaming replication,
+ so this status should not occur in ordinary applications.
+
PGRES_SINGLE_TUPLE #
+ The PGresult contains a single result tuple
+ from the current command. This status occurs only when
+ single-row mode has been selected for the query
+ (see Section 34.6).
+
PGRES_PIPELINE_SYNC #
+ The PGresult represents a
+ synchronization point in pipeline mode, requested by
+ PQpipelineSync.
+ This status occurs only when pipeline mode has been selected.
+
PGRES_PIPELINE_ABORTED #
+ The PGresult represents a pipeline that has
+ received an error from the server. PQgetResult
+ must be called repeatedly, and each time it will return this status code
+ until the end of the current pipeline, at which point it will return
+ PGRES_PIPELINE_SYNC and normal processing can
+ resume.
+
+
+ If the result status is PGRES_TUPLES_OK or
+ PGRES_SINGLE_TUPLE, then
+ the functions described below can be used to retrieve the rows
+ returned by the query. Note that a SELECT
+ command that happens to retrieve zero rows still shows
+ PGRES_TUPLES_OK.
+ PGRES_COMMAND_OK is for commands that can never
+ return rows (INSERT or UPDATE
+ without a RETURNING clause,
+ etc.). A response of PGRES_EMPTY_QUERY might
+ indicate a bug in the client software.
+
+ A result of status PGRES_NONFATAL_ERROR will
+ never be returned directly by PQexec or other
+ query execution functions; results of this kind are instead passed
+ to the notice processor (see Section 34.13).
+
PQresStatus #
+ Converts the enumerated type returned by
+ PQresultStatus into a string constant describing the
+ status code. The caller should not free the result.
+
+
+char *PQresStatus(ExecStatusType status);
+
+
PQresultErrorMessage #
+ Returns the error message associated with the command, or an empty string
+ if there was no error.
+
+char *PQresultErrorMessage(const PGresult *res);
+
+ If there was an error, the returned string will include a trailing
+ newline. The caller should not free the result directly. It will
+ be freed when the associated PGresult handle is
+ passed to PQclear.
+
+ Immediately following a PQexec or
+ PQgetResult call,
+ PQerrorMessage (on the connection) will return
+ the same string as PQresultErrorMessage (on
+ the result). However, a PGresult will
+ retain its error message until destroyed, whereas the connection's
+ error message will change when subsequent operations are done.
+ Use PQresultErrorMessage when you want to
+ know the status associated with a particular
+ PGresult; use
+ PQerrorMessage when you want to know the
+ status from the latest operation on the connection.
+
PQresultVerboseErrorMessage #
+ Returns a reformatted version of the error message associated with
+ a PGresult object.
+
+char *PQresultVerboseErrorMessage(const PGresult *res,
+ PGVerbosity verbosity,
+ PGContextVisibility show_context);
+
+ In some situations a client might wish to obtain a more detailed
+ version of a previously-reported error.
+ PQresultVerboseErrorMessage addresses this need
+ by computing the message that would have been produced
+ by PQresultErrorMessage if the specified
+ verbosity settings had been in effect for the connection when the
+ given PGresult was generated. If
+ the PGresult is not an error result,
+ “PGresult is not an error result” is reported instead.
+ The returned string includes a trailing newline.
+
+ Unlike most other functions for extracting data from
+ a PGresult, the result of this function is a freshly
+ allocated string. The caller must free it
+ using PQfreemem() when the string is no longer needed.
+
+ A NULL return is possible if there is insufficient memory.
+
PQresultErrorField #
+ Returns an individual field of an error report.
+
+char *PQresultErrorField(const PGresult *res, int fieldcode);
+
+ fieldcode is an error field identifier; see the symbols
+ listed below. NULL is returned if the
+ PGresult is not an error or warning result,
+ or does not include the specified field. Field values will normally
+ not include a trailing newline. The caller should not free the
+ result directly. It will be freed when the
+ associated PGresult handle is passed to
+ PQclear.
+
+ The following field codes are available:
+
PG_DIAG_SEVERITY #
+ The severity; the field contents are ERROR,
+ FATAL, or PANIC (in an error message),
+ or WARNING, NOTICE, DEBUG,
+ INFO, or LOG (in a notice message), or
+ a localized translation of one of these. Always present.
+
PG_DIAG_SEVERITY_NONLOCALIZED #
+ The severity; the field contents are ERROR,
+ FATAL, or PANIC (in an error message),
+ or WARNING, NOTICE, DEBUG,
+ INFO, or LOG (in a notice message).
+ This is identical to the PG_DIAG_SEVERITY field except
+ that the contents are never localized. This is present only in
+ reports generated by PostgreSQL versions 9.6
+ and later.
+
PG_DIAG_SQLSTATE #
+ The SQLSTATE code for the error. The SQLSTATE code identifies
+ the type of error that has occurred; it can be used by
+ front-end applications to perform specific operations (such
+ as error handling) in response to a particular database error.
+ For a list of the possible SQLSTATE codes, see Appendix A. This field is not localizable,
+ and is always present.
+
PG_DIAG_MESSAGE_PRIMARY #
+ The primary human-readable error message (typically one line).
+ Always present.
+
PG_DIAG_MESSAGE_DETAIL #
+ Detail: an optional secondary error message carrying more
+ detail about the problem. Might run to multiple lines.
+
PG_DIAG_MESSAGE_HINT #
+ Hint: an optional suggestion what to do about the problem.
+ This is intended to differ from detail in that it offers advice
+ (potentially inappropriate) rather than hard facts. Might
+ run to multiple lines.
+
PG_DIAG_STATEMENT_POSITION #
+ A string containing a decimal integer indicating an error cursor
+ position as an index into the original statement string. The
+ first character has index 1, and positions are measured in
+ characters not bytes.
+
PG_DIAG_INTERNAL_POSITION #
+ This is defined the same as the
+ PG_DIAG_STATEMENT_POSITION field, but it is used
+ when the cursor position refers to an internally generated
+ command rather than the one submitted by the client. The
+ PG_DIAG_INTERNAL_QUERY field will always appear when
+ this field appears.
+
PG_DIAG_INTERNAL_QUERY #
+ The text of a failed internally-generated command. This could
+ be, for example, an SQL query issued by a PL/pgSQL function.
+
PG_DIAG_CONTEXT #
+ An indication of the context in which the error occurred.
+ Presently this includes a call stack traceback of active
+ procedural language functions and internally-generated queries.
+ The trace is one entry per line, most recent first.
+
PG_DIAG_SCHEMA_NAME #
+ If the error was associated with a specific database object,
+ the name of the schema containing that object, if any.
+
PG_DIAG_TABLE_NAME #
+ If the error was associated with a specific table, the name of the
+ table. (Refer to the schema name field for the name of the
+ table's schema.)
+
PG_DIAG_COLUMN_NAME #
+ If the error was associated with a specific table column, the name
+ of the column. (Refer to the schema and table name fields to
+ identify the table.)
+
PG_DIAG_DATATYPE_NAME #
+ If the error was associated with a specific data type, the name of
+ the data type. (Refer to the schema name field for the name of
+ the data type's schema.)
+
PG_DIAG_CONSTRAINT_NAME #
+ If the error was associated with a specific constraint, the name
+ of the constraint. Refer to fields listed above for the
+ associated table or domain. (For this purpose, indexes are
+ treated as constraints, even if they weren't created with
+ constraint syntax.)
+
PG_DIAG_SOURCE_FILE #
+ The file name of the source-code location where the error was
+ reported.
+
PG_DIAG_SOURCE_LINE #
+ The line number of the source-code location where the error
+ was reported.
+
PG_DIAG_SOURCE_FUNCTION #
+ The name of the source-code function reporting the error.
+
+
Note
+ The fields for schema name, table name, column name, data type name,
+ and constraint name are supplied only for a limited number of error
+ types; see Appendix A. Do not assume that
+ the presence of any of these fields guarantees the presence of
+ another field. Core error sources observe the interrelationships
+ noted above, but user-defined functions may use these fields in other
+ ways. In the same vein, do not assume that these fields denote
+ contemporary objects in the current database.
+
+ The client is responsible for formatting displayed information to meet
+ its needs; in particular it should break long lines as needed.
+ Newline characters appearing in the error message fields should be
+ treated as paragraph breaks, not line breaks.
+
+ Errors generated internally by libpq will
+ have severity and primary message, but typically no other fields.
+
+ Note that error fields are only available from
+ PGresult objects, not
+ PGconn objects; there is no
+ PQerrorField function.
+
PQclear #
+ Frees the storage associated with a
+ PGresult. Every command result should be
+ freed via PQclear when it is no longer
+ needed.
+
+
+void PQclear(PGresult *res);
+
+
+ If the argument is a NULL pointer, no operation is
+ performed.
+
+ You can keep a PGresult object around for
+ as long as you need it; it does not go away when you issue a new
+ command, nor even if you close the connection. To get rid of it,
+ you must call PQclear. Failure to do this
+ will result in memory leaks in your application.
+
+
34.3.2. Retrieving Query Result Information #
+ These functions are used to extract information from a
+ PGresult object that represents a successful
+ query result (that is, one that has status
+ PGRES_TUPLES_OK or PGRES_SINGLE_TUPLE).
+ They can also be used to extract
+ information from a successful Describe operation: a Describe's result
+ has all the same column information that actual execution of the query
+ would provide, but it has zero rows. For objects with other status values,
+ these functions will act as though the result has zero rows and zero columns.
+
PQntuples #
+ Returns the number of rows (tuples) in the query result.
+ (Note that PGresult objects are limited to no more
+ than INT_MAX rows, so an int result is
+ sufficient.)
+
+
+int PQntuples(const PGresult *res);
+
+
+
PQnfields #
+ Returns the number of columns (fields) in each row of the query
+ result.
+
+
+int PQnfields(const PGresult *res);
+
+
PQfname #
+ Returns the column name associated with the given column number.
+ Column numbers start at 0. The caller should not free the result
+ directly. It will be freed when the associated
+ PGresult handle is passed to
+ PQclear.
+
+char *PQfname(const PGresult *res,
+ int column_number);
+
+
+ NULL is returned if the column number is out of range.
+
PQfnumber #
+ Returns the column number associated with the given column name.
+
+int PQfnumber(const PGresult *res,
+ const char *column_name);
+
+
+ -1 is returned if the given name does not match any column.
+
+ The given name is treated like an identifier in an SQL command,
+ that is, it is downcased unless double-quoted. For example, given
+ a query result generated from the SQL command:
+
+SELECT 1 AS FOO, 2 AS "BAR";
+
+ we would have the results:
+
+PQfname(res, 0) foo
+PQfname(res, 1) BAR
+PQfnumber(res, "FOO") 0
+PQfnumber(res, "foo") 0
+PQfnumber(res, "BAR") -1
+PQfnumber(res, "\"BAR\"") 1
+
+
PQftable #
+ Returns the OID of the table from which the given column was
+ fetched. Column numbers start at 0.
+
+Oid PQftable(const PGresult *res,
+ int column_number);
+
+
+ InvalidOid is returned if the column number is out of range,
+ or if the specified column is not a simple reference to a table column.
+ You can query the system table pg_class to determine
+ exactly which table is referenced.
+
+ The type Oid and the constant
+ InvalidOid will be defined when you include
+ the libpq header file. They will both
+ be some integer type.
+
PQftablecol #
+ Returns the column number (within its table) of the column making
+ up the specified query result column. Query-result column numbers
+ start at 0, but table columns have nonzero numbers.
+
+int PQftablecol(const PGresult *res,
+ int column_number);
+
+
+ Zero is returned if the column number is out of range, or if the
+ specified column is not a simple reference to a table column.
+
PQfformat #
+ Returns the format code indicating the format of the given
+ column. Column numbers start at 0.
+
+int PQfformat(const PGresult *res,
+ int column_number);
+
+
+ Format code zero indicates textual data representation, while format
+ code one indicates binary representation. (Other codes are reserved
+ for future definition.)
+
PQftype #
+ Returns the data type associated with the given column number.
+ The integer returned is the internal OID number of the type.
+ Column numbers start at 0.
+
+Oid PQftype(const PGresult *res,
+ int column_number);
+
+
+ You can query the system table pg_type to
+ obtain the names and properties of the various data types. The
+ OIDs of the built-in data types are defined
+ in the file catalog/pg_type_d.h
+ in the PostgreSQL
+ installation's include directory.
+
PQfmod #
+ Returns the type modifier of the column associated with the
+ given column number. Column numbers start at 0.
+
+int PQfmod(const PGresult *res,
+ int column_number);
+
+
+ The interpretation of modifier values is type-specific; they
+ typically indicate precision or size limits. The value -1 is
+ used to indicate “no information available”. Most data
+ types do not use modifiers, in which case the value is always
+ -1.
+
PQfsize #
+ Returns the size in bytes of the column associated with the
+ given column number. Column numbers start at 0.
+
+int PQfsize(const PGresult *res,
+ int column_number);
+
+
+ PQfsize returns the space allocated for this column
+ in a database row, in other words the size of the server's
+ internal representation of the data type. (Accordingly, it is
+ not really very useful to clients.) A negative value indicates
+ the data type is variable-length.
+
PQbinaryTuples #
+ Returns 1 if the PGresult contains binary data
+ and 0 if it contains text data.
+
+int PQbinaryTuples(const PGresult *res);
+
+
+ This function is deprecated (except for its use in connection with
+ COPY), because it is possible for a single
+ PGresult to contain text data in some columns and
+ binary data in others. PQfformat is preferred.
+ PQbinaryTuples returns 1 only if all columns of the
+ result are binary (format 1).
+
PQgetvalue #
+ Returns a single field value of one row of a
+ PGresult. Row and column numbers start
+ at 0. The caller should not free the result directly. It will
+ be freed when the associated PGresult handle is
+ passed to PQclear.
+
+char *PQgetvalue(const PGresult *res,
+ int row_number,
+ int column_number);
+
+
+ For data in text format, the value returned by
+ PQgetvalue is a null-terminated character
+ string representation of the field value. For data in binary
+ format, the value is in the binary representation determined by
+ the data type's typsend and typreceive
+ functions. (The value is actually followed by a zero byte in
+ this case too, but that is not ordinarily useful, since the
+ value is likely to contain embedded nulls.)
+
+ An empty string is returned if the field value is null. See
+ PQgetisnull to distinguish null values from
+ empty-string values.
+
+ The pointer returned by PQgetvalue points
+ to storage that is part of the PGresult
+ structure. One should not modify the data it points to, and one
+ must explicitly copy the data into other storage if it is to be
+ used past the lifetime of the PGresult
+ structure itself.
+
PQgetisnull #
+ Tests a field for a null value. Row and column numbers start
+ at 0.
+
+int PQgetisnull(const PGresult *res,
+ int row_number,
+ int column_number);
+
+
+ This function returns 1 if the field is null and 0 if it
+ contains a non-null value. (Note that
+ PQgetvalue will return an empty string,
+ not a null pointer, for a null field.)
+
PQgetlength #
+ Returns the actual length of a field value in bytes. Row and
+ column numbers start at 0.
+
+int PQgetlength(const PGresult *res,
+ int row_number,
+ int column_number);
+
+
+ This is the actual data length for the particular data value,
+ that is, the size of the object pointed to by
+ PQgetvalue. For text data format this is
+ the same as strlen(). For binary format this is
+ essential information. Note that one should not
+ rely on PQfsize to obtain the actual data
+ length.
+
PQnparams #
+ Returns the number of parameters of a prepared statement.
+
+int PQnparams(const PGresult *res);
+
+
+ This function is only useful when inspecting the result of
+ PQdescribePrepared. For other types of results it
+ will return zero.
+
PQparamtype #
+ Returns the data type of the indicated statement parameter.
+ Parameter numbers start at 0.
+
+Oid PQparamtype(const PGresult *res, int param_number);
+
+
+ This function is only useful when inspecting the result of
+ PQdescribePrepared. For other types of results it
+ will return zero.
+
PQprint #
+ Prints out all the rows and, optionally, the column names to
+ the specified output stream.
+
+void PQprint(FILE *fout, /* output stream */
+ const PGresult *res,
+ const PQprintOpt *po);
+typedef struct
+{
+ pqbool header; /* print output field headings and row count */
+ pqbool align; /* fill align the fields */
+ pqbool standard; /* old brain dead format */
+ pqbool html3; /* output HTML tables */
+ pqbool expanded; /* expand tables */
+ pqbool pager; /* use pager for output if needed */
+ char *fieldSep; /* field separator */
+ char *tableOpt; /* attributes for HTML table element */
+ char *caption; /* HTML table caption */
+ char **fieldName; /* null-terminated array of replacement field names */
+} PQprintOpt;
+
+
+ This function was formerly used by psql
+ to print query results, but this is no longer the case. Note
+ that it assumes all the data is in text format.
+
34.3.3. Retrieving Other Result Information #
+ These functions are used to extract other information from
+ PGresult objects.
+
PQcmdStatus #
+ Returns the command status tag from the SQL command that generated
+ the PGresult.
+
+char *PQcmdStatus(PGresult *res);
+
+
+ Commonly this is just the name of the command, but it might include
+ additional data such as the number of rows processed. The caller
+ should not free the result directly. It will be freed when the
+ associated PGresult handle is passed to
+ PQclear.
+
PQcmdTuples #
+ Returns the number of rows affected by the SQL command.
+
+char *PQcmdTuples(PGresult *res);
+
+
+ This function returns a string containing the number of rows
+ affected by the SQL statement that generated the
+ PGresult. This function can only be used following
+ the execution of a SELECT, CREATE TABLE AS,
+ INSERT, UPDATE, DELETE,
+ MERGE, MOVE, FETCH,
+ or COPY statement, or an EXECUTE of a
+ prepared query that contains an INSERT,
+ UPDATE, DELETE,
+ or MERGE statement.
+ If the command that generated the PGresult was anything
+ else, PQcmdTuples returns an empty string. The caller
+ should not free the return value directly. It will be freed when
+ the associated PGresult handle is passed to
+ PQclear.
+
PQoidValue #
+ Returns the OID
+ of the inserted row, if the SQL command was an
+ INSERT that inserted exactly one row into a table that
+ has OIDs, or a EXECUTE of a prepared query containing
+ a suitable INSERT statement. Otherwise, this function
+ returns InvalidOid. This function will also
+ return InvalidOid if the table affected by the
+ INSERT statement does not contain OIDs.
+
+Oid PQoidValue(const PGresult *res);
+
+
PQoidStatus #
+ This function is deprecated in favor of
+ PQoidValue and is not thread-safe.
+ It returns a string with the OID of the inserted row, while
+ PQoidValue returns the OID value.
+
+char *PQoidStatus(const PGresult *res);
+
+
34.3.4. Escaping Strings for Inclusion in SQL Commands #
PQescapeLiteral #
+
+char *PQescapeLiteral(PGconn *conn, const char *str, size_t length);
+
+
+ PQescapeLiteral escapes a string for
+ use within an SQL command. This is useful when inserting data
+ values as literal constants in SQL commands. Certain characters
+ (such as quotes and backslashes) must be escaped to prevent them
+ from being interpreted specially by the SQL parser.
+ PQescapeLiteral performs this operation.
+
+ PQescapeLiteral returns an escaped version of the
+ str parameter in memory allocated with
+ malloc(). This memory should be freed using
+ PQfreemem() when the result is no longer needed.
+ A terminating zero byte is not required, and should not be
+ counted in length. (If a terminating zero byte is found
+ before length bytes are processed,
+ PQescapeLiteral stops at the zero; the behavior is
+ thus rather like strncpy.) The
+ return string has all special characters replaced so that they can
+ be properly processed by the PostgreSQL
+ string literal parser. A terminating zero byte is also added. The
+ single quotes that must surround PostgreSQL
+ string literals are included in the result string.
+
+ On error, PQescapeLiteral returns NULL and a suitable
+ message is stored in the conn object.
+
Tip
+ It is especially important to do proper escaping when handling
+ strings that were received from an untrustworthy source.
+ Otherwise there is a security risk: you are vulnerable to
+ “SQL injection” attacks wherein unwanted SQL commands are
+ fed to your database.
+
+ Note that it is neither necessary nor correct to do escaping when a data
+ value is passed as a separate parameter in PQexecParams or
+ its sibling routines.
+
PQescapeIdentifier #
+
+char *PQescapeIdentifier(PGconn *conn, const char *str, size_t length);
+
+
+ PQescapeIdentifier escapes a string for
+ use as an SQL identifier, such as a table, column, or function name.
+ This is useful when a user-supplied identifier might contain
+ special characters that would otherwise not be interpreted as part
+ of the identifier by the SQL parser, or when the identifier might
+ contain upper case characters whose case should be preserved.
+
+ PQescapeIdentifier returns a version of the
+ str parameter escaped as an SQL identifier
+ in memory allocated with malloc(). This memory must be
+ freed using PQfreemem() when the result is no longer
+ needed. A terminating zero byte is not required, and should not be
+ counted in length. (If a terminating zero byte is found
+ before length bytes are processed,
+ PQescapeIdentifier stops at the zero; the behavior is
+ thus rather like strncpy.) The
+ return string has all special characters replaced so that it
+ will be properly processed as an SQL identifier. A terminating zero byte
+ is also added. The return string will also be surrounded by double
+ quotes.
+
+ On error, PQescapeIdentifier returns NULL and a suitable
+ message is stored in the conn object.
+
Tip
+ As with string literals, to prevent SQL injection attacks,
+ SQL identifiers must be escaped when they are received from an
+ untrustworthy source.
+
PQescapeStringConn #
+
+size_t PQescapeStringConn(PGconn *conn,
+ char *to, const char *from, size_t length,
+ int *error);
+
+
+ PQescapeStringConn escapes string literals, much like
+ PQescapeLiteral. Unlike PQescapeLiteral,
+ the caller is responsible for providing an appropriately sized buffer.
+ Furthermore, PQescapeStringConn does not generate the
+ single quotes that must surround PostgreSQL string
+ literals; they should be provided in the SQL command that the
+ result is inserted into. The parameter from points to
+ the first character of the string that is to be escaped, and the
+ length parameter gives the number of bytes in this
+ string. A terminating zero byte is not required, and should not be
+ counted in length. (If a terminating zero byte is found
+ before length bytes are processed,
+ PQescapeStringConn stops at the zero; the behavior is
+ thus rather like strncpy.) to shall point
+ to a buffer that is able to hold at least one more byte than twice
+ the value of length, otherwise the behavior is undefined.
+ Behavior is likewise undefined if the to and
+ from strings overlap.
+
+ If the error parameter is not NULL, then
+ *error is set to zero on success, nonzero on error.
+ Presently the only possible error conditions involve invalid multibyte
+ encoding in the source string. The output string is still generated
+ on error, but it can be expected that the server will reject it as
+ malformed. On error, a suitable message is stored in the
+ conn object, whether or not error is NULL.
+
+ PQescapeStringConn returns the number of bytes written
+ to to, not including the terminating zero byte.
+
PQescapeString #
+ PQescapeString is an older, deprecated version of
+ PQescapeStringConn.
+
+size_t PQescapeString (char *to, const char *from, size_t length);
+
+
+ The only difference from PQescapeStringConn is that
+ PQescapeString does not take PGconn
+ or error parameters.
+ Because of this, it cannot adjust its behavior depending on the
+ connection properties (such as character encoding) and therefore
+ it might give the wrong results. Also, it has no way
+ to report error conditions.
+
+ PQescapeString can be used safely in
+ client programs that work with only one PostgreSQL
+ connection at a time (in this case it can find out what it needs to
+ know “behind the scenes”). In other contexts it is a security
+ hazard and should be avoided in favor of
+ PQescapeStringConn.
+
PQescapeByteaConn #
+ Escapes binary data for use within an SQL command with the type
+ bytea. As with PQescapeStringConn,
+ this is only used when inserting data directly into an SQL command string.
+
+unsigned char *PQescapeByteaConn(PGconn *conn,
+ const unsigned char *from,
+ size_t from_length,
+ size_t *to_length);
+
+
+ Certain byte values must be escaped when used as part of a
+ bytea literal in an SQL statement.
+ PQescapeByteaConn escapes bytes using
+ either hex encoding or backslash escaping. See Section 8.4 for more information.
+
+ The from parameter points to the first
+ byte of the string that is to be escaped, and the
+ from_length parameter gives the number of
+ bytes in this binary string. (A terminating zero byte is
+ neither necessary nor counted.) The to_length
+ parameter points to a variable that will hold the resultant
+ escaped string length. This result string length includes the terminating
+ zero byte of the result.
+
+ PQescapeByteaConn returns an escaped version of the
+ from parameter binary string in memory
+ allocated with malloc(). This memory should be freed using
+ PQfreemem() when the result is no longer needed. The
+ return string has all special characters replaced so that they can
+ be properly processed by the PostgreSQL
+ string literal parser, and the bytea input function. A
+ terminating zero byte is also added. The single quotes that must
+ surround PostgreSQL string literals are
+ not part of the result string.
+
+ On error, a null pointer is returned, and a suitable error message
+ is stored in the conn object. Currently, the only
+ possible error is insufficient memory for the result string.
+
PQescapeBytea #
+ PQescapeBytea is an older, deprecated version of
+ PQescapeByteaConn.
+
+unsigned char *PQescapeBytea(const unsigned char *from,
+ size_t from_length,
+ size_t *to_length);
+
+
+ The only difference from PQescapeByteaConn is that
+ PQescapeBytea does not take a PGconn
+ parameter. Because of this, PQescapeBytea can
+ only be used safely in client programs that use a single
+ PostgreSQL connection at a time (in this case
+ it can find out what it needs to know “behind the
+ scenes”). It might give the wrong results if
+ used in programs that use multiple database connections (use
+ PQescapeByteaConn in such cases).
+
PQunescapeBytea #
+ Converts a string representation of binary data into binary data
+ — the reverse of PQescapeBytea. This
+ is needed when retrieving bytea data in text format,
+ but not when retrieving it in binary format.
+
+
+unsigned char *PQunescapeBytea(const unsigned char *from, size_t *to_length);
+
+
+ The from parameter points to a string
+ such as might be returned by PQgetvalue when applied
+ to a bytea column. PQunescapeBytea
+ converts this string representation into its binary representation.
+ It returns a pointer to a buffer allocated with
+ malloc(), or NULL on error, and puts the size of
+ the buffer in to_length. The result must be
+ freed using PQfreemem when it is no longer needed.
+
+ This conversion is not exactly the inverse of
+ PQescapeBytea, because the string is not expected
+ to be “escaped” when received from PQgetvalue.
+ In particular this means there is no need for string quoting considerations,
+ and so no need for a PGconn parameter.
+
34.8. The Fast-Path Interface #
+ PostgreSQL provides a fast-path interface
+ to send simple function calls to the server.
+
Tip
+ This interface is somewhat obsolete, as one can achieve similar
+ performance and greater functionality by setting up a prepared
+ statement to define the function call. Then, executing the statement
+ with binary transmission of parameters and results substitutes for a
+ fast-path function call.
+
+ The function PQfn
+ requests execution of a server function via the fast-path interface:
+
+PGresult *PQfn(PGconn *conn,
+ int fnid,
+ int *result_buf,
+ int *result_len,
+ int result_is_int,
+ const PQArgBlock *args,
+ int nargs);
+
+typedef struct
+{
+ int len;
+ int isint;
+ union
+ {
+ int *ptr;
+ int integer;
+ } u;
+} PQArgBlock;
+
+
+ The fnid argument is the OID of the function to be
+ executed. args and nargs define the
+ parameters to be passed to the function; they must match the declared
+ function argument list. When the isint field of a
+ parameter structure is true, the u.integer value is sent
+ to the server as an integer of the indicated length (this must be
+ 2 or 4 bytes); proper byte-swapping occurs. When isint
+ is false, the indicated number of bytes at *u.ptr are
+ sent with no processing; the data must be in the format expected by
+ the server for binary transmission of the function's argument data
+ type. (The declaration of u.ptr as being of
+ type int * is historical; it would be better to consider
+ it void *.)
+ result_buf points to the buffer in which to place
+ the function's return value. The caller must have allocated sufficient
+ space to store the return value. (There is no check!) The actual result
+ length in bytes will be returned in the integer pointed to by
+ result_len. If a 2- or 4-byte integer result
+ is expected, set result_is_int to 1, otherwise
+ set it to 0. Setting result_is_int to 1 causes
+ libpq to byte-swap the value if necessary, so that it
+ is delivered as a proper int value for the client machine;
+ note that a 4-byte integer is delivered into *result_buf
+ for either allowed result size.
+ When result_is_int is 0, the binary-format byte string
+ sent by the server is returned unmodified. (In this case it's better
+ to consider result_buf as being of
+ type void *.)
+
+ PQfn always returns a valid
+ PGresult pointer, with
+ status PGRES_COMMAND_OK for success
+ or PGRES_FATAL_ERROR if some problem was encountered.
+ The result status should be
+ checked before the result is used. The caller is responsible for
+ freeing the PGresult with
+ PQclear when it is no longer needed.
+
+ To pass a NULL argument to the function, set
+ the len field of that parameter structure
+ to -1; the isint
+ and u fields are then irrelevant.
+
+ If the function returns NULL, *result_len is set
+ to -1, and *result_buf is not
+ modified.
+
+ Note that it is not possible to handle set-valued results when using
+ this interface. Also, the function must be a plain function, not an
+ aggregate, window function, or procedure.
+
34.18. LDAP Lookup of Connection Parameters #
+ If libpq has been compiled with LDAP support (option
+ --with-ldapconfigure)
+ it is possible to retrieve connection options like host
+ or dbname via LDAP from a central server.
+ The advantage is that if the connection parameters for a database change,
+ the connection information doesn't have to be updated on all client machines.
+
+ LDAP connection parameter lookup uses the connection service file
+ pg_service.conf (see Section 34.17). A line in a
+ pg_service.conf stanza that starts with
+ ldap:// will be recognized as an LDAP URL and an
+ LDAP query will be performed. The result must be a list of
+ keyword = value pairs which will be used to set
+ connection options. The URL must conform to
+ RFC 1959
+ and be of the form
+
+ldap://[hostname[:port]]/search_base?attribute?search_scope?filter
+
+ where hostname defaults to
+ localhost and port
+ defaults to 389.
+
+ Processing of pg_service.conf is terminated after
+ a successful LDAP lookup, but is continued if the LDAP server cannot
+ be contacted. This is to provide a fallback with further LDAP URL
+ lines that point to different LDAP servers, classical keyword
+ = value pairs, or default connection options. If you would
+ rather get an error message in this case, add a syntactically incorrect
+ line after the LDAP URL.
+
+ A sample LDAP entry that has been created with the LDIF file
+
+version:1
+dn:cn=mydatabase,dc=mycompany,dc=com
+changetype:add
+objectclass:top
+objectclass:device
+cn:mydatabase
+description:host=dbserver.mycompany.com
+description:port=5439
+description:dbname=mydb
+description:user=mydb_user
+description:sslmode=require
+
+ might be queried with the following LDAP URL:
+
+ldap://ldap.mycompany.com/dc=mycompany,dc=com?description?one?(cn=mydatabase)
+
+
+ You can also mix regular service file entries with LDAP lookups.
+ A complete example for a stanza in pg_service.conf
+ would be:
+
+# only host and port are stored in LDAP, specify dbname and user explicitly
+[customerdb]
+dbname=customer
+user=appuser
+ldap://ldap.acme.com/cn=dbserver,cn=hosts?pgconnectinfo?base?(objectclass=*)
+
+
34.12. Miscellaneous Functions #
+ As always, there are some functions that just don't fit anywhere.
+
PQfreemem #
+ Frees memory allocated by libpq.
+
+void PQfreemem(void *ptr);
+
+
+ Frees memory allocated by libpq, particularly
+ PQescapeByteaConn,
+ PQescapeBytea,
+ PQunescapeBytea,
+ and PQnotifies.
+ It is particularly important that this function, rather than
+ free(), be used on Microsoft Windows. This is because
+ allocating memory in a DLL and releasing it in the application works
+ only if multithreaded/single-threaded, release/debug, and static/dynamic
+ flags are the same for the DLL and the application. On non-Microsoft
+ Windows platforms, this function is the same as the standard library
+ function free().
+
PQconninfoFree #
+ Frees the data structures allocated by
+ PQconndefaults or PQconninfoParse.
+
+void PQconninfoFree(PQconninfoOption *connOptions);
+
+ If the argument is a NULL pointer, no operation is
+ performed.
+
+ A simple PQfreemem will not do for this, since
+ the array contains references to subsidiary strings.
+
PQencryptPasswordConn #
+ Prepares the encrypted form of a PostgreSQL password.
+
+char *PQencryptPasswordConn(PGconn *conn, const char *passwd, const char *user, const char *algorithm);
+
+ This function is intended to be used by client applications that
+ wish to send commands like ALTER USER joe PASSWORD
+ 'pwd'. It is good practice not to send the original cleartext
+ password in such a command, because it might be exposed in command
+ logs, activity displays, and so on. Instead, use this function to
+ convert the password to encrypted form before it is sent.
+
+ The passwd and user arguments
+ are the cleartext password, and the SQL name of the user it is for.
+ algorithm specifies the encryption algorithm
+ to use to encrypt the password. Currently supported algorithms are
+ md5 and scram-sha-256 (on and
+ off are also accepted as aliases for md5, for
+ compatibility with older server versions). Note that support for
+ scram-sha-256 was introduced in PostgreSQL
+ version 10, and will not work correctly with older server versions. If
+ algorithm is NULL, this function will query
+ the server for the current value of the
+ password_encryption setting. That can block, and
+ will fail if the current transaction is aborted, or if the connection
+ is busy executing another query. If you wish to use the default
+ algorithm for the server but want to avoid blocking, query
+ password_encryption yourself before calling
+ PQencryptPasswordConn, and pass that value as the
+ algorithm.
+
+ The return value is a string allocated by malloc.
+ The caller can assume the string doesn't contain any special characters
+ that would require escaping. Use PQfreemem to free the
+ result when done with it. On error, returns NULL, and
+ a suitable message is stored in the connection object.
+
PQencryptPassword #
+ Prepares the md5-encrypted form of a PostgreSQL password.
+
+char *PQencryptPassword(const char *passwd, const char *user);
+
+ PQencryptPassword is an older, deprecated version of
+ PQencryptPasswordConn. The difference is that
+ PQencryptPassword does not
+ require a connection object, and md5 is always used as the
+ encryption algorithm.
+
PQmakeEmptyPGresult #
+ Constructs an empty PGresult object with the given status.
+
+PGresult *PQmakeEmptyPGresult(PGconn *conn, ExecStatusType status);
+
+
+ This is libpq's internal function to allocate and
+ initialize an empty PGresult object. This
+ function returns NULL if memory could not be allocated. It is
+ exported because some applications find it useful to generate result
+ objects (particularly objects with error status) themselves. If
+ conn is not null and status
+ indicates an error, the current error message of the specified
+ connection is copied into the PGresult.
+ Also, if conn is not null, any event procedures
+ registered in the connection are copied into the
+ PGresult. (They do not get
+ PGEVT_RESULTCREATE calls, but see
+ PQfireResultCreateEvents.)
+ Note that PQclear should eventually be called
+ on the object, just as with a PGresult
+ returned by libpq itself.
+
PQfireResultCreateEvents #
+ Fires a PGEVT_RESULTCREATE event (see Section 34.14) for each event procedure registered in the
+ PGresult object. Returns non-zero for success,
+ zero if any event procedure fails.
+
+
+int PQfireResultCreateEvents(PGconn *conn, PGresult *res);
+
+
+ The conn argument is passed through to event procedures
+ but not used directly. It can be NULL if the event
+ procedures won't use it.
+
+ Event procedures that have already received a
+ PGEVT_RESULTCREATE or PGEVT_RESULTCOPY event
+ for this object are not fired again.
+
+ The main reason that this function is separate from
+ PQmakeEmptyPGresult is that it is often appropriate
+ to create a PGresult and fill it with data
+ before invoking the event procedures.
+
PQcopyResult #
+ Makes a copy of a PGresult object. The copy is
+ not linked to the source result in any way and
+ PQclear must be called when the copy is no longer
+ needed. If the function fails, NULL is returned.
+
+
+PGresult *PQcopyResult(const PGresult *src, int flags);
+
+
+ This is not intended to make an exact copy. The returned result is
+ always put into PGRES_TUPLES_OK status, and does not
+ copy any error message in the source. (It does copy the command status
+ string, however.) The flags argument determines
+ what else is copied. It is a bitwise OR of several flags.
+ PG_COPYRES_ATTRS specifies copying the source
+ result's attributes (column definitions).
+ PG_COPYRES_TUPLES specifies copying the source
+ result's tuples. (This implies copying the attributes, too.)
+ PG_COPYRES_NOTICEHOOKS specifies
+ copying the source result's notify hooks.
+ PG_COPYRES_EVENTS specifies copying the source
+ result's events. (But any instance data associated with the source
+ is not copied.)
+ The event procedures receive PGEVT_RESULTCOPY events.
+
PQsetResultAttrs #
+ Sets the attributes of a PGresult object.
+
+int PQsetResultAttrs(PGresult *res, int numAttributes, PGresAttDesc *attDescs);
+
+
+ The provided attDescs are copied into the result.
+ If the attDescs pointer is NULL or
+ numAttributes is less than one, the request is
+ ignored and the function succeeds. If res
+ already contains attributes, the function will fail. If the function
+ fails, the return value is zero. If the function succeeds, the return
+ value is non-zero.
+
PQsetvalue #
+ Sets a tuple field value of a PGresult object.
+
+int PQsetvalue(PGresult *res, int tup_num, int field_num, char *value, int len);
+
+
+ The function will automatically grow the result's internal tuples array
+ as needed. However, the tup_num argument must be
+ less than or equal to PQntuples, meaning this
+ function can only grow the tuples array one tuple at a time. But any
+ field of any existing tuple can be modified in any order. If a value at
+ field_num already exists, it will be overwritten.
+ If len is -1 or
+ value is NULL, the field value
+ will be set to an SQL null value. The
+ value is copied into the result's private storage,
+ thus is no longer needed after the function
+ returns. If the function fails, the return value is zero. If the
+ function succeeds, the return value is non-zero.
+
PQresultAlloc #
+ Allocate subsidiary storage for a PGresult object.
+
+void *PQresultAlloc(PGresult *res, size_t nBytes);
+
+
+ Any memory allocated with this function will be freed when
+ res is cleared. If the function fails,
+ the return value is NULL. The result is
+ guaranteed to be adequately aligned for any type of data,
+ just as for malloc.
+
PQresultMemorySize #
+ Retrieves the number of bytes allocated for
+ a PGresult object.
+
+size_t PQresultMemorySize(const PGresult *res);
+
+
+ This value is the sum of all malloc requests
+ associated with the PGresult object, that is,
+ all the space that will be freed by PQclear.
+ This information can be useful for managing memory consumption.
+
PQlibVersion #
+ Return the version of libpq that is being used.
+
+int PQlibVersion(void);
+
+
+ The result of this function can be used to determine, at
+ run time, whether specific functionality is available in the currently
+ loaded version of libpq. The function can be used, for example,
+ to determine which connection options are available in
+ PQconnectdb.
+
+ The result is formed by multiplying the library's major version
+ number by 10000 and adding the minor version number. For example,
+ version 10.1 will be returned as 100001, and version 11.0 will be
+ returned as 110000.
+
+ Prior to major version 10, PostgreSQL used
+ three-part version numbers in which the first two parts together
+ represented the major version. For those
+ versions, PQlibVersion uses two digits for each
+ part; for example version 9.1.5 will be returned as 90105, and
+ version 9.2.0 will be returned as 90200.
+
+ Therefore, for purposes of determining feature compatibility,
+ applications should divide the result of PQlibVersion
+ by 100 not 10000 to determine a logical major version number.
+ In all release series, only the last two digits differ between
+ minor releases (bug-fix releases).
+
Note
+ This function appeared in PostgreSQL version 9.1, so
+ it cannot be used to detect required functionality in earlier
+ versions, since calling it will create a link dependency
+ on version 9.1 or later.
+
34.13. Notice Processing #
+ Notice and warning messages generated by the server are not returned
+ by the query execution functions, since they do not imply failure of
+ the query. Instead they are passed to a notice handling function, and
+ execution continues normally after the handler returns. The default
+ notice handling function prints the message on
+ stderr, but the application can override this
+ behavior by supplying its own handling function.
+
+ For historical reasons, there are two levels of notice handling, called
+ the notice receiver and notice processor. The default behavior is for
+ the notice receiver to format the notice and pass a string to the notice
+ processor for printing. However, an application that chooses to provide
+ its own notice receiver will typically ignore the notice processor
+ layer and just do all the work in the notice receiver.
+
+ The function PQsetNoticeReceiver
+
+ sets or
+ examines the current notice receiver for a connection object.
+ Similarly, PQsetNoticeProcessor
+
+ sets or
+ examines the current notice processor.
+
+
+typedef void (*PQnoticeReceiver) (void *arg, const PGresult *res);
+
+PQnoticeReceiver
+PQsetNoticeReceiver(PGconn *conn,
+ PQnoticeReceiver proc,
+ void *arg);
+
+typedef void (*PQnoticeProcessor) (void *arg, const char *message);
+
+PQnoticeProcessor
+PQsetNoticeProcessor(PGconn *conn,
+ PQnoticeProcessor proc,
+ void *arg);
+
+
+ Each of these functions returns the previous notice receiver or
+ processor function pointer, and sets the new value. If you supply a
+ null function pointer, no action is taken, but the current pointer is
+ returned.
+
+ When a notice or warning message is received from the server, or
+ generated internally by libpq, the notice
+ receiver function is called. It is passed the message in the form of
+ a PGRES_NONFATAL_ERROR
+ PGresult. (This allows the receiver to extract
+ individual fields using PQresultErrorField, or obtain a
+ complete preformatted message using PQresultErrorMessage
+ or PQresultVerboseErrorMessage.) The same
+ void pointer passed to PQsetNoticeReceiver is also
+ passed. (This pointer can be used to access application-specific state
+ if needed.)
+
+ The default notice receiver simply extracts the message (using
+ PQresultErrorMessage) and passes it to the notice
+ processor.
+
+ The notice processor is responsible for handling a notice or warning
+ message given in text form. It is passed the string text of the message
+ (including a trailing newline), plus a void pointer that is the same
+ one passed to PQsetNoticeProcessor. (This pointer
+ can be used to access application-specific state if needed.)
+
+ The default notice processor is simply:
+
+static void
+defaultNoticeProcessor(void *arg, const char *message)
+{
+ fprintf(stderr, "%s", message);
+}
+
+
+ Once you have set a notice receiver or processor, you should expect
+ that that function could be called as long as either the
+ PGconn object or PGresult objects made
+ from it exist. At creation of a PGresult, the
+ PGconn's current notice handling pointers are copied
+ into the PGresult for possible use by functions like
+ PQgetvalue.
+
34.9. Asynchronous Notification #
+ PostgreSQL offers asynchronous notification
+ via the LISTEN and NOTIFY
+ commands. A client session registers its interest in a particular
+ notification channel with the LISTEN command (and
+ can stop listening with the UNLISTEN command). All
+ sessions listening on a particular channel will be notified
+ asynchronously when a NOTIFY command with that
+ channel name is executed by any session. A “payload” string can
+ be passed to communicate additional data to the listeners.
+
+ libpq applications submit
+ LISTEN, UNLISTEN,
+ and NOTIFY commands as
+ ordinary SQL commands. The arrival of NOTIFY
+ messages can subsequently be detected by calling
+ PQnotifies.
+
+ The function PQnotifies returns the next notification
+ from a list of unhandled notification messages received from the server.
+ It returns a null pointer if there are no pending notifications. Once a
+ notification is returned from PQnotifies, it is considered
+ handled and will be removed from the list of notifications.
+
+
+PGnotify *PQnotifies(PGconn *conn);
+
+typedef struct pgNotify
+{
+ char *relname; /* notification channel name */
+ int be_pid; /* process ID of notifying server process */
+ char *extra; /* notification payload string */
+} PGnotify;
+
+
+ After processing a PGnotify object returned
+ by PQnotifies, be sure to free it with
+ PQfreemem. It is sufficient to free the
+ PGnotify pointer; the
+ relname and extra
+ fields do not represent separate allocations. (The names of these fields
+ are historical; in particular, channel names need not have anything to
+ do with relation names.)
+
+ Example 34.2 gives a sample program that illustrates
+ the use of asynchronous notification.
+
+ PQnotifies does not actually read data from the
+ server; it just returns messages previously absorbed by another
+ libpq function. In ancient releases of
+ libpq, the only way to ensure timely receipt
+ of NOTIFY messages was to constantly submit commands, even
+ empty ones, and then check PQnotifies after each
+ PQexec. While this still works, it is deprecated
+ as a waste of processing power.
+
+ A better way to check for NOTIFY messages when you have no
+ useful commands to execute is to call
+ PQconsumeInput
+ , then check
+ PQnotifies. You can use
+ select() to wait for data to arrive from the
+ server, thereby using no CPU power unless there is
+ something to do. (See PQsocket to obtain the file
+ descriptor number to use with select().) Note that
+ this will work OK whether you submit commands with
+ PQsendQuery/PQgetResult or
+ simply use PQexec. You should, however, remember
+ to check PQnotifies after each
+ PQgetResult or PQexec, to
+ see if any notifications came in during the processing of the command.
+
34.16. The Password File #
+ The file .pgpass in a user's home directory can
+ contain passwords to
+ be used if the connection requires a password (and no password has been
+ specified otherwise). On Microsoft Windows the file is named
+ %APPDATA%\postgresql\pgpass.conf (where
+ %APPDATA% refers to the Application Data subdirectory in
+ the user's profile).
+ Alternatively, the password file to use can be specified
+ using the connection parameter passfile
+ or the environment variable PGPASSFILE.
+
+ This file should contain lines of the following format:
+
+hostname:port:database:username:password
+
+ (You can add a reminder comment to the file by copying the line above and
+ preceding it with #.)
+ Each of the first four fields can be a literal value, or
+ *, which matches anything. The password field from
+ the first line that matches the current connection parameters will be
+ used. (Therefore, put more-specific entries first when you are using
+ wildcards.) If an entry needs to contain : or
+ \, escape this character with \.
+ The host name field is matched to the host connection
+ parameter if that is specified, otherwise to
+ the hostaddr parameter if that is specified; if neither
+ are given then the host name localhost is searched for.
+ The host name localhost is also searched for when
+ the connection is a Unix-domain socket connection and
+ the host parameter
+ matches libpq's default socket directory path.
+ In a standby server, a database field of replication
+ matches streaming replication connections made to the primary server.
+ The database field is of limited usefulness otherwise, because users have
+ the same password for all databases in the same cluster.
+
+ On Unix systems, the permissions on a password file must
+ disallow any access to world or group; achieve this by a command such as
+ chmod 0600 ~/.pgpass. If the permissions are less
+ strict than this, the file will be ignored. On Microsoft Windows, it
+ is assumed that the file is stored in a directory that is secure, so
+ no special permissions check is made.
+
34.17. The Connection Service File #
+ The connection service file allows libpq connection parameters to be
+ associated with a single service name. That service name can then be
+ specified in a libpq connection string, and the associated settings will be
+ used. This allows connection parameters to be modified without requiring
+ a recompile of the libpq-using application. The service name can also be
+ specified using the PGSERVICE environment variable.
+
+ Service names can be defined in either a per-user service file or a
+ system-wide file. If the same service name exists in both the user
+ and the system file, the user file takes precedence.
+ By default, the per-user service file is named
+ ~/.pg_service.conf.
+ On Microsoft Windows, it is named
+ %APPDATA%\postgresql\.pg_service.conf (where
+ %APPDATA% refers to the Application Data subdirectory
+ in the user's profile). A different file name can be specified by
+ setting the environment variable PGSERVICEFILE.
+ The system-wide file is named pg_service.conf.
+ By default it is sought in the etc directory
+ of the PostgreSQL installation
+ (use pg_config --sysconfdir to identify this
+ directory precisely). Another directory, but not a different file
+ name, can be specified by setting the environment variable
+ PGSYSCONFDIR.
+
+ Either service file uses an “INI file” format where the section
+ name is the service name and the parameters are connection
+ parameters; see Section 34.1.2 for a list. For
+ example:
+
+# comment
+[mydb]
+host=somehost
+port=5433
+user=admin
+
+ An example file is provided in
+ the PostgreSQL installation at
+ share/pg_service.conf.sample.
+
+ Connection parameters obtained from a service file are combined with
+ parameters obtained from other sources. A service file setting
+ overrides the corresponding environment variable, and in turn can be
+ overridden by a value given directly in the connection string.
+ For example, using the above service file, a connection string
+ service=mydb port=5434 will use
+ host somehost, port 5434,
+ user admin, and other parameters as set by
+ environment variables or built-in defaults.
+
+ libpq pipeline mode allows applications to
+ send a query without having to read the result of the previously
+ sent query. Taking advantage of the pipeline mode, a client will wait
+ less for the server, since multiple queries/results can be
+ sent/received in a single network transaction.
+
+ While pipeline mode provides a significant performance boost, writing
+ clients using the pipeline mode is more complex because it involves
+ managing a queue of pending queries and finding which result
+ corresponds to which query in the queue.
+
+ Pipeline mode also generally consumes more memory on both the client and server,
+ though careful and aggressive management of the send/receive queue can mitigate
+ this. This applies whether or not the connection is in blocking or non-blocking
+ mode.
+
+ While libpq's pipeline API was introduced in
+ PostgreSQL 14, it is a client-side feature
+ which doesn't require special server support and works on any server
+ that supports the v3 extended query protocol. For more information see
+ Section 55.2.4.
+
34.5.1. Using Pipeline Mode #
+ To issue pipelines, the application must switch the connection
+ into pipeline mode,
+ which is done with PQenterPipelineMode.
+ PQpipelineStatus can be used
+ to test whether pipeline mode is active.
+ In pipeline mode, only asynchronous operations
+ that utilize the extended query protocol
+ are permitted, command strings containing multiple SQL commands are
+ disallowed, and so is COPY.
+ Using synchronous command execution functions
+ such as PQfn,
+ PQexec,
+ PQexecParams,
+ PQprepare,
+ PQexecPrepared,
+ PQdescribePrepared,
+ PQdescribePortal,
+ is an error condition.
+ PQsendQuery is
+ also disallowed, because it uses the simple query protocol.
+ Once all dispatched commands have had their results processed, and
+ the end pipeline result has been consumed, the application may return
+ to non-pipelined mode with PQexitPipelineMode.
+
Note
+ It is best to use pipeline mode with libpq in
+ non-blocking mode. If used
+ in blocking mode it is possible for a client/server deadlock to occur.
+
+
34.5.1.1. Issuing Queries #
+ After entering pipeline mode, the application dispatches requests using
+ PQsendQueryParams
+ or its prepared-query sibling
+ PQsendQueryPrepared.
+ These requests are queued on the client-side until flushed to the server;
+ this occurs when PQpipelineSync is used to
+ establish a synchronization point in the pipeline,
+ or when PQflush is called.
+ The functions PQsendPrepare,
+ PQsendDescribePrepared, and
+ PQsendDescribePortal also work in pipeline mode.
+ Result processing is described below.
+
+ The server executes statements, and returns results, in the order the
+ client sends them. The server will begin executing the commands in the
+ pipeline immediately, not waiting for the end of the pipeline.
+ Note that results are buffered on the server side; the server flushes
+ that buffer when a synchronization point is established with
+ PQpipelineSync, or when
+ PQsendFlushRequest is called.
+ If any statement encounters an error, the server aborts the current
+ transaction and does not execute any subsequent command in the queue
+ until the next synchronization point;
+ a PGRES_PIPELINE_ABORTED result is produced for
+ each such command.
+ (This remains true even if the commands in the pipeline would rollback
+ the transaction.)
+ Query processing resumes after the synchronization point.
+
+ It's fine for one operation to depend on the results of a
+ prior one; for example, one query may define a table that the next
+ query in the same pipeline uses. Similarly, an application may
+ create a named prepared statement and execute it with later
+ statements in the same pipeline.
+
34.5.1.2. Processing Results #
+ To process the result of one query in a pipeline, the application calls
+ PQgetResult repeatedly and handles each result
+ until PQgetResult returns null.
+ The result from the next query in the pipeline may then be retrieved using
+ PQgetResult again and the cycle repeated.
+ The application handles individual statement results as normal.
+ When the results of all the queries in the pipeline have been
+ returned, PQgetResult returns a result
+ containing the status value PGRES_PIPELINE_SYNC
+
+ The client may choose to defer result processing until the complete
+ pipeline has been sent, or interleave that with sending further
+ queries in the pipeline; see Section 34.5.1.4.
+
+ To enter single-row mode, call PQsetSingleRowMode
+ before retrieving results with PQgetResult.
+ This mode selection is effective only for the query currently
+ being processed. For more information on the use of
+ PQsetSingleRowMode,
+ refer to Section 34.6.
+
+ PQgetResult behaves the same as for normal
+ asynchronous processing except that it may contain the new
+ PGresult types PGRES_PIPELINE_SYNC
+ and PGRES_PIPELINE_ABORTED.
+ PGRES_PIPELINE_SYNC is reported exactly once for each
+ PQpipelineSync at the corresponding point
+ in the pipeline.
+ PGRES_PIPELINE_ABORTED is emitted in place of a normal
+ query result for the first error and all subsequent results
+ until the next PGRES_PIPELINE_SYNC;
+ see Section 34.5.1.3.
+
+ PQisBusy, PQconsumeInput, etc
+ operate as normal when processing pipeline results. In particular,
+ a call to PQisBusy in the middle of a pipeline
+ returns 0 if the results for all the queries issued so far have been
+ consumed.
+
+ libpq does not provide any information to the
+ application about the query currently being processed (except that
+ PQgetResult returns null to indicate that we start
+ returning the results of next query). The application must keep track
+ of the order in which it sent queries, to associate them with their
+ corresponding results.
+ Applications will typically use a state machine or a FIFO queue for this.
+
34.5.1.3. Error Handling #
+ From the client's perspective, after PQresultStatus
+ returns PGRES_FATAL_ERROR,
+ the pipeline is flagged as aborted.
+ PQresultStatus will report a
+ PGRES_PIPELINE_ABORTED result for each remaining queued
+ operation in an aborted pipeline. The result for
+ PQpipelineSync is reported as
+ PGRES_PIPELINE_SYNC to signal the end of the aborted pipeline
+ and resumption of normal result processing.
+
+ The client must process results with
+ PQgetResult during error recovery.
+
+ If the pipeline used an implicit transaction, then operations that have
+ already executed are rolled back and operations that were queued to follow
+ the failed operation are skipped entirely. The same behavior holds if the
+ pipeline starts and commits a single explicit transaction (i.e. the first
+ statement is BEGIN and the last is
+ COMMIT) except that the session remains in an aborted
+ transaction state at the end of the pipeline. If a pipeline contains
+ multiple explicit transactions, all transactions that
+ committed prior to the error remain committed, the currently in-progress
+ transaction is aborted, and all subsequent operations are skipped completely,
+ including subsequent transactions. If a pipeline synchronization point
+ occurs with an explicit transaction block in aborted state, the next pipeline
+ will become aborted immediately unless the next command puts the transaction
+ in normal mode with ROLLBACK.
+
Note
+ The client must not assume that work is committed when it
+ sends a COMMIT — only when the
+ corresponding result is received to confirm the commit is complete.
+ Because errors arrive asynchronously, the application needs to be able to
+ restart from the last received committed change and
+ resend work done after that point if something goes wrong.
+
34.5.1.4. Interleaving Result Processing and Query Dispatch #
+ To avoid deadlocks on large pipelines the client should be structured
+ around a non-blocking event loop using operating system facilities
+ such as select, poll,
+ WaitForMultipleObjectEx, etc.
+
+ The client application should generally maintain a queue of work
+ remaining to be dispatched and a queue of work that has been dispatched
+ but not yet had its results processed. When the socket is writable
+ it should dispatch more work. When the socket is readable it should
+ read results and process them, matching them up to the next entry in
+ its corresponding results queue. Based on available memory, results from the
+ socket should be read frequently: there's no need to wait until the
+ pipeline end to read the results. Pipelines should be scoped to logical
+ units of work, usually (but not necessarily) one transaction per pipeline.
+ There's no need to exit pipeline mode and re-enter it between pipelines,
+ or to wait for one pipeline to finish before sending the next.
+
+ An example using select() and a simple state
+ machine to track sent and received work is in
+ src/test/modules/libpq_pipeline/libpq_pipeline.c
+ in the PostgreSQL source distribution.
+
34.5.2. Functions Associated with Pipeline Mode #
PQpipelineStatus #
+ Returns the current pipeline mode status of the
+ libpq connection.
+
+PGpipelineStatus PQpipelineStatus(const PGconn *conn);
+
+
+ PQpipelineStatus can return one of the following values:
+
+
-
+
PQ_PIPELINE_ON
+
+ The libpq connection is in
+ pipeline mode.
+
-
+
PQ_PIPELINE_OFF
+
+ The libpq connection is
+ not in pipeline mode.
+
-
+
PQ_PIPELINE_ABORTED
+
+ The libpq connection is in pipeline
+ mode and an error occurred while processing the current pipeline.
+ The aborted flag is cleared when PQgetResult
+ returns a result of type PGRES_PIPELINE_SYNC.
+
+
PQenterPipelineMode #
+ Causes a connection to enter pipeline mode if it is currently idle or
+ already in pipeline mode.
+
+
+int PQenterPipelineMode(PGconn *conn);
+
+
+
+ Returns 1 for success.
+ Returns 0 and has no effect if the connection is not currently
+ idle, i.e., it has a result ready, or it is waiting for more
+ input from the server, etc.
+ This function does not actually send anything to the server,
+ it just changes the libpq connection
+ state.
+
PQexitPipelineMode #
+ Causes a connection to exit pipeline mode if it is currently in pipeline mode
+ with an empty queue and no pending results.
+
+int PQexitPipelineMode(PGconn *conn);
+
+
+ Returns 1 for success. Returns 1 and takes no action if not in
+ pipeline mode. If the current statement isn't finished processing,
+ or PQgetResult has not been called to collect
+ results from all previously sent query, returns 0 (in which case,
+ use PQerrorMessage to get more information
+ about the failure).
+
PQpipelineSync #
+ Marks a synchronization point in a pipeline by sending a
+ sync message
+ and flushing the send buffer. This serves as
+ the delimiter of an implicit transaction and an error recovery
+ point; see Section 34.5.1.3.
+
+
+int PQpipelineSync(PGconn *conn);
+
+
+ Returns 1 for success. Returns 0 if the connection is not in
+ pipeline mode or sending a
+ sync message
+ failed.
+
PQsendFlushRequest #
+ Sends a request for the server to flush its output buffer.
+
+int PQsendFlushRequest(PGconn *conn);
+
+
+ Returns 1 for success. Returns 0 on any failure.
+
+ The server flushes its output buffer automatically as a result of
+ PQpipelineSync being called, or
+ on any request when not in pipeline mode; this function is useful
+ to cause the server to flush its output buffer in pipeline mode
+ without establishing a synchronization point.
+ Note that the request is not itself flushed to the server automatically;
+ use PQflush if necessary.
+
34.5.3. When to Use Pipeline Mode #
+ Much like asynchronous query mode, there is no meaningful performance
+ overhead when using pipeline mode. It increases client application complexity,
+ and extra caution is required to prevent client/server deadlocks, but
+ pipeline mode can offer considerable performance improvements, in exchange for
+ increased memory usage from leaving state around longer.
+
+ Pipeline mode is most useful when the server is distant, i.e., network latency
+ (“ping time”) is high, and also when many small operations
+ are being performed in rapid succession. There is usually less benefit
+ in using pipelined commands when each query takes many multiples of the client/server
+ round-trip time to execute. A 100-statement operation run on a server
+ 300 ms round-trip-time away would take 30 seconds in network latency alone
+ without pipelining; with pipelining it may spend as little as 0.3 s waiting for
+ results from the server.
+
+ Use pipelined commands when your application does lots of small
+ INSERT, UPDATE and
+ DELETE operations that can't easily be transformed
+ into operations on sets, or into a COPY operation.
+
+ Pipeline mode is not useful when information from one operation is required by
+ the client to produce the next operation. In such cases, the client
+ would have to introduce a synchronization point and wait for a full client/server
+ round-trip to get the results it needs. However, it's often possible to
+ adjust the client design to exchange the required information server-side.
+ Read-modify-write cycles are especially good candidates; for example:
+
+BEGIN;
+SELECT x FROM mytable WHERE id = 42 FOR UPDATE;
+-- result: x=2
+-- client adds 1 to x:
+UPDATE mytable SET x = 3 WHERE id = 42;
+COMMIT;
+
+ could be much more efficiently done with:
+
+UPDATE mytable SET x = x + 1 WHERE id = 42;
+
+
+ Pipelining is less useful, and more complex, when a single pipeline contains
+ multiple transactions (see Section 34.5.1.3).
+
34.6. Retrieving Query Results Row-by-Row #
+ Ordinarily, libpq collects an SQL command's
+ entire result and returns it to the application as a single
+ PGresult. This can be unworkable for commands
+ that return a large number of rows. For such cases, applications can use
+ PQsendQuery and PQgetResult in
+ single-row mode. In this mode, the result row(s) are
+ returned to the application one at a time, as they are received from the
+ server.
+
+ To enter single-row mode, call PQsetSingleRowMode
+ immediately after a successful call of PQsendQuery
+ (or a sibling function). This mode selection is effective only for the
+ currently executing query. Then call PQgetResult
+ repeatedly, until it returns null, as documented in Section 34.4. If the query returns any rows, they are returned
+ as individual PGresult objects, which look like
+ normal query results except for having status code
+ PGRES_SINGLE_TUPLE instead of
+ PGRES_TUPLES_OK. After the last row, or immediately if
+ the query returns zero rows, a zero-row object with status
+ PGRES_TUPLES_OK is returned; this is the signal that no
+ more rows will arrive. (But note that it is still necessary to continue
+ calling PQgetResult until it returns null.) All of
+ these PGresult objects will contain the same row
+ description data (column names, types, etc.) that an ordinary
+ PGresult object for the query would have.
+ Each object should be freed with PQclear as usual.
+
+ When using pipeline mode, single-row mode needs to be activated for each
+ query in the pipeline before retrieving results for that query
+ with PQgetResult.
+ See Section 34.5 for more information.
+
+
PQsetSingleRowMode #
+ Select single-row mode for the currently-executing query.
+
+
+int PQsetSingleRowMode(PGconn *conn);
+
+
+ This function can only be called immediately after
+ PQsendQuery or one of its sibling functions,
+ before any other operation on the connection such as
+ PQconsumeInput
+ or
+ PQgetResult. If called at the correct time,
+ the function activates single-row mode for the current query and
+ returns 1. Otherwise the mode stays unchanged and the function
+ returns 0. In any case, the mode reverts to normal after
+ completion of the current query.
+
+
Caution
+ While processing a query, the server may return some rows and then
+ encounter an error, causing the query to be aborted. Ordinarily,
+ libpq discards any such rows and reports only the
+ error. But in single-row mode, those rows will have already been
+ returned to the application. Hence, the application will see some
+ PGRES_SINGLE_TUPLE PGresult
+ objects followed by a PGRES_FATAL_ERROR object. For
+ proper transactional behavior, the application must be designed to
+ discard or undo whatever has been done with the previously-processed
+ rows, if the query ultimately fails.
+
+ PostgreSQL has native support for using SSL
+ connections to encrypt client/server communications using
+ TLS protocols for increased security.
+ See Section 19.9 for details about the server-side
+ SSL functionality.
+
+ libpq reads the system-wide
+ OpenSSL configuration file. By default, this
+ file is named openssl.cnf and is located in the
+ directory reported by openssl version -d. This default
+ can be overridden by setting environment variable
+ OPENSSL_CONF to the name of the desired configuration
+ file.
+
34.19.1. Client Verification of Server Certificates #
+ By default, PostgreSQL will not perform any verification of
+ the server certificate. This means that it is possible to spoof the server
+ identity (for example by modifying a DNS record or by taking over the server
+ IP address) without the client knowing. In order to prevent spoofing,
+ the client must be able to verify the server's identity via a chain of
+ trust. A chain of trust is established by placing a root (self-signed)
+ certificate authority (CA) certificate on one
+ computer and a leaf certificate signed by the
+ root certificate on another computer. It is also possible to use an
+ “intermediate” certificate which is signed by the root
+ certificate and signs leaf certificates.
+
+ To allow the client to verify the identity of the server, place a root
+ certificate on the client and a leaf certificate signed by the root
+ certificate on the server. To allow the server to verify the identity
+ of the client, place a root certificate on the server and a leaf
+ certificate signed by the root certificate on the client. One or more
+ intermediate certificates (usually stored with the leaf certificate)
+ can also be used to link the leaf certificate to the root certificate.
+
+ Once a chain of trust has been established, there are two ways for
+ the client to validate the leaf certificate sent by the server.
+ If the parameter sslmode is set to verify-ca,
+ libpq will verify that the server is trustworthy by checking the
+ certificate chain up to the root certificate stored on the client.
+ If sslmode is set to verify-full,
+ libpq will also verify that the server host
+ name matches the name stored in the server certificate. The
+ SSL connection will fail if the server certificate cannot be
+ verified. verify-full is recommended in most
+ security-sensitive environments.
+
+ In verify-full mode, the host name is matched against the
+ certificate's Subject Alternative Name attribute(s) (SAN), or against the
+ Common Name attribute if no SAN of type dNSName is
+ present. If the certificate's name attribute starts with an asterisk
+ (*), the asterisk will be treated as
+ a wildcard, which will match all characters except a dot
+ (.). This means the certificate will not match subdomains.
+ If the connection is made using an IP address instead of a host name, the
+ IP address will be matched (without doing any DNS lookups) against SANs of
+ type iPAddress or dNSName. If no
+ iPAddress SAN is present and no
+ matching dNSName SAN is present, the host IP address is
+ matched against the Common Name attribute.
+
Note
+ For backward compatibility with earlier versions of PostgreSQL, the host
+ IP address is verified in a manner different
+ from RFC 6125.
+ The host IP address is always matched against dNSName
+ SANs as well as iPAddress SANs, and can be matched
+ against the Common Name attribute if no relevant SANs exist.
+
+ To allow server certificate verification, one or more root certificates
+ must be placed in the file ~/.postgresql/root.crt
+ in the user's home directory. (On Microsoft Windows the file is named
+ %APPDATA%\postgresql\root.crt.) Intermediate
+ certificates should also be added to the file if they are needed to link
+ the certificate chain sent by the server to the root certificates
+ stored on the client.
+
+ Certificate Revocation List (CRL) entries are also checked
+ if the file ~/.postgresql/root.crl exists
+ (%APPDATA%\postgresql\root.crl on Microsoft
+ Windows).
+
+ The location of the root certificate file and the CRL can be changed by
+ setting
+ the connection parameters sslrootcert and sslcrl
+ or the environment variables PGSSLROOTCERT and PGSSLCRL.
+ sslcrldir or the environment variable PGSSLCRLDIR
+ can also be used to specify a directory containing CRL files.
+
Note
+ For backwards compatibility with earlier versions of PostgreSQL, if a
+ root CA file exists, the behavior of
+ sslmode=require will be the same
+ as that of verify-ca, meaning the server certificate
+ is validated against the CA. Relying on this behavior is discouraged,
+ and applications that need certificate validation should always use
+ verify-ca or verify-full.
+
34.19.2. Client Certificates #
+ If the server attempts to verify the identity of the
+ client by requesting the client's leaf certificate,
+ libpq will send the certificate(s) stored in
+ file ~/.postgresql/postgresql.crt in the user's home
+ directory. The certificates must chain to the root certificate trusted
+ by the server. A matching
+ private key file ~/.postgresql/postgresql.key must also
+ be present.
+ On Microsoft Windows these files are named
+ %APPDATA%\postgresql\postgresql.crt and
+ %APPDATA%\postgresql\postgresql.key.
+ The location of the certificate and key files can be overridden by the
+ connection parameters sslcert
+ and sslkey, or by the
+ environment variables PGSSLCERT and PGSSLKEY.
+
+ On Unix systems, the permissions on the private key file must disallow
+ any access to world or group; achieve this by a command such as
+ chmod 0600 ~/.postgresql/postgresql.key.
+ Alternatively, the file can be owned by root and have group read access
+ (that is, 0640 permissions). That setup is intended
+ for installations where certificate and key files are managed by the
+ operating system. The user of libpq should
+ then be made a member of the group that has access to those certificate
+ and key files. (On Microsoft Windows, there is no file permissions
+ check, since the %APPDATA%\postgresql directory is
+ presumed secure.)
+
+ The first certificate in postgresql.crt must be the
+ client's certificate because it must match the client's private key.
+ “Intermediate” certificates can be optionally appended
+ to the file — doing so avoids requiring storage of intermediate
+ certificates on the server (ssl_ca_file).
+
+ The certificate and key may be in PEM or ASN.1 DER format.
+
+ The key may be
+ stored in cleartext or encrypted with a passphrase using any algorithm
+ supported by OpenSSL, like AES-128. If the key
+ is stored encrypted, then the passphrase may be provided in the
+ sslpassword connection option. If an
+ encrypted key is supplied and the sslpassword option
+ is absent or blank, a password will be prompted for interactively by
+ OpenSSL with a
+ Enter PEM pass phrase: prompt if a TTY is available.
+ Applications can override the client certificate prompt and the handling
+ of the sslpassword parameter by supplying their own
+ key password callback; see
+ PQsetSSLKeyPassHook_OpenSSL.
+
+ For instructions on creating certificates, see Section 19.9.5.
+
34.19.3. Protection Provided in Different Modes #
+ The different values for the sslmode parameter provide different
+ levels of protection. SSL can provide
+ protection against three types of attacks:
+
+
- Eavesdropping
If a third party can examine the network traffic between the
+ client and the server, it can read both connection information (including
+ the user name and password) and the data that is passed. SSL
+ uses encryption to prevent this.
+
- Man-in-the-middle (MITM)
If a third party can modify the data while passing between the
+ client and server, it can pretend to be the server and therefore see and
+ modify data even if it is encrypted. The third party can then
+ forward the connection information and data to the original server,
+ making it impossible to detect this attack. Common vectors to do this
+ include DNS poisoning and address hijacking, whereby the client is directed
+ to a different server than intended. There are also several other
+ attack methods that can accomplish this. SSL uses certificate
+ verification to prevent this, by authenticating the server to the client.
+
- Impersonation
If a third party can pretend to be an authorized client, it can
+ simply access data it should not have access to. Typically this can
+ happen through insecure password management. SSL uses
+ client certificates to prevent this, by making sure that only holders
+ of valid certificates can access the server.
+
+
+ For a connection to be known SSL-secured, SSL usage must be configured
+ on both the client and the server before the connection
+ is made. If it is only configured on the server, the client may end up
+ sending sensitive information (e.g., passwords) before
+ it knows that the server requires high security. In libpq, secure
+ connections can be ensured
+ by setting the sslmode parameter to verify-full or
+ verify-ca, and providing the system with a root certificate to
+ verify against. This is analogous to using an https
+ URL for encrypted web browsing.
+
+ Once the server has been authenticated, the client can pass sensitive data.
+ This means that up until this point, the client does not need to know if
+ certificates will be used for authentication, making it safe to specify that
+ only in the server configuration.
+
+ All SSL options carry overhead in the form of encryption and
+ key-exchange, so there is a trade-off that has to be made between performance
+ and security. Table 34.1
+ illustrates the risks the different sslmode values
+ protect against, and what statement they make about security and overhead.
+
Table 34.1. SSL Mode Descriptions
sslmode | Eavesdropping protection | MITM protection | Statement |
|---|
disable | No | No | I don't care about security, and I don't want to pay the overhead
+ of encryption.
+ |
allow | Maybe | No | I don't care about security, but I will pay the overhead of
+ encryption if the server insists on it.
+ |
prefer | Maybe | No | I don't care about encryption, but I wish to pay the overhead of
+ encryption if the server supports it.
+ |
require | Yes | No | I want my data to be encrypted, and I accept the overhead. I trust
+ that the network will make sure I always connect to the server I want.
+ |
verify-ca | Yes | Depends on CA policy | I want my data encrypted, and I accept the overhead. I want to be
+ sure that I connect to a server that I trust.
+ |
verify-full | Yes | Yes | I want my data encrypted, and I accept the overhead. I want to be
+ sure that I connect to a server I trust, and that it's the one I
+ specify.
+ |
+ The difference between verify-ca and verify-full
+ depends on the policy of the root CA. If a public
+ CA is used, verify-ca allows connections to a server
+ that somebody else may have registered with the CA.
+ In this case, verify-full should always be used. If
+ a local CA is used, or even a self-signed certificate, using
+ verify-ca often provides enough protection.
+
+ The default value for sslmode is prefer. As is shown
+ in the table, this makes no sense from a security point of view, and it only
+ promises performance overhead if possible. It is only provided as the default
+ for backward compatibility, and is not recommended in secure deployments.
+
34.19.4. SSL Client File Usage #
+ Table 34.2 summarizes the files that are
+ relevant to the SSL setup on the client.
+
Table 34.2. Libpq/Client SSL File Usage
| File | Contents | Effect |
|---|
~/.postgresql/postgresql.crt | client certificate | sent to server |
~/.postgresql/postgresql.key | client private key | proves client certificate sent by owner; does not indicate
+ certificate owner is trustworthy |
~/.postgresql/root.crt | trusted certificate authorities | checks that server certificate is signed by a trusted certificate
+ authority |
~/.postgresql/root.crl | certificates revoked by certificate authorities | server certificate must not be on this list |
34.19.5. SSL Library Initialization #
+ If your application initializes libssl and/or
+ libcrypto libraries and libpq
+ is built with SSL support, you should call
+ PQinitOpenSSL to tell libpq
+ that the libssl and/or libcrypto libraries
+ have been initialized by your application, so that
+ libpq will not also initialize those libraries.
+ However, this is unnecessary when using OpenSSL
+ version 1.1.0 or later, as duplicate initializations are no longer problematic.
+
+
PQinitOpenSSL #
+ Allows applications to select which security libraries to initialize.
+
+void PQinitOpenSSL(int do_ssl, int do_crypto);
+
+
+ When do_ssl is non-zero, libpq
+ will initialize the OpenSSL library before first
+ opening a database connection. When do_crypto is
+ non-zero, the libcrypto library will be initialized. By
+ default (if PQinitOpenSSL is not called), both libraries
+ are initialized. When SSL support is not compiled in, this function is
+ present but does nothing.
+
+ If your application uses and initializes either OpenSSL
+ or its underlying libcrypto library, you must
+ call this function with zeroes for the appropriate parameter(s)
+ before first opening a database connection. Also be sure that you
+ have done that initialization before opening a database connection.
+
PQinitSSL #
+ Allows applications to select which security libraries to initialize.
+
+void PQinitSSL(int do_ssl);
+
+
+ This function is equivalent to
+ PQinitOpenSSL(do_ssl, do_ssl).
+ It is sufficient for applications that initialize both or neither
+ of OpenSSL and libcrypto.
+
+ PQinitSSL has been present since
+ PostgreSQL 8.0, while PQinitOpenSSL
+ was added in PostgreSQL 8.4, so PQinitSSL
+ might be preferable for applications that need to work with older
+ versions of libpq.
+
+
34.2. Connection Status Functions #
+ These functions can be used to interrogate the status
+ of an existing database connection object.
+
Tip
+
+
+ libpq application programmers should be careful to
+ maintain the PGconn abstraction. Use the accessor
+ functions described below to get at the contents of PGconn.
+ Reference to internal PGconn fields using
+ libpq-int.h is not recommended because they are subject to change
+ in the future.
+
+ The following functions return parameter values established at connection.
+ These values are fixed for the life of the connection. If a multi-host
+ connection string is used, the values of PQhost,
+ PQport, and PQpass can change if a new connection
+ is established using the same PGconn object. Other values
+ are fixed for the lifetime of the PGconn object.
+
+
PQdb #
+ Returns the database name of the connection.
+
+char *PQdb(const PGconn *conn);
+
+
PQuser #
+ Returns the user name of the connection.
+
+char *PQuser(const PGconn *conn);
+
+
PQpass #
+ Returns the password of the connection.
+
+char *PQpass(const PGconn *conn);
+
+
+ PQpass will return either the password specified
+ in the connection parameters, or if there was none and the password
+ was obtained from the password
+ file, it will return that. In the latter case,
+ if multiple hosts were specified in the connection parameters, it is
+ not possible to rely on the result of PQpass until
+ the connection is established. The status of the connection can be
+ checked using the function PQstatus.
+
PQhost #
+ Returns the server host name of the active connection.
+ This can be a host name, an IP address, or a directory path if the
+ connection is via Unix socket. (The path case can be distinguished
+ because it will always be an absolute path, beginning
+ with /.)
+
+char *PQhost(const PGconn *conn);
+
+
+ If the connection parameters specified both host and
+ hostaddr, then PQhost will
+ return the host information. If only
+ hostaddr was specified, then that is returned.
+ If multiple hosts were specified in the connection parameters,
+ PQhost returns the host actually connected to.
+
+ PQhost returns NULL if the
+ conn argument is NULL.
+ Otherwise, if there is an error producing the host information (perhaps
+ if the connection has not been fully established or there was an
+ error), it returns an empty string.
+
+ If multiple hosts were specified in the connection parameters, it is
+ not possible to rely on the result of PQhost until
+ the connection is established. The status of the connection can be
+ checked using the function PQstatus.
+
PQhostaddr #
+ Returns the server IP address of the active connection.
+ This can be the address that a host name resolved to,
+ or an IP address provided through the hostaddr
+ parameter.
+
+char *PQhostaddr(const PGconn *conn);
+
+
+ PQhostaddr returns NULL if the
+ conn argument is NULL.
+ Otherwise, if there is an error producing the host information
+ (perhaps if the connection has not been fully established or
+ there was an error), it returns an empty string.
+
PQport #
+ Returns the port of the active connection.
+
+
+char *PQport(const PGconn *conn);
+
+
+ If multiple ports were specified in the connection parameters,
+ PQport returns the port actually connected to.
+
+ PQport returns NULL if the
+ conn argument is NULL.
+ Otherwise, if there is an error producing the port information (perhaps
+ if the connection has not been fully established or there was an
+ error), it returns an empty string.
+
+ If multiple ports were specified in the connection parameters, it is
+ not possible to rely on the result of PQport until
+ the connection is established. The status of the connection can be
+ checked using the function PQstatus.
+
PQtty #
+ This function no longer does anything, but it remains for backwards
+ compatibility. The function always return an empty string, or
+ NULL if the conn argument is
+ NULL.
+
+
+char *PQtty(const PGconn *conn);
+
+
PQoptions #
+ Returns the command-line options passed in the connection request.
+
+char *PQoptions(const PGconn *conn);
+
+
+
+ The following functions return status data that can change as operations
+ are executed on the PGconn object.
+
+
PQstatus #
+ Returns the status of the connection.
+
+ConnStatusType PQstatus(const PGconn *conn);
+
+
+ The status can be one of a number of values. However, only two of
+ these are seen outside of an asynchronous connection procedure:
+ CONNECTION_OK and
+ CONNECTION_BAD. A good connection to the database
+ has the status CONNECTION_OK. A failed
+ connection attempt is signaled by status
+ CONNECTION_BAD. Ordinarily, an OK status will
+ remain so until PQfinish, but a communications
+ failure might result in the status changing to
+ CONNECTION_BAD prematurely. In that case the
+ application could try to recover by calling
+ PQreset.
+
+ See the entry for PQconnectStartParams, PQconnectStart
+ and PQconnectPoll with regards to other status codes that
+ might be returned.
+
PQtransactionStatus #
+ Returns the current in-transaction status of the server.
+
+
+PGTransactionStatusType PQtransactionStatus(const PGconn *conn);
+
+
+ The status can be PQTRANS_IDLE (currently idle),
+ PQTRANS_ACTIVE (a command is in progress),
+ PQTRANS_INTRANS (idle, in a valid transaction block),
+ or PQTRANS_INERROR (idle, in a failed transaction block).
+ PQTRANS_UNKNOWN is reported if the connection is bad.
+ PQTRANS_ACTIVE is reported only when a query
+ has been sent to the server and not yet completed.
+
PQparameterStatus #
+ Looks up a current parameter setting of the server.
+
+
+const char *PQparameterStatus(const PGconn *conn, const char *paramName);
+
+
+ Certain parameter values are reported by the server automatically at
+ connection startup or whenever their values change.
+ PQparameterStatus can be used to interrogate these settings.
+ It returns the current value of a parameter if known, or NULL
+ if the parameter is not known.
+
+ Parameters reported as of the current release include:
+
application_name | is_superuser |
client_encoding | scram_iterations |
DateStyle | server_encoding |
default_transaction_read_only | server_version |
in_hot_standby | session_authorization |
integer_datetimes | standard_conforming_strings |
IntervalStyle | TimeZone |
+ (server_encoding, TimeZone, and
+ integer_datetimes were not reported by releases before 8.0;
+ standard_conforming_strings was not reported by releases
+ before 8.1;
+ IntervalStyle was not reported by releases before 8.4;
+ application_name was not reported by releases before
+ 9.0;
+ default_transaction_read_only and
+ in_hot_standby were not reported by releases before
+ 14; scram_iterations was not reported by releases
+ before 16.)
+ Note that
+ server_version,
+ server_encoding and
+ integer_datetimes
+ cannot change after startup.
+
+ If no value for standard_conforming_strings is reported,
+ applications can assume it is off, that is, backslashes
+ are treated as escapes in string literals. Also, the presence of
+ this parameter can be taken as an indication that the escape string
+ syntax (E'...') is accepted.
+
+ Although the returned pointer is declared const, it in fact
+ points to mutable storage associated with the PGconn structure.
+ It is unwise to assume the pointer will remain valid across queries.
+
PQprotocolVersion #
+ Interrogates the frontend/backend protocol being used.
+
+int PQprotocolVersion(const PGconn *conn);
+
+ Applications might wish to use this function to determine whether certain
+ features are supported. Currently, the possible values are 3
+ (3.0 protocol), or zero (connection bad). The protocol version will
+ not change after connection startup is complete, but it could
+ theoretically change during a connection reset. The 3.0 protocol is
+ supported by PostgreSQL server versions 7.4
+ and above.
+
PQserverVersion #
+ Returns an integer representing the server version.
+
+int PQserverVersion(const PGconn *conn);
+
+
+ Applications might use this function to determine the version of the
+ database server they are connected to. The result is formed by
+ multiplying the server's major version number by 10000 and adding
+ the minor version number. For example, version 10.1 will be
+ returned as 100001, and version 11.0 will be returned as 110000.
+ Zero is returned if the connection is bad.
+
+ Prior to major version 10, PostgreSQL used
+ three-part version numbers in which the first two parts together
+ represented the major version. For those
+ versions, PQserverVersion uses two digits for each
+ part; for example version 9.1.5 will be returned as 90105, and
+ version 9.2.0 will be returned as 90200.
+
+ Therefore, for purposes of determining feature compatibility,
+ applications should divide the result of PQserverVersion
+ by 100 not 10000 to determine a logical major version number.
+ In all release series, only the last two digits differ between
+ minor releases (bug-fix releases).
+
PQerrorMessage #
+ Returns the error message
+ most recently generated by an operation on the connection.
+
+
+char *PQerrorMessage(const PGconn *conn);
+
+
+
+ Nearly all libpq functions will set a message for
+ PQerrorMessage if they fail. Note that by
+ libpq convention, a nonempty
+ PQerrorMessage result can consist of multiple lines,
+ and will include a trailing newline. The caller should not free
+ the result directly. It will be freed when the associated
+ PGconn handle is passed to
+ PQfinish. The result string should not be
+ expected to remain the same across operations on the
+ PGconn structure.
+
PQsocket #
+ Obtains the file descriptor number of the connection socket to
+ the server. A valid descriptor will be greater than or equal
+ to 0; a result of -1 indicates that no server connection is
+ currently open. (This will not change during normal operation,
+ but could change during connection setup or reset.)
+
+
+int PQsocket(const PGconn *conn);
+
+
+
PQbackendPID #
+ Returns the process ID (PID)
+ of the backend process handling this connection.
+
+
+int PQbackendPID(const PGconn *conn);
+
+
+ The backend PID is useful for debugging
+ purposes and for comparison to NOTIFY
+ messages (which include the PID of the
+ notifying backend process). Note that the
+ PID belongs to a process executing on the
+ database server host, not the local host!
+
PQconnectionNeedsPassword #
+ Returns true (1) if the connection authentication method
+ required a password, but none was available.
+ Returns false (0) if not.
+
+
+int PQconnectionNeedsPassword(const PGconn *conn);
+
+
+ This function can be applied after a failed connection attempt
+ to decide whether to prompt the user for a password.
+
PQconnectionUsedPassword #
+ Returns true (1) if the connection authentication method
+ used a password. Returns false (0) if not.
+
+
+int PQconnectionUsedPassword(const PGconn *conn);
+
+
+ This function can be applied after either a failed or successful
+ connection attempt to detect whether the server demanded a password.
+
PQconnectionUsedGSSAPI #
+ Returns true (1) if the connection authentication method
+ used GSSAPI. Returns false (0) if not.
+
+
+int PQconnectionUsedGSSAPI(const PGconn *conn);
+
+
+ This function can be applied to detect whether the connection was
+ authenticated with GSSAPI.
+
+
+ The following functions return information related to SSL. This information
+ usually doesn't change after a connection is established.
+
+
PQsslInUse #
+ Returns true (1) if the connection uses SSL, false (0) if not.
+
+
+int PQsslInUse(const PGconn *conn);
+
+
PQsslAttribute #
+ Returns SSL-related information about the connection.
+
+
+const char *PQsslAttribute(const PGconn *conn, const char *attribute_name);
+
+
+ The list of available attributes varies depending on the SSL library
+ being used and the type of connection. Returns NULL if the connection
+ does not use SSL or the specified attribute name is not defined for the
+ library in use.
+
+ The following attributes are commonly available:
+
library
+ Name of the SSL implementation in use. (Currently, only
+ "OpenSSL" is implemented)
+
protocol
+ SSL/TLS version in use. Common values
+ are "TLSv1", "TLSv1.1"
+ and "TLSv1.2", but an implementation may
+ return other strings if some other protocol is used.
+
key_bits
+ Number of key bits used by the encryption algorithm.
+
cipher
+ A short name of the ciphersuite used, e.g.,
+ "DHE-RSA-DES-CBC3-SHA". The names are specific
+ to each SSL implementation.
+
compression
+ Returns "on" if SSL compression is in use, else it returns "off".
+
+
+ As a special case, the library attribute may be
+ queried without a connection by passing NULL as
+ the conn argument. The result will be the default
+ SSL library name, or NULL if libpq was
+ compiled without any SSL support. (Prior
+ to PostgreSQL version 15, passing NULL as
+ the conn argument always resulted in NULL.
+ Client programs needing to differentiate between the newer and older
+ implementations of this case may check the
+ LIBPQ_HAS_SSL_LIBRARY_DETECTION feature macro.)
+
PQsslAttributeNames #
+ Returns an array of SSL attribute names that can be used
+ in PQsslAttribute().
+ The array is terminated by a NULL pointer.
+
+const char * const * PQsslAttributeNames(const PGconn *conn);
+
+
+ If conn is NULL, the attributes available for the
+ default SSL library are returned, or an empty list
+ if libpq was compiled without any SSL
+ support. If conn is not NULL, the attributes
+ available for the SSL library in use for the connection are returned,
+ or an empty list if the connection is not encrypted.
+
PQsslStruct #
+ Returns a pointer to an SSL-implementation-specific object describing
+ the connection. Returns NULL if the connection is not encrypted
+ or the requested type of object is not available from the connection's
+ SSL implementation.
+
+void *PQsslStruct(const PGconn *conn, const char *struct_name);
+
+
+ The struct(s) available depend on the SSL implementation in use.
+ For OpenSSL, there is one struct,
+ available under the name OpenSSL,
+ and it returns a pointer to
+ OpenSSL's SSL struct.
+ To use this function, code along the following lines could be used:
+
+#include <libpq-fe.h>
+#include <openssl/ssl.h>
+
+...
+
+ SSL *ssl;
+
+ dbconn = PQconnectdb(...);
+ ...
+
+ ssl = PQsslStruct(dbconn, "OpenSSL");
+ if (ssl)
+ {
+ /* use OpenSSL functions to access ssl */
+ }
+
+
+ This structure can be used to verify encryption levels, check server
+ certificates, and more. Refer to the OpenSSL
+ documentation for information about this structure.
+
PQgetssl #
+
+ Returns the SSL structure used in the connection, or NULL
+ if SSL is not in use.
+
+
+void *PQgetssl(const PGconn *conn);
+
+
+ This function is equivalent to PQsslStruct(conn, "OpenSSL"). It should
+ not be used in new applications, because the returned struct is
+ specific to OpenSSL and will not be
+ available if another SSL implementation is used.
+ To check if a connection uses SSL, call
+ PQsslInUse instead, and for more details about the
+ connection, use PQsslAttribute.
+
+
34.20. Behavior in Threaded Programs #
+ libpq is reentrant and thread-safe by default.
+ You might need to use special compiler command-line
+ options when you compile your application code. Refer to your
+ system's documentation for information about how to build
+ thread-enabled applications, or look in
+ src/Makefile.global for PTHREAD_CFLAGS
+ and PTHREAD_LIBS. This function allows the querying of
+ libpq's thread-safe status:
+
PQisthreadsafe #
+ Returns the thread safety status of the
+ libpq library.
+
+int PQisthreadsafe();
+
+
+ Returns 1 if the libpq is thread-safe
+ and 0 if it is not.
+
+ One thread restriction is that no two threads attempt to manipulate
+ the same PGconn object at the same time. In particular,
+ you cannot issue concurrent commands from different threads through
+ the same connection object. (If you need to run concurrent commands,
+ use multiple connections.)
+
+ PGresult objects are normally read-only after creation,
+ and so can be passed around freely between threads. However, if you use
+ any of the PGresult-modifying functions described in
+ Section 34.12 or Section 34.14, it's up
+ to you to avoid concurrent operations on the same PGresult,
+ too.
+
+ The deprecated functions PQrequestCancel and
+ PQoidStatus are not thread-safe and should not be
+ used in multithread programs. PQrequestCancel
+ can be replaced by PQcancel.
+ PQoidStatus can be replaced by
+ PQoidValue.
+
+ If you are using Kerberos inside your application (in addition to inside
+ libpq), you will need to do locking around
+ Kerberos calls because Kerberos functions are not thread-safe. See
+ function PQregisterThreadLock in the
+ libpq source code for a way to do cooperative
+ locking between libpq and your application.
+
Chapter 34. libpq — C Library
+ libpq is the C
+ application programmer's interface to PostgreSQL.
+ libpq is a set of library functions that allow
+ client programs to pass queries to the PostgreSQL
+ backend server and to receive the results of these queries.
+
+ libpq is also the underlying engine for several
+ other PostgreSQL application interfaces, including
+ those written for C++, Perl, Python, Tcl and ECPG.
+ So some aspects of libpq's behavior will be
+ important to you if you use one of those packages. In particular,
+ Section 34.15,
+ Section 34.16 and
+ Section 34.19
+ describe behavior that is visible to the user of any application
+ that uses libpq.
+
+ Some short programs are included at the end of this chapter (Section 34.22) to show how
+ to write programs that use libpq. There are also several
+ complete examples of libpq applications in the
+ directory src/test/examples in the source code distribution.
+
+ Client programs that use libpq must
+ include the header file
+ libpq-fe.h
+ and must link with the libpq library.
+
Appendix K. PostgreSQL Limits
+ Table K.1 describes various hard limits of
+ PostgreSQL. However, practical limits, such as
+ performance limitations or available disk space may apply before absolute
+ hard limits are reached.
+
Table K.1. PostgreSQL Limitations
| Item | Upper Limit | Comment |
|---|
| database size | unlimited | |
| number of databases | 4,294,950,911 | |
| relations per database | 1,431,650,303 | |
| relation size | 32 TB | with the default BLCKSZ of 8192 bytes |
| rows per table | limited by the number of tuples that can fit onto 4,294,967,295 pages | |
| columns per table | 1,600 | further limited by tuple size fitting on a single page; see note
+ below |
| columns in a result set | 1,664 | |
| field size | 1 GB | |
| indexes per table | unlimited | constrained by maximum relations per database |
| columns per index | 32 | can be increased by recompiling PostgreSQL |
| partition keys | 32 | can be increased by recompiling PostgreSQL |
| identifier length | 63 bytes | can be increased by recompiling PostgreSQL |
| function arguments | 100 | can be increased by recompiling PostgreSQL |
| query parameters | 65,535 | |
+ The maximum number of columns for a table is further reduced as the tuple
+ being stored must fit in a single 8192-byte heap page. For example,
+ excluding the tuple header, a tuple made up of 1,600 int columns
+ would consume 6400 bytes and could be stored in a heap page, but a tuple of
+ 1,600 bigint columns would consume 12800 bytes and would
+ therefore not fit inside a heap page.
+ Variable-length fields of
+ types such as text, varchar, and char
+ can have their values stored out of line in the table's TOAST table when the
+ values are large enough to require it. Only an 18-byte pointer must remain
+ inside the tuple in the table's heap. For shorter length variable-length
+ fields, either a 4-byte or 1-byte field header is used and the value is
+ stored inside the heap tuple.
+
+ Columns that have been dropped from the table also contribute to the maximum
+ column limit. Moreover, although the dropped column values for newly
+ created tuples are internally marked as null in the tuple's null bitmap, the
+ null bitmap also occupies space.
+
+ Example 35.1 is a sample program which shows how the large object
+ interface
+ in libpq can be used. Parts of the program are
+ commented out but are left in the source for the reader's
+ benefit. This program can also be found in
+ src/test/examples/testlo.c in the source distribution.
+
Example 35.1. Large Objects with libpq Example Program
+/*-----------------------------------------------------------------
+ *
+ * testlo.c
+ * test using large objects with libpq
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * src/test/examples/testlo.c
+ *
+ *-----------------------------------------------------------------
+ */
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+#include "libpq-fe.h"
+#include "libpq/libpq-fs.h"
+
+#define BUFSIZE 1024
+
+/*
+ * importFile -
+ * import file "in_filename" into database as large object "lobjOid"
+ *
+ */
+static Oid
+importFile(PGconn *conn, char *filename)
+{
+ Oid lobjId;
+ int lobj_fd;
+ char buf[BUFSIZE];
+ int nbytes,
+ tmp;
+ int fd;
+
+ /*
+ * open the file to be read in
+ */
+ fd = open(filename, O_RDONLY, 0666);
+ if (fd < 0)
+ { /* error */
+ fprintf(stderr, "cannot open unix file\"%s\"\n", filename);
+ }
+
+ /*
+ * create the large object
+ */
+ lobjId = lo_creat(conn, INV_READ | INV_WRITE);
+ if (lobjId == 0)
+ fprintf(stderr, "cannot create large object");
+
+ lobj_fd = lo_open(conn, lobjId, INV_WRITE);
+
+ /*
+ * read in from the Unix file and write to the inversion file
+ */
+ while ((nbytes = read(fd, buf, BUFSIZE)) > 0)
+ {
+ tmp = lo_write(conn, lobj_fd, buf, nbytes);
+ if (tmp < nbytes)
+ fprintf(stderr, "error while reading \"%s\"", filename);
+ }
+
+ close(fd);
+ lo_close(conn, lobj_fd);
+
+ return lobjId;
+}
+
+static void
+pickout(PGconn *conn, Oid lobjId, int start, int len)
+{
+ int lobj_fd;
+ char *buf;
+ int nbytes;
+ int nread;
+
+ lobj_fd = lo_open(conn, lobjId, INV_READ);
+ if (lobj_fd < 0)
+ fprintf(stderr, "cannot open large object %u", lobjId);
+
+ lo_lseek(conn, lobj_fd, start, SEEK_SET);
+ buf = malloc(len + 1);
+
+ nread = 0;
+ while (len - nread > 0)
+ {
+ nbytes = lo_read(conn, lobj_fd, buf, len - nread);
+ buf[nbytes] = '\0';
+ fprintf(stderr, ">>> %s", buf);
+ nread += nbytes;
+ if (nbytes <= 0)
+ break; /* no more data? */
+ }
+ free(buf);
+ fprintf(stderr, "\n");
+ lo_close(conn, lobj_fd);
+}
+
+static void
+overwrite(PGconn *conn, Oid lobjId, int start, int len)
+{
+ int lobj_fd;
+ char *buf;
+ int nbytes;
+ int nwritten;
+ int i;
+
+ lobj_fd = lo_open(conn, lobjId, INV_WRITE);
+ if (lobj_fd < 0)
+ fprintf(stderr, "cannot open large object %u", lobjId);
+
+ lo_lseek(conn, lobj_fd, start, SEEK_SET);
+ buf = malloc(len + 1);
+
+ for (i = 0; i < len; i++)
+ buf[i] = 'X';
+ buf[i] = '\0';
+
+ nwritten = 0;
+ while (len - nwritten > 0)
+ {
+ nbytes = lo_write(conn, lobj_fd, buf + nwritten, len - nwritten);
+ nwritten += nbytes;
+ if (nbytes <= 0)
+ {
+ fprintf(stderr, "\nWRITE FAILED!\n");
+ break;
+ }
+ }
+ free(buf);
+ fprintf(stderr, "\n");
+ lo_close(conn, lobj_fd);
+}
+
+
+/*
+ * exportFile -
+ * export large object "lobjOid" to file "out_filename"
+ *
+ */
+static void
+exportFile(PGconn *conn, Oid lobjId, char *filename)
+{
+ int lobj_fd;
+ char buf[BUFSIZE];
+ int nbytes,
+ tmp;
+ int fd;
+
+ /*
+ * open the large object
+ */
+ lobj_fd = lo_open(conn, lobjId, INV_READ);
+ if (lobj_fd < 0)
+ fprintf(stderr, "cannot open large object %u", lobjId);
+
+ /*
+ * open the file to be written to
+ */
+ fd = open(filename, O_CREAT | O_WRONLY | O_TRUNC, 0666);
+ if (fd < 0)
+ { /* error */
+ fprintf(stderr, "cannot open unix file\"%s\"",
+ filename);
+ }
+
+ /*
+ * read in from the inversion file and write to the Unix file
+ */
+ while ((nbytes = lo_read(conn, lobj_fd, buf, BUFSIZE)) > 0)
+ {
+ tmp = write(fd, buf, nbytes);
+ if (tmp < nbytes)
+ {
+ fprintf(stderr, "error while writing \"%s\"",
+ filename);
+ }
+ }
+
+ lo_close(conn, lobj_fd);
+ close(fd);
+}
+
+static void
+exit_nicely(PGconn *conn)
+{
+ PQfinish(conn);
+ exit(1);
+}
+
+int
+main(int argc, char **argv)
+{
+ char *in_filename,
+ *out_filename;
+ char *database;
+ Oid lobjOid;
+ PGconn *conn;
+ PGresult *res;
+
+ if (argc != 4)
+ {
+ fprintf(stderr, "Usage: %s database_name in_filename out_filename\n",
+ argv[0]);
+ exit(1);
+ }
+
+ database = argv[1];
+ in_filename = argv[2];
+ out_filename = argv[3];
+
+ /*
+ * set up the connection
+ */
+ conn = PQsetdb(NULL, NULL, NULL, NULL, database);
+
+ /* check to see that the backend connection was successfully made */
+ if (PQstatus(conn) != CONNECTION_OK)
+ {
+ fprintf(stderr, "%s", PQerrorMessage(conn));
+ exit_nicely(conn);
+ }
+
+ /* Set always-secure search path, so malicious users can't take control. */
+ res = PQexec(conn,
+ "SELECT pg_catalog.set_config('search_path', '', false)");
+ if (PQresultStatus(res) != PGRES_TUPLES_OK)
+ {
+ fprintf(stderr, "SET failed: %s", PQerrorMessage(conn));
+ PQclear(res);
+ exit_nicely(conn);
+ }
+ PQclear(res);
+
+ res = PQexec(conn, "begin");
+ PQclear(res);
+ printf("importing file \"%s\" ...\n", in_filename);
+/* lobjOid = importFile(conn, in_filename); */
+ lobjOid = lo_import(conn, in_filename);
+ if (lobjOid == 0)
+ fprintf(stderr, "%s\n", PQerrorMessage(conn));
+ else
+ {
+ printf("\tas large object %u.\n", lobjOid);
+
+ printf("picking out bytes 1000-2000 of the large object\n");
+ pickout(conn, lobjOid, 1000, 1000);
+
+ printf("overwriting bytes 1000-2000 of the large object with X's\n");
+ overwrite(conn, lobjOid, 1000, 1000);
+
+ printf("exporting large object to file \"%s\" ...\n", out_filename);
+/* exportFile(conn, lobjOid, out_filename); */
+ if (lo_export(conn, lobjOid, out_filename) < 0)
+ fprintf(stderr, "%s\n", PQerrorMessage(conn));
+ }
+
+ res = PQexec(conn, "end");
+ PQclear(res);
+ PQfinish(conn);
+ return 0;
+}
+
+35.4. Server-Side Functions #
+ Server-side functions tailored for manipulating large objects from SQL are
+ listed in Table 35.1.
+
Table 35.1. SQL-Oriented Large Object Functions
+ Function
+
+
+ Description
+
+
+ Example(s)
+ |
|---|
+
+ lo_from_bytea ( loid oid, data bytea )
+ → oid
+
+
+ Creates a large object and stores data in it.
+ If loid is zero then the system will choose a
+ free OID, otherwise that OID is used (with an error if some large
+ object already has that OID). On success, the large object's OID is
+ returned.
+
+
+ lo_from_bytea(0, '\xffffff00')
+ → 24528
+ |
+
+ lo_put ( loid oid, offset bigint, data bytea )
+ → void
+
+
+ Writes data starting at the given offset within
+ the large object; the large object is enlarged if necessary.
+
+
+ lo_put(24528, 1, '\xaa')
+ → |
+
+ lo_get ( loid oid [, offset bigint, length integer ] )
+ → bytea
+
+
+ Extracts the large object's contents, or a substring thereof.
+
+
+ lo_get(24528, 0, 3)
+ → \xffaaff
+ |
+ There are additional server-side functions corresponding to each of the
+ client-side functions described earlier; indeed, for the most part the
+ client-side functions are simply interfaces to the equivalent server-side
+ functions. The ones just as convenient to call via SQL commands are
+ lo_creat,
+ lo_create,
+ lo_unlink,
+ lo_import, and
+ lo_export.
+ Here are examples of their use:
+
+
+CREATE TABLE image (
+ name text,
+ raster oid
+);
+
+SELECT lo_creat(-1); -- returns OID of new, empty large object
+
+SELECT lo_create(43213); -- attempts to create large object with OID 43213
+
+SELECT lo_unlink(173454); -- deletes large object with OID 173454
+
+INSERT INTO image (name, raster)
+ VALUES ('beautiful image', lo_import('/etc/motd'));
+
+INSERT INTO image (name, raster) -- same as above, but specify OID to use
+ VALUES ('beautiful image', lo_import('/etc/motd', 68583));
+
+SELECT lo_export(image.raster, '/tmp/motd') FROM image
+ WHERE name = 'beautiful image';
+
+
+ The server-side lo_import and
+ lo_export functions behave considerably differently
+ from their client-side analogs. These two functions read and write files
+ in the server's file system, using the permissions of the database's
+ owning user. Therefore, by default their use is restricted to superusers.
+ In contrast, the client-side import and export functions read and write
+ files in the client's file system, using the permissions of the client
+ program. The client-side functions do not require any database
+ privileges, except the privilege to read or write the large object in
+ question.
+
Caution
+ It is possible to GRANT use of the
+ server-side lo_import
+ and lo_export functions to non-superusers, but
+ careful consideration of the security implications is required. A
+ malicious user of such privileges could easily parlay them into becoming
+ superuser (for example by rewriting server configuration files), or could
+ attack the rest of the server's file system without bothering to obtain
+ database superuser privileges as such. Access to roles having
+ such privilege must therefore be guarded just as carefully as access to
+ superuser roles. Nonetheless, if use of
+ server-side lo_import
+ or lo_export is needed for some routine task, it's
+ safer to use a role with such privileges than one with full superuser
+ privileges, as that helps to reduce the risk of damage from accidental
+ errors.
+
+ The functionality of lo_read and
+ lo_write is also available via server-side calls,
+ but the names of the server-side functions differ from the client side
+ interfaces in that they do not contain underscores. You must call
+ these functions as loread and lowrite.
+
35.2. Implementation Features #
+ The large object implementation breaks large
+ objects up into “chunks” and stores the chunks in
+ rows in the database. A B-tree index guarantees fast
+ searches for the correct chunk number when doing random
+ access reads and writes.
+
+ The chunks stored for a large object do not have to be contiguous.
+ For example, if an application opens a new large object, seeks to offset
+ 1000000, and writes a few bytes there, this does not result in allocation
+ of 1000000 bytes worth of storage; only of chunks covering the range of
+ data bytes actually written. A read operation will, however, read out
+ zeroes for any unallocated locations preceding the last existing chunk.
+ This corresponds to the common behavior of “sparsely allocated”
+ files in Unix file systems.
+
+ As of PostgreSQL 9.0, large objects have an owner
+ and a set of access permissions, which can be managed using
+ GRANT and
+ REVOKE.
+ SELECT privileges are required to read a large
+ object, and
+ UPDATE privileges are required to write or
+ truncate it.
+ Only the large object's owner (or a database superuser) can delete,
+ comment on, or change the owner of a large object.
+ To adjust this behavior for compatibility with prior releases, see the
+ lo_compat_privileges run-time parameter.
+
35.3. Client Interfaces #
+ This section describes the facilities that
+ PostgreSQL's libpq
+ client interface library provides for accessing large objects.
+ The PostgreSQL large object interface is
+ modeled after the Unix file-system interface, with
+ analogues of open, read,
+ write,
+ lseek, etc.
+
+ All large object manipulation using these functions
+ must take place within an SQL transaction block,
+ since large object file descriptors are only valid for the duration of
+ a transaction. Write operations, including lo_open
+ with the INV_WRITE mode, are not allowed in a read-only
+ transaction.
+
+ If an error occurs while executing any one of these functions, the
+ function will return an otherwise-impossible value, typically 0 or -1.
+ A message describing the error is stored in the connection object and
+ can be retrieved with PQerrorMessage.
+
+ Client applications that use these functions should include the header file
+ libpq/libpq-fs.h and link with the
+ libpq library.
+
+ Client applications cannot use these functions while a libpq connection is in pipeline mode.
+
35.3.1. Creating a Large Object #
+
+ The function
+
+Oid lo_create(PGconn *conn, Oid lobjId);
+
+ creates a new large object. The OID to be assigned can be
+ specified by lobjId;
+ if so, failure occurs if that OID is already in use for some large
+ object. If lobjId
+ is InvalidOid (zero) then lo_create
+ assigns an unused OID.
+ The return value is the OID that was assigned to the new large object,
+ or InvalidOid (zero) on failure.
+
+ An example:
+
+inv_oid = lo_create(conn, desired_oid);
+
+
+
+ The older function
+
+Oid lo_creat(PGconn *conn, int mode);
+
+ also creates a new large object, always assigning an unused OID.
+ The return value is the OID that was assigned to the new large object,
+ or InvalidOid (zero) on failure.
+
+ In PostgreSQL releases 8.1 and later,
+ the mode is ignored,
+ so that lo_creat is exactly equivalent to
+ lo_create with a zero second argument.
+ However, there is little reason to use lo_creat
+ unless you need to work with servers older than 8.1.
+ To work with such an old server, you must
+ use lo_creat not lo_create,
+ and you must set mode to
+ one of INV_READ, INV_WRITE,
+ or INV_READ | INV_WRITE.
+ (These symbolic constants are defined
+ in the header file libpq/libpq-fs.h.)
+
+ An example:
+
+inv_oid = lo_creat(conn, INV_READ|INV_WRITE);
+
+
35.3.2. Importing a Large Object #
+
+ To import an operating system file as a large object, call
+
+Oid lo_import(PGconn *conn, const char *filename);
+
+ filename
+ specifies the operating system name of
+ the file to be imported as a large object.
+ The return value is the OID that was assigned to the new large object,
+ or InvalidOid (zero) on failure.
+ Note that the file is read by the client interface library, not by
+ the server; so it must exist in the client file system and be readable
+ by the client application.
+
+
+ The function
+
+Oid lo_import_with_oid(PGconn *conn, const char *filename, Oid lobjId);
+
+ also imports a new large object. The OID to be assigned can be
+ specified by lobjId;
+ if so, failure occurs if that OID is already in use for some large
+ object. If lobjId
+ is InvalidOid (zero) then lo_import_with_oid assigns an unused
+ OID (this is the same behavior as lo_import).
+ The return value is the OID that was assigned to the new large object,
+ or InvalidOid (zero) on failure.
+
+ lo_import_with_oid is new as of PostgreSQL
+ 8.4 and uses lo_create internally which is new in 8.1; if this function is run against 8.0 or before, it will
+ fail and return InvalidOid.
+
35.3.3. Exporting a Large Object #
+
+ To export a large object
+ into an operating system file, call
+
+int lo_export(PGconn *conn, Oid lobjId, const char *filename);
+
+ The lobjId argument specifies the OID of the large
+ object to export and the filename argument
+ specifies the operating system name of the file. Note that the file is
+ written by the client interface library, not by the server. Returns 1
+ on success, -1 on failure.
+
35.3.4. Opening an Existing Large Object #
+
+ To open an existing large object for reading or writing, call
+
+int lo_open(PGconn *conn, Oid lobjId, int mode);
+
+ The lobjId argument specifies the OID of the large
+ object to open. The mode bits control whether the
+ object is opened for reading (INV_READ), writing
+ (INV_WRITE), or both.
+ (These symbolic constants are defined
+ in the header file libpq/libpq-fs.h.)
+ lo_open returns a (non-negative) large object
+ descriptor for later use in lo_read,
+ lo_write, lo_lseek,
+ lo_lseek64, lo_tell,
+ lo_tell64, lo_truncate,
+ lo_truncate64, and lo_close.
+ The descriptor is only valid for
+ the duration of the current transaction.
+ On failure, -1 is returned.
+
+ The server currently does not distinguish between modes
+ INV_WRITE and INV_READ |
+ INV_WRITE: you are allowed to read from the descriptor
+ in either case. However there is a significant difference between
+ these modes and INV_READ alone: with INV_READ
+ you cannot write on the descriptor, and the data read from it will
+ reflect the contents of the large object at the time of the transaction
+ snapshot that was active when lo_open was executed,
+ regardless of later writes by this or other transactions. Reading
+ from a descriptor opened with INV_WRITE returns
+ data that reflects all writes of other committed transactions as well
+ as writes of the current transaction. This is similar to the behavior
+ of REPEATABLE READ versus READ COMMITTED transaction
+ modes for ordinary SQL SELECT commands.
+
+ lo_open will fail if SELECT
+ privilege is not available for the large object, or
+ if INV_WRITE is specified and UPDATE
+ privilege is not available.
+ (Prior to PostgreSQL 11, these privilege
+ checks were instead performed at the first actual read or write call
+ using the descriptor.)
+ These privilege checks can be disabled with the
+ lo_compat_privileges run-time parameter.
+
+ An example:
+
+inv_fd = lo_open(conn, inv_oid, INV_READ|INV_WRITE);
+
+
35.3.5. Writing Data to a Large Object #
+
+ The function
+
+int lo_write(PGconn *conn, int fd, const char *buf, size_t len);
+
+ writes len bytes from buf
+ (which must be of size len) to large object
+ descriptor fd. The fd argument must
+ have been returned by a previous lo_open. The
+ number of bytes actually written is returned (in the current
+ implementation, this will always equal len unless
+ there is an error). In the event of an error, the return value is -1.
+
+ Although the len parameter is declared as
+ size_t, this function will reject length values larger than
+ INT_MAX. In practice, it's best to transfer data in chunks
+ of at most a few megabytes anyway.
+
35.3.6. Reading Data from a Large Object #
+
+ The function
+
+int lo_read(PGconn *conn, int fd, char *buf, size_t len);
+
+ reads up to len bytes from large object descriptor
+ fd into buf (which must be
+ of size len). The fd
+ argument must have been returned by a previous
+ lo_open. The number of bytes actually read is
+ returned; this will be less than len if the end of
+ the large object is reached first. In the event of an error, the return
+ value is -1.
+
+ Although the len parameter is declared as
+ size_t, this function will reject length values larger than
+ INT_MAX. In practice, it's best to transfer data in chunks
+ of at most a few megabytes anyway.
+
35.3.7. Seeking in a Large Object #
+
+ To change the current read or write location associated with a
+ large object descriptor, call
+
+int lo_lseek(PGconn *conn, int fd, int offset, int whence);
+
+ This function moves the
+ current location pointer for the large object descriptor identified by
+ fd to the new location specified by
+ offset. The valid values for whence
+ are SEEK_SET (seek from object start),
+ SEEK_CUR (seek from current position), and
+ SEEK_END (seek from object end). The return value is
+ the new location pointer, or -1 on error.
+
+
+ When dealing with large objects that might exceed 2GB in size,
+ instead use
+
+pg_int64 lo_lseek64(PGconn *conn, int fd, pg_int64 offset, int whence);
+
+ This function has the same behavior
+ as lo_lseek, but it can accept an
+ offset larger than 2GB and/or deliver a result larger
+ than 2GB.
+ Note that lo_lseek will fail if the new location
+ pointer would be greater than 2GB.
+
+ lo_lseek64 is new as of PostgreSQL
+ 9.3. If this function is run against an older server version, it will
+ fail and return -1.
+
35.3.8. Obtaining the Seek Position of a Large Object #
+
+ To obtain the current read or write location of a large object descriptor,
+ call
+
+int lo_tell(PGconn *conn, int fd);
+
+ If there is an error, the return value is -1.
+
+
+ When dealing with large objects that might exceed 2GB in size,
+ instead use
+
+pg_int64 lo_tell64(PGconn *conn, int fd);
+
+ This function has the same behavior
+ as lo_tell, but it can deliver a result larger
+ than 2GB.
+ Note that lo_tell will fail if the current
+ read/write location is greater than 2GB.
+
+ lo_tell64 is new as of PostgreSQL
+ 9.3. If this function is run against an older server version, it will
+ fail and return -1.
+
35.3.9. Truncating a Large Object #
+
+ To truncate a large object to a given length, call
+
+int lo_truncate(PGconn *conn, int fd, size_t len);
+
+ This function truncates the large object
+ descriptor fd to length len. The
+ fd argument must have been returned by a
+ previous lo_open. If len is
+ greater than the large object's current length, the large object
+ is extended to the specified length with null bytes ('\0').
+ On success, lo_truncate returns
+ zero. On error, the return value is -1.
+
+ The read/write location associated with the descriptor
+ fd is not changed.
+
+ Although the len parameter is declared as
+ size_t, lo_truncate will reject length
+ values larger than INT_MAX.
+
+
+ When dealing with large objects that might exceed 2GB in size,
+ instead use
+
+int lo_truncate64(PGconn *conn, int fd, pg_int64 len);
+
+ This function has the same
+ behavior as lo_truncate, but it can accept a
+ len value exceeding 2GB.
+
+ lo_truncate is new as of PostgreSQL
+ 8.3; if this function is run against an older server version, it will
+ fail and return -1.
+
+ lo_truncate64 is new as of PostgreSQL
+ 9.3; if this function is run against an older server version, it will
+ fail and return -1.
+
35.3.10. Closing a Large Object Descriptor #
+
+ A large object descriptor can be closed by calling
+
+int lo_close(PGconn *conn, int fd);
+
+ where fd is a
+ large object descriptor returned by lo_open.
+ On success, lo_close returns zero. On
+ error, the return value is -1.
+
+ Any large object descriptors that remain open at the end of a
+ transaction will be closed automatically.
+
35.3.11. Removing a Large Object #
+
+ To remove a large object from the database, call
+
+int lo_unlink(PGconn *conn, Oid lobjId);
+
+ The lobjId argument specifies the OID of the
+ large object to remove. Returns 1 if successful, -1 on failure.
+
+ All large objects are stored in a single system table named pg_largeobject.
+ Each large object also has an entry in the system table pg_largeobject_metadata.
+ Large objects can be created, modified, and deleted using a read/write API
+ that is similar to standard operations on files.
+
+ PostgreSQL also supports a storage system called
+ “TOAST”,
+ which automatically stores values
+ larger than a single database page into a secondary storage area per table.
+ This makes the large object facility partially obsolete. One
+ remaining advantage of the large object facility is that it allows values
+ up to 4 TB in size, whereas TOASTed fields can be at
+ most 1 GB. Also, reading and updating portions of a large object can be
+ done efficiently, while most operations on a TOASTed
+ field will read or write the whole value as a unit.
+
F.22. lo — manage large objects #
+ The lo module provides support for managing Large Objects
+ (also called LOs or BLOBs). This includes a data type lo
+ and a trigger lo_manage.
+
+ This module is considered “trusted”, that is, it can be
+ installed by non-superusers who have CREATE privilege
+ on the current database.
+
+ One of the problems with the JDBC driver (and this affects the ODBC driver
+ also), is that the specification assumes that references to BLOBs (Binary
+ Large OBjects) are stored within a table, and if that entry is changed, the
+ associated BLOB is deleted from the database.
+
+ As PostgreSQL stands, this doesn't occur. Large objects
+ are treated as objects in their own right; a table entry can reference a
+ large object by OID, but there can be multiple table entries referencing
+ the same large object OID, so the system doesn't delete the large object
+ just because you change or remove one such entry.
+
+ Now this is fine for PostgreSQL-specific applications, but
+ standard code using JDBC or ODBC won't delete the objects, resulting in
+ orphan objects — objects that are not referenced by anything, and
+ simply occupy disk space.
+
+ The lo module allows fixing this by attaching a trigger
+ to tables that contain LO reference columns. The trigger essentially just
+ does a lo_unlink whenever you delete or modify a value
+ referencing a large object. When you use this trigger, you are assuming
+ that there is only one database reference to any large object that is
+ referenced in a trigger-controlled column!
+
+ The module also provides a data type lo, which is really just
+ a domain over
+ the oid type. This is useful for differentiating
+ database columns that hold large object references from those that are
+ OIDs of other things. You don't have to use the lo type to
+ use the trigger, but it may be convenient to use it to keep track of which
+ columns in your database represent large objects that you are managing with
+ the trigger. It is also rumored that the ODBC driver gets confused if you
+ don't use lo for BLOB columns.
+
+ Here's a simple example of usage:
+
+CREATE TABLE image (title text, raster lo);
+
+CREATE TRIGGER t_raster BEFORE UPDATE OR DELETE ON image
+ FOR EACH ROW EXECUTE FUNCTION lo_manage(raster);
+
+ For each column that will contain unique references to large objects,
+ create a BEFORE UPDATE OR DELETE trigger, and give the column
+ name as the sole trigger argument. You can also restrict the trigger
+ to only execute on updates to the column by using BEFORE UPDATE
+ OF column_name.
+ If you need multiple lo
+ columns in the same table, create a separate trigger for each one,
+ remembering to give a different name to each trigger on the same table.
+
+ Dropping a table will still orphan any objects it contains, as the trigger
+ is not executed. You can avoid this by preceding the DROP
+ TABLE with DELETE FROM table.
+
+ TRUNCATE has the same hazard.
+
+ If you already have, or suspect you have, orphaned large objects, see the
+ vacuumlo module to help
+ you clean them up. It's a good idea to run vacuumlo
+ occasionally as a back-stop to the lo_manage trigger.
+
+ Some frontends may create their own tables, and will not create the
+ associated trigger(s). Also, users may not remember (or know) to create
+ the triggers.
+
+ Locale support refers to an application respecting
+ cultural preferences regarding alphabets, sorting, number
+ formatting, etc. PostgreSQL uses the standard ISO
+ C and POSIX locale facilities provided by the server operating
+ system. For additional information refer to the documentation of your
+ system.
+
+ Locale support is automatically initialized when a database
+ cluster is created using initdb.
+ initdb will initialize the database cluster
+ with the locale setting of its execution environment by default,
+ so if your system is already set to use the locale that you want
+ in your database cluster then there is nothing else you need to
+ do. If you want to use a different locale (or you are not sure
+ which locale your system is set to), you can instruct
+ initdb exactly which locale to use by
+ specifying the --locale option. For example:
+
+initdb --locale=sv_SE
+
+
+ This example for Unix systems sets the locale to Swedish
+ (sv) as spoken
+ in Sweden (SE). Other possibilities might include
+ en_US (U.S. English) and fr_CA (French
+ Canadian). If more than one character set can be used for a
+ locale then the specifications can take the form
+ language_territory.codeset. For example,
+ fr_BE.UTF-8 represents the French language (fr) as
+ spoken in Belgium (BE), with a UTF-8 character set
+ encoding.
+
+ What locales are available on your
+ system under what names depends on what was provided by the operating
+ system vendor and what was installed. On most Unix systems, the command
+ locale -a will provide a list of available locales.
+ Windows uses more verbose locale names, such as German_Germany
+ or Swedish_Sweden.1252, but the principles are the same.
+
+ Occasionally it is useful to mix rules from several locales, e.g.,
+ use English collation rules but Spanish messages. To support that, a
+ set of locale subcategories exist that control only certain
+ aspects of the localization rules:
+
+
+
+ The category names translate into names of
+ initdb options to override the locale choice
+ for a specific category. For instance, to set the locale to
+ French Canadian, but use U.S. rules for formatting currency, use
+ initdb --locale=fr_CA --lc-monetary=en_US.
+
+ If you want the system to behave as if it had no locale support,
+ use the special locale name C, or equivalently
+ POSIX.
+
+ Some locale categories must have their values
+ fixed when the database is created. You can use different settings
+ for different databases, but once a database is created, you cannot
+ change them for that database anymore. LC_COLLATE
+ and LC_CTYPE are these categories. They affect
+ the sort order of indexes, so they must be kept fixed, or indexes on
+ text columns would become corrupt.
+ (But you can alleviate this restriction using collations, as discussed
+ in Section 24.2.)
+ The default values for these
+ categories are determined when initdb is run, and
+ those values are used when new databases are created, unless
+ specified otherwise in the CREATE DATABASE command.
+
+ The other locale categories can be changed whenever desired
+ by setting the server configuration parameters
+ that have the same name as the locale categories (see Section 20.11.2 for details). The values
+ that are chosen by initdb are actually only written
+ into the configuration file postgresql.conf to
+ serve as defaults when the server is started. If you remove these
+ assignments from postgresql.conf then the
+ server will inherit the settings from its execution environment.
+
+ Note that the locale behavior of the server is determined by the
+ environment variables seen by the server, not by the environment
+ of any client. Therefore, be careful to configure the correct locale settings
+ before starting the server. A consequence of this is that if
+ client and server are set up in different locales, messages might
+ appear in different languages depending on where they originated.
+
Note
+ When we speak of inheriting the locale from the execution
+ environment, this means the following on most operating systems:
+ For a given locale category, say the collation, the following
+ environment variables are consulted in this order until one is
+ found to be set: LC_ALL, LC_COLLATE
+ (or the variable corresponding to the respective category),
+ LANG. If none of these environment variables are
+ set then the locale defaults to C.
+
+ Some message localization libraries also look at the environment
+ variable LANGUAGE which overrides all other locale
+ settings for the purpose of setting the language of messages. If
+ in doubt, please refer to the documentation of your operating
+ system, in particular the documentation about
+ gettext.
+
+ To enable messages to be translated to the user's preferred language,
+ NLS must have been selected at build time
+ (configure --enable-nls). All other locale support is
+ built in automatically.
+
+ The locale settings influence the following SQL features:
+
+
+ Sort order in queries using ORDER BY or the standard
+ comparison operators on textual data
+
+
+ The upper, lower, and initcap
+ functions
+
+
+
+ Pattern matching operators (LIKE, SIMILAR TO,
+ and POSIX-style regular expressions); locales affect both case
+ insensitive matching and the classification of characters by
+ character-class regular expressions
+
+
+
+ The to_char family of functions
+
+
+ The ability to use indexes with LIKE clauses
+
+
+ The drawback of using locales other than C or
+ POSIX in PostgreSQL is its performance
+ impact. It slows character handling and prevents ordinary indexes
+ from being used by LIKE. For this reason use locales
+ only if you actually need them.
+
+ As a workaround to allow PostgreSQL to use indexes
+ with LIKE clauses under a non-C locale, several custom
+ operator classes exist. These allow the creation of an index that
+ performs a strict character-by-character comparison, ignoring
+ locale comparison rules. Refer to Section 11.10
+ for more information. Another approach is to create indexes using
+ the C collation, as discussed in
+ Section 24.2.
+
24.1.3. Selecting Locales #
+ Locales can be selected in different scopes depending on requirements.
+ The above overview showed how locales are specified using
+ initdb to set the defaults for the entire cluster. The
+ following list shows where locales can be selected. Each item provides
+ the defaults for the subsequent items, and each lower item allows
+ overriding the defaults on a finer granularity.
+
+ As explained above, the environment of the operating system provides the
+ defaults for the locales of a newly initialized database cluster. In
+ many cases, this is enough: If the operating system is configured for
+ the desired language/territory, then
+ PostgreSQL will by default also behave
+ according to that locale.
+
+ As shown above, command-line options for initdb
+ specify the locale settings for a newly initialized database cluster.
+ Use this if the operating system does not have the locale configuration
+ you want for your database system.
+
+ A locale can be selected separately for each database. The SQL command
+ CREATE DATABASE and its command-line equivalent
+ createdb have options for that. Use this for example
+ if a database cluster houses databases for multiple tenants with
+ different requirements.
+
+ Locale settings can be made for individual table columns. This uses an
+ SQL object called collation and is explained in
+ Section 24.2. Use this for example to sort data in
+ different languages or customize the sort order of a particular table.
+
+ Finally, locales can be selected for an individual query. Again, this
+ uses SQL collation objects. This could be used to change the sort order
+ based on run-time choices or for ad-hoc experimentation.
+
24.1.4. Locale Providers #
+ PostgreSQL supports multiple locale
+ providers. This specifies which library supplies the locale
+ data. One standard provider name is libc, which uses
+ the locales provided by the operating system C library. These are the
+ locales used by most tools provided by the operating system. Another
+ provider is icu, which uses the external
+ ICU library. ICU locales can
+ only be used if support for ICU was configured when PostgreSQL was built.
+
+ The commands and tools that select the locale settings, as described
+ above, each have an option to select the locale provider. The examples
+ shown earlier all use the libc provider, which is the
+ default. Here is an example to initialize a database cluster using the
+ ICU provider:
+
+initdb --locale-provider=icu --icu-locale=en
+
+ See the description of the respective commands and programs for
+ details. Note that you can mix locale providers at different
+ granularities, for example use libc by default for the
+ cluster but have one database that uses the icu
+ provider, and then have collation objects using either provider within
+ those databases.
+
+ Which locale provider to use depends on individual requirements. For most
+ basic uses, either provider will give adequate results. For the libc
+ provider, it depends on what the operating system offers; some operating
+ systems are better than others. For advanced uses, ICU offers more locale
+ variants and customization options.
+
24.1.5.1. ICU Locale Names #
+ The ICU format for the locale name is a Language Tag.
+
+
+CREATE COLLATION mycollation1 (provider = icu, locale = 'ja-JP');
+CREATE COLLATION mycollation2 (provider = icu, locale = 'fr');
+
+
24.1.5.2. Locale Canonicalization and Validation #
+ When defining a new ICU collation object or database with ICU as the
+ provider, the given locale name is transformed ("canonicalized") into a
+ language tag if not already in that form. For instance,
+
+
+CREATE COLLATION mycollation3 (provider = icu, locale = 'en-US-u-kn-true');
+NOTICE: using standard form "en-US-u-kn" for locale "en-US-u-kn-true"
+CREATE COLLATION mycollation4 (provider = icu, locale = 'de_DE.utf8');
+NOTICE: using standard form "de-DE" for locale "de_DE.utf8"
+
+
+ If you see this notice, ensure that the provider and
+ locale are the expected result. For consistent results
+ when using the ICU provider, specify the canonical language tag instead of relying on the
+ transformation.
+
+ A locale with no language name, or the special language name
+ root, is transformed to have the language
+ und ("undefined").
+
+ ICU can transform most libc locale names, as well as some other formats,
+ into language tags for easier transition to ICU. If a libc locale name is
+ used in ICU, it may not have precisely the same behavior as in libc.
+
+ If there is a problem interpreting the locale name, or if the locale name
+ represents a language or region that ICU does not recognize, you will see
+ the following warning:
+
+
+CREATE COLLATION nonsense (provider = icu, locale = 'nonsense');
+WARNING: ICU locale "nonsense" has unknown language "nonsense"
+HINT: To disable ICU locale validation, set parameter icu_validation_level to DISABLED.
+CREATE COLLATION
+
+
+ icu_validation_level controls how the message is
+ reported. Unless set to ERROR, the collation will
+ still be created, but the behavior may not be what the user intended.
+
+ A language tag, defined in BCP 47, is a standardized identifier used to
+ identify languages, regions, and other information about a locale.
+
+ Basic language tags are simply
+ language-region;
+ or even just language. The
+ language is a language code
+ (e.g. fr for French), and
+ region is a region code
+ (e.g. CA for Canada). Examples:
+ ja-JP, de, or
+ fr-CA.
+
+ Collation settings may be included in the language tag to customize
+ collation behavior. ICU allows extensive customization, such as
+ sensitivity (or insensitivity) to accents, case, and punctuation;
+ treatment of digits within text; and many other options to satisfy a
+ variety of uses.
+
+ To include this additional collation information in a language tag,
+ append -u, which indicates there are additional
+ collation settings, followed by one or more
+ -key-value
+ pairs. The key is the key for a collation setting and
+ value is a valid value for that setting. For
+ boolean settings, the -key
+ may be specified without a corresponding
+ -value, which implies a
+ value of true.
+
+ For example, the language tag en-US-u-kn-ks-level2
+ means the locale with the English language in the US region, with
+ collation settings kn set to true
+ and ks set to level2. Those
+ settings mean the collation will be case-insensitive and treat a sequence
+ of digits as a single number:
+
+
+CREATE COLLATION mycollation5 (provider = icu, deterministic = false, locale = 'en-US-u-kn-ks-level2');
+SELECT 'aB' = 'Ab' COLLATE mycollation5 as result;
+ result
+--------
+ t
+(1 row)
+
+SELECT 'N-45' < 'N-123' COLLATE mycollation5 as result;
+ result
+--------
+ t
+(1 row)
+
+
+ See Section 24.2.3 for details and additional
+ examples of using language tags with custom collation information for the
+ locale.
+
+ If locale support doesn't work according to the explanation above,
+ check that the locale support in your operating system is
+ correctly configured. To check what locales are installed on your
+ system, you can use the command locale -a if
+ your operating system provides it.
+
+ Check that PostgreSQL is actually using the locale
+ that you think it is. The LC_COLLATE and LC_CTYPE
+ settings are determined when a database is created, and cannot be
+ changed except by creating a new database. Other locale
+ settings including LC_MESSAGES and LC_MONETARY
+ are initially determined by the environment the server is started
+ in, but can be changed on-the-fly. You can check the active locale
+ settings using the SHOW command.
+
+ The directory src/test/locale in the source
+ distribution contains a test suite for
+ PostgreSQL's locale support.
+
+ Client applications that handle server-side errors by parsing the
+ text of the error message will obviously have problems when the
+ server's messages are in a different language. Authors of such
+ applications are advised to make use of the error code scheme
+ instead.
+
+ Maintaining catalogs of message translations requires the on-going
+ efforts of many volunteers that want to see
+ PostgreSQL speak their preferred language well.
+ If messages in your language are currently not available or not fully
+ translated, your assistance would be appreciated. If you want to
+ help, refer to Chapter 57 or write to the developers'
+ mailing list.
+
13.7. Locking and Indexes #
+ Though PostgreSQL
+ provides nonblocking read/write access to table
+ data, nonblocking read/write access is not currently offered for every
+ index access method implemented
+ in PostgreSQL.
+ The various index types are handled as follows:
+
+
-
+ B-tree, GiST and SP-GiST indexes
+
+ Short-term share/exclusive page-level locks are used for
+ read/write access. Locks are released immediately after each
+ index row is fetched or inserted. These index types provide
+ the highest concurrency without deadlock conditions.
+
-
+ Hash indexes
+
+ Share/exclusive hash-bucket-level locks are used for read/write
+ access. Locks are released after the whole bucket is processed.
+ Bucket-level locks provide better concurrency than index-level
+ ones, but deadlock is possible since the locks are held longer
+ than one index operation.
+
-
+ GIN indexes
+
+ Short-term share/exclusive page-level locks are used for
+ read/write access. Locks are released immediately after each
+ index row is fetched or inserted. But note that insertion of a
+ GIN-indexed value usually produces several index key insertions
+ per row, so GIN might do substantial work for a single value's
+ insertion.
+
+
+ Currently, B-tree indexes offer the best performance for concurrent
+ applications; since they also have more features than hash
+ indexes, they are the recommended index type for concurrent
+ applications that need to index scalar data. When dealing with
+ non-scalar data, B-trees are not useful, and GiST, SP-GiST or GIN
+ indexes should be used instead.
+
25.3. Log File Maintenance #
+ It is a good idea to save the database server's log output
+ somewhere, rather than just discarding it via /dev/null.
+ The log output is invaluable when diagnosing
+ problems.
+
Note
+ The server log can contain sensitive information and needs to be protected,
+ no matter how or where it is stored, or the destination to which it is routed.
+ For example, some DDL statements might contain plaintext passwords or other
+ authentication details. Logged statements at the ERROR
+ level might show the SQL source code for applications
+ and might also contain some parts of data rows. Recording data, events and
+ related information is the intended function of this facility, so this is
+ not a leakage or a bug. Please ensure the server logs are visible only to
+ appropriately authorized people.
+
+ Log output tends to be voluminous
+ (especially at higher debug levels) so you won't want to save it
+ indefinitely. You need to rotate the log files so that
+ new log files are started and old ones removed after a reasonable
+ period of time.
+
+ If you simply direct the stderr of
+ postgres into a
+ file, you will have log output, but
+ the only way to truncate the log file is to stop and restart
+ the server. This might be acceptable if you are using
+ PostgreSQL in a development environment,
+ but few production servers would find this behavior acceptable.
+
+ A better approach is to send the server's
+ stderr output to some type of log rotation program.
+ There is a built-in log rotation facility, which you can use by
+ setting the configuration parameter logging_collector to
+ true in postgresql.conf. The control
+ parameters for this program are described in Section 20.8.1. You can also use this approach
+ to capture the log data in machine readable CSV
+ (comma-separated values) format.
+
+ Alternatively, you might prefer to use an external log rotation
+ program if you have one that you are already using with other
+ server software. For example, the rotatelogs
+ tool included in the Apache distribution
+ can be used with PostgreSQL. One way to
+ do this is to pipe the server's
+ stderr output to the desired program.
+ If you start the server with
+ pg_ctl, then stderr
+ is already redirected to stdout, so you just need a
+ pipe command, for example:
+
+
+pg_ctl start | rotatelogs /var/log/pgsql_log 86400
+
+
+ You can combine these approaches by setting up logrotate
+ to collect log files produced by PostgreSQL built-in
+ logging collector. In this case, the logging collector defines the names and
+ location of the log files, while logrotate
+ periodically archives these files. When initiating log rotation,
+ logrotate must ensure that the application
+ sends further output to the new file. This is commonly done with a
+ postrotate script that sends a SIGHUP
+ signal to the application, which then reopens the log file.
+ In PostgreSQL, you can run pg_ctl
+ with the logrotate option instead. When the server receives
+ this command, the server either switches to a new log file or reopens the
+ existing file, depending on the logging configuration
+ (see Section 20.8.1).
+
Note
+ When using static log file names, the server might fail to reopen the log
+ file if the max open file limit is reached or a file table overflow occurs.
+ In this case, log messages are sent to the old log file until a
+ successful log rotation. If logrotate is
+ configured to compress the log file and delete it, the server may lose
+ the messages logged in this time frame. To avoid this issue, you can
+ configure the logging collector to dynamically assign log file names
+ and use a prerotate script to ignore open log files.
+
+ Another production-grade approach to managing log output is to
+ send it to syslog and let
+ syslog deal with file rotation. To do this, set the
+ configuration parameter log_destination to syslog
+ (to log to syslog only) in
+ postgresql.conf. Then you can send a SIGHUP
+ signal to the syslog daemon whenever you want to force it
+ to start writing a new log file. If you want to automate log
+ rotation, the logrotate program can be
+ configured to work with log files from
+ syslog.
+
+ On many systems, however, syslog is not very reliable,
+ particularly with large log messages; it might truncate or drop messages
+ just when you need them the most. Also, on Linux,
+ syslog will flush each message to disk, yielding poor
+ performance. (You can use a “-” at the start of the file name
+ in the syslog configuration file to disable syncing.)
+
+ Note that all the solutions described above take care of starting new
+ log files at configurable intervals, but they do not handle deletion
+ of old, no-longer-useful log files. You will probably want to set
+ up a batch job to periodically delete old log files. Another possibility
+ is to configure the rotation program so that old log files are overwritten
+ cyclically.
+
+ pgBadger
+ is an external project that does sophisticated log file analysis.
+ check_postgres
+ provides Nagios alerts when important messages appear in the log
+ files, as well as detection of many other extraordinary conditions.
+
+ Logical replication starts by copying a snapshot of the data on the
+ publisher database. Once that is done, changes on the publisher are sent
+ to the subscriber as they occur in real time. The subscriber applies data
+ in the order in which commits were made on the publisher so that
+ transactional consistency is guaranteed for the publications within any
+ single subscription.
+
+ Logical replication is built with an architecture similar to physical
+ streaming replication (see Section 27.2.5). It is
+ implemented by walsender and apply
+ processes. The walsender process starts logical decoding (described
+ in Chapter 49) of the WAL and loads the standard
+ logical decoding output plugin (pgoutput). The plugin
+ transforms the changes read
+ from WAL to the logical replication protocol
+ (see Section 55.5) and filters the data
+ according to the publication specification. The data is then continuously
+ transferred using the streaming replication protocol to the apply worker,
+ which maps the data to local tables and applies the individual changes as
+ they are received, in correct transactional order.
+
+ The apply process on the subscriber database always runs with
+ session_replication_role
+ set to replica. This means that, by default,
+ triggers and rules will not fire on a subscriber. Users can optionally choose to
+ enable triggers and rules on a table using the
+ ALTER TABLE command
+ and the ENABLE TRIGGER and ENABLE RULE
+ clauses.
+
+ The logical replication apply process currently only fires row triggers,
+ not statement triggers. The initial table synchronization, however, is
+ implemented like a COPY command and thus fires both row
+ and statement triggers for INSERT.
+
31.7.1. Initial Snapshot #
+ The initial data in existing subscribed tables are snapshotted and
+ copied in a parallel instance of a special kind of apply process.
+ This process will create its own replication slot and copy the existing
+ data. As soon as the copy is finished the table contents will become
+ visible to other backends. Once existing data is copied, the worker
+ enters synchronization mode, which ensures that the table is brought
+ up to a synchronized state with the main apply process by streaming
+ any changes that happened during the initial data copy using standard
+ logical replication. During this synchronization phase, the changes
+ are applied and committed in the same order as they happened on the
+ publisher. Once synchronization is done, control of the
+ replication of the table is given back to the main apply process where
+ replication continues as normal.
+
Note
+ The publication
+ publish
+ parameter only affects what DML operations will be replicated. The
+ initial data synchronization does not take this parameter into account
+ when copying the existing table data.
+
+ Each publication can optionally specify which columns of each table are
+ replicated to subscribers. The table on the subscriber side must have at
+ least all the columns that are published. If no column list is specified,
+ then all columns on the publisher are replicated.
+ See CREATE PUBLICATION for details on the syntax.
+
+ The choice of columns can be based on behavioral or performance reasons.
+ However, do not rely on this feature for security: a malicious subscriber
+ is able to obtain data from columns that are not specifically
+ published. If security is a consideration, protections can be applied
+ at the publisher side.
+
+ If no column list is specified, any columns added later are automatically
+ replicated. This means that having a column list which names all columns
+ is not the same as having no column list at all.
+
+ A column list can contain only simple column references. The order
+ of columns in the list is not preserved.
+
+ Specifying a column list when the publication also publishes
+ FOR TABLES IN SCHEMA
+ is not supported.
+
+ For partitioned tables, the publication parameter
+ publish_via_partition_root
+ determines which column list is used. If publish_via_partition_root
+ is true, the root partitioned table's column list is
+ used. Otherwise, if publish_via_partition_root is
+ false (the default), each partition's column list is used.
+
+ If a publication publishes UPDATE or
+ DELETE operations, any column list must include the
+ table's replica identity columns (see
+ REPLICA IDENTITY).
+ If a publication publishes only INSERT operations, then
+ the column list may omit replica identity columns.
+
+ Column lists have no effect for the TRUNCATE command.
+
+ During initial data synchronization, only the published columns are
+ copied. However, if the subscriber is from a release prior to 15, then
+ all the columns in the table are copied during initial data synchronization,
+ ignoring any column lists.
+
Warning: Combining Column Lists from Multiple Publications
+ There's currently no support for subscriptions comprising several
+ publications where the same table has been published with different
+ column lists. CREATE SUBSCRIPTION disallows
+ creating such subscriptions, but it is still possible to get into
+ that situation by adding or altering column lists on the publication
+ side after a subscription has been created.
+
+ This means changing the column lists of tables on publications that are
+ already subscribed could lead to errors being thrown on the subscriber
+ side.
+
+ If a subscription is affected by this problem, the only way to resume
+ replication is to adjust one of the column lists on the publication
+ side so that they all match; and then either recreate the subscription,
+ or use ALTER SUBSCRIPTION ... DROP PUBLICATION to
+ remove one of the offending publications and add it again.
+
+ Create a table t1 to be used in the following example.
+
+test_pub=# CREATE TABLE t1(id int, a text, b text, c text, d text, e text, PRIMARY KEY(id));
+CREATE TABLE
+
+ Create a publication p1. A column list is defined for
+ table t1 to reduce the number of columns that will be
+ replicated. Notice that the order of column names in the column list does
+ not matter.
+
+test_pub=# CREATE PUBLICATION p1 FOR TABLE t1 (id, b, a, d);
+CREATE PUBLICATION
+
+ psql can be used to show the column lists (if defined)
+ for each publication.
+
+test_pub=# \dRp+
+ Publication p1
+ Owner | All tables | Inserts | Updates | Deletes | Truncates | Via root
+----------+------------+---------+---------+---------+-----------+----------
+ postgres | f | t | t | t | t | f
+Tables:
+ "public.t1" (id, a, b, d)
+
+ psql can be used to show the column lists (if defined)
+ for each table.
+
+test_pub=# \d t1
+ Table "public.t1"
+ Column | Type | Collation | Nullable | Default
+--------+---------+-----------+----------+---------
+ id | integer | | not null |
+ a | text | | |
+ b | text | | |
+ c | text | | |
+ d | text | | |
+ e | text | | |
+Indexes:
+ "t1_pkey" PRIMARY KEY, btree (id)
+Publications:
+ "p1" (id, a, b, d)
+
+ On the subscriber node, create a table t1 which now
+ only needs a subset of the columns that were on the publisher table
+ t1, and also create the subscription
+ s1 that subscribes to the publication
+ p1.
+
+test_sub=# CREATE TABLE t1(id int, b text, a text, d text, PRIMARY KEY(id));
+CREATE TABLE
+test_sub=# CREATE SUBSCRIPTION s1
+test_sub-# CONNECTION 'host=localhost dbname=test_pub application_name=s1'
+test_sub-# PUBLICATION p1;
+CREATE SUBSCRIPTION
+
+ On the publisher node, insert some rows to table t1.
+
+test_pub=# INSERT INTO t1 VALUES(1, 'a-1', 'b-1', 'c-1', 'd-1', 'e-1');
+INSERT 0 1
+test_pub=# INSERT INTO t1 VALUES(2, 'a-2', 'b-2', 'c-2', 'd-2', 'e-2');
+INSERT 0 1
+test_pub=# INSERT INTO t1 VALUES(3, 'a-3', 'b-3', 'c-3', 'd-3', 'e-3');
+INSERT 0 1
+test_pub=# SELECT * FROM t1 ORDER BY id;
+ id | a | b | c | d | e
+----+-----+-----+-----+-----+-----
+ 1 | a-1 | b-1 | c-1 | d-1 | e-1
+ 2 | a-2 | b-2 | c-2 | d-2 | e-2
+ 3 | a-3 | b-3 | c-3 | d-3 | e-3
+(3 rows)
+
+ Only data from the column list of publication p1 is
+ replicated.
+
+test_sub=# SELECT * FROM t1 ORDER BY id;
+ id | b | a | d
+----+-----+-----+-----
+ 1 | b-1 | a-1 | d-1
+ 2 | b-2 | a-2 | d-2
+ 3 | b-3 | a-3 | d-3
+(3 rows)
+
31.10. Configuration Settings #
+ Logical replication requires several configuration options to be set. Most
+ options are relevant only on one side of the replication. However,
+ max_replication_slots is used on both the publisher and
+ the subscriber, but it has a different meaning for each.
+
+ wal_level must be
+ set to logical.
+
+ max_replication_slots
+ must be set to at least the number of subscriptions expected to connect,
+ plus some reserve for table synchronization.
+
+ max_wal_senders
+ should be set to at least the same as
+ max_replication_slots, plus the number of physical
+ replicas that are connected at the same time.
+
+ Logical replication walsender is also affected by
+ wal_sender_timeout.
+
+ Logical replication behaves similarly to normal DML operations in that
+ the data will be updated even if it was changed locally on the subscriber
+ node. If incoming data violates any constraints the replication will
+ stop. This is referred to as a conflict. When
+ replicating UPDATE or DELETE
+ operations, missing data will not produce a conflict and such operations
+ will simply be skipped.
+
+ Logical replication operations are performed with the privileges of the role
+ which owns the subscription. Permissions failures on target tables will
+ cause replication conflicts, as will enabled
+ row-level security on target tables
+ that the subscription owner is subject to, without regard to whether any
+ policy would ordinarily reject the INSERT,
+ UPDATE, DELETE or
+ TRUNCATE which is being replicated. This restriction on
+ row-level security may be lifted in a future version of
+ PostgreSQL.
+
+ A conflict will produce an error and will stop the replication; it must be
+ resolved manually by the user. Details about the conflict can be found in
+ the subscriber's server log.
+
+ The resolution can be done either by changing data or permissions on the subscriber so
+ that it does not conflict with the incoming change or by skipping the
+ transaction that conflicts with the existing data. When a conflict produces
+ an error, the replication won't proceed, and the logical replication worker will
+ emit the following kind of message to the subscriber's server log:
+
+ERROR: duplicate key value violates unique constraint "test_pkey"
+DETAIL: Key (c)=(1) already exists.
+CONTEXT: processing remote data for replication origin "pg_16395" during "INSERT" for replication target relation "public.test" in transaction 725 finished at 0/14C0378
+
+ The LSN of the transaction that contains the change violating the constraint and
+ the replication origin name can be found from the server log (LSN 0/14C0378 and
+ replication origin pg_16395 in the above case). The
+ transaction that produced the conflict can be skipped by using
+ ALTER SUBSCRIPTION ... SKIP with the finish LSN
+ (i.e., LSN 0/14C0378). The finish LSN could be an LSN at which the transaction
+ is committed or prepared on the publisher. Alternatively, the transaction can
+ also be skipped by calling the
+ pg_replication_origin_advance() function.
+ Before using this function, the subscription needs to be disabled temporarily
+ either by ALTER SUBSCRIPTION ... DISABLE or, the
+ subscription can be used with the
+ disable_on_error
+ option. Then, you can use pg_replication_origin_advance()
+ function with the node_name (i.e., pg_16395)
+ and the next LSN of the finish LSN (i.e., 0/14C0379). The current position of
+ origins can be seen in the
+ pg_replication_origin_status system view.
+ Please note that skipping the whole transaction includes skipping changes that
+ might not violate any constraint. This can easily make the subscriber
+ inconsistent.
+
+ When the
+ streaming
+ mode is parallel, the finish LSN of failed transactions
+ may not be logged. In that case, it may be necessary to change the streaming
+ mode to on or off and cause the same
+ conflicts again so the finish LSN of the failed transaction will be written
+ to the server log. For the usage of finish LSN, please refer to ALTER SUBSCRIPTION ...
+ SKIP.
+
+ Because logical replication is based on a similar architecture as
+ physical streaming replication,
+ the monitoring on a publication node is similar to monitoring of a
+ physical replication primary
+ (see Section 27.2.5.2).
+
+ The monitoring information about subscription is visible in
+
+ pg_stat_subscription.
+ This view contains one row for every subscription worker. A subscription
+ can have zero or more active subscription workers depending on its state.
+
+ Normally, there is a single apply process running for an enabled
+ subscription. A disabled subscription or a crashed subscription will have
+ zero rows in this view. If the initial data synchronization of any
+ table is in progress, there will be additional workers for the tables
+ being synchronized. Moreover, if the
+ streaming
+ transaction is applied in parallel, there may be additional parallel apply
+ workers.
+
+ A publication can be defined on any physical
+ replication primary. The node where a publication is defined is referred to
+ as publisher. A publication is a set of changes
+ generated from a table or a group of tables, and might also be described as
+ a change set or replication set. Each publication exists in only one database.
+
+ Publications are different from schemas and do not affect how the table is
+ accessed. Each table can be added to multiple publications if needed.
+ Publications may currently only contain tables and all tables in schema.
+ Objects must be added explicitly, except when a publication is created for
+ ALL TABLES.
+
+ Publications can choose to limit the changes they produce to
+ any combination of INSERT, UPDATE,
+ DELETE, and TRUNCATE, similar to how triggers are fired by
+ particular event types. By default, all operation types are replicated.
+ These publication specifications apply only for DML operations; they do not affect the initial
+ data synchronization copy. (Row filters have no effect for
+ TRUNCATE. See Section 31.3).
+
+ A published table must have a replica identity configured in
+ order to be able to replicate UPDATE
+ and DELETE operations, so that appropriate rows to
+ update or delete can be identified on the subscriber side. By default,
+ this is the primary key, if there is one. Another unique index (with
+ certain additional requirements) can also be set to be the replica
+ identity. If the table does not have any suitable key, then it can be set
+ to replica identity FULL, which means the entire row becomes
+ the key. When replica identity FULL is specified,
+ indexes can be used on the subscriber side for searching the rows. Candidate
+ indexes must be btree, non-partial, and the leftmost index field must be a
+ column (not an expression) that references the published table column. These
+ restrictions on the non-unique index properties adhere to some of the
+ restrictions that are enforced for primary keys. If there are no such
+ suitable indexes, the search on the subscriber side can be very inefficient,
+ therefore replica identity FULL should only be used as a
+ fallback if no other solution is possible. If a replica identity other
+ than FULL is set on the publisher side, a replica identity
+ comprising the same or fewer columns must also be set on the subscriber
+ side. See REPLICA IDENTITY for details on
+ how to set the replica identity. If a table without a replica identity is
+ added to a publication that replicates UPDATE
+ or DELETE operations then
+ subsequent UPDATE or DELETE
+ operations will cause an error on the publisher. INSERT
+ operations can proceed regardless of any replica identity.
+
+ Every publication can have multiple subscribers.
+
+ A publication is created using the CREATE PUBLICATION
+ command and may later be altered or dropped using corresponding commands.
+
+ The individual tables can be added and removed dynamically using
+ ALTER PUBLICATION. Both the ADD
+ TABLE and DROP TABLE operations are
+ transactional; so the table will start or stop replicating at the correct
+ snapshot once the transaction has committed.
+
+ First set the configuration options in postgresql.conf:
+
+wal_level = logical
+
+ The other required settings have default values that are sufficient for a
+ basic setup.
+
+ pg_hba.conf needs to be adjusted to allow replication
+ (the values here depend on your actual network configuration and user you
+ want to use for connecting):
+
+host all repuser 0.0.0.0/0 md5
+
+
+ Then on the publisher database:
+
+CREATE PUBLICATION mypub FOR TABLE users, departments;
+
+
+ And on the subscriber database:
+
+CREATE SUBSCRIPTION mysub CONNECTION 'dbname=foo host=bar user=repuser' PUBLICATION mypub;
+
+
+ The above will start the replication process, which synchronizes the
+ initial table contents of the tables users and
+ departments and then starts replicating
+ incremental changes to those tables.
+
+ Logical replication currently has the following restrictions or missing
+ functionality. These might be addressed in future releases.
+
+ The database schema and DDL commands are not replicated. The initial
+ schema can be copied by hand using pg_dump
+ --schema-only. Subsequent schema changes would need to be kept
+ in sync manually. (Note, however, that there is no need for the schemas
+ to be absolutely the same on both sides.) Logical replication is robust
+ when schema definitions change in a live database: When the schema is
+ changed on the publisher and replicated data starts arriving at the
+ subscriber but does not fit into the table schema, replication will error
+ until the schema is updated. In many cases, intermittent errors can be
+ avoided by applying additive schema changes to the subscriber first.
+
+ Sequence data is not replicated. The data in serial or identity columns
+ backed by sequences will of course be replicated as part of the table,
+ but the sequence itself would still show the start value on the
+ subscriber. If the subscriber is used as a read-only database, then this
+ should typically not be a problem. If, however, some kind of switchover
+ or failover to the subscriber database is intended, then the sequences
+ would need to be updated to the latest values, either by copying the
+ current data from the publisher (perhaps
+ using pg_dump) or by determining a sufficiently high
+ value from the tables themselves.
+
+ Replication of TRUNCATE commands is supported, but
+ some care must be taken when truncating groups of tables connected by
+ foreign keys. When replicating a truncate action, the subscriber will
+ truncate the same group of tables that was truncated on the publisher,
+ either explicitly specified or implicitly collected via
+ CASCADE, minus tables that are not part of the
+ subscription. This will work correctly if all affected tables are part
+ of the same subscription. But if some tables to be truncated on the
+ subscriber have foreign-key links to tables that are not part of the same
+ (or any) subscription, then the application of the truncate action on the
+ subscriber will fail.
+
+ Large objects (see Chapter 35) are not replicated.
+ There is no workaround for that, other than storing data in normal
+ tables.
+
+ Replication is only supported by tables, including partitioned tables.
+ Attempts to replicate other types of relations, such as views, materialized
+ views, or foreign tables, will result in an error.
+
+ When replicating between partitioned tables, the actual replication
+ originates, by default, from the leaf partitions on the publisher, so
+ partitions on the publisher must also exist on the subscriber as valid
+ target tables. (They could either be leaf partitions themselves, or they
+ could be further subpartitioned, or they could even be independent
+ tables.) Publications can also specify that changes are to be replicated
+ using the identity and schema of the partitioned root table instead of
+ that of the individual leaf partitions in which the changes actually
+ originate (see
+ publish_via_partition_root
+ parameter of CREATE PUBLICATION).
+
+ By default, all data from all published tables will be replicated to the
+ appropriate subscribers. The replicated data can be reduced by using a
+ row filter. A user might choose to use row filters
+ for behavioral, security or performance reasons. If a published table sets a
+ row filter, a row is replicated only if its data satisfies the row filter
+ expression. This allows a set of tables to be partially replicated. The row
+ filter is defined per table. Use a WHERE clause after the
+ table name for each published table that requires data to be filtered out.
+ The WHERE clause must be enclosed by parentheses. See
+ CREATE PUBLICATION for details.
+
31.3.1. Row Filter Rules #
+ Row filters are applied before publishing the changes.
+ If the row filter evaluates to false or NULL
+ then the row is not replicated. The WHERE clause expression
+ is evaluated with the same role used for the replication connection (i.e.
+ the role specified in the
+ CONNECTION
+ clause of the CREATE SUBSCRIPTION). Row filters have
+ no effect for TRUNCATE command.
+
31.3.2. Expression Restrictions #
+ The WHERE clause allows only simple expressions. It
+ cannot contain user-defined functions, operators, types, and collations,
+ system column references or non-immutable built-in functions.
+
+ If a publication publishes UPDATE or
+ DELETE operations, the row filter WHERE
+ clause must contain only columns that are covered by the replica identity
+ (see REPLICA IDENTITY). If a publication
+ publishes only INSERT operations, the row filter
+ WHERE clause can use any column.
+
31.3.4. Partitioned Tables #
+ If the publication contains a partitioned table, the publication parameter
+ publish_via_partition_root
+ determines which row filter is used. If publish_via_partition_root
+ is true, the root partitioned table's
+ row filter is used. Otherwise, if publish_via_partition_root
+ is false (default), each partition's
+ row filter is used.
+
31.3.5. Initial Data Synchronization #
+ If the subscription requires copying pre-existing table data
+ and a publication contains WHERE clauses, only data that
+ satisfies the row filter expressions is copied to the subscriber.
+
+ If the subscription has several publications in which a table has been
+ published with different WHERE clauses, rows that satisfy
+ any of the expressions will be copied. See
+ Section 31.3.6 for details.
+
Warning
+ Because initial data synchronization does not take into account the
+ publish
+ parameter when copying existing table data, some rows may be copied that
+ would not be replicated using DML. Refer to
+ Section 31.7.1, and see
+ Section 31.2.2 for examples.
+
Note
+ If the subscriber is in a release prior to 15, copy pre-existing data
+ doesn't use row filters even if they are defined in the publication.
+ This is because old releases can only copy the entire table data.
+
31.3.6. Combining Multiple Row Filters #
+ If the subscription has several publications in which the same table has
+ been published with different row filters (for the same
+ publish
+ operation), those expressions get ORed together, so that rows satisfying
+ any of the expressions will be replicated. This means all
+ the other row filters for the same table become redundant if:
+
+ One of the publications has no row filter.
+
+ One of the publications was created using
+ FOR ALL TABLES.
+ This clause does not allow row filters.
+
+ One of the publications was created using
+ FOR TABLES IN SCHEMA
+ and the table belongs to the referred schema. This clause does not allow
+ row filters.
+
+ Create some tables to be used in the following examples.
+
+test_pub=# CREATE TABLE t1(a int, b int, c text, PRIMARY KEY(a,c));
+CREATE TABLE
+test_pub=# CREATE TABLE t2(d int, e int, f int, PRIMARY KEY(d));
+CREATE TABLE
+test_pub=# CREATE TABLE t3(g int, h int, i int, PRIMARY KEY(g));
+CREATE TABLE
+
+ Create some publications. Publication p1 has one table
+ (t1) and that table has a row filter. Publication
+ p2 has two tables. Table t1 has no row
+ filter, and table t2 has a row filter. Publication
+ p3 has two tables, and both of them have a row filter.
+
+test_pub=# CREATE PUBLICATION p1 FOR TABLE t1 WHERE (a > 5 AND c = 'NSW');
+CREATE PUBLICATION
+test_pub=# CREATE PUBLICATION p2 FOR TABLE t1, t2 WHERE (e = 99);
+CREATE PUBLICATION
+test_pub=# CREATE PUBLICATION p3 FOR TABLE t2 WHERE (d = 10), t3 WHERE (g = 10);
+CREATE PUBLICATION
+
+ psql can be used to show the row filter expressions (if
+ defined) for each publication.
+
+test_pub=# \dRp+
+ Publication p1
+ Owner | All tables | Inserts | Updates | Deletes | Truncates | Via root
+----------+------------+---------+---------+---------+-----------+----------
+ postgres | f | t | t | t | t | f
+Tables:
+ "public.t1" WHERE ((a > 5) AND (c = 'NSW'::text))
+
+ Publication p2
+ Owner | All tables | Inserts | Updates | Deletes | Truncates | Via root
+----------+------------+---------+---------+---------+-----------+----------
+ postgres | f | t | t | t | t | f
+Tables:
+ "public.t1"
+ "public.t2" WHERE (e = 99)
+
+ Publication p3
+ Owner | All tables | Inserts | Updates | Deletes | Truncates | Via root
+----------+------------+---------+---------+---------+-----------+----------
+ postgres | f | t | t | t | t | f
+Tables:
+ "public.t2" WHERE (d = 10)
+ "public.t3" WHERE (g = 10)
+
+ psql can be used to show the row filter expressions (if
+ defined) for each table. See that table t1 is a member
+ of two publications, but has a row filter only in p1.
+ See that table t2 is a member of two publications, and
+ has a different row filter in each of them.
+
+test_pub=# \d t1
+ Table "public.t1"
+ Column | Type | Collation | Nullable | Default
+--------+---------+-----------+----------+---------
+ a | integer | | not null |
+ b | integer | | |
+ c | text | | not null |
+Indexes:
+ "t1_pkey" PRIMARY KEY, btree (a, c)
+Publications:
+ "p1" WHERE ((a > 5) AND (c = 'NSW'::text))
+ "p2"
+
+test_pub=# \d t2
+ Table "public.t2"
+ Column | Type | Collation | Nullable | Default
+--------+---------+-----------+----------+---------
+ d | integer | | not null |
+ e | integer | | |
+ f | integer | | |
+Indexes:
+ "t2_pkey" PRIMARY KEY, btree (d)
+Publications:
+ "p2" WHERE (e = 99)
+ "p3" WHERE (d = 10)
+
+test_pub=# \d t3
+ Table "public.t3"
+ Column | Type | Collation | Nullable | Default
+--------+---------+-----------+----------+---------
+ g | integer | | not null |
+ h | integer | | |
+ i | integer | | |
+Indexes:
+ "t3_pkey" PRIMARY KEY, btree (g)
+Publications:
+ "p3" WHERE (g = 10)
+
+ On the subscriber node, create a table t1 with the same
+ definition as the one on the publisher, and also create the subscription
+ s1 that subscribes to the publication p1.
+
+test_sub=# CREATE TABLE t1(a int, b int, c text, PRIMARY KEY(a,c));
+CREATE TABLE
+test_sub=# CREATE SUBSCRIPTION s1
+test_sub-# CONNECTION 'host=localhost dbname=test_pub application_name=s1'
+test_sub-# PUBLICATION p1;
+CREATE SUBSCRIPTION
+
+ Insert some rows. Only the rows satisfying the t1 WHERE
+ clause of publication p1 are replicated.
+
+test_pub=# INSERT INTO t1 VALUES (2, 102, 'NSW');
+INSERT 0 1
+test_pub=# INSERT INTO t1 VALUES (3, 103, 'QLD');
+INSERT 0 1
+test_pub=# INSERT INTO t1 VALUES (4, 104, 'VIC');
+INSERT 0 1
+test_pub=# INSERT INTO t1 VALUES (5, 105, 'ACT');
+INSERT 0 1
+test_pub=# INSERT INTO t1 VALUES (6, 106, 'NSW');
+INSERT 0 1
+test_pub=# INSERT INTO t1 VALUES (7, 107, 'NT');
+INSERT 0 1
+test_pub=# INSERT INTO t1 VALUES (8, 108, 'QLD');
+INSERT 0 1
+test_pub=# INSERT INTO t1 VALUES (9, 109, 'NSW');
+INSERT 0 1
+
+test_pub=# SELECT * FROM t1;
+ a | b | c
+---+-----+-----
+ 2 | 102 | NSW
+ 3 | 103 | QLD
+ 4 | 104 | VIC
+ 5 | 105 | ACT
+ 6 | 106 | NSW
+ 7 | 107 | NT
+ 8 | 108 | QLD
+ 9 | 109 | NSW
+(8 rows)
+
+
+test_sub=# SELECT * FROM t1;
+ a | b | c
+---+-----+-----
+ 6 | 106 | NSW
+ 9 | 109 | NSW
+(2 rows)
+
+ Update some data, where the old and new row values both
+ satisfy the t1 WHERE clause of publication
+ p1. The UPDATE replicates
+ the change as normal.
+
+test_pub=# UPDATE t1 SET b = 999 WHERE a = 6;
+UPDATE 1
+
+test_pub=# SELECT * FROM t1;
+ a | b | c
+---+-----+-----
+ 2 | 102 | NSW
+ 3 | 103 | QLD
+ 4 | 104 | VIC
+ 5 | 105 | ACT
+ 7 | 107 | NT
+ 8 | 108 | QLD
+ 9 | 109 | NSW
+ 6 | 999 | NSW
+(8 rows)
+
+
+test_sub=# SELECT * FROM t1;
+ a | b | c
+---+-----+-----
+ 9 | 109 | NSW
+ 6 | 999 | NSW
+(2 rows)
+
+ Update some data, where the old row values did not satisfy
+ the t1 WHERE clause of publication p1,
+ but the new row values do satisfy it. The UPDATE is
+ transformed into an INSERT and the change is replicated.
+ See the new row on the subscriber.
+
+test_pub=# UPDATE t1 SET a = 555 WHERE a = 2;
+UPDATE 1
+
+test_pub=# SELECT * FROM t1;
+ a | b | c
+-----+-----+-----
+ 3 | 103 | QLD
+ 4 | 104 | VIC
+ 5 | 105 | ACT
+ 7 | 107 | NT
+ 8 | 108 | QLD
+ 9 | 109 | NSW
+ 6 | 999 | NSW
+ 555 | 102 | NSW
+(8 rows)
+
+
+test_sub=# SELECT * FROM t1;
+ a | b | c
+-----+-----+-----
+ 9 | 109 | NSW
+ 6 | 999 | NSW
+ 555 | 102 | NSW
+(3 rows)
+
+ Update some data, where the old row values satisfied
+ the t1 WHERE clause of publication p1,
+ but the new row values do not satisfy it. The UPDATE is
+ transformed into a DELETE and the change is replicated.
+ See that the row is removed from the subscriber.
+
+test_pub=# UPDATE t1 SET c = 'VIC' WHERE a = 9;
+UPDATE 1
+
+test_pub=# SELECT * FROM t1;
+ a | b | c
+-----+-----+-----
+ 3 | 103 | QLD
+ 4 | 104 | VIC
+ 5 | 105 | ACT
+ 7 | 107 | NT
+ 8 | 108 | QLD
+ 6 | 999 | NSW
+ 555 | 102 | NSW
+ 9 | 109 | VIC
+(8 rows)
+
+
+test_sub=# SELECT * FROM t1;
+ a | b | c
+-----+-----+-----
+ 6 | 999 | NSW
+ 555 | 102 | NSW
+(2 rows)
+
+ The following examples show how the publication parameter
+ publish_via_partition_root
+ determines whether the row filter of the parent or child table will be used
+ in the case of partitioned tables.
+
+ Create a partitioned table on the publisher.
+
+test_pub=# CREATE TABLE parent(a int PRIMARY KEY) PARTITION BY RANGE(a);
+CREATE TABLE
+test_pub=# CREATE TABLE child PARTITION OF parent DEFAULT;
+CREATE TABLE
+
+ Create the same tables on the subscriber.
+
+test_sub=# CREATE TABLE parent(a int PRIMARY KEY) PARTITION BY RANGE(a);
+CREATE TABLE
+test_sub=# CREATE TABLE child PARTITION OF parent DEFAULT;
+CREATE TABLE
+
+ Create a publication p4, and then subscribe to it. The
+ publication parameter publish_via_partition_root is set
+ as true. There are row filters defined on both the partitioned table
+ (parent), and on the partition (child).
+
+test_pub=# CREATE PUBLICATION p4 FOR TABLE parent WHERE (a < 5), child WHERE (a >= 5)
+test_pub-# WITH (publish_via_partition_root=true);
+CREATE PUBLICATION
+
+
+test_sub=# CREATE SUBSCRIPTION s4
+test_sub-# CONNECTION 'host=localhost dbname=test_pub application_name=s4'
+test_sub-# PUBLICATION p4;
+CREATE SUBSCRIPTION
+
+ Insert some values directly into the parent and
+ child tables. They replicate using the row filter of
+ parent (because publish_via_partition_root
+ is true).
+
+test_pub=# INSERT INTO parent VALUES (2), (4), (6);
+INSERT 0 3
+test_pub=# INSERT INTO child VALUES (3), (5), (7);
+INSERT 0 3
+
+test_pub=# SELECT * FROM parent ORDER BY a;
+ a
+---
+ 2
+ 3
+ 4
+ 5
+ 6
+ 7
+(6 rows)
+
+
+test_sub=# SELECT * FROM parent ORDER BY a;
+ a
+---
+ 2
+ 3
+ 4
+(3 rows)
+
+ Repeat the same test, but with a different value for publish_via_partition_root.
+ The publication parameter publish_via_partition_root is
+ set as false. A row filter is defined on the partition (child).
+
+test_pub=# DROP PUBLICATION p4;
+DROP PUBLICATION
+test_pub=# CREATE PUBLICATION p4 FOR TABLE parent, child WHERE (a >= 5)
+test_pub-# WITH (publish_via_partition_root=false);
+CREATE PUBLICATION
+
+
+test_sub=# ALTER SUBSCRIPTION s4 REFRESH PUBLICATION;
+ALTER SUBSCRIPTION
+
+ Do the inserts on the publisher same as before. They replicate using the
+ row filter of child (because
+ publish_via_partition_root is false).
+
+test_pub=# TRUNCATE parent;
+TRUNCATE TABLE
+test_pub=# INSERT INTO parent VALUES (2), (4), (6);
+INSERT 0 3
+test_pub=# INSERT INTO child VALUES (3), (5), (7);
+INSERT 0 3
+
+test_pub=# SELECT * FROM parent ORDER BY a;
+ a
+---
+ 2
+ 3
+ 4
+ 5
+ 6
+ 7
+(6 rows)
+
+
+test_sub=# SELECT * FROM child ORDER BY a;
+ a
+---
+ 5
+ 6
+ 7
+(3 rows)
+
+ The role used for the replication connection must have
+ the REPLICATION attribute (or be a superuser). If the
+ role lacks SUPERUSER and BYPASSRLS,
+ publisher row security policies can execute. If the role does not trust
+ all table owners, include options=-crow_security=off in
+ the connection string; if a table owner then adds a row security policy,
+ that setting will cause replication to halt rather than execute the policy.
+ Access for the role must be configured in pg_hba.conf
+ and it must have the LOGIN attribute.
+
+ In order to be able to copy the initial table data, the role used for the
+ replication connection must have the SELECT privilege on
+ a published table (or be a superuser).
+
+ To create a publication, the user must have the CREATE
+ privilege in the database.
+
+ To add tables to a publication, the user must have ownership rights on the
+ table. To add all tables in schema to a publication, the user must be a
+ superuser. To create a publication that publishes all tables or all tables in
+ schema automatically, the user must be a superuser.
+
+ There are currently no privileges on publications. Any subscription (that
+ is able to connect) can access any publication. Thus, if you intend to
+ hide some information from particular subscribers, such as by using row
+ filters or column lists, or by not adding the whole table to the
+ publication, be aware that other publications in the same database could
+ expose the same information. Publication privileges might be added to
+ PostgreSQL in the future to allow for
+ finer-grained access control.
+
+ To create a subscription, the user must have the privileges of the
+ the pg_create_subscription role, as well as
+ CREATE privileges on the database.
+
+ The subscription apply process will, at a session level, run with the
+ privileges of the subscription owner. However, when performing an insert,
+ update, delete, or truncate operation on a particular table, it will switch
+ roles to the table owner and perform the operation with the table owner's
+ privileges. This means that the subscription owner needs to be able to
+ SET ROLE to each role that owns a replicated table.
+
+ If the subscription has been configured with
+ run_as_owner = true, then no user switching will
+ occur. Instead, all operations will be performed with the permissions
+ of the subscription owner. In this case, the subscription owner only
+ needs privileges to SELECT, INSERT,
+ UPDATE, and DELETE from the
+ target table, and does not need privileges to SET ROLE
+ to the table owner. However, this also means that any user who owns
+ a table into which replication is happening can execute arbitrary code with
+ the privileges of the subscription owner. For example, they could do this
+ by simply attaching a trigger to one of the tables which they own.
+ Because it is usually undesirable to allow one role to freely assume
+ the privileges of another, this option should be avoided unless user
+ security within the database is of no concern.
+
+ On the publisher, privileges are only checked once at the start of a
+ replication connection and are not re-checked as each change record is read.
+
+ On the subscriber, the subscription owner's privileges are re-checked for
+ each transaction when applied. If a worker is in the process of applying a
+ transaction when the ownership of the subscription is changed by a
+ concurrent transaction, the application of the current transaction will
+ continue under the old owner's privileges.
+
+ A subscription is the downstream side of logical
+ replication. The node where a subscription is defined is referred to as
+ the subscriber. A subscription defines the connection
+ to another database and set of publications (one or more) to which it wants
+ to subscribe.
+
+ The subscriber database behaves in the same way as any other PostgreSQL
+ instance and can be used as a publisher for other databases by defining its
+ own publications.
+
+ A subscriber node may have multiple subscriptions if desired. It is
+ possible to define multiple subscriptions between a single
+ publisher-subscriber pair, in which case care must be taken to ensure
+ that the subscribed publication objects don't overlap.
+
+ Each subscription will receive changes via one replication slot (see
+ Section 27.2.6). Additional replication
+ slots may be required for the initial data synchronization of
+ pre-existing table data and those will be dropped at the end of data
+ synchronization.
+
+ A logical replication subscription can be a standby for synchronous
+ replication (see Section 27.2.8). The standby
+ name is by default the subscription name. An alternative name can be
+ specified as application_name in the connection
+ information of the subscription.
+
+ Subscriptions are dumped by pg_dump if the current user
+ is a superuser. Otherwise a warning is written and subscriptions are
+ skipped, because non-superusers cannot read all subscription information
+ from the pg_subscription catalog.
+
+ The subscription is added using CREATE SUBSCRIPTION and
+ can be stopped/resumed at any time using the
+ ALTER SUBSCRIPTION command and removed using
+ DROP SUBSCRIPTION.
+
+ When a subscription is dropped and recreated, the synchronization
+ information is lost. This means that the data has to be resynchronized
+ afterwards.
+
+ The schema definitions are not replicated, and the published tables must
+ exist on the subscriber. Only regular tables may be
+ the target of replication. For example, you can't replicate to a view.
+
+ The tables are matched between the publisher and the subscriber using the
+ fully qualified table name. Replication to differently-named tables on the
+ subscriber is not supported.
+
+ Columns of a table are also matched by name. The order of columns in the
+ subscriber table does not need to match that of the publisher. The data
+ types of the columns do not need to match, as long as the text
+ representation of the data can be converted to the target type. For
+ example, you can replicate from a column of type integer to a
+ column of type bigint. The target table can also have
+ additional columns not provided by the published table. Any such columns
+ will be filled with the default value as specified in the definition of the
+ target table. However, logical replication in binary format is more
+ restrictive. See the
+ binary
+ option of CREATE SUBSCRIPTION for details.
+
31.2.1. Replication Slot Management #
+ As mentioned earlier, each (active) subscription receives changes from a
+ replication slot on the remote (publishing) side.
+
+ Additional table synchronization slots are normally transient, created
+ internally to perform initial table synchronization and dropped
+ automatically when they are no longer needed. These table synchronization
+ slots have generated names: “pg_%u_sync_%u_%llu”
+ (parameters: Subscription oid,
+ Table relid, system identifier sysid)
+
+ Normally, the remote replication slot is created automatically when the
+ subscription is created using CREATE SUBSCRIPTION and it
+ is dropped automatically when the subscription is dropped using
+ DROP SUBSCRIPTION. In some situations, however, it can
+ be useful or necessary to manipulate the subscription and the underlying
+ replication slot separately. Here are some scenarios:
+
+
+ When creating a subscription, the replication slot already exists. In
+ that case, the subscription can be created using
+ the create_slot = false option to associate with the
+ existing slot.
+
+ When creating a subscription, the remote host is not reachable or in an
+ unclear state. In that case, the subscription can be created using
+ the connect = false option. The remote host will then not
+ be contacted at all. This is what pg_dump
+ uses. The remote replication slot will then have to be created
+ manually before the subscription can be activated.
+
+ When dropping a subscription, the replication slot should be kept.
+ This could be useful when the subscriber database is being moved to a
+ different host and will be activated from there. In that case,
+ disassociate the slot from the subscription using ALTER
+ SUBSCRIPTION before attempting to drop the subscription.
+
+ When dropping a subscription, the remote host is not reachable. In
+ that case, disassociate the slot from the subscription
+ using ALTER SUBSCRIPTION before attempting to drop
+ the subscription. If the remote database instance no longer exists, no
+ further action is then necessary. If, however, the remote database
+ instance is just unreachable, the replication slot (and any still
+ remaining table synchronization slots) should then be
+ dropped manually; otherwise it/they would continue to reserve WAL and might
+ eventually cause the disk to fill up. Such cases should be carefully
+ investigated.
+
+
31.2.2. Examples: Set Up Logical Replication #
+ Create some test tables on the publisher.
+
+test_pub=# CREATE TABLE t1(a int, b text, PRIMARY KEY(a));
+CREATE TABLE
+test_pub=# CREATE TABLE t2(c int, d text, PRIMARY KEY(c));
+CREATE TABLE
+test_pub=# CREATE TABLE t3(e int, f text, PRIMARY KEY(e));
+CREATE TABLE
+
+ Create the same tables on the subscriber.
+
+test_sub=# CREATE TABLE t1(a int, b text, PRIMARY KEY(a));
+CREATE TABLE
+test_sub=# CREATE TABLE t2(c int, d text, PRIMARY KEY(c));
+CREATE TABLE
+test_sub=# CREATE TABLE t3(e int, f text, PRIMARY KEY(e));
+CREATE TABLE
+
+ Insert data to the tables at the publisher side.
+
+test_pub=# INSERT INTO t1 VALUES (1, 'one'), (2, 'two'), (3, 'three');
+INSERT 0 3
+test_pub=# INSERT INTO t2 VALUES (1, 'A'), (2, 'B'), (3, 'C');
+INSERT 0 3
+test_pub=# INSERT INTO t3 VALUES (1, 'i'), (2, 'ii'), (3, 'iii');
+INSERT 0 3
+
+ Create publications for the tables. The publications pub2
+ and pub3a disallow some
+ publish
+ operations. The publication pub3b has a row filter (see
+ Section 31.3).
+
+test_pub=# CREATE PUBLICATION pub1 FOR TABLE t1;
+CREATE PUBLICATION
+test_pub=# CREATE PUBLICATION pub2 FOR TABLE t2 WITH (publish = 'truncate');
+CREATE PUBLICATION
+test_pub=# CREATE PUBLICATION pub3a FOR TABLE t3 WITH (publish = 'truncate');
+CREATE PUBLICATION
+test_pub=# CREATE PUBLICATION pub3b FOR TABLE t3 WHERE (e > 5);
+CREATE PUBLICATION
+
+ Create subscriptions for the publications. The subscription
+ sub3 subscribes to both pub3a and
+ pub3b. All subscriptions will copy initial data by default.
+
+test_sub=# CREATE SUBSCRIPTION sub1
+test_sub-# CONNECTION 'host=localhost dbname=test_pub application_name=sub1'
+test_sub-# PUBLICATION pub1;
+CREATE SUBSCRIPTION
+test_sub=# CREATE SUBSCRIPTION sub2
+test_sub-# CONNECTION 'host=localhost dbname=test_pub application_name=sub2'
+test_sub-# PUBLICATION pub2;
+CREATE SUBSCRIPTION
+test_sub=# CREATE SUBSCRIPTION sub3
+test_sub-# CONNECTION 'host=localhost dbname=test_pub application_name=sub3'
+test_sub-# PUBLICATION pub3a, pub3b;
+CREATE SUBSCRIPTION
+
+ Observe that initial table data is copied, regardless of the
+ publish operation of the publication.
+
+test_sub=# SELECT * FROM t1;
+ a | b
+---+-------
+ 1 | one
+ 2 | two
+ 3 | three
+(3 rows)
+
+test_sub=# SELECT * FROM t2;
+ c | d
+---+---
+ 1 | A
+ 2 | B
+ 3 | C
+(3 rows)
+
+ Furthermore, because the initial data copy ignores the publish
+ operation, and because publication pub3a has no row filter,
+ it means the copied table t3 contains all rows even when
+ they do not match the row filter of publication pub3b.
+
+test_sub=# SELECT * FROM t3;
+ e | f
+---+-----
+ 1 | i
+ 2 | ii
+ 3 | iii
+(3 rows)
+
+ Insert more data to the tables at the publisher side.
+
+test_pub=# INSERT INTO t1 VALUES (4, 'four'), (5, 'five'), (6, 'six');
+INSERT 0 3
+test_pub=# INSERT INTO t2 VALUES (4, 'D'), (5, 'E'), (6, 'F');
+INSERT 0 3
+test_pub=# INSERT INTO t3 VALUES (4, 'iv'), (5, 'v'), (6, 'vi');
+INSERT 0 3
+
+ Now the publisher side data looks like:
+
+test_pub=# SELECT * FROM t1;
+ a | b
+---+-------
+ 1 | one
+ 2 | two
+ 3 | three
+ 4 | four
+ 5 | five
+ 6 | six
+(6 rows)
+
+test_pub=# SELECT * FROM t2;
+ c | d
+---+---
+ 1 | A
+ 2 | B
+ 3 | C
+ 4 | D
+ 5 | E
+ 6 | F
+(6 rows)
+
+test_pub=# SELECT * FROM t3;
+ e | f
+---+-----
+ 1 | i
+ 2 | ii
+ 3 | iii
+ 4 | iv
+ 5 | v
+ 6 | vi
+(6 rows)
+
+ Observe that during normal replication the appropriate
+ publish operations are used. This means publications
+ pub2 and pub3a will not replicate the
+ INSERT. Also, publication pub3b will
+ only replicate data that matches the row filter of pub3b.
+ Now the subscriber side data looks like:
+
+test_sub=# SELECT * FROM t1;
+ a | b
+---+-------
+ 1 | one
+ 2 | two
+ 3 | three
+ 4 | four
+ 5 | five
+ 6 | six
+(6 rows)
+
+test_sub=# SELECT * FROM t2;
+ c | d
+---+---
+ 1 | A
+ 2 | B
+ 3 | C
+(3 rows)
+
+test_sub=# SELECT * FROM t3;
+ e | f
+---+-----
+ 1 | i
+ 2 | ii
+ 3 | iii
+ 6 | vi
+(4 rows)
+
31.2.3. Examples: Deferred Replication Slot Creation #
+ There are some cases (e.g.
+ Section 31.2.1) where, if the
+ remote replication slot was not created automatically, the user must create
+ it manually before the subscription can be activated. The steps to create
+ the slot and activate the subscription are shown in the following examples.
+ These examples specify the standard logical decoding output plugin
+ (pgoutput), which is what the built-in logical
+ replication uses.
+
+ First, create a publication for the examples to use.
+
+test_pub=# CREATE PUBLICATION pub1 FOR ALL TABLES;
+CREATE PUBLICATION
+
+ Example 1: Where the subscription says connect = false
+
+
+ Create the subscription.
+
+test_sub=# CREATE SUBSCRIPTION sub1
+test_sub-# CONNECTION 'host=localhost dbname=test_pub'
+test_sub-# PUBLICATION pub1
+test_sub-# WITH (connect=false);
+WARNING: subscription was created, but is not connected
+HINT: To initiate replication, you must manually create the replication slot, enable the subscription, and refresh the subscription.
+CREATE SUBSCRIPTION
+
+ On the publisher, manually create a slot. Because the name was not
+ specified during CREATE SUBSCRIPTION, the name of the
+ slot to create is same as the subscription name, e.g. "sub1".
+
+test_pub=# SELECT * FROM pg_create_logical_replication_slot('sub1', 'pgoutput');
+ slot_name | lsn
+-----------+-----------
+ sub1 | 0/19404D0
+(1 row)
+
+ On the subscriber, complete the activation of the subscription. After
+ this the tables of pub1 will start replicating.
+
+test_sub=# ALTER SUBSCRIPTION sub1 ENABLE;
+ALTER SUBSCRIPTION
+test_sub=# ALTER SUBSCRIPTION sub1 REFRESH PUBLICATION;
+ALTER SUBSCRIPTION
+
+
+ Example 2: Where the subscription says connect = false,
+ but also specifies the
+ slot_name
+ option.
+
+ Create the subscription.
+
+test_sub=# CREATE SUBSCRIPTION sub1
+test_sub-# CONNECTION 'host=localhost dbname=test_pub'
+test_sub-# PUBLICATION pub1
+test_sub-# WITH (connect=false, slot_name='myslot');
+WARNING: subscription was created, but is not connected
+HINT: To initiate replication, you must manually create the replication slot, enable the subscription, and refresh the subscription.
+CREATE SUBSCRIPTION
+
+ On the publisher, manually create a slot using the same name that was
+ specified during CREATE SUBSCRIPTION, e.g. "myslot".
+
+test_pub=# SELECT * FROM pg_create_logical_replication_slot('myslot', 'pgoutput');
+ slot_name | lsn
+-----------+-----------
+ myslot | 0/19059A0
+(1 row)
+
+ On the subscriber, the remaining subscription activation steps are the
+ same as before.
+
+test_sub=# ALTER SUBSCRIPTION sub1 ENABLE;
+ALTER SUBSCRIPTION
+test_sub=# ALTER SUBSCRIPTION sub1 REFRESH PUBLICATION;
+ALTER SUBSCRIPTION
+
+
+ Example 3: Where the subscription specifies slot_name = NONE
+
+ Create the subscription. When slot_name = NONE then
+ enabled = false, and
+ create_slot = false are also needed.
+
+test_sub=# CREATE SUBSCRIPTION sub1
+test_sub-# CONNECTION 'host=localhost dbname=test_pub'
+test_sub-# PUBLICATION pub1
+test_sub-# WITH (slot_name=NONE, enabled=false, create_slot=false);
+CREATE SUBSCRIPTION
+
+ On the publisher, manually create a slot using any name, e.g. "myslot".
+
+test_pub=# SELECT * FROM pg_create_logical_replication_slot('myslot', 'pgoutput');
+ slot_name | lsn
+-----------+-----------
+ myslot | 0/1905930
+(1 row)
+
+ On the subscriber, associate the subscription with the slot name just
+ created.
+
+test_sub=# ALTER SUBSCRIPTION sub1 SET (slot_name='myslot');
+ALTER SUBSCRIPTION
+
+ The remaining subscription activation steps are same as before.
+
+test_sub=# ALTER SUBSCRIPTION sub1 ENABLE;
+ALTER SUBSCRIPTION
+test_sub=# ALTER SUBSCRIPTION sub1 REFRESH PUBLICATION;
+ALTER SUBSCRIPTION
+
+
Chapter 31. Logical Replication
+ Logical replication is a method of replicating data objects and their
+ changes, based upon their replication identity (usually a primary key). We
+ use the term logical in contrast to physical replication, which uses exact
+ block addresses and byte-by-byte replication. PostgreSQL supports both
+ mechanisms concurrently, see Chapter 27. Logical
+ replication allows fine-grained control over both data replication and
+ security.
+
+ Logical replication uses a publish
+ and subscribe model with one or
+ more subscribers subscribing to one or more
+ publications on a publisher
+ node. Subscribers pull data from the publications they subscribe to and may
+ subsequently re-publish data to allow cascading replication or more complex
+ configurations.
+
+ Logical replication of a table typically starts with taking a snapshot
+ of the data on the publisher database and copying that to the subscriber.
+ Once that is done, the changes on the publisher are sent to the subscriber
+ as they occur in real-time. The subscriber applies the data in the same
+ order as the publisher so that transactional consistency is guaranteed for
+ publications within a single subscription. This method of data replication
+ is sometimes referred to as transactional replication.
+
+ The typical use-cases for logical replication are:
+
+
+ Sending incremental changes in a single database or a subset of a
+ database to subscribers as they occur.
+
+ Firing triggers for individual changes as they arrive on the
+ subscriber.
+
+ Consolidating multiple databases into a single one (for example for
+ analytical purposes).
+
+ Replicating between different major versions of PostgreSQL.
+
+ Replicating between PostgreSQL instances on different platforms (for
+ example Linux to Windows)
+
+ Giving access to replicated data to different groups of users.
+
+ Sharing a subset of the database between multiple databases.
+
+
+ The subscriber database behaves in the same way as any other PostgreSQL
+ instance and can be used as a publisher for other databases by defining its
+ own publications. When the subscriber is treated as read-only by
+ application, there will be no conflicts from a single subscription. On the
+ other hand, if there are other writes done either by an application or by other
+ subscribers to the same set of tables, conflicts can arise.
+
49.5. System Catalogs Related to Logical Decoding #
+ The pg_replication_slots
+ view and the
+
+ pg_stat_replication
+ view provide information about the current state of replication slots and
+ streaming replication connections respectively. These views apply to both physical and
+ logical replication. The
+
+ pg_stat_replication_slots
+ view provides statistics information about the logical replication slots.
+
49.1. Logical Decoding Examples #
+ The following example demonstrates controlling logical decoding using the
+ SQL interface.
+
+ Before you can use logical decoding, you must set
+ wal_level to logical and
+ max_replication_slots to at least 1. Then, you
+ should connect to the target database (in the example
+ below, postgres) as a superuser.
+
+postgres=# -- Create a slot named 'regression_slot' using the output plugin 'test_decoding'
+postgres=# SELECT * FROM pg_create_logical_replication_slot('regression_slot', 'test_decoding', false, true);
+ slot_name | lsn
+-----------------+-----------
+ regression_slot | 0/16B1970
+(1 row)
+
+postgres=# SELECT slot_name, plugin, slot_type, database, active, restart_lsn, confirmed_flush_lsn FROM pg_replication_slots;
+ slot_name | plugin | slot_type | database | active | restart_lsn | confirmed_flush_lsn
+-----------------+---------------+-----------+----------+--------+-------------+-----------------
+ regression_slot | test_decoding | logical | postgres | f | 0/16A4408 | 0/16A4440
+(1 row)
+
+postgres=# -- There are no changes to see yet
+postgres=# SELECT * FROM pg_logical_slot_get_changes('regression_slot', NULL, NULL);
+ lsn | xid | data
+-----+-----+------
+(0 rows)
+
+postgres=# CREATE TABLE data(id serial primary key, data text);
+CREATE TABLE
+
+postgres=# -- DDL isn't replicated, so all you'll see is the transaction
+postgres=# SELECT * FROM pg_logical_slot_get_changes('regression_slot', NULL, NULL);
+ lsn | xid | data
+-----------+-------+--------------
+ 0/BA2DA58 | 10297 | BEGIN 10297
+ 0/BA5A5A0 | 10297 | COMMIT 10297
+(2 rows)
+
+postgres=# -- Once changes are read, they're consumed and not emitted
+postgres=# -- in a subsequent call:
+postgres=# SELECT * FROM pg_logical_slot_get_changes('regression_slot', NULL, NULL);
+ lsn | xid | data
+-----+-----+------
+(0 rows)
+
+postgres=# BEGIN;
+postgres=*# INSERT INTO data(data) VALUES('1');
+postgres=*# INSERT INTO data(data) VALUES('2');
+postgres=*# COMMIT;
+
+postgres=# SELECT * FROM pg_logical_slot_get_changes('regression_slot', NULL, NULL);
+ lsn | xid | data
+-----------+-------+---------------------------------------------------------
+ 0/BA5A688 | 10298 | BEGIN 10298
+ 0/BA5A6F0 | 10298 | table public.data: INSERT: id[integer]:1 data[text]:'1'
+ 0/BA5A7F8 | 10298 | table public.data: INSERT: id[integer]:2 data[text]:'2'
+ 0/BA5A8A8 | 10298 | COMMIT 10298
+(4 rows)
+
+postgres=# INSERT INTO data(data) VALUES('3');
+
+postgres=# -- You can also peek ahead in the change stream without consuming changes
+postgres=# SELECT * FROM pg_logical_slot_peek_changes('regression_slot', NULL, NULL);
+ lsn | xid | data
+-----------+-------+---------------------------------------------------------
+ 0/BA5A8E0 | 10299 | BEGIN 10299
+ 0/BA5A8E0 | 10299 | table public.data: INSERT: id[integer]:3 data[text]:'3'
+ 0/BA5A990 | 10299 | COMMIT 10299
+(3 rows)
+
+postgres=# -- The next call to pg_logical_slot_peek_changes() returns the same changes again
+postgres=# SELECT * FROM pg_logical_slot_peek_changes('regression_slot', NULL, NULL);
+ lsn | xid | data
+-----------+-------+---------------------------------------------------------
+ 0/BA5A8E0 | 10299 | BEGIN 10299
+ 0/BA5A8E0 | 10299 | table public.data: INSERT: id[integer]:3 data[text]:'3'
+ 0/BA5A990 | 10299 | COMMIT 10299
+(3 rows)
+
+postgres=# -- options can be passed to output plugin, to influence the formatting
+postgres=# SELECT * FROM pg_logical_slot_peek_changes('regression_slot', NULL, NULL, 'include-timestamp', 'on');
+ lsn | xid | data
+-----------+-------+---------------------------------------------------------
+ 0/BA5A8E0 | 10299 | BEGIN 10299
+ 0/BA5A8E0 | 10299 | table public.data: INSERT: id[integer]:3 data[text]:'3'
+ 0/BA5A990 | 10299 | COMMIT 10299 (at 2017-05-10 12:07:21.272494-04)
+(3 rows)
+
+postgres=# -- Remember to destroy a slot you no longer need to stop it consuming
+postgres=# -- server resources:
+postgres=# SELECT pg_drop_replication_slot('regression_slot');
+ pg_drop_replication_slot
+-----------------------
+
+(1 row)
+
+ The following examples shows how logical decoding is controlled over the
+ streaming replication protocol, using the
+ program pg_recvlogical included in the PostgreSQL
+ distribution. This requires that client authentication is set up to allow
+ replication connections
+ (see Section 27.2.5.1) and
+ that max_wal_senders is set sufficiently high to allow
+ an additional connection. The second example shows how to stream two-phase
+ transactions. Before you use two-phase commands, you must set
+ max_prepared_transactions to at least 1.
+
+Example 1:
+$ pg_recvlogical -d postgres --slot=test --create-slot
+$ pg_recvlogical -d postgres --slot=test --start -f -
+Control+Z
+$ psql -d postgres -c "INSERT INTO data(data) VALUES('4');"
+$ fg
+BEGIN 693
+table public.data: INSERT: id[integer]:4 data[text]:'4'
+COMMIT 693
+Control+C
+$ pg_recvlogical -d postgres --slot=test --drop-slot
+
+Example 2:
+$ pg_recvlogical -d postgres --slot=test --create-slot --two-phase
+$ pg_recvlogical -d postgres --slot=test --start -f -
+Control+Z
+$ psql -d postgres -c "BEGIN;INSERT INTO data(data) VALUES('5');PREPARE TRANSACTION 'test';"
+$ fg
+BEGIN 694
+table public.data: INSERT: id[integer]:5 data[text]:'5'
+PREPARE TRANSACTION 'test', txid 694
+Control+Z
+$ psql -d postgres -c "COMMIT PREPARED 'test';"
+$ fg
+COMMIT PREPARED 'test', txid 694
+Control+C
+$ pg_recvlogical -d postgres --slot=test --drop-slot
+
+ The following example shows SQL interface that can be used to decode prepared
+ transactions. Before you use two-phase commit commands, you must set
+ max_prepared_transactions to at least 1. You must also have
+ set the two-phase parameter as 'true' while creating the slot using
+ pg_create_logical_replication_slot
+ Note that we will stream the entire transaction after the commit if it
+ is not already decoded.
+
+postgres=# BEGIN;
+postgres=*# INSERT INTO data(data) VALUES('5');
+postgres=*# PREPARE TRANSACTION 'test_prepared1';
+
+postgres=# SELECT * FROM pg_logical_slot_get_changes('regression_slot', NULL, NULL);
+ lsn | xid | data
+-----------+-----+---------------------------------------------------------
+ 0/1689DC0 | 529 | BEGIN 529
+ 0/1689DC0 | 529 | table public.data: INSERT: id[integer]:3 data[text]:'5'
+ 0/1689FC0 | 529 | PREPARE TRANSACTION 'test_prepared1', txid 529
+(3 rows)
+
+postgres=# COMMIT PREPARED 'test_prepared1';
+postgres=# select * from pg_logical_slot_get_changes('regression_slot', NULL, NULL);
+ lsn | xid | data
+-----------+-----+--------------------------------------------
+ 0/168A060 | 529 | COMMIT PREPARED 'test_prepared1', txid 529
+(4 row)
+
+postgres=#-- you can also rollback a prepared transaction
+postgres=# BEGIN;
+postgres=*# INSERT INTO data(data) VALUES('6');
+postgres=*# PREPARE TRANSACTION 'test_prepared2';
+postgres=# select * from pg_logical_slot_get_changes('regression_slot', NULL, NULL);
+ lsn | xid | data
+-----------+-----+---------------------------------------------------------
+ 0/168A180 | 530 | BEGIN 530
+ 0/168A1E8 | 530 | table public.data: INSERT: id[integer]:4 data[text]:'6'
+ 0/168A430 | 530 | PREPARE TRANSACTION 'test_prepared2', txid 530
+(3 rows)
+
+postgres=# ROLLBACK PREPARED 'test_prepared2';
+postgres=# select * from pg_logical_slot_get_changes('regression_slot', NULL, NULL);
+ lsn | xid | data
+-----------+-----+----------------------------------------------
+ 0/168A4B8 | 530 | ROLLBACK PREPARED 'test_prepared2', txid 530
+(1 row)
+49.2. Logical Decoding Concepts #
49.2.1. Logical Decoding #
+ Logical decoding is the process of extracting all persistent changes
+ to a database's tables into a coherent, easy to understand format which
+ can be interpreted without detailed knowledge of the database's internal
+ state.
+
+ In PostgreSQL, logical decoding is implemented
+ by decoding the contents of the write-ahead
+ log, which describe changes on a storage level, into an
+ application-specific form such as a stream of tuples or SQL statements.
+
49.2.2. Replication Slots #
+ In the context of logical replication, a slot represents a stream of
+ changes that can be replayed to a client in the order they were made on
+ the origin server. Each slot streams a sequence of changes from a single
+ database.
+
Note
PostgreSQL also has streaming replication slots
+ (see Section 27.2.5), but they are used somewhat
+ differently there.
+
+ A replication slot has an identifier that is unique across all databases
+ in a PostgreSQL cluster. Slots persist
+ independently of the connection using them and are crash-safe.
+
+ A logical slot will emit each change just once in normal operation.
+ The current position of each slot is persisted only at checkpoint, so in
+ the case of a crash the slot may return to an earlier LSN, which will
+ then cause recent changes to be sent again when the server restarts.
+ Logical decoding clients are responsible for avoiding ill effects from
+ handling the same message more than once. Clients may wish to record
+ the last LSN they saw when decoding and skip over any repeated data or
+ (when using the replication protocol) request that decoding start from
+ that LSN rather than letting the server determine the start point.
+ The Replication Progress Tracking feature is designed for this purpose,
+ refer to replication origins.
+
+ Multiple independent slots may exist for a single database. Each slot has
+ its own state, allowing different consumers to receive changes from
+ different points in the database change stream. For most applications, a
+ separate slot will be required for each consumer.
+
+ A logical replication slot knows nothing about the state of the
+ receiver(s). It's even possible to have multiple different receivers using
+ the same slot at different times; they'll just get the changes following
+ on from when the last receiver stopped consuming them. Only one receiver
+ may consume changes from a slot at any given time.
+
+ A logical replication slot can also be created on a hot standby. To prevent
+ VACUUM from removing required rows from the system
+ catalogs, hot_standby_feedback should be set on the
+ standby. In spite of that, if any required rows get removed, the slot gets
+ invalidated. It's highly recommended to use a physical slot between the
+ primary and the standby. Otherwise, hot_standby_feedback
+ will work but only while the connection is alive (for example a node
+ restart would break it). Then, the primary may delete system catalog rows
+ that could be needed by the logical decoding on the standby (as it does
+ not know about the catalog_xmin on the standby). Existing logical slots
+ on standby also get invalidated if wal_level on the
+ primary is reduced to less than logical.
+ This is done as soon as the standby detects such a change in the WAL stream.
+ It means that, for walsenders which are lagging (if any), some WAL records up
+ to the wal_level parameter change on the primary won't be
+ decoded.
+
+ Creation of a logical slot requires information about all the currently
+ running transactions. On the primary, this information is available
+ directly, but on a standby, this information has to be obtained from
+ primary. Thus, slot creation may need to wait for some activity to happen
+ on the primary. If the primary is idle, creating a logical slot on
+ standby may take noticeable time. This can be sped up by calling the
+ pg_log_standby_snapshot function on the primary.
+
Caution
+ Replication slots persist across crashes and know nothing about the state
+ of their consumer(s). They will prevent removal of required resources
+ even when there is no connection using them. This consumes storage
+ because neither required WAL nor required rows from the system catalogs
+ can be removed by VACUUM as long as they are required by a replication
+ slot. In extreme cases this could cause the database to shut down to prevent
+ transaction ID wraparound (see Section 25.1.5).
+ So if a slot is no longer required it should be dropped.
+
+ Output plugins transform the data from the write-ahead log's internal
+ representation into the format the consumer of a replication slot desires.
+
49.2.4. Exported Snapshots #
+ When a new replication slot is created using the streaming replication
+ interface (see CREATE_REPLICATION_SLOT), a
+ snapshot is exported
+ (see Section 9.27.5), which will show
+ exactly the state of the database after which all changes will be
+ included in the change stream. This can be used to create a new replica by
+ using SET TRANSACTION
+ SNAPSHOT to read the state of the database at the moment
+ the slot was created. This transaction can then be used to dump the
+ database's state at that point in time, which afterwards can be updated
+ using the slot's contents without losing any changes.
+
+ Creation of a snapshot is not always possible. In particular, it will
+ fail when connected to a hot standby. Applications that do not require
+ snapshot export may suppress it with the NOEXPORT_SNAPSHOT
+ option.
+
49.6. Logical Decoding Output Plugins #
+ An example output plugin can be found in the
+
+ contrib/test_decoding
+
+ subdirectory of the PostgreSQL source tree.
+
49.6.1. Initialization Function #
+ An output plugin is loaded by dynamically loading a shared library with
+ the output plugin's name as the library base name. The normal library
+ search path is used to locate the library. To provide the required output
+ plugin callbacks and to indicate that the library is actually an output
+ plugin it needs to provide a function named
+ _PG_output_plugin_init. This function is passed a
+ struct that needs to be filled with the callback function pointers for
+ individual actions.
+
+typedef struct OutputPluginCallbacks
+{
+ LogicalDecodeStartupCB startup_cb;
+ LogicalDecodeBeginCB begin_cb;
+ LogicalDecodeChangeCB change_cb;
+ LogicalDecodeTruncateCB truncate_cb;
+ LogicalDecodeCommitCB commit_cb;
+ LogicalDecodeMessageCB message_cb;
+ LogicalDecodeFilterByOriginCB filter_by_origin_cb;
+ LogicalDecodeShutdownCB shutdown_cb;
+ LogicalDecodeFilterPrepareCB filter_prepare_cb;
+ LogicalDecodeBeginPrepareCB begin_prepare_cb;
+ LogicalDecodePrepareCB prepare_cb;
+ LogicalDecodeCommitPreparedCB commit_prepared_cb;
+ LogicalDecodeRollbackPreparedCB rollback_prepared_cb;
+ LogicalDecodeStreamStartCB stream_start_cb;
+ LogicalDecodeStreamStopCB stream_stop_cb;
+ LogicalDecodeStreamAbortCB stream_abort_cb;
+ LogicalDecodeStreamPrepareCB stream_prepare_cb;
+ LogicalDecodeStreamCommitCB stream_commit_cb;
+ LogicalDecodeStreamChangeCB stream_change_cb;
+ LogicalDecodeStreamMessageCB stream_message_cb;
+ LogicalDecodeStreamTruncateCB stream_truncate_cb;
+} OutputPluginCallbacks;
+
+typedef void (*LogicalOutputPluginInit) (struct OutputPluginCallbacks *cb);
+
+ The begin_cb, change_cb
+ and commit_cb callbacks are required,
+ while startup_cb, truncate_cb,
+ message_cb, filter_by_origin_cb,
+ and shutdown_cb are optional.
+ If truncate_cb is not set but a
+ TRUNCATE is to be decoded, the action will be ignored.
+
+ An output plugin may also define functions to support streaming of large,
+ in-progress transactions. The stream_start_cb,
+ stream_stop_cb, stream_abort_cb,
+ stream_commit_cb, and stream_change_cb
+ are required, while stream_message_cb and
+ stream_truncate_cb are optional. The
+ stream_prepare_cb is also required if the output
+ plugin also support two-phase commits.
+
+ An output plugin may also define functions to support two-phase commits,
+ which allows actions to be decoded on the PREPARE TRANSACTION.
+ The begin_prepare_cb, prepare_cb,
+ commit_prepared_cb and rollback_prepared_cb
+ callbacks are required, while filter_prepare_cb is optional.
+ The stream_prepare_cb is also required if the output plugin
+ also supports the streaming of large in-progress transactions.
+
+ To decode, format and output changes, output plugins can use most of the
+ backend's normal infrastructure, including calling output functions. Read
+ only access to relations is permitted as long as only relations are
+ accessed that either have been created by initdb in
+ the pg_catalog schema, or have been marked as user
+ provided catalog tables using
+
+ALTER TABLE user_catalog_table SET (user_catalog_table = true);
+CREATE TABLE another_catalog_table(data text) WITH (user_catalog_table = true);
+
+ Note that access to user catalog tables or regular system catalog tables
+ in the output plugins has to be done via the systable_*
+ scan APIs only. Access via the heap_* scan APIs will
+ error out. Additionally, any actions leading to transaction ID assignment
+ are prohibited. That, among others, includes writing to tables, performing
+ DDL changes, and calling pg_current_xact_id().
+
+ Output plugin callbacks can pass data to the consumer in nearly arbitrary
+ formats. For some use cases, like viewing the changes via SQL, returning
+ data in a data type that can contain arbitrary data (e.g., bytea) is
+ cumbersome. If the output plugin only outputs textual data in the
+ server's encoding, it can declare that by
+ setting OutputPluginOptions.output_type
+ to OUTPUT_PLUGIN_TEXTUAL_OUTPUT instead
+ of OUTPUT_PLUGIN_BINARY_OUTPUT in
+ the startup
+ callback. In that case, all the data has to be in the server's encoding
+ so that a text datum can contain it. This is checked in assertion-enabled
+ builds.
+
49.6.4. Output Plugin Callbacks #
+ An output plugin gets notified about changes that are happening via
+ various callbacks it needs to provide.
+
+ Concurrent transactions are decoded in commit order, and only changes
+ belonging to a specific transaction are decoded between
+ the begin and commit
+ callbacks. Transactions that were rolled back explicitly or implicitly
+ never get
+ decoded. Successful savepoints are
+ folded into the transaction containing them in the order they were
+ executed within that transaction. A transaction that is prepared for
+ a two-phase commit using PREPARE TRANSACTION will
+ also be decoded if the output plugin callbacks needed for decoding
+ them are provided. It is possible that the current prepared transaction
+ which is being decoded is aborted concurrently via a
+ ROLLBACK PREPARED command. In that case, the logical
+ decoding of this transaction will be aborted too. All the changes of such
+ a transaction are skipped once the abort is detected and the
+ prepare_cb callback is invoked. Thus even in case of
+ a concurrent abort, enough information is provided to the output plugin
+ for it to properly deal with ROLLBACK PREPARED once
+ that is decoded.
+
Note
+ Only transactions that have already safely been flushed to disk will be
+ decoded. That can lead to a COMMIT not immediately being decoded in a
+ directly following pg_logical_slot_get_changes()
+ when synchronous_commit is set
+ to off.
+
49.6.4.1. Startup Callback #
+ The optional startup_cb callback is called whenever
+ a replication slot is created or asked to stream changes, independent
+ of the number of changes that are ready to be put out.
+
+typedef void (*LogicalDecodeStartupCB) (struct LogicalDecodingContext *ctx,
+ OutputPluginOptions *options,
+ bool is_init);
+
+ The is_init parameter will be true when the
+ replication slot is being created and false
+ otherwise. options points to a struct of options
+ that output plugins can set:
+
+typedef struct OutputPluginOptions
+{
+ OutputPluginOutputType output_type;
+ bool receive_rewrites;
+} OutputPluginOptions;
+
+ output_type has to either be set to
+ OUTPUT_PLUGIN_TEXTUAL_OUTPUT
+ or OUTPUT_PLUGIN_BINARY_OUTPUT. See also
+ Section 49.6.3.
+ If receive_rewrites is true, the output plugin will
+ also be called for changes made by heap rewrites during certain DDL
+ operations. These are of interest to plugins that handle DDL
+ replication, but they require special handling.
+
+ The startup callback should validate the options present in
+ ctx->output_plugin_options. If the output plugin
+ needs to have a state, it can
+ use ctx->output_plugin_private to store it.
+
49.6.4.2. Shutdown Callback #
+ The optional shutdown_cb callback is called
+ whenever a formerly active replication slot is not used anymore and can
+ be used to deallocate resources private to the output plugin. The slot
+ isn't necessarily being dropped, streaming is just being stopped.
+
+typedef void (*LogicalDecodeShutdownCB) (struct LogicalDecodingContext *ctx);
+
+
49.6.4.3. Transaction Begin Callback #
+ The required begin_cb callback is called whenever a
+ start of a committed transaction has been decoded. Aborted transactions
+ and their contents never get decoded.
+
+typedef void (*LogicalDecodeBeginCB) (struct LogicalDecodingContext *ctx,
+ ReorderBufferTXN *txn);
+
+ The txn parameter contains meta information about
+ the transaction, like the time stamp at which it has been committed and
+ its XID.
+
49.6.4.4. Transaction End Callback #
+ The required commit_cb callback is called whenever
+ a transaction commit has been
+ decoded. The change_cb callbacks for all modified
+ rows will have been called before this, if there have been any modified
+ rows.
+
+typedef void (*LogicalDecodeCommitCB) (struct LogicalDecodingContext *ctx,
+ ReorderBufferTXN *txn,
+ XLogRecPtr commit_lsn);
+
+
49.6.4.5. Change Callback #
+ The required change_cb callback is called for every
+ individual row modification inside a transaction, may it be
+ an INSERT, UPDATE,
+ or DELETE. Even if the original command modified
+ several rows at once the callback will be called individually for each
+ row. The change_cb callback may access system or
+ user catalog tables to aid in the process of outputting the row
+ modification details. In case of decoding a prepared (but yet
+ uncommitted) transaction or decoding of an uncommitted transaction, this
+ change callback might also error out due to simultaneous rollback of
+ this very same transaction. In that case, the logical decoding of this
+ aborted transaction is stopped gracefully.
+
+typedef void (*LogicalDecodeChangeCB) (struct LogicalDecodingContext *ctx,
+ ReorderBufferTXN *txn,
+ Relation relation,
+ ReorderBufferChange *change);
+
+ The ctx and txn parameters
+ have the same contents as for the begin_cb
+ and commit_cb callbacks, but additionally the
+ relation descriptor relation points to the
+ relation the row belongs to and a struct
+ change describing the row modification are passed
+ in.
+
Note
+ Only changes in user defined tables that are not unlogged
+ (see UNLOGGED) and not temporary
+ (see TEMPORARY or TEMP) can be extracted using
+ logical decoding.
+
49.6.4.6. Truncate Callback #
+ The optional truncate_cb callback is called for a
+ TRUNCATE command.
+
+typedef void (*LogicalDecodeTruncateCB) (struct LogicalDecodingContext *ctx,
+ ReorderBufferTXN *txn,
+ int nrelations,
+ Relation relations[],
+ ReorderBufferChange *change);
+
+ The parameters are analogous to the change_cb
+ callback. However, because TRUNCATE actions on
+ tables connected by foreign keys need to be executed together, this
+ callback receives an array of relations instead of just a single one.
+ See the description of the TRUNCATE statement for
+ details.
+
49.6.4.7. Origin Filter Callback #
+ The optional filter_by_origin_cb callback
+ is called to determine whether data that has been replayed
+ from origin_id is of interest to the
+ output plugin.
+
+typedef bool (*LogicalDecodeFilterByOriginCB) (struct LogicalDecodingContext *ctx,
+ RepOriginId origin_id);
+
+ The ctx parameter has the same contents
+ as for the other callbacks. No information but the origin is
+ available. To signal that changes originating on the passed in
+ node are irrelevant, return true, causing them to be filtered
+ away; false otherwise. The other callbacks will not be called
+ for transactions and changes that have been filtered away.
+
+ This is useful when implementing cascading or multidirectional
+ replication solutions. Filtering by the origin allows to
+ prevent replicating the same changes back and forth in such
+ setups. While transactions and changes also carry information
+ about the origin, filtering via this callback is noticeably
+ more efficient.
+
49.6.4.8. Generic Message Callback #
+ The optional message_cb callback is called whenever
+ a logical decoding message has been decoded.
+
+typedef void (*LogicalDecodeMessageCB) (struct LogicalDecodingContext *ctx,
+ ReorderBufferTXN *txn,
+ XLogRecPtr message_lsn,
+ bool transactional,
+ const char *prefix,
+ Size message_size,
+ const char *message);
+
+ The txn parameter contains meta information about
+ the transaction, like the time stamp at which it has been committed and
+ its XID. Note however that it can be NULL when the message is
+ non-transactional and the XID was not assigned yet in the transaction
+ which logged the message. The lsn has WAL
+ location of the message. The transactional says
+ if the message was sent as transactional or not. Similar to the change
+ callback, in case of decoding a prepared (but yet uncommitted)
+ transaction or decoding of an uncommitted transaction, this message
+ callback might also error out due to simultaneous rollback of
+ this very same transaction. In that case, the logical decoding of this
+ aborted transaction is stopped gracefully.
+
+ The prefix is arbitrary null-terminated prefix
+ which can be used for identifying interesting messages for the current
+ plugin. And finally the message parameter holds
+ the actual message of message_size size.
+
+ Extra care should be taken to ensure that the prefix the output plugin
+ considers interesting is unique. Using name of the extension or the
+ output plugin itself is often a good choice.
+
49.6.4.9. Prepare Filter Callback #
+ The optional filter_prepare_cb callback
+ is called to determine whether data that is part of the current
+ two-phase commit transaction should be considered for decoding
+ at this prepare stage or later as a regular one-phase transaction at
+ COMMIT PREPARED time. To signal that
+ decoding should be skipped, return true;
+ false otherwise. When the callback is not
+ defined, false is assumed (i.e. no filtering, all
+ transactions using two-phase commit are decoded in two phases as well).
+
+typedef bool (*LogicalDecodeFilterPrepareCB) (struct LogicalDecodingContext *ctx,
+ TransactionId xid,
+ const char *gid);
+
+ The ctx parameter has the same contents as for
+ the other callbacks. The parameters xid
+ and gid provide two different ways to identify
+ the transaction. The later COMMIT PREPARED or
+ ROLLBACK PREPARED carries both identifiers,
+ providing an output plugin the choice of what to use.
+
+ The callback may be invoked multiple times per transaction to decode
+ and must provide the same static answer for a given pair of
+ xid and gid every time
+ it is called.
+
49.6.4.10. Transaction Begin Prepare Callback #
+ The required begin_prepare_cb callback is called
+ whenever the start of a prepared transaction has been decoded. The
+ gid field, which is part of the
+ txn parameter, can be used in this callback to
+ check if the plugin has already received this PREPARE
+ in which case it can either error out or skip the remaining changes of
+ the transaction.
+
+typedef void (*LogicalDecodeBeginPrepareCB) (struct LogicalDecodingContext *ctx,
+ ReorderBufferTXN *txn);
+
+
49.6.4.11. Transaction Prepare Callback #
+ The required prepare_cb callback is called whenever
+ a transaction which is prepared for two-phase commit has been
+ decoded. The change_cb callback for all modified
+ rows will have been called before this, if there have been any modified
+ rows. The gid field, which is part of the
+ txn parameter, can be used in this callback.
+
+typedef void (*LogicalDecodePrepareCB) (struct LogicalDecodingContext *ctx,
+ ReorderBufferTXN *txn,
+ XLogRecPtr prepare_lsn);
+
+
49.6.4.12. Transaction Commit Prepared Callback #
+ The required commit_prepared_cb callback is called
+ whenever a transaction COMMIT PREPARED has been decoded.
+ The gid field, which is part of the
+ txn parameter, can be used in this callback.
+
+typedef void (*LogicalDecodeCommitPreparedCB) (struct LogicalDecodingContext *ctx,
+ ReorderBufferTXN *txn,
+ XLogRecPtr commit_lsn);
+
+
49.6.4.13. Transaction Rollback Prepared Callback #
+ The required rollback_prepared_cb callback is called
+ whenever a transaction ROLLBACK PREPARED has been
+ decoded. The gid field, which is part of the
+ txn parameter, can be used in this callback. The
+ parameters prepare_end_lsn and
+ prepare_time can be used to check if the plugin
+ has received this PREPARE TRANSACTION in which case
+ it can apply the rollback, otherwise, it can skip the rollback operation. The
+ gid alone is not sufficient because the downstream
+ node can have a prepared transaction with same identifier.
+
+typedef void (*LogicalDecodeRollbackPreparedCB) (struct LogicalDecodingContext *ctx,
+ ReorderBufferTXN *txn,
+ XLogRecPtr prepare_end_lsn,
+ TimestampTz prepare_time);
+
+
49.6.4.14. Stream Start Callback #
+ The required stream_start_cb callback is called when
+ opening a block of streamed changes from an in-progress transaction.
+
+typedef void (*LogicalDecodeStreamStartCB) (struct LogicalDecodingContext *ctx,
+ ReorderBufferTXN *txn);
+
+
49.6.4.15. Stream Stop Callback #
+ The required stream_stop_cb callback is called when
+ closing a block of streamed changes from an in-progress transaction.
+
+typedef void (*LogicalDecodeStreamStopCB) (struct LogicalDecodingContext *ctx,
+ ReorderBufferTXN *txn);
+
+
49.6.4.16. Stream Abort Callback #
+ The required stream_abort_cb callback is called to
+ abort a previously streamed transaction.
+
+typedef void (*LogicalDecodeStreamAbortCB) (struct LogicalDecodingContext *ctx,
+ ReorderBufferTXN *txn,
+ XLogRecPtr abort_lsn);
+
+
49.6.4.17. Stream Prepare Callback #
+ The stream_prepare_cb callback is called to prepare
+ a previously streamed transaction as part of a two-phase commit. This
+ callback is required when the output plugin supports both the streaming
+ of large in-progress transactions and two-phase commits.
+
+typedef void (*LogicalDecodeStreamPrepareCB) (struct LogicalDecodingContext *ctx,
+ ReorderBufferTXN *txn,
+ XLogRecPtr prepare_lsn);
+
+
49.6.4.18. Stream Commit Callback #
+ The required stream_commit_cb callback is called to
+ commit a previously streamed transaction.
+
+typedef void (*LogicalDecodeStreamCommitCB) (struct LogicalDecodingContext *ctx,
+ ReorderBufferTXN *txn,
+ XLogRecPtr commit_lsn);
+
+
49.6.4.19. Stream Change Callback #
+ The required stream_change_cb callback is called
+ when sending a change in a block of streamed changes (demarcated by
+ stream_start_cb and stream_stop_cb calls).
+ The actual changes are not displayed as the transaction can abort at a later
+ point in time and we don't decode changes for aborted transactions.
+
+typedef void (*LogicalDecodeStreamChangeCB) (struct LogicalDecodingContext *ctx,
+ ReorderBufferTXN *txn,
+ Relation relation,
+ ReorderBufferChange *change);
+
+
49.6.4.20. Stream Message Callback #
+ The optional stream_message_cb callback is called when
+ sending a generic message in a block of streamed changes (demarcated by
+ stream_start_cb and stream_stop_cb calls).
+ The message contents for transactional messages are not displayed as the transaction
+ can abort at a later point in time and we don't decode changes for aborted
+ transactions.
+
+typedef void (*LogicalDecodeStreamMessageCB) (struct LogicalDecodingContext *ctx,
+ ReorderBufferTXN *txn,
+ XLogRecPtr message_lsn,
+ bool transactional,
+ const char *prefix,
+ Size message_size,
+ const char *message);
+
+
49.6.4.21. Stream Truncate Callback #
+ The optional stream_truncate_cb callback is called
+ for a TRUNCATE command in a block of streamed changes
+ (demarcated by stream_start_cb and
+ stream_stop_cb calls).
+
+typedef void (*LogicalDecodeStreamTruncateCB) (struct LogicalDecodingContext *ctx,
+ ReorderBufferTXN *txn,
+ int nrelations,
+ Relation relations[],
+ ReorderBufferChange *change);
+
+ The parameters are analogous to the stream_change_cb
+ callback. However, because TRUNCATE actions on
+ tables connected by foreign keys need to be executed together, this
+ callback receives an array of relations instead of just a single one.
+ See the description of the TRUNCATE statement for
+ details.
+
49.6.5. Functions for Producing Output #
+ To actually produce output, output plugins can write data to
+ the StringInfo output buffer
+ in ctx->out when inside
+ the begin_cb, commit_cb,
+ or change_cb callbacks. Before writing to the output
+ buffer, OutputPluginPrepareWrite(ctx, last_write) has
+ to be called, and after finishing writing to the
+ buffer, OutputPluginWrite(ctx, last_write) has to be
+ called to perform the write. The last_write
+ indicates whether a particular write was the callback's last write.
+
+ The following example shows how to output data to the consumer of an
+ output plugin:
+
+OutputPluginPrepareWrite(ctx, true);
+appendStringInfo(ctx->out, "BEGIN %u", txn->xid);
+OutputPluginWrite(ctx, true);
+
+
49.4. Logical Decoding SQL Interface #
+ See Section 9.27.6 for detailed documentation on
+ the SQL-level API for interacting with logical decoding.
+
+ Synchronous replication (see Section 27.2.8) is
+ only supported on replication slots used over the streaming replication interface. The
+ function interface and additional, non-core interfaces do not support
+ synchronous replication.
+
49.9. Streaming of Large Transactions for Logical Decoding #
+ The basic output plugin callbacks (e.g., begin_cb,
+ change_cb, commit_cb and
+ message_cb) are only invoked when the transaction
+ actually commits. The changes are still decoded from the transaction
+ log, but are only passed to the output plugin at commit (and discarded
+ if the transaction aborts).
+
+ This means that while the decoding happens incrementally, and may spill
+ to disk to keep memory usage under control, all the decoded changes have
+ to be transmitted when the transaction finally commits (or more precisely,
+ when the commit is decoded from the transaction log). Depending on the
+ size of the transaction and network bandwidth, the transfer time may
+ significantly increase the apply lag.
+
+ To reduce the apply lag caused by large transactions, an output plugin
+ may provide additional callback to support incremental streaming of
+ in-progress transactions. There are multiple required streaming callbacks
+ (stream_start_cb, stream_stop_cb,
+ stream_abort_cb, stream_commit_cb
+ and stream_change_cb) and two optional callbacks
+ (stream_message_cb and stream_truncate_cb).
+ Also, if streaming of two-phase commands is to be supported, then additional
+ callbacks must be provided. (See Section 49.10
+ for details).
+
+ When streaming an in-progress transaction, the changes (and messages) are
+ streamed in blocks demarcated by stream_start_cb
+ and stream_stop_cb callbacks. Once all the decoded
+ changes are transmitted, the transaction can be committed using the
+ stream_commit_cb callback
+ (or possibly aborted using the stream_abort_cb callback).
+ If two-phase commits are supported, the transaction can be prepared using the
+ stream_prepare_cb callback,
+ COMMIT PREPARED using the
+ commit_prepared_cb callback or aborted using the
+ rollback_prepared_cb.
+
+ One example sequence of streaming callback calls for one transaction may
+ look like this:
+
+stream_start_cb(...); <-- start of first block of changes
+ stream_change_cb(...);
+ stream_change_cb(...);
+ stream_message_cb(...);
+ stream_change_cb(...);
+ ...
+ stream_change_cb(...);
+stream_stop_cb(...); <-- end of first block of changes
+
+stream_start_cb(...); <-- start of second block of changes
+ stream_change_cb(...);
+ stream_change_cb(...);
+ stream_change_cb(...);
+ ...
+ stream_message_cb(...);
+ stream_change_cb(...);
+stream_stop_cb(...); <-- end of second block of changes
+
+
+[a. when using normal commit]
+stream_commit_cb(...); <-- commit of the streamed transaction
+
+[b. when using two-phase commit]
+stream_prepare_cb(...); <-- prepare the streamed transaction
+commit_prepared_cb(...); <-- commit of the prepared transaction
+
+
+ The actual sequence of callback calls may be more complicated, of course.
+ There may be blocks for multiple streamed transactions, some of the
+ transactions may get aborted, etc.
+
+ Similar to spill-to-disk behavior, streaming is triggered when the total
+ amount of changes decoded from the WAL (for all in-progress transactions)
+ exceeds the limit defined by logical_decoding_work_mem setting.
+ At that point, the largest top-level transaction (measured by the amount of memory
+ currently used for decoded changes) is selected and streamed. However, in
+ some cases we still have to spill to disk even if streaming is enabled
+ because we exceed the memory threshold but still have not decoded the
+ complete tuple e.g., only decoded toast table insert but not the main table
+ insert.
+
+ Even when streaming large transactions, the changes are still applied in
+ commit order, preserving the same guarantees as the non-streaming mode.
+
49.8. Synchronous Replication Support for Logical Decoding #
+ Logical decoding can be used to build
+ synchronous
+ replication solutions with the same user interface as synchronous
+ replication for streaming
+ replication. To do this, the streaming replication interface
+ (see Section 49.3) must be used to stream out
+ data. Clients have to send Standby status update (F)
+ (see Section 55.4) messages, just like streaming
+ replication clients do.
+
Note
+ A synchronous replica receiving changes via logical decoding will work in
+ the scope of a single database. Since, in contrast to
+ that, synchronous_standby_names currently is
+ server wide, this means this technique will not work properly if more
+ than one database is actively used.
+
+ In synchronous replication setup, a deadlock can happen, if the transaction
+ has locked [user] catalog tables exclusively. See
+ Section 49.6.2 for information on user
+ catalog tables. This is because logical decoding of transactions can lock
+ catalog tables to access them. To avoid this users must refrain from taking
+ an exclusive lock on [user] catalog tables. This can happen in the following
+ ways:
+
+
+ Issuing an explicit LOCK on pg_class
+ in a transaction.
+
+ Perform CLUSTER on pg_class in
+ a transaction.
+
+ PREPARE TRANSACTION after LOCK command
+ on pg_class and allow logical decoding of two-phase
+ transactions.
+
+ PREPARE TRANSACTION after CLUSTER
+ command on pg_trigger and allow logical decoding of
+ two-phase transactions. This will lead to deadlock only when published table
+ have a trigger.
+
+ Executing TRUNCATE on [user] catalog table in a
+ transaction.
+
+
+ Note that these commands that can cause deadlock apply to not only explicitly
+ indicated system catalog tables above but also to any other [user] catalog
+ table.
+
49.10. Two-phase Commit Support for Logical Decoding #
+ With the basic output plugin callbacks (eg., begin_cb,
+ change_cb, commit_cb and
+ message_cb) two-phase commit commands like
+ PREPARE TRANSACTION, COMMIT PREPARED
+ and ROLLBACK PREPARED are not decoded. While the
+ PREPARE TRANSACTION is ignored,
+ COMMIT PREPARED is decoded as a COMMIT
+ and ROLLBACK PREPARED is decoded as a
+ ROLLBACK.
+
+ To support the streaming of two-phase commands, an output plugin needs to
+ provide additional callbacks. There are multiple two-phase commit callbacks
+ that are required, (begin_prepare_cb,
+ prepare_cb, commit_prepared_cb,
+ rollback_prepared_cb and
+ stream_prepare_cb) and an optional callback
+ (filter_prepare_cb).
+
+ If the output plugin callbacks for decoding two-phase commit commands are
+ provided, then on PREPARE TRANSACTION, the changes of
+ that transaction are decoded, passed to the output plugin, and the
+ prepare_cb callback is invoked. This differs from the
+ basic decoding setup where changes are only passed to the output plugin
+ when a transaction is committed. The start of a prepared transaction is
+ indicated by the begin_prepare_cb callback.
+
+ When a prepared transaction is rolled back using the
+ ROLLBACK PREPARED, then the
+ rollback_prepared_cb callback is invoked and when the
+ prepared transaction is committed using COMMIT PREPARED,
+ then the commit_prepared_cb callback is invoked.
+
+ Optionally the output plugin can define filtering rules via
+ filter_prepare_cb to decode only specific transaction
+ in two phases. This can be achieved by pattern matching on the
+ gid or via lookups using the
+ xid.
+
+ The users that want to decode prepared transactions need to be careful about
+ below mentioned points:
+
+
+ If the prepared transaction has locked [user] catalog tables exclusively
+ then decoding prepare can block till the main transaction is committed.
+
+ The logical replication solution that builds distributed two phase commit
+ using this feature can deadlock if the prepared transaction has locked
+ [user] catalog tables exclusively. To avoid this users must refrain from
+ having locks on catalog tables (e.g. explicit LOCK command)
+ in such transactions.
+ See Section 49.8.2 for the details.
+
+
49.3. Streaming Replication Protocol Interface #
+ The commands
+
CREATE_REPLICATION_SLOT slot_name LOGICAL output_plugin
DROP_REPLICATION_SLOT slot_name [ WAIT ]
START_REPLICATION SLOT slot_name LOGICAL ...
+ are used to create, drop, and stream changes from a replication
+ slot, respectively. These commands are only available over a replication
+ connection; they cannot be used via SQL.
+ See Section 55.4 for details on these commands.
+
+ The command pg_recvlogical can be used to control
+ logical decoding over a streaming replication connection. (It uses
+ these commands internally.)
+
49.7. Logical Decoding Output Writers #
+ It is possible to add more output methods for logical decoding.
+ For details, see
+ src/backend/replication/logical/logicalfuncs.c.
+ Essentially, three functions need to be provided: one to read WAL, one to
+ prepare writing output, and one to write the output
+ (see Section 49.6.5).
+
Chapter 49. Logical Decoding
+ PostgreSQL provides infrastructure to stream the modifications performed
+ via SQL to external consumers. This functionality can be used for a
+ variety of purposes, including replication solutions and auditing.
+
+ Changes are sent out in streams identified by logical replication slots.
+
+ The format in which those changes are streamed is determined by the output
+ plugin used. An example plugin is provided in the PostgreSQL distribution.
+ Additional plugins can be
+ written to extend the choice of available formats without modifying any
+ core code.
+ Every output plugin has access to each individual new row produced
+ by INSERT and the new row version created
+ by UPDATE. Availability of old row versions for
+ UPDATE and DELETE depends on
+ the configured replica identity (see REPLICA IDENTITY).
+
+ Changes can be consumed either using the streaming replication protocol
+ (see Section 55.4 and
+ Section 49.3), or by calling functions
+ via SQL (see Section 49.4). It is also possible
+ to write additional methods of consuming the output of a replication slot
+ without modifying core code
+ (see Section 49.7).
+
F.23. ltree — hierarchical tree-like data type #
+ This module implements a data type ltree for representing
+ labels of data stored in a hierarchical tree-like structure.
+ Extensive facilities for searching through label trees are provided.
+
+ This module is considered “trusted”, that is, it can be
+ installed by non-superusers who have CREATE privilege
+ on the current database.
+
+ A label is a sequence of alphanumeric characters,
+ underscores, and hyphens. Valid alphanumeric character ranges are
+ dependent on the database locale. For example, in C locale, the characters
+ A-Za-z0-9_- are allowed.
+ Labels must be no more than 1000 characters long.
+
+ Examples: 42, Personal_Services
+
+ A label path is a sequence of zero or more
+ labels separated by dots, for example L1.L2.L3, representing
+ a path from the root of a hierarchical tree to a particular node. The
+ length of a label path cannot exceed 65535 labels.
+
+ Example: Top.Countries.Europe.Russia
+
+ The ltree module provides several data types:
+
+ ltree stores a label path.
+
+ lquery represents a regular-expression-like pattern
+ for matching ltree values. A simple word matches that
+ label within a path. A star symbol (*) matches zero
+ or more labels. These can be joined with dots to form a pattern that
+ must match the whole label path. For example:
+
+foo Match the exact label path foo
+*.foo.* Match any label path containing the label foo
+*.foo Match any label path whose last label is foo
+
+
+ Both star symbols and simple words can be quantified to restrict how many
+ labels they can match:
+
+*{n} Match exactly n labels
+*{n,} Match at least n labels
+*{n,m} Match at least n but not more than m labels
+*{,m} Match at most m labels — same as *{0,m}
+foo{n,m} Match at least n but not more than m occurrences of foo
+foo{,} Match any number of occurrences of foo, including zero
+
+ In the absence of any explicit quantifier, the default for a star symbol
+ is to match any number of labels (that is, {,}) while
+ the default for a non-star item is to match exactly once (that
+ is, {1}).
+
+ There are several modifiers that can be put at the end of a non-star
+ lquery item to make it match more than just the exact match:
+
+@ Match case-insensitively, for example a@ matches A
+* Match any label with this prefix, for example foo* matches foobar
+% Match initial underscore-separated words
+
+ The behavior of % is a bit complicated. It tries to match
+ words rather than the entire label. For example
+ foo_bar% matches foo_bar_baz but not
+ foo_barbaz. If combined with *, prefix
+ matching applies to each word separately, for example
+ foo_bar%* matches foo1_bar2_baz but
+ not foo1_br2_baz.
+
+ Also, you can write several possibly-modified non-star items separated with
+ | (OR) to match any of those items, and you can put
+ ! (NOT) at the start of a non-star group to match any
+ label that doesn't match any of the alternatives. A quantifier, if any,
+ goes at the end of the group; it means some number of matches for the
+ group as a whole (that is, some number of labels matching or not matching
+ any of the alternatives).
+
+ Here's an annotated example of lquery:
+
+Top.*{0,2}.sport*@.!football|tennis{1,}.Russ*|Spain
+a. b. c. d. e.
+
+ This query will match any label path that:
+
+ begins with the label Top
+
+ and next has zero to two labels before
+
+ a label beginning with the case-insensitive prefix sport
+
+ then has one or more labels, none of which
+ match football nor tennis
+
+ and then ends with a label beginning with Russ or
+ exactly matching Spain.
+
ltxtquery represents a full-text-search-like
+ pattern for matching ltree values. An
+ ltxtquery value contains words, possibly with the
+ modifiers @, *, % at the end;
+ the modifiers have the same meanings as in lquery.
+ Words can be combined with & (AND),
+ | (OR), ! (NOT), and parentheses.
+ The key difference from
+ lquery is that ltxtquery matches words without
+ regard to their position in the label path.
+
+ Here's an example ltxtquery:
+
+Europe & Russia*@ & !Transportation
+
+ This will match paths that contain the label Europe and
+ any label beginning with Russia (case-insensitive),
+ but not paths containing the label Transportation.
+ The location of these words within the path is not important.
+ Also, when % is used, the word can be matched to any
+ underscore-separated word within a label, regardless of position.
+
+ Note: ltxtquery allows whitespace between symbols, but
+ ltree and lquery do not.
+
F.23.2. Operators and Functions #
+ Type ltree has the usual comparison operators
+ =, <>,
+ <, >, <=, >=.
+ Comparison sorts in the order of a tree traversal, with the children
+ of a node sorted by label text. In addition, the specialized
+ operators shown in Table F.13 are available.
+
Table F.13. ltree Operators
+ Operator
+
+
+ Description
+ |
|---|
+ ltree @> ltree
+ → boolean
+
+
+ Is left argument an ancestor of right (or equal)?
+ |
+ ltree <@ ltree
+ → boolean
+
+
+ Is left argument a descendant of right (or equal)?
+ |
+ ltree ~ lquery
+ → boolean
+
+
+ lquery ~ ltree
+ → boolean
+
+
+ Does ltree match lquery?
+ |
+ ltree ? lquery[]
+ → boolean
+
+
+ lquery[] ? ltree
+ → boolean
+
+
+ Does ltree match any lquery in array?
+ |
+ ltree @ ltxtquery
+ → boolean
+
+
+ ltxtquery @ ltree
+ → boolean
+
+
+ Does ltree match ltxtquery?
+ |
+ ltree || ltree
+ → ltree
+
+
+ Concatenates ltree paths.
+ |
+ ltree || text
+ → ltree
+
+
+ text || ltree
+ → ltree
+
+
+ Converts text to ltree and concatenates.
+ |
+ ltree[] @> ltree
+ → boolean
+
+
+ ltree <@ ltree[]
+ → boolean
+
+
+ Does array contain an ancestor of ltree?
+ |
+ ltree[] <@ ltree
+ → boolean
+
+
+ ltree @> ltree[]
+ → boolean
+
+
+ Does array contain a descendant of ltree?
+ |
+ ltree[] ~ lquery
+ → boolean
+
+
+ lquery ~ ltree[]
+ → boolean
+
+
+ Does array contain any path matching lquery?
+ |
+ ltree[] ? lquery[]
+ → boolean
+
+
+ lquery[] ? ltree[]
+ → boolean
+
+
+ Does ltree array contain any path matching
+ any lquery?
+ |
+ ltree[] @ ltxtquery
+ → boolean
+
+
+ ltxtquery @ ltree[]
+ → boolean
+
+
+ Does array contain any path matching ltxtquery?
+ |
+ ltree[] ?@> ltree
+ → ltree
+
+
+ Returns first array entry that is an ancestor of ltree,
+ or NULL if none.
+ |
+ ltree[] ?<@ ltree
+ → ltree
+
+
+ Returns first array entry that is a descendant of ltree,
+ or NULL if none.
+ |
+ ltree[] ?~ lquery
+ → ltree
+
+
+ Returns first array entry that matches lquery,
+ or NULL if none.
+ |
+ ltree[] ?@ ltxtquery
+ → ltree
+
+
+ Returns first array entry that matches ltxtquery,
+ or NULL if none.
+ |
+ The operators <@, @>,
+ @ and ~ have analogues
+ ^<@, ^@>, ^@,
+ ^~, which are the same except they do not use
+ indexes. These are useful only for testing purposes.
+
+ The available functions are shown in Table F.14.
+
Table F.14. ltree Functions
+ Function
+
+
+ Description
+
+
+ Example(s)
+ |
|---|
+
+ subltree ( ltree, start integer, end integer )
+ → ltree
+
+
+ Returns subpath of ltree from
+ position start to
+ position end-1 (counting from 0).
+
+
+ subltree('Top.Child1.Child2', 1, 2)
+ → Child1
+ |
+
+ subpath ( ltree, offset integer, len integer )
+ → ltree
+
+
+ Returns subpath of ltree starting at
+ position offset, with
+ length len. If offset
+ is negative, subpath starts that far from the end of the path.
+ If len is negative, leaves that many labels off
+ the end of the path.
+
+
+ subpath('Top.Child1.Child2', 0, 2)
+ → Top.Child1
+ |
+ subpath ( ltree, offset integer )
+ → ltree
+
+
+ Returns subpath of ltree starting at
+ position offset, extending to end of path.
+ If offset is negative, subpath starts that far
+ from the end of the path.
+
+
+ subpath('Top.Child1.Child2', 1)
+ → Child1.Child2
+ |
+
+ nlevel ( ltree )
+ → integer
+
+
+ Returns number of labels in path.
+
+
+ nlevel('Top.Child1.Child2')
+ → 3
+ |
+
+ index ( a ltree, b ltree )
+ → integer
+
+
+ Returns position of first occurrence of b in
+ a, or -1 if not found.
+
+
+ index('0.1.2.3.5.4.5.6.8.5.6.8', '5.6')
+ → 6
+ |
+ index ( a ltree, b ltree, offset integer )
+ → integer
+
+
+ Returns position of first occurrence of b
+ in a, or -1 if not found. The search starts at
+ position offset;
+ negative offset means
+ start -offset labels from the end of the path.
+
+
+ index('0.1.2.3.5.4.5.6.8.5.6.8', '5.6', -4)
+ → 9
+ |
+
+ text2ltree ( text )
+ → ltree
+
+
+ Casts text to ltree.
+ |
+
+ ltree2text ( ltree )
+ → text
+
+
+ Casts ltree to text.
+ |
+
+ lca ( ltree [, ltree [, ... ]] )
+ → ltree
+
+
+ Computes longest common ancestor of paths
+ (up to 8 arguments are supported).
+
+
+ lca('1.2.3', '1.2.3.4.5.6')
+ → 1.2
+ |
+ lca ( ltree[] )
+ → ltree
+
+
+ Computes longest common ancestor of paths in array.
+
+
+ lca(array['1.2.3'::ltree,'1.2.3.4'])
+ → 1.2
+ |
+ ltree supports several types of indexes that can speed
+ up the indicated operators:
+
+ B-tree index over ltree:
+ <, <=, =,
+ >=, >
+
+ GiST index over ltree (gist_ltree_ops
+ opclass):
+ <, <=, =,
+ >=, >,
+ @>, <@,
+ @, ~, ?
+
+ gist_ltree_ops GiST opclass approximates a set of
+ path labels as a bitmap signature. Its optional integer parameter
+ siglen determines the
+ signature length in bytes. The default signature length is 8 bytes.
+ The length must be a positive multiple of int alignment
+ (4 bytes on most machines)) up to 2024. Longer
+ signatures lead to a more precise search (scanning a smaller fraction of the index and
+ fewer heap pages), at the cost of a larger index.
+
+ Example of creating such an index with the default signature length of 8 bytes:
+
+CREATE INDEX path_gist_idx ON test USING GIST (path);
+
+ Example of creating such an index with a signature length of 100 bytes:
+
+CREATE INDEX path_gist_idx ON test USING GIST (path gist_ltree_ops(siglen=100));
+
+ GiST index over ltree[] (gist__ltree_ops
+ opclass):
+ ltree[] <@ ltree, ltree @> ltree[],
+ @, ~, ?
+
+ gist__ltree_ops GiST opclass works similarly to
+ gist_ltree_ops and also takes signature length as
+ a parameter. The default value of siglen in
+ gist__ltree_ops is 28 bytes.
+
+ Example of creating such an index with the default signature length of 28 bytes:
+
+CREATE INDEX path_gist_idx ON test USING GIST (array_path);
+
+ Example of creating such an index with a signature length of 100 bytes:
+
+CREATE INDEX path_gist_idx ON test USING GIST (array_path gist__ltree_ops(siglen=100));
+
+ Note: This index type is lossy.
+
+ This example uses the following data (also available in file
+ contrib/ltree/ltreetest.sql in the source distribution):
+
+CREATE TABLE test (path ltree);
+INSERT INTO test VALUES ('Top');
+INSERT INTO test VALUES ('Top.Science');
+INSERT INTO test VALUES ('Top.Science.Astronomy');
+INSERT INTO test VALUES ('Top.Science.Astronomy.Astrophysics');
+INSERT INTO test VALUES ('Top.Science.Astronomy.Cosmology');
+INSERT INTO test VALUES ('Top.Hobbies');
+INSERT INTO test VALUES ('Top.Hobbies.Amateurs_Astronomy');
+INSERT INTO test VALUES ('Top.Collections');
+INSERT INTO test VALUES ('Top.Collections.Pictures');
+INSERT INTO test VALUES ('Top.Collections.Pictures.Astronomy');
+INSERT INTO test VALUES ('Top.Collections.Pictures.Astronomy.Stars');
+INSERT INTO test VALUES ('Top.Collections.Pictures.Astronomy.Galaxies');
+INSERT INTO test VALUES ('Top.Collections.Pictures.Astronomy.Astronauts');
+CREATE INDEX path_gist_idx ON test USING GIST (path);
+CREATE INDEX path_idx ON test USING BTREE (path);
+
+ Now, we have a table test populated with data describing
+ the hierarchy shown below:
+
+ Top
+ / | \
+ Science Hobbies Collections
+ / | \
+ Astronomy Amateurs_Astronomy Pictures
+ / \ |
+Astrophysics Cosmology Astronomy
+ / | \
+ Galaxies Stars Astronauts
+
+ We can do inheritance:
+
+ltreetest=> SELECT path FROM test WHERE path <@ 'Top.Science';
+ path
+------------------------------------
+ Top.Science
+ Top.Science.Astronomy
+ Top.Science.Astronomy.Astrophysics
+ Top.Science.Astronomy.Cosmology
+(4 rows)
+
+
+ Here are some examples of path matching:
+
+ltreetest=> SELECT path FROM test WHERE path ~ '*.Astronomy.*';
+ path
+-----------------------------------------------
+ Top.Science.Astronomy
+ Top.Science.Astronomy.Astrophysics
+ Top.Science.Astronomy.Cosmology
+ Top.Collections.Pictures.Astronomy
+ Top.Collections.Pictures.Astronomy.Stars
+ Top.Collections.Pictures.Astronomy.Galaxies
+ Top.Collections.Pictures.Astronomy.Astronauts
+(7 rows)
+
+ltreetest=> SELECT path FROM test WHERE path ~ '*.!pictures@.Astronomy.*';
+ path
+------------------------------------
+ Top.Science.Astronomy
+ Top.Science.Astronomy.Astrophysics
+ Top.Science.Astronomy.Cosmology
+(3 rows)
+
+
+ Here are some examples of full text search:
+
+ltreetest=> SELECT path FROM test WHERE path @ 'Astro*% & !pictures@';
+ path
+------------------------------------
+ Top.Science.Astronomy
+ Top.Science.Astronomy.Astrophysics
+ Top.Science.Astronomy.Cosmology
+ Top.Hobbies.Amateurs_Astronomy
+(4 rows)
+
+ltreetest=> SELECT path FROM test WHERE path @ 'Astro* & !pictures@';
+ path
+------------------------------------
+ Top.Science.Astronomy
+ Top.Science.Astronomy.Astrophysics
+ Top.Science.Astronomy.Cosmology
+(3 rows)
+
+
+ Path construction using functions:
+
+ltreetest=> SELECT subpath(path,0,2)||'Space'||subpath(path,2) FROM test WHERE path <@ 'Top.Science.Astronomy';
+ ?column?
+------------------------------------------
+ Top.Science.Space.Astronomy
+ Top.Science.Space.Astronomy.Astrophysics
+ Top.Science.Space.Astronomy.Cosmology
+(3 rows)
+
+
+ We could simplify this by creating an SQL function that inserts a label
+ at a specified position in a path:
+
+CREATE FUNCTION ins_label(ltree, int, text) RETURNS ltree
+ AS 'select subpath($1,0,$2) || $3 || subpath($1,$2);'
+ LANGUAGE SQL IMMUTABLE;
+
+ltreetest=> SELECT ins_label(path,2,'Space') FROM test WHERE path <@ 'Top.Science.Astronomy';
+ ins_label
+------------------------------------------
+ Top.Science.Space.Astronomy
+ Top.Science.Space.Astronomy.Astrophysics
+ Top.Science.Space.Astronomy.Cosmology
+(3 rows)
+
+
Chapter 25. Routine Database Maintenance Tasks
+ PostgreSQL, like any database software, requires that certain tasks
+ be performed regularly to achieve optimum performance. The tasks
+ discussed here are required, but they
+ are repetitive in nature and can easily be automated using standard
+ tools such as cron scripts or
+ Windows' Task Scheduler. It is the database
+ administrator's responsibility to set up appropriate scripts, and to
+ check that they execute successfully.
+
+ One obvious maintenance task is the creation of backup copies of the data on a
+ regular schedule. Without a recent backup, you have no chance of recovery
+ after a catastrophe (disk failure, fire, mistakenly dropping a critical
+ table, etc.). The backup and recovery mechanisms available in
+ PostgreSQL are discussed at length in
+ Chapter 26.
+
+ The other main category of maintenance task is periodic “vacuuming”
+ of the database. This activity is discussed in
+ Section 25.1. Closely related to this is updating
+ the statistics that will be used by the query planner, as discussed in
+ Section 25.1.3.
+
+ Another task that might need periodic attention is log file management.
+ This is discussed in Section 25.3.
+
+ check_postgres
+ is available for monitoring database health and reporting unusual
+ conditions. check_postgres integrates with
+ Nagios and MRTG, but can be run standalone too.
+
+ PostgreSQL is low-maintenance compared
+ to some other database management systems. Nonetheless,
+ appropriate attention to these tasks will go far towards ensuring a
+ pleasant and productive experience with the system.
+
23.4. Database Configuration #
+ Recall from Chapter 20 that the
+ PostgreSQL server provides a large number of
+ run-time configuration variables. You can set database-specific
+ default values for many of these settings.
+
+ For example, if for some reason you want to disable the
+ GEQO optimizer for a given database, you'd
+ ordinarily have to either disable it for all databases or make sure
+ that every connecting client is careful to issue SET geqo
+ TO off. To make this setting the default within a particular
+ database, you can execute the command:
+
+ALTER DATABASE mydb SET geqo TO off;
+
+ This will save the setting (but not set it immediately). In
+ subsequent connections to this database it will appear as though
+ SET geqo TO off; had been executed just before the
+ session started.
+ Note that users can still alter this setting during their sessions; it
+ will only be the default. To undo any such setting, use
+ ALTER DATABASE dbname RESET
+ varname.
+
23.2. Creating a Database #
+ In order to create a database, the PostgreSQL
+ server must be up and running (see Section 19.3).
+
+ Databases are created with the SQL command
+ CREATE DATABASE:
+
+CREATE DATABASE name;
+
+ where name follows the usual rules for
+ SQL identifiers. The current role automatically
+ becomes the owner of the new database. It is the privilege of the
+ owner of a database to remove it later (which also removes all
+ the objects in it, even if they have a different owner).
+
+ The creation of databases is a restricted operation. See Section 22.2 for how to grant permission.
+
+ Since you need to be connected to the database server in order to
+ execute the CREATE DATABASE command, the
+ question remains how the first database at any given
+ site can be created. The first database is always created by the
+ initdb command when the data storage area is
+ initialized. (See Section 19.2.) This
+ database is called
+ postgres. So to
+ create the first “ordinary” database you can connect to
+ postgres.
+
+ Two additional databases,
+ template1
+ and
+ template0,
+ are also created during database cluster initialization. Whenever a
+ new database is created within the
+ cluster, template1 is essentially cloned.
+ This means that any changes you make in template1 are
+ propagated to all subsequently created databases. Because of this,
+ avoid creating objects in template1 unless you want them
+ propagated to every newly created database.
+ template0 is meant as a pristine copy of the original
+ contents of template1. It can be cloned instead
+ of template1 when it is important to make a database
+ without any such site-local additions. More details
+ appear in Section 23.3.
+
+ As a convenience, there is a program you can
+ execute from the shell to create new databases,
+ createdb.
+
+
+createdb dbname
+
+
+ createdb does no magic. It connects to the postgres
+ database and issues the CREATE DATABASE command,
+ exactly as described above.
+ The createdb reference page contains the invocation
+ details. Note that createdb without any arguments will create
+ a database with the current user name.
+
Note
+ Chapter 21 contains information about
+ how to restrict who can connect to a given database.
+
+ Sometimes you want to create a database for someone else, and have them
+ become the owner of the new database, so they can
+ configure and manage it themselves. To achieve that, use one of the
+ following commands:
+
+CREATE DATABASE dbname OWNER rolename;
+
+ from the SQL environment, or:
+
+createdb -O rolename dbname
+
+ from the shell.
+ Only the superuser is allowed to create a database for
+ someone else (that is, for a role you are not a member of).
+
23.5. Destroying a Database #
+ Databases are destroyed with the command
+ DROP DATABASE:
+
+DROP DATABASE name;
+
+ Only the owner of the database, or
+ a superuser, can drop a database. Dropping a database removes all objects
+ that were
+ contained within the database. The destruction of a database cannot
+ be undone.
+
+ You cannot execute the DROP DATABASE command
+ while connected to the victim database. You can, however, be
+ connected to any other database, including the template1
+ database.
+ template1 would be the only option for dropping the last user database of a
+ given cluster.
+
+ For convenience, there is also a shell program to drop
+ databases, dropdb:
+
+dropdb dbname
+
+ (Unlike createdb, it is not the default action to drop
+ the database with the current user name.)
+
+ A small number of objects, like role, database, and tablespace
+ names, are defined at the cluster level and stored in the
+ pg_global tablespace. Inside the cluster are
+ multiple databases, which are isolated from each other but can access
+ cluster-level objects. Inside each database are multiple schemas,
+ which contain objects like tables and functions. So the full hierarchy
+ is: cluster, database, schema, table (or some other kind of object,
+ such as a function).
+
+ When connecting to the database server, a client must specify the
+ database name in its connection request.
+ It is not possible to access more than one database per
+ connection. However, clients can open multiple connections to
+ the same database, or different databases.
+ Database-level security has two components: access control
+ (see Section 21.1), managed at the
+ connection level, and authorization control
+ (see Section 5.7), managed via the grant system.
+ Foreign data wrappers (see postgres_fdw)
+ allow for objects within one database to act as proxies for objects in
+ other database or clusters.
+ The older dblink module (see dblink) provides a similar capability.
+ By default, all users can connect to all databases using all connection methods.
+
+ If one PostgreSQL server cluster is planned to contain
+ unrelated projects or users that should be, for the most part, unaware
+ of each other, it is recommended to put them into separate databases and
+ adjust authorizations and access controls accordingly.
+ If the projects or users are interrelated, and thus should be able to use
+ each other's resources, they should be put in the same database but probably
+ into separate schemas; this provides a modular structure with namespace
+ isolation and authorization control.
+ More information about managing schemas is in Section 5.9.
+
+ While multiple databases can be created within a single cluster, it is advised
+ to consider carefully whether the benefits outweigh the risks and limitations.
+ In particular, the impact that having a shared WAL (see Chapter 30)
+ has on backup and recovery options. While individual databases in the cluster
+ are isolated when considered from the user's perspective, they are closely bound
+ from the database administrator's point-of-view.
+
+ Databases are created with the CREATE DATABASE command
+ (see Section 23.2) and destroyed with the
+ DROP DATABASE command
+ (see Section 23.5).
+ To determine the set of existing databases, examine the
+ pg_database system catalog, for example
+
+SELECT datname FROM pg_database;
+
+ The psql program's \l meta-command
+ and -l command-line option are also useful for listing the
+ existing databases.
+
Note
+ The SQL standard calls databases “catalogs”, but there
+ is no difference in practice.
+
+ Tablespaces in PostgreSQL allow database administrators to
+ define locations in the file system where the files representing
+ database objects can be stored. Once created, a tablespace can be referred
+ to by name when creating database objects.
+
+ By using tablespaces, an administrator can control the disk layout
+ of a PostgreSQL installation. This is useful in at
+ least two ways. First, if the partition or volume on which the
+ cluster was initialized runs out of space and cannot be extended,
+ a tablespace can be created on a different partition and used
+ until the system can be reconfigured.
+
+ Second, tablespaces allow an administrator to use knowledge of the
+ usage pattern of database objects to optimize performance. For
+ example, an index which is very heavily used can be placed on a
+ very fast, highly available disk, such as an expensive solid state
+ device. At the same time a table storing archived data which is
+ rarely used or not performance critical could be stored on a less
+ expensive, slower disk system.
+
Warning
+ Even though located outside the main PostgreSQL data directory,
+ tablespaces are an integral part of the database cluster and
+ cannot be treated as an autonomous collection
+ of data files. They are dependent on metadata contained in the main
+ data directory, and therefore cannot be attached to a different
+ database cluster or backed up individually. Similarly, if you lose
+ a tablespace (file deletion, disk failure, etc.), the database cluster
+ might become unreadable or unable to start. Placing a tablespace
+ on a temporary file system like a RAM disk risks the reliability of
+ the entire cluster.
+
+ To define a tablespace, use the CREATE TABLESPACE
+ command, for example::
+
+CREATE TABLESPACE fastspace LOCATION '/ssd1/postgresql/data';
+
+ The location must be an existing, empty directory that is owned by
+ the PostgreSQL operating system user. All objects subsequently
+ created within the tablespace will be stored in files underneath this
+ directory. The location must not be on removable or transient storage,
+ as the cluster might fail to function if the tablespace is missing
+ or lost.
+
Note
+ There is usually not much point in making more than one
+ tablespace per logical file system, since you cannot control the location
+ of individual files within a logical file system. However,
+ PostgreSQL does not enforce any such limitation, and
+ indeed it is not directly aware of the file system boundaries on your
+ system. It just stores files in the directories you tell it to use.
+
+ Creation of the tablespace itself must be done as a database superuser,
+ but after that you can allow ordinary database users to use it.
+ To do that, grant them the CREATE privilege on it.
+
+ Tables, indexes, and entire databases can be assigned to
+ particular tablespaces. To do so, a user with the CREATE
+ privilege on a given tablespace must pass the tablespace name as a
+ parameter to the relevant command. For example, the following creates
+ a table in the tablespace space1:
+
+CREATE TABLE foo(i int) TABLESPACE space1;
+
+
+ Alternatively, use the default_tablespace parameter:
+
+SET default_tablespace = space1;
+CREATE TABLE foo(i int);
+
+ When default_tablespace is set to anything but an empty
+ string, it supplies an implicit TABLESPACE clause for
+ CREATE TABLE and CREATE INDEX commands that
+ do not have an explicit one.
+
+ There is also a temp_tablespaces parameter, which
+ determines the placement of temporary tables and indexes, as well as
+ temporary files that are used for purposes such as sorting large data
+ sets. This can be a list of tablespace names, rather than only one,
+ so that the load associated with temporary objects can be spread over
+ multiple tablespaces. A random member of the list is picked each time
+ a temporary object is to be created.
+
+ The tablespace associated with a database is used to store the system
+ catalogs of that database. Furthermore, it is the default tablespace
+ used for tables, indexes, and temporary files created within the database,
+ if no TABLESPACE clause is given and no other selection is
+ specified by default_tablespace or
+ temp_tablespaces (as appropriate).
+ If a database is created without specifying a tablespace for it,
+ it uses the same tablespace as the template database it is copied from.
+
+ Two tablespaces are automatically created when the database cluster
+ is initialized. The
+ pg_global tablespace is used for shared system catalogs. The
+ pg_default tablespace is the default tablespace of the
+ template1 and template0 databases (and, therefore,
+ will be the default tablespace for other databases as well, unless
+ overridden by a TABLESPACE clause in CREATE
+ DATABASE).
+
+ Once created, a tablespace can be used from any database, provided
+ the requesting user has sufficient privilege. This means that a tablespace
+ cannot be dropped until all objects in all databases using the tablespace
+ have been removed.
+
+ To remove an empty tablespace, use the DROP TABLESPACE
+ command.
+
+ To determine the set of existing tablespaces, examine the
+ pg_tablespace
+ system catalog, for example
+
+SELECT spcname FROM pg_tablespace;
+
+ The psql program's \db meta-command
+ is also useful for listing the existing tablespaces.
+
+ The directory $PGDATA/pg_tblspc contains symbolic links that
+ point to each of the non-built-in tablespaces defined in the cluster.
+ Although not recommended, it is possible to adjust the tablespace
+ layout by hand by redefining these links. Under no circumstances perform
+ this operation while the server is running. Note that in PostgreSQL 9.1
+ and earlier you will also need to update the pg_tablespace
+ catalog with the new locations. (If you do not, pg_dump will
+ continue to output the old tablespace locations.)
+
23.3. Template Databases #
+ CREATE DATABASE actually works by copying an existing
+ database. By default, it copies the standard system database named
+ template1. Thus that
+ database is the “template” from which new databases are
+ made. If you add objects to template1, these objects
+ will be copied into subsequently created user databases. This
+ behavior allows site-local modifications to the standard set of
+ objects in databases. For example, if you install the procedural
+ language PL/Perl in template1, it will
+ automatically be available in user databases without any extra
+ action being taken when those databases are created.
+
+ However, CREATE DATABASE does not copy database-level
+ GRANT permissions attached to the source database.
+ The new database has default database-level permissions.
+
+ There is a second standard system database named
+ template0. This
+ database contains the same data as the initial contents of
+ template1, that is, only the standard objects
+ predefined by your version of
+ PostgreSQL. template0
+ should never be changed after the database cluster has been
+ initialized. By instructing
+ CREATE DATABASE to copy template0 instead
+ of template1, you can create a “pristine” user
+ database (one where no user-defined objects exist and where the system
+ objects have not been altered) that contains none of the site-local additions in
+ template1. This is particularly handy when restoring a
+ pg_dump dump: the dump script should be restored in a
+ pristine database to ensure that one recreates the correct contents
+ of the dumped database, without conflicting with objects that
+ might have been added to template1 later on.
+
+ Another common reason for copying template0 instead
+ of template1 is that new encoding and locale settings
+ can be specified when copying template0, whereas a copy
+ of template1 must use the same settings it does.
+ This is because template1 might contain encoding-specific
+ or locale-specific data, while template0 is known not to.
+
+ To create a database by copying template0, use:
+
+CREATE DATABASE dbname TEMPLATE template0;
+
+ from the SQL environment, or:
+
+createdb -T template0 dbname
+
+ from the shell.
+
+ It is possible to create additional template databases, and indeed
+ one can copy any database in a cluster by specifying its name
+ as the template for CREATE DATABASE. It is important to
+ understand, however, that this is not (yet) intended as
+ a general-purpose “COPY DATABASE” facility.
+ The principal limitation is that no other sessions can be connected to
+ the source database while it is being copied. CREATE
+ DATABASE will fail if any other connection exists when it starts;
+ during the copy operation, new connections to the source database
+ are prevented.
+
+ Two useful flags exist in pg_database for each
+ database: the columns datistemplate and
+ datallowconn. datistemplate
+ can be set to indicate that a database is intended as a template for
+ CREATE DATABASE. If this flag is set, the database can be
+ cloned by any user with CREATEDB privileges; if it is not set,
+ only superusers and the owner of the database can clone it.
+ If datallowconn is false, then no new connections
+ to that database will be allowed (but existing sessions are not terminated
+ simply by setting the flag false). The template0
+ database is normally marked datallowconn = false to prevent its modification.
+ Both template0 and template1
+ should always be marked with datistemplate = true.
+
Note
+ template1 and template0 do not have any special
+ status beyond the fact that the name template1 is the default
+ source database name for CREATE DATABASE.
+ For example, one could drop template1 and recreate it from
+ template0 without any ill effects. This course of action
+ might be advisable if one has carelessly added a bunch of junk in
+ template1. (To delete template1,
+ it must have pg_database.datistemplate = false.)
+
+ The postgres database is also created when a database
+ cluster is initialized. This database is meant as a default database for
+ users and applications to connect to. It is simply a copy of
+ template1 and can be dropped and recreated if necessary.
+
Chapter 23. Managing Databases
+ Every instance of a running PostgreSQL
+ server manages one or more databases. Databases are therefore the
+ topmost hierarchical level for organizing SQL
+ objects (“database objects”). This chapter describes
+ the properties of databases, and how to create, manage, and destroy
+ them.
+
+ Another useful tool for monitoring database activity is the
+ pg_locks system table. It allows the
+ database administrator to view information about the outstanding
+ locks in the lock manager. For example, this capability can be used
+ to:
+
+
+ View all the locks currently outstanding, all the locks on
+ relations in a particular database, all the locks on a
+ particular relation, or all the locks held by a particular
+ PostgreSQL session.
+
+ Determine the relation in the current database with the most
+ ungranted locks (which might be a source of contention among
+ database clients).
+
+ Determine the effect of lock contention on overall database
+ performance, as well as the extent to which contention varies
+ with overall database traffic.
+
+
+ Details of the pg_locks view appear in
+ Section 54.12.
+ For more information on locking and managing concurrency with
+ PostgreSQL, refer to Chapter 13.
+
28.1. Standard Unix Tools #
+ On most Unix platforms, PostgreSQL modifies its
+ command title as reported by ps, so that individual server
+ processes can readily be identified. A sample display is
+
+
+$ ps auxww | grep ^postgres
+postgres 15551 0.0 0.1 57536 7132 pts/0 S 18:02 0:00 postgres -i
+postgres 15554 0.0 0.0 57536 1184 ? Ss 18:02 0:00 postgres: background writer
+postgres 15555 0.0 0.0 57536 916 ? Ss 18:02 0:00 postgres: checkpointer
+postgres 15556 0.0 0.0 57536 916 ? Ss 18:02 0:00 postgres: walwriter
+postgres 15557 0.0 0.0 58504 2244 ? Ss 18:02 0:00 postgres: autovacuum launcher
+postgres 15582 0.0 0.0 58772 3080 ? Ss 18:04 0:00 postgres: joe runbug 127.0.0.1 idle
+postgres 15606 0.0 0.0 58772 3052 ? Ss 18:07 0:00 postgres: tgl regression [local] SELECT waiting
+postgres 15610 0.0 0.0 58772 3056 ? Ss 18:07 0:00 postgres: tgl regression [local] idle in transaction
+
+
+ (The appropriate invocation of ps varies across different
+ platforms, as do the details of what is shown. This example is from a
+ recent Linux system.) The first process listed here is the
+ primary server process. The command arguments
+ shown for it are the same ones used when it was launched. The next four
+ processes are background worker processes automatically launched by the
+ primary process. (The “autovacuum launcher” process will not
+ be present if you have set the system not to run autovacuum.)
+ Each of the remaining
+ processes is a server process handling one client connection. Each such
+ process sets its command line display in the form
+
+
+postgres: user database host activity
+
+
+ The user, database, and (client) host items remain the same for
+ the life of the client connection, but the activity indicator changes.
+ The activity can be idle (i.e., waiting for a client command),
+ idle in transaction (waiting for client inside a BEGIN block),
+ or a command type name such as SELECT. Also,
+ waiting is appended if the server process is presently waiting
+ on a lock held by another session. In the above example we can infer
+ that process 15606 is waiting for process 15610 to complete its transaction
+ and thereby release some lock. (Process 15610 must be the blocker, because
+ there is no other active session. In more complicated cases it would be
+ necessary to look into the
+ pg_locks
+ system view to determine who is blocking whom.)
+
+ If cluster_name has been configured the
+ cluster name will also be shown in ps output:
+
+$ psql -c 'SHOW cluster_name'
+ cluster_name
+--------------
+ server1
+(1 row)
+
+$ ps aux|grep server1
+postgres 27093 0.0 0.0 30096 2752 ? Ss 11:34 0:00 postgres: server1: background writer
+...
+
+
+ If you have turned off update_process_title then the
+ activity indicator is not updated; the process title is set only once
+ when a new process is launched. On some platforms this saves a measurable
+ amount of per-command overhead; on others it's insignificant.
+
Tip
+ Solaris requires special handling. You must
+ use /usr/ucb/ps, rather than
+ /bin/ps. You also must use two w
+ flags, not just one. In addition, your original invocation of the
+ postgres command must have a shorter
+ ps status display than that provided by each
+ server process. If you fail to do all three things, the ps
+ output for each server process will be the original postgres
+ command line.
+
28.2. The Cumulative Statistics System #
+ PostgreSQL's cumulative statistics
+ system supports collection and reporting of information about
+ server activity. Presently, accesses to tables and indexes in both
+ disk-block and individual-row terms are counted. The total number of rows
+ in each table, and information about vacuum and analyze actions for each
+ table are also counted. If enabled, calls to user-defined functions and
+ the total time spent in each one are counted as well.
+
+ PostgreSQL also supports reporting dynamic
+ information about exactly what is going on in the system right now, such as
+ the exact command currently being executed by other server processes, and
+ which other connections exist in the system. This facility is independent
+ of the cumulative statistics system.
+
28.2.1. Statistics Collection Configuration #
+ Since collection of statistics adds some overhead to query execution,
+ the system can be configured to collect or not collect information.
+ This is controlled by configuration parameters that are normally set in
+ postgresql.conf. (See Chapter 20 for
+ details about setting configuration parameters.)
+
+ The parameter track_activities enables monitoring
+ of the current command being executed by any server process.
+
+ The parameter track_counts controls whether
+ cumulative statistics are collected about table and index accesses.
+
+ The parameter track_functions enables tracking of
+ usage of user-defined functions.
+
+ The parameter track_io_timing enables monitoring
+ of block read and write times.
+
+ The parameter track_wal_io_timing enables monitoring
+ of WAL write times.
+
+ Normally these parameters are set in postgresql.conf so
+ that they apply to all server processes, but it is possible to turn
+ them on or off in individual sessions using the SET command. (To prevent
+ ordinary users from hiding their activity from the administrator,
+ only superusers are allowed to change these parameters with
+ SET.)
+
+ Cumulative statistics are collected in shared memory. Every
+ PostgreSQL process collects statistics locally,
+ then updates the shared data at appropriate intervals. When a server,
+ including a physical replica, shuts down cleanly, a permanent copy of the
+ statistics data is stored in the pg_stat subdirectory,
+ so that statistics can be retained across server restarts. In contrast,
+ when starting from an unclean shutdown (e.g., after an immediate shutdown,
+ a server crash, starting from a base backup, and point-in-time recovery),
+ all statistics counters are reset.
+
28.2.2. Viewing Statistics #
+ Several predefined views, listed in Table 28.1, are available to show
+ the current state of the system. There are also several other
+ views, listed in Table 28.2, available to show the accumulated
+ statistics. Alternatively, one can
+ build custom views using the underlying cumulative statistics functions, as
+ discussed in Section 28.2.25.
+
+ When using the cumulative statistics views and functions to monitor
+ collected data, it is important to realize that the information does not
+ update instantaneously. Each individual server process flushes out
+ accumulated statistics to shared memory just before going idle, but not
+ more frequently than once per PGSTAT_MIN_INTERVAL
+ milliseconds (1 second unless altered while building the server); so a
+ query or transaction still in progress does not affect the displayed totals
+ and the displayed information lags behind actual activity. However,
+ current-query information collected by track_activities
+ is always up-to-date.
+
+ Another important point is that when a server process is asked to display
+ any of the accumulated statistics, accessed values are cached until the end
+ of its current transaction in the default configuration. So the statistics
+ will show static information as long as you continue the current
+ transaction. Similarly, information about the current queries of all
+ sessions is collected when any such information is first requested within a
+ transaction, and the same information will be displayed throughout the
+ transaction. This is a feature, not a bug, because it allows you to perform
+ several queries on the statistics and correlate the results without
+ worrying that the numbers are changing underneath you.
+
+ When analyzing statistics interactively, or with expensive queries, the
+ time delta between accesses to individual statistics can lead to
+ significant skew in the cached statistics. To minimize skew,
+ stats_fetch_consistency can be set to
+ snapshot, at the price of increased memory usage for
+ caching not-needed statistics data. Conversely, if it's known that
+ statistics are only accessed once, caching accessed statistics is
+ unnecessary and can be avoided by setting
+ stats_fetch_consistency to none.
+
+ You can invoke pg_stat_clear_snapshot() to discard the
+ current transaction's statistics snapshot or cached values (if any). The
+ next use of statistical information will (when in snapshot mode) cause a
+ new snapshot to be built or (when in cache mode) accessed statistics to be
+ cached.
+
+ A transaction can also see its own statistics (not yet flushed out to the
+ shared memory statistics) in the views
+ pg_stat_xact_all_tables,
+ pg_stat_xact_sys_tables,
+ pg_stat_xact_user_tables, and
+ pg_stat_xact_user_functions. These numbers do not act as
+ stated above; instead they update continuously throughout the transaction.
+
+ Some of the information in the dynamic statistics views shown in Table 28.1 is security restricted.
+ Ordinary users can only see all the information about their own sessions
+ (sessions belonging to a role that they are a member of). In rows about
+ other sessions, many columns will be null. Note, however, that the
+ existence of a session and its general properties such as its sessions user
+ and database are visible to all users. Superusers and roles with privileges of
+ built-in role pg_read_all_stats (see also Section 22.5) can see all the information about all sessions.
+
Table 28.1. Dynamic Statistics Views
| View Name | Description |
|---|
+ pg_stat_activity
+
+ |
+ One row per server process, showing information related to
+ the current activity of that process, such as state and current query.
+ See
+ pg_stat_activity for details.
+ |
pg_stat_replication | One row per WAL sender process, showing statistics about
+ replication to that sender's connected standby server.
+ See
+ pg_stat_replication for details.
+ |
pg_stat_wal_receiver | Only one row, showing statistics about the WAL receiver from
+ that receiver's connected server.
+ See
+ pg_stat_wal_receiver for details.
+ |
pg_stat_recovery_prefetch | Only one row, showing statistics about blocks prefetched during recovery.
+ See
+ pg_stat_recovery_prefetch for details.
+ |
pg_stat_subscription | At least one row per subscription, showing information about
+ the subscription workers.
+ See
+ pg_stat_subscription for details.
+ |
pg_stat_ssl | One row per connection (regular and replication), showing information about
+ SSL used on this connection.
+ See
+ pg_stat_ssl for details.
+ |
pg_stat_gssapi | One row per connection (regular and replication), showing information about
+ GSSAPI authentication and encryption used on this connection.
+ See
+ pg_stat_gssapi for details.
+ |
pg_stat_progress_analyze | One row for each backend (including autovacuum worker processes) running
+ ANALYZE, showing current progress.
+ See Section 28.4.1.
+ |
pg_stat_progress_create_index | One row for each backend running CREATE INDEX or REINDEX, showing
+ current progress.
+ See Section 28.4.4.
+ |
pg_stat_progress_vacuum | One row for each backend (including autovacuum worker processes) running
+ VACUUM, showing current progress.
+ See Section 28.4.5.
+ |
pg_stat_progress_cluster | One row for each backend running
+ CLUSTER or VACUUM FULL, showing current progress.
+ See Section 28.4.2.
+ |
pg_stat_progress_basebackup | One row for each WAL sender process streaming a base backup,
+ showing current progress.
+ See Section 28.4.6.
+ |
pg_stat_progress_copy | One row for each backend running COPY, showing current progress.
+ See Section 28.4.3.
+ |
Table 28.2. Collected Statistics Views
| View Name | Description |
|---|
pg_stat_archiver | One row only, showing statistics about the
+ WAL archiver process's activity. See
+
+ pg_stat_archiver for details.
+ |
pg_stat_bgwriter | One row only, showing statistics about the
+ background writer process's activity. See
+
+ pg_stat_bgwriter for details.
+ |
pg_stat_database | One row per database, showing database-wide statistics. See
+
+ pg_stat_database for details.
+ |
pg_stat_database_conflicts |
+ One row per database, showing database-wide statistics about
+ query cancels due to conflict with recovery on standby servers.
+ See
+ pg_stat_database_conflicts for details.
+ |
pg_stat_io |
+ One row for each combination of backend type, context, and target object
+ containing cluster-wide I/O statistics.
+ See
+ pg_stat_io for details.
+ |
pg_stat_replication_slots | One row per replication slot, showing statistics about the
+ replication slot's usage. See
+
+ pg_stat_replication_slots for details.
+ |
pg_stat_slru | One row per SLRU, showing statistics of operations. See
+
+ pg_stat_slru for details.
+ |
pg_stat_subscription_stats | One row per subscription, showing statistics about errors.
+ See
+ pg_stat_subscription_stats for details.
+ |
pg_stat_wal | One row only, showing statistics about WAL activity. See
+
+ pg_stat_wal for details.
+ |
pg_stat_all_tables |
+ One row for each table in the current database, showing statistics
+ about accesses to that specific table.
+ See
+ pg_stat_all_tables for details.
+ |
pg_stat_sys_tables | Same as pg_stat_all_tables, except that only
+ system tables are shown. |
pg_stat_user_tables | Same as pg_stat_all_tables, except that only user
+ tables are shown. |
pg_stat_xact_all_tables | Similar to pg_stat_all_tables, but counts actions
+ taken so far within the current transaction (which are not
+ yet included in pg_stat_all_tables and related views).
+ The columns for numbers of live and dead rows and vacuum and
+ analyze actions are not present in this view. |
pg_stat_xact_sys_tables | Same as pg_stat_xact_all_tables, except that only
+ system tables are shown. |
pg_stat_xact_user_tables | Same as pg_stat_xact_all_tables, except that only
+ user tables are shown. |
pg_stat_all_indexes |
+ One row for each index in the current database, showing statistics
+ about accesses to that specific index.
+ See
+ pg_stat_all_indexes for details.
+ |
pg_stat_sys_indexes | Same as pg_stat_all_indexes, except that only
+ indexes on system tables are shown. |
pg_stat_user_indexes | Same as pg_stat_all_indexes, except that only
+ indexes on user tables are shown. |
pg_stat_user_functions |
+ One row for each tracked function, showing statistics
+ about executions of that function. See
+
+ pg_stat_user_functions for details.
+ |
pg_stat_xact_user_functions | Similar to pg_stat_user_functions, but counts only
+ calls during the current transaction (which are not
+ yet included in pg_stat_user_functions). |
pg_statio_all_tables |
+ One row for each table in the current database, showing statistics
+ about I/O on that specific table.
+ See
+ pg_statio_all_tables for details.
+ |
pg_statio_sys_tables | Same as pg_statio_all_tables, except that only
+ system tables are shown. |
pg_statio_user_tables | Same as pg_statio_all_tables, except that only
+ user tables are shown. |
pg_statio_all_indexes |
+ One row for each index in the current database,
+ showing statistics about I/O on that specific index.
+ See
+ pg_statio_all_indexes for details.
+ |
pg_statio_sys_indexes | Same as pg_statio_all_indexes, except that only
+ indexes on system tables are shown. |
pg_statio_user_indexes | Same as pg_statio_all_indexes, except that only
+ indexes on user tables are shown. |
pg_statio_all_sequences |
+ One row for each sequence in the current database,
+ showing statistics about I/O on that specific sequence.
+ See
+ pg_statio_all_sequences for details.
+ |
pg_statio_sys_sequences | Same as pg_statio_all_sequences, except that only
+ system sequences are shown. (Presently, no system sequences are defined,
+ so this view is always empty.) |
pg_statio_user_sequences | Same as pg_statio_all_sequences, except that only
+ user sequences are shown. |
+ The per-index statistics are particularly useful to determine which
+ indexes are being used and how effective they are.
+
+ The pg_stat_io and
+ pg_statio_ set of views are useful for determining
+ the effectiveness of the buffer cache. They can be used to calculate a cache
+ hit ratio. Note that while PostgreSQL's I/O
+ statistics capture most instances in which the kernel was invoked in order
+ to perform I/O, they do not differentiate between data which had to be
+ fetched from disk and that which already resided in the kernel page cache.
+ Users are advised to use the PostgreSQL
+ statistics views in combination with operating system utilities for a more
+ complete picture of their database's I/O performance.
+
28.2.3. pg_stat_activity #
+ The pg_stat_activity view will have one row
+ per server process, showing information related to
+ the current activity of that process.
+
Table 28.3. pg_stat_activity View
+ Column Type
+
+
+ Description
+ |
|---|
+ datid oid
+
+
+ OID of the database this backend is connected to
+ |
+ datname name
+
+
+ Name of the database this backend is connected to
+ |
+ pid integer
+
+
+ Process ID of this backend
+ |
+ leader_pid integer
+
+
+ Process ID of the parallel group leader if this process is a parallel
+ query worker, or process ID of the leader apply worker if this process
+ is a parallel apply worker. NULL indicates that this
+ process is a parallel group leader or leader apply worker, or does not
+ participate in any parallel operation.
+ |
+ usesysid oid
+
+
+ OID of the user logged into this backend
+ |
+ usename name
+
+
+ Name of the user logged into this backend
+ |
+ application_name text
+
+
+ Name of the application that is connected
+ to this backend
+ |
+ client_addr inet
+
+
+ IP address of the client connected to this backend.
+ If this field is null, it indicates either that the client is
+ connected via a Unix socket on the server machine or that this is an
+ internal process such as autovacuum.
+ |
+ client_hostname text
+
+
+ Host name of the connected client, as reported by a
+ reverse DNS lookup of client_addr. This field will
+ only be non-null for IP connections, and only when log_hostname is enabled.
+ |
+ client_port integer
+
+
+ TCP port number that the client is using for communication
+ with this backend, or -1 if a Unix socket is used.
+ If this field is null, it indicates that this is an internal server process.
+ |
+ backend_start timestamp with time zone
+
+
+ Time when this process was started. For client backends,
+ this is the time the client connected to the server.
+ |
+ xact_start timestamp with time zone
+
+
+ Time when this process' current transaction was started, or null
+ if no transaction is active. If the current
+ query is the first of its transaction, this column is equal to the
+ query_start column.
+ |
+ query_start timestamp with time zone
+
+
+ Time when the currently active query was started, or if
+ state is not active, when the last query
+ was started
+ |
+ state_change timestamp with time zone
+
+
+ Time when the state was last changed
+ |
+ wait_event_type text
+
+
+ The type of event for which the backend is waiting, if any;
+ otherwise NULL. See Table 28.4.
+ |
+ wait_event text
+
+
+ Wait event name if backend is currently waiting, otherwise NULL.
+ See Table 28.5 through
+ Table 28.13.
+ |
+ state text
+
+
+ Current overall state of this backend.
+ Possible values are:
+
+ active: The backend is executing a query.
+
+ idle: The backend is waiting for a new client command.
+
+ idle in transaction: The backend is in a transaction,
+ but is not currently executing a query.
+
+ idle in transaction (aborted): This state is similar to
+ idle in transaction, except one of the statements in
+ the transaction caused an error.
+
+ fastpath function call: The backend is executing a
+ fast-path function.
+
+ disabled: This state is reported if track_activities is disabled in this backend.
+
+ |
+ backend_xid xid
+
+
+ Top-level transaction identifier of this backend, if any; see
+ Section 74.1.
+ |
+ backend_xmin xid
+
+
+ The current backend's xmin horizon.
+ |
+ query_id bigint
+
+
+ Identifier of this backend's most recent query. If
+ state is active this
+ field shows the identifier of the currently executing query. In
+ all other states, it shows the identifier of last query that was
+ executed. Query identifiers are not computed by default so this
+ field will be null unless compute_query_id
+ parameter is enabled or a third-party module that computes query
+ identifiers is configured.
+ |
+ query text
+
+
+ Text of this backend's most recent query. If
+ state is active this field shows the
+ currently executing query. In all other states, it shows the last query
+ that was executed. By default the query text is truncated at 1024
+ bytes; this value can be changed via the parameter
+ track_activity_query_size.
+ |
+ backend_type text
+
+
+ Type of current backend. Possible types are
+ autovacuum launcher, autovacuum worker,
+ logical replication launcher,
+ logical replication worker,
+ parallel worker, background writer,
+ client backend, checkpointer,
+ archiver, standalone backend,
+ startup, walreceiver,
+ walsender and walwriter.
+ In addition, background workers registered by extensions may have
+ additional types.
+ |
Note
+ The wait_event and state columns are
+ independent. If a backend is in the active state,
+ it may or may not be waiting on some event. If the state
+ is active and wait_event is non-null, it
+ means that a query is being executed, but is being blocked somewhere
+ in the system.
+
Table 28.4. Wait Event Types
| Wait Event Type | Description |
|---|
Activity | The server process is idle. This event type indicates a process
+ waiting for activity in its main processing loop.
+ wait_event will identify the specific wait point;
+ see Table 28.5.
+ |
BufferPin | The server process is waiting for exclusive access to
+ a data buffer. Buffer pin waits can be protracted if
+ another process holds an open cursor that last read data from the
+ buffer in question. See Table 28.6.
+ |
Client | The server process is waiting for activity on a socket
+ connected to a user application. Thus, the server expects something
+ to happen that is independent of its internal processes.
+ wait_event will identify the specific wait point;
+ see Table 28.7.
+ |
Extension | The server process is waiting for some condition defined by an
+ extension module.
+ See Table 28.8.
+ |
IO | The server process is waiting for an I/O operation to complete.
+ wait_event will identify the specific wait point;
+ see Table 28.9.
+ |
IPC | The server process is waiting for some interaction with
+ another server process. wait_event will
+ identify the specific wait point;
+ see Table 28.10.
+ |
Lock | The server process is waiting for a heavyweight lock.
+ Heavyweight locks, also known as lock manager locks or simply locks,
+ primarily protect SQL-visible objects such as tables. However,
+ they are also used to ensure mutual exclusion for certain internal
+ operations such as relation extension. wait_event
+ will identify the type of lock awaited;
+ see Table 28.11.
+ |
LWLock | The server process is waiting for a lightweight lock.
+ Most such locks protect a particular data structure in shared memory.
+ wait_event will contain a name identifying the purpose
+ of the lightweight lock. (Some locks have specific names; others
+ are part of a group of locks each with a similar purpose.)
+ See Table 28.12.
+ |
Timeout | The server process is waiting for a timeout
+ to expire. wait_event will identify the specific wait
+ point; see Table 28.13.
+ |
Table 28.5. Wait Events of Type Activity
Activity Wait Event | Description |
|---|
ArchiverMain | Waiting in main loop of archiver process. |
AutoVacuumMain | Waiting in main loop of autovacuum launcher process. |
BgWriterHibernate | Waiting in background writer process, hibernating. |
BgWriterMain | Waiting in main loop of background writer process. |
CheckpointerMain | Waiting in main loop of checkpointer process. |
LogicalApplyMain | Waiting in main loop of logical replication apply process. |
LogicalLauncherMain | Waiting in main loop of logical replication launcher process. |
LogicalParallelApplyMain | Waiting in main loop of logical replication parallel apply
+ process. |
RecoveryWalStream | Waiting in main loop of startup process for WAL to arrive, during
+ streaming recovery. |
SysLoggerMain | Waiting in main loop of syslogger process. |
WalReceiverMain | Waiting in main loop of WAL receiver process. |
WalSenderMain | Waiting in main loop of WAL sender process. |
WalWriterMain | Waiting in main loop of WAL writer process. |
Table 28.6. Wait Events of Type BufferPin
BufferPin Wait Event | Description |
|---|
BufferPin | Waiting to acquire an exclusive pin on a buffer. |
Table 28.7. Wait Events of Type Client
Client Wait Event | Description |
|---|
ClientRead | Waiting to read data from the client. |
ClientWrite | Waiting to write data to the client. |
GSSOpenServer | Waiting to read data from the client while establishing a GSSAPI
+ session. |
LibPQWalReceiverConnect | Waiting in WAL receiver to establish connection to remote
+ server. |
LibPQWalReceiverReceive | Waiting in WAL receiver to receive data from remote server. |
SSLOpenServer | Waiting for SSL while attempting connection. |
WalSenderWaitForWAL | Waiting for WAL to be flushed in WAL sender process. |
WalSenderWriteData | Waiting for any activity when processing replies from WAL
+ receiver in WAL sender process. |
Table 28.8. Wait Events of Type Extension
Extension Wait Event | Description |
|---|
Extension | Waiting in an extension. |
Table 28.9. Wait Events of Type IO
IO Wait Event | Description |
|---|
BaseBackupRead | Waiting for base backup to read from a file. |
BaseBackupSync | Waiting for data written by a base backup to reach durable storage. |
BaseBackupWrite | Waiting for base backup to write to a file. |
BufFileRead | Waiting for a read from a buffered file. |
BufFileTruncate | Waiting for a buffered file to be truncated. |
BufFileWrite | Waiting for a write to a buffered file. |
ControlFileRead | Waiting for a read from the pg_control
+ file. |
ControlFileSync | Waiting for the pg_control file to reach
+ durable storage. |
ControlFileSyncUpdate | Waiting for an update to the pg_control file
+ to reach durable storage. |
ControlFileWrite | Waiting for a write to the pg_control
+ file. |
ControlFileWriteUpdate | Waiting for a write to update the pg_control
+ file. |
CopyFileRead | Waiting for a read during a file copy operation. |
CopyFileWrite | Waiting for a write during a file copy operation. |
DSMAllocate | Waiting for a dynamic shared memory segment to be
+ allocated. |
DSMFillZeroWrite | Waiting to fill a dynamic shared memory backing file with
+ zeroes. |
DataFileExtend | Waiting for a relation data file to be extended. |
DataFileFlush | Waiting for a relation data file to reach durable storage. |
DataFileImmediateSync | Waiting for an immediate synchronization of a relation data file to
+ durable storage. |
DataFilePrefetch | Waiting for an asynchronous prefetch from a relation data
+ file. |
DataFileRead | Waiting for a read from a relation data file. |
DataFileSync | Waiting for changes to a relation data file to reach durable storage. |
DataFileTruncate | Waiting for a relation data file to be truncated. |
DataFileWrite | Waiting for a write to a relation data file. |
LockFileAddToDataDirRead | Waiting for a read while adding a line to the data directory lock
+ file. |
LockFileAddToDataDirSync | Waiting for data to reach durable storage while adding a line to the
+ data directory lock file. |
LockFileAddToDataDirWrite | Waiting for a write while adding a line to the data directory
+ lock file. |
LockFileCreateRead | Waiting to read while creating the data directory lock
+ file. |
LockFileCreateSync | Waiting for data to reach durable storage while creating the data
+ directory lock file. |
LockFileCreateWrite | Waiting for a write while creating the data directory lock
+ file. |
LockFileReCheckDataDirRead | Waiting for a read during recheck of the data directory lock
+ file. |
LogicalRewriteCheckpointSync | Waiting for logical rewrite mappings to reach durable storage
+ during a checkpoint. |
LogicalRewriteMappingSync | Waiting for mapping data to reach durable storage during a logical
+ rewrite. |
LogicalRewriteMappingWrite | Waiting for a write of mapping data during a logical
+ rewrite. |
LogicalRewriteSync | Waiting for logical rewrite mappings to reach durable
+ storage. |
LogicalRewriteTruncate | Waiting for truncate of mapping data during a logical
+ rewrite. |
LogicalRewriteWrite | Waiting for a write of logical rewrite mappings. |
RelationMapRead | Waiting for a read of the relation map file. |
RelationMapReplace | Waiting for durable replacement of a relation map file. |
RelationMapWrite | Waiting for a write to the relation map file. |
ReorderBufferRead | Waiting for a read during reorder buffer management. |
ReorderBufferWrite | Waiting for a write during reorder buffer management. |
ReorderLogicalMappingRead | Waiting for a read of a logical mapping during reorder buffer
+ management. |
ReplicationSlotRead | Waiting for a read from a replication slot control file. |
ReplicationSlotRestoreSync | Waiting for a replication slot control file to reach durable storage
+ while restoring it to memory. |
ReplicationSlotSync | Waiting for a replication slot control file to reach durable
+ storage. |
ReplicationSlotWrite | Waiting for a write to a replication slot control file. |
SLRUFlushSync | Waiting for SLRU data to reach durable storage during a checkpoint
+ or database shutdown. |
SLRURead | Waiting for a read of an SLRU page. |
SLRUSync | Waiting for SLRU data to reach durable storage following a page
+ write. |
SLRUWrite | Waiting for a write of an SLRU page. |
SnapbuildRead | Waiting for a read of a serialized historical catalog
+ snapshot. |
SnapbuildSync | Waiting for a serialized historical catalog snapshot to reach
+ durable storage. |
SnapbuildWrite | Waiting for a write of a serialized historical catalog
+ snapshot. |
TimelineHistoryFileSync | Waiting for a timeline history file received via streaming
+ replication to reach durable storage. |
TimelineHistoryFileWrite | Waiting for a write of a timeline history file received via
+ streaming replication. |
TimelineHistoryRead | Waiting for a read of a timeline history file. |
TimelineHistorySync | Waiting for a newly created timeline history file to reach durable
+ storage. |
TimelineHistoryWrite | Waiting for a write of a newly created timeline history
+ file. |
TwophaseFileRead | Waiting for a read of a two phase state file. |
TwophaseFileSync | Waiting for a two phase state file to reach durable storage. |
TwophaseFileWrite | Waiting for a write of a two phase state file. |
VersionFileSync | Waiting for the version file to reach durable storage while
+ creating a database. |
VersionFileWrite | Waiting for the version file to be written while creating a database. |
WALBootstrapSync | Waiting for WAL to reach durable storage during
+ bootstrapping. |
WALBootstrapWrite | Waiting for a write of a WAL page during bootstrapping. |
WALCopyRead | Waiting for a read when creating a new WAL segment by copying an
+ existing one. |
WALCopySync | Waiting for a new WAL segment created by copying an existing one to
+ reach durable storage. |
WALCopyWrite | Waiting for a write when creating a new WAL segment by copying an
+ existing one. |
WALInitSync | Waiting for a newly initialized WAL file to reach durable
+ storage. |
WALInitWrite | Waiting for a write while initializing a new WAL file. |
WALRead | Waiting for a read from a WAL file. |
WALSenderTimelineHistoryRead | Waiting for a read from a timeline history file during a walsender
+ timeline command. |
WALSync | Waiting for a WAL file to reach durable storage. |
WALSyncMethodAssign | Waiting for data to reach durable storage while assigning a new
+ WAL sync method. |
WALWrite | Waiting for a write to a WAL file. |
Table 28.10. Wait Events of Type IPC
IPC Wait Event | Description |
|---|
AppendReady | Waiting for subplan nodes of an Append plan
+ node to be ready. |
ArchiveCleanupCommand | Waiting for archive_cleanup_command to
+ complete. |
ArchiveCommand | Waiting for archive_command to
+ complete. |
BackendTermination | Waiting for the termination of another backend. |
BackupWaitWalArchive | Waiting for WAL files required for a backup to be successfully
+ archived. |
BgWorkerShutdown | Waiting for background worker to shut down. |
BgWorkerStartup | Waiting for background worker to start up. |
BtreePage | Waiting for the page number needed to continue a parallel B-tree
+ scan to become available. |
BufferIO | Waiting for buffer I/O to complete. |
CheckpointDone | Waiting for a checkpoint to complete. |
CheckpointStart | Waiting for a checkpoint to start. |
ExecuteGather | Waiting for activity from a child process while
+ executing a Gather plan node. |
HashBatchAllocate | Waiting for an elected Parallel Hash participant to allocate a hash
+ table. |
HashBatchElect | Waiting to elect a Parallel Hash participant to allocate a hash
+ table. |
HashBatchLoad | Waiting for other Parallel Hash participants to finish loading a
+ hash table. |
HashBuildAllocate | Waiting for an elected Parallel Hash participant to allocate the
+ initial hash table. |
HashBuildElect | Waiting to elect a Parallel Hash participant to allocate the
+ initial hash table. |
HashBuildHashInner | Waiting for other Parallel Hash participants to finish hashing the
+ inner relation. |
HashBuildHashOuter | Waiting for other Parallel Hash participants to finish partitioning
+ the outer relation. |
HashGrowBatchesDecide | Waiting to elect a Parallel Hash participant to decide on future
+ batch growth. |
HashGrowBatchesElect | Waiting to elect a Parallel Hash participant to allocate more
+ batches. |
HashGrowBatchesFinish | Waiting for an elected Parallel Hash participant to decide on
+ future batch growth. |
HashGrowBatchesReallocate | Waiting for an elected Parallel Hash participant to allocate more
+ batches. |
HashGrowBatchesRepartition | Waiting for other Parallel Hash participants to finish
+ repartitioning. |
HashGrowBucketsElect | Waiting to elect a Parallel Hash participant to allocate more
+ buckets. |
HashGrowBucketsReallocate | Waiting for an elected Parallel Hash participant to finish
+ allocating more buckets. |
HashGrowBucketsReinsert | Waiting for other Parallel Hash participants to finish inserting
+ tuples into new buckets. |
LogicalApplySendData | Waiting for a logical replication leader apply process to send
+ data to a parallel apply process. |
LogicalParallelApplyStateChange | Waiting for a logical replication parallel apply process to change
+ state. |
LogicalSyncData | Waiting for a logical replication remote server to send data for
+ initial table synchronization. |
LogicalSyncStateChange | Waiting for a logical replication remote server to change
+ state. |
MessageQueueInternal | Waiting for another process to be attached to a shared message
+ queue. |
MessageQueuePutMessage | Waiting to write a protocol message to a shared message queue. |
MessageQueueReceive | Waiting to receive bytes from a shared message queue. |
MessageQueueSend | Waiting to send bytes to a shared message queue. |
ParallelBitmapScan | Waiting for parallel bitmap scan to become initialized. |
ParallelCreateIndexScan | Waiting for parallel CREATE INDEX workers to
+ finish heap scan. |
ParallelFinish | Waiting for parallel workers to finish computing. |
ProcArrayGroupUpdate | Waiting for the group leader to clear the transaction ID at
+ end of a parallel operation. |
ProcSignalBarrier | Waiting for a barrier event to be processed by all
+ backends. |
Promote | Waiting for standby promotion. |
RecoveryConflictSnapshot | Waiting for recovery conflict resolution for a vacuum
+ cleanup. |
RecoveryConflictTablespace | Waiting for recovery conflict resolution for dropping a
+ tablespace. |
RecoveryEndCommand | Waiting for recovery_end_command to
+ complete. |
RecoveryPause | Waiting for recovery to be resumed. |
ReplicationOriginDrop | Waiting for a replication origin to become inactive so it can be
+ dropped. |
ReplicationSlotDrop | Waiting for a replication slot to become inactive so it can be
+ dropped. |
RestoreCommand | Waiting for restore_command to
+ complete. |
SafeSnapshot | Waiting to obtain a valid snapshot for a READ ONLY
+ DEFERRABLE transaction. |
SyncRep | Waiting for confirmation from a remote server during synchronous
+ replication. |
WalReceiverExit | Waiting for the WAL receiver to exit. |
WalReceiverWaitStart | Waiting for startup process to send initial data for streaming
+ replication. |
XactGroupUpdate | Waiting for the group leader to update transaction status at
+ end of a parallel operation. |
Table 28.11. Wait Events of Type Lock
Lock Wait Event | Description |
|---|
advisory | Waiting to acquire an advisory user lock. |
applytransaction | Waiting to acquire a lock on a remote transaction being applied
+ by a logical replication subscriber. |
extend | Waiting to extend a relation. |
frozenid | Waiting to
+ update pg_database.datfrozenxid
+ and pg_database.datminmxid. |
object | Waiting to acquire a lock on a non-relation database object. |
page | Waiting to acquire a lock on a page of a relation. |
relation | Waiting to acquire a lock on a relation. |
spectoken | Waiting to acquire a speculative insertion lock. |
transactionid | Waiting for a transaction to finish. |
tuple | Waiting to acquire a lock on a tuple. |
userlock | Waiting to acquire a user lock. |
virtualxid | Waiting to acquire a virtual transaction ID lock; see
+ Section 74.1. |
Table 28.12. Wait Events of Type LWLock
LWLock Wait Event | Description |
|---|
AddinShmemInit | Waiting to manage an extension's space allocation in shared
+ memory. |
AutoFile | Waiting to update the postgresql.auto.conf
+ file. |
Autovacuum | Waiting to read or update the current state of autovacuum
+ workers. |
AutovacuumSchedule | Waiting to ensure that a table selected for autovacuum
+ still needs vacuuming. |
BackgroundWorker | Waiting to read or update background worker state. |
BtreeVacuum | Waiting to read or update vacuum-related information for a
+ B-tree index. |
BufferContent | Waiting to access a data page in memory. |
BufferMapping | Waiting to associate a data block with a buffer in the buffer
+ pool. |
CheckpointerComm | Waiting to manage fsync requests. |
CommitTs | Waiting to read or update the last value set for a
+ transaction commit timestamp. |
CommitTsBuffer | Waiting for I/O on a commit timestamp SLRU buffer. |
CommitTsSLRU | Waiting to access the commit timestamp SLRU cache. |
ControlFile | Waiting to read or update the pg_control
+ file or create a new WAL file. |
DynamicSharedMemoryControl | Waiting to read or update dynamic shared memory allocation
+ information. |
LockFastPath | Waiting to read or update a process' fast-path lock
+ information. |
LockManager | Waiting to read or update information
+ about “heavyweight” locks. |
LogicalRepLauncherDSA | Waiting to access logical replication launcher's dynamic shared
+ memory allocator. |
LogicalRepLauncherHash | Waiting to access logical replication launcher's shared
+ hash table. |
LogicalRepWorker | Waiting to read or update the state of logical replication
+ workers. |
MultiXactGen | Waiting to read or update shared multixact state. |
MultiXactMemberBuffer | Waiting for I/O on a multixact member SLRU buffer. |
MultiXactMemberSLRU | Waiting to access the multixact member SLRU cache. |
MultiXactOffsetBuffer | Waiting for I/O on a multixact offset SLRU buffer. |
MultiXactOffsetSLRU | Waiting to access the multixact offset SLRU cache. |
MultiXactTruncation | Waiting to read or truncate multixact information. |
NotifyBuffer | Waiting for I/O on a NOTIFY message SLRU
+ buffer. |
NotifyQueue | Waiting to read or update NOTIFY messages. |
NotifyQueueTail | Waiting to update limit on NOTIFY message
+ storage. |
NotifySLRU | Waiting to access the NOTIFY message SLRU
+ cache. |
OidGen | Waiting to allocate a new OID. |
OldSnapshotTimeMap | Waiting to read or update old snapshot control information. |
ParallelAppend | Waiting to choose the next subplan during Parallel Append plan
+ execution. |
ParallelHashJoin | Waiting to synchronize workers during Parallel Hash Join plan
+ execution. |
ParallelQueryDSA | Waiting for parallel query dynamic shared memory allocation. |
PerSessionDSA | Waiting for parallel query dynamic shared memory allocation. |
PerSessionRecordType | Waiting to access a parallel query's information about composite
+ types. |
PerSessionRecordTypmod | Waiting to access a parallel query's information about type
+ modifiers that identify anonymous record types. |
PerXactPredicateList | Waiting to access the list of predicate locks held by the current
+ serializable transaction during a parallel query. |
PgStatsData | Waiting for shared memory stats data access |
PgStatsDSA | Waiting for stats dynamic shared memory allocator access |
PgStatsHash | Waiting for stats shared memory hash table access |
PredicateLockManager | Waiting to access predicate lock information used by
+ serializable transactions. |
ProcArray | Waiting to access the shared per-process data structures
+ (typically, to get a snapshot or report a session's transaction
+ ID). |
RelationMapping | Waiting to read or update
+ a pg_filenode.map file (used to track the
+ filenode assignments of certain system catalogs). |
RelCacheInit | Waiting to read or update a pg_internal.init
+ relation cache initialization file. |
ReplicationOrigin | Waiting to create, drop or use a replication origin. |
ReplicationOriginState | Waiting to read or update the progress of one replication
+ origin. |
ReplicationSlotAllocation | Waiting to allocate or free a replication slot. |
ReplicationSlotControl | Waiting to read or update replication slot state. |
ReplicationSlotIO | Waiting for I/O on a replication slot. |
SerialBuffer | Waiting for I/O on a serializable transaction conflict SLRU
+ buffer. |
SerializableFinishedList | Waiting to access the list of finished serializable
+ transactions. |
SerializablePredicateList | Waiting to access the list of predicate locks held by
+ serializable transactions. |
SerializableXactHash | Waiting to read or update information about serializable
+ transactions. |
SerialSLRU | Waiting to access the serializable transaction conflict SLRU
+ cache. |
SharedTidBitmap | Waiting to access a shared TID bitmap during a parallel bitmap
+ index scan. |
SharedTupleStore | Waiting to access a shared tuple store during parallel
+ query. |
ShmemIndex | Waiting to find or allocate space in shared memory. |
SInvalRead | Waiting to retrieve messages from the shared catalog invalidation
+ queue. |
SInvalWrite | Waiting to add a message to the shared catalog invalidation
+ queue. |
SubtransBuffer | Waiting for I/O on a sub-transaction SLRU buffer. |
SubtransSLRU | Waiting to access the sub-transaction SLRU cache. |
SyncRep | Waiting to read or update information about the state of
+ synchronous replication. |
SyncScan | Waiting to select the starting location of a synchronized table
+ scan. |
TablespaceCreate | Waiting to create or drop a tablespace. |
TwoPhaseState | Waiting to read or update the state of prepared transactions. |
WALBufMapping | Waiting to replace a page in WAL buffers. |
WALInsert | Waiting to insert WAL data into a memory buffer. |
WALWrite | Waiting for WAL buffers to be written to disk. |
WrapLimitsVacuum | Waiting to update limits on transaction id and multixact
+ consumption. |
XactBuffer | Waiting for I/O on a transaction status SLRU buffer. |
XactSLRU | Waiting to access the transaction status SLRU cache. |
XactTruncation | Waiting to execute pg_xact_status or update
+ the oldest transaction ID available to it. |
XidGen | Waiting to allocate a new transaction ID. |
Note
+ Extensions can add LWLock types to the list shown in
+ Table 28.12. In some cases, the name
+ assigned by an extension will not be available in all server processes;
+ so an LWLock wait event might be reported as
+ just “extension” rather than the
+ extension-assigned name.
+
Table 28.13. Wait Events of Type Timeout
Timeout Wait Event | Description |
|---|
BaseBackupThrottle | Waiting during base backup when throttling activity. |
CheckpointWriteDelay | Waiting between writes while performing a checkpoint. |
PgSleep | Waiting due to a call to pg_sleep or
+ a sibling function. |
RecoveryApplyDelay | Waiting to apply WAL during recovery because of a delay
+ setting. |
RecoveryRetrieveRetryInterval | Waiting during recovery when WAL data is not available from any
+ source (pg_wal, archive or stream). |
RegisterSyncRequest | Waiting while sending synchronization requests to the
+ checkpointer, because the request queue is full. |
SpinDelay | Waiting while acquiring a contended spinlock. |
VacuumDelay | Waiting in a cost-based vacuum delay point. |
VacuumTruncate | Waiting to acquire an exclusive lock to truncate off any
+ empty pages at the end of a table vacuumed. |
+ Here is an example of how wait events can be viewed:
+
+
+SELECT pid, wait_event_type, wait_event FROM pg_stat_activity WHERE wait_event is NOT NULL;
+ pid | wait_event_type | wait_event
+------+-----------------+------------
+ 2540 | Lock | relation
+ 6644 | LWLock | ProcArray
+(2 rows)
+
+
28.2.4. pg_stat_replication #
+ The pg_stat_replication view will contain one row
+ per WAL sender process, showing statistics about replication to that
+ sender's connected standby server. Only directly connected standbys are
+ listed; no information is available about downstream standby servers.
+
Table 28.14. pg_stat_replication View
+ Column Type
+
+
+ Description
+ |
|---|
+ pid integer
+
+
+ Process ID of a WAL sender process
+ |
+ usesysid oid
+
+
+ OID of the user logged into this WAL sender process
+ |
+ usename name
+
+
+ Name of the user logged into this WAL sender process
+ |
+ application_name text
+
+
+ Name of the application that is connected
+ to this WAL sender
+ |
+ client_addr inet
+
+
+ IP address of the client connected to this WAL sender.
+ If this field is null, it indicates that the client is
+ connected via a Unix socket on the server machine.
+ |
+ client_hostname text
+
+
+ Host name of the connected client, as reported by a
+ reverse DNS lookup of client_addr. This field will
+ only be non-null for IP connections, and only when log_hostname is enabled.
+ |
+ client_port integer
+
+
+ TCP port number that the client is using for communication
+ with this WAL sender, or -1 if a Unix socket is used
+ |
+ backend_start timestamp with time zone
+
+
+ Time when this process was started, i.e., when the
+ client connected to this WAL sender
+ |
+ backend_xmin xid
+
+
+ This standby's xmin horizon reported
+ by hot_standby_feedback.
+ |
+ state text
+
+
+ Current WAL sender state.
+ Possible values are:
+
+ startup: This WAL sender is starting up.
+
+ catchup: This WAL sender's connected standby is
+ catching up with the primary.
+
+ streaming: This WAL sender is streaming changes
+ after its connected standby server has caught up with the primary.
+
+ backup: This WAL sender is sending a backup.
+
+ stopping: This WAL sender is stopping.
+
+ |
+ sent_lsn pg_lsn
+
+
+ Last write-ahead log location sent on this connection
+ |
+ write_lsn pg_lsn
+
+
+ Last write-ahead log location written to disk by this standby
+ server
+ |
+ flush_lsn pg_lsn
+
+
+ Last write-ahead log location flushed to disk by this standby
+ server
+ |
+ replay_lsn pg_lsn
+
+
+ Last write-ahead log location replayed into the database on this
+ standby server
+ |
+ write_lag interval
+
+
+ Time elapsed between flushing recent WAL locally and receiving
+ notification that this standby server has written it (but not yet
+ flushed it or applied it). This can be used to gauge the delay that
+ synchronous_commit level
+ remote_write incurred while committing if this
+ server was configured as a synchronous standby.
+ |
+ flush_lag interval
+
+
+ Time elapsed between flushing recent WAL locally and receiving
+ notification that this standby server has written and flushed it
+ (but not yet applied it). This can be used to gauge the delay that
+ synchronous_commit level
+ on incurred while committing if this
+ server was configured as a synchronous standby.
+ |
+ replay_lag interval
+
+
+ Time elapsed between flushing recent WAL locally and receiving
+ notification that this standby server has written, flushed and
+ applied it. This can be used to gauge the delay that
+ synchronous_commit level
+ remote_apply incurred while committing if this
+ server was configured as a synchronous standby.
+ |
+ sync_priority integer
+
+
+ Priority of this standby server for being chosen as the
+ synchronous standby in a priority-based synchronous replication.
+ This has no effect in a quorum-based synchronous replication.
+ |
+ sync_state text
+
+
+ Synchronous state of this standby server.
+ Possible values are:
+
+ async: This standby server is asynchronous.
+
+ potential: This standby server is now asynchronous,
+ but can potentially become synchronous if one of current
+ synchronous ones fails.
+
+ sync: This standby server is synchronous.
+
+ quorum: This standby server is considered as a candidate
+ for quorum standbys.
+
+ |
+ reply_time timestamp with time zone
+
+
+ Send time of last reply message received from standby server
+ |
+ The lag times reported in the pg_stat_replication
+ view are measurements of the time taken for recent WAL to be written,
+ flushed and replayed and for the sender to know about it. These times
+ represent the commit delay that was (or would have been) introduced by each
+ synchronous commit level, if the remote server was configured as a
+ synchronous standby. For an asynchronous standby, the
+ replay_lag column approximates the delay
+ before recent transactions became visible to queries. If the standby
+ server has entirely caught up with the sending server and there is no more
+ WAL activity, the most recently measured lag times will continue to be
+ displayed for a short time and then show NULL.
+
+ Lag times work automatically for physical replication. Logical decoding
+ plugins may optionally emit tracking messages; if they do not, the tracking
+ mechanism will simply display NULL lag.
+
Note
+ The reported lag times are not predictions of how long it will take for
+ the standby to catch up with the sending server assuming the current
+ rate of replay. Such a system would show similar times while new WAL is
+ being generated, but would differ when the sender becomes idle. In
+ particular, when the standby has caught up completely,
+ pg_stat_replication shows the time taken to
+ write, flush and replay the most recent reported WAL location rather than
+ zero as some users might expect. This is consistent with the goal of
+ measuring synchronous commit and transaction visibility delays for
+ recent write transactions.
+ To reduce confusion for users expecting a different model of lag, the
+ lag columns revert to NULL after a short time on a fully replayed idle
+ system. Monitoring systems should choose whether to represent this
+ as missing data, zero or continue to display the last known value.
+
28.2.5. pg_stat_replication_slots #
+ The pg_stat_replication_slots view will contain
+ one row per logical replication slot, showing statistics about its usage.
+
Table 28.15. pg_stat_replication_slots View
+ Column Type
+
+
+ Description
+ |
|---|
+ slot_name text
+
+
+ A unique, cluster-wide identifier for the replication slot
+ |
+ spill_txns bigint
+
+
+ Number of transactions spilled to disk once the memory used by
+ logical decoding to decode changes from WAL has exceeded
+ logical_decoding_work_mem. The counter gets
+ incremented for both top-level transactions and subtransactions.
+ |
+ spill_count bigint
+
+
+ Number of times transactions were spilled to disk while decoding
+ changes from WAL for this slot. This counter is incremented each time
+ a transaction is spilled, and the same transaction may be spilled
+ multiple times.
+ |
+ spill_bytes bigint
+
+
+ Amount of decoded transaction data spilled to disk while performing
+ decoding of changes from WAL for this slot. This and other spill
+ counters can be used to gauge the I/O which occurred during logical
+ decoding and allow tuning logical_decoding_work_mem.
+ |
+ stream_txns bigint
+
+
+ Number of in-progress transactions streamed to the decoding output
+ plugin after the memory used by logical decoding to decode changes
+ from WAL for this slot has exceeded
+ logical_decoding_work_mem. Streaming only
+ works with top-level transactions (subtransactions can't be streamed
+ independently), so the counter is not incremented for subtransactions.
+ |
+ stream_countbigint
+
+
+ Number of times in-progress transactions were streamed to the decoding
+ output plugin while decoding changes from WAL for this slot. This
+ counter is incremented each time a transaction is streamed, and the
+ same transaction may be streamed multiple times.
+ |
+ stream_bytesbigint
+
+
+ Amount of transaction data decoded for streaming in-progress
+ transactions to the decoding output plugin while decoding changes from
+ WAL for this slot. This and other streaming counters for this slot can
+ be used to tune logical_decoding_work_mem.
+
+ |
+ total_txns bigint
+
+
+ Number of decoded transactions sent to the decoding output plugin for
+ this slot. This counts top-level transactions only, and is not incremented
+ for subtransactions. Note that this includes the transactions that are
+ streamed and/or spilled.
+ |
+ total_bytesbigint
+
+
+ Amount of transaction data decoded for sending transactions to the
+ decoding output plugin while decoding changes from WAL for this slot.
+ Note that this includes data that is streamed and/or spilled.
+
+ |
+ stats_reset timestamp with time zone
+
+
+ Time at which these statistics were last reset
+ |
28.2.6. pg_stat_wal_receiver #
+ The pg_stat_wal_receiver view will contain only
+ one row, showing statistics about the WAL receiver from that receiver's
+ connected server.
+
Table 28.16. pg_stat_wal_receiver View
+ Column Type
+
+
+ Description
+ |
|---|
+ pid integer
+
+
+ Process ID of the WAL receiver process
+ |
+ status text
+
+
+ Activity status of the WAL receiver process
+ |
+ receive_start_lsn pg_lsn
+
+
+ First write-ahead log location used when WAL receiver is
+ started
+ |
+ receive_start_tli integer
+
+
+ First timeline number used when WAL receiver is started
+ |
+ written_lsn pg_lsn
+
+
+ Last write-ahead log location already received and written to disk,
+ but not flushed. This should not be used for data integrity checks.
+ |
+ flushed_lsn pg_lsn
+
+
+ Last write-ahead log location already received and flushed to
+ disk, the initial value of this field being the first log location used
+ when WAL receiver is started
+ |
+ received_tli integer
+
+
+ Timeline number of last write-ahead log location received and
+ flushed to disk, the initial value of this field being the timeline
+ number of the first log location used when WAL receiver is started
+ |
+ last_msg_send_time timestamp with time zone
+
+
+ Send time of last message received from origin WAL sender
+ |
+ last_msg_receipt_time timestamp with time zone
+
+
+ Receipt time of last message received from origin WAL sender
+ |
+ latest_end_lsn pg_lsn
+
+
+ Last write-ahead log location reported to origin WAL sender
+ |
+ latest_end_time timestamp with time zone
+
+
+ Time of last write-ahead log location reported to origin WAL sender
+ |
+ slot_name text
+
+
+ Replication slot name used by this WAL receiver
+ |
+ sender_host text
+
+
+ Host of the PostgreSQL instance
+ this WAL receiver is connected to. This can be a host name,
+ an IP address, or a directory path if the connection is via
+ Unix socket. (The path case can be distinguished because it
+ will always be an absolute path, beginning with /.)
+ |
+ sender_port integer
+
+
+ Port number of the PostgreSQL instance
+ this WAL receiver is connected to.
+ |
+ conninfo text
+
+
+ Connection string used by this WAL receiver,
+ with security-sensitive fields obfuscated.
+ |
28.2.7. pg_stat_recovery_prefetch #
+ The pg_stat_recovery_prefetch view will contain
+ only one row. The columns wal_distance,
+ block_distance and
+ io_depth show current values, and the
+ other columns show cumulative counters that can be reset
+ with the pg_stat_reset_shared function.
+
Table 28.17. pg_stat_recovery_prefetch View
+ Column Type
+
+
+ Description
+ |
|---|
|
+
+ stats_reset timestamp with time zone
+
+
+ Time at which these statistics were last reset
+
+ |
|
+
+ prefetch bigint
+
+
+ Number of blocks prefetched because they were not in the buffer pool
+
+ |
|
+
+ hit bigint
+
+
+ Number of blocks not prefetched because they were already in the buffer pool
+
+ |
|
+
+ skip_init bigint
+
+
+ Number of blocks not prefetched because they would be zero-initialized
+
+ |
|
+
+ skip_new bigint
+
+
+ Number of blocks not prefetched because they didn't exist yet
+
+ |
|
+
+ skip_fpw bigint
+
+
+ Number of blocks not prefetched because a full page image was included in the WAL
+
+ |
|
+
+ skip_rep bigint
+
+
+ Number of blocks not prefetched because they were already recently prefetched
+
+ |
|
+
+ wal_distance int
+
+
+ How many bytes ahead the prefetcher is looking
+
+ |
|
+
+ block_distance int
+
+
+ How many blocks ahead the prefetcher is looking
+
+ |
|
+
+ io_depth int
+
+
+ How many prefetches have been initiated but are not yet known to have completed
+
+ |
28.2.8. pg_stat_subscription #
Table 28.18. pg_stat_subscription View
+ Column Type
+
+
+ Description
+ |
|---|
+ subid oid
+
+
+ OID of the subscription
+ |
+ subname name
+
+
+ Name of the subscription
+ |
+ pid integer
+
+
+ Process ID of the subscription worker process
+ |
+ leader_pid integer
+
+
+ Process ID of the leader apply worker if this process is a parallel
+ apply worker; NULL if this process is a leader apply worker or a
+ synchronization worker
+ |
+ relid oid
+
+
+ OID of the relation that the worker is synchronizing; NULL for the
+ leader apply worker and parallel apply workers
+ |
+ received_lsn pg_lsn
+
+
+ Last write-ahead log location received, the initial value of
+ this field being 0; NULL for parallel apply workers
+ |
+ last_msg_send_time timestamp with time zone
+
+
+ Send time of last message received from origin WAL sender; NULL for
+ parallel apply workers
+ |
+ last_msg_receipt_time timestamp with time zone
+
+
+ Receipt time of last message received from origin WAL sender; NULL for
+ parallel apply workers
+ |
+ latest_end_lsn pg_lsn
+
+
+ Last write-ahead log location reported to origin WAL sender; NULL for
+ parallel apply workers
+ |
+ latest_end_time timestamp with time zone
+
+
+ Time of last write-ahead log location reported to origin WAL
+ sender; NULL for parallel apply workers
+ |
28.2.9. pg_stat_subscription_stats #
+ The pg_stat_subscription_stats view will contain
+ one row per subscription.
+
Table 28.19. pg_stat_subscription_stats View
+ Column Type
+
+
+ Description
+ |
|---|
+ subid oid
+
+
+ OID of the subscription
+ |
+ subname name
+
+
+ Name of the subscription
+ |
+ apply_error_count bigint
+
+
+ Number of times an error occurred while applying changes
+ |
+ sync_error_count bigint
+
+
+ Number of times an error occurred during the initial table
+ synchronization
+ |
+ stats_reset timestamp with time zone
+
+
+ Time at which these statistics were last reset
+ |
+ The pg_stat_ssl view will contain one row per
+ backend or WAL sender process, showing statistics about SSL usage on
+ this connection. It can be joined to pg_stat_activity
+ or pg_stat_replication on the
+ pid column to get more details about the
+ connection.
+
Table 28.20. pg_stat_ssl View
+ Column Type
+
+
+ Description
+ |
|---|
+ pid integer
+
+
+ Process ID of a backend or WAL sender process
+ |
+ ssl boolean
+
+
+ True if SSL is used on this connection
+ |
+ version text
+
+
+ Version of SSL in use, or NULL if SSL is not in use
+ on this connection
+ |
+ cipher text
+
+
+ Name of SSL cipher in use, or NULL if SSL is not in use
+ on this connection
+ |
+ bits integer
+
+
+ Number of bits in the encryption algorithm used, or NULL
+ if SSL is not used on this connection
+ |
+ client_dn text
+
+
+ Distinguished Name (DN) field from the client certificate
+ used, or NULL if no client certificate was supplied or if SSL
+ is not in use on this connection. This field is truncated if the
+ DN field is longer than NAMEDATALEN (64 characters
+ in a standard build).
+ |
+ client_serial numeric
+
+
+ Serial number of the client certificate, or NULL if no client
+ certificate was supplied or if SSL is not in use on this connection. The
+ combination of certificate serial number and certificate issuer uniquely
+ identifies a certificate (unless the issuer erroneously reuses serial
+ numbers).
+ |
+ issuer_dn text
+
+
+ DN of the issuer of the client certificate, or NULL if no client
+ certificate was supplied or if SSL is not in use on this connection.
+ This field is truncated like client_dn.
+ |
28.2.11. pg_stat_gssapi #
+ The pg_stat_gssapi view will contain one row per
+ backend, showing information about GSSAPI usage on this connection. It can
+ be joined to pg_stat_activity or
+ pg_stat_replication on the
+ pid column to get more details about the
+ connection.
+
Table 28.21. pg_stat_gssapi View
+ Column Type
+
+
+ Description
+ |
|---|
+ pid integer
+
+
+ Process ID of a backend
+ |
+ gss_authenticated boolean
+
+
+ True if GSSAPI authentication was used for this connection
+ |
+ principal text
+
+
+ Principal used to authenticate this connection, or NULL
+ if GSSAPI was not used to authenticate this connection. This
+ field is truncated if the principal is longer than
+ NAMEDATALEN (64 characters in a standard build).
+ |
+ encrypted boolean
+
+
+ True if GSSAPI encryption is in use on this connection
+ |
+ credentials_delegated boolean
+
+
+ True if GSSAPI credentials were delegated on this connection.
+ |
28.2.12. pg_stat_archiver #
+ The pg_stat_archiver view will always have a
+ single row, containing data about the archiver process of the cluster.
+
Table 28.22. pg_stat_archiver View
+ Column Type
+
+
+ Description
+ |
|---|
+ archived_count bigint
+
+
+ Number of WAL files that have been successfully archived
+ |
+ last_archived_wal text
+
+
+ Name of the WAL file most recently successfully archived
+ |
+ last_archived_time timestamp with time zone
+
+
+ Time of the most recent successful archive operation
+ |
+ failed_count bigint
+
+
+ Number of failed attempts for archiving WAL files
+ |
+ last_failed_wal text
+
+
+ Name of the WAL file of the most recent failed archival operation
+ |
+ last_failed_time timestamp with time zone
+
+
+ Time of the most recent failed archival operation
+ |
+ stats_reset timestamp with time zone
+
+
+ Time at which these statistics were last reset
+ |
+ Normally, WAL files are archived in order, oldest to newest, but that is
+ not guaranteed, and does not hold under special circumstances like when
+ promoting a standby or after crash recovery. Therefore it is not safe to
+ assume that all files older than
+ last_archived_wal have also been successfully
+ archived.
+
+ The pg_stat_io view will contain one row for each
+ combination of backend type, target I/O object, and I/O context, showing
+ cluster-wide I/O statistics. Combinations which do not make sense are
+ omitted.
+
+ Currently, I/O on relations (e.g. tables, indexes) is tracked. However,
+ relation I/O which bypasses shared buffers (e.g. when moving a table from one
+ tablespace to another) is currently not tracked.
+
Table 28.23. pg_stat_io View
|
+
+ Column Type
+
+
+ Description
+
+ |
|---|
|
+
+ backend_type text
+
+
+ Type of backend (e.g. background worker, autovacuum worker). See
+ pg_stat_activity for more information
+ on backend_types. Some
+ backend_types do not accumulate I/O operation
+ statistics and will not be included in the view.
+
+ |
|
+
+ object text
+
+
+ Target object of an I/O operation. Possible values are:
+
+
+ |
|
+
+ context text
+
+
+ The context of an I/O operation. Possible values are:
+
+
+ normal: The default or standard
+ context for a type of I/O operation. For
+ example, by default, relation data is read into and written out from
+ shared buffers. Thus, reads and writes of relation data to and from
+ shared buffers are tracked in context
+ normal.
+
+ vacuum: I/O operations performed outside of shared
+ buffers while vacuuming and analyzing permanent relations. Temporary
+ table vacuums use the same local buffer pool as other temporary table
+ IO operations and are tracked in context
+ normal.
+
+ bulkread: Certain large read I/O operations
+ done outside of shared buffers, for example, a sequential scan of a
+ large table.
+
+ bulkwrite: Certain large write I/O operations
+ done outside of shared buffers, such as COPY.
+
|
|
+
+ reads bigint
+
+
+ Number of read operations, each of the size specified in
+ op_bytes.
+
+ |
|
+
+ read_time double precision
+
+
+ Time spent in read operations in milliseconds (if
+ track_io_timing is enabled, otherwise zero)
+
+ |
|
+
+ writes bigint
+
+
+ Number of write operations, each of the size specified in
+ op_bytes.
+
+ |
|
+
+ write_time double precision
+
+
+ Time spent in write operations in milliseconds (if
+ track_io_timing is enabled, otherwise zero)
+
+ |
|
+
+ writebacks bigint
+
+
+ Number of units of size op_bytes which the process
+ requested the kernel write out to permanent storage.
+
+ |
|
+
+ writeback_time double precision
+
+
+ Time spent in writeback operations in milliseconds (if
+ track_io_timing is enabled, otherwise zero). This
+ includes the time spent queueing write-out requests and, potentially,
+ the time spent to write out the dirty data.
+
+ |
|
+
+ extends bigint
+
+
+ Number of relation extend operations, each of the size specified in
+ op_bytes.
+
+ |
|
+
+ extend_time double precision
+
+
+ Time spent in extend operations in milliseconds (if
+ track_io_timing is enabled, otherwise zero)
+
+ |
|
+
+ op_bytes bigint
+
+
+ The number of bytes per unit of I/O read, written, or extended.
+
+
+ Relation data reads, writes, and extends are done in
+ block_size units, derived from the build-time
+ parameter BLCKSZ, which is 8192 by
+ default.
+
+ |
|
+
+ hits bigint
+
+
+ The number of times a desired block was found in a shared buffer.
+
+ |
|
+
+ evictions bigint
+
+
+ Number of times a block has been written out from a shared or local
+ buffer in order to make it available for another use.
+
+
+ In context normal, this counts
+ the number of times a block was evicted from a buffer and replaced with
+ another block. In contexts
+ bulkwrite, bulkread, and
+ vacuum, this counts the number of times a block was
+ evicted from shared buffers in order to add the shared buffer to a
+ separate, size-limited ring buffer for use in a bulk I/O operation.
+
+ |
|
+
+ reuses bigint
+
+
+ The number of times an existing buffer in a size-limited ring buffer
+ outside of shared buffers was reused as part of an I/O operation in the
+ bulkread, bulkwrite, or
+ vacuum contexts.
+
+ |
|
+
+ fsyncs bigint
+
+
+ Number of fsync calls. These are only tracked in
+ context normal.
+
+ |
|
+
+ fsync_time double precision
+
+
+ Time spent in fsync operations in milliseconds (if
+ track_io_timing is enabled, otherwise zero)
+
+ |
|
+
+ stats_reset timestamp with time zone
+
+
+ Time at which these statistics were last reset.
+
+ |
+ Some backend types never perform I/O operations on some I/O objects and/or
+ in some I/O contexts. These rows are omitted from the view. For example, the
+ checkpointer does not checkpoint temporary tables, so there will be no rows
+ for backend_type checkpointer and
+ object temp relation.
+
+ In addition, some I/O operations will never be performed either by certain
+ backend types or on certain I/O objects and/or in certain I/O contexts.
+ These cells will be NULL. For example, temporary tables are not
+ fsynced, so fsyncs will be NULL for
+ object temp relation. Also, the
+ background writer does not perform reads, so reads will
+ be NULL in rows for backend_type background
+ writer.
+
+ pg_stat_io can be used to inform database tuning.
+ For example:
+
+ A high evictions count can indicate that shared
+ buffers should be increased.
+
+ Client backends rely on the checkpointer to ensure data is persisted to
+ permanent storage. Large numbers of fsyncs by
+ client backends could indicate a misconfiguration of
+ shared buffers or of the checkpointer. More information on configuring
+ the checkpointer can be found in Section 30.5.
+
+ Normally, client backends should be able to rely on auxiliary processes
+ like the checkpointer and the background writer to write out dirty data
+ as much as possible. Large numbers of writes by client backends could
+ indicate a misconfiguration of shared buffers or of the checkpointer.
+ More information on configuring the checkpointer can be found in Section 30.5.
+
+
Note
+ Columns tracking I/O time will only be non-zero when
+ track_io_timing is enabled. The user should be
+ careful when referencing these columns in combination with their
+ corresponding IO operations in case track_io_timing
+ was not enabled for the entire time since the last stats reset.
+
28.2.14. pg_stat_bgwriter #
+ The pg_stat_bgwriter view will always have a
+ single row, containing global data for the cluster.
+
Table 28.24. pg_stat_bgwriter View
+ Column Type
+
+
+ Description
+ |
|---|
+ checkpoints_timed bigint
+
+
+ Number of scheduled checkpoints that have been performed
+ |
+ checkpoints_req bigint
+
+
+ Number of requested checkpoints that have been performed
+ |
+ checkpoint_write_time double precision
+
+
+ Total amount of time that has been spent in the portion of
+ checkpoint processing where files are written to disk, in milliseconds
+ |
+ checkpoint_sync_time double precision
+
+
+ Total amount of time that has been spent in the portion of
+ checkpoint processing where files are synchronized to disk, in
+ milliseconds
+ |
+ buffers_checkpoint bigint
+
+
+ Number of buffers written during checkpoints
+ |
+ buffers_clean bigint
+
+
+ Number of buffers written by the background writer
+ |
+ maxwritten_clean bigint
+
+
+ Number of times the background writer stopped a cleaning
+ scan because it had written too many buffers
+ |
+ buffers_backend bigint
+
+
+ Number of buffers written directly by a backend
+ |
+ buffers_backend_fsync bigint
+
+
+ Number of times a backend had to execute its own
+ fsync call (normally the background writer handles those
+ even when the backend does its own write)
+ |
+ buffers_alloc bigint
+
+
+ Number of buffers allocated
+ |
+ stats_reset timestamp with time zone
+
+
+ Time at which these statistics were last reset
+ |
+ The pg_stat_wal view will always have a
+ single row, containing data about WAL activity of the cluster.
+
Table 28.25. pg_stat_wal View
+ Column Type
+
+
+ Description
+ |
|---|
+ wal_records bigint
+
+
+ Total number of WAL records generated
+ |
+ wal_fpi bigint
+
+
+ Total number of WAL full page images generated
+ |
+ wal_bytes numeric
+
+
+ Total amount of WAL generated in bytes
+ |
+ wal_buffers_full bigint
+
+
+ Number of times WAL data was written to disk because WAL buffers became full
+ |
+ wal_write bigint
+
+
+ Number of times WAL buffers were written out to disk via
+ XLogWrite request.
+ See Section 30.5 for more information about
+ the internal WAL function XLogWrite.
+ |
+ wal_sync bigint
+
+
+ Number of times WAL files were synced to disk via
+ issue_xlog_fsync request
+ (if fsync is on and
+ wal_sync_method is either
+ fdatasync, fsync or
+ fsync_writethrough, otherwise zero).
+ See Section 30.5 for more information about
+ the internal WAL function issue_xlog_fsync.
+ |
+ wal_write_time double precision
+
+
+ Total amount of time spent writing WAL buffers to disk via
+ XLogWrite request, in milliseconds
+ (if track_wal_io_timing is enabled,
+ otherwise zero). This includes the sync time when
+ wal_sync_method is either
+ open_datasync or open_sync.
+ |
+ wal_sync_time double precision
+
+
+ Total amount of time spent syncing WAL files to disk via
+ issue_xlog_fsync request, in milliseconds
+ (if track_wal_io_timing is enabled,
+ fsync is on, and
+ wal_sync_method is either
+ fdatasync, fsync or
+ fsync_writethrough, otherwise zero).
+ |
+ stats_reset timestamp with time zone
+
+
+ Time at which these statistics were last reset
+ |
28.2.16. pg_stat_database #
+ The pg_stat_database view will contain one row
+ for each database in the cluster, plus one for shared objects, showing
+ database-wide statistics.
+
Table 28.26. pg_stat_database View
+ Column Type
+
+
+ Description
+ |
|---|
+ datid oid
+
+
+ OID of this database, or 0 for objects belonging to a shared
+ relation
+ |
+ datname name
+
+
+ Name of this database, or NULL for shared
+ objects.
+ |
+ numbackends integer
+
+
+ Number of backends currently connected to this database, or
+ NULL for shared objects. This is the only column
+ in this view that returns a value reflecting current state; all other
+ columns return the accumulated values since the last reset.
+ |
+ xact_commit bigint
+
+
+ Number of transactions in this database that have been
+ committed
+ |
+ xact_rollback bigint
+
+
+ Number of transactions in this database that have been
+ rolled back
+ |
+ blks_read bigint
+
+
+ Number of disk blocks read in this database
+ |
+ blks_hit bigint
+
+
+ Number of times disk blocks were found already in the buffer
+ cache, so that a read was not necessary (this only includes hits in the
+ PostgreSQL buffer cache, not the operating system's file system cache)
+ |
+ tup_returned bigint
+
+
+ Number of live rows fetched by sequential scans and index entries returned by index scans in this database
+ |
+ tup_fetched bigint
+
+
+ Number of live rows fetched by index scans in this database
+ |
+ tup_inserted bigint
+
+
+ Number of rows inserted by queries in this database
+ |
+ tup_updated bigint
+
+
+ Number of rows updated by queries in this database
+ |
+ tup_deleted bigint
+
+
+ Number of rows deleted by queries in this database
+ |
+ conflicts bigint
+
+
+ Number of queries canceled due to conflicts with recovery
+ in this database. (Conflicts occur only on standby servers; see
+
+ pg_stat_database_conflicts for details.)
+ |
+ temp_files bigint
+
+
+ Number of temporary files created by queries in this database.
+ All temporary files are counted, regardless of why the temporary file
+ was created (e.g., sorting or hashing), and regardless of the
+ log_temp_files setting.
+ |
+ temp_bytes bigint
+
+
+ Total amount of data written to temporary files by queries in
+ this database. All temporary files are counted, regardless of why
+ the temporary file was created, and
+ regardless of the log_temp_files setting.
+ |
+ deadlocks bigint
+
+
+ Number of deadlocks detected in this database
+ |
+ checksum_failures bigint
+
+
+ Number of data page checksum failures detected in this
+ database (or on a shared object), or NULL if data checksums are not
+ enabled.
+ |
+ checksum_last_failure timestamp with time zone
+
+
+ Time at which the last data page checksum failure was detected in
+ this database (or on a shared object), or NULL if data checksums are not
+ enabled.
+ |
+ blk_read_time double precision
+
+
+ Time spent reading data file blocks by backends in this database,
+ in milliseconds (if track_io_timing is enabled,
+ otherwise zero)
+ |
+ blk_write_time double precision
+
+
+ Time spent writing data file blocks by backends in this database,
+ in milliseconds (if track_io_timing is enabled,
+ otherwise zero)
+ |
+ session_time double precision
+
+
+ Time spent by database sessions in this database, in milliseconds
+ (note that statistics are only updated when the state of a session
+ changes, so if sessions have been idle for a long time, this idle time
+ won't be included)
+ |
+ active_time double precision
+
+
+ Time spent executing SQL statements in this database, in milliseconds
+ (this corresponds to the states active and
+ fastpath function call in
+
+ pg_stat_activity)
+ |
+ idle_in_transaction_time double precision
+
+
+ Time spent idling while in a transaction in this database, in milliseconds
+ (this corresponds to the states idle in transaction and
+ idle in transaction (aborted) in
+
+ pg_stat_activity)
+ |
+ sessions bigint
+
+
+ Total number of sessions established to this database
+ |
+ sessions_abandoned bigint
+
+
+ Number of database sessions to this database that were terminated
+ because connection to the client was lost
+ |
+ sessions_fatal bigint
+
+
+ Number of database sessions to this database that were terminated
+ by fatal errors
+ |
+ sessions_killed bigint
+
+
+ Number of database sessions to this database that were terminated
+ by operator intervention
+ |
+ stats_reset timestamp with time zone
+
+
+ Time at which these statistics were last reset
+ |
28.2.17. pg_stat_database_conflicts #
+ The pg_stat_database_conflicts view will contain
+ one row per database, showing database-wide statistics about
+ query cancels occurring due to conflicts with recovery on standby servers.
+ This view will only contain information on standby servers, since
+ conflicts do not occur on primary servers.
+
Table 28.27. pg_stat_database_conflicts View
+ Column Type
+
+
+ Description
+ |
|---|
+ datid oid
+
+
+ OID of a database
+ |
+ datname name
+
+
+ Name of this database
+ |
+ confl_tablespace bigint
+
+
+ Number of queries in this database that have been canceled due to
+ dropped tablespaces
+ |
+ confl_lock bigint
+
+
+ Number of queries in this database that have been canceled due to
+ lock timeouts
+ |
+ confl_snapshot bigint
+
+
+ Number of queries in this database that have been canceled due to
+ old snapshots
+ |
+ confl_bufferpin bigint
+
+
+ Number of queries in this database that have been canceled due to
+ pinned buffers
+ |
+ confl_deadlock bigint
+
+
+ Number of queries in this database that have been canceled due to
+ deadlocks
+ |
+ confl_active_logicalslot bigint
+
+
+ Number of uses of logical slots in this database that have been
+ canceled due to old snapshots or too low a wal_level
+ on the primary
+ |
28.2.18. pg_stat_all_tables #
+ The pg_stat_all_tables view will contain
+ one row for each table in the current database (including TOAST
+ tables), showing statistics about accesses to that specific table. The
+ pg_stat_user_tables and
+ pg_stat_sys_tables views
+ contain the same information,
+ but filtered to only show user and system tables respectively.
+
Table 28.28. pg_stat_all_tables View
+ Column Type
+
+
+ Description
+ |
|---|
+ relid oid
+
+
+ OID of a table
+ |
+ schemaname name
+
+
+ Name of the schema that this table is in
+ |
+ relname name
+
+
+ Name of this table
+ |
+ seq_scan bigint
+
+
+ Number of sequential scans initiated on this table
+ |
+ last_seq_scan timestamp with time zone
+
+
+ The time of the last sequential scan on this table, based on the
+ most recent transaction stop time
+ |
+ seq_tup_read bigint
+
+
+ Number of live rows fetched by sequential scans
+ |
+ idx_scan bigint
+
+
+ Number of index scans initiated on this table
+ |
+ last_idx_scan timestamp with time zone
+
+
+ The time of the last index scan on this table, based on the
+ most recent transaction stop time
+ |
+ idx_tup_fetch bigint
+
+
+ Number of live rows fetched by index scans
+ |
+ n_tup_ins bigint
+
+
+ Total number of rows inserted
+ |
+ n_tup_upd bigint
+
+
+ Total number of rows updated. (This includes row updates
+ counted in n_tup_hot_upd and
+ n_tup_newpage_upd, and remaining
+ non-HOT updates.)
+ |
+ n_tup_del bigint
+
+
+ Total number of rows deleted
+ |
+ n_tup_hot_upd bigint
+
+
+ Number of rows HOT updated.
+ These are updates where no successor versions are required in
+ indexes.
+ |
+ n_tup_newpage_upd bigint
+
+
+ Number of rows updated where the successor version goes onto a
+ new heap page, leaving behind an original
+ version with a
+ t_ctid
+ field that points to a different heap page. These are
+ always non-HOT updates.
+ |
+ n_live_tup bigint
+
+
+ Estimated number of live rows
+ |
+ n_dead_tup bigint
+
+
+ Estimated number of dead rows
+ |
+ n_mod_since_analyze bigint
+
+
+ Estimated number of rows modified since this table was last analyzed
+ |
+ n_ins_since_vacuum bigint
+
+
+ Estimated number of rows inserted since this table was last vacuumed
+ |
+ last_vacuum timestamp with time zone
+
+
+ Last time at which this table was manually vacuumed
+ (not counting VACUUM FULL)
+ |
+ last_autovacuum timestamp with time zone
+
+
+ Last time at which this table was vacuumed by the autovacuum
+ daemon
+ |
+ last_analyze timestamp with time zone
+
+
+ Last time at which this table was manually analyzed
+ |
+ last_autoanalyze timestamp with time zone
+
+
+ Last time at which this table was analyzed by the autovacuum
+ daemon
+ |
+ vacuum_count bigint
+
+
+ Number of times this table has been manually vacuumed
+ (not counting VACUUM FULL)
+ |
+ autovacuum_count bigint
+
+
+ Number of times this table has been vacuumed by the autovacuum
+ daemon
+ |
+ analyze_count bigint
+
+
+ Number of times this table has been manually analyzed
+ |
+ autoanalyze_count bigint
+
+
+ Number of times this table has been analyzed by the autovacuum
+ daemon
+ |
28.2.19. pg_stat_all_indexes #
+ The pg_stat_all_indexes view will contain
+ one row for each index in the current database,
+ showing statistics about accesses to that specific index. The
+ pg_stat_user_indexes and
+ pg_stat_sys_indexes views
+ contain the same information,
+ but filtered to only show user and system indexes respectively.
+
Table 28.29. pg_stat_all_indexes View
+ Column Type
+
+
+ Description
+ |
|---|
+ relid oid
+
+
+ OID of the table for this index
+ |
+ indexrelid oid
+
+
+ OID of this index
+ |
+ schemaname name
+
+
+ Name of the schema this index is in
+ |
+ relname name
+
+
+ Name of the table for this index
+ |
+ indexrelname name
+
+
+ Name of this index
+ |
+ idx_scan bigint
+
+
+ Number of index scans initiated on this index
+ |
+ last_idx_scan timestamp with time zone
+
+
+ The time of the last scan on this index, based on the
+ most recent transaction stop time
+ |
+ idx_tup_read bigint
+
+
+ Number of index entries returned by scans on this index
+ |
+ idx_tup_fetch bigint
+
+
+ Number of live table rows fetched by simple index scans using this
+ index
+ |
+ Indexes can be used by simple index scans, “bitmap” index scans,
+ and the optimizer. In a bitmap scan
+ the output of several indexes can be combined via AND or OR rules,
+ so it is difficult to associate individual heap row fetches
+ with specific indexes when a bitmap scan is used. Therefore, a bitmap
+ scan increments the
+ pg_stat_all_indexes.idx_tup_read
+ count(s) for the index(es) it uses, and it increments the
+ pg_stat_all_tables.idx_tup_fetch
+ count for the table, but it does not affect
+ pg_stat_all_indexes.idx_tup_fetch.
+ The optimizer also accesses indexes to check for supplied constants
+ whose values are outside the recorded range of the optimizer statistics
+ because the optimizer statistics might be stale.
+
Note
+ The idx_tup_read and idx_tup_fetch counts
+ can be different even without any use of bitmap scans,
+ because idx_tup_read counts
+ index entries retrieved from the index while idx_tup_fetch
+ counts live rows fetched from the table. The latter will be less if any
+ dead or not-yet-committed rows are fetched using the index, or if any
+ heap fetches are avoided by means of an index-only scan.
+
28.2.20. pg_statio_all_tables #
+ The pg_statio_all_tables view will contain
+ one row for each table in the current database (including TOAST
+ tables), showing statistics about I/O on that specific table. The
+ pg_statio_user_tables and
+ pg_statio_sys_tables views
+ contain the same information,
+ but filtered to only show user and system tables respectively.
+
Table 28.30. pg_statio_all_tables View
+ Column Type
+
+
+ Description
+ |
|---|
+ relid oid
+
+
+ OID of a table
+ |
+ schemaname name
+
+
+ Name of the schema that this table is in
+ |
+ relname name
+
+
+ Name of this table
+ |
+ heap_blks_read bigint
+
+
+ Number of disk blocks read from this table
+ |
+ heap_blks_hit bigint
+
+
+ Number of buffer hits in this table
+ |
+ idx_blks_read bigint
+
+
+ Number of disk blocks read from all indexes on this table
+ |
+ idx_blks_hit bigint
+
+
+ Number of buffer hits in all indexes on this table
+ |
+ toast_blks_read bigint
+
+
+ Number of disk blocks read from this table's TOAST table (if any)
+ |
+ toast_blks_hit bigint
+
+
+ Number of buffer hits in this table's TOAST table (if any)
+ |
+ tidx_blks_read bigint
+
+
+ Number of disk blocks read from this table's TOAST table indexes (if any)
+ |
+ tidx_blks_hit bigint
+
+
+ Number of buffer hits in this table's TOAST table indexes (if any)
+ |
28.2.21. pg_statio_all_indexes #
+ The pg_statio_all_indexes view will contain
+ one row for each index in the current database,
+ showing statistics about I/O on that specific index. The
+ pg_statio_user_indexes and
+ pg_statio_sys_indexes views
+ contain the same information,
+ but filtered to only show user and system indexes respectively.
+
Table 28.31. pg_statio_all_indexes View
+ Column Type
+
+
+ Description
+ |
|---|
+ relid oid
+
+
+ OID of the table for this index
+ |
+ indexrelid oid
+
+
+ OID of this index
+ |
+ schemaname name
+
+
+ Name of the schema this index is in
+ |
+ relname name
+
+
+ Name of the table for this index
+ |
+ indexrelname name
+
+
+ Name of this index
+ |
+ idx_blks_read bigint
+
+
+ Number of disk blocks read from this index
+ |
+ idx_blks_hit bigint
+
+
+ Number of buffer hits in this index
+ |
28.2.22. pg_statio_all_sequences #
+ The pg_statio_all_sequences view will contain
+ one row for each sequence in the current database,
+ showing statistics about I/O on that specific sequence.
+
Table 28.32. pg_statio_all_sequences View
+ Column Type
+
+
+ Description
+ |
|---|
+ relid oid
+
+
+ OID of a sequence
+ |
+ schemaname name
+
+
+ Name of the schema this sequence is in
+ |
+ relname name
+
+
+ Name of this sequence
+ |
+ blks_read bigint
+
+
+ Number of disk blocks read from this sequence
+ |
+ blks_hit bigint
+
+
+ Number of buffer hits in this sequence
+ |
28.2.23. pg_stat_user_functions #
+ The pg_stat_user_functions view will contain
+ one row for each tracked function, showing statistics about executions of
+ that function. The track_functions parameter
+ controls exactly which functions are tracked.
+
Table 28.33. pg_stat_user_functions View
+ Column Type
+
+
+ Description
+ |
|---|
+ funcid oid
+
+
+ OID of a function
+ |
+ schemaname name
+
+
+ Name of the schema this function is in
+ |
+ funcname name
+
+
+ Name of this function
+ |
+ calls bigint
+
+
+ Number of times this function has been called
+ |
+ total_time double precision
+
+
+ Total time spent in this function and all other functions
+ called by it, in milliseconds
+ |
+ self_time double precision
+
+
+ Total time spent in this function itself, not including
+ other functions called by it, in milliseconds
+ |
+ PostgreSQL accesses certain on-disk information
+ via SLRU (simple least-recently-used) caches.
+ The pg_stat_slru view will contain
+ one row for each tracked SLRU cache, showing statistics about access
+ to cached pages.
+
Table 28.34. pg_stat_slru View
+ Column Type
+
+
+ Description
+ |
|---|
+ name text
+
+
+ Name of the SLRU
+ |
+ blks_zeroed bigint
+
+
+ Number of blocks zeroed during initializations
+ |
+ blks_hit bigint
+
+
+ Number of times disk blocks were found already in the SLRU,
+ so that a read was not necessary (this only includes hits in the
+ SLRU, not the operating system's file system cache)
+ |
+ blks_read bigint
+
+
+ Number of disk blocks read for this SLRU
+ |
+ blks_written bigint
+
+
+ Number of disk blocks written for this SLRU
+ |
+ blks_exists bigint
+
+
+ Number of blocks checked for existence for this SLRU
+ |
+ flushes bigint
+
+
+ Number of flushes of dirty data for this SLRU
+ |
+ truncates bigint
+
+
+ Number of truncates for this SLRU
+ |
+ stats_reset timestamp with time zone
+
+
+ Time at which these statistics were last reset
+ |
28.2.25. Statistics Functions #
+ Other ways of looking at the statistics can be set up by writing
+ queries that use the same underlying statistics access functions used by
+ the standard views shown above. For details such as the functions' names,
+ consult the definitions of the standard views. (For example, in
+ psql you could issue \d+ pg_stat_activity.)
+ The access functions for per-database statistics take a database OID as an
+ argument to identify which database to report on.
+ The per-table and per-index functions take a table or index OID.
+ The functions for per-function statistics take a function OID.
+ Note that only tables, indexes, and functions in the current database
+ can be seen with these functions.
+
+ Additional functions related to the cumulative statistics system are listed
+ in Table 28.35.
+
Table 28.35. Additional Statistics Functions
+ Function
+
+
+ Description
+ |
|---|
+ pg_backend_pid ()
+ → integer
+
+
+ Returns the process ID of the server process attached to the current
+ session.
+ |
+
+ pg_stat_get_activity ( integer )
+ → setof record
+
+
+ Returns a record of information about the backend with the specified
+ process ID, or one record for each active backend in the system
+ if NULL is specified. The fields returned are a
+ subset of those in the pg_stat_activity view.
+ |
+
+ pg_stat_get_snapshot_timestamp ()
+ → timestamp with time zone
+
+
+ Returns the timestamp of the current statistics snapshot, or NULL if
+ no statistics snapshot has been taken. A snapshot is taken the first
+ time cumulative statistics are accessed in a transaction if
+ stats_fetch_consistency is set to
+ snapshot
+ |
+
+ pg_stat_get_xact_blocks_fetched ( oid )
+ → bigint
+
+
+ Returns the number of block read requests for table or index, in the
+ current transaction. This number minus
+ pg_stat_get_xact_blocks_hit gives the number of
+ kernel read() calls; the number of actual
+ physical reads is usually lower due to kernel-level buffering.
+ |
+
+ pg_stat_get_xact_blocks_hit ( oid )
+ → bigint
+
+
+ Returns the number of block read requests for table or index, in the
+ current transaction, found in cache (not triggering kernel
+ read() calls).
+ |
+
+ pg_stat_clear_snapshot ()
+ → void
+
+
+ Discards the current statistics snapshot or cached information.
+ |
+
+ pg_stat_reset ()
+ → void
+
+
+ Resets all statistics counters for the current database to zero.
+
+
+ This function is restricted to superusers by default, but other users
+ can be granted EXECUTE to run the function.
+ |
+
+ pg_stat_reset_shared ( text )
+ → void
+
+
+ Resets some cluster-wide statistics counters to zero, depending on the
+ argument. The argument can be bgwriter to reset
+ all the counters shown in
+ the pg_stat_bgwriter
+ view, archiver to reset all the counters shown in
+ the pg_stat_archiver view,
+ io to reset all the counters shown in the
+ pg_stat_io view,
+ wal to reset all the counters shown in the
+ pg_stat_wal view or
+ recovery_prefetch to reset all the counters shown
+ in the pg_stat_recovery_prefetch view.
+
+
+ This function is restricted to superusers by default, but other users
+ can be granted EXECUTE to run the function.
+ |
+
+ pg_stat_reset_single_table_counters ( oid )
+ → void
+
+
+ Resets statistics for a single table or index in the current database
+ or shared across all databases in the cluster to zero.
+
+
+ This function is restricted to superusers by default, but other users
+ can be granted EXECUTE to run the function.
+ |
+
+ pg_stat_reset_single_function_counters ( oid )
+ → void
+
+
+ Resets statistics for a single function in the current database to
+ zero.
+
+
+ This function is restricted to superusers by default, but other users
+ can be granted EXECUTE to run the function.
+ |
+
+ pg_stat_reset_slru ( text )
+ → void
+
+
+ Resets statistics to zero for a single SLRU cache, or for all SLRUs in
+ the cluster. If the argument is NULL, all counters shown in
+ the pg_stat_slru view for all SLRU caches are
+ reset. The argument can be one of
+ CommitTs,
+ MultiXactMember,
+ MultiXactOffset,
+ Notify,
+ Serial,
+ Subtrans, or
+ Xact
+ to reset the counters for only that entry.
+ If the argument is other (or indeed, any
+ unrecognized name), then the counters for all other SLRU caches, such
+ as extension-defined caches, are reset.
+
+
+ This function is restricted to superusers by default, but other users
+ can be granted EXECUTE to run the function.
+ |
+
+ pg_stat_reset_replication_slot ( text )
+ → void
+
+
+ Resets statistics of the replication slot defined by the argument. If
+ the argument is NULL, resets statistics for all
+ the replication slots.
+
+
+ This function is restricted to superusers by default, but other users
+ can be granted EXECUTE to run the function.
+ |
+
+ pg_stat_reset_subscription_stats ( oid )
+ → void
+
+
+ Resets statistics for a single subscription shown in the
+ pg_stat_subscription_stats view to zero. If
+ the argument is NULL, reset statistics for all
+ subscriptions.
+
+
+ This function is restricted to superusers by default, but other users
+ can be granted EXECUTE to run the function.
+ |
Warning
+ Using pg_stat_reset() also resets counters that
+ autovacuum uses to determine when to trigger a vacuum or an analyze.
+ Resetting these counters can cause autovacuum to not perform necessary
+ work, which can cause problems such as table bloat or out-dated
+ table statistics. A database-wide ANALYZE is
+ recommended after the statistics have been reset.
+
+ pg_stat_get_activity, the underlying function of
+ the pg_stat_activity view, returns a set of records
+ containing all the available information about each backend process.
+ Sometimes it may be more convenient to obtain just a subset of this
+ information. In such cases, another set of per-backend statistics
+ access functions can be used; these are shown in Table 28.36.
+ These access functions use the session's backend ID number, which is a
+ small positive integer that is distinct from the backend ID of any
+ concurrent session, although a session's ID can be recycled as soon as
+ it exits. The backend ID is used, among other things, to identify the
+ session's temporary schema if it has one.
+ The function pg_stat_get_backend_idset provides a
+ convenient way to list all the active backends' ID numbers for
+ invoking these functions. For example, to show the PIDs and
+ current queries of all backends:
+
+
+SELECT pg_stat_get_backend_pid(backendid) AS pid,
+ pg_stat_get_backend_activity(backendid) AS query
+FROM pg_stat_get_backend_idset() AS backendid;
+
+
Table 28.36. Per-Backend Statistics Functions
+ Function
+
+
+ Description
+ |
|---|
+
+ pg_stat_get_backend_activity ( integer )
+ → text
+
+
+ Returns the text of this backend's most recent query.
+ |
+
+ pg_stat_get_backend_activity_start ( integer )
+ → timestamp with time zone
+
+
+ Returns the time when the backend's most recent query was started.
+ |
+
+ pg_stat_get_backend_client_addr ( integer )
+ → inet
+
+
+ Returns the IP address of the client connected to this backend.
+ |
+
+ pg_stat_get_backend_client_port ( integer )
+ → integer
+
+
+ Returns the TCP port number that the client is using for communication.
+ |
+
+ pg_stat_get_backend_dbid ( integer )
+ → oid
+
+
+ Returns the OID of the database this backend is connected to.
+ |
+
+ pg_stat_get_backend_idset ()
+ → setof integer
+
+
+ Returns the set of currently active backend ID numbers.
+ |
+
+ pg_stat_get_backend_pid ( integer )
+ → integer
+
+
+ Returns the process ID of this backend.
+ |
+
+ pg_stat_get_backend_start ( integer )
+ → timestamp with time zone
+
+
+ Returns the time when this process was started.
+ |
+
+ pg_stat_get_backend_subxact ( integer )
+ → record
+
+
+ Returns a record of information about the subtransactions of the
+ backend with the specified ID.
+ The fields returned are subxact_count, which
+ is the number of subtransactions in the backend's subtransaction cache,
+ and subxact_overflow, which indicates whether
+ the backend's subtransaction cache is overflowed or not.
+ |
+
+ pg_stat_get_backend_userid ( integer )
+ → oid
+
+
+ Returns the OID of the user logged into this backend.
+ |
+
+ pg_stat_get_backend_wait_event ( integer )
+ → text
+
+
+ Returns the wait event name if this backend is currently waiting,
+ otherwise NULL. See Table 28.5 through
+ Table 28.13.
+ |
+
+ pg_stat_get_backend_wait_event_type ( integer )
+ → text
+
+
+ Returns the wait event type name if this backend is currently waiting,
+ otherwise NULL. See Table 28.4 for details.
+ |
+
+ pg_stat_get_backend_xact_start ( integer )
+ → timestamp with time zone
+
+
+ Returns the time when the backend's current transaction was started.
+ |
Chapter 28. Monitoring Database Activity
+ A database administrator frequently wonders, “What is the system
+ doing right now?”
+ This chapter discusses how to find that out.
+
+ Several tools are available for monitoring database activity and
+ analyzing performance. Most of this chapter is devoted to describing
+ PostgreSQL's cumulative statistics system,
+ but one should not neglect regular Unix monitoring programs such as
+ ps, top, iostat, and vmstat.
+ Also, once one has identified a
+ poorly-performing query, further investigation might be needed using
+ PostgreSQL's EXPLAIN command.
+ Section 14.1 discusses EXPLAIN
+ and other methods for understanding the behavior of an individual
+ query.
+
24.3. Character Set Support #
+ The character set support in PostgreSQL
+ allows you to store text in a variety of character sets (also called
+ encodings), including
+ single-byte character sets such as the ISO 8859 series and
+ multiple-byte character sets such as EUC (Extended Unix
+ Code), UTF-8, and Mule internal code. All supported character sets
+ can be used transparently by clients, but a few are not supported
+ for use within the server (that is, as a server-side encoding).
+ The default character set is selected while
+ initializing your PostgreSQL database
+ cluster using initdb. It can be overridden when you
+ create a database, so you can have multiple
+ databases each with a different character set.
+
+ An important restriction, however, is that each database's character set
+ must be compatible with the database's LC_CTYPE (character
+ classification) and LC_COLLATE (string sort order) locale
+ settings. For C or
+ POSIX locale, any character set is allowed, but for other
+ libc-provided locales there is only one character set that will work
+ correctly.
+ (On Windows, however, UTF-8 encoding can be used with any locale.)
+ If you have ICU support configured, ICU-provided locales can be used
+ with most but not all server-side encodings.
+
24.3.1. Supported Character Sets #
+ Table 24.3 shows the character sets available
+ for use in PostgreSQL.
+
Table 24.3. PostgreSQL Character Sets
| Name | Description | Language | Server? | ICU? | Bytes/Char | Aliases |
|---|
BIG5 | Big Five | Traditional Chinese | No | No | 1–2 | WIN950, Windows950 |
EUC_CN | Extended UNIX Code-CN | Simplified Chinese | Yes | Yes | 1–3 | |
EUC_JP | Extended UNIX Code-JP | Japanese | Yes | Yes | 1–3 | |
EUC_JIS_2004 | Extended UNIX Code-JP, JIS X 0213 | Japanese | Yes | No | 1–3 | |
EUC_KR | Extended UNIX Code-KR | Korean | Yes | Yes | 1–3 | |
EUC_TW | Extended UNIX Code-TW | Traditional Chinese, Taiwanese | Yes | Yes | 1–3 | |
GB18030 | National Standard | Chinese | No | No | 1–4 | |
GBK | Extended National Standard | Simplified Chinese | No | No | 1–2 | WIN936, Windows936 |
ISO_8859_5 | ISO 8859-5, ECMA 113 | Latin/Cyrillic | Yes | Yes | 1 | |
ISO_8859_6 | ISO 8859-6, ECMA 114 | Latin/Arabic | Yes | Yes | 1 | |
ISO_8859_7 | ISO 8859-7, ECMA 118 | Latin/Greek | Yes | Yes | 1 | |
ISO_8859_8 | ISO 8859-8, ECMA 121 | Latin/Hebrew | Yes | Yes | 1 | |
JOHAB | JOHAB | Korean (Hangul) | No | No | 1–3 | |
KOI8R | KOI8-R | Cyrillic (Russian) | Yes | Yes | 1 | KOI8 |
KOI8U | KOI8-U | Cyrillic (Ukrainian) | Yes | Yes | 1 | |
LATIN1 | ISO 8859-1, ECMA 94 | Western European | Yes | Yes | 1 | ISO88591 |
LATIN2 | ISO 8859-2, ECMA 94 | Central European | Yes | Yes | 1 | ISO88592 |
LATIN3 | ISO 8859-3, ECMA 94 | South European | Yes | Yes | 1 | ISO88593 |
LATIN4 | ISO 8859-4, ECMA 94 | North European | Yes | Yes | 1 | ISO88594 |
LATIN5 | ISO 8859-9, ECMA 128 | Turkish | Yes | Yes | 1 | ISO88599 |
LATIN6 | ISO 8859-10, ECMA 144 | Nordic | Yes | Yes | 1 | ISO885910 |
LATIN7 | ISO 8859-13 | Baltic | Yes | Yes | 1 | ISO885913 |
LATIN8 | ISO 8859-14 | Celtic | Yes | Yes | 1 | ISO885914 |
LATIN9 | ISO 8859-15 | LATIN1 with Euro and accents | Yes | Yes | 1 | ISO885915 |
LATIN10 | ISO 8859-16, ASRO SR 14111 | Romanian | Yes | No | 1 | ISO885916 |
MULE_INTERNAL | Mule internal code | Multilingual Emacs | Yes | No | 1–4 | |
SJIS | Shift JIS | Japanese | No | No | 1–2 | Mskanji, ShiftJIS, WIN932, Windows932 |
SHIFT_JIS_2004 | Shift JIS, JIS X 0213 | Japanese | No | No | 1–2 | |
SQL_ASCII | unspecified (see text) | any | Yes | No | 1 | |
UHC | Unified Hangul Code | Korean | No | No | 1–2 | WIN949, Windows949 |
UTF8 | Unicode, 8-bit | all | Yes | Yes | 1–4 | Unicode |
WIN866 | Windows CP866 | Cyrillic | Yes | Yes | 1 | ALT |
WIN874 | Windows CP874 | Thai | Yes | No | 1 | |
WIN1250 | Windows CP1250 | Central European | Yes | Yes | 1 | |
WIN1251 | Windows CP1251 | Cyrillic | Yes | Yes | 1 | WIN |
WIN1252 | Windows CP1252 | Western European | Yes | Yes | 1 | |
WIN1253 | Windows CP1253 | Greek | Yes | Yes | 1 | |
WIN1254 | Windows CP1254 | Turkish | Yes | Yes | 1 | |
WIN1255 | Windows CP1255 | Hebrew | Yes | Yes | 1 | |
WIN1256 | Windows CP1256 | Arabic | Yes | Yes | 1 | |
WIN1257 | Windows CP1257 | Baltic | Yes | Yes | 1 | |
WIN1258 | Windows CP1258 | Vietnamese | Yes | Yes | 1 | ABC, TCVN, TCVN5712, VSCII |
+ Not all client APIs support all the listed character sets. For example, the
+ PostgreSQL
+ JDBC driver does not support MULE_INTERNAL, LATIN6,
+ LATIN8, and LATIN10.
+
+ The SQL_ASCII setting behaves considerably differently
+ from the other settings. When the server character set is
+ SQL_ASCII, the server interprets byte values 0–127
+ according to the ASCII standard, while byte values 128–255 are taken
+ as uninterpreted characters. No encoding conversion will be done when
+ the setting is SQL_ASCII. Thus, this setting is not so
+ much a declaration that a specific encoding is in use, as a declaration
+ of ignorance about the encoding. In most cases, if you are
+ working with any non-ASCII data, it is unwise to use the
+ SQL_ASCII setting because
+ PostgreSQL will be unable to help you by
+ converting or validating non-ASCII characters.
+
24.3.2. Setting the Character Set #
+ initdb defines the default character set (encoding)
+ for a PostgreSQL cluster. For example,
+
+
+initdb -E EUC_JP
+
+
+ sets the default character set to
+ EUC_JP (Extended Unix Code for Japanese). You
+ can use --encoding instead of
+ -E if you prefer longer option strings.
+ If no -E or --encoding option is
+ given, initdb attempts to determine the appropriate
+ encoding to use based on the specified or default locale.
+
+ You can specify a non-default encoding at database creation time,
+ provided that the encoding is compatible with the selected locale:
+
+
+createdb -E EUC_KR -T template0 --lc-collate=ko_KR.euckr --lc-ctype=ko_KR.euckr korean
+
+
+ This will create a database named korean that
+ uses the character set EUC_KR, and locale ko_KR.
+ Another way to accomplish this is to use this SQL command:
+
+
+CREATE DATABASE korean WITH ENCODING 'EUC_KR' LC_COLLATE='ko_KR.euckr' LC_CTYPE='ko_KR.euckr' TEMPLATE=template0;
+
+
+ Notice that the above commands specify copying the template0
+ database. When copying any other database, the encoding and locale
+ settings cannot be changed from those of the source database, because
+ that might result in corrupt data. For more information see
+ Section 23.3.
+
+ The encoding for a database is stored in the system catalog
+ pg_database. You can see it by using the
+ psql -l option or the
+ \l command.
+
+
+$ psql -l
+ List of databases
+ Name | Owner | Encoding | Collation | Ctype | Access Privileges
+-----------+----------+-----------+-------------+-------------+-------------------------------------
+ clocaledb | hlinnaka | SQL_ASCII | C | C |
+ englishdb | hlinnaka | UTF8 | en_GB.UTF8 | en_GB.UTF8 |
+ japanese | hlinnaka | UTF8 | ja_JP.UTF8 | ja_JP.UTF8 |
+ korean | hlinnaka | EUC_KR | ko_KR.euckr | ko_KR.euckr |
+ postgres | hlinnaka | UTF8 | fi_FI.UTF8 | fi_FI.UTF8 |
+ template0 | hlinnaka | UTF8 | fi_FI.UTF8 | fi_FI.UTF8 | {=c/hlinnaka,hlinnaka=CTc/hlinnaka}
+ template1 | hlinnaka | UTF8 | fi_FI.UTF8 | fi_FI.UTF8 | {=c/hlinnaka,hlinnaka=CTc/hlinnaka}
+(7 rows)
+
+
Important
+ On most modern operating systems, PostgreSQL
+ can determine which character set is implied by the LC_CTYPE
+ setting, and it will enforce that only the matching database encoding is
+ used. On older systems it is your responsibility to ensure that you use
+ the encoding expected by the locale you have selected. A mistake in
+ this area is likely to lead to strange behavior of locale-dependent
+ operations such as sorting.
+
+ PostgreSQL will allow superusers to create
+ databases with SQL_ASCII encoding even when
+ LC_CTYPE is not C or POSIX. As noted
+ above, SQL_ASCII does not enforce that the data stored in
+ the database has any particular encoding, and so this choice poses risks
+ of locale-dependent misbehavior. Using this combination of settings is
+ deprecated and may someday be forbidden altogether.
+
24.3.3. Automatic Character Set Conversion Between Server and Client #
+ PostgreSQL supports automatic character
+ set conversion between server and client for many combinations of
+ character sets (Section 24.3.4
+ shows which ones).
+
+ To enable automatic character set conversion, you have to
+ tell PostgreSQL the character set
+ (encoding) you would like to use in the client. There are several
+ ways to accomplish this:
+
+
+ Using the \encoding command in
+ psql.
+ \encoding allows you to change client
+ encoding on the fly. For
+ example, to change the encoding to SJIS, type:
+
+
+\encoding SJIS
+
+
+ libpq (Section 34.11) has functions to control the client encoding.
+
+ Using SET client_encoding TO.
+
+ Setting the client encoding can be done with this SQL command:
+
+
+SET CLIENT_ENCODING TO 'value';
+
+
+ Also you can use the standard SQL syntax SET NAMES
+ for this purpose:
+
+
+SET NAMES 'value';
+
+
+ To query the current client encoding:
+
+
+SHOW client_encoding;
+
+
+ To return to the default encoding:
+
+
+RESET client_encoding;
+
+
+ Using PGCLIENTENCODING. If the environment variable
+ PGCLIENTENCODING is defined in the client's
+ environment, that client encoding is automatically selected
+ when a connection to the server is made. (This can
+ subsequently be overridden using any of the other methods
+ mentioned above.)
+
+ Using the configuration variable client_encoding. If the
+ client_encoding variable is set, that client
+ encoding is automatically selected when a connection to the
+ server is made. (This can subsequently be overridden using any
+ of the other methods mentioned above.)
+
+
+ If the conversion of a particular character is not possible
+ — suppose you chose EUC_JP for the
+ server and LATIN1 for the client, and some
+ Japanese characters are returned that do not have a representation in
+ LATIN1 — an error is reported.
+
+ If the client character set is defined as SQL_ASCII,
+ encoding conversion is disabled, regardless of the server's character
+ set. (However, if the server's character set is
+ not SQL_ASCII, the server will still check that
+ incoming data is valid for that encoding; so the net effect is as
+ though the client character set were the same as the server's.)
+ Just as for the server, use of SQL_ASCII is unwise
+ unless you are working with all-ASCII data.
+
24.3.4. Available Character Set Conversions #
+ PostgreSQL allows conversion between any
+ two character sets for which a conversion function is listed in the
+ pg_conversion
+ system catalog. PostgreSQL comes with
+ some predefined conversions, as summarized in
+ Table 24.4 and shown in more
+ detail in Table 24.5. You can
+ create a new conversion using the SQL command
+ CREATE CONVERSION. (To be used for automatic
+ client/server conversions, a conversion must be marked
+ as “default” for its character set pair.)
+
Table 24.4. Built-in Client/Server Character Set Conversions
| Server Character Set | Available Client Character Sets |
|---|
BIG5 | not supported as a server encoding
+ |
EUC_CN | EUC_CN,
+ MULE_INTERNAL,
+ UTF8
+ |
EUC_JP | EUC_JP,
+ MULE_INTERNAL,
+ SJIS,
+ UTF8
+ |
EUC_JIS_2004 | EUC_JIS_2004,
+ SHIFT_JIS_2004,
+ UTF8
+ |
EUC_KR | EUC_KR,
+ MULE_INTERNAL,
+ UTF8
+ |
EUC_TW | EUC_TW,
+ BIG5,
+ MULE_INTERNAL,
+ UTF8
+ |
GB18030 | not supported as a server encoding
+ |
GBK | not supported as a server encoding
+ |
ISO_8859_5 | ISO_8859_5,
+ KOI8R,
+ MULE_INTERNAL,
+ UTF8,
+ WIN866,
+ WIN1251
+ |
ISO_8859_6 | ISO_8859_6,
+ UTF8
+ |
ISO_8859_7 | ISO_8859_7,
+ UTF8
+ |
ISO_8859_8 | ISO_8859_8,
+ UTF8
+ |
JOHAB | not supported as a server encoding
+ |
KOI8R | KOI8R,
+ ISO_8859_5,
+ MULE_INTERNAL,
+ UTF8,
+ WIN866,
+ WIN1251
+ |
KOI8U | KOI8U,
+ UTF8
+ |
LATIN1 | LATIN1,
+ MULE_INTERNAL,
+ UTF8
+ |
LATIN2 | LATIN2,
+ MULE_INTERNAL,
+ UTF8,
+ WIN1250
+ |
LATIN3 | LATIN3,
+ MULE_INTERNAL,
+ UTF8
+ |
LATIN4 | LATIN4,
+ MULE_INTERNAL,
+ UTF8
+ |
LATIN5 | LATIN5,
+ UTF8
+ |
LATIN6 | LATIN6,
+ UTF8
+ |
LATIN7 | LATIN7,
+ UTF8
+ |
LATIN8 | LATIN8,
+ UTF8
+ |
LATIN9 | LATIN9,
+ UTF8
+ |
LATIN10 | LATIN10,
+ UTF8
+ |
MULE_INTERNAL | MULE_INTERNAL,
+ BIG5,
+ EUC_CN,
+ EUC_JP,
+ EUC_KR,
+ EUC_TW,
+ ISO_8859_5,
+ KOI8R,
+ LATIN1 to LATIN4,
+ SJIS,
+ WIN866,
+ WIN1250,
+ WIN1251
+ |
SJIS | not supported as a server encoding
+ |
SHIFT_JIS_2004 | not supported as a server encoding
+ |
SQL_ASCII | any (no conversion will be performed)
+ |
UHC | not supported as a server encoding
+ |
UTF8 | all supported encodings
+ |
WIN866 | WIN866,
+ ISO_8859_5,
+ KOI8R,
+ MULE_INTERNAL,
+ UTF8,
+ WIN1251
+ |
WIN874 | WIN874,
+ UTF8
+ |
WIN1250 | WIN1250,
+ LATIN2,
+ MULE_INTERNAL,
+ UTF8
+ |
WIN1251 | WIN1251,
+ ISO_8859_5,
+ KOI8R,
+ MULE_INTERNAL,
+ UTF8,
+ WIN866
+ |
WIN1252 | WIN1252,
+ UTF8
+ |
WIN1253 | WIN1253,
+ UTF8
+ |
WIN1254 | WIN1254,
+ UTF8
+ |
WIN1255 | WIN1255,
+ UTF8
+ |
WIN1256 | WIN1256,
+ UTF8
+ |
WIN1257 | WIN1257,
+ UTF8
+ |
WIN1258 | WIN1258,
+ UTF8
+ |
Table 24.5. All Built-in Character Set Conversions
| Conversion Name
+
+ | Source Encoding | Destination Encoding |
|---|
big5_to_euc_tw | BIG5 | EUC_TW |
big5_to_mic | BIG5 | MULE_INTERNAL |
big5_to_utf8 | BIG5 | UTF8 |
euc_cn_to_mic | EUC_CN | MULE_INTERNAL |
euc_cn_to_utf8 | EUC_CN | UTF8 |
euc_jp_to_mic | EUC_JP | MULE_INTERNAL |
euc_jp_to_sjis | EUC_JP | SJIS |
euc_jp_to_utf8 | EUC_JP | UTF8 |
euc_kr_to_mic | EUC_KR | MULE_INTERNAL |
euc_kr_to_utf8 | EUC_KR | UTF8 |
euc_tw_to_big5 | EUC_TW | BIG5 |
euc_tw_to_mic | EUC_TW | MULE_INTERNAL |
euc_tw_to_utf8 | EUC_TW | UTF8 |
gb18030_to_utf8 | GB18030 | UTF8 |
gbk_to_utf8 | GBK | UTF8 |
iso_8859_10_to_utf8 | LATIN6 | UTF8 |
iso_8859_13_to_utf8 | LATIN7 | UTF8 |
iso_8859_14_to_utf8 | LATIN8 | UTF8 |
iso_8859_15_to_utf8 | LATIN9 | UTF8 |
iso_8859_16_to_utf8 | LATIN10 | UTF8 |
iso_8859_1_to_mic | LATIN1 | MULE_INTERNAL |
iso_8859_1_to_utf8 | LATIN1 | UTF8 |
iso_8859_2_to_mic | LATIN2 | MULE_INTERNAL |
iso_8859_2_to_utf8 | LATIN2 | UTF8 |
iso_8859_2_to_windows_1250 | LATIN2 | WIN1250 |
iso_8859_3_to_mic | LATIN3 | MULE_INTERNAL |
iso_8859_3_to_utf8 | LATIN3 | UTF8 |
iso_8859_4_to_mic | LATIN4 | MULE_INTERNAL |
iso_8859_4_to_utf8 | LATIN4 | UTF8 |
iso_8859_5_to_koi8_r | ISO_8859_5 | KOI8R |
iso_8859_5_to_mic | ISO_8859_5 | MULE_INTERNAL |
iso_8859_5_to_utf8 | ISO_8859_5 | UTF8 |
iso_8859_5_to_windows_1251 | ISO_8859_5 | WIN1251 |
iso_8859_5_to_windows_866 | ISO_8859_5 | WIN866 |
iso_8859_6_to_utf8 | ISO_8859_6 | UTF8 |
iso_8859_7_to_utf8 | ISO_8859_7 | UTF8 |
iso_8859_8_to_utf8 | ISO_8859_8 | UTF8 |
iso_8859_9_to_utf8 | LATIN5 | UTF8 |
johab_to_utf8 | JOHAB | UTF8 |
koi8_r_to_iso_8859_5 | KOI8R | ISO_8859_5 |
koi8_r_to_mic | KOI8R | MULE_INTERNAL |
koi8_r_to_utf8 | KOI8R | UTF8 |
koi8_r_to_windows_1251 | KOI8R | WIN1251 |
koi8_r_to_windows_866 | KOI8R | WIN866 |
koi8_u_to_utf8 | KOI8U | UTF8 |
mic_to_big5 | MULE_INTERNAL | BIG5 |
mic_to_euc_cn | MULE_INTERNAL | EUC_CN |
mic_to_euc_jp | MULE_INTERNAL | EUC_JP |
mic_to_euc_kr | MULE_INTERNAL | EUC_KR |
mic_to_euc_tw | MULE_INTERNAL | EUC_TW |
mic_to_iso_8859_1 | MULE_INTERNAL | LATIN1 |
mic_to_iso_8859_2 | MULE_INTERNAL | LATIN2 |
mic_to_iso_8859_3 | MULE_INTERNAL | LATIN3 |
mic_to_iso_8859_4 | MULE_INTERNAL | LATIN4 |
mic_to_iso_8859_5 | MULE_INTERNAL | ISO_8859_5 |
mic_to_koi8_r | MULE_INTERNAL | KOI8R |
mic_to_sjis | MULE_INTERNAL | SJIS |
mic_to_windows_1250 | MULE_INTERNAL | WIN1250 |
mic_to_windows_1251 | MULE_INTERNAL | WIN1251 |
mic_to_windows_866 | MULE_INTERNAL | WIN866 |
sjis_to_euc_jp | SJIS | EUC_JP |
sjis_to_mic | SJIS | MULE_INTERNAL |
sjis_to_utf8 | SJIS | UTF8 |
windows_1258_to_utf8 | WIN1258 | UTF8 |
uhc_to_utf8 | UHC | UTF8 |
utf8_to_big5 | UTF8 | BIG5 |
utf8_to_euc_cn | UTF8 | EUC_CN |
utf8_to_euc_jp | UTF8 | EUC_JP |
utf8_to_euc_kr | UTF8 | EUC_KR |
utf8_to_euc_tw | UTF8 | EUC_TW |
utf8_to_gb18030 | UTF8 | GB18030 |
utf8_to_gbk | UTF8 | GBK |
utf8_to_iso_8859_1 | UTF8 | LATIN1 |
utf8_to_iso_8859_10 | UTF8 | LATIN6 |
utf8_to_iso_8859_13 | UTF8 | LATIN7 |
utf8_to_iso_8859_14 | UTF8 | LATIN8 |
utf8_to_iso_8859_15 | UTF8 | LATIN9 |
utf8_to_iso_8859_16 | UTF8 | LATIN10 |
utf8_to_iso_8859_2 | UTF8 | LATIN2 |
utf8_to_iso_8859_3 | UTF8 | LATIN3 |
utf8_to_iso_8859_4 | UTF8 | LATIN4 |
utf8_to_iso_8859_5 | UTF8 | ISO_8859_5 |
utf8_to_iso_8859_6 | UTF8 | ISO_8859_6 |
utf8_to_iso_8859_7 | UTF8 | ISO_8859_7 |
utf8_to_iso_8859_8 | UTF8 | ISO_8859_8 |
utf8_to_iso_8859_9 | UTF8 | LATIN5 |
utf8_to_johab | UTF8 | JOHAB |
utf8_to_koi8_r | UTF8 | KOI8R |
utf8_to_koi8_u | UTF8 | KOI8U |
utf8_to_sjis | UTF8 | SJIS |
utf8_to_windows_1258 | UTF8 | WIN1258 |
utf8_to_uhc | UTF8 | UHC |
utf8_to_windows_1250 | UTF8 | WIN1250 |
utf8_to_windows_1251 | UTF8 | WIN1251 |
utf8_to_windows_1252 | UTF8 | WIN1252 |
utf8_to_windows_1253 | UTF8 | WIN1253 |
utf8_to_windows_1254 | UTF8 | WIN1254 |
utf8_to_windows_1255 | UTF8 | WIN1255 |
utf8_to_windows_1256 | UTF8 | WIN1256 |
utf8_to_windows_1257 | UTF8 | WIN1257 |
utf8_to_windows_866 | UTF8 | WIN866 |
utf8_to_windows_874 | UTF8 | WIN874 |
windows_1250_to_iso_8859_2 | WIN1250 | LATIN2 |
windows_1250_to_mic | WIN1250 | MULE_INTERNAL |
windows_1250_to_utf8 | WIN1250 | UTF8 |
windows_1251_to_iso_8859_5 | WIN1251 | ISO_8859_5 |
windows_1251_to_koi8_r | WIN1251 | KOI8R |
windows_1251_to_mic | WIN1251 | MULE_INTERNAL |
windows_1251_to_utf8 | WIN1251 | UTF8 |
windows_1251_to_windows_866 | WIN1251 | WIN866 |
windows_1252_to_utf8 | WIN1252 | UTF8 |
windows_1256_to_utf8 | WIN1256 | UTF8 |
windows_866_to_iso_8859_5 | WIN866 | ISO_8859_5 |
windows_866_to_koi8_r | WIN866 | KOI8R |
windows_866_to_mic | WIN866 | MULE_INTERNAL |
windows_866_to_utf8 | WIN866 | UTF8 |
windows_866_to_windows_1251 | WIN866 | WIN |
windows_874_to_utf8 | WIN874 | UTF8 |
euc_jis_2004_to_utf8 | EUC_JIS_2004 | UTF8 |
utf8_to_euc_jis_2004 | UTF8 | EUC_JIS_2004 |
shift_jis_2004_to_utf8 | SHIFT_JIS_2004 | UTF8 |
utf8_to_shift_jis_2004 | UTF8 | SHIFT_JIS_2004 |
euc_jis_2004_to_shift_jis_2004 | EUC_JIS_2004 | SHIFT_JIS_2004 |
shift_jis_2004_to_euc_jis_2004 | SHIFT_JIS_2004 | EUC_JIS_2004 |
24.3.5. Further Reading #
+ These are good sources to start learning about various kinds of encoding
+ systems.
+
+
- CJKV Information Processing: Chinese, Japanese, Korean & Vietnamese Computing
+ Contains detailed explanations of EUC_JP,
+ EUC_CN, EUC_KR,
+ EUC_TW.
+
- https://www.unicode.org/
+ The web site of the Unicode Consortium.
+
- RFC 3629
+ UTF-8 (8-bit UCS/Unicode Transformation
+ Format) is defined here.
+
+
76.2. Multivariate Statistics Examples #
76.2.1. Functional Dependencies #
+ Multivariate correlation can be demonstrated with a very simple data set
+ — a table with two columns, both containing the same values:
+
+
+CREATE TABLE t (a INT, b INT);
+INSERT INTO t SELECT i % 100, i % 100 FROM generate_series(1, 10000) s(i);
+ANALYZE t;
+
+
+ As explained in Section 14.2, the planner can determine
+ cardinality of t using the number of pages and
+ rows obtained from pg_class:
+
+
+SELECT relpages, reltuples FROM pg_class WHERE relname = 't';
+
+ relpages | reltuples
+----------+-----------
+ 45 | 10000
+
+
+ The data distribution is very simple; there are only 100 distinct values
+ in each column, uniformly distributed.
+
+ The following example shows the result of estimating a WHERE
+ condition on the a column:
+
+
+EXPLAIN (ANALYZE, TIMING OFF) SELECT * FROM t WHERE a = 1;
+ QUERY PLAN
+-------------------------------------------------------------------------------
+ Seq Scan on t (cost=0.00..170.00 rows=100 width=8) (actual rows=100 loops=1)
+ Filter: (a = 1)
+ Rows Removed by Filter: 9900
+
+
+ The planner examines the condition and determines the selectivity
+ of this clause to be 1%. By comparing this estimate and the actual
+ number of rows, we see that the estimate is very accurate
+ (in fact exact, as the table is very small). Changing the
+ WHERE condition to use the b column, an
+ identical plan is generated. But observe what happens if we apply the same
+ condition on both columns, combining them with AND:
+
+
+EXPLAIN (ANALYZE, TIMING OFF) SELECT * FROM t WHERE a = 1 AND b = 1;
+ QUERY PLAN
+-----------------------------------------------------------------------------
+ Seq Scan on t (cost=0.00..195.00 rows=1 width=8) (actual rows=100 loops=1)
+ Filter: ((a = 1) AND (b = 1))
+ Rows Removed by Filter: 9900
+
+
+ The planner estimates the selectivity for each condition individually,
+ arriving at the same 1% estimates as above. Then it assumes that the
+ conditions are independent, and so it multiplies their selectivities,
+ producing a final selectivity estimate of just 0.01%.
+ This is a significant underestimate, as the actual number of rows
+ matching the conditions (100) is two orders of magnitude higher.
+
+ This problem can be fixed by creating a statistics object that
+ directs ANALYZE to calculate functional-dependency
+ multivariate statistics on the two columns:
+
+
+CREATE STATISTICS stts (dependencies) ON a, b FROM t;
+ANALYZE t;
+EXPLAIN (ANALYZE, TIMING OFF) SELECT * FROM t WHERE a = 1 AND b = 1;
+ QUERY PLAN
+-------------------------------------------------------------------------------
+ Seq Scan on t (cost=0.00..195.00 rows=100 width=8) (actual rows=100 loops=1)
+ Filter: ((a = 1) AND (b = 1))
+ Rows Removed by Filter: 9900
+
+
76.2.2. Multivariate N-Distinct Counts #
+ A similar problem occurs with estimation of the cardinality of sets of
+ multiple columns, such as the number of groups that would be generated by
+ a GROUP BY clause. When GROUP BY
+ lists a single column, the n-distinct estimate (which is visible as the
+ estimated number of rows returned by the HashAggregate node) is very
+ accurate:
+
+EXPLAIN (ANALYZE, TIMING OFF) SELECT COUNT(*) FROM t GROUP BY a;
+ QUERY PLAN
+-----------------------------------------------------------------------------------------
+ HashAggregate (cost=195.00..196.00 rows=100 width=12) (actual rows=100 loops=1)
+ Group Key: a
+ -> Seq Scan on t (cost=0.00..145.00 rows=10000 width=4) (actual rows=10000 loops=1)
+
+ But without multivariate statistics, the estimate for the number of
+ groups in a query with two columns in GROUP BY, as
+ in the following example, is off by an order of magnitude:
+
+EXPLAIN (ANALYZE, TIMING OFF) SELECT COUNT(*) FROM t GROUP BY a, b;
+ QUERY PLAN
+--------------------------------------------------------------------------------------------
+ HashAggregate (cost=220.00..230.00 rows=1000 width=16) (actual rows=100 loops=1)
+ Group Key: a, b
+ -> Seq Scan on t (cost=0.00..145.00 rows=10000 width=8) (actual rows=10000 loops=1)
+
+ By redefining the statistics object to include n-distinct counts for the
+ two columns, the estimate is much improved:
+
+DROP STATISTICS stts;
+CREATE STATISTICS stts (dependencies, ndistinct) ON a, b FROM t;
+ANALYZE t;
+EXPLAIN (ANALYZE, TIMING OFF) SELECT COUNT(*) FROM t GROUP BY a, b;
+ QUERY PLAN
+--------------------------------------------------------------------------------------------
+ HashAggregate (cost=220.00..221.00 rows=100 width=16) (actual rows=100 loops=1)
+ Group Key: a, b
+ -> Seq Scan on t (cost=0.00..145.00 rows=10000 width=8) (actual rows=10000 loops=1)
+
+
+ As explained in Section 76.2.1, functional
+ dependencies are very cheap and efficient type of statistics, but their
+ main limitation is their global nature (only tracking dependencies at
+ the column level, not between individual column values).
+
+ This section introduces multivariate variant of MCV
+ (most-common values) lists, a straightforward extension of the per-column
+ statistics described in Section 76.1. These
+ statistics address the limitation by storing individual values, but it is
+ naturally more expensive, both in terms of building the statistics in
+ ANALYZE, storage and planning time.
+
+ Let's look at the query from Section 76.2.1
+ again, but this time with a MCV list created on the
+ same set of columns (be sure to drop the functional dependencies, to
+ make sure the planner uses the newly created statistics).
+
+
+DROP STATISTICS stts;
+CREATE STATISTICS stts2 (mcv) ON a, b FROM t;
+ANALYZE t;
+EXPLAIN (ANALYZE, TIMING OFF) SELECT * FROM t WHERE a = 1 AND b = 1;
+ QUERY PLAN
+-------------------------------------------------------------------------------
+ Seq Scan on t (cost=0.00..195.00 rows=100 width=8) (actual rows=100 loops=1)
+ Filter: ((a = 1) AND (b = 1))
+ Rows Removed by Filter: 9900
+
+
+ The estimate is as accurate as with the functional dependencies, mostly
+ thanks to the table being fairly small and having a simple distribution
+ with a low number of distinct values. Before looking at the second query,
+ which was not handled by functional dependencies particularly well,
+ let's inspect the MCV list a bit.
+
+ Inspecting the MCV list is possible using
+ pg_mcv_list_items set-returning function.
+
+
+SELECT m.* FROM pg_statistic_ext join pg_statistic_ext_data on (oid = stxoid),
+ pg_mcv_list_items(stxdmcv) m WHERE stxname = 'stts2';
+ index | values | nulls | frequency | base_frequency
+-------+----------+-------+-----------+----------------
+ 0 | {0, 0} | {f,f} | 0.01 | 0.0001
+ 1 | {1, 1} | {f,f} | 0.01 | 0.0001
+ ...
+ 49 | {49, 49} | {f,f} | 0.01 | 0.0001
+ 50 | {50, 50} | {f,f} | 0.01 | 0.0001
+ ...
+ 97 | {97, 97} | {f,f} | 0.01 | 0.0001
+ 98 | {98, 98} | {f,f} | 0.01 | 0.0001
+ 99 | {99, 99} | {f,f} | 0.01 | 0.0001
+(100 rows)
+
+
+ This confirms there are 100 distinct combinations in the two columns, and
+ all of them are about equally likely (1% frequency for each one). The
+ base frequency is the frequency computed from per-column statistics, as if
+ there were no multi-column statistics. Had there been any null values in
+ either of the columns, this would be identified in the
+ nulls column.
+
+ When estimating the selectivity, the planner applies all the conditions
+ on items in the MCV list, and then sums the frequencies
+ of the matching ones. See mcv_clauselist_selectivity
+ in src/backend/statistics/mcv.c for details.
+
+ Compared to functional dependencies, MCV lists have two
+ major advantages. Firstly, the list stores actual values, making it possible
+ to decide which combinations are compatible.
+
+
+EXPLAIN (ANALYZE, TIMING OFF) SELECT * FROM t WHERE a = 1 AND b = 10;
+ QUERY PLAN
+---------------------------------------------------------------------------
+ Seq Scan on t (cost=0.00..195.00 rows=1 width=8) (actual rows=0 loops=1)
+ Filter: ((a = 1) AND (b = 10))
+ Rows Removed by Filter: 10000
+
+
+ Secondly, MCV lists handle a wider range of clause types,
+ not just equality clauses like functional dependencies. For example,
+ consider the following range query for the same table:
+
+
+EXPLAIN (ANALYZE, TIMING OFF) SELECT * FROM t WHERE a <= 49 AND b > 49;
+ QUERY PLAN
+---------------------------------------------------------------------------
+ Seq Scan on t (cost=0.00..195.00 rows=1 width=8) (actual rows=0 loops=1)
+ Filter: ((a <= 49) AND (b > 49))
+ Rows Removed by Filter: 10000
+
+
+
+ Some DDL commands, currently only TRUNCATE and the
+ table-rewriting forms of ALTER TABLE, are not
+ MVCC-safe. This means that after the truncation or rewrite commits, the
+ table will appear empty to concurrent transactions, if they are using a
+ snapshot taken before the DDL command committed. This will only be an
+ issue for a transaction that did not access the table in question
+ before the DDL command started — any transaction that has done so
+ would hold at least an ACCESS SHARE table lock,
+ which would block the DDL command until that transaction completes.
+ So these commands will not cause any apparent inconsistency in the
+ table contents for successive queries on the target table, but they
+ could cause visible inconsistency between the contents of the target
+ table and other tables in the database.
+
+ Support for the Serializable transaction isolation level has not yet
+ been added to hot standby replication targets (described in
+ Section 27.4). The strictest isolation level currently
+ supported in hot standby mode is Repeatable Read. While performing all
+ permanent database writes within Serializable transactions on the
+ primary will ensure that all standbys will eventually reach a consistent
+ state, a Repeatable Read transaction run on the standby can sometimes
+ see a transient state that is inconsistent with any serial execution
+ of the transactions on the primary.
+
+ Internal access to the system catalogs is not done using the isolation
+ level of the current transaction. This means that newly created database
+ objects such as tables are visible to concurrent Repeatable Read and
+ Serializable transactions, even though the rows they contain are not. In
+ contrast, queries that explicitly examine the system catalogs don't see
+ rows representing concurrently created database objects, in the higher
+ isolation levels.
+
+ PostgreSQL provides a rich set of tools
+ for developers to manage concurrent access to data. Internally,
+ data consistency is maintained by using a multiversion
+ model (Multiversion Concurrency Control, MVCC).
+ This means that each SQL statement sees
+ a snapshot of data (a database version)
+ as it was some
+ time ago, regardless of the current state of the underlying data.
+ This prevents statements from viewing inconsistent data produced
+ by concurrent transactions performing updates on the same
+ data rows, providing transaction isolation
+ for each database session. MVCC, by eschewing
+ the locking methodologies of traditional database systems,
+ minimizes lock contention in order to allow for reasonable
+ performance in multiuser environments.
+
+ The main advantage of using the MVCC model of
+ concurrency control rather than locking is that in
+ MVCC locks acquired for querying (reading) data
+ do not conflict with locks acquired for writing data, and so
+ reading never blocks writing and writing never blocks reading.
+ PostgreSQL maintains this guarantee
+ even when providing the strictest level of transaction
+ isolation through the use of an innovative Serializable
+ Snapshot Isolation (SSI) level.
+
+ Table- and row-level locking facilities are also available in
+ PostgreSQL for applications which don't
+ generally need full transaction isolation and prefer to explicitly
+ manage particular points of conflict. However, proper
+ use of MVCC will generally provide better
+ performance than locks. In addition, application-defined advisory
+ locks provide a mechanism for acquiring locks that are not tied
+ to a single transaction.
+
13.5. Serialization Failure Handling #
+ Both Repeatable Read and Serializable isolation levels can produce
+ errors that are designed to prevent serialization anomalies. As
+ previously stated, applications using these levels must be prepared to
+ retry transactions that fail due to serialization errors. Such an
+ error's message text will vary according to the precise circumstances,
+ but it will always have the SQLSTATE code 40001
+ (serialization_failure).
+
+ It may also be advisable to retry deadlock failures.
+ These have the SQLSTATE code 40P01
+ (deadlock_detected).
+
+ In some cases it is also appropriate to retry unique-key failures,
+ which have SQLSTATE code 23505
+ (unique_violation), and exclusion constraint
+ failures, which have SQLSTATE code 23P01
+ (exclusion_violation). For example, if the
+ application selects a new value for a primary key column after
+ inspecting the currently stored keys, it could get a unique-key
+ failure because another application instance selected the same new key
+ concurrently. This is effectively a serialization failure, but the
+ server will not detect it as such because it cannot “see”
+ the connection between the inserted value and the previous reads.
+ There are also some corner cases in which the server will issue a
+ unique-key or exclusion constraint error even though in principle it
+ has enough information to determine that a serialization problem
+ is the underlying cause. While it's recommendable to just
+ retry serialization_failure errors unconditionally,
+ more care is needed when retrying these other error codes, since they
+ might represent persistent error conditions rather than transient
+ failures.
+
+ It is important to retry the complete transaction, including all logic
+ that decides which SQL to issue and/or which values to use.
+ Therefore, PostgreSQL does not offer an
+ automatic retry facility, since it cannot do so with any guarantee of
+ correctness.
+
+ Transaction retry does not guarantee that the retried transaction will
+ complete; multiple retries may be needed. In cases with very high
+ contention, it is possible that completion of a transaction may take
+ many attempts. In cases involving a conflicting prepared transaction,
+ it may not be possible to make progress until the prepared transaction
+ commits or rolls back.
+
Chapter 13. Concurrency Control
+ This chapter describes the behavior of the
+ PostgreSQL database system when two or
+ more sessions try to access the same data at the same time. The
+ goals in that situation are to allow efficient access for all
+ sessions while maintaining strict data integrity. Every developer
+ of database applications should be familiar with the topics covered
+ in this chapter.
+
57.2. For the Programmer #
+ This section describes how to implement native language support in a
+ program or library that is part of the
+ PostgreSQL distribution.
+ Currently, it only applies to C programs.
+
Adding NLS Support to a Program
+ Insert this code into the start-up sequence of the program:
+
+#ifdef ENABLE_NLS
+#include <locale.h>
+#endif
+
+...
+
+#ifdef ENABLE_NLS
+setlocale(LC_ALL, "");
+bindtextdomain("progname", LOCALEDIR);
+textdomain("progname");
+#endif
+
+ (The progname can actually be chosen
+ freely.)
+
+ Wherever a message that is a candidate for translation is found,
+ a call to gettext() needs to be inserted. E.g.:
+
+fprintf(stderr, "panic level %d\n", lvl);
+
+ would be changed to:
+
+fprintf(stderr, gettext("panic level %d\n"), lvl);
+
+ (gettext is defined as a no-op if NLS support is
+ not configured.)
+
+ This tends to add a lot of clutter. One common shortcut is to use:
+
+#define _(x) gettext(x)
+
+ Another solution is feasible if the program does much of its
+ communication through one or a few functions, such as
+ ereport() in the backend. Then you make this
+ function call gettext internally on all
+ input strings.
+
+ Add a file nls.mk in the directory with the
+ program sources. This file will be read as a makefile. The
+ following variable assignments need to be made here:
+
+
CATALOG_NAME
+ The program name, as provided in the
+ textdomain() call.
+
GETTEXT_FILES
+ List of files that contain translatable strings, i.e., those
+ marked with gettext or an alternative
+ solution. Eventually, this will include nearly all source
+ files of the program. If this list gets too long you can
+ make the first “file” be a +
+ and the second word be a file that contains one file name per
+ line.
+
GETTEXT_TRIGGERS
+ The tools that generate message catalogs for the translators
+ to work on need to know what function calls contain
+ translatable strings. By default, only
+ gettext() calls are known. If you used
+ _ or other identifiers you need to list
+ them here. If the translatable string is not the first
+ argument, the item needs to be of the form
+ func:2 (for the second argument).
+ If you have a function that supports pluralized messages,
+ the item should look like func:1,2
+ (identifying the singular and plural message arguments).
+
+
+ Add a file po/LINGUAS, which will contain the list
+ of provided translations — initially empty.
+
+ The build system will automatically take care of building and
+ installing the message catalogs.
+
57.2.2. Message-Writing Guidelines #
+ Here are some guidelines for writing messages that are easily
+ translatable.
+
+
+ Do not construct sentences at run-time, like:
+
+printf("Files were %s.\n", flag ? "copied" : "removed");
+
+ The word order within the sentence might be different in other
+ languages. Also, even if you remember to call gettext() on
+ each fragment, the fragments might not translate well separately. It's
+ better to duplicate a little code so that each message to be
+ translated is a coherent whole. Only numbers, file names, and
+ such-like run-time variables should be inserted at run time into
+ a message text.
+
+ For similar reasons, this won't work:
+
+printf("copied %d file%s", n, n!=1 ? "s" : "");
+
+ because it assumes how the plural is formed. If you figured you
+ could solve it like this:
+
+if (n==1)
+ printf("copied 1 file");
+else
+ printf("copied %d files", n):
+
+ then be disappointed. Some languages have more than two forms,
+ with some peculiar rules. It's often best to design the message
+ to avoid the issue altogether, for instance like this:
+
+printf("number of copied files: %d", n);
+
+
+ If you really want to construct a properly pluralized message,
+ there is support for this, but it's a bit awkward. When generating
+ a primary or detail error message in ereport(), you can
+ write something like this:
+
+errmsg_plural("copied %d file",
+ "copied %d files",
+ n,
+ n)
+
+ The first argument is the format string appropriate for English
+ singular form, the second is the format string appropriate for
+ English plural form, and the third is the integer control value
+ that determines which plural form to use. Subsequent arguments
+ are formatted per the format string as usual. (Normally, the
+ pluralization control value will also be one of the values to be
+ formatted, so it has to be written twice.) In English it only
+ matters whether n is 1 or not 1, but in other
+ languages there can be many different plural forms. The translator
+ sees the two English forms as a group and has the opportunity to
+ supply multiple substitute strings, with the appropriate one being
+ selected based on the run-time value of n.
+
+ If you need to pluralize a message that isn't going directly to an
+ errmsg or errdetail report, you have to use
+ the underlying function ngettext. See the gettext
+ documentation.
+
+ If you want to communicate something to the translator, such as
+ about how a message is intended to line up with other output,
+ precede the occurrence of the string with a comment that starts
+ with translator, e.g.:
+
+/* translator: This message is not what it seems to be. */
+
+ These comments are copied to the message catalog files so that
+ the translators can see them.
+
+
57.1. For the Translator #
+ PostgreSQL
+ programs (server and client) can issue their messages in
+ your favorite language — if the messages have been translated.
+ Creating and maintaining translated message sets needs the help of
+ people who speak their own language well and want to contribute to
+ the PostgreSQL effort. You do not have to be a
+ programmer at all
+ to do this. This section explains how to help.
+
+ We won't judge your language skills — this section is about
+ software tools. Theoretically, you only need a text editor. But
+ this is only in the unlikely event that you do not want to try out
+ your translated messages. When you configure your source tree, be
+ sure to use the --enable-nls option. This will
+ also check for the libintl library and the
+ msgfmt program, which all end users will need
+ anyway. To try out your work, follow the applicable portions of
+ the installation instructions.
+
+ If you want to start a new translation effort or want to do a
+ message catalog merge (described later), you will need the
+ programs xgettext and
+ msgmerge, respectively, in a GNU-compatible
+ implementation. Later, we will try to arrange it so that if you
+ use a packaged source distribution, you won't need
+ xgettext. (If working from Git, you will still need
+ it.) GNU Gettext 0.10.36 or later is currently recommended.
+
+ Your local gettext implementation should come with its own
+ documentation. Some of that is probably duplicated in what
+ follows, but for additional details you should look there.
+
+ The pairs of original (English) messages and their (possibly)
+ translated equivalents are kept in message
+ catalogs, one for each program (although related
+ programs can share a message catalog) and for each target
+ language. There are two file formats for message catalogs: The
+ first is the “PO” file (for Portable Object), which
+ is a plain text file with special syntax that translators edit.
+ The second is the “MO” file (for Machine Object),
+ which is a binary file generated from the respective PO file and
+ is used while the internationalized program is run. Translators
+ do not deal with MO files; in fact hardly anyone does.
+
+ The extension of the message catalog file is to no surprise either
+ .po or .mo. The base
+ name is either the name of the program it accompanies, or the
+ language the file is for, depending on the situation. This is a
+ bit confusing. Examples are psql.po (PO file
+ for psql) or fr.mo (MO file in French).
+
+ The file format of the PO files is illustrated here:
+
+# comment
+
+msgid "original string"
+msgstr "translated string"
+
+msgid "more original"
+msgstr "another translated"
+"string can be broken up like this"
+
+...
+
+ The msgid lines are extracted from the program source. (They need not
+ be, but this is the most common way.) The msgstr lines are
+ initially empty and are filled in with useful strings by the
+ translator. The strings can contain C-style escape characters and
+ can be continued across lines as illustrated. (The next line must
+ start at the beginning of the line.)
+
+ The # character introduces a comment. If whitespace immediately
+ follows the # character, then this is a comment maintained by the
+ translator. There can also be automatic comments, which have a
+ non-whitespace character immediately following the #. These are
+ maintained by the various tools that operate on the PO files and
+ are intended to aid the translator.
+
+#. automatic comment
+#: filename.c:1023
+#, flags, flags
+
+ The #. style comments are extracted from the source file where the
+ message is used. Possibly the programmer has inserted information
+ for the translator, such as about expected alignment. The #:
+ comments indicate the exact locations where the message is used
+ in the source. The translator need not look at the program
+ source, but can if there is doubt about the correct
+ translation. The #, comments contain flags that describe the
+ message in some way. There are currently two flags:
+ fuzzy is set if the message has possibly been
+ outdated because of changes in the program source. The translator
+ can then verify this and possibly remove the fuzzy flag. Note
+ that fuzzy messages are not made available to the end user. The
+ other flag is c-format, which indicates that
+ the message is a printf-style format
+ template. This means that the translation should also be a format
+ string with the same number and type of placeholders. There are
+ tools that can verify this, which key off the c-format flag.
+
57.1.3. Creating and Maintaining Message Catalogs #
+ OK, so how does one create a “blank” message
+ catalog? First, go into the directory that contains the program
+ whose messages you want to translate. If there is a file
+ nls.mk, then this program has been prepared
+ for translation.
+
+ If there are already some .po files, then
+ someone has already done some translation work. The files are
+ named language.polanguage is the
+
+ ISO 639-1 two-letter language code (in lower case), e.g.,
+ fr.po for French. If there is really a need
+ for more than one translation effort per language then the files
+ can also be named
+ language_region.poregion is the
+
+ ISO 3166-1 two-letter country code (in upper case),
+ e.g.,
+ pt_BR.po for Portuguese in Brazil. If you
+ find the language you wanted you can just start working on that
+ file.
+
+ If you need to start a new translation effort, then first run the
+ command:
+
+make init-po
+
+ This will create a file
+ progname.pot.pot to distinguish it from PO files that
+ are “in production”. The T stands for
+ “template”.)
+ Copy this file to
+ language.popo/LINGUAS and add the
+ language (or language and country) code next to languages already listed,
+ like:
+
+de fr
+
+ (Other languages can appear, of course.)
+
+ As the underlying program or library changes, messages might be
+ changed or added by the programmers. In this case you do not need
+ to start from scratch. Instead, run the command:
+
+make update-po
+
+ which will create a new blank message catalog file (the pot file
+ you started with) and will merge it with the existing PO files.
+ If the merge algorithm is not sure about a particular message it
+ marks it “fuzzy” as explained above. The new PO file
+ is saved with a .po.new extension.
+
57.1.4. Editing the PO Files #
+ The PO files can be edited with a regular text editor. There are also
+ several specialized editors for PO files which can help the process with
+ translation-specific features.
+ There is (unsurprisingly) a PO mode for Emacs, which can be quite
+ useful.
+
+ The translator should only change the area between the quotes after
+ the msgstr directive, add comments, and alter the fuzzy flag.
+
+ The PO files need not be completely filled in. The software will
+ automatically fall back to the original string if no translation
+ (or an empty translation) is available. It is no problem to
+ submit incomplete translations for inclusions in the source tree;
+ that gives room for other people to pick up your work. However,
+ you are encouraged to give priority to removing fuzzy entries
+ after doing a merge. Remember that fuzzy entries will not be
+ installed; they only serve as reference for what might be the right
+ translation.
+
+ Here are some things to keep in mind while editing the
+ translations:
+
+ Make sure that if the original ends with a newline, the
+ translation does, too. Similarly for tabs, etc.
+
+ If the original is a printf format string, the translation
+ also needs to be. The translation also needs to have the same
+ format specifiers in the same order. Sometimes the natural
+ rules of the language make this impossible or at least awkward.
+ In that case you can modify the format specifiers like this:
+
+msgstr "Die Datei %2$s hat %1$u Zeichen."
+
+ Then the first placeholder will actually use the second
+ argument from the list. The
+ digits$printf
+ family of functions. You might not have heard of it before because
+ there is little use for it outside of message
+ internationalization.)
+
+ If the original string contains a linguistic mistake, report
+ that (or fix it yourself in the program source) and translate
+ normally. The corrected string can be merged in when the
+ program sources have been updated. If the original string
+ contains a factual mistake, report that (or fix it yourself)
+ and do not translate it. Instead, you can mark the string with
+ a comment in the PO file.
+
+ Maintain the style and tone of the original string.
+ Specifically, messages that are not sentences (cannot
+ open file %s) should probably not start with a
+ capital letter (if your language distinguishes letter case) or
+ end with a period (if your language uses punctuation marks).
+ It might help to read Section 56.3.
+
+ If you don't know what a message means, or if it is ambiguous,
+ ask on the developers' mailing list. Chances are that English
+ speaking end users might also not understand it or find it
+ ambiguous, so it's best to improve the message.
+
+
Chapter 57. Native Language Support
14.5. Non-Durable Settings #
+ Durability is a database feature that guarantees the recording of
+ committed transactions even if the server crashes or loses
+ power. However, durability adds significant database overhead,
+ so if your site does not require such a guarantee,
+ PostgreSQL can be configured to run
+ much faster. The following are configuration changes you can make
+ to improve performance in such cases. Except as noted below, durability
+ is still guaranteed in case of a crash of the database software;
+ only an abrupt operating system crash creates a risk of data loss
+ or corruption when these settings are used.
+
+
+ Place the database cluster's data directory in a memory-backed
+ file system (i.e., RAM disk). This eliminates all
+ database disk I/O, but limits data storage to the amount of
+ available memory (and perhaps swap).
+
+ Turn off fsync; there is no need to flush
+ data to disk.
+
+ Turn off synchronous_commit; there might be no
+ need to force WAL writes to disk on every
+ commit. This setting does risk transaction loss (though not data
+ corruption) in case of a crash of the database.
+
+ Turn off full_page_writes; there is no need
+ to guard against partial page writes.
+
+ Increase max_wal_size and checkpoint_timeout; this reduces the frequency
+ of checkpoints, but increases the storage requirements of
+ /pg_wal.
+
+ Create unlogged
+ tables to avoid WAL writes, though it
+ makes the tables non-crash-safe.
+
+
+ The following conventions are used in the synopsis of a command:
+ brackets ([ and ]) indicate
+ optional parts. Braces
+ ({ and }) and vertical lines
+ (|) indicate that you must choose one
+ alternative. Dots (...) mean that the preceding element
+ can be repeated. All other symbols, including parentheses, should be
+ taken literally.
+
+ Where it enhances the clarity, SQL commands are preceded by the
+ prompt =>, and shell commands are preceded by the
+ prompt $. Normally, prompts are not shown, though.
+
+ An administrator is generally a person who is
+ in charge of installing and running the server. A user
+ could be anyone who is using, or wants to use, any part of the
+ PostgreSQL system. These terms should not
+ be interpreted too narrowly; this book does not have fixed
+ presumptions about system administration procedures.
+
oid2name
oid2name — resolve OIDs and file nodes in a PostgreSQL data directory
Description
+ oid2name is a utility program that helps administrators to
+ examine the file structure used by PostgreSQL. To make use of it, you need
+ to be familiar with the database file structure, which is described in
+ Chapter 73.
+
Note
+ The name “oid2name” is historical, and is actually rather
+ misleading, since most of the time when you use it, you will really
+ be concerned with tables' filenode numbers (which are the file names
+ visible in the database directories). Be sure you understand the
+ difference between table OIDs and table filenodes!
+
+ oid2name connects to a target database and
+ extracts OID, filenode, and/or table name information. You can also have
+ it show database OIDs or tablespace OIDs.
+
Options
+ oid2name accepts the following command-line arguments:
+
+
-f filenode
--filenode=filenodeshow info for table with filenode filenode.
-i
--indexesinclude indexes and sequences in the listing.
-o oid
--oid=oidshow info for table with OID oid.
-q
--quietomit headers (useful for scripting).
-s
--tablespacesshow tablespace OIDs.
-S
--system-objectsinclude system objects (those in
+ information_schema, pg_toast
+ and pg_catalog schemas).
+
-t tablename_pattern
--table=tablename_patternshow info for table(s) matching tablename_pattern.
-V
--version
+ Print the oid2name version and exit.
+
-x
--extendeddisplay more information about each object shown: tablespace name,
+ schema name, and OID.
+
-?
--help
+ Show help about oid2name command line
+ arguments, and exit.
+
+
+ oid2name also accepts the following command-line
+ arguments for connection parameters:
+
+
-d database
--dbname=databasedatabase to connect to.
-h host
--host=hostdatabase server's host.
-H hostdatabase server's host. Use of this parameter is
+ deprecated as of
+ PostgreSQL 12.
-p port
--port=portdatabase server's port.
-U username
--username=usernameuser name to connect as.
+
+ To display specific tables, select which tables to show by
+ using -o, -f and/or -t.
+ -o takes an OID,
+ -f takes a filenode,
+ and -t takes a table name (actually, it's a LIKE
+ pattern, so you can use things like foo%).
+ You can use as many
+ of these options as you like, and the listing will include all objects
+ matched by any of the options. But note that these options can only
+ show objects in the database given by -d.
+
+ If you don't give any of -o, -f or -t,
+ but do give -d, it will list all tables in the database
+ named by -d. In this mode, the -S and
+ -i options control what gets listed.
+
+ If you don't give -d either, it will show a listing of database
+ OIDs. Alternatively you can give -s to get a tablespace
+ listing.
+
Environment
PGHOST
PGPORT
PGUSER
+ Default connection parameters.
+
+ This utility, like most other PostgreSQL
+ utilities, also uses the environment variables supported by
+ libpq (see Section 34.15).
+
+ The environment variable PG_COLOR specifies whether to use
+ color in diagnostic messages. Possible values are
+ always, auto and
+ never.
+
Notes
+ oid2name requires a running database server with
+ non-corrupt system catalogs. It is therefore of only limited use
+ for recovering from catastrophic database corruption situations.
+
Examples
+$ # what's in this database server, anyway?
+$ oid2name
+All databases:
+ Oid Database Name Tablespace
+----------------------------------
+ 17228 alvherre pg_default
+ 17255 regression pg_default
+ 17227 template0 pg_default
+ 1 template1 pg_default
+
+$ oid2name -s
+All tablespaces:
+ Oid Tablespace Name
+-------------------------
+ 1663 pg_default
+ 1664 pg_global
+ 155151 fastdisk
+ 155152 bigdisk
+
+$ # OK, let's look into database alvherre
+$ cd $PGDATA/base/17228
+
+$ # get top 10 db objects in the default tablespace, ordered by size
+$ ls -lS * | head -10
+-rw------- 1 alvherre alvherre 136536064 sep 14 09:51 155173
+-rw------- 1 alvherre alvherre 17965056 sep 14 09:51 1155291
+-rw------- 1 alvherre alvherre 1204224 sep 14 09:51 16717
+-rw------- 1 alvherre alvherre 581632 sep 6 17:51 1255
+-rw------- 1 alvherre alvherre 237568 sep 14 09:50 16674
+-rw------- 1 alvherre alvherre 212992 sep 14 09:51 1249
+-rw------- 1 alvherre alvherre 204800 sep 14 09:51 16684
+-rw------- 1 alvherre alvherre 196608 sep 14 09:50 16700
+-rw------- 1 alvherre alvherre 163840 sep 14 09:50 16699
+-rw------- 1 alvherre alvherre 122880 sep 6 17:51 16751
+
+$ # I wonder what file 155173 is ...
+$ oid2name -d alvherre -f 155173
+From database "alvherre":
+ Filenode Table Name
+----------------------
+ 155173 accounts
+
+$ # you can ask for more than one object
+$ oid2name -d alvherre -f 155173 -f 1155291
+From database "alvherre":
+ Filenode Table Name
+-------------------------
+ 155173 accounts
+ 1155291 accounts_pkey
+
+$ # you can mix the options, and get more details with -x
+$ oid2name -d alvherre -t accounts -f 1155291 -x
+From database "alvherre":
+ Filenode Table Name Oid Schema Tablespace
+------------------------------------------------------
+ 155173 accounts 155173 public pg_default
+ 1155291 accounts_pkey 1155291 public pg_default
+
+$ # show disk space for every db object
+$ du [0-9]* |
+> while read SIZE FILENODE
+> do
+> echo "$SIZE `oid2name -q -d alvherre -i -f $FILENODE`"
+> done
+16 1155287 branches_pkey
+16 1155289 tellers_pkey
+17561 1155291 accounts_pkey
+...
+
+$ # same, but sort by size
+$ du [0-9]* | sort -rn | while read SIZE FN
+> do
+> echo "$SIZE `oid2name -q -d alvherre -f $FN`"
+> done
+133466 155173 accounts
+17561 1155291 accounts_pkey
+1177 16717 pg_proc_proname_args_nsp_index
+...
+
+$ # If you want to see what's in tablespaces, use the pg_tblspc directory
+$ cd $PGDATA/pg_tblspc
+$ oid2name -s
+All tablespaces:
+ Oid Tablespace Name
+-------------------------
+ 1663 pg_default
+ 1664 pg_global
+ 155151 fastdisk
+ 155152 bigdisk
+
+$ # what databases have objects in tablespace "fastdisk"?
+$ ls -d 155151/*
+155151/17228/ 155151/PG_VERSION
+
+$ # Oh, what was database 17228 again?
+$ oid2name
+All databases:
+ Oid Database Name Tablespace
+----------------------------------
+ 17228 alvherre pg_default
+ 17255 regression pg_default
+ 17227 template0 pg_default
+ 1 template1 pg_default
+
+$ # Let's see what objects does this database have in the tablespace.
+$ cd 155151/17228
+$ ls -l
+total 0
+-rw------- 1 postgres postgres 0 sep 13 23:20 155156
+
+$ # OK, this is a pretty small table ... but which one is it?
+$ oid2name -d alvherre -f 155156
+From database "alvherre":
+ Filenode Table Name
+----------------------
+ 155156 foo
+
F.24. old_snapshot — inspect old_snapshot_threshold state #
+ The old_snapshot module allows inspection
+ of the server state that is used to implement
+ old_snapshot_threshold.
+
pg_old_snapshot_time_mapping(array_offset OUT int4, end_timestamp OUT timestamptz, newest_xmin OUT xid) returns setof record
+ Returns all of the entries in the server's timestamp to XID mapping.
+ Each entry represents the newest xmin of any snapshot taken in the
+ corresponding minute.
+
Chapter 52. Overview of PostgreSQL Internals
Author
+ This chapter originated as part of
+ [sim98] Stefan Simkovics'
+ Master's Thesis prepared at Vienna University of Technology under the direction
+ of O.Univ.Prof.Dr. Georg Gottlob and Univ.Ass. Mag. Katrin Seyr.
+
+ This chapter gives an overview of the internal structure of the
+ backend of PostgreSQL. After having
+ read the following sections you should have an idea of how a query
+ is processed. This chapter is intended to help the reader
+ understand the general sequence of operations that occur within the
+ backend from the point at which a query is received, to the point
+ at which the results are returned to the client.
+
F.25. pageinspect — low-level inspection of database pages #
+ The pageinspect module provides functions that allow you to
+ inspect the contents of database pages at a low level, which is useful for
+ debugging purposes. All of these functions may be used only by superusers.
+
F.25.1. General Functions #
-
+
get_raw_page(relname text, fork text, blkno bigint) returns bytea
+
+
+ get_raw_page reads the specified block of the named
+ relation and returns a copy as a bytea value. This allows a
+ single time-consistent copy of the block to be obtained.
+ fork should be 'main' for
+ the main data fork, 'fsm' for the
+ free space map,
+ 'vm' for the
+ visibility map, or
+ 'init' for the initialization fork.
+
-
+
get_raw_page(relname text, blkno bigint) returns bytea
+
+ A shorthand version of get_raw_page, for reading
+ from the main fork. Equivalent to
+ get_raw_page(relname, 'main', blkno)
+
-
+
page_header(page bytea) returns record
+
+
+ page_header shows fields that are common to all
+ PostgreSQL heap and index pages.
+
+ A page image obtained with get_raw_page should be
+ passed as argument. For example:
+
+test=# SELECT * FROM page_header(get_raw_page('pg_class', 0));
+ lsn | checksum | flags | lower | upper | special | pagesize | version | prune_xid
+-----------+----------+--------+-------+-------+---------+----------+---------+-----------
+ 0/24A1B50 | 0 | 1 | 232 | 368 | 8192 | 8192 | 4 | 0
+
+ The returned columns correspond to the fields in the
+ PageHeaderData struct.
+ See src/include/storage/bufpage.h for details.
+
+ The checksum field is the checksum stored in
+ the page, which might be incorrect if the page is somehow corrupted. If
+ data checksums are not enabled for this instance, then the value stored
+ is meaningless.
+
-
+
page_checksum(page bytea, blkno bigint) returns smallint
+
+
+ page_checksum computes the checksum for the page, as if
+ it was located at the given block.
+
+ A page image obtained with get_raw_page should be
+ passed as argument. For example:
+
+test=# SELECT page_checksum(get_raw_page('pg_class', 0), 0);
+ page_checksum
+---------------
+ 13443
+
+ Note that the checksum depends on the block number, so matching block
+ numbers should be passed (except when doing esoteric debugging).
+
+ The checksum computed with this function can be compared with
+ the checksum result field of the
+ function page_header. If data checksums are
+ enabled for this instance, then the two values should be equal.
+
-
+
fsm_page_contents(page bytea) returns text
+
+
+ fsm_page_contents shows the internal node structure
+ of an FSM page. For example:
+
+test=# SELECT fsm_page_contents(get_raw_page('pg_class', 'fsm', 0));
+
+ The output is a multiline string, with one line per node in the binary
+ tree within the page. Only those nodes that are not zero are printed.
+ The so-called "next" pointer, which points to the next slot to be
+ returned from the page, is also printed.
+
+ See src/backend/storage/freespace/README for more
+ information on the structure of an FSM page.
+
-
+
heap_page_items(page bytea) returns setof record
+
+
+ heap_page_items shows all line pointers on a heap
+ page. For those line pointers that are in use, tuple headers as well
+ as tuple raw data are also shown. All tuples are shown, whether or not
+ the tuples were visible to an MVCC snapshot at the time the raw page
+ was copied.
+
+ A heap page image obtained with get_raw_page should
+ be passed as argument. For example:
+
+test=# SELECT * FROM heap_page_items(get_raw_page('pg_class', 0));
+
+ See src/include/storage/itemid.h and
+ src/include/access/htup_details.h for explanations of the fields
+ returned.
+
+ The heap_tuple_infomask_flags function can be
+ used to unpack the flag bits of t_infomask
+ and t_infomask2 for heap tuples.
+
-
+
tuple_data_split(rel_oid oid, t_data bytea, t_infomask integer, t_infomask2 integer, t_bits text [, do_detoast bool]) returns bytea[]
+
+
+ tuple_data_split splits tuple data into attributes
+ in the same way as backend internals.
+
+test=# SELECT tuple_data_split('pg_class'::regclass, t_data, t_infomask, t_infomask2, t_bits) FROM heap_page_items(get_raw_page('pg_class', 0));
+
+ This function should be called with the same arguments as the return
+ attributes of heap_page_items.
+
+ If do_detoast is true,
+ attributes will be detoasted as needed. Default value is
+ false.
+
-
+
heap_page_item_attrs(page bytea, rel_oid regclass [, do_detoast bool]) returns setof record
+
+
+ heap_page_item_attrs is equivalent to
+ heap_page_items except that it returns
+ tuple raw data as an array of attributes that can optionally
+ be detoasted by do_detoast which is
+ false by default.
+
+ A heap page image obtained with get_raw_page should
+ be passed as argument. For example:
+
+test=# SELECT * FROM heap_page_item_attrs(get_raw_page('pg_class', 0), 'pg_class'::regclass);
+
+
-
+
heap_tuple_infomask_flags(t_infomask integer, t_infomask2 integer) returns record
+
+
+ heap_tuple_infomask_flags decodes the
+ t_infomask and
+ t_infomask2 returned by
+ heap_page_items into a human-readable
+ set of arrays made of flag names, with one column for all
+ the flags and one column for combined flags. For example:
+
+test=# SELECT t_ctid, raw_flags, combined_flags
+ FROM heap_page_items(get_raw_page('pg_class', 0)),
+ LATERAL heap_tuple_infomask_flags(t_infomask, t_infomask2)
+ WHERE t_infomask IS NOT NULL OR t_infomask2 IS NOT NULL;
+
+ This function should be called with the same arguments as the return
+ attributes of heap_page_items.
+
+ Combined flags are displayed for source-level macros that take into
+ account the value of more than one raw bit, such as
+ HEAP_XMIN_FROZEN.
+
+ See src/include/access/htup_details.h for
+ explanations of the flag names returned.
+
F.25.3. B-Tree Functions #
-
+
bt_metap(relname text) returns record
+
+
+ bt_metap returns information about a B-tree
+ index's metapage. For example:
+
+test=# SELECT * FROM bt_metap('pg_cast_oid_index');
+-[ RECORD 1 ]-------------+-------
+magic | 340322
+version | 4
+root | 1
+level | 0
+fastroot | 1
+fastlevel | 0
+last_cleanup_num_delpages | 0
+last_cleanup_num_tuples | 230
+allequalimage | f
+
+
-
+
bt_page_stats(relname text, blkno bigint) returns record
+
+
+ bt_page_stats returns summary information about
+ a data page of a B-tree index. For example:
+
+test=# SELECT * FROM bt_page_stats('pg_cast_oid_index', 1);
+-[ RECORD 1 ]-+-----
+blkno | 1
+type | l
+live_items | 224
+dead_items | 0
+avg_item_size | 16
+page_size | 8192
+free_size | 3668
+btpo_prev | 0
+btpo_next | 0
+btpo_level | 0
+btpo_flags | 3
+
+
-
+
bt_multi_page_stats(relname text, blkno bigint, blk_count bigint) returns setof record
+
+
+ bt_multi_page_stats returns the same information
+ as bt_page_stats, but does so for each page of the
+ range of pages beginning at blkno and extending
+ for blk_count pages.
+ If blk_count is negative, all pages
+ from blkno to the end of the index are reported
+ on. For example:
+
+test=# SELECT * FROM bt_multi_page_stats('pg_proc_oid_index', 5, 2);
+-[ RECORD 1 ]-+-----
+blkno | 5
+type | l
+live_items | 367
+dead_items | 0
+avg_item_size | 16
+page_size | 8192
+free_size | 808
+btpo_prev | 4
+btpo_next | 6
+btpo_level | 0
+btpo_flags | 1
+-[ RECORD 2 ]-+-----
+blkno | 6
+type | l
+live_items | 367
+dead_items | 0
+avg_item_size | 16
+page_size | 8192
+free_size | 808
+btpo_prev | 5
+btpo_next | 7
+btpo_level | 0
+btpo_flags | 1
+
+
-
+
bt_page_items(relname text, blkno bigint) returns setof record
+
+
+ bt_page_items returns detailed information about
+ all of the items on a B-tree index page. For example:
+
+test=# SELECT itemoffset, ctid, itemlen, nulls, vars, data, dead, htid, tids[0:2] AS some_tids
+ FROM bt_page_items('tenk2_hundred', 5);
+ itemoffset | ctid | itemlen | nulls | vars | data | dead | htid | some_tids
+------------+-----------+---------+-------+------+-------------------------+------+--------+---------------------
+ 1 | (16,1) | 16 | f | f | 30 00 00 00 00 00 00 00 | | |
+ 2 | (16,8292) | 616 | f | f | 24 00 00 00 00 00 00 00 | f | (1,6) | {"(1,6)","(10,22)"}
+ 3 | (16,8292) | 616 | f | f | 25 00 00 00 00 00 00 00 | f | (1,18) | {"(1,18)","(4,22)"}
+ 4 | (16,8292) | 616 | f | f | 26 00 00 00 00 00 00 00 | f | (4,18) | {"(4,18)","(6,17)"}
+ 5 | (16,8292) | 616 | f | f | 27 00 00 00 00 00 00 00 | f | (1,2) | {"(1,2)","(1,19)"}
+ 6 | (16,8292) | 616 | f | f | 28 00 00 00 00 00 00 00 | f | (2,24) | {"(2,24)","(4,11)"}
+ 7 | (16,8292) | 616 | f | f | 29 00 00 00 00 00 00 00 | f | (2,17) | {"(2,17)","(11,2)"}
+ 8 | (16,8292) | 616 | f | f | 2a 00 00 00 00 00 00 00 | f | (0,25) | {"(0,25)","(3,20)"}
+ 9 | (16,8292) | 616 | f | f | 2b 00 00 00 00 00 00 00 | f | (0,10) | {"(0,10)","(0,14)"}
+ 10 | (16,8292) | 616 | f | f | 2c 00 00 00 00 00 00 00 | f | (1,3) | {"(1,3)","(3,9)"}
+ 11 | (16,8292) | 616 | f | f | 2d 00 00 00 00 00 00 00 | f | (6,28) | {"(6,28)","(11,1)"}
+ 12 | (16,8292) | 616 | f | f | 2e 00 00 00 00 00 00 00 | f | (0,27) | {"(0,27)","(1,13)"}
+ 13 | (16,8292) | 616 | f | f | 2f 00 00 00 00 00 00 00 | f | (4,17) | {"(4,17)","(4,21)"}
+(13 rows)
+
+ This is a B-tree leaf page. All tuples that point to the table
+ happen to be posting list tuples (all of which store a total of
+ 100 6 byte TIDs). There is also a “high key” tuple
+ at itemoffset number 1.
+ ctid is used to store encoded
+ information about each tuple in this example, though leaf page
+ tuples often store a heap TID directly in the
+ ctid field instead.
+ tids is the list of TIDs stored as a
+ posting list.
+
+ In an internal page (not shown), the block number part of
+ ctid is a “downlink”,
+ which is a block number of another page in the index itself.
+ The offset part (the second number) of
+ ctid stores encoded information about
+ the tuple, such as the number of columns present (suffix
+ truncation may have removed unneeded suffix columns). Truncated
+ columns are treated as having the value “minus
+ infinity”.
+
+ htid shows a heap TID for the tuple,
+ regardless of the underlying tuple representation. This value
+ may match ctid, or may be decoded
+ from the alternative representations used by posting list tuples
+ and tuples from internal pages. Tuples in internal pages
+ usually have the implementation level heap TID column truncated
+ away, which is represented as a NULL
+ htid value.
+
+ Note that the first item on any non-rightmost page (any page with
+ a non-zero value in the btpo_next field) is the
+ page's “high key”, meaning its data
+ serves as an upper bound on all items appearing on the page, while
+ its ctid field does not point to
+ another block. Also, on internal pages, the first real data
+ item (the first item that is not a high key) reliably has every
+ column truncated away, leaving no actual value in its
+ data field. Such an item does have a
+ valid downlink in its ctid field,
+ however.
+
+ For more details about the structure of B-tree indexes, see
+ Section 67.4.1. For more details about
+ deduplication and posting lists, see Section 67.4.3.
+
-
+
bt_page_items(page bytea) returns setof record
+
+
+ It is also possible to pass a page to bt_page_items
+ as a bytea value. A page image obtained
+ with get_raw_page should be passed as argument. So
+ the last example could also be rewritten like this:
+
+test=# SELECT itemoffset, ctid, itemlen, nulls, vars, data, dead, htid, tids[0:2] AS some_tids
+ FROM bt_page_items(get_raw_page('tenk2_hundred', 5));
+ itemoffset | ctid | itemlen | nulls | vars | data | dead | htid | some_tids
+------------+-----------+---------+-------+------+-------------------------+------+--------+---------------------
+ 1 | (16,1) | 16 | f | f | 30 00 00 00 00 00 00 00 | | |
+ 2 | (16,8292) | 616 | f | f | 24 00 00 00 00 00 00 00 | f | (1,6) | {"(1,6)","(10,22)"}
+ 3 | (16,8292) | 616 | f | f | 25 00 00 00 00 00 00 00 | f | (1,18) | {"(1,18)","(4,22)"}
+ 4 | (16,8292) | 616 | f | f | 26 00 00 00 00 00 00 00 | f | (4,18) | {"(4,18)","(6,17)"}
+ 5 | (16,8292) | 616 | f | f | 27 00 00 00 00 00 00 00 | f | (1,2) | {"(1,2)","(1,19)"}
+ 6 | (16,8292) | 616 | f | f | 28 00 00 00 00 00 00 00 | f | (2,24) | {"(2,24)","(4,11)"}
+ 7 | (16,8292) | 616 | f | f | 29 00 00 00 00 00 00 00 | f | (2,17) | {"(2,17)","(11,2)"}
+ 8 | (16,8292) | 616 | f | f | 2a 00 00 00 00 00 00 00 | f | (0,25) | {"(0,25)","(3,20)"}
+ 9 | (16,8292) | 616 | f | f | 2b 00 00 00 00 00 00 00 | f | (0,10) | {"(0,10)","(0,14)"}
+ 10 | (16,8292) | 616 | f | f | 2c 00 00 00 00 00 00 00 | f | (1,3) | {"(1,3)","(3,9)"}
+ 11 | (16,8292) | 616 | f | f | 2d 00 00 00 00 00 00 00 | f | (6,28) | {"(6,28)","(11,1)"}
+ 12 | (16,8292) | 616 | f | f | 2e 00 00 00 00 00 00 00 | f | (0,27) | {"(0,27)","(1,13)"}
+ 13 | (16,8292) | 616 | f | f | 2f 00 00 00 00 00 00 00 | f | (4,17) | {"(4,17)","(4,21)"}
+(13 rows)
+
+ All the other details are the same as explained in the previous item.
+
-
+
brin_page_type(page bytea) returns text
+
+
+ brin_page_type returns the page type of the given
+ BRIN index page, or throws an error if the page is
+ not a valid BRIN page. For example:
+
+test=# SELECT brin_page_type(get_raw_page('brinidx', 0));
+ brin_page_type
+----------------
+ meta
+
+
-
+
brin_metapage_info(page bytea) returns record
+
+
+ brin_metapage_info returns assorted information
+ about a BRIN index metapage. For example:
+
+test=# SELECT * FROM brin_metapage_info(get_raw_page('brinidx', 0));
+ magic | version | pagesperrange | lastrevmappage
+------------+---------+---------------+----------------
+ 0xA8109CFA | 1 | 4 | 2
+
+
-
+
brin_revmap_data(page bytea) returns setof tid
+
+
+ brin_revmap_data returns the list of tuple
+ identifiers in a BRIN index range map page.
+ For example:
+
+test=# SELECT * FROM brin_revmap_data(get_raw_page('brinidx', 2)) LIMIT 5;
+ pages
+---------
+ (6,137)
+ (6,138)
+ (6,139)
+ (6,140)
+ (6,141)
+
+
-
+
brin_page_items(page bytea, index oid) returns setof record
+
+
+ brin_page_items returns the data stored in the
+ BRIN data page. For example:
+
+test=# SELECT * FROM brin_page_items(get_raw_page('brinidx', 5),
+ 'brinidx')
+ ORDER BY blknum, attnum LIMIT 6;
+ itemoffset | blknum | attnum | allnulls | hasnulls | placeholder | empty | value
+------------+--------+--------+----------+----------+-------------+-------+--------------
+ 137 | 0 | 1 | t | f | f | f |
+ 137 | 0 | 2 | f | f | f | f | {1 .. 88}
+ 138 | 4 | 1 | t | f | f | f |
+ 138 | 4 | 2 | f | f | f | f | {89 .. 176}
+ 139 | 8 | 1 | t | f | f | f |
+ 139 | 8 | 2 | f | f | f | f | {177 .. 264}
+
+ The returned columns correspond to the fields in the
+ BrinMemTuple and BrinValues structs.
+ See src/include/access/brin_tuple.h for details.
+
-
+
gin_metapage_info(page bytea) returns record
+
+
+ gin_metapage_info returns information about
+ a GIN index metapage. For example:
+
+test=# SELECT * FROM gin_metapage_info(get_raw_page('gin_index', 0));
+-[ RECORD 1 ]----+-----------
+pending_head | 4294967295
+pending_tail | 4294967295
+tail_free_size | 0
+n_pending_pages | 0
+n_pending_tuples | 0
+n_total_pages | 7
+n_entry_pages | 6
+n_data_pages | 0
+n_entries | 693
+version | 2
+
+
-
+
gin_page_opaque_info(page bytea) returns record
+
+
+ gin_page_opaque_info returns information about
+ a GIN index opaque area, like the page type.
+ For example:
+
+test=# SELECT * FROM gin_page_opaque_info(get_raw_page('gin_index', 2));
+ rightlink | maxoff | flags
+-----------+--------+------------------------
+ 5 | 0 | {data,leaf,compressed}
+(1 row)
+
+
-
+
gin_leafpage_items(page bytea) returns setof record
+
+
+ gin_leafpage_items returns information about
+ the data stored in a GIN leaf page. For example:
+
+test=# SELECT first_tid, nbytes, tids[0:5] AS some_tids
+ FROM gin_leafpage_items(get_raw_page('gin_test_idx', 2));
+ first_tid | nbytes | some_tids
+-----------+--------+----------------------------------------------------------
+ (8,41) | 244 | {"(8,41)","(8,43)","(8,44)","(8,45)","(8,46)"}
+ (10,45) | 248 | {"(10,45)","(10,46)","(10,47)","(10,48)","(10,49)"}
+ (12,52) | 248 | {"(12,52)","(12,53)","(12,54)","(12,55)","(12,56)"}
+ (14,59) | 320 | {"(14,59)","(14,60)","(14,61)","(14,62)","(14,63)"}
+ (167,16) | 376 | {"(167,16)","(167,17)","(167,18)","(167,19)","(167,20)"}
+ (170,30) | 376 | {"(170,30)","(170,31)","(170,32)","(170,33)","(170,34)"}
+ (173,44) | 197 | {"(173,44)","(173,45)","(173,46)","(173,47)","(173,48)"}
+(7 rows)
+
+
-
+
gist_page_opaque_info(page bytea) returns record
+
+
+ gist_page_opaque_info returns information from
+ a GiST index page's opaque area, such as the NSN,
+ rightlink and page type.
+ For example:
+
+test=# SELECT * FROM gist_page_opaque_info(get_raw_page('test_gist_idx', 2));
+ lsn | nsn | rightlink | flags
+-----+-----+-----------+--------
+ 0/1 | 0/0 | 1 | {leaf}
+(1 row)
+
+
-
+
gist_page_items(page bytea, index_oid regclass) returns setof record
+
+
+ gist_page_items returns information about
+ the data stored in a page of a GiST index. For example:
+
+test=# SELECT * FROM gist_page_items(get_raw_page('test_gist_idx', 0), 'test_gist_idx');
+ itemoffset | ctid | itemlen | dead | keys
+------------+-----------+---------+------+-------------------------------
+ 1 | (1,65535) | 40 | f | (p)=("(185,185),(1,1)")
+ 2 | (2,65535) | 40 | f | (p)=("(370,370),(186,186)")
+ 3 | (3,65535) | 40 | f | (p)=("(555,555),(371,371)")
+ 4 | (4,65535) | 40 | f | (p)=("(740,740),(556,556)")
+ 5 | (5,65535) | 40 | f | (p)=("(870,870),(741,741)")
+ 6 | (6,65535) | 40 | f | (p)=("(1000,1000),(871,871)")
+(6 rows)
+
+
-
+
gist_page_items_bytea(page bytea) returns setof record
+
+
+ Same as gist_page_items, but returns the key data
+ as a raw bytea blob. Since it does not attempt to decode
+ the key, it does not need to know which index is involved. For
+ example:
+
+test=# SELECT * FROM gist_page_items_bytea(get_raw_page('test_gist_idx', 0));
+ itemoffset | ctid | itemlen | dead | key_data
+------------+-----------+---------+------+------------------------------------------------------------------------------------
+ 1 | (1,65535) | 40 | f | \x00000100ffff28000000000000c064400000000000c06440000000000000f03f000000000000f03f
+ 2 | (2,65535) | 40 | f | \x00000200ffff28000000000000c074400000000000c074400000000000e064400000000000e06440
+ 3 | (3,65535) | 40 | f | \x00000300ffff28000000000000207f400000000000207f400000000000d074400000000000d07440
+ 4 | (4,65535) | 40 | f | \x00000400ffff28000000000000c084400000000000c084400000000000307f400000000000307f40
+ 5 | (5,65535) | 40 | f | \x00000500ffff28000000000000f089400000000000f089400000000000c884400000000000c88440
+ 6 | (6,65535) | 40 | f | \x00000600ffff28000000000000208f400000000000208f400000000000f889400000000000f88940
+ 7 | (7,65535) | 40 | f | \x00000700ffff28000000000000408f400000000000408f400000000000288f400000000000288f40
+(7 rows)
+
+
-
+
hash_page_type(page bytea) returns text
+
+
+ hash_page_type returns page type of
+ the given HASH index page. For example:
+
+test=# SELECT hash_page_type(get_raw_page('con_hash_index', 0));
+ hash_page_type
+----------------
+ metapage
+
+
-
+
hash_page_stats(page bytea) returns setof record
+
+
+ hash_page_stats returns information about
+ a bucket or overflow page of a HASH index.
+ For example:
+
+test=# SELECT * FROM hash_page_stats(get_raw_page('con_hash_index', 1));
+-[ RECORD 1 ]---+-----------
+live_items | 407
+dead_items | 0
+page_size | 8192
+free_size | 8
+hasho_prevblkno | 4096
+hasho_nextblkno | 8474
+hasho_bucket | 0
+hasho_flag | 66
+hasho_page_id | 65408
+
+
-
+
hash_page_items(page bytea) returns setof record
+
+
+ hash_page_items returns information about
+ the data stored in a bucket or overflow page of a HASH
+ index page. For example:
+
+test=# SELECT * FROM hash_page_items(get_raw_page('con_hash_index', 1)) LIMIT 5;
+ itemoffset | ctid | data
+------------+-----------+------------
+ 1 | (899,77) | 1053474816
+ 2 | (897,29) | 1053474816
+ 3 | (894,207) | 1053474816
+ 4 | (892,159) | 1053474816
+ 5 | (890,111) | 1053474816
+
+
-
+
hash_bitmap_info(index oid, blkno bigint) returns record
+
+
+ hash_bitmap_info shows the status of a bit
+ in the bitmap page for a particular overflow page of HASH
+ index. For example:
+
+test=# SELECT * FROM hash_bitmap_info('con_hash_index', 2052);
+ bitmapblkno | bitmapbit | bitstatus
+-------------+-----------+-----------
+ 65 | 3 | t
+
+
-
+
hash_metapage_info(page bytea) returns record
+
+
+ hash_metapage_info returns information stored
+ in the meta page of a HASH index. For example:
+
+test=# SELECT magic, version, ntuples, ffactor, bsize, bmsize, bmshift,
+test-# maxbucket, highmask, lowmask, ovflpoint, firstfree, nmaps, procid,
+test-# regexp_replace(spares::text, '(,0)*}', '}') as spares,
+test-# regexp_replace(mapp::text, '(,0)*}', '}') as mapp
+test-# FROM hash_metapage_info(get_raw_page('con_hash_index', 0));
+-[ RECORD 1 ]-------------------------------------------------------------------------------
+magic | 105121344
+version | 4
+ntuples | 500500
+ffactor | 40
+bsize | 8152
+bmsize | 4096
+bmshift | 15
+maxbucket | 12512
+highmask | 16383
+lowmask | 8191
+ovflpoint | 28
+firstfree | 1204
+nmaps | 1
+procid | 450
+spares | {0,0,0,0,0,0,1,1,1,1,1,1,1,1,3,4,4,4,45,55,58,59,508,567,628,704,1193,1202,1204}
+mapp | {65}
+
+
+ Because each worker executes the parallel portion of the plan to
+ completion, it is not possible to simply take an ordinary query plan
+ and run it using multiple workers. Each worker would produce a full
+ copy of the output result set, so the query would not run any faster
+ than normal but would produce incorrect results. Instead, the parallel
+ portion of the plan must be what is known internally to the query
+ optimizer as a partial plan; that is, it must be constructed
+ so that each process that executes the plan will generate only a
+ subset of the output rows in such a way that each required output row
+ is guaranteed to be generated by exactly one of the cooperating processes.
+ Generally, this means that the scan on the driving table of the query
+ must be a parallel-aware scan.
+
+ The following types of parallel-aware table scans are currently supported.
+
+
+ In a parallel sequential scan, the table's blocks will
+ be divided into ranges and shared among the cooperating processes. Each
+ worker process will complete the scanning of its given range of blocks before
+ requesting an additional range of blocks.
+
+ In a parallel bitmap heap scan, one process is chosen
+ as the leader. That process performs a scan of one or more indexes
+ and builds a bitmap indicating which table blocks need to be visited.
+ These blocks are then divided among the cooperating processes as in
+ a parallel sequential scan. In other words, the heap scan is performed
+ in parallel, but the underlying index scan is not.
+
+ In a parallel index scan or parallel index-only
+ scan, the cooperating processes take turns reading data from the
+ index. Currently, parallel index scans are supported only for
+ btree indexes. Each process will claim a single index block and will
+ scan and return all tuples referenced by that block; other processes can
+ at the same time be returning tuples from a different index block.
+ The results of a parallel btree scan are returned in sorted order
+ within each worker process.
+
+
+ Other scan types, such as scans of non-btree indexes, may support
+ parallel scans in the future.
+
+ Just as in a non-parallel plan, the driving table may be joined to one or
+ more other tables using a nested loop, hash join, or merge join. The
+ inner side of the join may be any kind of non-parallel plan that is
+ otherwise supported by the planner provided that it is safe to run within
+ a parallel worker. Depending on the join type, the inner side may also be
+ a parallel plan.
+
+ In a nested loop join, the inner side is always
+ non-parallel. Although it is executed in full, this is efficient if
+ the inner side is an index scan, because the outer tuples and thus
+ the loops that look up values in the index are divided over the
+ cooperating processes.
+
+ In a merge join, the inner side is always
+ a non-parallel plan and therefore executed in full. This may be
+ inefficient, especially if a sort must be performed, because the work
+ and resulting data are duplicated in every cooperating process.
+
+ In a hash join (without the "parallel" prefix),
+ the inner side is executed in full by every cooperating process
+ to build identical copies of the hash table. This may be inefficient
+ if the hash table is large or the plan is expensive. In a
+ parallel hash join, the inner side is a
+ parallel hash that divides the work of building
+ a shared hash table over the cooperating processes.
+
15.3.3. Parallel Aggregation #
+ PostgreSQL supports parallel aggregation by aggregating in
+ two stages. First, each process participating in the parallel portion of
+ the query performs an aggregation step, producing a partial result for
+ each group of which that process is aware. This is reflected in the plan
+ as a Partial Aggregate node. Second, the partial results are
+ transferred to the leader via Gather or Gather
+ Merge. Finally, the leader re-aggregates the results across all
+ workers in order to produce the final result. This is reflected in the
+ plan as a Finalize Aggregate node.
+
+ Because the Finalize Aggregate node runs on the leader
+ process, queries that produce a relatively large number of groups in
+ comparison to the number of input rows will appear less favorable to the
+ query planner. For example, in the worst-case scenario the number of
+ groups seen by the Finalize Aggregate node could be as many as
+ the number of input rows that were seen by all worker processes in the
+ Partial Aggregate stage. For such cases, there is clearly
+ going to be no performance benefit to using parallel aggregation. The
+ query planner takes this into account during the planning process and is
+ unlikely to choose parallel aggregate in this scenario.
+
+ Parallel aggregation is not supported in all situations. Each aggregate
+ must be safe for parallelism and must
+ have a combine function. If the aggregate has a transition state of type
+ internal, it must have serialization and deserialization
+ functions. See CREATE AGGREGATE for more details.
+ Parallel aggregation is not supported if any aggregate function call
+ contains DISTINCT or ORDER BY clause and is also
+ not supported for ordered set aggregates or when the query involves
+ GROUPING SETS. It can only be used when all joins involved in
+ the query are also part of the parallel portion of the plan.
+
15.3.4. Parallel Append #
+ Whenever PostgreSQL needs to combine rows
+ from multiple sources into a single result set, it uses an
+ Append or MergeAppend plan node.
+ This commonly happens when implementing UNION ALL or
+ when scanning a partitioned table. Such nodes can be used in parallel
+ plans just as they can in any other plan. However, in a parallel plan,
+ the planner may instead use a Parallel Append node.
+
+ When an Append node is used in a parallel plan, each
+ process will execute the child plans in the order in which they appear,
+ so that all participating processes cooperate to execute the first child
+ plan until it is complete and then move to the second plan at around the
+ same time. When a Parallel Append is used instead, the
+ executor will instead spread out the participating processes as evenly as
+ possible across its child plans, so that multiple child plans are executed
+ simultaneously. This avoids contention, and also avoids paying the startup
+ cost of a child plan in those processes that never execute it.
+
+ Also, unlike a regular Append node, which can only have
+ partial children when used within a parallel plan, a Parallel
+ Append node can have both partial and non-partial child plans.
+ Non-partial children will be scanned by only a single process, since
+ scanning them more than once would produce duplicate results. Plans that
+ involve appending multiple results sets can therefore achieve
+ coarse-grained parallelism even when efficient partial plans are not
+ available. For example, consider a query against a partitioned table
+ that can only be implemented efficiently by using an index that does
+ not support parallel scans. The planner might choose a Parallel
+ Append of regular Index Scan plans; each
+ individual index scan would have to be executed to completion by a single
+ process, but different scans could be performed at the same time by
+ different processes.
+
+ enable_parallel_append can be used to disable
+ this feature.
+
15.3.5. Parallel Plan Tips #
+ If a query that is expected to do so does not produce a parallel plan,
+ you can try reducing parallel_setup_cost or
+ parallel_tuple_cost. Of course, this plan may turn
+ out to be slower than the serial plan that the planner preferred, but
+ this will not always be the case. If you don't get a parallel
+ plan even with very small values of these settings (e.g., after setting
+ them both to zero), there may be some reason why the query planner is
+ unable to generate a parallel plan for your query. See
+ Section 15.2 and
+ Section 15.4 for information on why this may be
+ the case.
+
+ When executing a parallel plan, you can use EXPLAIN (ANALYZE,
+ VERBOSE) to display per-worker statistics for each plan node.
+ This may be useful in determining whether the work is being evenly
+ distributed between all plan nodes and more generally in understanding the
+ performance characteristics of the plan.
+
Chapter 15. Parallel Query
+ PostgreSQL can devise query plans that can leverage
+ multiple CPUs in order to answer queries faster. This feature is known
+ as parallel query. Many queries cannot benefit from parallel query, either
+ due to limitations of the current implementation or because there is no
+ imaginable query plan that is any faster than the serial query plan.
+ However, for queries that can benefit, the speedup from parallel query
+ is often very significant. Many queries can run more than twice as fast
+ when using parallel query, and some queries can run four times faster or
+ even more. Queries that touch a large amount of data but return only a
+ few rows to the user will typically benefit most. This chapter explains
+ some details of how parallel query works and in which situations it can be
+ used so that users who wish to make use of it can understand what to expect.
+
+ The planner classifies operations involved in a query as either
+ parallel safe, parallel restricted,
+ or parallel unsafe. A parallel safe operation is one that
+ does not conflict with the use of parallel query. A parallel restricted
+ operation is one that cannot be performed in a parallel worker, but that
+ can be performed in the leader while parallel query is in use. Therefore,
+ parallel restricted operations can never occur below a Gather
+ or Gather Merge node, but can occur elsewhere in a plan that
+ contains such a node. A parallel unsafe operation is one that cannot
+ be performed while parallel query is in use, not even in the leader.
+ When a query contains anything that is parallel unsafe, parallel query
+ is completely disabled for that query.
+
+ The following operations are always parallel restricted:
+
+ Scans of common table expressions (CTEs).
+
+ Scans of temporary tables.
+
+ Scans of foreign tables, unless the foreign data wrapper has
+ an IsForeignScanParallelSafe API that indicates otherwise.
+
+ Plan nodes to which an InitPlan is attached.
+
+ Plan nodes that reference a correlated SubPlan.
+
15.4.1. Parallel Labeling for Functions and Aggregates #
+ The planner cannot automatically determine whether a user-defined
+ function or aggregate is parallel safe, parallel restricted, or parallel
+ unsafe, because this would require predicting every operation that the
+ function could possibly perform. In general, this is equivalent to the
+ Halting Problem and therefore impossible. Even for simple functions
+ where it could conceivably be done, we do not try, since this would be expensive
+ and error-prone. Instead, all user-defined functions are assumed to
+ be parallel unsafe unless otherwise marked. When using
+ CREATE FUNCTION or
+ ALTER FUNCTION, markings can be set by specifying
+ PARALLEL SAFE, PARALLEL RESTRICTED, or
+ PARALLEL UNSAFE as appropriate. When using
+ CREATE AGGREGATE, the
+ PARALLEL option can be specified with SAFE,
+ RESTRICTED, or UNSAFE as the corresponding value.
+
+ Functions and aggregates must be marked PARALLEL UNSAFE if
+ they write to the database, access sequences, change the transaction state
+ even temporarily (e.g., a PL/pgSQL function that establishes an
+ EXCEPTION block to catch errors), or make persistent changes to
+ settings. Similarly, functions must be marked PARALLEL
+ RESTRICTED if they access temporary tables, client connection state,
+ cursors, prepared statements, or miscellaneous backend-local state that
+ the system cannot synchronize across workers. For example,
+ setseed and random are parallel restricted for
+ this last reason.
+
+ In general, if a function is labeled as being safe when it is restricted or
+ unsafe, or if it is labeled as being restricted when it is in fact unsafe,
+ it may throw errors or produce wrong answers when used in a parallel query.
+ C-language functions could in theory exhibit totally undefined behavior if
+ mislabeled, since there is no way for the system to protect itself against
+ arbitrary C code, but in most likely cases the result will be no worse than
+ for any other function. If in doubt, it is probably best to label functions
+ as UNSAFE.
+
+ If a function executed within a parallel worker acquires locks that are
+ not held by the leader, for example by querying a table not referenced in
+ the query, those locks will be released at worker exit, not end of
+ transaction. If you write a function that does this, and this behavior
+ difference is important to you, mark such functions as
+ PARALLEL RESTRICTED
+ to ensure that they execute only in the leader.
+
+ Note that the query planner does not consider deferring the evaluation of
+ parallel-restricted functions or aggregates involved in the query in
+ order to obtain a superior plan. So, for example, if a WHERE
+ clause applied to a particular table is parallel restricted, the query
+ planner will not consider performing a scan of that table in the parallel
+ portion of a plan. In some cases, it would be
+ possible (and perhaps even efficient) to include the scan of that table in
+ the parallel portion of the query and defer the evaluation of the
+ WHERE clause so that it happens above the Gather
+ node. However, the planner does not do this.
+
+ The parser stage consists of two parts:
+
+
+ The parser defined in
+ gram.y and scan.l is
+ built using the Unix tools bison
+ and flex.
+
+ The transformation process does
+ modifications and augmentations to the data structures returned by the parser.
+
+
+ The parser has to check the query string (which arrives as plain
+ text) for valid syntax. If the syntax is correct a
+ parse tree is built up and handed back;
+ otherwise an error is returned. The parser and lexer are
+ implemented using the well-known Unix tools bison
+ and flex.
+
+ The lexer is defined in the file
+ scan.l and is responsible
+ for recognizing identifiers,
+ the SQL key words etc. For
+ every key word or identifier that is found, a token
+ is generated and handed to the parser.
+
+ The parser is defined in the file gram.y and
+ consists of a set of grammar rules and
+ actions that are executed whenever a rule
+ is fired. The code of the actions (which is actually C code) is
+ used to build up the parse tree.
+
+ The file scan.l is transformed to the C
+ source file scan.c using the program
+ flex and gram.y is
+ transformed to gram.c using
+ bison. After these transformations
+ have taken place a normal C compiler can be used to create the
+ parser. Never make any changes to the generated C files as they
+ will be overwritten the next time flex
+ or bison is called.
+
+
Note
+ The mentioned transformations and compilations are normally done
+ automatically using the makefiles
+ shipped with the PostgreSQL
+ source distribution.
+
+
+ A detailed description of bison or
+ the grammar rules given in gram.y would be
+ beyond the scope of this manual. There are many books and
+ documents dealing with flex and
+ bison. You should be familiar with
+ bison before you start to study the
+ grammar given in gram.y otherwise you won't
+ understand what happens there.
+
F.26. passwordcheck — verify password strength #
+ The passwordcheck module checks users' passwords
+ whenever they are set with
+ CREATE ROLE or
+ ALTER ROLE.
+ If a password is considered too weak, it will be rejected and
+ the command will terminate with an error.
+
+ To enable this module, add '$libdir/passwordcheck'
+ to shared_preload_libraries in
+ postgresql.conf, then restart the server.
+
+ You can adapt this module to your needs by changing the source code.
+ For example, you can use
+ CrackLib
+ to check passwords — this only requires uncommenting
+ two lines in the Makefile and rebuilding the
+ module. (We cannot include CrackLib
+ by default for license reasons.)
+ Without CrackLib, the module enforces a few
+ simple rules for password strength, which you can modify or extend
+ as you see fit.
+
Caution
+ To prevent unencrypted passwords from being sent across the network,
+ written to the server log or otherwise stolen by a database administrator,
+ PostgreSQL allows the user to supply
+ pre-encrypted passwords. Many client programs make use of this
+ functionality and encrypt the password before sending it to the server.
+
+ This limits the usefulness of the passwordcheck
+ module, because in that case it can only try to guess the password.
+ For this reason, passwordcheck is not
+ recommended if your security requirements are high.
+ It is more secure to use an external authentication method such as GSSAPI
+ (see Chapter 21) than to rely on
+ passwords within the database.
+
+ Alternatively, you could modify passwordcheck
+ to reject pre-encrypted passwords, but forcing users to set their
+ passwords in clear text carries its own security risks.
+
22.6. Function Security #
+ Functions, triggers and row-level security policies allow users to insert
+ code into the backend server that other users might execute
+ unintentionally. Hence, these mechanisms permit users to “Trojan
+ horse” others with relative ease. The strongest protection is tight
+ control over who can define objects. Where that is infeasible, write
+ queries referring only to objects having trusted owners. Remove
+ from search_path any schemas that permit untrusted users
+ to create objects.
+
+ Functions run inside the backend
+ server process with the operating system permissions of the
+ database server daemon. If the programming language
+ used for the function allows unchecked memory accesses, it is
+ possible to change the server's internal data structures.
+ Hence, among many other things, such functions can circumvent any
+ system access controls. Function languages that allow such access
+ are considered “untrusted”, and
+ PostgreSQL allows only superusers to
+ create functions written in those languages.
+
pg_archivecleanup
pg_archivecleanup — clean up PostgreSQL WAL archive files
Synopsis
pg_archivecleanup [option...] archivelocation oldestkeptwalfile
Description
+ pg_archivecleanup is designed to be used as an
+ archive_cleanup_command to clean up WAL file archives when
+ running as a standby server (see Section 27.2).
+ pg_archivecleanup can also be used as a standalone program to
+ clean WAL file archives.
+
+ To configure a standby
+ server to use pg_archivecleanup, put this into its
+ postgresql.conf configuration file:
+
+archive_cleanup_command = 'pg_archivecleanup archivelocation %r'
+
+ where archivelocation is the directory from which WAL segment
+ files should be removed.
+
+ When used within archive_cleanup_command, all WAL files
+ logically preceding the value of the %r argument will be removed
+ from archivelocation. This minimizes the number of files
+ that need to be retained, while preserving crash-restart capability. Use of
+ this parameter is appropriate if the archivelocation is a
+ transient staging area for this particular standby server, but
+ not when the archivelocation is intended as a
+ long-term WAL archive area, or when multiple standby servers are recovering
+ from the same archive location.
+
+ When used as a standalone program all WAL files logically preceding the
+ oldestkeptwalfile will be removed from archivelocation.
+ In this mode, if you specify a .partial or .backup
+ file name, then only the file prefix will be used as the
+ oldestkeptwalfile. This treatment of .backup
+ file name allows you to remove
+ all WAL files archived prior to a specific base backup without error.
+ For example, the following example will remove all files older than
+ WAL file name 000000010000003700000010:
+
+pg_archivecleanup -d archive 000000010000003700000010.00000020.backup
+
+pg_archivecleanup: keep WAL file "archive/000000010000003700000010" and later
+pg_archivecleanup: removing file "archive/00000001000000370000000F"
+pg_archivecleanup: removing file "archive/00000001000000370000000E"
+
+
+ pg_archivecleanup assumes that
+ archivelocation is a directory readable and writable by the
+ server-owning user.
+
Options
+ pg_archivecleanup accepts the following command-line arguments:
+
+
-d
+ Print lots of debug logging output on stderr.
+
-n
+ Print the names of the files that would have been removed on stdout (performs a dry run).
+
-V
--version
+ Print the pg_archivecleanup version and exit.
+
-x extension
+ Provide an extension
+ that will be stripped from all file names before deciding if they
+ should be deleted. This is typically useful for cleaning up archives
+ that have been compressed during storage, and therefore have had an
+ extension added by the compression program. For example: -x
+ .gz.
+
-?
--help
+ Show help about pg_archivecleanup command line
+ arguments, and exit.
+
+
Environment
+ The environment variable PG_COLOR specifies whether to use
+ color in diagnostic messages. Possible values are
+ always, auto and
+ never.
+
Notes
+ pg_archivecleanup is designed to work with
+ PostgreSQL 8.0 and later when used as a standalone utility,
+ or with PostgreSQL 9.0 and later when used as an
+ archive cleanup command.
+
+ pg_archivecleanup is written in C and has an
+ easy-to-modify source code, with specifically designated sections to modify
+ for your own needs
+
Examples
On Linux or Unix systems, you might use:
+
+archive_cleanup_command = 'pg_archivecleanup -d /mnt/standby/archive %r 2>>cleanup.log'
+
+ where the archive directory is physically located on the standby server,
+ so that the archive_command is accessing it across NFS,
+ but the files are local to the standby.
+ This will:
+
pgbench
pgbench — run a benchmark test on PostgreSQL
Synopsis
pgbench -i [option...] [dbname]
pgbench [option...] [dbname]
Description
+ pgbench is a simple program for running benchmark
+ tests on PostgreSQL. It runs the same sequence of SQL
+ commands over and over, possibly in multiple concurrent database sessions,
+ and then calculates the average transaction rate (transactions per second).
+ By default, pgbench tests a scenario that is
+ loosely based on TPC-B, involving five SELECT,
+ UPDATE, and INSERT commands per transaction.
+ However, it is easy to test other cases by writing your own transaction
+ script files.
+
+ Typical output from pgbench looks like:
+
+
+transaction type: <builtin: TPC-B (sort of)>
+scaling factor: 10
+query mode: simple
+number of clients: 10
+number of threads: 1
+maximum number of tries: 1
+number of transactions per client: 1000
+number of transactions actually processed: 10000/10000
+number of failed transactions: 0 (0.000%)
+latency average = 11.013 ms
+latency stddev = 7.351 ms
+initial connection time = 45.758 ms
+tps = 896.967014 (without initial connection time)
+
+
+ The first seven lines report some of the most important parameter
+ settings.
+ The sixth line reports the maximum number of tries for transactions with
+ serialization or deadlock errors (see Failures and Serialization/Deadlock Retries
+ for more information).
+ The eighth line reports the number of transactions completed
+ and intended (the latter being just the product of number of clients
+ and number of transactions per client); these will be equal unless the run
+ failed before completion or some SQL command(s) failed. (In
+ -T mode, only the actual number of transactions is printed.)
+ The next line reports the number of failed transactions due to
+ serialization or deadlock errors (see Failures and Serialization/Deadlock Retries
+ for more information).
+ The last line reports the number of transactions per second.
+
+ The default TPC-B-like transaction test requires specific tables to be
+ set up beforehand. pgbench should be invoked with
+ the -i (initialize) option to create and populate these
+ tables. (When you are testing a custom script, you don't need this
+ step, but will instead need to do whatever setup your test needs.)
+ Initialization looks like:
+
+
+pgbench -i [ other-options ] dbname
+
+
+ where dbname is the name of the already-created
+ database to test in. (You may also need -h,
+ -p, and/or -U options to specify how to
+ connect to the database server.)
+
Caution
+ pgbench -i creates four tables pgbench_accounts,
+ pgbench_branches, pgbench_history, and
+ pgbench_tellers,
+ destroying any existing tables of these names.
+ Be very careful to use another database if you have tables having these
+ names!
+
+ At the default “scale factor” of 1, the tables initially
+ contain this many rows:
+
+table # of rows
+---------------------------------
+pgbench_branches 1
+pgbench_tellers 10
+pgbench_accounts 100000
+pgbench_history 0
+
+ You can (and, for most purposes, probably should) increase the number
+ of rows by using the -s (scale factor) option. The
+ -F (fillfactor) option might also be used at this point.
+
+ Once you have done the necessary setup, you can run your benchmark
+ with a command that doesn't include -i, that is
+
+
+pgbench [ options ] dbname
+
+
+ In nearly all cases, you'll need some options to make a useful test.
+ The most important options are -c (number of clients),
+ -t (number of transactions), -T (time limit),
+ and -f (specify a custom script file).
+ See below for a full list.
+
Options
+ The following is divided into three subsections. Different options are
+ used during database initialization and while running benchmarks, but some
+ options are useful in both cases.
+
Initialization Options
+ pgbench accepts the following command-line
+ initialization arguments:
+
+
dbname #
+ Specifies the name of the database to test in. If this is
+ not specified, the environment variable
+ PGDATABASE is used. If that is not set, the
+ user name specified for the connection is used.
+
-i
--initialize #
+ Required to invoke initialization mode.
+
-I init_steps
--init-steps=init_steps #
+ Perform just a selected set of the normal initialization steps.
+ init_steps specifies the
+ initialization steps to be performed, using one character per step.
+ Each step is invoked in the specified order.
+ The default is dtgvp.
+ The available steps are:
+
+
d (Drop) #
+ Drop any existing pgbench tables.
+
t (create Tables) #
+ Create the tables used by the
+ standard pgbench scenario, namely
+ pgbench_accounts,
+ pgbench_branches,
+ pgbench_history, and
+ pgbench_tellers.
+
g or G (Generate data, client-side or server-side) #
+ Generate data and load it into the standard tables,
+ replacing any data already present.
+
+ With g (client-side data generation),
+ data is generated in pgbench client and then
+ sent to the server. This uses the client/server bandwidth
+ extensively through a COPY.
+ pgbench uses the FREEZE option with version 14 or later
+ of PostgreSQL to speed up
+ subsequent VACUUM, unless partitions are enabled.
+ Using g causes logging to print one message
+ every 100,000 rows while generating data for the
+ pgbench_accounts table.
+
+ With G (server-side data generation),
+ only small queries are sent from the pgbench
+ client and then data is actually generated in the server.
+ No significant bandwidth is required for this variant, but
+ the server will do more work.
+ Using G causes logging not to print any progress
+ message while generating data.
+
+ The default initialization behavior uses client-side data
+ generation (equivalent to g).
+
v (Vacuum) #
+ Invoke VACUUM on the standard tables.
+
p (create Primary keys) #
+ Create primary key indexes on the standard tables.
+
f (create Foreign keys) #
+ Create foreign key constraints between the standard tables.
+ (Note that this step is not performed by default.)
+
-F fillfactor
--fillfactor=fillfactor #
+ Create the pgbench_accounts,
+ pgbench_tellers and
+ pgbench_branches tables with the given fillfactor.
+ Default is 100.
+
-n
--no-vacuum #
+ Perform no vacuuming during initialization.
+ (This option suppresses the v initialization step,
+ even if it was specified in -I.)
+
-q
--quiet #
+ Switch logging to quiet mode, producing only one progress message per 5
+ seconds. The default logging prints one message each 100,000 rows, which
+ often outputs many lines per second (especially on good hardware).
+
+ This setting has no effect if G is specified
+ in -I.
+
-s scale_factor
--scale=scale_factor #
+ Multiply the number of rows generated by the scale factor.
+ For example, -s 100 will create 10,000,000 rows
+ in the pgbench_accounts table. Default is 1.
+ When the scale is 20,000 or larger, the columns used to
+ hold account identifiers (aid columns)
+ will switch to using larger integers (bigint),
+ in order to be big enough to hold the range of account
+ identifiers.
+
--foreign-keys #
+ Create foreign key constraints between the standard tables.
+ (This option adds the f step to the initialization
+ step sequence, if it is not already present.)
+
--index-tablespace=index_tablespace #
+ Create indexes in the specified tablespace, rather than the default
+ tablespace.
+
--partition-method=NAME #
+ Create a partitioned pgbench_accounts table with
+ NAME method.
+ Expected values are range or hash.
+ This option requires that --partitions is set to non-zero.
+ If unspecified, default is range.
+
--partitions=NUM #
+ Create a partitioned pgbench_accounts table with
+ NUM partitions of nearly equal size for
+ the scaled number of accounts.
+ Default is 0, meaning no partitioning.
+
--tablespace=tablespace #
+ Create tables in the specified tablespace, rather than the default
+ tablespace.
+
--unlogged-tables #
+ Create all tables as unlogged tables, rather than permanent tables.
+
+
Benchmarking Options
+ pgbench accepts the following command-line
+ benchmarking arguments:
+
+
-b scriptname[@weight]
--builtin=scriptname[@weight] #
+ Add the specified built-in script to the list of scripts to be executed.
+ Available built-in scripts are: tpcb-like,
+ simple-update and select-only.
+ Unambiguous prefixes of built-in names are accepted.
+ With the special name list, show the list of built-in scripts
+ and exit immediately.
+
+ Optionally, write an integer weight after @ to
+ adjust the probability of selecting this script versus other ones.
+ The default weight is 1.
+ See below for details.
+
-c clients
--client=clients #
+ Number of clients simulated, that is, number of concurrent database
+ sessions. Default is 1.
+
-C
--connect #
+ Establish a new connection for each transaction, rather than
+ doing it just once per client session.
+ This is useful to measure the connection overhead.
+
-d
--debug #
+ Print debugging output.
+
-D varname=value
--define=varname=value #
+ Define a variable for use by a custom script (see below).
+ Multiple -D options are allowed.
+
-f filename[@weight]
--file=filename[@weight] #
+ Add a transaction script read from filename
+ to the list of scripts to be executed.
+
+ Optionally, write an integer weight after @ to
+ adjust the probability of selecting this script versus other ones.
+ The default weight is 1.
+ (To use a script file name that includes an @
+ character, append a weight so that there is no ambiguity, for
+ example filen@me@1.)
+ See below for details.
+
-j threads
--jobs=threads #
+ Number of worker threads within pgbench.
+ Using more than one thread can be helpful on multi-CPU machines.
+ Clients are distributed as evenly as possible among available threads.
+ Default is 1.
+
-l
--log #
+ Write information about each transaction to a log file.
+ See below for details.
+
-L limit
--latency-limit=limit #
+ Transactions that last more than limit milliseconds
+ are counted and reported separately, as late.
+
+ When throttling is used (--rate=...), transactions that
+ lag behind schedule by more than limit ms, and thus
+ have no hope of meeting the latency limit, are not sent to the server
+ at all. They are counted and reported separately as
+ skipped.
+
+ When the --max-tries option is used, a transaction
+ which fails due to a serialization anomaly or from a deadlock will not
+ be retried if the total time of all its tries is greater than
+ limit ms. To limit only the time of tries
+ and not their number, use --max-tries=0. By
+ default, the option --max-tries is set to 1 and
+ transactions with serialization/deadlock errors are not retried. See
+ Failures and Serialization/Deadlock Retries for more information about
+ retrying such transactions.
+
-M querymode
--protocol=querymode #
+ Protocol to use for submitting queries to the server:
+
simple: use simple query protocol.
extended: use extended query protocol.
prepared: use extended query protocol with prepared statements.
+
+ In the prepared mode, pgbench
+ reuses the parse analysis result starting from the second query
+ iteration, so pgbench runs faster
+ than in other modes.
+
+ The default is simple query protocol. (See Chapter 55
+ for more information.)
+
-n
--no-vacuum #
+ Perform no vacuuming before running the test.
+ This option is necessary
+ if you are running a custom test scenario that does not include
+ the standard tables pgbench_accounts,
+ pgbench_branches, pgbench_history, and
+ pgbench_tellers.
+
-N
--skip-some-updates #
+ Run built-in simple-update script.
+ Shorthand for -b simple-update.
+
-P sec
--progress=sec #
+ Show progress report every sec seconds. The report
+ includes the time since the beginning of the run, the TPS since the
+ last report, and the transaction latency average, standard deviation,
+ and the number of failed transactions since the last report. Under
+ throttling (-R), the latency is computed with respect
+ to the transaction scheduled start time, not the actual transaction
+ beginning time, thus it also includes the average schedule lag time.
+ When --max-tries is used to enable transaction retries
+ after serialization/deadlock errors, the report includes the number of
+ retried transactions and the sum of all retries.
+
-r
--report-per-command #
+ Report the following statistics for each command after the benchmark
+ finishes: the average per-statement latency (execution time from the
+ perspective of the client), the number of failures, and the number of
+ retries after serialization or deadlock errors in this command. The
+ report displays retry statistics only if the
+ --max-tries option is not equal to 1.
+
-R rate
--rate=rate #
+ Execute transactions targeting the specified rate instead of running
+ as fast as possible (the default). The rate is given in transactions
+ per second. If the targeted rate is above the maximum possible rate,
+ the rate limit won't impact the results.
+
+ The rate is targeted by starting transactions along a
+ Poisson-distributed schedule time line. The expected start time
+ schedule moves forward based on when the client first started, not
+ when the previous transaction ended. That approach means that when
+ transactions go past their original scheduled end time, it is
+ possible for later ones to catch up again.
+
+ When throttling is active, the transaction latency reported at the
+ end of the run is calculated from the scheduled start times, so it
+ includes the time each transaction had to wait for the previous
+ transaction to finish. The wait time is called the schedule lag time,
+ and its average and maximum are also reported separately. The
+ transaction latency with respect to the actual transaction start time,
+ i.e., the time spent executing the transaction in the database, can be
+ computed by subtracting the schedule lag time from the reported
+ latency.
+
+ If --latency-limit is used together with --rate,
+ a transaction can lag behind so much that it is already over the
+ latency limit when the previous transaction ends, because the latency
+ is calculated from the scheduled start time. Such transactions are
+ not sent to the server, but are skipped altogether and counted
+ separately.
+
+ A high schedule lag time is an indication that the system cannot
+ process transactions at the specified rate, with the chosen number of
+ clients and threads. When the average transaction execution time is
+ longer than the scheduled interval between each transaction, each
+ successive transaction will fall further behind, and the schedule lag
+ time will keep increasing the longer the test run is. When that
+ happens, you will have to reduce the specified transaction rate.
+
-s scale_factor
--scale=scale_factor #
+ Report the specified scale factor in pgbench's
+ output. With the built-in tests, this is not necessary; the
+ correct scale factor will be detected by counting the number of
+ rows in the pgbench_branches table.
+ However, when testing only custom benchmarks (-f option),
+ the scale factor will be reported as 1 unless this option is used.
+
-S
--select-only #
+ Run built-in select-only script.
+ Shorthand for -b select-only.
+
-t transactions
--transactions=transactions #
+ Number of transactions each client runs. Default is 10.
+
-T seconds
--time=seconds #
+ Run the test for this many seconds, rather than a fixed number of
+ transactions per client. -t and
+ -T are mutually exclusive.
+
-v
--vacuum-all #
+ Vacuum all four standard tables before running the test.
+ With neither -n nor -v, pgbench will vacuum the
+ pgbench_tellers and pgbench_branches
+ tables, and will truncate pgbench_history.
+
--aggregate-interval=seconds #
+ Length of aggregation interval (in seconds). May be used only
+ with -l option. With this option, the log contains
+ per-interval summary data, as described below.
+
--failures-detailed #
+ Report failures in per-transaction and aggregation logs, as well as in
+ the main and per-script reports, grouped by the following types:
+
serialization failures;
deadlock failures;
+ See Failures and Serialization/Deadlock Retries for more information.
+
--log-prefix=prefix #
+ Set the filename prefix for the log files created by
+ --log. The default is pgbench_log.
+
--max-tries=number_of_tries #
+ Enable retries for transactions with serialization/deadlock errors and
+ set the maximum number of these tries. This option can be combined with
+ the --latency-limit option which limits the total time
+ of all transaction tries; moreover, you cannot use an unlimited number
+ of tries (--max-tries=0) without
+ --latency-limit or --time.
+ The default value is 1 and transactions with serialization/deadlock
+ errors are not retried. See Failures and Serialization/Deadlock Retries
+ for more information about retrying such transactions.
+
--progress-timestamp #
+ When showing progress (option -P), use a timestamp
+ (Unix epoch) instead of the number of seconds since the
+ beginning of the run. The unit is in seconds, with millisecond
+ precision after the dot.
+ This helps compare logs generated by various tools.
+
--random-seed=seed #
+ Set random generator seed. Seeds the system random number generator,
+ which then produces a sequence of initial generator states, one for
+ each thread.
+ Values for seed may be:
+ time (the default, the seed is based on the current time),
+ rand (use a strong random source, failing if none
+ is available), or an unsigned decimal integer value.
+ The random generator is invoked explicitly from a pgbench script
+ (random... functions) or implicitly (for instance option
+ --rate uses it to schedule transactions).
+ When explicitly set, the value used for seeding is shown on the terminal.
+ Any value allowed for seed may also be
+ provided through the environment variable
+ PGBENCH_RANDOM_SEED.
+ To ensure that the provided seed impacts all possible uses, put this option
+ first or use the environment variable.
+
+ Setting the seed explicitly allows to reproduce a pgbench
+ run exactly, as far as random numbers are concerned.
+ As the random state is managed per thread, this means the exact same
+ pgbench run for an identical invocation if there is one
+ client per thread and there are no external or data dependencies.
+ From a statistical viewpoint reproducing runs exactly is a bad idea because
+ it can hide the performance variability or improve performance unduly,
+ e.g., by hitting the same pages as a previous run.
+ However, it may also be of great help for debugging, for instance
+ re-running a tricky case which leads to an error.
+ Use wisely.
+
--sampling-rate=rate #
+ Sampling rate, used when writing data into the log, to reduce the
+ amount of log generated. If this option is given, only the specified
+ fraction of transactions are logged. 1.0 means all transactions will
+ be logged, 0.05 means only 5% of the transactions will be logged.
+
+ Remember to take the sampling rate into account when processing the
+ log file. For example, when computing TPS values, you need to multiply
+ the numbers accordingly (e.g., with 0.01 sample rate, you'll only get
+ 1/100 of the actual TPS).
+
--show-script=scriptname #
+ Show the actual code of builtin script scriptname
+ on stderr, and exit immediately.
+
--verbose-errors #
+ Print messages about all errors and failures (errors without retrying)
+ including which limit for retries was exceeded and how far it was
+ exceeded for the serialization/deadlock failures. (Note that in this
+ case the output can be significantly increased.).
+ See Failures and Serialization/Deadlock Retries for more information.
+
+
Common Options
+ pgbench also accepts the following common command-line
+ arguments for connection parameters:
+
+
-h hostname
--host=hostname #
+ The database server's host name
+
-p port
--port=port #
+ The database server's port number
+
-U login
--username=login #
+ The user name to connect as
+
-V
--version #
+ Print the pgbench version and exit.
+
-?
--help #
+ Show help about pgbench command line
+ arguments, and exit.
+
+
Exit Status
+ A successful run will exit with status 0. Exit status 1 indicates static
+ problems such as invalid command-line options or internal errors which
+ are supposed to never occur. Early errors that occur when starting
+ benchmark such as initial connection failures also exit with status 1.
+ Errors during the run such as database errors or problems in the script
+ will result in exit status 2. In the latter case,
+ pgbench will print partial results.
+
Environment
PGDATABASE
PGHOST
PGPORT
PGUSER #
+ Default connection parameters.
+
+ This utility, like most other PostgreSQL utilities,
+ uses the environment variables supported by libpq
+ (see Section 34.15).
+
+ The environment variable PG_COLOR specifies whether to use
+ color in diagnostic messages. Possible values are
+ always, auto and
+ never.
+
Notes
What Is the “Transaction” Actually Performed in pgbench?
+ pgbench executes test scripts chosen randomly
+ from a specified list.
+ The scripts may include built-in scripts specified with -b
+ and user-provided scripts specified with -f.
+ Each script may be given a relative weight specified after an
+ @ so as to change its selection probability.
+ The default weight is 1.
+ Scripts with a weight of 0 are ignored.
+
+ The default built-in transaction script (also invoked with -b tpcb-like)
+ issues seven commands per transaction over randomly chosen aid,
+ tid, bid and delta.
+ The scenario is inspired by the TPC-B benchmark, but is not actually TPC-B,
+ hence the name.
+
BEGIN;
UPDATE pgbench_accounts SET abalance = abalance + :delta WHERE aid = :aid;
SELECT abalance FROM pgbench_accounts WHERE aid = :aid;
UPDATE pgbench_tellers SET tbalance = tbalance + :delta WHERE tid = :tid;
UPDATE pgbench_branches SET bbalance = bbalance + :delta WHERE bid = :bid;
INSERT INTO pgbench_history (tid, bid, aid, delta, mtime) VALUES (:tid, :bid, :aid, :delta, CURRENT_TIMESTAMP);
END;
+ If you select the simple-update built-in (also -N),
+ steps 4 and 5 aren't included in the transaction.
+ This will avoid update contention on these tables, but
+ it makes the test case even less like TPC-B.
+
+ If you select the select-only built-in (also -S),
+ only the SELECT is issued.
+
Custom Scripts
+ pgbench has support for running custom
+ benchmark scenarios by replacing the default transaction script
+ (described above) with a transaction script read from a file
+ (-f option). In this case a “transaction”
+ counts as one execution of a script file.
+
+ A script file contains one or more SQL commands terminated by
+ semicolons. Empty lines and lines beginning with
+ -- are ignored. Script files can also contain
+ “meta commands”, which are interpreted by pgbench
+ itself, as described below.
+
Note
+ Before PostgreSQL 9.6, SQL commands in script files
+ were terminated by newlines, and so they could not be continued across
+ lines. Now a semicolon is required to separate consecutive
+ SQL commands (though an SQL command does not need one if it is followed
+ by a meta command). If you need to create a script file that works with
+ both old and new versions of pgbench, be sure to write
+ each SQL command on a single line ending with a semicolon.
+
+ It is assumed that pgbench scripts do not contain incomplete blocks of SQL
+ transactions. If at runtime the client reaches the end of the script without
+ completing the last transaction block, it will be aborted.
+
+ There is a simple variable-substitution facility for script files.
+ Variable names must consist of letters (including non-Latin letters),
+ digits, and underscores, with the first character not being a digit.
+ Variables can be set by the command-line -D option,
+ explained above, or by the meta commands explained below.
+ In addition to any variables preset by -D command-line options,
+ there are a few variables that are preset automatically, listed in
+ Table 293. A value specified for these
+ variables using -D takes precedence over the automatic presets.
+ Once set, a variable's
+ value can be inserted into an SQL command by writing
+ :variablename. When running more than
+ one client session, each session has its own set of variables.
+ pgbench supports up to 255 variable uses in one
+ statement.
+
Table 293. pgbench Automatic Variables
| Variable | Description |
|---|
client_id | unique number identifying the client session (starts from zero) |
default_seed | seed used in hash and pseudorandom permutation functions by default |
random_seed | random generator seed (unless overwritten with -D) |
scale | current scale factor |
+ Script file meta commands begin with a backslash (\) and
+ normally extend to the end of the line, although they can be continued
+ to additional lines by writing backslash-return.
+ Arguments to a meta command are separated by white space.
+ These meta commands are supported:
+
-
+
\gset [prefix]
+ \aset [prefix]
+ #
+ These commands may be used to end SQL queries, taking the place of the
+ terminating semicolon (;).
+
+ When the \gset command is used, the preceding SQL query is
+ expected to return one row, the columns of which are stored into variables
+ named after column names, and prefixed with prefix
+ if provided.
+
+ When the \aset command is used, all combined SQL queries
+ (separated by \;) have their columns stored into variables
+ named after column names, and prefixed with prefix
+ if provided. If a query returns no row, no assignment is made and the variable
+ can be tested for existence to detect this. If a query returns more than one
+ row, the last value is kept.
+
+ \gset and \aset cannot be used in
+ pipeline mode, since the query results are not yet available by the time
+ the commands would need them.
+
+ The following example puts the final account balance from the first query
+ into variable abalance, and fills variables
+ p_two and p_three
+ with integers from the third query.
+ The result of the second query is discarded.
+ The result of the two last combined queries are stored in variables
+ four and five.
+
+UPDATE pgbench_accounts
+ SET abalance = abalance + :delta
+ WHERE aid = :aid
+ RETURNING abalance \gset
+-- compound of two queries
+SELECT 1 \;
+SELECT 2 AS two, 3 AS three \gset p_
+SELECT 4 AS four \; SELECT 5 AS five \aset
+
\if expression
\elif expression
\else
\endif #
+ This group of commands implements nestable conditional blocks,
+ similarly to psql's \if expression.
+ Conditional expressions are identical to those with \set,
+ with non-zero values interpreted as true.
+
-
+
\set varname expression
+ #
+ Sets variable varname to a value calculated
+ from expression.
+ The expression may contain the NULL constant,
+ Boolean constants TRUE and FALSE,
+ integer constants such as 5432,
+ double constants such as 3.14159,
+ references to variables :variablename,
+ operators
+ with their usual SQL precedence and associativity,
+ function calls,
+ SQL CASE generic conditional
+ expressions and parentheses.
+
+ Functions and most operators return NULL on
+ NULL input.
+
+ For conditional purposes, non zero numerical values are
+ TRUE, zero numerical values and NULL
+ are FALSE.
+
+ Too large or small integer and double constants, as well as
+ integer arithmetic operators (+,
+ -, * and /)
+ raise errors on overflows.
+
+ When no final ELSE clause is provided to a
+ CASE, the default value is NULL.
+
+ Examples:
+
+\set ntellers 10 * :scale
+\set aid (1021 * random(1, 100000 * :scale)) % \
+ (100000 * :scale) + 1
+\set divx CASE WHEN :x <> 0 THEN :y/:x ELSE NULL END
+
-
+
\sleep number [ us | ms | s ]
+ #
+ Causes script execution to sleep for the specified duration in
+ microseconds (us), milliseconds (ms) or seconds
+ (s). If the unit is omitted then seconds are the default.
+ number can be either an integer constant or a
+ :variablename reference to a variable
+ having an integer value.
+
+ Example:
+
+\sleep 10 ms
+
-
+
\setshell varname command [ argument ... ]
+ #
+ Sets variable varname to the result of the shell command
+ command with the given argument(s).
+ The command must return an integer value through its standard output.
+
+ command and each argument can be either
+ a text constant or a :variablename reference
+ to a variable. If you want to use an argument starting
+ with a colon, write an additional colon at the beginning of
+ argument.
+
+ Example:
+
+\setshell variable_to_be_assigned command literal_argument :variable ::literal_starting_with_colon
+
-
+
\shell command [ argument ... ]
+ #
+ Same as \setshell, but the result of the command
+ is discarded.
+
+ Example:
+
+\shell command literal_argument :variable ::literal_starting_with_colon
+
\startpipeline
\endpipeline #
+ These commands delimit the start and end of a pipeline of SQL
+ statements. In pipeline mode, statements are sent to the server
+ without waiting for the results of previous statements. See
+ Section 34.5 for more details.
+ Pipeline mode requires the use of extended query protocol.
+
Built-in Operators
+ The arithmetic, bitwise, comparison and logical operators listed in
+ Table 294 are built into pgbench
+ and may be used in expressions appearing in
+ \set.
+ The operators are listed in increasing precedence order.
+ Except as noted, operators taking two numeric inputs will produce
+ a double value if either input is double, otherwise they produce
+ an integer result.
+
Table 294. pgbench Operators
+ Operator
+
+
+ Description
+
+
+ Example(s)
+ |
|---|
+ boolean OR boolean
+ → boolean
+
+ Logical OR
+
+
+ 5 or 0
+ → TRUE
+ |
+ boolean AND boolean
+ → boolean
+
+ Logical AND
+
+
+ 3 and 0
+ → FALSE
+ |
+ NOT boolean
+ → boolean
+
+ Logical NOT
+
+
+ not false
+ → TRUE
+ |
+ boolean IS [NOT] (NULL|TRUE|FALSE)
+ → boolean
+
+ Boolean value tests
+
+
+ 1 is null
+ → FALSE
+ |
+ value ISNULL|NOTNULL
+ → boolean
+
+ Nullness tests
+
+
+ 1 notnull
+ → TRUE
+ |
+ number = number
+ → boolean
+
+ Equal
+
+
+ 5 = 4
+ → FALSE
+ |
+ number <> number
+ → boolean
+
+ Not equal
+
+
+ 5 <> 4
+ → TRUE
+ |
+ number != number
+ → boolean
+
+ Not equal
+
+
+ 5 != 5
+ → FALSE
+ |
+ number < number
+ → boolean
+
+ Less than
+
+
+ 5 < 4
+ → FALSE
+ |
+ number <= number
+ → boolean
+
+ Less than or equal to
+
+
+ 5 <= 4
+ → FALSE
+ |
+ number > number
+ → boolean
+
+ Greater than
+
+
+ 5 > 4
+ → TRUE
+ |
+ number >= number
+ → boolean
+
+ Greater than or equal to
+
+
+ 5 >= 4
+ → TRUE
+ |
+ integer | integer
+ → integer
+
+ Bitwise OR
+
+
+ 1 | 2
+ → 3
+ |
+ integer # integer
+ → integer
+
+ Bitwise XOR
+
+
+ 1 # 3
+ → 2
+ |
+ integer & integer
+ → integer
+
+ Bitwise AND
+
+
+ 1 & 3
+ → 1
+ |
+ ~ integer
+ → integer
+
+ Bitwise NOT
+
+
+ ~ 1
+ → -2
+ |
+ integer << integer
+ → integer
+
+ Bitwise shift left
+
+
+ 1 << 2
+ → 4
+ |
+ integer >> integer
+ → integer
+
+ Bitwise shift right
+
+
+ 8 >> 2
+ → 2
+ |
+ number + number
+ → number
+
+ Addition
+
+
+ 5 + 4
+ → 9
+ |
+ number - number
+ → number
+
+ Subtraction
+
+
+ 3 - 2.0
+ → 1.0
+ |
+ number * number
+ → number
+
+ Multiplication
+
+
+ 5 * 4
+ → 20
+ |
+ number / number
+ → number
+
+ Division (truncates the result towards zero if both inputs are integers)
+
+
+ 5 / 3
+ → 1
+ |
+ integer % integer
+ → integer
+
+ Modulo (remainder)
+
+
+ 3 % 2
+ → 1
+ |
+ - number
+ → number
+
+ Negation
+
+
+ - 2.0
+ → -2.0
+ |
Built-In Functions
+ The functions listed in Table 295 are built
+ into pgbench and may be used in expressions appearing in
+ \set.
+
Table 295. pgbench Functions
+ Function
+
+
+ Description
+
+
+ Example(s)
+ |
|---|
+ abs ( number )
+ →
+
+ Absolute value
+
+
+ abs(-17)
+ → 17
+ |
+ debug ( number )
+ →
+
+ Prints the argument to stderr,
+ and returns the argument.
+
+
+ debug(5432.1)
+ → 5432.1
+ |
+ double ( number )
+ → double
+
+
+ Casts to double.
+
+
+ double(5432)
+ → 5432.0
+ |
+ exp ( number )
+ → double
+
+
+ Exponential (e raised to the given power)
+
+
+ exp(1.0)
+ → 2.718281828459045
+ |
+ greatest ( number [, ... ] )
+ → double if any argument is double, else integer
+
+
+ Selects the largest value among the arguments.
+
+
+ greatest(5, 4, 3, 2)
+ → 5
+ |
+ hash ( value [, seed ] )
+ → integer
+
+
+ This is an alias for hash_murmur2.
+
+
+ hash(10, 5432)
+ → -5817877081768721676
+ |
+ hash_fnv1a ( value [, seed ] )
+ → integer
+
+
+ Computes FNV-1a hash.
+
+
+ hash_fnv1a(10, 5432)
+ → -7793829335365542153
+ |
+ hash_murmur2 ( value [, seed ] )
+ → integer
+
+
+ Computes MurmurHash2 hash.
+
+
+ hash_murmur2(10, 5432)
+ → -5817877081768721676
+ |
+ int ( number )
+ → integer
+
+
+ Casts to integer.
+
+
+ int(5.4 + 3.8)
+ → 9
+ |
+ least ( number [, ... ] )
+ → double if any argument is double, else integer
+
+
+ Selects the smallest value among the arguments.
+
+
+ least(5, 4, 3, 2.1)
+ → 2.1
+ |
+ ln ( number )
+ → double
+
+
+ Natural logarithm
+
+
+ ln(2.718281828459045)
+ → 1.0
+ |
+mod ( integer, integer )
+ → integer
+
+
+ Modulo (remainder)
+
+
+ mod(54, 32)
+ → 22
+ |
+ permute ( i, size [, seed ] )
+ → integer
+
+
+ Permuted value of i, in the range
+ [0, size). This is the new position of
+ i (modulo size) in a
+ pseudorandom permutation of the integers 0...size-1,
+ parameterized by seed, see below.
+
+
+ permute(0, 4)
+ → an integer between 0 and 3
+ |
+ pi ()
+ → double
+
+
+ Approximate value of π
+
+
+ pi()
+ → 3.14159265358979323846
+ |
+ pow ( x, y )
+ → double
+
+
+ power ( x, y )
+ → double
+
+
+ x raised to the power of y
+
+
+ pow(2.0, 10)
+ → 1024.0
+ |
+ random ( lb, ub )
+ → integer
+
+
+ Computes a uniformly-distributed random integer in [lb,
+ ub].
+
+
+ random(1, 10)
+ → an integer between 1 and 10
+ |
+ random_exponential ( lb, ub, parameter )
+ → integer
+
+
+ Computes an exponentially-distributed random integer in [lb,
+ ub], see below.
+
+
+ random_exponential(1, 10, 3.0)
+ → an integer between 1 and 10
+ |
+ random_gaussian ( lb, ub, parameter )
+ → integer
+
+
+ Computes a Gaussian-distributed random integer in [lb,
+ ub], see below.
+
+
+ random_gaussian(1, 10, 2.5)
+ → an integer between 1 and 10
+ |
+ random_zipfian ( lb, ub, parameter )
+ → integer
+
+
+ Computes a Zipfian-distributed random integer in [lb,
+ ub], see below.
+
+
+ random_zipfian(1, 10, 1.5)
+ → an integer between 1 and 10
+ |
+ sqrt ( number )
+ → double
+
+
+ Square root
+
+
+ sqrt(2.0)
+ → 1.414213562
+ |
+ The random function generates values using a uniform
+ distribution, that is all the values are drawn within the specified
+ range with equal probability. The random_exponential,
+ random_gaussian and random_zipfian
+ functions require an additional double parameter which determines the precise
+ shape of the distribution.
+
+ For an exponential distribution, parameter
+ controls the distribution by truncating a quickly-decreasing
+ exponential distribution at parameter, and then
+ projecting onto integers between the bounds.
+ To be precise, with
+
+f(x) = exp(-parameter * (x - min) / (max - min + 1)) / (1 - exp(-parameter))
+
+ Then value i between min and
+ max inclusive is drawn with probability:
+ f(i) - f(i + 1).
+
+ Intuitively, the larger the parameter, the more
+ frequently values close to min are accessed, and the
+ less frequently values close to max are accessed.
+ The closer to 0 parameter is, the flatter (more
+ uniform) the access distribution.
+ A crude approximation of the distribution is that the most frequent 1%
+ values in the range, close to min, are drawn
+ parameter% of the time.
+ The parameter value must be strictly positive.
+
+ For a Gaussian distribution, the interval is mapped onto a standard
+ normal distribution (the classical bell-shaped Gaussian curve) truncated
+ at -parameter on the left and +parameter
+ on the right.
+ Values in the middle of the interval are more likely to be drawn.
+ To be precise, if PHI(x) is the cumulative distribution
+ function of the standard normal distribution, with mean mu
+ defined as (max + min) / 2.0, with
+
+f(x) = PHI(2.0 * parameter * (x - mu) / (max - min + 1)) /
+ (2.0 * PHI(parameter) - 1)
+
+ then value i between min and
+ max inclusive is drawn with probability:
+ f(i + 0.5) - f(i - 0.5).
+ Intuitively, the larger the parameter, the more
+ frequently values close to the middle of the interval are drawn, and the
+ less frequently values close to the min and
+ max bounds. About 67% of values are drawn from the
+ middle 1.0 / parameter, that is a relative
+ 0.5 / parameter around the mean, and 95% in the middle
+ 2.0 / parameter, that is a relative
+ 1.0 / parameter around the mean; for instance, if
+ parameter is 4.0, 67% of values are drawn from the
+ middle quarter (1.0 / 4.0) of the interval (i.e., from
+ 3.0 / 8.0 to 5.0 / 8.0) and 95% from
+ the middle half (2.0 / 4.0) of the interval (second and third
+ quartiles). The minimum allowed parameter
+ value is 2.0.
+
+ random_zipfian generates a bounded Zipfian
+ distribution.
+ parameter defines how skewed the distribution
+ is. The larger the parameter, the more
+ frequently values closer to the beginning of the interval are drawn.
+ The distribution is such that, assuming the range starts from 1,
+ the ratio of the probability of drawing k
+ versus drawing k+1 is
+ ((k+1)/k)**parameter.
+ For example, random_zipfian(1, ..., 2.5) produces
+ the value 1 about (2/1)**2.5 =
+ 5.66 times more frequently than 2, which
+ itself is produced (3/2)**2.5 = 2.76 times more
+ frequently than 3, and so on.
+
+ pgbench's implementation is based on
+ "Non-Uniform Random Variate Generation", Luc Devroye, p. 550-551,
+ Springer 1986. Due to limitations of that algorithm,
+ the parameter value is restricted to
+ the range [1.001, 1000].
+
Note
+ When designing a benchmark which selects rows non-uniformly, be aware
+ that the rows chosen may be correlated with other data such as IDs from
+ a sequence or the physical row ordering, which may skew performance
+ measurements.
+
+ To avoid this, you may wish to use the permute
+ function, or some other additional step with similar effect, to shuffle
+ the selected rows and remove such correlations.
+
+ Hash functions hash, hash_murmur2 and
+ hash_fnv1a accept an input value and an optional seed parameter.
+ In case the seed isn't provided the value of :default_seed
+ is used, which is initialized randomly unless set by the command-line
+ -D option.
+
+ permute accepts an input value, a size, and an optional
+ seed parameter. It generates a pseudorandom permutation of integers in
+ the range [0, size), and returns the index of the input
+ value in the permuted values. The permutation chosen is parameterized by
+ the seed, which defaults to :default_seed, if not
+ specified. Unlike the hash functions, permute ensures
+ that there are no collisions or holes in the output values. Input values
+ outside the interval are interpreted modulo the size. The function raises
+ an error if the size is not positive. permute can be
+ used to scatter the distribution of non-uniform random functions such as
+ random_zipfian or random_exponential
+ so that values drawn more often are not trivially correlated. For
+ instance, the following pgbench script
+ simulates a possible real world workload typical for social media and
+ blogging platforms where a few accounts generate excessive load:
+
+
+\set size 1000000
+\set r random_zipfian(1, :size, 1.07)
+\set k 1 + permute(:r, :size)
+
+
+ In some cases several distinct distributions are needed which don't correlate
+ with each other and this is when the optional seed parameter comes in handy:
+
+
+\set k1 1 + permute(:r, :size, :default_seed + 123)
+\set k2 1 + permute(:r, :size, :default_seed + 321)
+
+
+ A similar behavior can also be approximated with hash:
+
+
+\set size 1000000
+\set r random_zipfian(1, 100 * :size, 1.07)
+\set k 1 + abs(hash(:r)) % :size
+
+
+ However, since hash generates collisions, some values
+ will not be reachable and others will be more frequent than expected from
+ the original distribution.
+
+ As an example, the full definition of the built-in TPC-B-like
+ transaction is:
+
+
+\set aid random(1, 100000 * :scale)
+\set bid random(1, 1 * :scale)
+\set tid random(1, 10 * :scale)
+\set delta random(-5000, 5000)
+BEGIN;
+UPDATE pgbench_accounts SET abalance = abalance + :delta WHERE aid = :aid;
+SELECT abalance FROM pgbench_accounts WHERE aid = :aid;
+UPDATE pgbench_tellers SET tbalance = tbalance + :delta WHERE tid = :tid;
+UPDATE pgbench_branches SET bbalance = bbalance + :delta WHERE bid = :bid;
+INSERT INTO pgbench_history (tid, bid, aid, delta, mtime) VALUES (:tid, :bid, :aid, :delta, CURRENT_TIMESTAMP);
+END;
+
+
+ This script allows each iteration of the transaction to reference
+ different, randomly-chosen rows. (This example also shows why it's
+ important for each client session to have its own variables —
+ otherwise they'd not be independently touching different rows.)
+
Per-Transaction Logging
+ With the -l option (but without
+ the --aggregate-interval option),
+ pgbench writes information about each transaction
+ to a log file. The log file will be named
+ prefix.nnnprefix defaults to pgbench_log, and
+ nnn is the PID of the
+ pgbench process.
+ The prefix can be changed by using the --log-prefix option.
+ If the -j option is 2 or higher, so that there are multiple
+ worker threads, each will have its own log file. The first worker will
+ use the same name for its log file as in the standard single worker case.
+ The additional log files for the other workers will be named
+ prefix.nnn.mmmmmm is a sequential number for each worker starting
+ with 1.
+
+ Each line in a log file describes one transaction.
+ It contains the following space-separated fields:
+
+
client_id
+ identifies the client session that ran the transaction
+
transaction_no
+ counts how many transactions have been run by that session
+
time
+ transaction's elapsed time, in microseconds
+
script_no
+ identifies the script file that was used for the transaction
+ (useful when multiple scripts are specified
+ with -f or -b)
+
time_epoch
+ transaction's completion time, as a Unix-epoch time stamp
+
time_us
+ fractional-second part of transaction's completion time, in
+ microseconds
+
schedule_lag
+ transaction start delay, that is the difference between the
+ transaction's scheduled start time and the time it actually
+ started, in microseconds
+ (present only if --rate is specified)
+
retries
+ count of retries after serialization or deadlock errors during the
+ transaction
+ (present only if --max-tries is not equal to one)
+
+
+ When both --rate and --latency-limit are used,
+ the time for a skipped transaction will be reported as
+ skipped.
+ If the transaction ends with a failure, its time
+ will be reported as failed. If you use the
+ --failures-detailed option, the
+ time of the failed transaction will be reported as
+ serialization or
+ deadlock depending on the type of failure (see
+ Failures and Serialization/Deadlock Retries for more information).
+
+ Here is a snippet of a log file generated in a single-client run:
+
+0 199 2241 0 1175850568 995598
+0 200 2465 0 1175850568 998079
+0 201 2513 0 1175850569 608
+0 202 2038 0 1175850569 2663
+
+
+ Another example with --rate=100
+ and --latency-limit=5 (note the additional
+ schedule_lag column):
+
+0 81 4621 0 1412881037 912698 3005
+0 82 6173 0 1412881037 914578 4304
+0 83 skipped 0 1412881037 914578 5217
+0 83 skipped 0 1412881037 914578 5099
+0 83 4722 0 1412881037 916203 3108
+0 84 4142 0 1412881037 918023 2333
+0 85 2465 0 1412881037 919759 740
+
+ In this example, transaction 82 was late, because its latency (6.173 ms) was
+ over the 5 ms limit. The next two transactions were skipped, because they
+ were already late before they were even started.
+
+ The following example shows a snippet of a log file with failures and
+ retries, with the maximum number of tries set to 10 (note the additional
+ retries column):
+
+3 0 47423 0 1499414498 34501 3
+3 1 8333 0 1499414498 42848 0
+3 2 8358 0 1499414498 51219 0
+4 0 72345 0 1499414498 59433 6
+1 3 41718 0 1499414498 67879 4
+1 4 8416 0 1499414498 76311 0
+3 3 33235 0 1499414498 84469 3
+0 0 failed 0 1499414498 84905 9
+2 0 failed 0 1499414498 86248 9
+3 4 8307 0 1499414498 92788 0
+
+
+ If the --failures-detailed option is used, the type of
+ failure is reported in the time like this:
+
+3 0 47423 0 1499414498 34501 3
+3 1 8333 0 1499414498 42848 0
+3 2 8358 0 1499414498 51219 0
+4 0 72345 0 1499414498 59433 6
+1 3 41718 0 1499414498 67879 4
+1 4 8416 0 1499414498 76311 0
+3 3 33235 0 1499414498 84469 3
+0 0 serialization 0 1499414498 84905 9
+2 0 serialization 0 1499414498 86248 9
+3 4 8307 0 1499414498 92788 0
+
+
+ When running a long test on hardware that can handle a lot of transactions,
+ the log files can become very large. The --sampling-rate option
+ can be used to log only a random sample of transactions.
+
Aggregated Logging
+ With the --aggregate-interval option, a different
+ format is used for the log files. Each log line describes one
+ aggregation interval. It contains the following space-separated
+ fields:
+
+
interval_start
+ start time of the interval, as a Unix-epoch time stamp
+
num_transactions
+ number of transactions within the interval
+
sum_latency
+ sum of transaction latencies
+
sum_latency_2
+ sum of squares of transaction latencies
+
min_latency
+ minimum transaction latency
+
max_latency
+ maximum transaction latency
+
sum_lag
+ sum of transaction start delays
+ (zero unless --rate is specified)
+
sum_lag_2
+ sum of squares of transaction start delays
+ (zero unless --rate is specified)
+
min_lag
+ minimum transaction start delay
+ (zero unless --rate is specified)
+
max_lag
+ maximum transaction start delay
+ (zero unless --rate is specified)
+
skipped
+ number of transactions skipped because they would have started too late
+ (zero unless --rate
+ and --latency-limit are specified)
+
retried
+ number of retried transactions
+ (zero unless --max-tries is not equal to one)
+
retries
+ number of retries after serialization or deadlock errors
+ (zero unless --max-tries is not equal to one)
+
serialization_failures
+ number of transactions that got a serialization error and were not
+ retried afterwards
+ (zero unless --failures-detailed is specified)
+
deadlock_failures
+ number of transactions that got a deadlock error and were not
+ retried afterwards
+ (zero unless --failures-detailed is specified)
+
+
+ Here is some example output generated with these options:
+
+pgbench --aggregate-interval=10 --time=20 --client=10 --log --rate=1000 --latency-limit=10 --failures-detailed --max-tries=10 test
+
+1650260552 5178 26171317 177284491527 1136 44462 2647617 7321113867 0 9866 64 7564 28340 4148 0
+1650260562 4808 25573984 220121792172 1171 62083 3037380 9666800914 0 9998 598 7392 26621 4527 0
+
+
+ Notice that while the plain (unaggregated) log format shows which script
+ was used for each transaction, the aggregated format does not. Therefore if
+ you need per-script data, you need to aggregate the data on your own.
+
Per-Statement Report
+ With the -r option, pgbench
+ collects the following statistics for each statement:
+
+
+ The report displays retry statistics only if the --max-tries
+ option is not equal to 1.
+
+ All values are computed for each statement executed by every client and are
+ reported after the benchmark has finished.
+
+ For the default script, the output will look similar to this:
+
+starting vacuum...end.
+transaction type: <builtin: TPC-B (sort of)>
+scaling factor: 1
+query mode: simple
+number of clients: 10
+number of threads: 1
+maximum number of tries: 1
+number of transactions per client: 1000
+number of transactions actually processed: 10000/10000
+number of failed transactions: 0 (0.000%)
+number of transactions above the 50.0 ms latency limit: 1311/10000 (13.110 %)
+latency average = 28.488 ms
+latency stddev = 21.009 ms
+initial connection time = 69.068 ms
+tps = 346.224794 (without initial connection time)
+statement latencies in milliseconds and failures:
+ 0.012 0 \set aid random(1, 100000 * :scale)
+ 0.002 0 \set bid random(1, 1 * :scale)
+ 0.002 0 \set tid random(1, 10 * :scale)
+ 0.002 0 \set delta random(-5000, 5000)
+ 0.319 0 BEGIN;
+ 0.834 0 UPDATE pgbench_accounts SET abalance = abalance + :delta WHERE aid = :aid;
+ 0.641 0 SELECT abalance FROM pgbench_accounts WHERE aid = :aid;
+ 11.126 0 UPDATE pgbench_tellers SET tbalance = tbalance + :delta WHERE tid = :tid;
+ 12.961 0 UPDATE pgbench_branches SET bbalance = bbalance + :delta WHERE bid = :bid;
+ 0.634 0 INSERT INTO pgbench_history (tid, bid, aid, delta, mtime) VALUES (:tid, :bid, :aid, :delta, CURRENT_TIMESTAMP);
+ 1.957 0 END;
+
+
+ Another example of output for the default script using serializable default
+ transaction isolation level (PGOPTIONS='-c
+ default_transaction_isolation=serializable' pgbench ...):
+
+starting vacuum...end.
+transaction type: <builtin: TPC-B (sort of)>
+scaling factor: 1
+query mode: simple
+number of clients: 10
+number of threads: 1
+maximum number of tries: 10
+number of transactions per client: 1000
+number of transactions actually processed: 6317/10000
+number of failed transactions: 3683 (36.830%)
+number of transactions retried: 7667 (76.670%)
+total number of retries: 45339
+number of transactions above the 50.0 ms latency limit: 106/6317 (1.678 %)
+latency average = 17.016 ms
+latency stddev = 13.283 ms
+initial connection time = 45.017 ms
+tps = 186.792667 (without initial connection time)
+statement latencies in milliseconds, failures and retries:
+ 0.006 0 0 \set aid random(1, 100000 * :scale)
+ 0.001 0 0 \set bid random(1, 1 * :scale)
+ 0.001 0 0 \set tid random(1, 10 * :scale)
+ 0.001 0 0 \set delta random(-5000, 5000)
+ 0.385 0 0 BEGIN;
+ 0.773 0 1 UPDATE pgbench_accounts SET abalance = abalance + :delta WHERE aid = :aid;
+ 0.624 0 0 SELECT abalance FROM pgbench_accounts WHERE aid = :aid;
+ 1.098 320 3762 UPDATE pgbench_tellers SET tbalance = tbalance + :delta WHERE tid = :tid;
+ 0.582 3363 41576 UPDATE pgbench_branches SET bbalance = bbalance + :delta WHERE bid = :bid;
+ 0.465 0 0 INSERT INTO pgbench_history (tid, bid, aid, delta, mtime) VALUES (:tid, :bid, :aid, :delta, CURRENT_TIMESTAMP);
+ 1.933 0 0 END;
+
+ If multiple script files are specified, all statistics are reported
+ separately for each script file.
+
+ Note that collecting the additional timing information needed for
+ per-statement latency computation adds some overhead. This will slow
+ average execution speed and lower the computed TPS. The amount
+ of slowdown varies significantly depending on platform and hardware.
+ Comparing average TPS values with and without latency reporting enabled
+ is a good way to measure if the timing overhead is significant.
+
Failures and Serialization/Deadlock Retries
+ When executing pgbench, there are three main types
+ of errors:
+
+ Errors of the main program. They are the most serious and always result
+ in an immediate exit from pgbench with the
+ corresponding error message. They include:
+
+ errors at the beginning of pgbench
+ (e.g. an invalid option value);
+
+ errors in the initialization mode (e.g. the query to create
+ tables for built-in scripts fails);
+
+ errors before starting threads (e.g. could not connect to the
+ database server, syntax error in the meta command, thread
+ creation failure);
+
+ internal pgbench errors (which are
+ supposed to never occur...).
+
+ Errors when the thread manages its clients (e.g. the client could not
+ start a connection to the database server / the socket for connecting
+ the client to the database server has become invalid). In such cases
+ all clients of this thread stop while other threads continue to work.
+
+ Direct client errors. They lead to immediate exit from
+ pgbench with the corresponding error message
+ only in the case of an internal pgbench
+ error (which are supposed to never occur...). Otherwise in the worst
+ case they only lead to the abortion of the failed client while other
+ clients continue their run (but some client errors are handled without
+ an abortion of the client and reported separately, see below). Later in
+ this section it is assumed that the discussed errors are only the
+ direct client errors and they are not internal
+ pgbench errors.
+
+
+ A client's run is aborted in case of a serious error; for example, the
+ connection with the database server was lost or the end of script was reached
+ without completing the last transaction. In addition, if execution of an SQL
+ or meta command fails for reasons other than serialization or deadlock errors,
+ the client is aborted. Otherwise, if an SQL command fails with serialization or
+ deadlock errors, the client is not aborted. In such cases, the current
+ transaction is rolled back, which also includes setting the client variables
+ as they were before the run of this transaction (it is assumed that one
+ transaction script contains only one transaction; see
+ What Is the "Transaction" Actually Performed in pgbench? for more information).
+ Transactions with serialization or deadlock errors are repeated after
+ rollbacks until they complete successfully or reach the maximum
+ number of tries (specified by the --max-tries option) / the maximum
+ time of retries (specified by the --latency-limit option) / the end
+ of benchmark (specified by the --time option). If
+ the last trial run fails, this transaction will be reported as failed but
+ the client is not aborted and continues to work.
+
Note
+ Without specifying the --max-tries option, a transaction will
+ never be retried after a serialization or deadlock error because its default
+ value is 1. Use an unlimited number of tries (--max-tries=0)
+ and the --latency-limit option to limit only the maximum time
+ of tries. You can also use the --time option to limit the
+ benchmark duration under an unlimited number of tries.
+
+ Be careful when repeating scripts that contain multiple transactions: the
+ script is always retried completely, so successful transactions can be
+ performed several times.
+
+ Be careful when repeating transactions with shell commands. Unlike the
+ results of SQL commands, the results of shell commands are not rolled back,
+ except for the variable value of the \setshell command.
+
+ The latency of a successful transaction includes the entire time of
+ transaction execution with rollbacks and retries. The latency is measured
+ only for successful transactions and commands but not for failed transactions
+ or commands.
+
+ The main report contains the number of failed transactions. If the
+ --max-tries option is not equal to 1, the main report also
+ contains statistics related to retries: the total number of retried
+ transactions and total number of retries. The per-script report inherits all
+ these fields from the main report. The per-statement report displays retry
+ statistics only if the --max-tries option is not equal to 1.
+
+ If you want to group failures by basic types in per-transaction and
+ aggregation logs, as well as in the main and per-script reports, use the
+ --failures-detailed option. If you also want to distinguish
+ all errors and failures (errors without retrying) by type including which
+ limit for retries was exceeded and how much it was exceeded by for the
+ serialization/deadlock failures, use the --verbose-errors
+ option.
+
Table Access Methods
+ You may specify the Table Access Method
+ for the pgbench tables. The environment variable PGOPTIONS
+ specifies database configuration options that are passed to PostgreSQL via
+ the command line (See Section 20.1.4).
+ For example, a hypothetical default Table Access Method for the tables that
+ pgbench creates called wuzza can be specified with:
+
+PGOPTIONS='-c default_table_access_method=wuzza'
+
+
Good Practices
+ It is very easy to use pgbench to produce completely
+ meaningless numbers. Here are some guidelines to help you get useful
+ results.
+
+ In the first place, never believe any test that runs
+ for only a few seconds. Use the -t or -T option
+ to make the run last at least a few minutes, so as to average out noise.
+ In some cases you could need hours to get numbers that are reproducible.
+ It's a good idea to try the test run a few times, to find out if your
+ numbers are reproducible or not.
+
+ For the default TPC-B-like test scenario, the initialization scale factor
+ (-s) should be at least as large as the largest number of
+ clients you intend to test (-c); else you'll mostly be
+ measuring update contention. There are only -s rows in
+ the pgbench_branches table, and every transaction wants to
+ update one of them, so -c values in excess of -s
+ will undoubtedly result in lots of transactions blocked waiting for
+ other transactions.
+
+ The default test scenario is also quite sensitive to how long it's been
+ since the tables were initialized: accumulation of dead rows and dead space
+ in the tables changes the results. To understand the results you must keep
+ track of the total number of updates and when vacuuming happens. If
+ autovacuum is enabled it can result in unpredictable changes in measured
+ performance.
+
+ A limitation of pgbench is that it can itself become
+ the bottleneck when trying to test a large number of client sessions.
+ This can be alleviated by running pgbench on a different
+ machine from the database server, although low network latency will be
+ essential. It might even be useful to run several pgbench
+ instances concurrently, on several client machines, against the same
+ database server.
+
Security
+ If untrusted users have access to a database that has not adopted a
+ secure schema usage pattern,
+ do not run pgbench in that
+ database. pgbench uses unqualified names and
+ does not manipulate the search path.
+
F.27. pg_buffercache — inspect PostgreSQL
+ buffer cache state #
+ The pg_buffercache module provides a means for
+ examining what's happening in the shared buffer cache in real time.
+
+ This module provides the pg_buffercache_pages()
+ function (wrapped in the pg_buffercache view),
+ the pg_buffercache_summary() function, and the
+ pg_buffercache_usage_counts() function.
+
+ The pg_buffercache_pages() function returns a set of
+ records, each row describing the state of one shared buffer entry. The
+ pg_buffercache view wraps the function for
+ convenient use.
+
+ The pg_buffercache_summary() function returns a single
+ row summarizing the state of the shared buffer cache.
+
+ The pg_buffercache_usage_counts() function returns a set
+ of records, each row describing the number of buffers with a given usage
+ count.
+
+ By default, use is restricted to superusers and roles with privileges of the
+ pg_monitor role. Access may be granted to others
+ using GRANT.
+
F.27.1. The pg_buffercache View #
+ The definitions of the columns exposed by the view are shown in Table F.15.
+
Table F.15. pg_buffercache Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ bufferid integer
+
+
+ ID, in the range 1..shared_buffers
+ |
+ relfilenode oid
+ (references pg_class.relfilenode)
+
+
+ Filenode number of the relation
+ |
+ reltablespace oid
+ (references pg_tablespace.oid)
+
+
+ Tablespace OID of the relation
+ |
+ reldatabase oid
+ (references pg_database.oid)
+
+
+ Database OID of the relation
+ |
+ relforknumber smallint
+
+
+ Fork number within the relation; see
+ common/relpath.h
+ |
+ relblocknumber bigint
+
+
+ Page number within the relation
+ |
+ isdirty boolean
+
+
+ Is the page dirty?
+ |
+ usagecount smallint
+
+
+ Clock-sweep access count
+ |
+ pinning_backends integer
+
+
+ Number of backends pinning this buffer
+ |
+ There is one row for each buffer in the shared cache. Unused buffers are
+ shown with all fields null except bufferid. Shared system
+ catalogs are shown as belonging to database zero.
+
+ Because the cache is shared by all the databases, there will normally be
+ pages from relations not belonging to the current database. This means
+ that there may not be matching join rows in pg_class for
+ some rows, or that there could even be incorrect joins. If you are
+ trying to join against pg_class, it's a good idea to
+ restrict the join to rows having reldatabase equal to
+ the current database's OID or zero.
+
+ Since buffer manager locks are not taken to copy the buffer state data that
+ the view will display, accessing pg_buffercache view
+ has less impact on normal buffer activity but it doesn't provide a consistent
+ set of results across all buffers. However, we ensure that the information of
+ each buffer is self-consistent.
+
F.27.2. The pg_buffercache_summary() Function #
+ The definitions of the columns exposed by the function are shown in Table F.16.
+
Table F.16. pg_buffercache_summary() Output Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ buffers_used int4
+
+
+ Number of used shared buffers
+ |
+ buffers_unused int4
+
+
+ Number of unused shared buffers
+ |
+ buffers_dirty int4
+
+
+ Number of dirty shared buffers
+ |
+ buffers_pinned int4
+
+
+ Number of pinned shared buffers
+ |
+ usagecount_avg float8
+
+
+ Average usage count of used shared buffers
+ |
+ The pg_buffercache_summary() function returns a
+ single row summarizing the state of all shared buffers. Similar and more
+ detailed information is provided by the
+ pg_buffercache view, but
+ pg_buffercache_summary() is significantly cheaper.
+
+ Like the pg_buffercache view,
+ pg_buffercache_summary() does not acquire buffer
+ manager locks. Therefore concurrent activity can lead to minor inaccuracies
+ in the result.
+
F.27.3. The pg_buffercache_usage_counts() Function #
+ The definitions of the columns exposed by the function are shown in
+ Table F.17.
+
Table F.17. pg_buffercache_usage_counts() Output Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ usage_count int4
+
+
+ A possible buffer usage count
+ |
+ buffers int4
+
+
+ Number of buffers with the usage count
+ |
+ dirty int4
+
+
+ Number of dirty buffers with the usage count
+ |
+ pinned int4
+
+
+ Number of pinned buffers with the usage count
+ |
+ The pg_buffercache_usage_counts() function returns a
+ set of rows summarizing the states of all shared buffers, aggregated over
+ the possible usage count values. Similar and more detailed information is
+ provided by the pg_buffercache view, but
+ pg_buffercache_usage_counts() is significantly cheaper.
+
+ Like the pg_buffercache view,
+ pg_buffercache_usage_counts() does not acquire buffer
+ manager locks. Therefore concurrent activity can lead to minor inaccuracies
+ in the result.
+
+regression=# SELECT n.nspname, c.relname, count(*) AS buffers
+ FROM pg_buffercache b JOIN pg_class c
+ ON b.relfilenode = pg_relation_filenode(c.oid) AND
+ b.reldatabase IN (0, (SELECT oid FROM pg_database
+ WHERE datname = current_database()))
+ JOIN pg_namespace n ON n.oid = c.relnamespace
+ GROUP BY n.nspname, c.relname
+ ORDER BY 3 DESC
+ LIMIT 10;
+
+ nspname | relname | buffers
+------------+------------------------+---------
+ public | delete_test_table | 593
+ public | delete_test_table_pkey | 494
+ pg_catalog | pg_attribute | 472
+ public | quad_poly_tbl | 353
+ public | tenk2 | 349
+ public | tenk1 | 349
+ public | gin_test_idx | 306
+ pg_catalog | pg_largeobject | 206
+ public | gin_test_tbl | 188
+ public | spgist_text_tbl | 182
+(10 rows)
+
+
+regression=# SELECT * FROM pg_buffercache_summary();
+ buffers_used | buffers_unused | buffers_dirty | buffers_pinned | usagecount_avg
+--------------+----------------+---------------+----------------+----------------
+ 248 | 2096904 | 39 | 0 | 3.141129
+(1 row)
+
+
+regression=# SELECT * FROM pg_buffercache_usage_counts();
+ usage_count | buffers | dirty | pinned
+-------------+---------+-------+--------
+ 0 | 14650 | 0 | 0
+ 1 | 1436 | 671 | 0
+ 2 | 102 | 88 | 0
+ 3 | 23 | 21 | 0
+ 4 | 9 | 7 | 0
+ 5 | 164 | 106 | 0
+(6 rows)
+
F.28. pgcrypto — cryptographic functions #
+ The pgcrypto module provides cryptographic functions for
+ PostgreSQL.
+
+ This module is considered “trusted”, that is, it can be
+ installed by non-superusers who have CREATE privilege
+ on the current database.
+
+ pgcrypto requires OpenSSL and won't be installed if
+ OpenSSL support was not selected when PostgreSQL was built.
+
F.28.1. General Hashing Functions #
+digest(data text, type text) returns bytea
+digest(data bytea, type text) returns bytea
+
+ Computes a binary hash of the given data.
+ type is the algorithm to use.
+ Standard algorithms are md5, sha1,
+ sha224, sha256,
+ sha384 and sha512.
+ Moreover, any digest algorithm OpenSSL supports
+ is automatically picked up.
+
+ If you want the digest as a hexadecimal string, use
+ encode() on the result. For example:
+
+CREATE OR REPLACE FUNCTION sha1(bytea) returns text AS $$
+ SELECT encode(digest($1, 'sha1'), 'hex')
+$$ LANGUAGE SQL STRICT IMMUTABLE;
+
+
+hmac(data text, key text, type text) returns bytea
+hmac(data bytea, key bytea, type text) returns bytea
+
+ Calculates hashed MAC for data with key key.
+ type is the same as in digest().
+
+ This is similar to digest() but the hash can only be
+ recalculated knowing the key. This prevents the scenario of someone
+ altering data and also changing the hash to match.
+
+ If the key is larger than the hash block size it will first be hashed and
+ the result will be used as key.
+
F.28.2. Password Hashing Functions #
+ The functions crypt() and gen_salt()
+ are specifically designed for hashing passwords.
+ crypt() does the hashing and gen_salt()
+ prepares algorithm parameters for it.
+
+ The algorithms in crypt() differ from the usual
+ MD5 or SHA1 hashing algorithms in the following respects:
+
+ They are slow. As the amount of data is so small, this is the only
+ way to make brute-forcing passwords hard.
+
+ They use a random value, called the salt, so that users
+ having the same password will have different encrypted passwords.
+ This is also an additional defense against reversing the algorithm.
+
+ They include the algorithm type in the result, so passwords hashed with
+ different algorithms can co-exist.
+
+ Some of them are adaptive — that means when computers get
+ faster, you can tune the algorithm to be slower, without
+ introducing incompatibility with existing passwords.
+
+ Table F.18 lists the algorithms
+ supported by the crypt() function.
+
Table F.18. Supported Algorithms for crypt()
| Algorithm | Max Password Length | Adaptive? | Salt Bits | Output Length | Description |
|---|
bf | 72 | yes | 128 | 60 | Blowfish-based, variant 2a |
md5 | unlimited | no | 48 | 34 | MD5-based crypt |
xdes | 8 | yes | 24 | 20 | Extended DES |
des | 8 | no | 12 | 13 | Original UNIX crypt |
+crypt(password text, salt text) returns text
+
+ Calculates a crypt(3)-style hash of password.
+ When storing a new password, you need to use
+ gen_salt() to generate a new salt value.
+ To check a password, pass the stored hash value as salt,
+ and test whether the result matches the stored value.
+
+ Example of setting a new password:
+
+UPDATE ... SET pswhash = crypt('new password', gen_salt('md5'));
+
+
+ Example of authentication:
+
+SELECT (pswhash = crypt('entered password', pswhash)) AS pswmatch FROM ... ;
+
+ This returns true if the entered password is correct.
+
+gen_salt(type text [, iter_count integer ]) returns text
+
+ Generates a new random salt string for use in crypt().
+ The salt string also tells crypt() which algorithm to use.
+
+ The type parameter specifies the hashing algorithm.
+ The accepted types are: des, xdes,
+ md5 and bf.
+
+ The iter_count parameter lets the user specify the iteration
+ count, for algorithms that have one.
+ The higher the count, the more time it takes to hash
+ the password and therefore the more time to break it. Although with
+ too high a count the time to calculate a hash may be several years
+ — which is somewhat impractical. If the iter_count
+ parameter is omitted, the default iteration count is used.
+ Allowed values for iter_count depend on the algorithm and
+ are shown in Table F.19.
+
Table F.19. Iteration Counts for crypt()
| Algorithm | Default | Min | Max |
|---|
xdes | 725 | 1 | 16777215 |
bf | 6 | 4 | 31 |
+ For xdes there is an additional limitation that the
+ iteration count must be an odd number.
+
+ To pick an appropriate iteration count, consider that
+ the original DES crypt was designed to have the speed of 4 hashes per
+ second on the hardware of that time.
+ Slower than 4 hashes per second would probably dampen usability.
+ Faster than 100 hashes per second is probably too fast.
+
+ Table F.20 gives an overview of the relative slowness
+ of different hashing algorithms.
+ The table shows how much time it would take to try all
+ combinations of characters in an 8-character password, assuming
+ that the password contains either only lower case letters, or
+ upper- and lower-case letters and numbers.
+ In the crypt-bf entries, the number after a slash is
+ the iter_count parameter of
+ gen_salt.
+
Table F.20. Hash Algorithm Speeds
| Algorithm | Hashes/sec | For [a-z] | For [A-Za-z0-9] | Duration relative to md5 hash |
|---|
crypt-bf/8 | 1792 | 4 years | 3927 years | 100k |
crypt-bf/7 | 3648 | 2 years | 1929 years | 50k |
crypt-bf/6 | 7168 | 1 year | 982 years | 25k |
crypt-bf/5 | 13504 | 188 days | 521 years | 12.5k |
crypt-md5 | 171584 | 15 days | 41 years | 1k |
crypt-des | 23221568 | 157.5 minutes | 108 days | 7 |
sha1 | 37774272 | 90 minutes | 68 days | 4 |
md5 (hash) | 150085504 | 22.5 minutes | 17 days | 1 |
+ Notes:
+
+ The machine used is an Intel Mobile Core i3.
+
+ crypt-des and crypt-md5 algorithm numbers are
+ taken from John the Ripper v1.6.38 -test output.
+
+ md5 hash numbers are from mdcrack 1.2.
+
+ sha1 numbers are from lcrack-20031130-beta.
+
+ crypt-bf numbers are taken using a simple program that
+ loops over 1000 8-character passwords. That way the speed
+ with different numbers of iterations can be shown. For reference: john
+ -test shows 13506 loops/sec for crypt-bf/5.
+ (The very small
+ difference in results is in accordance with the fact that the
+ crypt-bf implementation in pgcrypto
+ is the same one used in John the Ripper.)
+
+ Note that “try all combinations” is not a realistic exercise.
+ Usually password cracking is done with the help of dictionaries, which
+ contain both regular words and various mutations of them. So, even
+ somewhat word-like passwords could be cracked much faster than the above
+ numbers suggest, while a 6-character non-word-like password may escape
+ cracking. Or not.
+
F.28.3. PGP Encryption Functions #
+ The functions here implement the encryption part of the OpenPGP
+ (RFC 4880)
+ standard. Supported are both symmetric-key and public-key encryption.
+
+ An encrypted PGP message consists of 2 parts, or packets:
+
+ When encrypting with a symmetric key (i.e., a password):
+
+ The given password is hashed using a String2Key (S2K) algorithm. This is
+ rather similar to crypt() algorithms — purposefully
+ slow and with random salt — but it produces a full-length binary
+ key.
+
+ If a separate session key is requested, a new random key will be
+ generated. Otherwise the S2K key will be used directly as the session
+ key.
+
+ If the S2K key is to be used directly, then only S2K settings will be put
+ into the session key packet. Otherwise the session key will be encrypted
+ with the S2K key and put into the session key packet.
+
+ When encrypting with a public key:
+
+ A new random session key is generated.
+
+ It is encrypted using the public key and put into the session key packet.
+
+ In either case the data to be encrypted is processed as follows:
+
+ Optional data-manipulation: compression, conversion to UTF-8,
+ and/or conversion of line-endings.
+
+ The data is prefixed with a block of random bytes. This is equivalent
+ to using a random IV.
+
+ A SHA1 hash of the random prefix and data is appended.
+
+ All this is encrypted with the session key and placed in the data packet.
+
F.28.3.1. pgp_sym_encrypt() #
+pgp_sym_encrypt(data text, psw text [, options text ]) returns bytea
+pgp_sym_encrypt_bytea(data bytea, psw text [, options text ]) returns bytea
+
+ Encrypt data with a symmetric PGP key psw.
+ The options parameter can contain option settings,
+ as described below.
+
F.28.3.2. pgp_sym_decrypt() #
+pgp_sym_decrypt(msg bytea, psw text [, options text ]) returns text
+pgp_sym_decrypt_bytea(msg bytea, psw text [, options text ]) returns bytea
+
+ Decrypt a symmetric-key-encrypted PGP message.
+
+ Decrypting bytea data with pgp_sym_decrypt is disallowed.
+ This is to avoid outputting invalid character data. Decrypting
+ originally textual data with pgp_sym_decrypt_bytea is fine.
+
+ The options parameter can contain option settings,
+ as described below.
+
F.28.3.3. pgp_pub_encrypt() #
+pgp_pub_encrypt(data text, key bytea [, options text ]) returns bytea
+pgp_pub_encrypt_bytea(data bytea, key bytea [, options text ]) returns bytea
+
+ Encrypt data with a public PGP key key.
+ Giving this function a secret key will produce an error.
+
+ The options parameter can contain option settings,
+ as described below.
+
F.28.3.4. pgp_pub_decrypt() #
+pgp_pub_decrypt(msg bytea, key bytea [, psw text [, options text ]]) returns text
+pgp_pub_decrypt_bytea(msg bytea, key bytea [, psw text [, options text ]]) returns bytea
+
+ Decrypt a public-key-encrypted message. key must be the
+ secret key corresponding to the public key that was used to encrypt.
+ If the secret key is password-protected, you must give the password in
+ psw. If there is no password, but you want to specify
+ options, you need to give an empty password.
+
+ Decrypting bytea data with pgp_pub_decrypt is disallowed.
+ This is to avoid outputting invalid character data. Decrypting
+ originally textual data with pgp_pub_decrypt_bytea is fine.
+
+ The options parameter can contain option settings,
+ as described below.
+
+pgp_key_id(bytea) returns text
+
+ pgp_key_id extracts the key ID of a PGP public or secret key.
+ Or it gives the key ID that was used for encrypting the data, if given
+ an encrypted message.
+
+ It can return 2 special key IDs:
+
+ SYMKEY
+
+ The message is encrypted with a symmetric key.
+
+ ANYKEY
+
+ The message is public-key encrypted, but the key ID has been removed.
+ That means you will need to try all your secret keys on it to see
+ which one decrypts it. pgcrypto itself does not produce
+ such messages.
+
+ Note that different keys may have the same ID. This is rare but a normal
+ event. The client application should then try to decrypt with each one,
+ to see which fits — like handling ANYKEY.
+
F.28.3.6. armor(), dearmor() #
+armor(data bytea [ , keys text[], values text[] ]) returns text
+dearmor(data text) returns bytea
+
+ These functions wrap/unwrap binary data into PGP ASCII-armor format,
+ which is basically Base64 with CRC and additional formatting.
+
+ If the keys and values arrays are specified,
+ an armor header is added to the armored format for each
+ key/value pair. Both arrays must be single-dimensional, and they must
+ be of the same length. The keys and values cannot contain any non-ASCII
+ characters.
+
F.28.3.8. Options for PGP Functions #
+ Options are named to be similar to GnuPG. An option's value should be
+ given after an equal sign; separate options from each other with commas.
+ For example:
+
+pgp_sym_encrypt(data, psw, 'compress-algo=1, cipher-algo=aes256')
+
+
+ All of the options except convert-crlf apply only to
+ encrypt functions. Decrypt functions get the parameters from the PGP
+ data.
+
+ The most interesting options are probably
+ compress-algo and unicode-mode.
+ The rest should have reasonable defaults.
+
F.28.3.8.1. cipher-algo #
+ Which cipher algorithm to use.
+
+Values: bf, aes128, aes192, aes256, 3des, cast5
+Default: aes128
+Applies to: pgp_sym_encrypt, pgp_pub_encrypt
+
F.28.3.8.2. compress-algo #
+ Which compression algorithm to use. Only available if
+ PostgreSQL was built with zlib.
+
+Values:
+ 0 - no compression
+ 1 - ZIP compression
+ 2 - ZLIB compression (= ZIP plus meta-data and block CRCs)
+Default: 0
+Applies to: pgp_sym_encrypt, pgp_pub_encrypt
+
F.28.3.8.3. compress-level #
+ How much to compress. Higher levels compress smaller but are slower.
+ 0 disables compression.
+
+Values: 0, 1-9
+Default: 6
+Applies to: pgp_sym_encrypt, pgp_pub_encrypt
+
F.28.3.8.4. convert-crlf #
+ Whether to convert \n into \r\n when
+ encrypting and \r\n to \n when
+ decrypting. RFC 4880 specifies that text data should be stored using
+ \r\n line-feeds. Use this to get fully RFC-compliant
+ behavior.
+
+Values: 0, 1
+Default: 0
+Applies to: pgp_sym_encrypt, pgp_pub_encrypt, pgp_sym_decrypt, pgp_pub_decrypt
+
F.28.3.8.5. disable-mdc #
+ Do not protect data with SHA-1. The only good reason to use this
+ option is to achieve compatibility with ancient PGP products, predating
+ the addition of SHA-1 protected packets to RFC 4880.
+ Recent gnupg.org and pgp.com software supports it fine.
+
+Values: 0, 1
+Default: 0
+Applies to: pgp_sym_encrypt, pgp_pub_encrypt
+
+ Use separate session key. Public-key encryption always uses a separate
+ session key; this option is for symmetric-key encryption, which by default
+ uses the S2K key directly.
+
+Values: 0, 1
+Default: 0
+Applies to: pgp_sym_encrypt
+
+ Which S2K algorithm to use.
+
+Values:
+ 0 - Without salt. Dangerous!
+ 1 - With salt but with fixed iteration count.
+ 3 - Variable iteration count.
+Default: 3
+Applies to: pgp_sym_encrypt
+
+ The number of iterations of the S2K algorithm to use. It must
+ be a value between 1024 and 65011712, inclusive.
+
+Default: A random value between 65536 and 253952
+Applies to: pgp_sym_encrypt, only with s2k-mode=3
+
F.28.3.8.9. s2k-digest-algo #
+ Which digest algorithm to use in S2K calculation.
+
+Values: md5, sha1
+Default: sha1
+Applies to: pgp_sym_encrypt
+
F.28.3.8.10. s2k-cipher-algo #
+ Which cipher to use for encrypting separate session key.
+
+Values: bf, aes, aes128, aes192, aes256
+Default: use cipher-algo
+Applies to: pgp_sym_encrypt
+
F.28.3.8.11. unicode-mode #
+ Whether to convert textual data from database internal encoding to
+ UTF-8 and back. If your database already is UTF-8, no conversion will
+ be done, but the message will be tagged as UTF-8. Without this option
+ it will not be.
+
+Values: 0, 1
+Default: 0
+Applies to: pgp_sym_encrypt, pgp_pub_encrypt
+
F.28.3.9. Generating PGP Keys with GnuPG #
+ To generate a new key:
+
+gpg --gen-key
+
+
+ The preferred key type is “DSA and Elgamal”.
+
+ For RSA encryption you must create either DSA or RSA sign-only key
+ as master and then add an RSA encryption subkey with
+ gpg --edit-key.
+
+ To list keys:
+
+gpg --list-secret-keys
+
+
+ To export a public key in ASCII-armor format:
+
+gpg -a --export KEYID > public.key
+
+
+ To export a secret key in ASCII-armor format:
+
+gpg -a --export-secret-keys KEYID > secret.key
+
+
+ You need to use dearmor() on these keys before giving them to
+ the PGP functions. Or if you can handle binary data, you can drop
+ -a from the command.
+
+ For more details see man gpg,
+ The GNU
+ Privacy Handbook and other documentation on
+ https://www.gnupg.org/.
+
F.28.3.10. Limitations of PGP Code #
+ No support for signing. That also means that it is not checked
+ whether the encryption subkey belongs to the master key.
+
+ No support for encryption key as master key. As such practice
+ is generally discouraged, this should not be a problem.
+
+ No support for several subkeys. This may seem like a problem, as this
+ is common practice. On the other hand, you should not use your regular
+ GPG/PGP keys with pgcrypto, but create new ones,
+ as the usage scenario is rather different.
+
F.28.4. Raw Encryption Functions #
+ These functions only run a cipher over data; they don't have any advanced
+ features of PGP encryption. Therefore they have some major problems:
+
+ They use user key directly as cipher key.
+
+ They don't provide any integrity checking, to see
+ if the encrypted data was modified.
+
+ They expect that users manage all encryption parameters
+ themselves, even IV.
+
+ They don't handle text.
+
+ So, with the introduction of PGP encryption, usage of raw
+ encryption functions is discouraged.
+
+encrypt(data bytea, key bytea, type text) returns bytea
+decrypt(data bytea, key bytea, type text) returns bytea
+
+encrypt_iv(data bytea, key bytea, iv bytea, type text) returns bytea
+decrypt_iv(data bytea, key bytea, iv bytea, type text) returns bytea
+
+ Encrypt/decrypt data using the cipher method specified by
+ type. The syntax of the
+ type string is:
+
+
+algorithm [ - mode ] [ /pad: padding ]
+
+ where algorithm is one of:
+
+
+ and mode is one of:
+
+ and padding is one of:
+
+
+ So, for example, these are equivalent:
+
+encrypt(data, 'fooz', 'bf')
+encrypt(data, 'fooz', 'bf-cbc/pad:pkcs')
+
+
+ In encrypt_iv and decrypt_iv, the
+ iv parameter is the initial value for the CBC mode;
+ it is ignored for ECB.
+ It is clipped or padded with zeroes if not exactly block size.
+ It defaults to all zeroes in the functions without this parameter.
+
F.28.5. Random-Data Functions #
+gen_random_bytes(count integer) returns bytea
+
+ Returns count cryptographically strong random bytes.
+ At most 1024 bytes can be extracted at a time. This is to avoid
+ draining the randomness generator pool.
+
+gen_random_uuid() returns uuid
+
+ Returns a version 4 (random) UUID. (Obsolete, this function
+ internally calls the core
+ function of the same name.)
+
F.28.6.1. Configuration #
+ pgcrypto configures itself according to the findings of the
+ main PostgreSQL configure script. The options that
+ affect it are --with-zlib and
+ --with-ssl=openssl.
+
+ When compiled with zlib, PGP encryption functions are able to
+ compress data before encrypting.
+
+ pgcrypto requires OpenSSL.
+ Otherwise, it will not be built or installed.
+
+ When compiled against OpenSSL 3.0.0 and later
+ versions, the legacy provider must be activated in the
+ openssl.cnf configuration file in order to use older
+ ciphers like DES or Blowfish.
+
F.28.6.2. NULL Handling #
+ As is standard in SQL, all functions return NULL, if any of the arguments
+ are NULL. This may create security risks on careless usage.
+
F.28.6.3. Security Limitations #
+ All pgcrypto functions run inside the database server.
+ That means that all
+ the data and passwords move between pgcrypto and client
+ applications in clear text. Thus you must:
+
Connect locally or use SSL connections.
Trust both system and database administrator.
+ If you cannot, then better do crypto inside client application.
+
+ The implementation does not resist
+ side-channel
+ attacks. For example, the time required for
+ a pgcrypto decryption function to complete varies among
+ ciphertexts of a given size.
+
+ Marko Kreen <markokr@gmail.com>
+
+ pgcrypto uses code from the following sources:
+
F.29. pg_freespacemap — examine the free space map #
+ The pg_freespacemap module provides a means for examining the
+ free space map (FSM).
+ It provides a function called pg_freespace, or two
+ overloaded functions, to be precise. The functions show the value recorded in
+ the free space map for a given page, or for all pages in the relation.
+
+ By default use is restricted to superusers and roles with privileges of the
+ pg_stat_scan_tables role. Access may be granted to others
+ using GRANT.
+
-
+
pg_freespace(rel regclass IN, blkno bigint IN) returns int2
+
+
+ Returns the amount of free space on the page of the relation, specified
+ by blkno, according to the FSM.
+
-
+
pg_freespace(rel regclass IN, blkno OUT bigint, avail OUT int2)
+
+ Displays the amount of free space on each page of the relation,
+ according to the FSM. A set of
+ (blkno bigint, avail int2)
+ tuples is returned, one tuple for each page in the relation.
+
+ The values stored in the free space map are not exact. They're rounded
+ to precision of 1/256th of BLCKSZ (32 bytes with default BLCKSZ), and
+ they're not kept fully up-to-date as tuples are inserted and updated.
+
+ For indexes, what is tracked is entirely-unused pages, rather than free
+ space within pages. Therefore, the values are not meaningful, just
+ whether a page is full or empty.
+
+postgres=# SELECT * FROM pg_freespace('foo');
+ blkno | avail
+-------+-------
+ 0 | 0
+ 1 | 0
+ 2 | 0
+ 3 | 32
+ 4 | 704
+ 5 | 704
+ 6 | 704
+ 7 | 1216
+ 8 | 704
+ 9 | 704
+ 10 | 704
+ 11 | 704
+ 12 | 704
+ 13 | 704
+ 14 | 704
+ 15 | 704
+ 16 | 704
+ 17 | 704
+ 18 | 704
+ 19 | 3648
+(20 rows)
+
+postgres=# SELECT * FROM pg_freespace('foo', 7);
+ pg_freespace
+--------------
+ 1216
+(1 row)
+F.30. pg_prewarm — preload relation data into buffer caches #
+ The pg_prewarm module provides a convenient way
+ to load relation data into either the operating system buffer cache
+ or the PostgreSQL buffer cache. Prewarming
+ can be performed manually using the pg_prewarm function,
+ or can be performed automatically by including pg_prewarm in
+ shared_preload_libraries. In the latter case, the
+ system will run a background worker which periodically records the contents
+ of shared buffers in a file called autoprewarm.blocks and
+ will, using 2 background workers, reload those same blocks after a restart.
+
+pg_prewarm(regclass, mode text default 'buffer', fork text default 'main',
+ first_block int8 default null,
+ last_block int8 default null) RETURNS int8
+
+ The first argument is the relation to be prewarmed. The second argument
+ is the prewarming method to be used, as further discussed below; the third
+ is the relation fork to be prewarmed, usually main.
+ The fourth argument is the first block number to prewarm
+ (NULL is accepted as a synonym for zero). The fifth
+ argument is the last block number to prewarm (NULL
+ means prewarm through the last block in the relation). The return value
+ is the number of blocks prewarmed.
+
+ There are three available prewarming methods. prefetch
+ issues asynchronous prefetch requests to the operating system, if this is
+ supported, or throws an error otherwise. read reads
+ the requested range of blocks; unlike prefetch, this is
+ synchronous and supported on all platforms and builds, but may be slower.
+ buffer reads the requested range of blocks into the
+ database buffer cache.
+
+ Note that with any of these methods, attempting to prewarm more blocks than
+ can be cached — by the OS when using prefetch or
+ read, or by PostgreSQL when
+ using buffer — will likely result in lower-numbered
+ blocks being evicted as higher numbered blocks are read in. Prewarmed data
+ also enjoys no special protection from cache evictions, so it is possible
+ that other system activity may evict the newly prewarmed blocks shortly
+ after they are read; conversely, prewarming may also evict other data from
+ cache. For these reasons, prewarming is typically most useful at startup,
+ when caches are largely empty.
+
+autoprewarm_start_worker() RETURNS void
+
+ Launch the main autoprewarm worker. This will normally happen
+ automatically, but is useful if automatic prewarm was not configured at
+ server startup time and you wish to start up the worker at a later time.
+
+autoprewarm_dump_now() RETURNS int8
+
+ Update autoprewarm.blocks immediately. This may be useful
+ if the autoprewarm worker is not running but you anticipate running it
+ after the next restart. The return value is the number of records written
+ to autoprewarm.blocks.
+
F.30.2. Configuration Parameters #
-
+
pg_prewarm.autoprewarm (boolean)
+
+
+ Controls whether the server should run the autoprewarm worker. This is
+ on by default. This parameter can only be set at server start.
+
-
+
pg_prewarm.autoprewarm_interval (integer)
+
+
+ This is the interval between updates to autoprewarm.blocks.
+ The default is 300 seconds. If set to 0, the file will not be
+ dumped at regular intervals, but only when the server is shut down.
+
+ These parameters must be set in postgresql.conf.
+ Typical usage might be:
+
+# postgresql.conf
+shared_preload_libraries = 'pg_prewarm'
+
+pg_prewarm.autoprewarm = true
+pg_prewarm.autoprewarm_interval = 300s
+
+
F.31. pgrowlocks — show a table's row locking information #
+ The pgrowlocks module provides a function to show row
+ locking information for a specified table.
+
+ By default use is restricted to superusers, roles with privileges of the
+ pg_stat_scan_tables role, and users with
+ SELECT permissions on the table.
+
+pgrowlocks(text) returns setof record
+
+ The parameter is the name of a table. The result is a set of records,
+ with one row for each locked row within the table. The output columns
+ are shown in Table F.21.
+
Table F.21. pgrowlocks Output Columns
| Name | Type | Description |
|---|
locked_row | tid | Tuple ID (TID) of locked row |
locker | xid | Transaction ID of locker, or multixact ID if
+ multitransaction; see Section 74.1 |
multi | boolean | True if locker is a multitransaction |
xids | xid[] | Transaction IDs of lockers (more than one if multitransaction) |
modes | text[] | Lock mode of lockers (more than one if multitransaction),
+ an array of Key Share, Share,
+ For No Key Update, No Key Update,
+ For Update, Update. |
pids | integer[] | Process IDs of locking backends (more than one if multitransaction) |
+ pgrowlocks takes AccessShareLock for the
+ target table and reads each row one by one to collect the row locking
+ information. This is not very speedy for a large table. Note that:
+
+ If an ACCESS EXCLUSIVE lock is taken on the table,
+ pgrowlocks will be blocked.
+
+ pgrowlocks is not guaranteed to produce a
+ self-consistent snapshot. It is possible that a new row lock is taken,
+ or an old lock is freed, during its execution.
+
+ pgrowlocks does not show the contents of locked
+ rows. If you want to take a look at the row contents at the same time, you
+ could do something like this:
+
+
+SELECT * FROM accounts AS a, pgrowlocks('accounts') AS p
+ WHERE p.locked_row = a.ctid;
+
+
+ Be aware however that such a query will be very inefficient.
+
+=# SELECT * FROM pgrowlocks('t1');
+ locked_row | locker | multi | xids | modes | pids
+------------+--------+-------+-------+----------------+--------
+ (0,1) | 609 | f | {609} | {"For Share"} | {3161}
+ (0,2) | 609 | f | {609} | {"For Share"} | {3161}
+ (0,3) | 607 | f | {607} | {"For Update"} | {3107}
+ (0,4) | 607 | f | {607} | {"For Update"} | {3107}
+(4 rows)
+F.32. pg_stat_statements — track statistics of SQL planning and execution #
+ The pg_stat_statements module provides a means for
+ tracking planning and execution statistics of all SQL statements executed by
+ a server.
+
+ The module must be loaded by adding pg_stat_statements to
+ shared_preload_libraries in
+ postgresql.conf, because it requires additional shared memory.
+ This means that a server restart is needed to add or remove the module.
+ In addition, query identifier calculation must be enabled in order for the
+ module to be active, which is done automatically if compute_query_id
+ is set to auto or on, or any third-party
+ module that calculates query identifiers is loaded.
+
+ When pg_stat_statements is active, it tracks
+ statistics across all databases of the server. To access and manipulate
+ these statistics, the module provides views
+ pg_stat_statements and
+ pg_stat_statements_info,
+ and the utility functions pg_stat_statements_reset and
+ pg_stat_statements. These are not available globally but
+ can be enabled for a specific database with
+ CREATE EXTENSION pg_stat_statements.
+
F.32.1. The pg_stat_statements View #
+ The statistics gathered by the module are made available via a
+ view named pg_stat_statements. This view
+ contains one row for each distinct combination of database ID, user
+ ID, query ID and whether it's a top-level statement or not (up to
+ the maximum number of distinct statements that the module can track).
+ The columns of the view are shown in
+ Table F.22.
+
Table F.22. pg_stat_statements Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ userid oid
+ (references pg_authid.oid)
+
+
+ OID of user who executed the statement
+ |
+ dbid oid
+ (references pg_database.oid)
+
+
+ OID of database in which the statement was executed
+ |
+ toplevel bool
+
+
+ True if the query was executed as a top-level statement
+ (always true if pg_stat_statements.track is set to
+ top)
+ |
+ queryid bigint
+
+
+ Hash code to identify identical normalized queries.
+ |
+ query text
+
+
+ Text of a representative statement
+ |
+ plans bigint
+
+
+ Number of times the statement was planned
+ (if pg_stat_statements.track_planning is enabled,
+ otherwise zero)
+ |
+ total_plan_time double precision
+
+
+ Total time spent planning the statement, in milliseconds
+ (if pg_stat_statements.track_planning is enabled,
+ otherwise zero)
+ |
+ min_plan_time double precision
+
+
+ Minimum time spent planning the statement, in milliseconds
+ (if pg_stat_statements.track_planning is enabled,
+ otherwise zero)
+ |
+ max_plan_time double precision
+
+
+ Maximum time spent planning the statement, in milliseconds
+ (if pg_stat_statements.track_planning is enabled,
+ otherwise zero)
+ |
+ mean_plan_time double precision
+
+
+ Mean time spent planning the statement, in milliseconds
+ (if pg_stat_statements.track_planning is enabled,
+ otherwise zero)
+ |
+ stddev_plan_time double precision
+
+
+ Population standard deviation of time spent planning the statement,
+ in milliseconds
+ (if pg_stat_statements.track_planning is enabled,
+ otherwise zero)
+ |
+ calls bigint
+
+
+ Number of times the statement was executed
+ |
+ total_exec_time double precision
+
+
+ Total time spent executing the statement, in milliseconds
+ |
+ min_exec_time double precision
+
+
+ Minimum time spent executing the statement, in milliseconds
+ |
+ max_exec_time double precision
+
+
+ Maximum time spent executing the statement, in milliseconds
+ |
+ mean_exec_time double precision
+
+
+ Mean time spent executing the statement, in milliseconds
+ |
+ stddev_exec_time double precision
+
+
+ Population standard deviation of time spent executing the statement, in milliseconds
+ |
+ rows bigint
+
+
+ Total number of rows retrieved or affected by the statement
+ |
+ shared_blks_hit bigint
+
+
+ Total number of shared block cache hits by the statement
+ |
+ shared_blks_read bigint
+
+
+ Total number of shared blocks read by the statement
+ |
+ shared_blks_dirtied bigint
+
+
+ Total number of shared blocks dirtied by the statement
+ |
+ shared_blks_written bigint
+
+
+ Total number of shared blocks written by the statement
+ |
+ local_blks_hit bigint
+
+
+ Total number of local block cache hits by the statement
+ |
+ local_blks_read bigint
+
+
+ Total number of local blocks read by the statement
+ |
+ local_blks_dirtied bigint
+
+
+ Total number of local blocks dirtied by the statement
+ |
+ local_blks_written bigint
+
+
+ Total number of local blocks written by the statement
+ |
+ temp_blks_read bigint
+
+
+ Total number of temp blocks read by the statement
+ |
+ temp_blks_written bigint
+
+
+ Total number of temp blocks written by the statement
+ |
+ blk_read_time double precision
+
+
+ Total time the statement spent reading data file blocks, in milliseconds
+ (if track_io_timing is enabled, otherwise zero)
+ |
+ blk_write_time double precision
+
+
+ Total time the statement spent writing data file blocks, in milliseconds
+ (if track_io_timing is enabled, otherwise zero)
+ |
+ temp_blk_read_time double precision
+
+
+ Total time the statement spent reading temporary file blocks, in
+ milliseconds (if track_io_timing is enabled,
+ otherwise zero)
+ |
+ temp_blk_write_time double precision
+
+
+ Total time the statement spent writing temporary file blocks, in
+ milliseconds (if track_io_timing is enabled,
+ otherwise zero)
+ |
+ wal_records bigint
+
+
+ Total number of WAL records generated by the statement
+ |
+ wal_fpi bigint
+
+
+ Total number of WAL full page images generated by the statement
+ |
+ wal_bytes numeric
+
+
+ Total amount of WAL generated by the statement in bytes
+ |
+ jit_functions bigint
+
+
+ Total number of functions JIT-compiled by the statement
+ |
+ jit_generation_time double precision
+
+
+ Total time spent by the statement on generating JIT code, in milliseconds
+ |
+ jit_inlining_count bigint
+
+
+ Number of times functions have been inlined
+ |
+ jit_inlining_time double precision
+
+
+ Total time spent by the statement on inlining functions, in milliseconds
+ |
+ jit_optimization_count bigint
+
+
+ Number of times the statement has been optimized
+ |
+ jit_optimization_time double precision
+
+
+ Total time spent by the statement on optimizing, in milliseconds
+ |
+ jit_emission_count bigint
+
+
+ Number of times code has been emitted
+ |
+ jit_emission_time double precision
+
+
+ Total time spent by the statement on emitting code, in milliseconds
+ |
+ For security reasons, only superusers and roles with privileges of the
+ pg_read_all_stats role are allowed to see the SQL text and
+ queryid of queries executed by other users.
+ Other users can see the statistics, however, if the view has been installed
+ in their database.
+
+ Plannable queries (that is, SELECT, INSERT,
+ UPDATE, DELETE, and MERGE)
+ and utility commands are combined into a single
+ pg_stat_statements entry whenever they have identical query
+ structures according to an internal hash calculation. Typically, two
+ queries will be considered the same for this purpose if they are
+ semantically equivalent except for the values of literal constants
+ appearing in the query.
+
Note
+ The following details about constant replacement and
+ queryid only apply when compute_query_id is enabled. If you use an external
+ module instead to compute queryid, you
+ should refer to its documentation for details.
+
+ When a constant's value has been ignored for purposes of matching the query
+ to other queries, the constant is replaced by a parameter symbol, such
+ as $1, in the pg_stat_statements
+ display.
+ The rest of the query text is that of the first query that had the
+ particular queryid hash value associated with the
+ pg_stat_statements entry.
+
+ Queries on which normalization can be applied may be observed with constant
+ values in pg_stat_statements, especially when there
+ is a high rate of entry deallocations. To reduce the likelihood of this
+ happening, consider increasing pg_stat_statements.max.
+ The pg_stat_statements_info view, discussed below
+ in Section F.32.2,
+ provides statistics about entry deallocations.
+
+ In some cases, queries with visibly different texts might get merged into a
+ single pg_stat_statements entry. Normally this will happen
+ only for semantically equivalent queries, but there is a small chance of
+ hash collisions causing unrelated queries to be merged into one entry.
+ (This cannot happen for queries belonging to different users or databases,
+ however.)
+
+ Since the queryid hash value is computed on the
+ post-parse-analysis representation of the queries, the opposite is
+ also possible: queries with identical texts might appear as
+ separate entries, if they have different meanings as a result of
+ factors such as different search_path settings.
+
+ Consumers of pg_stat_statements may wish to use
+ queryid (perhaps in combination with
+ dbid and userid) as a more stable
+ and reliable identifier for each entry than its query text.
+ However, it is important to understand that there are only limited
+ guarantees around the stability of the queryid hash
+ value. Since the identifier is derived from the
+ post-parse-analysis tree, its value is a function of, among other
+ things, the internal object identifiers appearing in this representation.
+ This has some counterintuitive implications. For example,
+ pg_stat_statements will consider two apparently-identical
+ queries to be distinct, if they reference a table that was dropped
+ and recreated between the executions of the two queries.
+ The hashing process is also sensitive to differences in
+ machine architecture and other facets of the platform.
+ Furthermore, it is not safe to assume that queryid
+ will be stable across major versions of PostgreSQL.
+
+ Two servers participating in replication based on physical WAL replay can
+ be expected to have identical queryid values for
+ the same query. However, logical replication schemes do not promise to
+ keep replicas identical in all relevant details, so
+ queryid will not be a useful identifier for
+ accumulating costs across a set of logical replicas.
+ If in doubt, direct testing is recommended.
+
+ Generally, it can be assumed that queryid values
+ are stable between minor version releases of PostgreSQL,
+ providing that instances are running on the same machine architecture and
+ the catalog metadata details match. Compatibility will only be broken
+ between minor versions as a last resort.
+
+ The parameter symbols used to replace constants in
+ representative query texts start from the next number after the
+ highest $n parameter in the original query
+ text, or $1 if there was none. It's worth noting that in
+ some cases there may be hidden parameter symbols that affect this
+ numbering. For example, PL/pgSQL uses hidden parameter
+ symbols to insert values of function local variables into queries, so that
+ a PL/pgSQL statement like SELECT i + 1 INTO j
+ would have representative text like SELECT i + $2.
+
+ The representative query texts are kept in an external disk file, and do
+ not consume shared memory. Therefore, even very lengthy query texts can
+ be stored successfully. However, if many long query texts are
+ accumulated, the external file might grow unmanageably large. As a
+ recovery method if that happens, pg_stat_statements may
+ choose to discard the query texts, whereupon all existing entries in
+ the pg_stat_statements view will show
+ null query fields, though the statistics associated with
+ each queryid are preserved. If this happens, consider
+ reducing pg_stat_statements.max to prevent
+ recurrences.
+
+ plans and calls aren't
+ always expected to match because planning and execution statistics are
+ updated at their respective end phase, and only for successful operations.
+ For example, if a statement is successfully planned but fails during
+ the execution phase, only its planning statistics will be updated.
+ If planning is skipped because a cached plan is used, only its execution
+ statistics will be updated.
+
F.32.2. The pg_stat_statements_info View #
+ The statistics of the pg_stat_statements module
+ itself are tracked and made available via a view named
+ pg_stat_statements_info. This view contains
+ only a single row. The columns of the view are shown in
+ Table F.23.
+
Table F.23. pg_stat_statements_info Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ dealloc bigint
+
+
+ Total number of times pg_stat_statements
+ entries about the least-executed statements were deallocated
+ because more distinct statements than
+ pg_stat_statements.max were observed
+ |
+ stats_reset timestamp with time zone
+
+
+ Time at which all statistics in the
+ pg_stat_statements view were last reset.
+ |
-
+
pg_stat_statements_reset(userid Oid, dbid Oid, queryid bigint) returns void
+
+
+ pg_stat_statements_reset discards statistics
+ gathered so far by pg_stat_statements corresponding
+ to the specified userid, dbid
+ and queryid. If any of the parameters are not
+ specified, the default value 0(invalid) is used for
+ each of them and the statistics that match with other parameters will be
+ reset. If no parameter is specified or all the specified parameters are
+ 0(invalid), it will discard all statistics.
+ If all statistics in the pg_stat_statements
+ view are discarded, it will also reset the statistics in the
+ pg_stat_statements_info view.
+ By default, this function can only be executed by superusers.
+ Access may be granted to others using GRANT.
+
-
+
pg_stat_statements(showtext boolean) returns setof record
+
+
+ The pg_stat_statements view is defined in
+ terms of a function also named pg_stat_statements.
+ It is possible for clients to call
+ the pg_stat_statements function directly, and by
+ specifying showtext := false have query text be
+ omitted (that is, the OUT argument that corresponds
+ to the view's query column will return nulls). This
+ feature is intended to support external tools that might wish to avoid
+ the overhead of repeatedly retrieving query texts of indeterminate
+ length. Such tools can instead cache the first query text observed
+ for each entry themselves, since that is
+ all pg_stat_statements itself does, and then retrieve
+ query texts only as needed. Since the server stores query texts in a
+ file, this approach may reduce physical I/O for repeated examination
+ of the pg_stat_statements data.
+
F.32.4. Configuration Parameters #
-
+
pg_stat_statements.max (integer)
+
+
+ pg_stat_statements.max is the maximum number of
+ statements tracked by the module (i.e., the maximum number of rows
+ in the pg_stat_statements view). If more distinct
+ statements than that are observed, information about the least-executed
+ statements is discarded. The number of times such information was
+ discarded can be seen in the
+ pg_stat_statements_info view.
+ The default value is 5000.
+ This parameter can only be set at server start.
+
-
+
pg_stat_statements.track (enum)
+
+
+ pg_stat_statements.track controls which statements
+ are counted by the module.
+ Specify top to track top-level statements (those issued
+ directly by clients), all to also track nested statements
+ (such as statements invoked within functions), or none to
+ disable statement statistics collection.
+ The default value is top.
+ Only superusers can change this setting.
+
-
+
pg_stat_statements.track_utility (boolean)
+
+
+ pg_stat_statements.track_utility controls whether
+ utility commands are tracked by the module. Utility commands are
+ all those other than SELECT, INSERT,
+ UPDATE, DELETE, and MERGE.
+ The default value is on.
+ Only superusers can change this setting.
+
-
+
pg_stat_statements.track_planning (boolean)
+
+
+ pg_stat_statements.track_planning controls whether
+ planning operations and duration are tracked by the module.
+ Enabling this parameter may incur a noticeable performance penalty,
+ especially when statements with identical query structure are executed
+ by many concurrent connections which compete to update a small number of
+ pg_stat_statements entries.
+ The default value is off.
+ Only superusers can change this setting.
+
-
+
pg_stat_statements.save (boolean)
+
+
+ pg_stat_statements.save specifies whether to
+ save statement statistics across server shutdowns.
+ If it is off then statistics are not saved at
+ shutdown nor reloaded at server start.
+ The default value is on.
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
+ The module requires additional shared memory proportional to
+ pg_stat_statements.max. Note that this
+ memory is consumed whenever the module is loaded, even if
+ pg_stat_statements.track is set to none.
+
+ These parameters must be set in postgresql.conf.
+ Typical usage might be:
+
+
+# postgresql.conf
+shared_preload_libraries = 'pg_stat_statements'
+
+compute_query_id = on
+pg_stat_statements.max = 10000
+pg_stat_statements.track = all
+
+
+bench=# SELECT pg_stat_statements_reset();
+
+$ pgbench -i bench
+$ pgbench -c10 -t300 bench
+
+bench=# \x
+bench=# SELECT query, calls, total_exec_time, rows, 100.0 * shared_blks_hit /
+ nullif(shared_blks_hit + shared_blks_read, 0) AS hit_percent
+ FROM pg_stat_statements ORDER BY total_exec_time DESC LIMIT 5;
+-[ RECORD 1 ]---+--------------------------------------------------------------------
+query | UPDATE pgbench_branches SET bbalance = bbalance + $1 WHERE bid = $2
+calls | 3000
+total_exec_time | 25565.855387
+rows | 3000
+hit_percent | 100.0000000000000000
+-[ RECORD 2 ]---+--------------------------------------------------------------------
+query | UPDATE pgbench_tellers SET tbalance = tbalance + $1 WHERE tid = $2
+calls | 3000
+total_exec_time | 20756.669379
+rows | 3000
+hit_percent | 100.0000000000000000
+-[ RECORD 3 ]---+--------------------------------------------------------------------
+query | copy pgbench_accounts from stdin
+calls | 1
+total_exec_time | 291.865911
+rows | 100000
+hit_percent | 100.0000000000000000
+-[ RECORD 4 ]---+--------------------------------------------------------------------
+query | UPDATE pgbench_accounts SET abalance = abalance + $1 WHERE aid = $2
+calls | 3000
+total_exec_time | 271.232977
+rows | 3000
+hit_percent | 98.8454011741682975
+-[ RECORD 5 ]---+--------------------------------------------------------------------
+query | alter table pgbench_accounts add primary key (aid)
+calls | 1
+total_exec_time | 160.588563
+rows | 0
+hit_percent | 100.0000000000000000
+
+
+bench=# SELECT pg_stat_statements_reset(0,0,s.queryid) FROM pg_stat_statements AS s
+ WHERE s.query = 'UPDATE pgbench_branches SET bbalance = bbalance + $1 WHERE bid = $2';
+
+bench=# SELECT query, calls, total_exec_time, rows, 100.0 * shared_blks_hit /
+ nullif(shared_blks_hit + shared_blks_read, 0) AS hit_percent
+ FROM pg_stat_statements ORDER BY total_exec_time DESC LIMIT 5;
+-[ RECORD 1 ]---+--------------------------------------------------------------------
+query | UPDATE pgbench_tellers SET tbalance = tbalance + $1 WHERE tid = $2
+calls | 3000
+total_exec_time | 20756.669379
+rows | 3000
+hit_percent | 100.0000000000000000
+-[ RECORD 2 ]---+--------------------------------------------------------------------
+query | copy pgbench_accounts from stdin
+calls | 1
+total_exec_time | 291.865911
+rows | 100000
+hit_percent | 100.0000000000000000
+-[ RECORD 3 ]---+--------------------------------------------------------------------
+query | UPDATE pgbench_accounts SET abalance = abalance + $1 WHERE aid = $2
+calls | 3000
+total_exec_time | 271.232977
+rows | 3000
+hit_percent | 98.8454011741682975
+-[ RECORD 4 ]---+--------------------------------------------------------------------
+query | alter table pgbench_accounts add primary key (aid)
+calls | 1
+total_exec_time | 160.588563
+rows | 0
+hit_percent | 100.0000000000000000
+-[ RECORD 5 ]---+--------------------------------------------------------------------
+query | vacuum analyze pgbench_accounts
+calls | 1
+total_exec_time | 136.448116
+rows | 0
+hit_percent | 99.9201915403032721
+
+bench=# SELECT pg_stat_statements_reset(0,0,0);
+
+bench=# SELECT query, calls, total_exec_time, rows, 100.0 * shared_blks_hit /
+ nullif(shared_blks_hit + shared_blks_read, 0) AS hit_percent
+ FROM pg_stat_statements ORDER BY total_exec_time DESC LIMIT 5;
+-[ RECORD 1 ]---+-----------------------------------------------------------------------------
+query | SELECT pg_stat_statements_reset(0,0,0)
+calls | 1
+total_exec_time | 0.189497
+rows | 1
+hit_percent |
+-[ RECORD 2 ]---+-----------------------------------------------------------------------------
+query | SELECT query, calls, total_exec_time, rows, $1 * shared_blks_hit / +
+ | nullif(shared_blks_hit + shared_blks_read, $2) AS hit_percent+
+ | FROM pg_stat_statements ORDER BY total_exec_time DESC LIMIT $3
+calls | 0
+total_exec_time | 0
+rows | 0
+hit_percent |
+
+
F.33. pgstattuple — obtain tuple-level statistics #
+ The pgstattuple module provides various functions to
+ obtain tuple-level statistics.
+
+ Because these functions return detailed page-level information, access is
+ restricted by default. By default, only the
+ role pg_stat_scan_tables has EXECUTE
+ privilege. Superusers of course bypass this restriction. After the
+ extension has been installed, users may issue GRANT
+ commands to change the privileges on the functions to allow others to
+ execute them. However, it might be preferable to add those users to
+ the pg_stat_scan_tables role instead.
+
-
+
+
pgstattuple(regclass) returns record
+
+ pgstattuple returns a relation's physical length,
+ percentage of “dead” tuples, and other info. This may help users
+ to determine whether vacuum is necessary or not. The argument is the
+ target relation's name (optionally schema-qualified) or OID.
+ For example:
+
+test=> SELECT * FROM pgstattuple('pg_catalog.pg_proc');
+-[ RECORD 1 ]------+-------
+table_len | 458752
+tuple_count | 1470
+tuple_len | 438896
+tuple_percent | 95.67
+dead_tuple_count | 11
+dead_tuple_len | 3157
+dead_tuple_percent | 0.69
+free_space | 8932
+free_percent | 1.95
+
+ The output columns are described in Table F.24.
+
Table F.24. pgstattuple Output Columns
| Column | Type | Description |
|---|
table_len | bigint | Physical relation length in bytes |
tuple_count | bigint | Number of live tuples |
tuple_len | bigint | Total length of live tuples in bytes |
tuple_percent | float8 | Percentage of live tuples |
dead_tuple_count | bigint | Number of dead tuples |
dead_tuple_len | bigint | Total length of dead tuples in bytes |
dead_tuple_percent | float8 | Percentage of dead tuples |
free_space | bigint | Total free space in bytes |
free_percent | float8 | Percentage of free space |
Note
+ The table_len will always be greater than the sum
+ of the tuple_len, dead_tuple_len
+ and free_space. The difference is accounted for by
+ fixed page overhead, the per-page table of pointers to tuples, and
+ padding to ensure that tuples are correctly aligned.
+
+ pgstattuple acquires only a read lock on the
+ relation. So the results do not reflect an instantaneous snapshot;
+ concurrent updates will affect them.
+
+ pgstattuple judges a tuple is “dead” if
+ HeapTupleSatisfiesDirty returns false.
+
-
+
pgstattuple(text) returns record
+
+ This is the same as pgstattuple(regclass), except
+ that the target relation is specified as TEXT. This function is kept
+ because of backward-compatibility so far, and will be deprecated in
+ some future release.
+
-
+
+
pgstatindex(regclass) returns record
+
+ pgstatindex returns a record showing information
+ about a B-tree index. For example:
+
+test=> SELECT * FROM pgstatindex('pg_cast_oid_index');
+-[ RECORD 1 ]------+------
+version | 2
+tree_level | 0
+index_size | 16384
+root_block_no | 1
+internal_pages | 0
+leaf_pages | 1
+empty_pages | 0
+deleted_pages | 0
+avg_leaf_density | 54.27
+leaf_fragmentation | 0
+
+
+ The output columns are:
+
+
+
+ The reported index_size will normally correspond to one more
+ page than is accounted for by internal_pages + leaf_pages +
+ empty_pages + deleted_pages, because it also includes the
+ index's metapage.
+
+ As with pgstattuple, the results are accumulated
+ page-by-page, and should not be expected to represent an
+ instantaneous snapshot of the whole index.
+
-
+
pgstatindex(text) returns record
+
+ This is the same as pgstatindex(regclass), except
+ that the target index is specified as TEXT. This function is kept
+ because of backward-compatibility so far, and will be deprecated in
+ some future release.
+
-
+
+
pgstatginindex(regclass) returns record
+
+ pgstatginindex returns a record showing information
+ about a GIN index. For example:
+
+test=> SELECT * FROM pgstatginindex('test_gin_index');
+-[ RECORD 1 ]--+--
+version | 1
+pending_pages | 0
+pending_tuples | 0
+
+
+ The output columns are:
+
+
+
-
+
+
pgstathashindex(regclass) returns record
+
+ pgstathashindex returns a record showing information
+ about a HASH index. For example:
+
+test=> select * from pgstathashindex('con_hash_index');
+-[ RECORD 1 ]--+-----------------
+version | 4
+bucket_pages | 33081
+overflow_pages | 0
+bitmap_pages | 1
+unused_pages | 32455
+live_items | 10204006
+dead_items | 0
+free_percent | 61.8005949100872
+
+
+ The output columns are:
+
+
+
-
+
+
pg_relpages(regclass) returns bigint
+
+ pg_relpages returns the number of pages in the
+ relation.
+
-
+
pg_relpages(text) returns bigint
+
+ This is the same as pg_relpages(regclass), except
+ that the target relation is specified as TEXT. This function is kept
+ because of backward-compatibility so far, and will be deprecated in
+ some future release.
+
-
+
+
pgstattuple_approx(regclass) returns record
+
+ pgstattuple_approx is a faster alternative to
+ pgstattuple that returns approximate results.
+ The argument is the target relation's name or OID.
+ For example:
+
+test=> SELECT * FROM pgstattuple_approx('pg_catalog.pg_proc'::regclass);
+-[ RECORD 1 ]--------+-------
+table_len | 573440
+scanned_percent | 2
+approx_tuple_count | 2740
+approx_tuple_len | 561210
+approx_tuple_percent | 97.87
+dead_tuple_count | 0
+dead_tuple_len | 0
+dead_tuple_percent | 0
+approx_free_space | 11996
+approx_free_percent | 2.09
+
+ The output columns are described in Table F.25.
+
+ Whereas pgstattuple always performs a
+ full-table scan and returns an exact count of live and dead tuples
+ (and their sizes) and free space, pgstattuple_approx
+ tries to avoid the full-table scan and returns exact dead tuple
+ statistics along with an approximation of the number and
+ size of live tuples and free space.
+
+ It does this by skipping pages that have only visible tuples
+ according to the visibility map (if a page has the corresponding VM
+ bit set, then it is assumed to contain no dead tuples). For such
+ pages, it derives the free space value from the free space map, and
+ assumes that the rest of the space on the page is taken up by live
+ tuples.
+
+ For pages that cannot be skipped, it scans each tuple, recording its
+ presence and size in the appropriate counters, and adding up the
+ free space on the page. At the end, it estimates the total number of
+ live tuples based on the number of pages and tuples scanned (in the
+ same way that VACUUM estimates pg_class.reltuples).
+
Table F.25. pgstattuple_approx Output Columns
| Column | Type | Description |
|---|
table_len | bigint | Physical relation length in bytes (exact) |
scanned_percent | float8 | Percentage of table scanned |
approx_tuple_count | bigint | Number of live tuples (estimated) |
approx_tuple_len | bigint | Total length of live tuples in bytes (estimated) |
approx_tuple_percent | float8 | Percentage of live tuples |
dead_tuple_count | bigint | Number of dead tuples (exact) |
dead_tuple_len | bigint | Total length of dead tuples in bytes (exact) |
dead_tuple_percent | float8 | Percentage of dead tuples |
approx_free_space | bigint | Total free space in bytes (estimated) |
approx_free_percent | float8 | Percentage of free space |
+ In the above output, the free space figures may not match the
+ pgstattuple output exactly, because the free
+ space map gives us an exact figure, but is not guaranteed to be
+ accurate to the byte.
+
+ Tatsuo Ishii, Satoshi Nagayasu and Abhijit Menon-Sen
+
F.34. pg_surgery — perform low-level surgery on relation data #
+ The pg_surgery module provides various functions to
+ perform surgery on a damaged relation. These functions are unsafe by design
+ and using them may corrupt (or further corrupt) your database. For example,
+ these functions can easily be used to make a table inconsistent with its
+ own indexes, to cause UNIQUE or
+ FOREIGN KEY constraint violations, or even to make
+ tuples visible which, when read, will cause a database server crash.
+ They should be used with great caution and only as a last resort.
+
-
+
heap_force_kill(regclass, tid[]) returns void
+
+ heap_force_kill marks “used” line
+ pointers as “dead” without examining the tuples. The
+ intended use of this function is to forcibly remove tuples that are not
+ otherwise accessible. For example:
+
+test=> select * from t1 where ctid = '(0, 1)';
+ERROR: could not access status of transaction 4007513275
+DETAIL: Could not open file "pg_xact/0EED": No such file or directory.
+
+test=# select heap_force_kill('t1'::regclass, ARRAY['(0, 1)']::tid[]);
+ heap_force_kill
+-----------------
+
+(1 row)
+
+test=# select * from t1 where ctid = '(0, 1)';
+(0 rows)
+
+
+
-
+
heap_force_freeze(regclass, tid[]) returns void
+
+ heap_force_freeze marks tuples as frozen without
+ examining the tuple data. The intended use of this function is to
+ make accessible tuples which are inaccessible due to corrupted
+ visibility information, or which prevent the table from being
+ successfully vacuumed due to corrupted visibility information.
+ For example:
+
+test=> vacuum t1;
+ERROR: found xmin 507 from before relfrozenxid 515
+CONTEXT: while scanning block 0 of relation "public.t1"
+
+test=# select ctid from t1 where xmin = 507;
+ ctid
+-------
+ (0,3)
+(1 row)
+
+test=# select heap_force_freeze('t1'::regclass, ARRAY['(0, 3)']::tid[]);
+ heap_force_freeze
+-------------------
+
+(1 row)
+
+test=# select ctid from t1 where xmin = 2;
+ ctid
+-------
+ (0,3)
+(1 row)
+
+
+
pg_test_fsync
pg_test_fsync — determine fastest wal_sync_method for PostgreSQL
Synopsis
pg_test_fsync [option...]
Description
+ pg_test_fsync is intended to give you a reasonable
+ idea of what the fastest wal_sync_method is on your
+ specific system,
+ as well as supplying diagnostic information in the event of an identified I/O
+ problem. However, differences shown by
+ pg_test_fsync might not make any significant
+ difference in real database throughput, especially since many database servers
+ are not speed-limited by their write-ahead logs.
+ pg_test_fsync reports average file sync operation
+ time in microseconds for each wal_sync_method, which can also be used to
+ inform efforts to optimize the value of commit_delay.
+
Options
+ pg_test_fsync accepts the following
+ command-line options:
+
+
-f
--filename
+ Specifies the file name to write test data in.
+ This file should be in the same file system that the
+ pg_wal directory is or will be placed in.
+ (pg_wal contains the WAL files.)
+ The default is pg_test_fsync.out in the current
+ directory.
+
-s
--secs-per-test
+ Specifies the number of seconds for each test. The more time
+ per test, the greater the test's accuracy, but the longer it takes
+ to run. The default is 5 seconds, which allows the program to
+ complete in under 2 minutes.
+
-V
--version
+ Print the pg_test_fsync version and exit.
+
-?
--help
+ Show help about pg_test_fsync command line
+ arguments, and exit.
+
+
Environment
+ The environment variable PG_COLOR specifies whether to use
+ color in diagnostic messages. Possible values are
+ always, auto and
+ never.
+
pg_test_timing
pg_test_timing — measure timing overhead
Synopsis
pg_test_timing [option...]
Description
+ pg_test_timing is a tool to measure the timing overhead
+ on your system and confirm that the system time never moves backwards.
+ Systems that are slow to collect timing data can give less accurate
+ EXPLAIN ANALYZE results.
+
Options
+ pg_test_timing accepts the following
+ command-line options:
+
+
-d duration
--duration=duration
+ Specifies the test duration, in seconds. Longer durations
+ give slightly better accuracy, and are more likely to discover
+ problems with the system clock moving backwards. The default
+ test duration is 3 seconds.
+
-V
--version
+ Print the pg_test_timing version and exit.
+
-?
--help
+ Show help about pg_test_timing command line
+ arguments, and exit.
+
+
Usage
Interpreting Results
+ Good results will show most (>90%) individual timing calls take less than
+ one microsecond. Average per loop overhead will be even lower, below 100
+ nanoseconds. This example from an Intel i7-860 system using a TSC clock
+ source shows excellent performance:
+
+
+Testing timing overhead for 3 seconds.
+Per loop time including overhead: 35.96 ns
+Histogram of timing durations:
+ < us % of total count
+ 1 96.40465 80435604
+ 2 3.59518 2999652
+ 4 0.00015 126
+ 8 0.00002 13
+ 16 0.00000 2
+
+
+ Note that different units are used for the per loop time than the
+ histogram. The loop can have resolution within a few nanoseconds (ns),
+ while the individual timing calls can only resolve down to one microsecond
+ (us).
+
Measuring Executor Timing Overhead
+ When the query executor is running a statement using
+ EXPLAIN ANALYZE, individual operations are timed as well
+ as showing a summary. The overhead of your system can be checked by
+ counting rows with the psql program:
+
+
+CREATE TABLE t AS SELECT * FROM generate_series(1,100000);
+\timing
+SELECT COUNT(*) FROM t;
+EXPLAIN ANALYZE SELECT COUNT(*) FROM t;
+
+
+ The i7-860 system measured runs the count query in 9.8 ms while
+ the EXPLAIN ANALYZE version takes 16.6 ms, each
+ processing just over 100,000 rows. That 6.8 ms difference means the timing
+ overhead per row is 68 ns, about twice what pg_test_timing estimated it
+ would be. Even that relatively small amount of overhead is making the fully
+ timed count statement take almost 70% longer. On more substantial queries,
+ the timing overhead would be less problematic.
+
Changing Time Sources
+ On some newer Linux systems, it's possible to change the clock source used
+ to collect timing data at any time. A second example shows the slowdown
+ possible from switching to the slower acpi_pm time source, on the same
+ system used for the fast results above:
+
+
+# cat /sys/devices/system/clocksource/clocksource0/available_clocksource
+tsc hpet acpi_pm
+# echo acpi_pm > /sys/devices/system/clocksource/clocksource0/current_clocksource
+# pg_test_timing
+Per loop time including overhead: 722.92 ns
+Histogram of timing durations:
+ < us % of total count
+ 1 27.84870 1155682
+ 2 72.05956 2990371
+ 4 0.07810 3241
+ 8 0.01357 563
+ 16 0.00007 3
+
+
+ In this configuration, the sample EXPLAIN ANALYZE above
+ takes 115.9 ms. That's 1061 ns of timing overhead, again a small multiple
+ of what's measured directly by this utility. That much timing overhead
+ means the actual query itself is only taking a tiny fraction of the
+ accounted for time, most of it is being consumed in overhead instead. In
+ this configuration, any EXPLAIN ANALYZE totals involving
+ many timed operations would be inflated significantly by timing overhead.
+
+ FreeBSD also allows changing the time source on the fly, and it logs
+ information about the timer selected during boot:
+
+
+# dmesg | grep "Timecounter"
+Timecounter "ACPI-fast" frequency 3579545 Hz quality 900
+Timecounter "i8254" frequency 1193182 Hz quality 0
+Timecounters tick every 10.000 msec
+Timecounter "TSC" frequency 2531787134 Hz quality 800
+# sysctl kern.timecounter.hardware=TSC
+kern.timecounter.hardware: ACPI-fast -> TSC
+
+
+ Other systems may only allow setting the time source on boot. On older
+ Linux systems the "clock" kernel setting is the only way to make this sort
+ of change. And even on some more recent ones, the only option you'll see
+ for a clock source is "jiffies". Jiffies are the older Linux software clock
+ implementation, which can have good resolution when it's backed by fast
+ enough timing hardware, as in this example:
+
+
+$ cat /sys/devices/system/clocksource/clocksource0/available_clocksource
+jiffies
+$ dmesg | grep time.c
+time.c: Using 3.579545 MHz WALL PM GTOD PIT/TSC timer.
+time.c: Detected 2400.153 MHz processor.
+$ pg_test_timing
+Testing timing overhead for 3 seconds.
+Per timing duration including loop overhead: 97.75 ns
+Histogram of timing durations:
+ < us % of total count
+ 1 90.23734 27694571
+ 2 9.75277 2993204
+ 4 0.00981 3010
+ 8 0.00007 22
+ 16 0.00000 1
+ 32 0.00000 1
+
Clock Hardware and Timing Accuracy
+ Collecting accurate timing information is normally done on computers using
+ hardware clocks with various levels of accuracy. With some hardware the
+ operating systems can pass the system clock time almost directly to
+ programs. A system clock can also be derived from a chip that simply
+ provides timing interrupts, periodic ticks at some known time interval. In
+ either case, operating system kernels provide a clock source that hides
+ these details. But the accuracy of that clock source and how quickly it can
+ return results varies based on the underlying hardware.
+
+ Inaccurate time keeping can result in system instability. Test any change
+ to the clock source very carefully. Operating system defaults are sometimes
+ made to favor reliability over best accuracy. And if you are using a virtual
+ machine, look into the recommended time sources compatible with it. Virtual
+ hardware faces additional difficulties when emulating timers, and there are
+ often per operating system settings suggested by vendors.
+
+ The Time Stamp Counter (TSC) clock source is the most accurate one available
+ on current generation CPUs. It's the preferred way to track the system time
+ when it's supported by the operating system and the TSC clock is
+ reliable. There are several ways that TSC can fail to provide an accurate
+ timing source, making it unreliable. Older systems can have a TSC clock that
+ varies based on the CPU temperature, making it unusable for timing. Trying
+ to use TSC on some older multicore CPUs can give a reported time that's
+ inconsistent among multiple cores. This can result in the time going
+ backwards, a problem this program checks for. And even the newest systems
+ can fail to provide accurate TSC timing with very aggressive power saving
+ configurations.
+
+ Newer operating systems may check for the known TSC problems and switch to a
+ slower, more stable clock source when they are seen. If your system
+ supports TSC time but doesn't default to that, it may be disabled for a good
+ reason. And some operating systems may not detect all the possible problems
+ correctly, or will allow using TSC even in situations where it's known to be
+ inaccurate.
+
+ The High Precision Event Timer (HPET) is the preferred timer on systems
+ where it's available and TSC is not accurate. The timer chip itself is
+ programmable to allow up to 100 nanosecond resolution, but you may not see
+ that much accuracy in your system clock.
+
+ Advanced Configuration and Power Interface (ACPI) provides a Power
+ Management (PM) Timer, which Linux refers to as the acpi_pm. The clock
+ derived from acpi_pm will at best provide 300 nanosecond resolution.
+
+ Timers used on older PC hardware include the 8254 Programmable Interval
+ Timer (PIT), the real-time clock (RTC), the Advanced Programmable Interrupt
+ Controller (APIC) timer, and the Cyclone timer. These timers aim for
+ millisecond resolution.
+
F.35. pg_trgm —
+ support for similarity of text using trigram matching #
+ The pg_trgm module provides functions and operators
+ for determining the similarity of
+ alphanumeric text based on trigram matching, as
+ well as index operator classes that support fast searching for similar
+ strings.
+
+ This module is considered “trusted”, that is, it can be
+ installed by non-superusers who have CREATE privilege
+ on the current database.
+
F.35.1. Trigram (or Trigraph) Concepts #
+ A trigram is a group of three consecutive characters taken
+ from a string. We can measure the similarity of two strings by
+ counting the number of trigrams they share. This simple idea
+ turns out to be very effective for measuring the similarity of
+ words in many natural languages.
+
Note
+ pg_trgm ignores non-word characters
+ (non-alphanumerics) when extracting trigrams from a string.
+ Each word is considered to have two spaces
+ prefixed and one space suffixed when determining the set
+ of trigrams contained in the string.
+ For example, the set of trigrams in the string
+ “cat” is
+ “ c”,
+ “ ca”,
+ “cat”, and
+ “at ”.
+ The set of trigrams in the string
+ “foo|bar” is
+ “ f”,
+ “ fo”,
+ “foo”,
+ “oo ”,
+ “ b”,
+ “ ba”,
+ “bar”, and
+ “ar ”.
+
F.35.2. Functions and Operators #
+ The functions provided by the pg_trgm module
+ are shown in Table F.26, the operators
+ in Table F.27.
+
Table F.26. pg_trgm Functions
+ Function
+
+
+ Description
+ |
|---|
+
+ similarity ( text, text )
+ → real
+
+
+ Returns a number that indicates how similar the two arguments are.
+ The range of the result is zero (indicating that the two strings are
+ completely dissimilar) to one (indicating that the two strings are
+ identical).
+ |
+
+ show_trgm ( text )
+ → text[]
+
+
+ Returns an array of all the trigrams in the given string.
+ (In practice this is seldom useful except for debugging.)
+ |
+
+ word_similarity ( text, text )
+ → real
+
+
+ Returns a number that indicates the greatest similarity between
+ the set of trigrams in the first string and any continuous extent
+ of an ordered set of trigrams in the second string. For details, see
+ the explanation below.
+ |
+
+ strict_word_similarity ( text, text )
+ → real
+
+
+ Same as word_similarity, but forces
+ extent boundaries to match word boundaries. Since we don't have
+ cross-word trigrams, this function actually returns greatest similarity
+ between first string and any continuous extent of words of the second
+ string.
+ |
+
+ show_limit ()
+ → real
+
+
+ Returns the current similarity threshold used by the %
+ operator. This sets the minimum similarity between
+ two words for them to be considered similar enough to
+ be misspellings of each other, for example.
+ (Deprecated; instead use SHOW
+ pg_trgm.similarity_threshold.)
+ |
+
+ set_limit ( real )
+ → real
+
+
+ Sets the current similarity threshold that is used by the %
+ operator. The threshold must be between 0 and 1 (default is 0.3).
+ Returns the same value passed in.
+ (Deprecated; instead use SET
+ pg_trgm.similarity_threshold.)
+ |
+ Consider the following example:
+
+
+# SELECT word_similarity('word', 'two words');
+ word_similarity
+-----------------
+ 0.8
+(1 row)
+
+
+ In the first string, the set of trigrams is
+ {" w"," wo","wor","ord","rd "}.
+ In the second string, the ordered set of trigrams is
+ {" t"," tw","two","wo "," w"," wo","wor","ord","rds","ds "}.
+ The most similar extent of an ordered set of trigrams in the second string
+ is {" w"," wo","wor","ord"}, and the similarity is
+ 0.8.
+
+ This function returns a value that can be approximately understood as the
+ greatest similarity between the first string and any substring of the second
+ string. However, this function does not add padding to the boundaries of
+ the extent. Thus, the number of additional characters present in the
+ second string is not considered, except for the mismatched word boundaries.
+
+ At the same time, strict_word_similarity
+ selects an extent of words in the second string. In the example above,
+ strict_word_similarity would select the
+ extent of a single word 'words', whose set of trigrams is
+ {" w"," wo","wor","ord","rds","ds "}.
+
+
+# SELECT strict_word_similarity('word', 'two words'), similarity('word', 'words');
+ strict_word_similarity | similarity
+------------------------+------------
+ 0.571429 | 0.571429
+(1 row)
+
+
+ Thus, the strict_word_similarity function
+ is useful for finding the similarity to whole words, while
+ word_similarity is more suitable for
+ finding the similarity for parts of words.
+
Table F.27. pg_trgm Operators
+ Operator
+
+
+ Description
+ |
|---|
+ text % text
+ → boolean
+
+
+ Returns true if its arguments have a similarity
+ that is greater than the current similarity threshold set by
+ pg_trgm.similarity_threshold.
+ |
+ text <% text
+ → boolean
+
+
+ Returns true if the similarity between the trigram
+ set in the first argument and a continuous extent of an ordered trigram
+ set in the second argument is greater than the current word similarity
+ threshold set by pg_trgm.word_similarity_threshold
+ parameter.
+ |
+ text %> text
+ → boolean
+
+
+ Commutator of the <% operator.
+ |
+ text <<% text
+ → boolean
+
+
+ Returns true if its second argument has a continuous
+ extent of an ordered trigram set that matches word boundaries,
+ and its similarity to the trigram set of the first argument is greater
+ than the current strict word similarity threshold set by the
+ pg_trgm.strict_word_similarity_threshold parameter.
+ |
+ text %>> text
+ → boolean
+
+
+ Commutator of the <<% operator.
+ |
+ text <-> text
+ → real
+
+
+ Returns the “distance” between the arguments, that is
+ one minus the similarity() value.
+ |
+ text <<-> text
+ → real
+
+
+ Returns the “distance” between the arguments, that is
+ one minus the word_similarity() value.
+ |
+ text <->> text
+ → real
+
+
+ Commutator of the <<-> operator.
+ |
+ text <<<-> text
+ → real
+
+
+ Returns the “distance” between the arguments, that is
+ one minus the strict_word_similarity() value.
+ |
+ text <->>> text
+ → real
+
+
+ Commutator of the <<<-> operator.
+ |
-
+
pg_trgm.similarity_threshold (real)
+
+ #
+ Sets the current similarity threshold that is used by the %
+ operator. The threshold must be between 0 and 1 (default is 0.3).
+
-
+
pg_trgm.word_similarity_threshold (real)
+
+ #
+ Sets the current word similarity threshold that is used by the
+ <% and %> operators. The threshold
+ must be between 0 and 1 (default is 0.6).
+
-
+
pg_trgm.strict_word_similarity_threshold (real)
+
+ #
+ Sets the current strict word similarity threshold that is used by the
+ <<% and %>> operators. The threshold
+ must be between 0 and 1 (default is 0.5).
+
+ The pg_trgm module provides GiST and GIN index
+ operator classes that allow you to create an index over a text column for
+ the purpose of very fast similarity searches. These index types support
+ the above-described similarity operators, and additionally support
+ trigram-based index searches for LIKE, ILIKE,
+ ~, ~* and = queries.
+ The similarity comparisons are case-insensitive in a default build of
+ pg_trgm.
+ Inequality operators are not supported.
+ Note that those indexes may not be as efficient as regular B-tree indexes
+ for equality operator.
+
+ Example:
+
+
+CREATE TABLE test_trgm (t text);
+CREATE INDEX trgm_idx ON test_trgm USING GIST (t gist_trgm_ops);
+
+or
+
+CREATE INDEX trgm_idx ON test_trgm USING GIN (t gin_trgm_ops);
+
+
+ gist_trgm_ops GiST opclass approximates a set of
+ trigrams as a bitmap signature. Its optional integer parameter
+ siglen determines the
+ signature length in bytes. The default length is 12 bytes.
+ Valid values of signature length are between 1 and 2024 bytes. Longer
+ signatures lead to a more precise search (scanning a smaller fraction of the index and
+ fewer heap pages), at the cost of a larger index.
+
+ Example of creating such an index with a signature length of 32 bytes:
+
+CREATE INDEX trgm_idx ON test_trgm USING GIST (t gist_trgm_ops(siglen=32));
+
+ At this point, you will have an index on the t column that
+ you can use for similarity searching. A typical query is
+
+SELECT t, similarity(t, 'word') AS sml
+ FROM test_trgm
+ WHERE t % 'word'
+ ORDER BY sml DESC, t;
+
+ This will return all values in the text column that are sufficiently
+ similar to word, sorted from best match to worst. The
+ index will be used to make this a fast operation even over very large data
+ sets.
+
+ A variant of the above query is
+
+SELECT t, t <-> 'word' AS dist
+ FROM test_trgm
+ ORDER BY dist LIMIT 10;
+
+ This can be implemented quite efficiently by GiST indexes, but not
+ by GIN indexes. It will usually beat the first formulation when only
+ a small number of the closest matches is wanted.
+
+ Also you can use an index on the t column for word
+ similarity or strict word similarity. Typical queries are:
+
+SELECT t, word_similarity('word', t) AS sml
+ FROM test_trgm
+ WHERE 'word' <% t
+ ORDER BY sml DESC, t;
+
+ and
+
+SELECT t, strict_word_similarity('word', t) AS sml
+ FROM test_trgm
+ WHERE 'word' <<% t
+ ORDER BY sml DESC, t;
+
+ This will return all values in the text column for which there is a
+ continuous extent in the corresponding ordered trigram set that is
+ sufficiently similar to the trigram set of word,
+ sorted from best match to worst. The index will be used to make this
+ a fast operation even over very large data sets.
+
+ Possible variants of the above queries are:
+
+SELECT t, 'word' <<-> t AS dist
+ FROM test_trgm
+ ORDER BY dist LIMIT 10;
+
+ and
+
+SELECT t, 'word' <<<-> t AS dist
+ FROM test_trgm
+ ORDER BY dist LIMIT 10;
+
+ This can be implemented quite efficiently by GiST indexes, but not
+ by GIN indexes.
+
+ Beginning in PostgreSQL 9.1, these index types also support
+ index searches for LIKE and ILIKE, for example
+
+SELECT * FROM test_trgm WHERE t LIKE '%foo%bar';
+
+ The index search works by extracting trigrams from the search string
+ and then looking these up in the index. The more trigrams in the search
+ string, the more effective the index search is. Unlike B-tree based
+ searches, the search string need not be left-anchored.
+
+ Beginning in PostgreSQL 9.3, these index types also support
+ index searches for regular-expression matches
+ (~ and ~* operators), for example
+
+SELECT * FROM test_trgm WHERE t ~ '(foo|bar)';
+
+ The index search works by extracting trigrams from the regular expression
+ and then looking these up in the index. The more trigrams that can be
+ extracted from the regular expression, the more effective the index search
+ is. Unlike B-tree based searches, the search string need not be
+ left-anchored.
+
+ For both LIKE and regular-expression searches, keep in mind
+ that a pattern with no extractable trigrams will degenerate to a full-index
+ scan.
+
+ The choice between GiST and GIN indexing depends on the relative
+ performance characteristics of GiST and GIN, which are discussed elsewhere.
+
F.35.5. Text Search Integration #
+ Trigram matching is a very useful tool when used in conjunction
+ with a full text index. In particular it can help to recognize
+ misspelled input words that will not be matched directly by the
+ full text search mechanism.
+
+ The first step is to generate an auxiliary table containing all
+ the unique words in the documents:
+
+
+CREATE TABLE words AS SELECT word FROM
+ ts_stat('SELECT to_tsvector(''simple'', bodytext) FROM documents');
+
+
+ where documents is a table that has a text field
+ bodytext that we wish to search. The reason for using
+ the simple configuration with the to_tsvector
+ function, instead of using a language-specific configuration,
+ is that we want a list of the original (unstemmed) words.
+
+ Next, create a trigram index on the word column:
+
+
+CREATE INDEX words_idx ON words USING GIN (word gin_trgm_ops);
+
+
+ Now, a SELECT query similar to the previous example can
+ be used to suggest spellings for misspelled words in user search terms.
+ A useful extra test is to require that the selected words are also of
+ similar length to the misspelled word.
+
Note
+ Since the words table has been generated as a separate,
+ static table, it will need to be periodically regenerated so that
+ it remains reasonably up-to-date with the document collection.
+ Keeping it exactly current is usually unnecessary.
+
+ Oleg Bartunov <oleg@sai.msu.su>, Moscow, Moscow University, Russia
+
+ Teodor Sigaev <teodor@sigaev.ru>, Moscow, Delta-Soft Ltd.,Russia
+
+ Alexander Korotkov <a.korotkov@postgrespro.ru>, Moscow, Postgres Professional, Russia
+
+ Documentation: Christopher Kings-Lynne
+
+ This module is sponsored by Delta-Soft Ltd., Moscow, Russia.
+
pg_upgrade
pg_upgrade — upgrade a PostgreSQL server instance
Synopsis
pg_upgrade -b oldbindir [-B newbindir] -d oldconfigdir -D newconfigdir [option...]
Description
+ pg_upgrade (formerly called pg_migrator) allows data
+ stored in PostgreSQL data files to be upgraded to a later PostgreSQL
+ major version without the data dump/restore typically required for
+ major version upgrades, e.g., from 12.14 to 13.10 or from 14.9 to 15.5.
+ It is not required for minor version upgrades, e.g., from 12.7 to 12.8
+ or from 14.1 to 14.5.
+
+ Major PostgreSQL releases regularly add new features that often
+ change the layout of the system tables, but the internal data storage
+ format rarely changes. pg_upgrade uses this fact
+ to perform rapid upgrades by creating new system tables and simply
+ reusing the old user data files. If a future major release ever
+ changes the data storage format in a way that makes the old data
+ format unreadable, pg_upgrade will not be usable
+ for such upgrades. (The community will attempt to avoid such
+ situations.)
+
+ pg_upgrade does its best to
+ make sure the old and new clusters are binary-compatible, e.g., by
+ checking for compatible compile-time settings, including 32/64-bit
+ binaries. It is important that
+ any external modules are also binary compatible, though this cannot
+ be checked by pg_upgrade.
+
+ pg_upgrade supports upgrades from 9.2.X and later to the current
+ major release of PostgreSQL, including snapshot and beta releases.
+
Options
+ pg_upgrade accepts the following command-line arguments:
+
+
-b bindir
--old-bindir=bindirthe old PostgreSQL executable directory;
+ environment variable PGBINOLD
-B bindir
--new-bindir=bindirthe new PostgreSQL executable directory;
+ default is the directory where pg_upgrade resides;
+ environment variable PGBINNEW
-c
--checkcheck clusters only, don't change any data
-d configdir
--old-datadir=configdirthe old database cluster configuration directory; environment
+ variable PGDATAOLD
-D configdir
--new-datadir=configdirthe new database cluster configuration directory; environment
+ variable PGDATANEW
-j njobs
--jobs=njobsnumber of simultaneous processes or threads to use
+
-k
--linkuse hard links instead of copying files to the new
+ cluster
-N
--no-sync
+ By default, pg_upgrade will wait for all files
+ of the upgraded cluster to be written safely to disk. This option
+ causes pg_upgrade to return without waiting, which
+ is faster, but means that a subsequent operating system crash can leave
+ the data directory corrupt. Generally, this option is
+ useful for testing but should not be used on a production
+ installation.
+
-o options
--old-options optionsoptions to be passed directly to the
+ old postgres command; multiple
+ option invocations are appended
-O options
--new-options optionsoptions to be passed directly to the
+ new postgres command; multiple
+ option invocations are appended
-p port
--old-port=portthe old cluster port number; environment
+ variable PGPORTOLD
-P port
--new-port=portthe new cluster port number; environment
+ variable PGPORTNEW
-r
--retainretain SQL and log files even after successful completion
+
-s dir
--socketdir=dirdirectory to use for postmaster sockets during upgrade;
+ default is current working directory; environment
+ variable PGSOCKETDIR
-U username
--username=usernamecluster's install user name; environment
+ variable PGUSER
-v
--verboseenable verbose internal logging
-V
--versiondisplay version information, then exit
--clone
+ Use efficient file cloning (also known as “reflinks” on
+ some systems) instead of copying files to the new cluster. This can
+ result in near-instantaneous copying of the data files, giving the
+ speed advantages of -k/--link while
+ leaving the old cluster untouched.
+
+ File cloning is only supported on some operating systems and file
+ systems. If it is selected but not supported, the
+ pg_upgrade run will error. At present, it
+ is supported on Linux (kernel 4.5 or later) with Btrfs and XFS (on
+ file systems created with reflink support), and on macOS with APFS.
+
--copy
+ Copy files to the new cluster. This is the default. (See also
+ --link and --clone.)
+
-?
--helpshow help, then exit
+
Usage
+ These are the steps to perform an upgrade
+ with pg_upgrade:
+
Optionally move the old cluster
+ If you are using a version-specific installation directory, e.g.,
+ /opt/PostgreSQL/16, you do not need to move the old cluster. The
+ graphical installers all use version-specific installation directories.
+
+ If your installation directory is not version-specific, e.g.,
+ /usr/local/pgsql, it is necessary to move the current PostgreSQL install
+ directory so it does not interfere with the new PostgreSQL installation.
+ Once the current PostgreSQL server is shut down, it is safe to rename the
+ PostgreSQL installation directory; assuming the old directory is
+ /usr/local/pgsql, you can do:
+
+
+mv /usr/local/pgsql /usr/local/pgsql.old
+
+ to rename the directory.
+
For source installs, build the new version
+ Build the new PostgreSQL source with configure flags that are compatible
+ with the old cluster. pg_upgrade will check pg_controldata to make
+ sure all settings are compatible before starting the upgrade.
+
Install the new PostgreSQL binaries
+ Install the new server's binaries and support
+ files. pg_upgrade is included in a default installation.
+
+ For source installs, if you wish to install the new server in a custom
+ location, use the prefix variable:
+
+
+make prefix=/usr/local/pgsql.new install
+
Initialize the new PostgreSQL cluster
+ Initialize the new cluster using initdb.
+ Again, use compatible initdb
+ flags that match the old cluster. Many
+ prebuilt installers do this step automatically. There is no need to
+ start the new cluster.
+
Install extension shared object files
+ Many extensions and custom modules, whether from
+ contrib or another source, use shared object
+ files (or DLLs), e.g., pgcrypto.so. If the old
+ cluster used these, shared object files matching the new server binary
+ must be installed in the new cluster, usually via operating system
+ commands. Do not load the schema definitions, e.g., CREATE
+ EXTENSION pgcrypto, because these will be duplicated from
+ the old cluster. If extension updates are available,
+ pg_upgrade will report this and create
+ a script that can be run later to update them.
+
Copy custom full-text search files
+ Copy any custom full text search files (dictionary, synonym,
+ thesaurus, stop words) from the old to the new cluster.
+
Adjust authentication
+ pg_upgrade will connect to the old and new servers several
+ times, so you might want to set authentication to peer
+ in pg_hba.conf or use a ~/.pgpass file
+ (see Section 34.16).
+
Stop both servers
+ Make sure both database servers are stopped using, on Unix, e.g.:
+
+
+pg_ctl -D /opt/PostgreSQL/12 stop
+pg_ctl -D /opt/PostgreSQL/16 stop
+
+
+ or on Windows, using the proper service names:
+
+
+NET STOP postgresql-12
+NET STOP postgresql-16
+
+
+ Streaming replication and log-shipping standby servers must be
+ running during this shutdown so they receive all changes.
+
Prepare for standby server upgrades
+ If you are upgrading standby servers using methods outlined in section Step 11, verify that the old standby
+ servers are caught up by running pg_controldata
+ against the old primary and standby clusters. Verify that the
+ “Latest checkpoint location” values match in all clusters.
+ Also, make sure wal_level is not set to
+ minimal in the postgresql.conf file on the
+ new primary cluster.
+
Run pg_upgrade
+ Always run the pg_upgrade binary of the new server, not the old one.
+ pg_upgrade requires the specification of the old and new cluster's
+ data and executable (bin) directories. You can also specify
+ user and port values, and whether you want the data files linked or cloned
+ instead of the default copy behavior.
+
+ If you use link mode, the upgrade will be much faster (no file
+ copying) and use less disk space, but you will not be able to access
+ your old cluster
+ once you start the new cluster after the upgrade. Link mode also
+ requires that the old and new cluster data directories be in the
+ same file system. (Tablespaces and pg_wal can be on
+ different file systems.)
+ Clone mode provides the same speed and disk space advantages but
+ does not cause the old cluster to be unusable once the new cluster
+ is started. Clone mode also requires that the old and new data
+ directories be in the same file system. This mode is only available
+ on certain operating systems and file systems.
+
+ The --jobs option allows multiple CPU cores to be used
+ for copying/linking of files and to dump and restore database schemas
+ in parallel; a good place to start is the maximum of the number of
+ CPU cores and tablespaces. This option can dramatically reduce the
+ time to upgrade a multi-database server running on a multiprocessor
+ machine.
+
+ For Windows users, you must be logged into an administrative account, and
+ then start a shell as the postgres user and set the proper path:
+
+
+RUNAS /USER:postgres "CMD.EXE"
+SET PATH=%PATH%;C:\Program Files\PostgreSQL\16\bin;
+
+
+ and then run pg_upgrade with quoted directories, e.g.:
+
+
+pg_upgrade.exe
+ --old-datadir "C:/Program Files/PostgreSQL/12/data"
+ --new-datadir "C:/Program Files/PostgreSQL/16/data"
+ --old-bindir "C:/Program Files/PostgreSQL/12/bin"
+ --new-bindir "C:/Program Files/PostgreSQL/16/bin"
+
+
+ Once started, pg_upgrade will verify the two clusters are compatible
+ and then do the upgrade. You can use pg_upgrade --check
+ to perform only the checks, even if the old server is still
+ running. pg_upgrade --check will also outline any
+ manual adjustments you will need to make after the upgrade. If you
+ are going to be using link or clone mode, you should use the option
+ --link or --clone with
+ --check to enable mode-specific checks.
+ pg_upgrade requires write permission in the current directory.
+
+ Obviously, no one should be accessing the clusters during the
+ upgrade. pg_upgrade defaults to running servers
+ on port 50432 to avoid unintended client connections.
+ You can use the same port number for both clusters when doing an
+ upgrade because the old and new clusters will not be running at the
+ same time. However, when checking an old running server, the old
+ and new port numbers must be different.
+
+ If an error occurs while restoring the database schema, pg_upgrade will
+ exit and you will have to revert to the old cluster as outlined in Step 17
+ below. To try pg_upgrade again, you will need to modify the old
+ cluster so the pg_upgrade schema restore succeeds. If the problem is a
+ contrib module, you might need to uninstall the contrib module from
+ the old cluster and install it in the new cluster after the upgrade,
+ assuming the module is not being used to store user data.
+
Upgrade streaming replication and log-shipping standby servers
+ If you used link mode and have Streaming Replication (see Section 27.2.5) or Log-Shipping (see Section 27.2) standby servers, you can follow these steps to
+ quickly upgrade them. You will not be running pg_upgrade on
+ the standby servers, but rather rsync on the primary.
+ Do not start any servers yet.
+
+ If you did not use link mode, do not have or do not
+ want to use rsync, or want an easier solution, skip
+ the instructions in this section and simply recreate the standby
+ servers once pg_upgrade completes and the new primary
+ is running.
+
Install the new PostgreSQL binaries on standby servers
+ Make sure the new binaries and support files are installed on all
+ standby servers.
+
Make sure the new standby data directories do not exist
+ Make sure the new standby data directories do not
+ exist or are empty. If initdb was run, delete
+ the standby servers' new data directories.
+
Install extension shared object files
+ Install the same extension shared object files on the new standbys
+ that you installed in the new primary cluster.
+
Stop standby servers
+ If the standby servers are still running, stop them now using the
+ above instructions.
+
Save configuration files
+ Save any configuration files from the old standbys' configuration
+ directories you need to keep, e.g., postgresql.conf
+ (and any files included by it), postgresql.auto.conf,
+ pg_hba.conf, because these will be overwritten
+ or removed in the next step.
+
Run rsync
+ When using link mode, standby servers can be quickly upgraded using
+ rsync. To accomplish this, from a directory on
+ the primary server that is above the old and new database cluster
+ directories, run this on the primary for each standby
+ server:
+
+
+rsync --archive --delete --hard-links --size-only --no-inc-recursive old_cluster new_cluster remote_dir
+
+
+ where old_cluster and new_cluster are relative
+ to the current directory on the primary, and remote_dir
+ is above the old and new cluster directories
+ on the standby. The directory structure under the specified
+ directories on the primary and standbys must match. Consult the
+ rsync manual page for details on specifying the
+ remote directory, e.g.,
+
+
+rsync --archive --delete --hard-links --size-only --no-inc-recursive /opt/PostgreSQL/12 \
+ /opt/PostgreSQL/16 standby.example.com:/opt/PostgreSQL
+
+
+ You can verify what the command will do using
+ rsync's --dry-run option. While
+ rsync must be run on the primary for at least one
+ standby, it is possible to run rsync on an upgraded
+ standby to upgrade other standbys, as long as the upgraded standby
+ has not been started.
+
+ What this does is to record the links created by
+ pg_upgrade's link mode that connect files in the
+ old and new clusters on the primary server. It then finds matching
+ files in the standby's old cluster and creates links for them in the
+ standby's new cluster. Files that were not linked on the primary
+ are copied from the primary to the standby. (They are usually
+ small.) This provides rapid standby upgrades. Unfortunately,
+ rsync needlessly copies files associated with
+ temporary and unlogged tables because these files don't normally
+ exist on standby servers.
+
+ If you have tablespaces, you will need to run a similar
+ rsync command for each tablespace directory, e.g.:
+
+
+rsync --archive --delete --hard-links --size-only --no-inc-recursive /vol1/pg_tblsp/PG_12_201909212 \
+ /vol1/pg_tblsp/PG_16_202307071 standby.example.com:/vol1/pg_tblsp
+
+
+ If you have relocated pg_wal outside the data
+ directories, rsync must be run on those directories
+ too.
+
Configure streaming replication and log-shipping standby servers
+ Configure the servers for log shipping. (You do not need to run
+ pg_backup_start() and pg_backup_stop()
+ or take a file system backup as the standbys are still synchronized
+ with the primary.) Replication slots are not copied and must
+ be recreated.
+
Restore pg_hba.conf
+ If you modified pg_hba.conf, restore its original settings.
+ It might also be necessary to adjust other configuration files in the new
+ cluster to match the old cluster, e.g., postgresql.conf
+ (and any files included by it), postgresql.auto.conf.
+
Start the new server
+ The new server can now be safely started, and then any
+ rsync'ed standby servers.
+
Post-upgrade processing
+ If any post-upgrade processing is required, pg_upgrade will issue
+ warnings as it completes. It will also generate script files that must
+ be run by the administrator. The script files will connect to each
+ database that needs post-upgrade processing. Each script should be
+ run using:
+
+
+psql --username=postgres --file=script.sql postgres
+
+
+ The scripts can be run in any order and can be deleted once they have
+ been run.
+
Caution
+ In general it is unsafe to access tables referenced in rebuild scripts
+ until the rebuild scripts have run to completion; doing so could yield
+ incorrect results or poor performance. Tables not referenced in rebuild
+ scripts can be accessed immediately.
+
Statistics
+ Because optimizer statistics are not transferred by pg_upgrade, you will
+ be instructed to run a command to regenerate that information at the end
+ of the upgrade. You might need to set connection parameters to
+ match your new cluster.
+
Delete old cluster
+ Once you are satisfied with the upgrade, you can delete the old
+ cluster's data directories by running the script mentioned when
+ pg_upgrade completes. (Automatic deletion is not
+ possible if you have user-defined tablespaces inside the old data
+ directory.) You can also delete the old installation directories
+ (e.g., bin, share).
+
Reverting to old cluster
+ If, after running pg_upgrade, you wish to revert to the old cluster,
+ there are several options:
+
+
+ If the --check option was used, the old cluster
+ was unmodified; it can be restarted.
+
+ If the --link option was not
+ used, the old cluster was unmodified; it can be restarted.
+
+ If the --link option was used, the data
+ files might be shared between the old and new cluster:
+
+
+ If pg_upgrade aborted before linking started,
+ the old cluster was unmodified; it can be restarted.
+
+ If you did not start the new cluster, the old
+ cluster was unmodified except that, when linking started, a
+ .old suffix was appended to
+ $PGDATA/global/pg_control. To reuse the old
+ cluster, remove the .old suffix from
+ $PGDATA/global/pg_control; you can then restart
+ the old cluster.
+
+ If you did start the new cluster, it has written to shared files
+ and it is unsafe to use the old cluster. The old cluster will
+ need to be restored from backup in this case.
+
Notes
+ pg_upgrade creates various working files, such
+ as schema dumps, stored within pg_upgrade_output.d in
+ the directory of the new cluster. Each run creates a new subdirectory named
+ with a timestamp formatted as per ISO 8601
+ (%Y%m%dT%H%M%S), where all its generated files are
+ stored.
+ pg_upgrade_output.d and its contained files will be
+ removed automatically if pg_upgrade completes
+ successfully; but in the event of trouble, the files there may provide
+ useful debugging information.
+
+ pg_upgrade launches short-lived postmasters in
+ the old and new data directories. Temporary Unix socket files for
+ communication with these postmasters are, by default, made in the current
+ working directory. In some situations the path name for the current
+ directory might be too long to be a valid socket name. In that case you
+ can use the -s option to put the socket files in some
+ directory with a shorter path name. For security, be sure that that
+ directory is not readable or writable by any other users.
+ (This is not supported on Windows.)
+
+ All failure, rebuild, and reindex cases will be reported by
+ pg_upgrade if they affect your installation;
+ post-upgrade scripts to rebuild tables and indexes will be
+ generated automatically. If you are trying to automate the upgrade
+ of many clusters, you should find that clusters with identical database
+ schemas require the same post-upgrade steps for all cluster upgrades;
+ this is because the post-upgrade steps are based on the database
+ schemas, and not user data.
+
+ For deployment testing, create a schema-only copy of the old cluster,
+ insert dummy data, and upgrade that.
+
+ pg_upgrade does not support upgrading of databases
+ containing table columns using these reg* OID-referencing system data types:
+
regcollation |
regconfig |
regdictionary |
regnamespace |
regoper |
regoperator |
regproc |
regprocedure |
+ (regclass, regrole, and regtype can be upgraded.)
+
+ If you want to use link mode and you do not want your old cluster
+ to be modified when the new cluster is started, consider using the clone mode.
+ If that is not available, make a copy of the
+ old cluster and upgrade that in link mode. To make a valid copy
+ of the old cluster, use rsync to create a dirty
+ copy of the old cluster while the server is running, then shut down
+ the old server and run rsync --checksum again to update the
+ copy with any changes to make it consistent. (--checksum
+ is necessary because rsync only has file modification-time
+ granularity of one second.) You might want to exclude some
+ files, e.g., postmaster.pid, as documented in Section 26.3.3. If your file system supports
+ file system snapshots or copy-on-write file copies, you can use that
+ to make a backup of the old cluster and tablespaces, though the snapshot
+ and copies must be created simultaneously or while the database server
+ is down.
+
F.36. pg_visibility — visibility map information and utilities #
+ The pg_visibility module provides a means for examining the
+ visibility map (VM) and page-level visibility information of a table.
+ It also provides functions to check the integrity of a visibility map and to
+ force it to be rebuilt.
+
+ Three different bits are used to store information about page-level
+ visibility. The all-visible bit in the visibility map indicates that every
+ tuple in the corresponding page of the relation is visible to every current
+ and future transaction. The all-frozen bit in the visibility map indicates
+ that every tuple in the page is frozen; that is, no future vacuum will need
+ to modify the page until such time as a tuple is inserted, updated, deleted,
+ or locked on that page.
+ The page header's PD_ALL_VISIBLE bit has the
+ same meaning as the all-visible bit in the visibility map, but is stored
+ within the data page itself rather than in a separate data structure.
+ These two bits will normally agree, but the page's all-visible bit can
+ sometimes be set while the visibility map bit is clear after a crash
+ recovery. The reported values can also disagree because of a change that
+ occurs after pg_visibility examines the visibility map and
+ before it examines the data page. Any event that causes data corruption
+ can also cause these bits to disagree.
+
+ Functions that display information about PD_ALL_VISIBLE bits
+ are much more costly than those that only consult the visibility map,
+ because they must read the relation's data blocks rather than only the
+ (much smaller) visibility map. Functions that check the relation's
+ data blocks are similarly expensive.
+
pg_visibility_map(relation regclass, blkno bigint, all_visible OUT boolean, all_frozen OUT boolean) returns record
+ Returns the all-visible and all-frozen bits in the visibility map for
+ the given block of the given relation.
+
pg_visibility(relation regclass, blkno bigint, all_visible OUT boolean, all_frozen OUT boolean, pd_all_visible OUT boolean) returns record
+ Returns the all-visible and all-frozen bits in the visibility map for
+ the given block of the given relation, plus the
+ PD_ALL_VISIBLE bit of that block.
+
pg_visibility_map(relation regclass, blkno OUT bigint, all_visible OUT boolean, all_frozen OUT boolean) returns setof record
+ Returns the all-visible and all-frozen bits in the visibility map for
+ each block of the given relation.
+
pg_visibility(relation regclass, blkno OUT bigint, all_visible OUT boolean, all_frozen OUT boolean, pd_all_visible OUT boolean) returns setof record
+ Returns the all-visible and all-frozen bits in the visibility map for
+ each block of the given relation, plus the PD_ALL_VISIBLE
+ bit of each block.
+
pg_visibility_map_summary(relation regclass, all_visible OUT bigint, all_frozen OUT bigint) returns record
+ Returns the number of all-visible pages and the number of all-frozen
+ pages in the relation according to the visibility map.
+
pg_check_frozen(relation regclass, t_ctid OUT tid) returns setof tid
+ Returns the TIDs of non-frozen tuples stored in pages marked all-frozen
+ in the visibility map. If this function returns a non-empty set of
+ TIDs, the visibility map is corrupt.
+
pg_check_visible(relation regclass, t_ctid OUT tid) returns setof tid
+ Returns the TIDs of non-all-visible tuples stored in pages marked
+ all-visible in the visibility map. If this function returns a non-empty
+ set of TIDs, the visibility map is corrupt.
+
pg_truncate_visibility_map(relation regclass) returns void
+ Truncates the visibility map for the given relation. This function is
+ useful if you believe that the visibility map for the relation is
+ corrupt and wish to force rebuilding it. The first VACUUM
+ executed on the given relation after this function is executed will scan
+ every page in the relation and rebuild the visibility map. (Until that
+ is done, queries will treat the visibility map as containing all zeroes.)
+
+ By default, these functions are executable only by superusers and roles with privileges
+ of the pg_stat_scan_tables role, with the exception of
+ pg_truncate_visibility_map(relation regclass) which can only
+ be executed by superusers.
+
pg_waldump
pg_waldump — display a human-readable rendering of the write-ahead log of a PostgreSQL database cluster
Synopsis
pg_waldump [option...] [startseg [endseg]]
Description
+ pg_waldump displays the write-ahead log (WAL) and is mainly
+ useful for debugging or educational purposes.
+
+ This utility can only be run by the user who installed the server, because
+ it requires read-only access to the data directory.
+
Options
+ The following command-line options control the location and format of the
+ output:
+
+
startseg
+ Start reading at the specified WAL segment file. This implicitly determines
+ the path in which files will be searched for, and the timeline to use.
+
endseg
+ Stop after reading the specified WAL segment file.
+
-b
--bkp-details
+ Output detailed information about backup blocks.
+
-B block
--block=block
+ Only display records that modify the given block. The relation must
+ also be provided with --relation or
+ -R.
+
-e end
--end=end
+ Stop reading at the specified WAL location, instead of reading to the
+ end of the log stream.
+
-f
--follow
+ After reaching the end of valid WAL, keep polling once per second for
+ new WAL to appear.
+
-F fork
--fork=fork
+ If provided, only display records that modify blocks in the given fork.
+ The valid values are main for the main fork,
+ fsm for the free space map,
+ vm for the visibility map,
+ and init for the init fork.
+
-n limit
--limit=limit
+ Display the specified number of records, then stop.
+
-p path
--path=path
+ Specifies a directory to search for WAL segment files or a
+ directory with a pg_wal subdirectory that
+ contains such files. The default is to search in the current
+ directory, the pg_wal subdirectory of the
+ current directory, and the pg_wal subdirectory
+ of PGDATA.
+
-q
--quiet
+ Do not print any output, except for errors. This option can be useful
+ when you want to know whether a range of WAL records can be
+ successfully parsed but don't care about the record contents.
+
-r rmgr
--rmgr=rmgr
+ Only display records generated by the specified resource manager. You can
+ specify the option multiple times to select multiple resource managers.
+ If list is passed as name, print a list of valid resource manager
+ names, and exit.
+
+ Extensions may define custom resource managers, but pg_waldump does
+ not load the extension module and therefore does not recognize custom
+ resource managers by name. Instead, you can specify the custom
+ resource managers as custom### where
+ "###" is the three-digit resource manager ID. Names
+ of this form will always be considered valid.
+
-R tblspc/db/rel
--relation=tblspc/db/rel
+ Only display records that modify blocks in the given relation. The
+ relation is specified with tablespace OID, database OID, and relfilenode
+ separated by slashes, for example 1234/12345/12345.
+ This is the same format used for relations in the program's output.
+
-s start
--start=start
+ WAL location at which to start reading. The default is to start reading
+ the first valid WAL record found in the earliest file found.
+
-t timeline
--timeline=timeline
+ Timeline from which to read WAL records. The default is to use the
+ value in startseg, if that is specified; otherwise, the
+ default is 1. The value can be specified in decimal or hexadecimal,
+ for example 17 or 0x11.
+
-V
--version
+ Print the pg_waldump version and exit.
+
-w
--fullpage
+ Only display records that include full page images.
+
-x xid
--xid=xid
+ Only display records marked with the given transaction ID.
+
-z
--stats[=record]
+ Display summary statistics (number and size of records and
+ full-page images) instead of individual records. Optionally
+ generate statistics per-record instead of per-rmgr.
+
+ If pg_waldump is terminated by signal
+ SIGINT
+ (Control+C),
+ the summary of the statistics computed is displayed up to the
+ termination point. This operation is not supported on
+ Windows.
+
--save-fullpage=save_path
+ Save full page images found in the WAL records to the
+ save_path directory. The images saved
+ are subject to the same filtering and limiting criteria as the
+ records displayed.
+
+ The full page images are saved with the following file name format:
+ TIMELINE-LSN.RELTABLESPACE.DATOID.RELNODE.BLKNOFORK
+
-?
--help
+ Show help about pg_waldump command line
+ arguments, and exit.
+
+
Environment
PGDATA
+ Data directory; see also the -p option.
+
PG_COLOR
+ Specifies whether to use color in diagnostic messages. Possible values
+ are always, auto and
+ never.
+
Notes
+ Can give wrong results when the server is running.
+
+ Only the specified timeline is displayed (or the default, if none is
+ specified). Records in other timelines are ignored.
+
+ pg_waldump cannot read WAL files with suffix
+ .partial. If those files need to be read, .partial
+ suffix needs to be removed from the file name.
+
F.37. pg_walinspect — low-level WAL inspection #
+ The pg_walinspect module provides SQL functions that
+ allow you to inspect the contents of write-ahead log of
+ a running PostgreSQL database cluster at a low
+ level, which is useful for debugging, analytical, reporting or
+ educational purposes. It is similar to pg_waldump, but
+ accessible through SQL rather than a separate utility.
+
+ All the functions of this module will provide the WAL information using the
+ server's current timeline ID.
+
Note
+ The pg_walinspect functions are often called
+ using an LSN argument that specifies the location at which a known
+ WAL record of interest begins. However, some
+ functions, such as
+ pg_logical_emit_message,
+ return the LSN after the record that was just
+ inserted.
+
Tip
+ All of the pg_walinspect functions that show
+ information about records that fall within a certain LSN range are
+ permissive about accepting end_lsn
+ arguments that are after the server's current LSN. Using an
+ end_lsn “from the future”
+ will not raise an error.
+
+ It may be convenient to provide the value
+ FFFFFFFF/FFFFFFFF (the maximum valid
+ pg_lsn value) as an end_lsn
+ argument. This is equivalent to providing an
+ end_lsn argument matching the server's
+ current LSN.
+
+ By default, use of these functions is restricted to superusers and members of
+ the pg_read_server_files role. Access may be granted by
+ superusers to others using GRANT.
+
F.37.1. General Functions #
-
+
pg_get_wal_record_info(in_lsn pg_lsn) returns record
+ #
+ Gets WAL record information about a record that is located at or
+ after the in_lsn argument. For
+ example:
+
+postgres=# SELECT * FROM pg_get_wal_record_info('0/E419E28');
+-[ RECORD 1 ]----+-------------------------------------------------
+start_lsn | 0/E419E28
+end_lsn | 0/E419E68
+prev_lsn | 0/E419D78
+xid | 0
+resource_manager | Heap2
+record_type | VACUUM
+record_length | 58
+main_data_length | 2
+fpi_length | 0
+description | nunused: 5, unused: [1, 2, 3, 4, 5]
+block_ref | blkref #0: rel 1663/16385/1249 fork main blk 364
+
+
+ If in_lsn isn't at the start of a WAL
+ record, information about the next valid WAL record is shown
+ instead. If there is no next valid WAL record, the function
+ raises an error.
+
-
+
+ pg_get_wal_records_info(start_lsn pg_lsn, end_lsn pg_lsn)
+ returns setof record
+
+ #
+ Gets information of all the valid WAL records between
+ start_lsn and end_lsn.
+ Returns one row per WAL record. For example:
+
+postgres=# SELECT * FROM pg_get_wal_records_info('0/1E913618', '0/1E913740') LIMIT 1;
+-[ RECORD 1 ]----+--------------------------------------------------------------
+start_lsn | 0/1E913618
+end_lsn | 0/1E913650
+prev_lsn | 0/1E9135A0
+xid | 0
+resource_manager | Standby
+record_type | RUNNING_XACTS
+record_length | 50
+main_data_length | 24
+fpi_length | 0
+description | nextXid 33775 latestCompletedXid 33774 oldestRunningXid 33775
+block_ref |
+
+
+ The function raises an error if
+ start_lsn is not available.
+
-
+
pg_get_wal_block_info(start_lsn pg_lsn, end_lsn pg_lsn, show_data boolean DEFAULT true) returns setof record
+ #
+ Gets information about each block reference from all the valid
+ WAL records between start_lsn and
+ end_lsn with one or more block
+ references. Returns one row per block reference per WAL record.
+ For example:
+
+postgres=# SELECT * FROM pg_get_wal_block_info('0/1230278', '0/12302B8');
+-[ RECORD 1 ]-----+-----------------------------------
+start_lsn | 0/1230278
+end_lsn | 0/12302B8
+prev_lsn | 0/122FD40
+block_id | 0
+reltablespace | 1663
+reldatabase | 1
+relfilenode | 2658
+relforknumber | 0
+relblocknumber | 11
+xid | 341
+resource_manager | Btree
+record_type | INSERT_LEAF
+record_length | 64
+main_data_length | 2
+block_data_length | 16
+block_fpi_length | 0
+block_fpi_info |
+description | off: 46
+block_data | \x00002a00070010402630000070696400
+block_fpi_data |
+
+
+ This example involves a WAL record that only contains one block
+ reference, but many WAL records contain several block
+ references. Rows output by
+ pg_get_wal_block_info are guaranteed to
+ have a unique combination of
+ start_lsn and
+ block_id values.
+
+ Much of the information shown here matches the output that
+ pg_get_wal_records_info would show, given
+ the same arguments. However,
+ pg_get_wal_block_info unnests the
+ information from each WAL record into an expanded form by
+ outputting one row per block reference, so certain details are
+ tracked at the block reference level rather than at the
+ whole-record level. This structure is useful with queries that
+ track how individual blocks changed over time. Note that
+ records with no block references (e.g.,
+ COMMIT WAL records) will have no rows
+ returned, so pg_get_wal_block_info may
+ actually return fewer rows than
+ pg_get_wal_records_info.
+
+ The reltablespace,
+ reldatabase, and
+ relfilenode parameters reference
+ pg_tablespace.oid,
+ pg_database.oid, and
+ pg_class.relfilenode
+ respectively. The relforknumber
+ field is the fork number within the relation for the block
+ reference; see common/relpath.h for
+ details.
+
Tip
+ The pg_filenode_relation function (see
+ Table 9.97) can help you to
+ determine which relation was modified during original execution.
+
+ It is possible for clients to avoid the overhead of
+ materializing block data. This may make function execution
+ significantly faster. When show_data
+ is set to false, block_data
+ and block_fpi_data values are omitted
+ (that is, the block_data and
+ block_fpi_data OUT
+ arguments are NULL for all rows returned).
+ Obviously, this optimization is only feasible with queries where
+ block data isn't truly required.
+
+ The function raises an error if
+ start_lsn is not available.
+
-
+
+ pg_get_wal_stats(start_lsn pg_lsn, end_lsn pg_lsn, per_record boolean DEFAULT false)
+ returns setof record
+
+ #
+ Gets statistics of all the valid WAL records between
+ start_lsn and
+ end_lsn. By default, it returns one row per
+ resource_manager type. When
+ per_record is set to true,
+ it returns one row per record_type.
+ For example:
+
+postgres=# SELECT * FROM pg_get_wal_stats('0/1E847D00', '0/1E84F500')
+ WHERE count > 0 AND
+ "resource_manager/record_type" = 'Transaction'
+ LIMIT 1;
+-[ RECORD 1 ]----------------+-------------------
+resource_manager/record_type | Transaction
+count | 2
+count_percentage | 8
+record_size | 875
+record_size_percentage | 41.23468426013195
+fpi_size | 0
+fpi_size_percentage | 0
+combined_size | 875
+combined_size_percentage | 2.8634072910530795
+
+
+ The function raises an error if
+ start_lsn is not available.
+
O.3. pg_xlogdump renamed to pg_waldump #
+ PostgreSQL 9.6 and below provided a command named
+ pg_xlogdump
+
+ to read write-ahead-log (WAL) files. This command was renamed to pg_waldump, see
+ pg_waldump for documentation of pg_waldump and see
+ the release notes for PostgreSQL 10 for details
+ on this change.
+
52.5. Planner/Optimizer #
+ The task of the planner/optimizer is to
+ create an optimal execution plan. A given SQL query (and hence, a
+ query tree) can be actually executed in a wide variety of
+ different ways, each of which will produce the same set of
+ results. If it is computationally feasible, the query optimizer
+ will examine each of these possible execution plans, ultimately
+ selecting the execution plan that is expected to run the fastest.
+
Note
+ In some situations, examining each possible way in which a query
+ can be executed would take an excessive amount of time and memory.
+ In particular, this occurs when executing queries
+ involving large numbers of join operations. In order to determine
+ a reasonable (not necessarily optimal) query plan in a reasonable amount
+ of time, PostgreSQL uses a Genetic
+ Query Optimizer (see Chapter 62) when the number of joins
+ exceeds a threshold (see geqo_threshold).
+
+ The planner's search procedure actually works with data structures
+ called paths, which are simply cut-down representations of
+ plans containing only as much information as the planner needs to make
+ its decisions. After the cheapest path is determined, a full-fledged
+ plan tree is built to pass to the executor. This represents
+ the desired execution plan in sufficient detail for the executor to run it.
+ In the rest of this section we'll ignore the distinction between paths
+ and plans.
+
52.5.1. Generating Possible Plans #
+ The planner/optimizer starts by generating plans for scanning each
+ individual relation (table) used in the query. The possible plans
+ are determined by the available indexes on each relation.
+ There is always the possibility of performing a
+ sequential scan on a relation, so a sequential scan plan is always
+ created. Assume an index is defined on a
+ relation (for example a B-tree index) and a query contains the
+ restriction
+ relation.attribute OPR constant. If
+ relation.attribute happens to match the key of the B-tree
+ index and OPR is one of the operators listed in
+ the index's operator class, another plan is created using
+ the B-tree index to scan the relation. If there are further indexes
+ present and the restrictions in the query happen to match a key of an
+ index, further plans will be considered. Index scan plans are also
+ generated for indexes that have a sort ordering that can match the
+ query's ORDER BY clause (if any), or a sort ordering that
+ might be useful for merge joining (see below).
+
+ If the query requires joining two or more relations,
+ plans for joining relations are considered
+ after all feasible plans have been found for scanning single relations.
+ The three available join strategies are:
+
+
+ nested loop join: The right relation is scanned
+ once for every row found in the left relation. This strategy
+ is easy to implement but can be very time consuming. (However,
+ if the right relation can be scanned with an index scan, this can
+ be a good strategy. It is possible to use values from the current
+ row of the left relation as keys for the index scan of the right.)
+
+ merge join: Each relation is sorted on the join
+ attributes before the join starts. Then the two relations are
+ scanned in parallel, and matching rows are combined to form
+ join rows. This kind of join is
+ attractive because each relation has to be scanned only once.
+ The required sorting might be achieved either by an explicit sort
+ step, or by scanning the relation in the proper order using an
+ index on the join key.
+
+ hash join: the right relation is first scanned
+ and loaded into a hash table, using its join attributes as hash keys.
+ Next the left relation is scanned and the
+ appropriate values of every row found are used as hash keys to
+ locate the matching rows in the table.
+
+
+ When the query involves more than two relations, the final result
+ must be built up by a tree of join steps, each with two inputs.
+ The planner examines different possible join sequences to find the
+ cheapest one.
+
+ If the query uses fewer than geqo_threshold
+ relations, a near-exhaustive search is conducted to find the best
+ join sequence. The planner preferentially considers joins between any
+ two relations for which there exists a corresponding join clause in the
+ WHERE qualification (i.e., for
+ which a restriction like where rel1.attr1=rel2.attr2
+ exists). Join pairs with no join clause are considered only when there
+ is no other choice, that is, a particular relation has no available
+ join clauses to any other relation. All possible plans are generated for
+ every join pair considered by the planner, and the one that is
+ (estimated to be) the cheapest is chosen.
+
+ When geqo_threshold is exceeded, the join
+ sequences considered are determined by heuristics, as described
+ in Chapter 62. Otherwise the process is the same.
+
+ The finished plan tree consists of sequential or index scans of
+ the base relations, plus nested-loop, merge, or hash join nodes as
+ needed, plus any auxiliary steps needed, such as sort nodes or
+ aggregate-function calculation nodes. Most of these plan node
+ types have the additional ability to do selection
+ (discarding rows that do not meet a specified Boolean condition)
+ and projection (computation of a derived column set
+ based on given column values, that is, evaluation of scalar
+ expressions where needed). One of the responsibilities of the
+ planner is to attach selection conditions from the
+ WHERE clause and computation of required
+ output expressions to the most appropriate nodes of the plan
+ tree.
+
Chapter 76. How the Planner Uses Statistics
+ This chapter builds on the material covered in Section 14.1 and Section 14.2 to show some
+ additional details about how the planner uses the
+ system statistics to estimate the number of rows each part of a query might
+ return. This is a significant part of the planning process,
+ providing much of the raw material for cost calculation.
+
+ The intent of this chapter is not to document the code in detail,
+ but to present an overview of how it works.
+ This will perhaps ease the learning curve for someone who subsequently
+ wishes to read the code.
+
76.3. Planner Statistics and Security #
+ Access to the table pg_statistic is restricted to
+ superusers, so that ordinary users cannot learn about the contents of the
+ tables of other users from it. Some selectivity estimation functions will
+ use a user-provided operator (either the operator appearing in the query or
+ a related operator) to analyze the stored statistics. For example, in order
+ to determine whether a stored most common value is applicable, the
+ selectivity estimator will have to run the appropriate =
+ operator to compare the constant in the query to the stored value.
+ Thus the data in pg_statistic is potentially
+ passed to user-defined operators. An appropriately crafted operator can
+ intentionally leak the passed operands (for example, by logging them
+ or writing them to a different table), or accidentally leak them by showing
+ their values in error messages, in either case possibly exposing data from
+ pg_statistic to a user who should not be able to
+ see it.
+
+ In order to prevent this, the following applies to all built-in selectivity
+ estimation functions. When planning a query, in order to be able to use
+ stored statistics, the current user must either
+ have SELECT privilege on the table or the involved
+ columns, or the operator used must be LEAKPROOF (more
+ accurately, the function that the operator is based on). If not, then the
+ selectivity estimator will behave as if no statistics are available, and
+ the planner will proceed with default or fall-back assumptions.
+
+ If a user does not have the required privilege on the table or columns,
+ then in many cases the query will ultimately receive a permission-denied
+ error, in which case this mechanism is invisible in practice. But if the
+ user is reading from a security-barrier view, then the planner might wish
+ to check the statistics of an underlying table that is otherwise
+ inaccessible to the user. In that case, the operator should be leak-proof
+ or the statistics will not be used. There is no direct feedback about
+ that, except that the plan might be suboptimal. If one suspects that this
+ is the case, one could try running the query as a more privileged user,
+ to see if a different plan results.
+
+ This restriction applies only to cases where the planner would need to
+ execute a user-defined operator on one or more values
+ from pg_statistic. Thus the planner is permitted
+ to use generic statistical information, such as the fraction of null values
+ or the number of distinct values in a column, regardless of access
+ privileges.
+
+ Selectivity estimation functions contained in third-party extensions that
+ potentially operate on statistics with user-defined operators should follow
+ the same security rules. Consult the PostgreSQL source code for guidance.
+
14.2. Statistics Used by the Planner #
14.2.1. Single-Column Statistics #
+ As we saw in the previous section, the query planner needs to estimate
+ the number of rows retrieved by a query in order to make good choices
+ of query plans. This section provides a quick look at the statistics
+ that the system uses for these estimates.
+
+ One component of the statistics is the total number of entries in
+ each table and index, as well as the number of disk blocks occupied
+ by each table and index. This information is kept in the table
+ pg_class,
+ in the columns reltuples and
+ relpages. We can look at it with
+ queries similar to this one:
+
+
+SELECT relname, relkind, reltuples, relpages
+FROM pg_class
+WHERE relname LIKE 'tenk1%';
+
+ relname | relkind | reltuples | relpages
+----------------------+---------+-----------+----------
+ tenk1 | r | 10000 | 358
+ tenk1_hundred | i | 10000 | 30
+ tenk1_thous_tenthous | i | 10000 | 30
+ tenk1_unique1 | i | 10000 | 30
+ tenk1_unique2 | i | 10000 | 30
+(5 rows)
+
+
+ Here we can see that tenk1 contains 10000
+ rows, as do its indexes, but the indexes are (unsurprisingly) much
+ smaller than the table.
+
+ For efficiency reasons, reltuples
+ and relpages are not updated on-the-fly,
+ and so they usually contain somewhat out-of-date values.
+ They are updated by VACUUM, ANALYZE, and a
+ few DDL commands such as CREATE INDEX. A VACUUM
+ or ANALYZE operation that does not scan the entire table
+ (which is commonly the case) will incrementally update the
+ reltuples count on the basis of the part
+ of the table it did scan, resulting in an approximate value.
+ In any case, the planner
+ will scale the values it finds in pg_class
+ to match the current physical table size, thus obtaining a closer
+ approximation.
+
+ Most queries retrieve only a fraction of the rows in a table, due
+ to WHERE clauses that restrict the rows to be
+ examined. The planner thus needs to make an estimate of the
+ selectivity of WHERE clauses, that is,
+ the fraction of rows that match each condition in the
+ WHERE clause. The information used for this task is
+ stored in the
+ pg_statistic
+ system catalog. Entries in pg_statistic
+ are updated by the ANALYZE and VACUUM
+ ANALYZE commands, and are always approximate even when freshly
+ updated.
+
+ Rather than look at pg_statistic directly,
+ it's better to look at its view
+ pg_stats
+ when examining the statistics manually. pg_stats
+ is designed to be more easily readable. Furthermore,
+ pg_stats is readable by all, whereas
+ pg_statistic is only readable by a superuser.
+ (This prevents unprivileged users from learning something about
+ the contents of other people's tables from the statistics. The
+ pg_stats view is restricted to show only
+ rows about tables that the current user can read.)
+ For example, we might do:
+
+
+SELECT attname, inherited, n_distinct,
+ array_to_string(most_common_vals, E'\n') as most_common_vals
+FROM pg_stats
+WHERE tablename = 'road';
+
+ attname | inherited | n_distinct | most_common_vals
+---------+-----------+------------+------------------------------------
+ name | f | -0.363388 | I- 580 Ramp+
+ | | | I- 880 Ramp+
+ | | | Sp Railroad +
+ | | | I- 580 +
+ | | | I- 680 Ramp
+ name | t | -0.284859 | I- 880 Ramp+
+ | | | I- 580 Ramp+
+ | | | I- 680 Ramp+
+ | | | I- 580 +
+ | | | State Hwy 13 Ramp
+(2 rows)
+
+
+ Note that two rows are displayed for the same column, one corresponding
+ to the complete inheritance hierarchy starting at the
+ road table (inherited=t),
+ and another one including only the road table itself
+ (inherited=f).
+
+ The amount of information stored in pg_statistic
+ by ANALYZE, in particular the maximum number of entries in the
+ most_common_vals and histogram_bounds
+ arrays for each column, can be set on a
+ column-by-column basis using the ALTER TABLE SET STATISTICS
+ command, or globally by setting the
+ default_statistics_target configuration variable.
+ The default limit is presently 100 entries. Raising the limit
+ might allow more accurate planner estimates to be made, particularly for
+ columns with irregular data distributions, at the price of consuming
+ more space in pg_statistic and slightly more
+ time to compute the estimates. Conversely, a lower limit might be
+ sufficient for columns with simple data distributions.
+
+ Further details about the planner's use of statistics can be found in
+ Chapter 76.
+
14.2.2. Extended Statistics #
+ It is common to see slow queries running bad execution plans because
+ multiple columns used in the query clauses are correlated.
+ The planner normally assumes that multiple conditions
+ are independent of each other,
+ an assumption that does not hold when column values are correlated.
+ Regular statistics, because of their per-individual-column nature,
+ cannot capture any knowledge about cross-column correlation.
+ However, PostgreSQL has the ability to compute
+ multivariate statistics, which can capture
+ such information.
+
+ Because the number of possible column combinations is very large,
+ it's impractical to compute multivariate statistics automatically.
+ Instead, extended statistics objects, more often
+ called just statistics objects, can be created to instruct
+ the server to obtain statistics across interesting sets of columns.
+
+ Statistics objects are created using the
+ CREATE STATISTICS command.
+ Creation of such an object merely creates a catalog entry expressing
+ interest in the statistics. Actual data collection is performed
+ by ANALYZE (either a manual command, or background
+ auto-analyze). The collected values can be examined in the
+ pg_statistic_ext_data
+ catalog.
+
+ ANALYZE computes extended statistics based on the same
+ sample of table rows that it takes for computing regular single-column
+ statistics. Since the sample size is increased by increasing the
+ statistics target for the table or any of its columns (as described in
+ the previous section), a larger statistics target will normally result in
+ more accurate extended statistics, as well as more time spent calculating
+ them.
+
+ The following subsections describe the kinds of extended statistics
+ that are currently supported.
+
14.2.2.1. Functional Dependencies #
+ The simplest kind of extended statistics tracks functional
+ dependencies, a concept used in definitions of database normal forms.
+ We say that column b is functionally dependent on
+ column a if knowledge of the value of
+ a is sufficient to determine the value
+ of b, that is there are no two rows having the same value
+ of a but different values of b.
+ In a fully normalized database, functional dependencies should exist
+ only on primary keys and superkeys. However, in practice many data sets
+ are not fully normalized for various reasons; intentional
+ denormalization for performance reasons is a common example.
+ Even in a fully normalized database, there may be partial correlation
+ between some columns, which can be expressed as partial functional
+ dependency.
+
+ The existence of functional dependencies directly affects the accuracy
+ of estimates in certain queries. If a query contains conditions on
+ both the independent and the dependent column(s), the
+ conditions on the dependent columns do not further reduce the result
+ size; but without knowledge of the functional dependency, the query
+ planner will assume that the conditions are independent, resulting
+ in underestimating the result size.
+
+ To inform the planner about functional dependencies, ANALYZE
+ can collect measurements of cross-column dependency. Assessing the
+ degree of dependency between all sets of columns would be prohibitively
+ expensive, so data collection is limited to those groups of columns
+ appearing together in a statistics object defined with
+ the dependencies option. It is advisable to create
+ dependencies statistics only for column groups that are
+ strongly correlated, to avoid unnecessary overhead in both
+ ANALYZE and later query planning.
+
+ Here is an example of collecting functional-dependency statistics:
+
+CREATE STATISTICS stts (dependencies) ON city, zip FROM zipcodes;
+
+ANALYZE zipcodes;
+
+SELECT stxname, stxkeys, stxddependencies
+ FROM pg_statistic_ext join pg_statistic_ext_data on (oid = stxoid)
+ WHERE stxname = 'stts';
+ stxname | stxkeys | stxddependencies
+---------+---------+------------------------------------------
+ stts | 1 5 | {"1 => 5": 1.000000, "5 => 1": 0.423130}
+(1 row)
+
+ Here it can be seen that column 1 (zip code) fully determines column
+ 5 (city) so the coefficient is 1.0, while city only determines zip code
+ about 42% of the time, meaning that there are many cities (58%) that are
+ represented by more than a single ZIP code.
+
+ When computing the selectivity for a query involving functionally
+ dependent columns, the planner adjusts the per-condition selectivity
+ estimates using the dependency coefficients so as not to produce
+ an underestimate.
+
14.2.2.1.1. Limitations of Functional Dependencies #
+ Functional dependencies are currently only applied when considering
+ simple equality conditions that compare columns to constant values,
+ and IN clauses with constant values.
+ They are not used to improve estimates for equality conditions
+ comparing two columns or comparing a column to an expression, nor for
+ range clauses, LIKE or any other type of condition.
+
+ When estimating with functional dependencies, the planner assumes that
+ conditions on the involved columns are compatible and hence redundant.
+ If they are incompatible, the correct estimate would be zero rows, but
+ that possibility is not considered. For example, given a query like
+
+SELECT * FROM zipcodes WHERE city = 'San Francisco' AND zip = '94105';
+
+ the planner will disregard the city clause as not
+ changing the selectivity, which is correct. However, it will make
+ the same assumption about
+
+SELECT * FROM zipcodes WHERE city = 'San Francisco' AND zip = '90210';
+
+ even though there will really be zero rows satisfying this query.
+ Functional dependency statistics do not provide enough information
+ to conclude that, however.
+
+ In many practical situations, this assumption is usually satisfied;
+ for example, there might be a GUI in the application that only allows
+ selecting compatible city and ZIP code values to use in a query.
+ But if that's not the case, functional dependencies may not be a viable
+ option.
+
14.2.2.2. Multivariate N-Distinct Counts #
+ Single-column statistics store the number of distinct values in each
+ column. Estimates of the number of distinct values when combining more
+ than one column (for example, for GROUP BY a, b) are
+ frequently wrong when the planner only has single-column statistical
+ data, causing it to select bad plans.
+
+ To improve such estimates, ANALYZE can collect n-distinct
+ statistics for groups of columns. As before, it's impractical to do
+ this for every possible column grouping, so data is collected only for
+ those groups of columns appearing together in a statistics object
+ defined with the ndistinct option. Data will be collected
+ for each possible combination of two or more columns from the set of
+ listed columns.
+
+ Continuing the previous example, the n-distinct counts in a
+ table of ZIP codes might look like the following:
+
+CREATE STATISTICS stts2 (ndistinct) ON city, state, zip FROM zipcodes;
+
+ANALYZE zipcodes;
+
+SELECT stxkeys AS k, stxdndistinct AS nd
+ FROM pg_statistic_ext join pg_statistic_ext_data on (oid = stxoid)
+ WHERE stxname = 'stts2';
+-[ RECORD 1 ]--------------------------------------------------------
+k | 1 2 5
+nd | {"1, 2": 33178, "1, 5": 33178, "2, 5": 27435, "1, 2, 5": 33178}
+(1 row)
+
+ This indicates that there are three combinations of columns that
+ have 33178 distinct values: ZIP code and state; ZIP code and city;
+ and ZIP code, city and state (the fact that they are all equal is
+ expected given that ZIP code alone is unique in this table). On the
+ other hand, the combination of city and state has only 27435 distinct
+ values.
+
+ It's advisable to create ndistinct statistics objects only
+ on combinations of columns that are actually used for grouping, and
+ for which misestimation of the number of groups is resulting in bad
+ plans. Otherwise, the ANALYZE cycles are just wasted.
+
14.2.2.3. Multivariate MCV Lists #
+ Another type of statistic stored for each column are most-common value
+ lists. This allows very accurate estimates for individual columns, but
+ may result in significant misestimates for queries with conditions on
+ multiple columns.
+
+ To improve such estimates, ANALYZE can collect MCV
+ lists on combinations of columns. Similarly to functional dependencies
+ and n-distinct coefficients, it's impractical to do this for every
+ possible column grouping. Even more so in this case, as the MCV list
+ (unlike functional dependencies and n-distinct coefficients) does store
+ the common column values. So data is collected only for those groups
+ of columns appearing together in a statistics object defined with the
+ mcv option.
+
+ Continuing the previous example, the MCV list for a table of ZIP codes
+ might look like the following (unlike for simpler types of statistics,
+ a function is required for inspection of MCV contents):
+
+
+CREATE STATISTICS stts3 (mcv) ON city, state FROM zipcodes;
+
+ANALYZE zipcodes;
+
+SELECT m.* FROM pg_statistic_ext join pg_statistic_ext_data on (oid = stxoid),
+ pg_mcv_list_items(stxdmcv) m WHERE stxname = 'stts3';
+
+ index | values | nulls | frequency | base_frequency
+-------+------------------------+-------+-----------+----------------
+ 0 | {Washington, DC} | {f,f} | 0.003467 | 2.7e-05
+ 1 | {Apo, AE} | {f,f} | 0.003067 | 1.9e-05
+ 2 | {Houston, TX} | {f,f} | 0.002167 | 0.000133
+ 3 | {El Paso, TX} | {f,f} | 0.002 | 0.000113
+ 4 | {New York, NY} | {f,f} | 0.001967 | 0.000114
+ 5 | {Atlanta, GA} | {f,f} | 0.001633 | 3.3e-05
+ 6 | {Sacramento, CA} | {f,f} | 0.001433 | 7.8e-05
+ 7 | {Miami, FL} | {f,f} | 0.0014 | 6e-05
+ 8 | {Dallas, TX} | {f,f} | 0.001367 | 8.8e-05
+ 9 | {Chicago, IL} | {f,f} | 0.001333 | 5.1e-05
+ ...
+(99 rows)
+
+ This indicates that the most common combination of city and state is
+ Washington in DC, with actual frequency (in the sample) about 0.35%.
+ The base frequency of the combination (as computed from the simple
+ per-column frequencies) is only 0.0027%, resulting in two orders of
+ magnitude under-estimates.
+
+ It's advisable to create MCV statistics objects only
+ on combinations of columns that are actually used in conditions together,
+ and for which misestimation of the number of groups is resulting in bad
+ plans. Otherwise, the ANALYZE and planning cycles
+ are just wasted.
+
Chapter 58. Writing a Procedural Language Handler
+ All calls to functions that are written in a language other than
+ the current “version 1” interface for compiled
+ languages (this includes functions in user-defined procedural languages
+ and functions written in SQL) go through a call handler
+ function for the specific language. It is the responsibility of
+ the call handler to execute the function in a meaningful way, such
+ as by interpreting the supplied source text. This chapter outlines
+ how a new procedural language's call handler can be written.
+
+ The call handler for a procedural language is a
+ “normal” function that must be written in a compiled
+ language such as C, using the version-1 interface, and registered
+ with PostgreSQL as taking no arguments
+ and returning the type language_handler. This
+ special pseudo-type identifies the function as a call handler and
+ prevents it from being called directly in SQL commands.
+ For more details on C language calling conventions and dynamic loading,
+ see Section 38.10.
+
+ The call handler is called in the same way as any other function:
+ It receives a pointer to a
+ FunctionCallInfoBaseData struct containing
+ argument values and information about the called function, and it
+ is expected to return a Datum result (and possibly
+ set the isnull field of the
+ FunctionCallInfoBaseData structure, if it wishes
+ to return an SQL null result). The difference between a call
+ handler and an ordinary callee function is that the
+ flinfo->fn_oid field of the
+ FunctionCallInfoBaseData structure will contain
+ the OID of the actual function to be called, not of the call
+ handler itself. The call handler must use this field to determine
+ which function to execute. Also, the passed argument list has
+ been set up according to the declaration of the target function,
+ not of the call handler.
+
+ It's up to the call handler to fetch the entry of the function from the
+ pg_proc system catalog and to analyze the argument
+ and return types of the called function. The AS clause from the
+ CREATE FUNCTION command for the function will be found
+ in the prosrc column of the
+ pg_proc row. This is commonly source
+ text in the procedural language, but in theory it could be something else,
+ such as a path name to a file, or anything else that tells the call handler
+ what to do in detail.
+
+ Often, the same function is called many times per SQL statement.
+ A call handler can avoid repeated lookups of information about the
+ called function by using the
+ flinfo->fn_extra field. This will
+ initially be NULL, but can be set by the call handler to point at
+ information about the called function. On subsequent calls, if
+ flinfo->fn_extra is already non-NULL
+ then it can be used and the information lookup step skipped. The
+ call handler must make sure that
+ flinfo->fn_extra is made to point at
+ memory that will live at least until the end of the current query,
+ since an FmgrInfo data structure could be
+ kept that long. One way to do this is to allocate the extra data
+ in the memory context specified by
+ flinfo->fn_mcxt; such data will
+ normally have the same lifespan as the
+ FmgrInfo itself. But the handler could
+ also choose to use a longer-lived memory context so that it can cache
+ function definition information across queries.
+
+ When a procedural-language function is invoked as a trigger, no arguments
+ are passed in the usual way, but the
+ FunctionCallInfoBaseData's
+ context field points at a
+ TriggerData structure, rather than being NULL
+ as it is in a plain function call. A language handler should
+ provide mechanisms for procedural-language functions to get at the trigger
+ information.
+
+ A template for a procedural-language handler written as a C extension is
+ provided in src/test/modules/plsample. This is a
+ working sample demonstrating one way to create a procedural-language
+ handler, process parameters, and return a value.
+
+ Although providing a call handler is sufficient to create a minimal
+ procedural language, there are two other functions that can optionally
+ be provided to make the language more convenient to use. These
+ are a validator and an
+ inline handler. A validator can be provided
+ to allow language-specific checking to be done during
+ CREATE FUNCTION.
+ An inline handler can be provided to allow the language to support
+ anonymous code blocks executed via the DO command.
+
+ If a validator is provided by a procedural language, it
+ must be declared as a function taking a single parameter of type
+ oid. The validator's result is ignored, so it is customarily
+ declared to return void. The validator will be called at
+ the end of a CREATE FUNCTION command that has created
+ or updated a function written in the procedural language.
+ The passed-in OID is the OID of the function's pg_proc
+ row. The validator must fetch this row in the usual way, and do
+ whatever checking is appropriate.
+ First, call CheckFunctionValidatorAccess() to diagnose
+ explicit calls to the validator that the user could not achieve through
+ CREATE FUNCTION. Typical checks then include verifying
+ that the function's argument and result types are supported by the
+ language, and that the function's body is syntactically correct
+ in the language. If the validator finds the function to be okay,
+ it should just return. If it finds an error, it should report that
+ via the normal ereport() error reporting mechanism.
+ Throwing an error will force a transaction rollback and thus prevent
+ the incorrect function definition from being committed.
+
+ Validator functions should typically honor the check_function_bodies parameter: if it is turned off then
+ any expensive or context-sensitive checking should be skipped. If the
+ language provides for code execution at compilation time, the validator
+ must suppress checks that would induce such execution. In particular,
+ this parameter is turned off by pg_dump so that it can
+ load procedural language functions without worrying about side effects or
+ dependencies of the function bodies on other database objects.
+ (Because of this requirement, the call handler should avoid
+ assuming that the validator has fully checked the function. The point
+ of having a validator is not to let the call handler omit checks, but
+ to notify the user immediately if there are obvious errors in a
+ CREATE FUNCTION command.)
+ While the choice of exactly what to check is mostly left to the
+ discretion of the validator function, note that the core
+ CREATE FUNCTION code only executes SET clauses
+ attached to a function when check_function_bodies is on.
+ Therefore, checks whose results might be affected by GUC parameters
+ definitely should be skipped when check_function_bodies is
+ off, to avoid false failures when restoring a dump.
+
+ If an inline handler is provided by a procedural language, it
+ must be declared as a function taking a single parameter of type
+ internal. The inline handler's result is ignored, so it is
+ customarily declared to return void. The inline handler
+ will be called when a DO statement is executed specifying
+ the procedural language. The parameter actually passed is a pointer
+ to an InlineCodeBlock struct, which contains information
+ about the DO statement's parameters, in particular the
+ text of the anonymous code block to be executed. The inline handler
+ should execute this code and return.
+
+ It's recommended that you wrap all these function declarations,
+ as well as the CREATE LANGUAGE command itself, into
+ an extension so that a simple CREATE EXTENSION
+ command is sufficient to install the language. See
+ Section 38.17 for information about writing
+ extensions.
+
+ The procedural languages included in the standard distribution
+ are good references when trying to write your own language handler.
+ Look into the src/pl subdirectory of the source tree.
+ The CREATE LANGUAGE
+ reference page also has some useful details.
+
45.3. Built-in Functions #
45.3.1. Database Access from PL/Perl #
+ Access to the database itself from your Perl function can be done
+ via the following functions:
+
-
+
spi_exec_query(query [, limit])
+ spi_exec_query executes an SQL command and
+returns the entire row set as a reference to an array of hash references.
+If limit is specified and is greater than zero,
+then spi_exec_query retrieves at
+most limit rows, much as if the query included
+a LIMIT clause. Omitting limit
+or specifying it as zero results in no row limit.
+
+You should only use this command when you know
+that the result set will be relatively small. Here is an
+example of a query (SELECT command) with the
+optional maximum number of rows:
+
+
+$rv = spi_exec_query('SELECT * FROM my_table', 5);
+
+ This returns up to 5 rows from the table
+ my_table. If my_table
+ has a column my_column, you can get that
+ value from row $i of the result like this:
+
+$foo = $rv->{rows}[$i]->{my_column};
+
+ The total number of rows returned from a SELECT
+ query can be accessed like this:
+
+$nrows = $rv->{processed}
+
+
+ Here is an example using a different command type:
+
+$query = "INSERT INTO my_table VALUES (1, 'test')";
+$rv = spi_exec_query($query);
+
+ You can then access the command status (e.g.,
+ SPI_OK_INSERT) like this:
+
+$res = $rv->{status};
+
+ To get the number of rows affected, do:
+
+$nrows = $rv->{processed};
+
+
+ Here is a complete example:
+
+CREATE TABLE test (
+ i int,
+ v varchar
+);
+
+INSERT INTO test (i, v) VALUES (1, 'first line');
+INSERT INTO test (i, v) VALUES (2, 'second line');
+INSERT INTO test (i, v) VALUES (3, 'third line');
+INSERT INTO test (i, v) VALUES (4, 'immortal');
+
+CREATE OR REPLACE FUNCTION test_munge() RETURNS SETOF test AS $$
+ my $rv = spi_exec_query('select i, v from test;');
+ my $status = $rv->{status};
+ my $nrows = $rv->{processed};
+ foreach my $rn (0 .. $nrows - 1) {
+ my $row = $rv->{rows}[$rn];
+ $row->{i} += 200 if defined($row->{i});
+ $row->{v} =~ tr/A-Za-z/a-zA-Z/ if (defined($row->{v}));
+ return_next($row);
+ }
+ return undef;
+$$ LANGUAGE plperl;
+
+SELECT * FROM test_munge();
+
+
-
+
spi_query(command)
+ spi_fetchrow(cursor)
+ spi_cursor_close(cursor)
+ spi_query and spi_fetchrow
+ work together as a pair for row sets which might be large, or for cases
+ where you wish to return rows as they arrive.
+ spi_fetchrow works only with
+ spi_query. The following example illustrates how
+ you use them together:
+
+
+CREATE TYPE foo_type AS (the_num INTEGER, the_text TEXT);
+
+CREATE OR REPLACE FUNCTION lotsa_md5 (INTEGER) RETURNS SETOF foo_type AS $$
+ use Digest::MD5 qw(md5_hex);
+ my $file = '/usr/share/dict/words';
+ my $t = localtime;
+ elog(NOTICE, "opening file $file at $t" );
+ open my $fh, '<', $file # ooh, it's a file access!
+ or elog(ERROR, "cannot open $file for reading: $!");
+ my @words = <$fh>;
+ close $fh;
+ $t = localtime;
+ elog(NOTICE, "closed file $file at $t");
+ chomp(@words);
+ my $row;
+ my $sth = spi_query("SELECT * FROM generate_series(1,$_[0]) AS b(a)");
+ while (defined ($row = spi_fetchrow($sth))) {
+ return_next({
+ the_num => $row->{a},
+ the_text => md5_hex($words[rand @words])
+ });
+ }
+ return;
+$$ LANGUAGE plperlu;
+
+SELECT * from lotsa_md5(500);
+
+
+ Normally, spi_fetchrow should be repeated until it
+ returns undef, indicating that there are no more
+ rows to read. The cursor returned by spi_query
+ is automatically freed when
+ spi_fetchrow returns undef.
+ If you do not wish to read all the rows, instead call
+ spi_cursor_close to free the cursor.
+ Failure to do so will result in memory leaks.
+
-
+
spi_prepare(command, argument types)
+ spi_query_prepared(plan, arguments)
+ spi_exec_prepared(plan [, attributes], arguments)
+ spi_freeplan(plan)
+ spi_prepare, spi_query_prepared, spi_exec_prepared,
+ and spi_freeplan implement the same functionality but for prepared queries.
+ spi_prepare accepts a query string with numbered argument placeholders ($1, $2, etc.)
+ and a string list of argument types:
+
+$plan = spi_prepare('SELECT * FROM test WHERE id > $1 AND name = $2',
+ 'INTEGER', 'TEXT');
+
+ Once a query plan is prepared by a call to spi_prepare, the plan can be used instead
+ of the string query, either in spi_exec_prepared, where the result is the same as returned
+ by spi_exec_query, or in spi_query_prepared which returns a cursor
+ exactly as spi_query does, which can be later passed to spi_fetchrow.
+ The optional second parameter to spi_exec_prepared is a hash reference of attributes;
+ the only attribute currently supported is limit, which
+ sets the maximum number of rows returned from the query.
+ Omitting limit or specifying it as zero results in no
+ row limit.
+
+ The advantage of prepared queries is that is it possible to use one prepared plan for more
+ than one query execution. After the plan is not needed anymore, it can be freed with
+ spi_freeplan:
+
+CREATE OR REPLACE FUNCTION init() RETURNS VOID AS $$
+ $_SHARED{my_plan} = spi_prepare('SELECT (now() + $1)::date AS now',
+ 'INTERVAL');
+$$ LANGUAGE plperl;
+
+CREATE OR REPLACE FUNCTION add_time( INTERVAL ) RETURNS TEXT AS $$
+ return spi_exec_prepared(
+ $_SHARED{my_plan},
+ $_[0]
+ )->{rows}->[0]->{now};
+$$ LANGUAGE plperl;
+
+CREATE OR REPLACE FUNCTION done() RETURNS VOID AS $$
+ spi_freeplan( $_SHARED{my_plan});
+ undef $_SHARED{my_plan};
+$$ LANGUAGE plperl;
+
+SELECT init();
+SELECT add_time('1 day'), add_time('2 days'), add_time('3 days');
+SELECT done();
+
+ add_time | add_time | add_time
+------------+------------+------------
+ 2005-12-10 | 2005-12-11 | 2005-12-12
+
+ Note that the parameter subscript in spi_prepare is defined via
+ $1, $2, $3, etc., so avoid declaring query strings in double quotes that might easily
+ lead to hard-to-catch bugs.
+
+ Another example illustrates usage of an optional parameter in spi_exec_prepared:
+
+CREATE TABLE hosts AS SELECT id, ('192.168.1.'||id)::inet AS address
+ FROM generate_series(1,3) AS id;
+
+CREATE OR REPLACE FUNCTION init_hosts_query() RETURNS VOID AS $$
+ $_SHARED{plan} = spi_prepare('SELECT * FROM hosts
+ WHERE address << $1', 'inet');
+$$ LANGUAGE plperl;
+
+CREATE OR REPLACE FUNCTION query_hosts(inet) RETURNS SETOF hosts AS $$
+ return spi_exec_prepared(
+ $_SHARED{plan},
+ {limit => 2},
+ $_[0]
+ )->{rows};
+$$ LANGUAGE plperl;
+
+CREATE OR REPLACE FUNCTION release_hosts_query() RETURNS VOID AS $$
+ spi_freeplan($_SHARED{plan});
+ undef $_SHARED{plan};
+$$ LANGUAGE plperl;
+
+SELECT init_hosts_query();
+SELECT query_hosts('192.168.1.0/30');
+SELECT release_hosts_query();
+
+ query_hosts
+-----------------
+ (1,192.168.1.1)
+ (2,192.168.1.2)
+(2 rows)
+
+
-
+
spi_commit()
+ spi_rollback()
+ Commit or roll back the current transaction. This can only be called
+ in a procedure or anonymous code block (DO command)
+ called from the top level. (Note that it is not possible to run the
+ SQL commands COMMIT or ROLLBACK
+ via spi_exec_query or similar. It has to be done
+ using these functions.) After a transaction is ended, a new
+ transaction is automatically started, so there is no separate function
+ for that.
+
+ Here is an example:
+
+CREATE PROCEDURE transaction_test1()
+LANGUAGE plperl
+AS $$
+foreach my $i (0..9) {
+ spi_exec_query("INSERT INTO test1 (a) VALUES ($i)");
+ if ($i % 2 == 0) {
+ spi_commit();
+ } else {
+ spi_rollback();
+ }
+}
+$$;
+
+CALL transaction_test1();
+
+
45.3.2. Utility Functions in PL/Perl #
-
+
elog(level, msg)
+ Emit a log or error message. Possible levels are
+ DEBUG, LOG, INFO,
+ NOTICE, WARNING, and ERROR.
+ ERROR
+ raises an error condition; if this is not trapped by the surrounding
+ Perl code, the error propagates out to the calling query, causing
+ the current transaction or subtransaction to be aborted. This
+ is effectively the same as the Perl die command.
+ The other levels only generate messages of different
+ priority levels.
+ Whether messages of a particular priority are reported to the client,
+ written to the server log, or both is controlled by the
+ log_min_messages and
+ client_min_messages configuration
+ variables. See Chapter 20 for more
+ information.
+
-
+
quote_literal(string)
+ Return the given string suitably quoted to be used as a string literal in an SQL
+ statement string. Embedded single-quotes and backslashes are properly doubled.
+ Note that quote_literal returns undef on undef input; if the argument
+ might be undef, quote_nullable is often more suitable.
+
-
+
quote_nullable(string)
+ Return the given string suitably quoted to be used as a string literal in an SQL
+ statement string; or, if the argument is undef, return the unquoted string "NULL".
+ Embedded single-quotes and backslashes are properly doubled.
+
-
+
quote_ident(string)
+ Return the given string suitably quoted to be used as an identifier in
+ an SQL statement string. Quotes are added only if necessary (i.e., if
+ the string contains non-identifier characters or would be case-folded).
+ Embedded quotes are properly doubled.
+
-
+
decode_bytea(string)
+ Return the unescaped binary data represented by the contents of the given string,
+ which should be bytea encoded.
+
-
+
encode_bytea(string)
+ Return the bytea encoded form of the binary data contents of the given string.
+
-
+
encode_array_literal(array)
+ encode_array_literal(array, delimiter)
+ Returns the contents of the referenced array as a string in array literal format
+ (see Section 8.15.2).
+ Returns the argument value unaltered if it's not a reference to an array.
+ The delimiter used between elements of the array literal defaults to ", "
+ if a delimiter is not specified or is undef.
+
-
+
encode_typed_literal(value, typename)
+ Converts a Perl variable to the value of the data type passed as a
+ second argument and returns a string representation of this value.
+ Correctly handles nested arrays and values of composite types.
+
-
+
encode_array_constructor(array)
+ Returns the contents of the referenced array as a string in array constructor format
+ (see Section 4.2.12).
+ Individual values are quoted using quote_nullable.
+ Returns the argument value, quoted using quote_nullable,
+ if it's not a reference to an array.
+
-
+
looks_like_number(string)
+ Returns a true value if the content of the given string looks like a
+ number, according to Perl, returns false otherwise.
+ Returns undef if the argument is undef. Leading and trailing space is
+ ignored. Inf and Infinity are regarded as numbers.
+
-
+
is_array_ref(argument)
+ Returns a true value if the given argument may be treated as an
+ array reference, that is, if ref of the argument is ARRAY or
+ PostgreSQL::InServer::ARRAY. Returns false otherwise.
+
45.2. Data Values in PL/Perl #
+ The argument values supplied to a PL/Perl function's code are
+ simply the input arguments converted to text form (just as if they
+ had been displayed by a SELECT statement).
+ Conversely, the return and return_next
+ commands will accept any string that is acceptable input format
+ for the function's declared return type.
+
+ If this behavior is inconvenient for a particular case, it can be
+ improved by using a transform, as already illustrated
+ for bool values. Several examples of transform modules
+ are included in the PostgreSQL distribution.
+
45.7. PL/Perl Event Triggers #
+ PL/Perl can be used to write event trigger functions. In an event trigger
+ function, the hash reference $_TD contains information
+ about the current trigger event. $_TD is a global variable,
+ which gets a separate local value for each invocation of the trigger. The
+ fields of the $_TD hash reference are:
+
+
$_TD->{event}
+ The name of the event the trigger is fired for.
+
$_TD->{tag}
+ The command tag for which the trigger is fired.
+
+
+ The return value of the trigger function is ignored.
+
+ Here is an example of an event trigger function, illustrating some of the
+ above:
+
+CREATE OR REPLACE FUNCTION perlsnitch() RETURNS event_trigger AS $$
+ elog(NOTICE, "perlsnitch: " . $_TD->{event} . " " . $_TD->{tag} . " ");
+$$ LANGUAGE plperl;
+
+CREATE EVENT TRIGGER perl_a_snitch
+ ON ddl_command_start
+ EXECUTE FUNCTION perlsnitch();
+
+
45.1. PL/Perl Functions and Arguments #
+ To create a function in the PL/Perl language, use the standard
+ CREATE FUNCTION
+ syntax:
+
+
+CREATE FUNCTION funcname (argument-types)
+RETURNS return-type
+-- function attributes can go here
+AS $$
+ # PL/Perl function body goes here
+$$ LANGUAGE plperl;
+
+
+ The body of the function is ordinary Perl code. In fact, the PL/Perl
+ glue code wraps it inside a Perl subroutine. A PL/Perl function is
+ called in a scalar context, so it can't return a list. You can return
+ non-scalar values (arrays, records, and sets) by returning a reference,
+ as discussed below.
+
+ In a PL/Perl procedure, any return value from the Perl code is ignored.
+
+ PL/Perl also supports anonymous code blocks called with the
+ DO statement:
+
+
+DO $$
+ # PL/Perl code
+$$ LANGUAGE plperl;
+
+
+ An anonymous code block receives no arguments, and whatever value it
+ might return is discarded. Otherwise it behaves just like a function.
+
Note
+ The use of named nested subroutines is dangerous in Perl, especially if
+ they refer to lexical variables in the enclosing scope. Because a PL/Perl
+ function is wrapped in a subroutine, any named subroutine you place inside
+ one will be nested. In general, it is far safer to create anonymous
+ subroutines which you call via a coderef. For more information, see the
+ entries for Variable "%s" will not stay shared and
+ Variable "%s" is not available in the
+ perldiag man page, or
+ search the Internet for “perl nested named subroutine”.
+
+ The syntax of the CREATE FUNCTION command requires
+ the function body to be written as a string constant. It is usually
+ most convenient to use dollar quoting (see Section 4.1.2.4) for the string constant.
+ If you choose to use escape string syntax E'',
+ you must double any single quote marks (') and backslashes
+ (\) used in the body of the function
+ (see Section 4.1.2.1).
+
+ Arguments and results are handled as in any other Perl subroutine:
+ arguments are passed in @_, and a result value
+ is returned with return or as the last expression
+ evaluated in the function.
+
+ For example, a function returning the greater of two integer values
+ could be defined as:
+
+
+CREATE FUNCTION perl_max (integer, integer) RETURNS integer AS $$
+ if ($_[0] > $_[1]) { return $_[0]; }
+ return $_[1];
+$$ LANGUAGE plperl;
+
+
Note
+ Arguments will be converted from the database's encoding to UTF-8
+ for use inside PL/Perl, and then converted from UTF-8 back to the
+ database encoding upon return.
+
+ If an SQL null value is passed to a function,
+ the argument value will appear as “undefined” in Perl. The
+ above function definition will not behave very nicely with null
+ inputs (in fact, it will act as though they are zeroes). We could
+ add STRICT to the function definition to make
+ PostgreSQL do something more reasonable:
+ if a null value is passed, the function will not be called at all,
+ but will just return a null result automatically. Alternatively,
+ we could check for undefined inputs in the function body. For
+ example, suppose that we wanted perl_max with
+ one null and one nonnull argument to return the nonnull argument,
+ rather than a null value:
+
+
+CREATE FUNCTION perl_max (integer, integer) RETURNS integer AS $$
+ my ($x, $y) = @_;
+ if (not defined $x) {
+ return undef if not defined $y;
+ return $y;
+ }
+ return $x if not defined $y;
+ return $x if $x > $y;
+ return $y;
+$$ LANGUAGE plperl;
+
+ As shown above, to return an SQL null value from a PL/Perl
+ function, return an undefined value. This can be done whether the
+ function is strict or not.
+
+ Anything in a function argument that is not a reference is
+ a string, which is in the standard PostgreSQL
+ external text representation for the relevant data type. In the case of
+ ordinary numeric or text types, Perl will just do the right thing and
+ the programmer will normally not have to worry about it. However, in
+ other cases the argument will need to be converted into a form that is
+ more usable in Perl. For example, the decode_bytea
+ function can be used to convert an argument of
+ type bytea into unescaped binary.
+
+ Similarly, values passed back to PostgreSQL
+ must be in the external text representation format. For example, the
+ encode_bytea function can be used to
+ escape binary data for a return value of type bytea.
+
+ One case that is particularly important is boolean values. As just
+ stated, the default behavior for bool values is that they
+ are passed to Perl as text, thus either 't'
+ or 'f'. This is problematic, since Perl will not
+ treat 'f' as false! It is possible to improve matters
+ by using a “transform” (see
+ CREATE TRANSFORM). Suitable transforms are provided
+ by the bool_plperl extension. To use it, install
+ the extension:
+
+CREATE EXTENSION bool_plperl; -- or bool_plperlu for PL/PerlU
+
+ Then use the TRANSFORM function attribute for a
+ PL/Perl function that takes or returns bool, for example:
+
+CREATE FUNCTION perl_and(bool, bool) RETURNS bool
+TRANSFORM FOR TYPE bool
+AS $$
+ my ($a, $b) = @_;
+ return $a && $b;
+$$ LANGUAGE plperl;
+
+ When this transform is applied, bool arguments will be seen
+ by Perl as being 1 or empty, thus properly true or
+ false. If the function result is type bool, it will be true
+ or false according to whether Perl would evaluate the returned value as
+ true.
+ Similar transformations are also performed for boolean query arguments
+ and results of SPI queries performed inside the function
+ (Section 45.3.1).
+
+ Perl can return PostgreSQL arrays as
+ references to Perl arrays. Here is an example:
+
+
+CREATE OR REPLACE function returns_array()
+RETURNS text[][] AS $$
+ return [['a"b','c,d'],['e\\f','g']];
+$$ LANGUAGE plperl;
+
+select returns_array();
+
+
+ Perl passes PostgreSQL arrays as a blessed
+ PostgreSQL::InServer::ARRAY object. This object may be treated as an array
+ reference or a string, allowing for backward compatibility with Perl
+ code written for PostgreSQL versions below 9.1 to
+ run. For example:
+
+
+CREATE OR REPLACE FUNCTION concat_array_elements(text[]) RETURNS TEXT AS $$
+ my $arg = shift;
+ my $result = "";
+ return undef if (!defined $arg);
+
+ # as an array reference
+ for (@$arg) {
+ $result .= $_;
+ }
+
+ # also works as a string
+ $result .= $arg;
+
+ return $result;
+$$ LANGUAGE plperl;
+
+SELECT concat_array_elements(ARRAY['PL','/','Perl']);
+
+
+
Note
+ Multidimensional arrays are represented as references to
+ lower-dimensional arrays of references in a way common to every Perl
+ programmer.
+
+
+ Composite-type arguments are passed to the function as references
+ to hashes. The keys of the hash are the attribute names of the
+ composite type. Here is an example:
+
+
+CREATE TABLE employee (
+ name text,
+ basesalary integer,
+ bonus integer
+);
+
+CREATE FUNCTION empcomp(employee) RETURNS integer AS $$
+ my ($emp) = @_;
+ return $emp->{basesalary} + $emp->{bonus};
+$$ LANGUAGE plperl;
+
+SELECT name, empcomp(employee.*) FROM employee;
+
+
+ A PL/Perl function can return a composite-type result using the same
+ approach: return a reference to a hash that has the required attributes.
+ For example:
+
+
+CREATE TYPE testrowperl AS (f1 integer, f2 text, f3 text);
+
+CREATE OR REPLACE FUNCTION perl_row() RETURNS testrowperl AS $$
+ return {f2 => 'hello', f1 => 1, f3 => 'world'};
+$$ LANGUAGE plperl;
+
+SELECT * FROM perl_row();
+
+
+ Any columns in the declared result data type that are not present in the
+ hash will be returned as null values.
+
+ Similarly, output arguments of procedures can be returned as a hash
+ reference:
+
+
+CREATE PROCEDURE perl_triple(INOUT a integer, INOUT b integer) AS $$
+ my ($a, $b) = @_;
+ return {a => $a * 3, b => $b * 3};
+$$ LANGUAGE plperl;
+
+CALL perl_triple(5, 10);
+
+
+ PL/Perl functions can also return sets of either scalar or
+ composite types. Usually you'll want to return rows one at a
+ time, both to speed up startup time and to keep from queuing up
+ the entire result set in memory. You can do this with
+ return_next as illustrated below. Note that
+ after the last return_next, you must put
+ either return or (better) return
+ undef.
+
+
+CREATE OR REPLACE FUNCTION perl_set_int(int)
+RETURNS SETOF INTEGER AS $$
+ foreach (0..$_[0]) {
+ return_next($_);
+ }
+ return undef;
+$$ LANGUAGE plperl;
+
+SELECT * FROM perl_set_int(5);
+
+CREATE OR REPLACE FUNCTION perl_set()
+RETURNS SETOF testrowperl AS $$
+ return_next({ f1 => 1, f2 => 'Hello', f3 => 'World' });
+ return_next({ f1 => 2, f2 => 'Hello', f3 => 'PostgreSQL' });
+ return_next({ f1 => 3, f2 => 'Hello', f3 => 'PL/Perl' });
+ return undef;
+$$ LANGUAGE plperl;
+
+
+ For small result sets, you can return a reference to an array that
+ contains either scalars, references to arrays, or references to
+ hashes for simple types, array types, and composite types,
+ respectively. Here are some simple examples of returning the entire
+ result set as an array reference:
+
+
+CREATE OR REPLACE FUNCTION perl_set_int(int) RETURNS SETOF INTEGER AS $$
+ return [0..$_[0]];
+$$ LANGUAGE plperl;
+
+SELECT * FROM perl_set_int(5);
+
+CREATE OR REPLACE FUNCTION perl_set() RETURNS SETOF testrowperl AS $$
+ return [
+ { f1 => 1, f2 => 'Hello', f3 => 'World' },
+ { f1 => 2, f2 => 'Hello', f3 => 'PostgreSQL' },
+ { f1 => 3, f2 => 'Hello', f3 => 'PL/Perl' }
+ ];
+$$ LANGUAGE plperl;
+
+SELECT * FROM perl_set();
+
+
+ If you wish to use the strict pragma with your code you
+ have a few options. For temporary global use you can SET
+ plperl.use_strict to true.
+ This will affect subsequent compilations of PL/Perl
+ functions, but not functions already compiled in the current session.
+ For permanent global use you can set plperl.use_strict
+ to true in the postgresql.conf file.
+
+ For permanent use in specific functions you can simply put:
+
+use strict;
+
+ at the top of the function body.
+
+ The feature pragma is also available to use if your Perl is version 5.10.0 or higher.
+
45.4. Global Values in PL/Perl #
+ You can use the global hash %_SHARED to store
+ data, including code references, between function calls for the
+ lifetime of the current session.
+
+ Here is a simple example for shared data:
+
+CREATE OR REPLACE FUNCTION set_var(name text, val text) RETURNS text AS $$
+ if ($_SHARED{$_[0]} = $_[1]) {
+ return 'ok';
+ } else {
+ return "cannot set shared variable $_[0] to $_[1]";
+ }
+$$ LANGUAGE plperl;
+
+CREATE OR REPLACE FUNCTION get_var(name text) RETURNS text AS $$
+ return $_SHARED{$_[0]};
+$$ LANGUAGE plperl;
+
+SELECT set_var('sample', 'Hello, PL/Perl! How''s tricks?');
+SELECT get_var('sample');
+
+
+ Here is a slightly more complicated example using a code reference:
+
+
+CREATE OR REPLACE FUNCTION myfuncs() RETURNS void AS $$
+ $_SHARED{myquote} = sub {
+ my $arg = shift;
+ $arg =~ s/(['\\])/\\$1/g;
+ return "'$arg'";
+ };
+$$ LANGUAGE plperl;
+
+SELECT myfuncs(); /* initializes the function */
+
+/* Set up a function that uses the quote function */
+
+CREATE OR REPLACE FUNCTION use_quote(TEXT) RETURNS text AS $$
+ my $text_to_quote = shift;
+ my $qfunc = $_SHARED{myquote};
+ return &$qfunc($text_to_quote);
+$$ LANGUAGE plperl;
+
+
+ (You could have replaced the above with the one-liner
+ return $_SHARED{myquote}->($_[0]);
+ at the expense of readability.)
+
+ For security reasons, PL/Perl executes functions called by any one SQL role
+ in a separate Perl interpreter for that role. This prevents accidental or
+ malicious interference by one user with the behavior of another user's
+ PL/Perl functions. Each such interpreter has its own value of the
+ %_SHARED variable and other global state. Thus, two
+ PL/Perl functions will share the same value of %_SHARED
+ if and only if they are executed by the same SQL role. In an application
+ wherein a single session executes code under multiple SQL roles (via
+ SECURITY DEFINER functions, use of SET ROLE, etc.)
+ you may need to take explicit steps to ensure that PL/Perl functions can
+ share data via %_SHARED. To do that, make sure that
+ functions that should communicate are owned by the same user, and mark
+ them SECURITY DEFINER. You must of course take care that
+ such functions can't be used to do anything unintended.
+
+ PL/Perl can be used to write trigger functions. In a trigger function,
+ the hash reference $_TD contains information about the
+ current trigger event. $_TD is a global variable,
+ which gets a separate local value for each invocation of the trigger.
+ The fields of the $_TD hash reference are:
+
+
$_TD->{new}{foo}
+ NEW value of column foo
+
$_TD->{old}{foo}
+ OLD value of column foo
+
$_TD->{name}
+ Name of the trigger being called
+
$_TD->{event}
+ Trigger event: INSERT, UPDATE,
+ DELETE, TRUNCATE, or UNKNOWN
+
$_TD->{when}
+ When the trigger was called: BEFORE,
+ AFTER, INSTEAD OF, or
+ UNKNOWN
+
$_TD->{level}
+ The trigger level: ROW, STATEMENT, or UNKNOWN
+
$_TD->{relid}
+ OID of the table on which the trigger fired
+
$_TD->{table_name}
+ Name of the table on which the trigger fired
+
$_TD->{relname}
+ Name of the table on which the trigger fired. This has been deprecated,
+ and could be removed in a future release.
+ Please use $_TD->{table_name} instead.
+
$_TD->{table_schema}
+ Name of the schema in which the table on which the trigger fired, is
+
$_TD->{argc}
+ Number of arguments of the trigger function
+
@{$_TD->{args}}
+ Arguments of the trigger function. Does not exist if $_TD->{argc} is 0.
+
+
+ Row-level triggers can return one of the following:
+
+
return;
+ Execute the operation
+
"SKIP"
+ Don't execute the operation
+
"MODIFY"
+ Indicates that the NEW row was modified by
+ the trigger function
+
+
+ Here is an example of a trigger function, illustrating some of the
+ above:
+
+CREATE TABLE test (
+ i int,
+ v varchar
+);
+
+CREATE OR REPLACE FUNCTION valid_id() RETURNS trigger AS $$
+ if (($_TD->{new}{i} >= 100) || ($_TD->{new}{i} <= 0)) {
+ return "SKIP"; # skip INSERT/UPDATE command
+ } elsif ($_TD->{new}{v} ne "immortal") {
+ $_TD->{new}{v} .= "(modified by trigger)";
+ return "MODIFY"; # modify row and execute INSERT/UPDATE command
+ } else {
+ return; # execute INSERT/UPDATE command
+ }
+$$ LANGUAGE plperl;
+
+CREATE TRIGGER test_valid_id_trig
+ BEFORE INSERT OR UPDATE ON test
+ FOR EACH ROW EXECUTE FUNCTION valid_id();
+
+
45.5. Trusted and Untrusted PL/Perl #
+ Normally, PL/Perl is installed as a “trusted” programming
+ language named plperl. In this setup, certain Perl
+ operations are disabled to preserve security. In general, the
+ operations that are restricted are those that interact with the
+ environment. This includes file handle operations,
+ require, and use (for
+ external modules). There is no way to access internals of the
+ database server process or to gain OS-level access with the
+ permissions of the server process,
+ as a C function can do. Thus, any unprivileged database user can
+ be permitted to use this language.
+
+ Here is an example of a function that will not work because file
+ system operations are not allowed for security reasons:
+
+CREATE FUNCTION badfunc() RETURNS integer AS $$
+ my $tmpfile = "/tmp/badfile";
+ open my $fh, '>', $tmpfile
+ or elog(ERROR, qq{could not open the file "$tmpfile": $!});
+ print $fh "Testing writing to a file\n";
+ close $fh or elog(ERROR, qq{could not close the file "$tmpfile": $!});
+ return 1;
+$$ LANGUAGE plperl;
+
+ The creation of this function will fail as its use of a forbidden
+ operation will be caught by the validator.
+
+ Sometimes it is desirable to write Perl functions that are not
+ restricted. For example, one might want a Perl function that sends
+ mail. To handle these cases, PL/Perl can also be installed as an
+ “untrusted” language (usually called
+ PL/PerlU).
+ In this case the full Perl language is available. When installing the
+ language, the language name plperlu will select
+ the untrusted PL/Perl variant.
+
+ The writer of a PL/PerlU function must take care that the function
+ cannot be used to do anything unwanted, since it will be able to do
+ anything that could be done by a user logged in as the database
+ administrator. Note that the database system allows only database
+ superusers to create functions in untrusted languages.
+
+ If the above function was created by a superuser using the language
+ plperlu, execution would succeed.
+
+ In the same way, anonymous code blocks written in Perl can use
+ restricted operations if the language is specified as
+ plperlu rather than plperl, but the caller
+ must be a superuser.
+
Note
+ While PL/Perl functions run in a separate Perl
+ interpreter for each SQL role, all PL/PerlU functions
+ executed in a given session run in a single Perl interpreter (which is
+ not any of the ones used for PL/Perl functions).
+ This allows PL/PerlU functions to share data freely,
+ but no communication can occur between PL/Perl and
+ PL/PerlU functions.
+
Note
+ Perl cannot support multiple interpreters within one process unless
+ it was built with the appropriate flags, namely either
+ usemultiplicity or useithreads.
+ (usemultiplicity is preferred unless you actually need
+ to use threads. For more details, see the
+ perlembed man page.)
+ If PL/Perl is used with a copy of Perl that was not built
+ this way, then it is only possible to have one Perl interpreter per
+ session, and so any one session can only execute either
+ PL/PerlU functions, or PL/Perl functions
+ that are all called by the same SQL role.
+
45.8. PL/Perl Under the Hood #
+ This section lists configuration parameters that affect PL/Perl.
+
-
+
plperl.on_init (string)
+
+ #
+ Specifies Perl code to be executed when a Perl interpreter is first
+ initialized, before it is specialized for use by plperl or
+ plperlu.
+ The SPI functions are not available when this code is executed.
+ If the code fails with an error it will abort the initialization of
+ the interpreter and propagate out to the calling query, causing the
+ current transaction or subtransaction to be aborted.
+
+ The Perl code is limited to a single string. Longer code can be placed
+ into a module and loaded by the on_init string.
+ Examples:
+
+plperl.on_init = 'require "plperlinit.pl"'
+plperl.on_init = 'use lib "/my/app"; use MyApp::PgInit;'
+
+
+ Any modules loaded by plperl.on_init, either directly or
+ indirectly, will be available for use by plperl. This may
+ create a security risk. To see what modules have been loaded you can use:
+
+DO 'elog(WARNING, join ", ", sort keys %INC)' LANGUAGE plperl;
+
+
+ Initialization will happen in the postmaster if the plperl library is
+ included in shared_preload_libraries, in which
+ case extra consideration should be given to the risk of destabilizing
+ the postmaster. The principal reason for making use of this feature
+ is that Perl modules loaded by plperl.on_init need be
+ loaded only at postmaster start, and will be instantly available
+ without loading overhead in individual database sessions. However,
+ keep in mind that the overhead is avoided only for the first Perl
+ interpreter used by a database session — either PL/PerlU, or
+ PL/Perl for the first SQL role that calls a PL/Perl function. Any
+ additional Perl interpreters created in a database session will have
+ to execute plperl.on_init afresh. Also, on Windows there
+ will be no savings whatsoever from preloading, since the Perl
+ interpreter created in the postmaster process does not propagate to
+ child processes.
+
+ This parameter can only be set in the postgresql.conf file or on the server command line.
+
-
+
plperl.on_plperl_init (string)
+
+
+ plperl.on_plperlu_init (string)
+
+ #
+ These parameters specify Perl code to be executed when a Perl
+ interpreter is specialized for plperl or
+ plperlu respectively. This will happen when a PL/Perl or
+ PL/PerlU function is first executed in a database session, or when
+ an additional interpreter has to be created because the other language
+ is called or a PL/Perl function is called by a new SQL role. This
+ follows any initialization done by plperl.on_init.
+ The SPI functions are not available when this code is executed.
+ The Perl code in plperl.on_plperl_init is executed after
+ “locking down” the interpreter, and thus it can only perform
+ trusted operations.
+
+ If the code fails with an error it will abort the initialization and
+ propagate out to the calling query, causing the current transaction or
+ subtransaction to be aborted. Any actions already done within Perl
+ won't be undone; however, that interpreter won't be used again.
+ If the language is used again the initialization will be attempted
+ again within a fresh Perl interpreter.
+
+ Only superusers can change these settings. Although these settings
+ can be changed within a session, such changes will not affect Perl
+ interpreters that have already been used to execute functions.
+
-
+
plperl.use_strict (boolean)
+
+ #
+ When set true subsequent compilations of PL/Perl functions will have
+ the strict pragma enabled. This parameter does not affect
+ functions already compiled in the current session.
+
45.8.2. Limitations and Missing Features #
+ The following features are currently missing from PL/Perl, but they
+ would make welcome contributions.
+
+
+ PL/Perl functions cannot call each other directly.
+
+ SPI is not yet fully implemented.
+
+ If you are fetching very large data sets using
+ spi_exec_query, you should be aware that
+ these will all go into memory. You can avoid this by using
+ spi_query/spi_fetchrow as
+ illustrated earlier.
+
+ A similar problem occurs if a set-returning function passes a
+ large set of rows back to PostgreSQL via return. You
+ can avoid this problem too by instead using
+ return_next for each row returned, as shown
+ previously.
+
+ When a session ends normally, not due to a fatal error, any
+ END blocks that have been defined are executed.
+ Currently no other actions are performed. Specifically,
+ file handles are not automatically flushed and objects are
+ not automatically destroyed.
+
+
Chapter 45. PL/Perl — Perl Procedural Language
+ PL/Perl is a loadable procedural language that enables you to write
+ PostgreSQL functions and procedures in the
+ Perl programming language.
+
+ The main advantage to using PL/Perl is that this allows use,
+ within stored functions and procedures, of the manyfold “string
+ munging” operators and functions available for Perl. Parsing
+ complex strings might be easier using Perl than it is with the
+ string functions and control structures provided in PL/pgSQL.
+
+ To install PL/Perl in a particular database, use
+ CREATE EXTENSION plperl.
+
Tip
+ If a language is installed into template1, all subsequently
+ created databases will have the language installed automatically.
+
Note
+ Users of source packages must specially enable the build of
+ PL/Perl during the installation process. (Refer to Chapter 17 for more information.) Users of
+ binary packages might find PL/Perl in a separate subpackage.
+
43.6. Control Structures #
+ Control structures are probably the most useful (and
+ important) part of PL/pgSQL. With
+ PL/pgSQL's control structures,
+ you can manipulate PostgreSQL data in a very
+ flexible and powerful way.
+
43.6.1. Returning from a Function #
+ There are two commands available that allow you to return data
+ from a function: RETURN and RETURN
+ NEXT.
+
+RETURN expression;
+
+ RETURN with an expression terminates the
+ function and returns the value of
+ expression to the caller. This form
+ is used for PL/pgSQL functions that do
+ not return a set.
+
+ In a function that returns a scalar type, the expression's result will
+ automatically be cast into the function's return type as described for
+ assignments. But to return a composite (row) value, you must write an
+ expression delivering exactly the requested column set. This may
+ require use of explicit casting.
+
+ If you declared the function with output parameters, write just
+ RETURN with no expression. The current values
+ of the output parameter variables will be returned.
+
+ If you declared the function to return void, a
+ RETURN statement can be used to exit the function
+ early; but do not write an expression following
+ RETURN.
+
+ The return value of a function cannot be left undefined. If
+ control reaches the end of the top-level block of the function
+ without hitting a RETURN statement, a run-time
+ error will occur. This restriction does not apply to functions
+ with output parameters and functions returning void,
+ however. In those cases a RETURN statement is
+ automatically executed if the top-level block finishes.
+
+ Some examples:
+
+
+-- functions returning a scalar type
+RETURN 1 + 2;
+RETURN scalar_var;
+
+-- functions returning a composite type
+RETURN composite_type_var;
+RETURN (1, 2, 'three'::text); -- must cast columns to correct types
+
+
43.6.1.2. RETURN NEXT and RETURN QUERY #
+RETURN NEXT expression;
+RETURN QUERY query;
+RETURN QUERY EXECUTE command-string [ USING expression [, ... ] ];
+
+ When a PL/pgSQL function is declared to return
+ SETOF sometype, the procedure
+ to follow is slightly different. In that case, the individual
+ items to return are specified by a sequence of RETURN
+ NEXT or RETURN QUERY commands, and
+ then a final RETURN command with no argument
+ is used to indicate that the function has finished executing.
+ RETURN NEXT can be used with both scalar and
+ composite data types; with a composite result type, an entire
+ “table” of results will be returned.
+ RETURN QUERY appends the results of executing
+ a query to the function's result set. RETURN
+ NEXT and RETURN QUERY can be freely
+ intermixed in a single set-returning function, in which case
+ their results will be concatenated.
+
+ RETURN NEXT and RETURN
+ QUERY do not actually return from the function —
+ they simply append zero or more rows to the function's result
+ set. Execution then continues with the next statement in the
+ PL/pgSQL function. As successive
+ RETURN NEXT or RETURN
+ QUERY commands are executed, the result set is built
+ up. A final RETURN, which should have no
+ argument, causes control to exit the function (or you can just
+ let control reach the end of the function).
+
+ RETURN QUERY has a variant
+ RETURN QUERY EXECUTE, which specifies the
+ query to be executed dynamically. Parameter expressions can
+ be inserted into the computed query string via USING,
+ in just the same way as in the EXECUTE command.
+
+ If you declared the function with output parameters, write just
+ RETURN NEXT with no expression. On each
+ execution, the current values of the output parameter
+ variable(s) will be saved for eventual return as a row of the
+ result. Note that you must declare the function as returning
+ SETOF record when there are multiple output
+ parameters, or SETOF sometype
+ when there is just one output parameter of type
+ sometype, in order to create a set-returning
+ function with output parameters.
+
+ Here is an example of a function using RETURN
+ NEXT:
+
+
+CREATE TABLE foo (fooid INT, foosubid INT, fooname TEXT);
+INSERT INTO foo VALUES (1, 2, 'three');
+INSERT INTO foo VALUES (4, 5, 'six');
+
+CREATE OR REPLACE FUNCTION get_all_foo() RETURNS SETOF foo AS
+$BODY$
+DECLARE
+ r foo%rowtype;
+BEGIN
+ FOR r IN
+ SELECT * FROM foo WHERE fooid > 0
+ LOOP
+ -- can do some processing here
+ RETURN NEXT r; -- return current row of SELECT
+ END LOOP;
+ RETURN;
+END;
+$BODY$
+LANGUAGE plpgsql;
+
+SELECT * FROM get_all_foo();
+
+
+ Here is an example of a function using RETURN
+ QUERY:
+
+
+CREATE FUNCTION get_available_flightid(date) RETURNS SETOF integer AS
+$BODY$
+BEGIN
+ RETURN QUERY SELECT flightid
+ FROM flight
+ WHERE flightdate >= $1
+ AND flightdate < ($1 + 1);
+
+ -- Since execution is not finished, we can check whether rows were returned
+ -- and raise exception if not.
+ IF NOT FOUND THEN
+ RAISE EXCEPTION 'No flight at %.', $1;
+ END IF;
+
+ RETURN;
+ END;
+$BODY$
+LANGUAGE plpgsql;
+
+-- Returns available flights or raises exception if there are no
+-- available flights.
+SELECT * FROM get_available_flightid(CURRENT_DATE);
+
+
Note
+ The current implementation of RETURN NEXT
+ and RETURN QUERY stores the entire result set
+ before returning from the function, as discussed above. That
+ means that if a PL/pgSQL function produces a
+ very large result set, performance might be poor: data will be
+ written to disk to avoid memory exhaustion, but the function
+ itself will not return until the entire result set has been
+ generated. A future version of PL/pgSQL might
+ allow users to define set-returning functions
+ that do not have this limitation. Currently, the point at
+ which data begins being written to disk is controlled by the
+ work_mem
+ configuration variable. Administrators who have sufficient
+ memory to store larger result sets in memory should consider
+ increasing this parameter.
+
43.6.2. Returning from a Procedure #
+ A procedure does not have a return value. A procedure can therefore end
+ without a RETURN statement. If you wish to use
+ a RETURN statement to exit the code early, write
+ just RETURN with no expression.
+
+ If the procedure has output parameters, the final values of the output
+ parameter variables will be returned to the caller.
+
43.6.3. Calling a Procedure #
+ A PL/pgSQL function, procedure,
+ or DO block can call a procedure
+ using CALL. Output parameters are handled
+ differently from the way that CALL works in plain
+ SQL. Each OUT or INOUT
+ parameter of the procedure must
+ correspond to a variable in the CALL statement, and
+ whatever the procedure returns is assigned back to that variable after
+ it returns. For example:
+
+CREATE PROCEDURE triple(INOUT x int)
+LANGUAGE plpgsql
+AS $$
+BEGIN
+ x := x * 3;
+END;
+$$;
+
+DO $$
+DECLARE myvar int := 5;
+BEGIN
+ CALL triple(myvar);
+ RAISE NOTICE 'myvar = %', myvar; -- prints 15
+END;
+$$;
+
+ The variable corresponding to an output parameter can be a simple
+ variable or a field of a composite-type variable. Currently,
+ it cannot be an element of an array.
+
+ IF and CASE statements let you execute
+ alternative commands based on certain conditions.
+ PL/pgSQL has three forms of IF:
+
+
+ and two forms of CASE:
+
+
+IF boolean-expression THEN
+ statements
+END IF;
+
+ IF-THEN statements are the simplest form of
+ IF. The statements between
+ THEN and END IF will be
+ executed if the condition is true. Otherwise, they are
+ skipped.
+
+ Example:
+
+IF v_user_id <> 0 THEN
+ UPDATE users SET email = v_email WHERE user_id = v_user_id;
+END IF;
+
+
+IF boolean-expression THEN
+ statements
+ELSE
+ statements
+END IF;
+
+ IF-THEN-ELSE statements add to
+ IF-THEN by letting you specify an
+ alternative set of statements that should be executed if the
+ condition is not true. (Note this includes the case where the
+ condition evaluates to NULL.)
+
+ Examples:
+
+IF parentid IS NULL OR parentid = ''
+THEN
+ RETURN fullname;
+ELSE
+ RETURN hp_true_filename(parentid) || '/' || fullname;
+END IF;
+
+
+
+IF v_count > 0 THEN
+ INSERT INTO users_count (count) VALUES (v_count);
+ RETURN 't';
+ELSE
+ RETURN 'f';
+END IF;
+
+
43.6.4.3. IF-THEN-ELSIF #
+IF boolean-expression THEN
+ statements
+[ ELSIF boolean-expression THEN
+ statements
+[ ELSIF boolean-expression THEN
+ statements
+ ...
+]
+]
+[ ELSE
+ statements ]
+END IF;
+
+ Sometimes there are more than just two alternatives.
+ IF-THEN-ELSIF provides a convenient
+ method of checking several alternatives in turn.
+ The IF conditions are tested successively
+ until the first one that is true is found. Then the
+ associated statement(s) are executed, after which control
+ passes to the next statement after END IF.
+ (Any subsequent IF conditions are not
+ tested.) If none of the IF conditions is true,
+ then the ELSE block (if any) is executed.
+
+ Here is an example:
+
+
+IF number = 0 THEN
+ result := 'zero';
+ELSIF number > 0 THEN
+ result := 'positive';
+ELSIF number < 0 THEN
+ result := 'negative';
+ELSE
+ -- hmm, the only other possibility is that number is null
+ result := 'NULL';
+END IF;
+
+
+ The key word ELSIF can also be spelled
+ ELSEIF.
+
+ An alternative way of accomplishing the same task is to nest
+ IF-THEN-ELSE statements, as in the
+ following example:
+
+
+IF demo_row.sex = 'm' THEN
+ pretty_sex := 'man';
+ELSE
+ IF demo_row.sex = 'f' THEN
+ pretty_sex := 'woman';
+ END IF;
+END IF;
+
+
+ However, this method requires writing a matching END IF
+ for each IF, so it is much more cumbersome than
+ using ELSIF when there are many alternatives.
+
+CASE search-expression
+ WHEN expression [, expression [ ... ]] THEN
+ statements
+ [ WHEN expression [, expression [ ... ]] THEN
+ statements
+ ... ]
+ [ ELSE
+ statements ]
+END CASE;
+
+ The simple form of CASE provides conditional execution
+ based on equality of operands. The search-expression
+ is evaluated (once) and successively compared to each
+ expression in the WHEN clauses.
+ If a match is found, then the corresponding
+ statements are executed, and then control
+ passes to the next statement after END CASE. (Subsequent
+ WHEN expressions are not evaluated.) If no match is
+ found, the ELSE statements are
+ executed; but if ELSE is not present, then a
+ CASE_NOT_FOUND exception is raised.
+
+ Here is a simple example:
+
+
+CASE x
+ WHEN 1, 2 THEN
+ msg := 'one or two';
+ ELSE
+ msg := 'other value than one or two';
+END CASE;
+
+
43.6.4.5. Searched CASE #
+CASE
+ WHEN boolean-expression THEN
+ statements
+ [ WHEN boolean-expression THEN
+ statements
+ ... ]
+ [ ELSE
+ statements ]
+END CASE;
+
+ The searched form of CASE provides conditional execution
+ based on truth of Boolean expressions. Each WHEN clause's
+ boolean-expression is evaluated in turn,
+ until one is found that yields true. Then the
+ corresponding statements are executed, and
+ then control passes to the next statement after END CASE.
+ (Subsequent WHEN expressions are not evaluated.)
+ If no true result is found, the ELSE
+ statements are executed;
+ but if ELSE is not present, then a
+ CASE_NOT_FOUND exception is raised.
+
+ Here is an example:
+
+
+CASE
+ WHEN x BETWEEN 0 AND 10 THEN
+ msg := 'value is between zero and ten';
+ WHEN x BETWEEN 11 AND 20 THEN
+ msg := 'value is between eleven and twenty';
+END CASE;
+
+
+ This form of CASE is entirely equivalent to
+ IF-THEN-ELSIF, except for the rule that reaching
+ an omitted ELSE clause results in an error rather
+ than doing nothing.
+
+ With the LOOP, EXIT,
+ CONTINUE, WHILE, FOR,
+ and FOREACH statements, you can arrange for your
+ PL/pgSQL function to repeat a series of commands.
+
+[ <<label>> ]
+LOOP
+ statements
+END LOOP [ label ];
+
+ LOOP defines an unconditional loop that is repeated
+ indefinitely until terminated by an EXIT or
+ RETURN statement. The optional
+ label can be used by EXIT
+ and CONTINUE statements within nested loops to
+ specify which loop those statements refer to.
+
+EXIT [ label ] [ WHEN boolean-expression ];
+
+ If no label is given, the innermost
+ loop is terminated and the statement following END
+ LOOP is executed next. If label
+ is given, it must be the label of the current or some outer
+ level of nested loop or block. Then the named loop or block is
+ terminated and control continues with the statement after the
+ loop's/block's corresponding END.
+
+ If WHEN is specified, the loop exit occurs only if
+ boolean-expression is true. Otherwise, control passes
+ to the statement after EXIT.
+
+ EXIT can be used with all types of loops; it is
+ not limited to use with unconditional loops.
+
+ When used with a
+ BEGIN block, EXIT passes
+ control to the next statement after the end of the block.
+ Note that a label must be used for this purpose; an unlabeled
+ EXIT is never considered to match a
+ BEGIN block. (This is a change from
+ pre-8.4 releases of PostgreSQL, which
+ would allow an unlabeled EXIT to match
+ a BEGIN block.)
+
+ Examples:
+
+LOOP
+ -- some computations
+ IF count > 0 THEN
+ EXIT; -- exit loop
+ END IF;
+END LOOP;
+
+LOOP
+ -- some computations
+ EXIT WHEN count > 0; -- same result as previous example
+END LOOP;
+
+<<ablock>>
+BEGIN
+ -- some computations
+ IF stocks > 100000 THEN
+ EXIT ablock; -- causes exit from the BEGIN block
+ END IF;
+ -- computations here will be skipped when stocks > 100000
+END;
+
+
+CONTINUE [ label ] [ WHEN boolean-expression ];
+
+ If no label is given, the next iteration of
+ the innermost loop is begun. That is, all statements remaining
+ in the loop body are skipped, and control returns
+ to the loop control expression (if any) to determine whether
+ another loop iteration is needed.
+ If label is present, it
+ specifies the label of the loop whose execution will be
+ continued.
+
+ If WHEN is specified, the next iteration of the
+ loop is begun only if boolean-expression is
+ true. Otherwise, control passes to the statement after
+ CONTINUE.
+
+ CONTINUE can be used with all types of loops; it
+ is not limited to use with unconditional loops.
+
+ Examples:
+
+LOOP
+ -- some computations
+ EXIT WHEN count > 100;
+ CONTINUE WHEN count < 50;
+ -- some computations for count IN [50 .. 100]
+END LOOP;
+
+
+[ <<label>> ]
+WHILE boolean-expression LOOP
+ statements
+END LOOP [ label ];
+
+ The WHILE statement repeats a
+ sequence of statements so long as the
+ boolean-expression
+ evaluates to true. The expression is checked just before
+ each entry to the loop body.
+
+ For example:
+
+WHILE amount_owed > 0 AND gift_certificate_balance > 0 LOOP
+ -- some computations here
+END LOOP;
+
+WHILE NOT done LOOP
+ -- some computations here
+END LOOP;
+
+
43.6.5.5. FOR (Integer Variant) #
+[ <<label>> ]
+FOR name IN [ REVERSE ] expression .. expression [ BY expression ] LOOP
+ statements
+END LOOP [ label ];
+
+ This form of FOR creates a loop that iterates over a range
+ of integer values. The variable
+ name is automatically defined as type
+ integer and exists only inside the loop (any existing
+ definition of the variable name is ignored within the loop).
+ The two expressions giving
+ the lower and upper bound of the range are evaluated once when entering
+ the loop. If the BY clause isn't specified the iteration
+ step is 1, otherwise it's the value specified in the BY
+ clause, which again is evaluated once on loop entry.
+ If REVERSE is specified then the step value is
+ subtracted, rather than added, after each iteration.
+
+ Some examples of integer FOR loops:
+
+FOR i IN 1..10 LOOP
+ -- i will take on the values 1,2,3,4,5,6,7,8,9,10 within the loop
+END LOOP;
+
+FOR i IN REVERSE 10..1 LOOP
+ -- i will take on the values 10,9,8,7,6,5,4,3,2,1 within the loop
+END LOOP;
+
+FOR i IN REVERSE 10..1 BY 2 LOOP
+ -- i will take on the values 10,8,6,4,2 within the loop
+END LOOP;
+
+
+ If the lower bound is greater than the upper bound (or less than,
+ in the REVERSE case), the loop body is not
+ executed at all. No error is raised.
+
+ If a label is attached to the
+ FOR loop then the integer loop variable can be
+ referenced with a qualified name, using that
+ label.
+
43.6.6. Looping through Query Results #
+ Using a different type of FOR loop, you can iterate through
+ the results of a query and manipulate that data
+ accordingly. The syntax is:
+
+[ <<label>> ]
+FOR target IN query LOOP
+ statements
+END LOOP [ label ];
+
+ The target is a record variable, row variable,
+ or comma-separated list of scalar variables.
+ The target is successively assigned each row
+ resulting from the query and the loop body is
+ executed for each row. Here is an example:
+
+CREATE FUNCTION refresh_mviews() RETURNS integer AS $$
+DECLARE
+ mviews RECORD;
+BEGIN
+ RAISE NOTICE 'Refreshing all materialized views...';
+
+ FOR mviews IN
+ SELECT n.nspname AS mv_schema,
+ c.relname AS mv_name,
+ pg_catalog.pg_get_userbyid(c.relowner) AS owner
+ FROM pg_catalog.pg_class c
+ LEFT JOIN pg_catalog.pg_namespace n ON (n.oid = c.relnamespace)
+ WHERE c.relkind = 'm'
+ ORDER BY 1
+ LOOP
+
+ -- Now "mviews" has one record with information about the materialized view
+
+ RAISE NOTICE 'Refreshing materialized view %.% (owner: %)...',
+ quote_ident(mviews.mv_schema),
+ quote_ident(mviews.mv_name),
+ quote_ident(mviews.owner);
+ EXECUTE format('REFRESH MATERIALIZED VIEW %I.%I', mviews.mv_schema, mviews.mv_name);
+ END LOOP;
+
+ RAISE NOTICE 'Done refreshing materialized views.';
+ RETURN 1;
+END;
+$$ LANGUAGE plpgsql;
+
+
+ If the loop is terminated by an EXIT statement, the last
+ assigned row value is still accessible after the loop.
+
+ The query used in this type of FOR
+ statement can be any SQL command that returns rows to the caller:
+ SELECT is the most common case,
+ but you can also use INSERT, UPDATE, or
+ DELETE with a RETURNING clause. Some utility
+ commands such as EXPLAIN will work too.
+
+ PL/pgSQL variables are replaced by query parameters,
+ and the query plan is cached for possible re-use, as discussed in
+ detail in Section 43.11.1 and
+ Section 43.11.2.
+
+ The FOR-IN-EXECUTE statement is another way to iterate over
+ rows:
+
+[ <<label>> ]
+FOR target IN EXECUTE text_expression [ USING expression [, ... ] ] LOOP
+ statements
+END LOOP [ label ];
+
+ This is like the previous form, except that the source query
+ is specified as a string expression, which is evaluated and replanned
+ on each entry to the FOR loop. This allows the programmer to
+ choose the speed of a preplanned query or the flexibility of a dynamic
+ query, just as with a plain EXECUTE statement.
+ As with EXECUTE, parameter values can be inserted
+ into the dynamic command via USING.
+
+ Another way to specify the query whose results should be iterated
+ through is to declare it as a cursor. This is described in
+ Section 43.7.4.
+
43.6.7. Looping through Arrays #
+ The FOREACH loop is much like a FOR loop,
+ but instead of iterating through the rows returned by an SQL query,
+ it iterates through the elements of an array value.
+ (In general, FOREACH is meant for looping through
+ components of a composite-valued expression; variants for looping
+ through composites besides arrays may be added in future.)
+ The FOREACH statement to loop over an array is:
+
+
+[ <<label>> ]
+FOREACH target [ SLICE number ] IN ARRAY expression LOOP
+ statements
+END LOOP [ label ];
+
+
+ Without SLICE, or if SLICE 0 is specified,
+ the loop iterates through individual elements of the array produced
+ by evaluating the expression.
+ The target variable is assigned each
+ element value in sequence, and the loop body is executed for each element.
+ Here is an example of looping through the elements of an integer
+ array:
+
+
+CREATE FUNCTION sum(int[]) RETURNS int8 AS $$
+DECLARE
+ s int8 := 0;
+ x int;
+BEGIN
+ FOREACH x IN ARRAY $1
+ LOOP
+ s := s + x;
+ END LOOP;
+ RETURN s;
+END;
+$$ LANGUAGE plpgsql;
+
+
+ The elements are visited in storage order, regardless of the number of
+ array dimensions. Although the target is
+ usually just a single variable, it can be a list of variables when
+ looping through an array of composite values (records). In that case,
+ for each array element, the variables are assigned from successive
+ columns of the composite value.
+
+ With a positive SLICE value, FOREACH
+ iterates through slices of the array rather than single elements.
+ The SLICE value must be an integer constant not larger
+ than the number of dimensions of the array. The
+ target variable must be an array,
+ and it receives successive slices of the array value, where each slice
+ is of the number of dimensions specified by SLICE.
+ Here is an example of iterating through one-dimensional slices:
+
+
+CREATE FUNCTION scan_rows(int[]) RETURNS void AS $$
+DECLARE
+ x int[];
+BEGIN
+ FOREACH x SLICE 1 IN ARRAY $1
+ LOOP
+ RAISE NOTICE 'row = %', x;
+ END LOOP;
+END;
+$$ LANGUAGE plpgsql;
+
+SELECT scan_rows(ARRAY[[1,2,3],[4,5,6],[7,8,9],[10,11,12]]);
+
+NOTICE: row = {1,2,3}
+NOTICE: row = {4,5,6}
+NOTICE: row = {7,8,9}
+NOTICE: row = {10,11,12}
+
+
43.6.8. Trapping Errors #
+ By default, any error occurring in a PL/pgSQL
+ function aborts execution of the function and the
+ surrounding transaction. You can trap errors and recover
+ from them by using a BEGIN block with an
+ EXCEPTION clause. The syntax is an extension of the
+ normal syntax for a BEGIN block:
+
+
+[ <<label>> ]
+[ DECLARE
+ declarations ]
+BEGIN
+ statements
+EXCEPTION
+ WHEN condition [ OR condition ... ] THEN
+ handler_statements
+ [ WHEN condition [ OR condition ... ] THEN
+ handler_statements
+ ... ]
+END;
+
+
+ If no error occurs, this form of block simply executes all the
+ statements, and then control passes
+ to the next statement after END. But if an error
+ occurs within the statements, further
+ processing of the statements is
+ abandoned, and control passes to the EXCEPTION list.
+ The list is searched for the first condition
+ matching the error that occurred. If a match is found, the
+ corresponding handler_statements are
+ executed, and then control passes to the next statement after
+ END. If no match is found, the error propagates out
+ as though the EXCEPTION clause were not there at all:
+ the error can be caught by an enclosing block with
+ EXCEPTION, or if there is none it aborts processing
+ of the function.
+
+ The condition names can be any of
+ those shown in Appendix A. A category
+ name matches any error within its category. The special
+ condition name OTHERS matches every error type except
+ QUERY_CANCELED and ASSERT_FAILURE.
+ (It is possible, but often unwise, to trap those two error types
+ by name.) Condition names are
+ not case-sensitive. Also, an error condition can be specified
+ by SQLSTATE code; for example these are equivalent:
+
+WHEN division_by_zero THEN ...
+WHEN SQLSTATE '22012' THEN ...
+
+
+ If a new error occurs within the selected
+ handler_statements, it cannot be caught
+ by this EXCEPTION clause, but is propagated out.
+ A surrounding EXCEPTION clause could catch it.
+
+ When an error is caught by an EXCEPTION clause,
+ the local variables of the PL/pgSQL function
+ remain as they were when the error occurred, but all changes
+ to persistent database state within the block are rolled back.
+ As an example, consider this fragment:
+
+
+INSERT INTO mytab(firstname, lastname) VALUES('Tom', 'Jones');
+BEGIN
+ UPDATE mytab SET firstname = 'Joe' WHERE lastname = 'Jones';
+ x := x + 1;
+ y := x / 0;
+EXCEPTION
+ WHEN division_by_zero THEN
+ RAISE NOTICE 'caught division_by_zero';
+ RETURN x;
+END;
+
+
+ When control reaches the assignment to y, it will
+ fail with a division_by_zero error. This will be caught by
+ the EXCEPTION clause. The value returned in the
+ RETURN statement will be the incremented value of
+ x, but the effects of the UPDATE command will
+ have been rolled back. The INSERT command preceding the
+ block is not rolled back, however, so the end result is that the database
+ contains Tom Jones not Joe Jones.
+
Tip
+ A block containing an EXCEPTION clause is significantly
+ more expensive to enter and exit than a block without one. Therefore,
+ don't use EXCEPTION without need.
+
Example 43.2. Exceptions with UPDATE/INSERT
+
+ This example uses exception handling to perform either
+ UPDATE or INSERT, as appropriate. It is
+ recommended that applications use INSERT with
+ ON CONFLICT DO UPDATE rather than actually using
+ this pattern. This example serves primarily to illustrate use of
+ PL/pgSQL control flow structures:
+
+
+CREATE TABLE db (a INT PRIMARY KEY, b TEXT);
+
+CREATE FUNCTION merge_db(key INT, data TEXT) RETURNS VOID AS
+$$
+BEGIN
+ LOOP
+ -- first try to update the key
+ UPDATE db SET b = data WHERE a = key;
+ IF found THEN
+ RETURN;
+ END IF;
+ -- not there, so try to insert the key
+ -- if someone else inserts the same key concurrently,
+ -- we could get a unique-key failure
+ BEGIN
+ INSERT INTO db(a,b) VALUES (key, data);
+ RETURN;
+ EXCEPTION WHEN unique_violation THEN
+ -- Do nothing, and loop to try the UPDATE again.
+ END;
+ END LOOP;
+END;
+$$
+LANGUAGE plpgsql;
+
+SELECT merge_db(1, 'david');
+SELECT merge_db(1, 'dennis');
+
+
+ This coding assumes the unique_violation error is caused by
+ the INSERT, and not by, say, an INSERT in a
+ trigger function on the table. It might also misbehave if there is
+ more than one unique index on the table, since it will retry the
+ operation regardless of which index caused the error.
+ More safety could be had by using the
+ features discussed next to check that the trapped error was the one
+ expected.
+
43.6.8.1. Obtaining Information about an Error #
+ Exception handlers frequently need to identify the specific error that
+ occurred. There are two ways to get information about the current
+ exception in PL/pgSQL: special variables and the
+ GET STACKED DIAGNOSTICS command.
+
+ Within an exception handler, the special variable
+ SQLSTATE contains the error code that corresponds to
+ the exception that was raised (refer to Table A.1
+ for a list of possible error codes). The special variable
+ SQLERRM contains the error message associated with the
+ exception. These variables are undefined outside exception handlers.
+
+ Within an exception handler, one may also retrieve
+ information about the current exception by using the
+ GET STACKED DIAGNOSTICS command, which has the form:
+
+
+GET STACKED DIAGNOSTICS variable { = | := } item [ , ... ];
+
+
+ Each item is a key word identifying a status
+ value to be assigned to the specified variable
+ (which should be of the right data type to receive it). The currently
+ available status items are shown
+ in Table 43.2.
+
Table 43.2. Error Diagnostics Items
| Name | Type | Description |
|---|
RETURNED_SQLSTATE | text | the SQLSTATE error code of the exception |
COLUMN_NAME | text | the name of the column related to exception |
CONSTRAINT_NAME | text | the name of the constraint related to exception |
PG_DATATYPE_NAME | text | the name of the data type related to exception |
MESSAGE_TEXT | text | the text of the exception's primary message |
TABLE_NAME | text | the name of the table related to exception |
SCHEMA_NAME | text | the name of the schema related to exception |
PG_EXCEPTION_DETAIL | text | the text of the exception's detail message, if any |
PG_EXCEPTION_HINT | text | the text of the exception's hint message, if any |
PG_EXCEPTION_CONTEXT | text | line(s) of text describing the call stack at the time of the
+ exception (see Section 43.6.9) |
+ If the exception did not set a value for an item, an empty string
+ will be returned.
+
+ Here is an example:
+
+DECLARE
+ text_var1 text;
+ text_var2 text;
+ text_var3 text;
+BEGIN
+ -- some processing which might cause an exception
+ ...
+EXCEPTION WHEN OTHERS THEN
+ GET STACKED DIAGNOSTICS text_var1 = MESSAGE_TEXT,
+ text_var2 = PG_EXCEPTION_DETAIL,
+ text_var3 = PG_EXCEPTION_HINT;
+END;
+
+
43.6.9. Obtaining Execution Location Information #
+ The GET DIAGNOSTICS command, previously described
+ in Section 43.5.5, retrieves information
+ about current execution state (whereas the GET STACKED
+ DIAGNOSTICS command discussed above reports information about
+ the execution state as of a previous error). Its PG_CONTEXT
+ status item is useful for identifying the current execution
+ location. PG_CONTEXT returns a text string with line(s)
+ of text describing the call stack. The first line refers to the current
+ function and currently executing GET DIAGNOSTICS
+ command. The second and any subsequent lines refer to calling functions
+ further up the call stack. For example:
+
+
+CREATE OR REPLACE FUNCTION outer_func() RETURNS integer AS $$
+BEGIN
+ RETURN inner_func();
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE OR REPLACE FUNCTION inner_func() RETURNS integer AS $$
+DECLARE
+ stack text;
+BEGIN
+ GET DIAGNOSTICS stack = PG_CONTEXT;
+ RAISE NOTICE E'--- Call Stack ---\n%', stack;
+ RETURN 1;
+END;
+$$ LANGUAGE plpgsql;
+
+SELECT outer_func();
+
+NOTICE: --- Call Stack ---
+PL/pgSQL function inner_func() line 5 at GET DIAGNOSTICS
+PL/pgSQL function outer_func() line 3 at RETURN
+CONTEXT: PL/pgSQL function outer_func() line 3 at RETURN
+ outer_func
+ ------------
+ 1
+(1 row)
+
+
+
+ GET STACKED DIAGNOSTICS ... PG_EXCEPTION_CONTEXT
+ returns the same sort of stack trace, but describing the location
+ at which an error was detected, rather than the current location.
+
+ Rather than executing a whole query at once, it is possible to set
+ up a cursor that encapsulates the query, and then read
+ the query result a few rows at a time. One reason for doing this is
+ to avoid memory overrun when the result contains a large number of
+ rows. (However, PL/pgSQL users do not normally need
+ to worry about that, since FOR loops automatically use a cursor
+ internally to avoid memory problems.) A more interesting usage is to
+ return a reference to a cursor that a function has created, allowing the
+ caller to read the rows. This provides an efficient way to return
+ large row sets from functions.
+
43.7.1. Declaring Cursor Variables #
+ All access to cursors in PL/pgSQL goes through
+ cursor variables, which are always of the special data type
+ refcursor. One way to create a cursor variable
+ is just to declare it as a variable of type refcursor.
+ Another way is to use the cursor declaration syntax,
+ which in general is:
+
+name [ [ NO ] SCROLL ] CURSOR [ ( arguments ) ] FOR query;
+
+ (FOR can be replaced by IS for
+ Oracle compatibility.)
+ If SCROLL is specified, the cursor will be capable of
+ scrolling backward; if NO SCROLL is specified, backward
+ fetches will be rejected; if neither specification appears, it is
+ query-dependent whether backward fetches will be allowed.
+ arguments, if specified, is a
+ comma-separated list of pairs name
+ datatype
+ Some examples:
+
+DECLARE
+ curs1 refcursor;
+ curs2 CURSOR FOR SELECT * FROM tenk1;
+ curs3 CURSOR (key integer) FOR SELECT * FROM tenk1 WHERE unique1 = key;
+
+ All three of these variables have the data type refcursor,
+ but the first can be used with any query, while the second has
+ a fully specified query already bound to it, and the last
+ has a parameterized query bound to it. (key will be
+ replaced by an integer parameter value when the cursor is opened.)
+ The variable curs1
+ is said to be unbound since it is not bound to
+ any particular query.
+
+ The SCROLL option cannot be used when the cursor's
+ query uses FOR UPDATE/SHARE. Also, it is
+ best to use NO SCROLL with a query that involves
+ volatile functions. The implementation of SCROLL
+ assumes that re-reading the query's output will give consistent
+ results, which a volatile function might not do.
+
43.7.2. Opening Cursors #
+ Before a cursor can be used to retrieve rows, it must be
+ opened. (This is the equivalent action to the SQL
+ command DECLARE
+ CURSOR.)
+ PL/pgSQL has
+ three forms of the OPEN statement, two of which use unbound
+ cursor variables while the third uses a bound cursor variable.
+
Note
+ Bound cursor variables can also be used without explicitly opening the cursor,
+ via the FOR statement described in
+ Section 43.7.4.
+ A FOR loop will open the cursor and then
+ close it again when the loop completes.
+
+ Opening a cursor involves creating a server-internal data structure
+ called a portal, which holds the execution
+ state for the cursor's query. A portal has a name, which must be
+ unique within the session for the duration of the portal's existence.
+ By default, PL/pgSQL will assign a unique
+ name to each portal it creates. However, if you assign a non-null
+ string value to a cursor variable, that string will be used as its
+ portal name. This feature can be used as described in
+ Section 43.7.3.5.
+
43.7.2.1. OPEN FOR query #
+OPEN unbound_cursorvar [ [ NO ] SCROLL ] FOR query;
+
+ The cursor variable is opened and given the specified query to
+ execute. The cursor cannot be open already, and it must have been
+ declared as an unbound cursor variable (that is, as a simple
+ refcursor variable). The query must be a
+ SELECT, or something else that returns rows
+ (such as EXPLAIN). The query
+ is treated in the same way as other SQL commands in
+ PL/pgSQL: PL/pgSQL
+ variable names are substituted, and the query plan is cached for
+ possible reuse. When a PL/pgSQL
+ variable is substituted into the cursor query, the value that is
+ substituted is the one it has at the time of the OPEN;
+ subsequent changes to the variable will not affect the cursor's
+ behavior.
+ The SCROLL and NO SCROLL
+ options have the same meanings as for a bound cursor.
+
+ An example:
+
+OPEN curs1 FOR SELECT * FROM foo WHERE key = mykey;
+
+
43.7.2.2. OPEN FOR EXECUTE #
+OPEN unbound_cursorvar [ [ NO ] SCROLL ] FOR EXECUTE query_string
+ [ USING expression [, ... ] ];
+
+ The cursor variable is opened and given the specified query to
+ execute. The cursor cannot be open already, and it must have been
+ declared as an unbound cursor variable (that is, as a simple
+ refcursor variable). The query is specified as a string
+ expression, in the same way as in the EXECUTE
+ command. As usual, this gives flexibility so the query plan can vary
+ from one run to the next (see Section 43.11.2),
+ and it also means that variable substitution is not done on the
+ command string. As with EXECUTE, parameter values
+ can be inserted into the dynamic command via
+ format() and USING.
+ The SCROLL and
+ NO SCROLL options have the same meanings as for a bound
+ cursor.
+
+ An example:
+
+OPEN curs1 FOR EXECUTE format('SELECT * FROM %I WHERE col1 = $1',tabname) USING keyvalue;
+
+ In this example, the table name is inserted into the query via
+ format(). The comparison value for col1
+ is inserted via a USING parameter, so it needs
+ no quoting.
+
43.7.2.3. Opening a Bound Cursor #
+OPEN bound_cursorvar [ ( [ argument_name := ] argument_value [, ...] ) ];
+
+ This form of OPEN is used to open a cursor
+ variable whose query was bound to it when it was declared. The
+ cursor cannot be open already. A list of actual argument value
+ expressions must appear if and only if the cursor was declared to
+ take arguments. These values will be substituted in the query.
+
+ The query plan for a bound cursor is always considered cacheable;
+ there is no equivalent of EXECUTE in this case.
+ Notice that SCROLL and NO SCROLL cannot be
+ specified in OPEN, as the cursor's scrolling
+ behavior was already determined.
+
+ Argument values can be passed using either positional
+ or named notation. In positional
+ notation, all arguments are specified in order. In named notation,
+ each argument's name is specified using := to
+ separate it from the argument expression. Similar to calling
+ functions, described in Section 4.3, it
+ is also allowed to mix positional and named notation.
+
+ Examples (these use the cursor declaration examples above):
+
+OPEN curs2;
+OPEN curs3(42);
+OPEN curs3(key := 42);
+
+
+ Because variable substitution is done on a bound cursor's query,
+ there are really two ways to pass values into the cursor: either
+ with an explicit argument to OPEN, or implicitly by
+ referencing a PL/pgSQL variable in the query.
+ However, only variables declared before the bound cursor was
+ declared will be substituted into it. In either case the value to
+ be passed is determined at the time of the OPEN.
+ For example, another way to get the same effect as the
+ curs3 example above is
+
+DECLARE
+ key integer;
+ curs4 CURSOR FOR SELECT * FROM tenk1 WHERE unique1 = key;
+BEGIN
+ key := 42;
+ OPEN curs4;
+
+
+ Once a cursor has been opened, it can be manipulated with the
+ statements described here.
+
+ These manipulations need not occur in the same function that
+ opened the cursor to begin with. You can return a refcursor
+ value out of a function and let the caller operate on the cursor.
+ (Internally, a refcursor value is simply the string name
+ of the portal containing the active query for the cursor. This name
+ can be passed around, assigned to other refcursor variables,
+ and so on, without disturbing the portal.)
+
+ All portals are implicitly closed at transaction end. Therefore
+ a refcursor value is usable to reference an open cursor
+ only until the end of the transaction.
+
+FETCH [ direction { FROM | IN } ] cursor INTO target;
+
+ FETCH retrieves the next row from the
+ cursor into a target, which might be a row variable, a record
+ variable, or a comma-separated list of simple variables, just like
+ SELECT INTO. If there is no next row, the
+ target is set to NULL(s). As with SELECT
+ INTO, the special variable FOUND can
+ be checked to see whether a row was obtained or not.
+
+ The direction clause can be any of the
+ variants allowed in the SQL FETCH
+ command except the ones that can fetch
+ more than one row; namely, it can be
+ NEXT,
+ PRIOR,
+ FIRST,
+ LAST,
+ ABSOLUTE count,
+ RELATIVE count,
+ FORWARD, or
+ BACKWARD.
+ Omitting direction is the same
+ as specifying NEXT.
+ In the forms using a count,
+ the count can be any integer-valued
+ expression (unlike the SQL FETCH command,
+ which only allows an integer constant).
+ direction values that require moving
+ backward are likely to fail unless the cursor was declared or opened
+ with the SCROLL option.
+
+ cursor must be the name of a refcursor
+ variable that references an open cursor portal.
+
+ Examples:
+
+FETCH curs1 INTO rowvar;
+FETCH curs2 INTO foo, bar, baz;
+FETCH LAST FROM curs3 INTO x, y;
+FETCH RELATIVE -2 FROM curs4 INTO x;
+
+
+MOVE [ direction { FROM | IN } ] cursor;
+
+ MOVE repositions a cursor without retrieving
+ any data. MOVE works exactly like the
+ FETCH command, except it only repositions the
+ cursor and does not return the row moved to. As with SELECT
+ INTO, the special variable FOUND can
+ be checked to see whether there was a next row to move to.
+
+ Examples:
+
+MOVE curs1;
+MOVE LAST FROM curs3;
+MOVE RELATIVE -2 FROM curs4;
+MOVE FORWARD 2 FROM curs4;
+
+
43.7.3.3. UPDATE/DELETE WHERE CURRENT OF #
+UPDATE table SET ... WHERE CURRENT OF cursor;
+DELETE FROM table WHERE CURRENT OF cursor;
+
+ When a cursor is positioned on a table row, that row can be updated
+ or deleted using the cursor to identify the row. There are
+ restrictions on what the cursor's query can be (in particular,
+ no grouping) and it's best to use FOR UPDATE in the
+ cursor. For more information see the
+ DECLARE
+ reference page.
+
+ An example:
+
+UPDATE foo SET dataval = myval WHERE CURRENT OF curs1;
+
+
+CLOSE cursor;
+
+ CLOSE closes the portal underlying an open
+ cursor. This can be used to release resources earlier than end of
+ transaction, or to free up the cursor variable to be opened again.
+
+ An example:
+
+CLOSE curs1;
+
+
43.7.3.5. Returning Cursors #
+ PL/pgSQL functions can return cursors to the
+ caller. This is useful to return multiple rows or columns,
+ especially with very large result sets. To do this, the function
+ opens the cursor and returns the cursor name to the caller (or simply
+ opens the cursor using a portal name specified by or otherwise known
+ to the caller). The caller can then fetch rows from the cursor. The
+ cursor can be closed by the caller, or it will be closed automatically
+ when the transaction closes.
+
+ The portal name used for a cursor can be specified by the
+ programmer or automatically generated. To specify a portal name,
+ simply assign a string to the refcursor variable before
+ opening it. The string value of the refcursor variable
+ will be used by OPEN as the name of the underlying portal.
+ However, if the refcursor variable's value is null
+ (as it will be by default), then
+ OPEN automatically generates a name that does not
+ conflict with any existing portal, and assigns it to the
+ refcursor variable.
+
Note
+ Prior to PostgreSQL 16, bound cursor
+ variables were initialized to contain their own names, rather
+ than being left as null, so that the underlying portal name would
+ be the same as the cursor variable's name by default. This was
+ changed because it created too much risk of conflicts between
+ similarly-named cursors in different functions.
+
+ The following example shows one way a cursor name can be supplied by
+ the caller:
+
+
+CREATE TABLE test (col text);
+INSERT INTO test VALUES ('123');
+
+CREATE FUNCTION reffunc(refcursor) RETURNS refcursor AS '
+BEGIN
+ OPEN $1 FOR SELECT col FROM test;
+ RETURN $1;
+END;
+' LANGUAGE plpgsql;
+
+BEGIN;
+SELECT reffunc('funccursor');
+FETCH ALL IN funccursor;
+COMMIT;
+
+
+ The following example uses automatic cursor name generation:
+
+
+CREATE FUNCTION reffunc2() RETURNS refcursor AS '
+DECLARE
+ ref refcursor;
+BEGIN
+ OPEN ref FOR SELECT col FROM test;
+ RETURN ref;
+END;
+' LANGUAGE plpgsql;
+
+-- need to be in a transaction to use cursors.
+BEGIN;
+SELECT reffunc2();
+
+ reffunc2
+--------------------
+ <unnamed cursor 1>
+(1 row)
+
+FETCH ALL IN "<unnamed cursor 1>";
+COMMIT;
+
+
+ The following example shows one way to return multiple cursors
+ from a single function:
+
+
+CREATE FUNCTION myfunc(refcursor, refcursor) RETURNS SETOF refcursor AS $$
+BEGIN
+ OPEN $1 FOR SELECT * FROM table_1;
+ RETURN NEXT $1;
+ OPEN $2 FOR SELECT * FROM table_2;
+ RETURN NEXT $2;
+END;
+$$ LANGUAGE plpgsql;
+
+-- need to be in a transaction to use cursors.
+BEGIN;
+
+SELECT * FROM myfunc('a', 'b');
+
+FETCH ALL FROM a;
+FETCH ALL FROM b;
+COMMIT;
+
+
43.7.4. Looping through a Cursor's Result #
+ There is a variant of the FOR statement that allows
+ iterating through the rows returned by a cursor. The syntax is:
+
+
+[ <<label>> ]
+FOR recordvar IN bound_cursorvar [ ( [ argument_name := ] argument_value [, ...] ) ] LOOP
+ statements
+END LOOP [ label ];
+
+
+ The cursor variable must have been bound to some query when it was
+ declared, and it cannot be open already. The
+ FOR statement automatically opens the cursor, and it closes
+ the cursor again when the loop exits. A list of actual argument value
+ expressions must appear if and only if the cursor was declared to take
+ arguments. These values will be substituted in the query, in just
+ the same way as during an OPEN (see Section 43.7.2.3).
+
+ The variable recordvar is automatically
+ defined as type record and exists only inside the loop (any
+ existing definition of the variable name is ignored within the loop).
+ Each row returned by the cursor is successively assigned to this
+ record variable and the loop body is executed.
+
+ All variables used in a block must be declared in the
+ declarations section of the block.
+ (The only exceptions are that the loop variable of a FOR loop
+ iterating over a range of integer values is automatically declared as an
+ integer variable, and likewise the loop variable of a FOR loop
+ iterating over a cursor's result is automatically declared as a
+ record variable.)
+
+ PL/pgSQL variables can have any SQL data type, such as
+ integer, varchar, and
+ char.
+
+ Here are some examples of variable declarations:
+
+user_id integer;
+quantity numeric(5);
+url varchar;
+myrow tablename%ROWTYPE;
+myfield tablename.columnname%TYPE;
+arow RECORD;
+
+
+ The general syntax of a variable declaration is:
+
+name [ CONSTANT ] type [ COLLATE collation_name ] [ NOT NULL ] [ { DEFAULT | := | = } expression ];
+
+ The DEFAULT clause, if given, specifies the initial value assigned
+ to the variable when the block is entered. If the DEFAULT clause
+ is not given then the variable is initialized to the
+ SQL null value.
+ The CONSTANT option prevents the variable from being
+ assigned to after initialization, so that its value will remain constant
+ for the duration of the block.
+ The COLLATE option specifies a collation to use for the
+ variable (see Section 43.3.6).
+ If NOT NULL
+ is specified, an assignment of a null value results in a run-time
+ error. All variables declared as NOT NULL
+ must have a nonnull default value specified.
+ Equal (=) can be used instead of PL/SQL-compliant
+ :=.
+
+ A variable's default value is evaluated and assigned to the variable
+ each time the block is entered (not just once per function call).
+ So, for example, assigning now() to a variable of type
+ timestamp causes the variable to have the
+ time of the current function call, not the time when the function was
+ precompiled.
+
+ Examples:
+
+quantity integer DEFAULT 32;
+url varchar := 'http://mysite.com';
+transaction_time CONSTANT timestamp with time zone := now();
+
+
+ Once declared, a variable's value can be used in later initialization
+ expressions in the same block, for example:
+
+DECLARE
+ x integer := 1;
+ y integer := x + 1;
+
+
43.3.1. Declaring Function Parameters #
+ Parameters passed to functions are named with the identifiers
+ $1, $2,
+ etc. Optionally, aliases can be declared for
+ $n
+ parameter names for increased readability. Either the alias or the
+ numeric identifier can then be used to refer to the parameter value.
+
+ There are two ways to create an alias. The preferred way is to give a
+ name to the parameter in the CREATE FUNCTION command,
+ for example:
+
+CREATE FUNCTION sales_tax(subtotal real) RETURNS real AS $$
+BEGIN
+ RETURN subtotal * 0.06;
+END;
+$$ LANGUAGE plpgsql;
+
+ The other way is to explicitly declare an alias, using the
+ declaration syntax
+
+
+name ALIAS FOR $n;
+
+
+ The same example in this style looks like:
+
+CREATE FUNCTION sales_tax(real) RETURNS real AS $$
+DECLARE
+ subtotal ALIAS FOR $1;
+BEGIN
+ RETURN subtotal * 0.06;
+END;
+$$ LANGUAGE plpgsql;
+
+
Note
+ These two examples are not perfectly equivalent. In the first case,
+ subtotal could be referenced as
+ sales_tax.subtotal, but in the second case it could not.
+ (Had we attached a label to the inner block, subtotal could
+ be qualified with that label, instead.)
+
+ Some more examples:
+
+CREATE FUNCTION instr(varchar, integer) RETURNS integer AS $$
+DECLARE
+ v_string ALIAS FOR $1;
+ index ALIAS FOR $2;
+BEGIN
+ -- some computations using v_string and index here
+END;
+$$ LANGUAGE plpgsql;
+
+
+CREATE FUNCTION concat_selected_fields(in_t sometablename) RETURNS text AS $$
+BEGIN
+ RETURN in_t.f1 || in_t.f3 || in_t.f5 || in_t.f7;
+END;
+$$ LANGUAGE plpgsql;
+
+
+ When a PL/pgSQL function is declared
+ with output parameters, the output parameters are given
+ $n names and optional
+ aliases in just the same way as the normal input parameters. An
+ output parameter is effectively a variable that starts out NULL;
+ it should be assigned to during the execution of the function.
+ The final value of the parameter is what is returned. For instance,
+ the sales-tax example could also be done this way:
+
+
+CREATE FUNCTION sales_tax(subtotal real, OUT tax real) AS $$
+BEGIN
+ tax := subtotal * 0.06;
+END;
+$$ LANGUAGE plpgsql;
+
+
+ Notice that we omitted RETURNS real — we could have
+ included it, but it would be redundant.
+
+ To call a function with OUT parameters, omit the
+ output parameter(s) in the function call:
+
+SELECT sales_tax(100.00);
+
+
+ Output parameters are most useful when returning multiple values.
+ A trivial example is:
+
+
+CREATE FUNCTION sum_n_product(x int, y int, OUT sum int, OUT prod int) AS $$
+BEGIN
+ sum := x + y;
+ prod := x * y;
+END;
+$$ LANGUAGE plpgsql;
+
+SELECT * FROM sum_n_product(2, 4);
+ sum | prod
+-----+------
+ 6 | 8
+
+
+ As discussed in Section 38.5.4, this
+ effectively creates an anonymous record type for the function's
+ results. If a RETURNS clause is given, it must say
+ RETURNS record.
+
+ This also works with procedures, for example:
+
+
+CREATE PROCEDURE sum_n_product(x int, y int, OUT sum int, OUT prod int) AS $$
+BEGIN
+ sum := x + y;
+ prod := x * y;
+END;
+$$ LANGUAGE plpgsql;
+
+
+ In a call to a procedure, all the parameters must be specified. For
+ output parameters, NULL may be specified when
+ calling the procedure from plain SQL:
+
+CALL sum_n_product(2, 4, NULL, NULL);
+ sum | prod
+-----+------
+ 6 | 8
+
+
+ However, when calling a procedure
+ from PL/pgSQL, you should instead write a
+ variable for any output parameter; the variable will receive the result
+ of the call. See Section 43.6.3
+ for details.
+
+ Another way to declare a PL/pgSQL function
+ is with RETURNS TABLE, for example:
+
+
+CREATE FUNCTION extended_sales(p_itemno int)
+RETURNS TABLE(quantity int, total numeric) AS $$
+BEGIN
+ RETURN QUERY SELECT s.quantity, s.quantity * s.price FROM sales AS s
+ WHERE s.itemno = p_itemno;
+END;
+$$ LANGUAGE plpgsql;
+
+
+ This is exactly equivalent to declaring one or more OUT
+ parameters and specifying RETURNS SETOF
+ sometype.
+
+ When the return type of a PL/pgSQL function
+ is declared as a polymorphic type (see
+ Section 38.2.5), a special
+ parameter $0 is created. Its data type is the actual
+ return type of the function, as deduced from the actual input types.
+ This allows the function to access its actual return type
+ as shown in Section 43.3.3.
+ $0 is initialized to null and can be modified by
+ the function, so it can be used to hold the return value if desired,
+ though that is not required. $0 can also be
+ given an alias. For example, this function works on any data type
+ that has a + operator:
+
+
+CREATE FUNCTION add_three_values(v1 anyelement, v2 anyelement, v3 anyelement)
+RETURNS anyelement AS $$
+DECLARE
+ result ALIAS FOR $0;
+BEGIN
+ result := v1 + v2 + v3;
+ RETURN result;
+END;
+$$ LANGUAGE plpgsql;
+
+
+ The same effect can be obtained by declaring one or more output parameters as
+ polymorphic types. In this case the
+ special $0 parameter is not used; the output
+ parameters themselves serve the same purpose. For example:
+
+
+CREATE FUNCTION add_three_values(v1 anyelement, v2 anyelement, v3 anyelement,
+ OUT sum anyelement)
+AS $$
+BEGIN
+ sum := v1 + v2 + v3;
+END;
+$$ LANGUAGE plpgsql;
+
+
+ In practice it might be more useful to declare a polymorphic function
+ using the anycompatible family of types, so that automatic
+ promotion of the input arguments to a common type will occur.
+ For example:
+
+
+CREATE FUNCTION add_three_values(v1 anycompatible, v2 anycompatible, v3 anycompatible)
+RETURNS anycompatible AS $$
+BEGIN
+ RETURN v1 + v2 + v3;
+END;
+$$ LANGUAGE plpgsql;
+
+
+ With this example, a call such as
+
+
+SELECT add_three_values(1, 2, 4.7);
+
+
+ will work, automatically promoting the integer inputs to numeric.
+ The function using anyelement would require you to
+ cast the three inputs to the same type manually.
+
+newname ALIAS FOR oldname;
+
+ The ALIAS syntax is more general than is suggested in the
+ previous section: you can declare an alias for any variable, not just
+ function parameters. The main practical use for this is to assign
+ a different name for variables with predetermined names, such as
+ NEW or OLD within
+ a trigger function.
+
+ Examples:
+
+DECLARE
+ prior ALIAS FOR old;
+ updated ALIAS FOR new;
+
+
+ Since ALIAS creates two different ways to name the same
+ object, unrestricted use can be confusing. It's best to use it only
+ for the purpose of overriding predetermined names.
+
+variable%TYPE
+
+ %TYPE provides the data type of a variable or
+ table column. You can use this to declare variables that will hold
+ database values. For example, let's say you have a column named
+ user_id in your users
+ table. To declare a variable with the same data type as
+ users.user_id you write:
+
+user_id users.user_id%TYPE;
+
+
+ By using %TYPE you don't need to know the data
+ type of the structure you are referencing, and most importantly,
+ if the data type of the referenced item changes in the future (for
+ instance: you change the type of user_id
+ from integer to real), you might not need
+ to change your function definition.
+
+ %TYPE is particularly valuable in polymorphic
+ functions, since the data types needed for internal variables can
+ change from one call to the next. Appropriate variables can be
+ created by applying %TYPE to the function's
+ arguments or result placeholders.
+
+name table_name%ROWTYPE;
+name composite_type_name;
+
+ A variable of a composite type is called a row
+ variable (or row-type variable). Such a variable
+ can hold a whole row of a SELECT or FOR
+ query result, so long as that query's column set matches the
+ declared type of the variable.
+ The individual fields of the row value
+ are accessed using the usual dot notation, for example
+ rowvar.field.
+
+ A row variable can be declared to have the same type as the rows of
+ an existing table or view, by using the
+ table_name%ROWTYPE
+ notation; or it can be declared by giving a composite type's name.
+ (Since every table has an associated composite type of the same name,
+ it actually does not matter in PostgreSQL whether you
+ write %ROWTYPE or not. But the form with
+ %ROWTYPE is more portable.)
+
+ Parameters to a function can be
+ composite types (complete table rows). In that case, the
+ corresponding identifier $n will be a row variable, and fields can
+ be selected from it, for example $1.user_id.
+
+ Here is an example of using composite types. table1
+ and table2 are existing tables having at least the
+ mentioned fields:
+
+
+CREATE FUNCTION merge_fields(t_row table1) RETURNS text AS $$
+DECLARE
+ t2_row table2%ROWTYPE;
+BEGIN
+ SELECT * INTO t2_row FROM table2 WHERE ... ;
+ RETURN t_row.f1 || t2_row.f3 || t_row.f5 || t2_row.f7;
+END;
+$$ LANGUAGE plpgsql;
+
+SELECT merge_fields(t.*) FROM table1 t WHERE ... ;
+
+
+name RECORD;
+
+ Record variables are similar to row-type variables, but they have no
+ predefined structure. They take on the actual row structure of the
+ row they are assigned during a SELECT or FOR command. The substructure
+ of a record variable can change each time it is assigned to.
+ A consequence of this is that until a record variable is first assigned
+ to, it has no substructure, and any attempt to access a
+ field in it will draw a run-time error.
+
+ Note that RECORD is not a true data type, only a placeholder.
+ One should also realize that when a PL/pgSQL
+ function is declared to return type record, this is not quite the
+ same concept as a record variable, even though such a function might
+ use a record variable to hold its result. In both cases the actual row
+ structure is unknown when the function is written, but for a function
+ returning record the actual structure is determined when the
+ calling query is parsed, whereas a record variable can change its row
+ structure on-the-fly.
+
43.3.6. Collation of PL/pgSQL Variables #
+ When a PL/pgSQL function has one or more
+ parameters of collatable data types, a collation is identified for each
+ function call depending on the collations assigned to the actual
+ arguments, as described in Section 24.2. If a collation is
+ successfully identified (i.e., there are no conflicts of implicit
+ collations among the arguments) then all the collatable parameters are
+ treated as having that collation implicitly. This will affect the
+ behavior of collation-sensitive operations within the function.
+ For example, consider
+
+
+CREATE FUNCTION less_than(a text, b text) RETURNS boolean AS $$
+BEGIN
+ RETURN a < b;
+END;
+$$ LANGUAGE plpgsql;
+
+SELECT less_than(text_field_1, text_field_2) FROM table1;
+SELECT less_than(text_field_1, text_field_2 COLLATE "C") FROM table1;
+
+
+ The first use of less_than will use the common collation
+ of text_field_1 and text_field_2 for
+ the comparison, while the second use will use C collation.
+
+ Furthermore, the identified collation is also assumed as the collation of
+ any local variables that are of collatable types. Thus this function
+ would not work any differently if it were written as
+
+
+CREATE FUNCTION less_than(a text, b text) RETURNS boolean AS $$
+DECLARE
+ local_a text := a;
+ local_b text := b;
+BEGIN
+ RETURN local_a < local_b;
+END;
+$$ LANGUAGE plpgsql;
+
+
+ If there are no parameters of collatable data types, or no common
+ collation can be identified for them, then parameters and local variables
+ use the default collation of their data type (which is usually the
+ database's default collation, but could be different for variables of
+ domain types).
+
+ A local variable of a collatable data type can have a different collation
+ associated with it by including the COLLATE option in its
+ declaration, for example
+
+
+DECLARE
+ local_a text COLLATE "en_US";
+
+
+ This option overrides the collation that would otherwise be
+ given to the variable according to the rules above.
+
+ Also, of course explicit COLLATE clauses can be written inside
+ a function if it is desired to force a particular collation to be used in
+ a particular operation. For example,
+
+
+CREATE FUNCTION less_than_c(a text, b text) RETURNS boolean AS $$
+BEGIN
+ RETURN a < b COLLATE "C";
+END;
+$$ LANGUAGE plpgsql;
+
+
+ This overrides the collations associated with the table columns,
+ parameters, or local variables used in the expression, just as would
+ happen in a plain SQL command.
+
43.12. Tips for Developing in PL/pgSQL #
+ One good way to develop in
+ PL/pgSQL is to use the text editor of your
+ choice to create your functions, and in another window, use
+ psql to load and test those functions.
+ If you are doing it this way, it
+ is a good idea to write the function using CREATE OR
+ REPLACE FUNCTION. That way you can just reload the file to update
+ the function definition. For example:
+
+CREATE OR REPLACE FUNCTION testfunc(integer) RETURNS integer AS $$
+ ....
+$$ LANGUAGE plpgsql;
+
+
+ While running psql, you can load or reload such
+ a function definition file with:
+
+\i filename.sql
+
+ and then immediately issue SQL commands to test the function.
+
+ Another good way to develop in PL/pgSQL is with a
+ GUI database access tool that facilitates development in a
+ procedural language. One example of such a tool is
+ pgAdmin, although others exist. These tools often
+ provide convenient features such as escaping single quotes and
+ making it easier to recreate and debug functions.
+
43.12.1. Handling of Quotation Marks #
+ The code of a PL/pgSQL function is specified in
+ CREATE FUNCTION as a string literal. If you
+ write the string literal in the ordinary way with surrounding
+ single quotes, then any single quotes inside the function body
+ must be doubled; likewise any backslashes must be doubled (assuming
+ escape string syntax is used).
+ Doubling quotes is at best tedious, and in more complicated cases
+ the code can become downright incomprehensible, because you can
+ easily find yourself needing half a dozen or more adjacent quote marks.
+ It's recommended that you instead write the function body as a
+ “dollar-quoted” string literal (see Section 4.1.2.4). In the dollar-quoting
+ approach, you never double any quote marks, but instead take care to
+ choose a different dollar-quoting delimiter for each level of
+ nesting you need. For example, you might write the CREATE
+ FUNCTION command as:
+
+CREATE OR REPLACE FUNCTION testfunc(integer) RETURNS integer AS $PROC$
+ ....
+$PROC$ LANGUAGE plpgsql;
+
+ Within this, you might use quote marks for simple literal strings in
+ SQL commands and $$ to delimit fragments of SQL commands
+ that you are assembling as strings. If you need to quote text that
+ includes $$, you could use $Q$, and so on.
+
+ The following chart shows what you have to do when writing quote
+ marks without dollar quoting. It might be useful when translating
+ pre-dollar quoting code into something more comprehensible.
+
- 1 quotation mark #
+ To begin and end the function body, for example:
+
+CREATE FUNCTION foo() RETURNS integer AS '
+ ....
+' LANGUAGE plpgsql;
+
+ Anywhere within a single-quoted function body, quote marks
+ must appear in pairs.
+
- 2 quotation marks #
+ For string literals inside the function body, for example:
+
+a_output := ''Blah'';
+SELECT * FROM users WHERE f_name=''foobar'';
+
+ In the dollar-quoting approach, you'd just write:
+
+a_output := 'Blah';
+SELECT * FROM users WHERE f_name='foobar';
+
+ which is exactly what the PL/pgSQL parser would see
+ in either case.
+
- 4 quotation marks #
+ When you need a single quotation mark in a string constant inside the
+ function body, for example:
+
+a_output := a_output || '' AND name LIKE ''''foobar'''' AND xyz''
+
+ The value actually appended to a_output would be:
+ AND name LIKE 'foobar' AND xyz.
+
+ In the dollar-quoting approach, you'd write:
+
+a_output := a_output || $$ AND name LIKE 'foobar' AND xyz$$
+
+ being careful that any dollar-quote delimiters around this are not
+ just $$.
+
- 6 quotation marks #
+ When a single quotation mark in a string inside the function body is
+ adjacent to the end of that string constant, for example:
+
+a_output := a_output || '' AND name LIKE ''''foobar''''''
+
+ The value appended to a_output would then be:
+ AND name LIKE 'foobar'.
+
+ In the dollar-quoting approach, this becomes:
+
+a_output := a_output || $$ AND name LIKE 'foobar'$$
+
+
- 10 quotation marks #
+ When you want two single quotation marks in a string constant (which
+ accounts for 8 quotation marks) and this is adjacent to the end of that
+ string constant (2 more). You will probably only need that if
+ you are writing a function that generates other functions, as in
+ Example 43.10.
+ For example:
+
+a_output := a_output || '' if v_'' ||
+ referrer_keys.kind || '' like ''''''''''
+ || referrer_keys.key_string || ''''''''''
+ then return '''''' || referrer_keys.referrer_type
+ || ''''''; end if;'';
+
+ The value of a_output would then be:
+
+if v_... like ''...'' then return ''...''; end if;
+
+
+ In the dollar-quoting approach, this becomes:
+
+a_output := a_output || $$ if v_$$ || referrer_keys.kind || $$ like '$$
+ || referrer_keys.key_string || $$'
+ then return '$$ || referrer_keys.referrer_type
+ || $$'; end if;$$;
+
+ where we assume we only need to put single quote marks into
+ a_output, because it will be re-quoted before use.
+
43.9. Errors and Messages #
43.9.1. Reporting Errors and Messages #
+ Use the RAISE statement to report messages and
+ raise errors.
+
+
+RAISE [ level ] 'format' [, expression [, ... ]] [ USING option = expression [, ... ] ];
+RAISE [ level ] condition_name [ USING option = expression [, ... ] ];
+RAISE [ level ] SQLSTATE 'sqlstate' [ USING option = expression [, ... ] ];
+RAISE [ level ] USING option = expression [, ... ];
+RAISE ;
+
+
+ The level option specifies
+ the error severity. Allowed levels are DEBUG,
+ LOG, INFO,
+ NOTICE, WARNING,
+ and EXCEPTION, with EXCEPTION
+ being the default.
+ EXCEPTION raises an error (which normally aborts the
+ current transaction); the other levels only generate messages of different
+ priority levels.
+ Whether messages of a particular priority are reported to the client,
+ written to the server log, or both is controlled by the
+ log_min_messages and
+ client_min_messages configuration
+ variables. See Chapter 20 for more
+ information.
+
+ After level if any,
+ you can specify a format string
+ (which must be a simple string literal, not an expression). The
+ format string specifies the error message text to be reported.
+ The format string can be followed
+ by optional argument expressions to be inserted into the message.
+ Inside the format string, % is replaced by the
+ string representation of the next optional argument's value. Write
+ %% to emit a literal %.
+ The number of arguments must match the number of %
+ placeholders in the format string, or an error is raised during
+ the compilation of the function.
+
+ In this example, the value of v_job_id will replace the
+ % in the string:
+
+RAISE NOTICE 'Calling cs_create_job(%)', v_job_id;
+
+
+ You can attach additional information to the error report by writing
+ USING followed by option = expression items. Each
+ expression can be any
+ string-valued expression. The allowed option key words are:
+
+
MESSAGE #Sets the error message text. This option can't be used in the
+ form of RAISE that includes a format string
+ before USING.
DETAIL #Supplies an error detail message.
HINT #Supplies a hint message.
ERRCODE #Specifies the error code (SQLSTATE) to report, either by condition
+ name, as shown in Appendix A, or directly as a
+ five-character SQLSTATE code.
COLUMN
CONSTRAINT
DATATYPE
TABLE
SCHEMA #Supplies the name of a related object.
+
+ This example will abort the transaction with the given error message
+ and hint:
+
+RAISE EXCEPTION 'Nonexistent ID --> %', user_id
+ USING HINT = 'Please check your user ID';
+
+
+ These two examples show equivalent ways of setting the SQLSTATE:
+
+RAISE 'Duplicate user ID: %', user_id USING ERRCODE = 'unique_violation';
+RAISE 'Duplicate user ID: %', user_id USING ERRCODE = '23505';
+
+
+ There is a second RAISE syntax in which the main argument
+ is the condition name or SQLSTATE to be reported, for example:
+
+RAISE division_by_zero;
+RAISE SQLSTATE '22012';
+
+ In this syntax, USING can be used to supply a custom
+ error message, detail, or hint. Another way to do the earlier
+ example is
+
+RAISE unique_violation USING MESSAGE = 'Duplicate user ID: ' || user_id;
+
+
+ Still another variant is to write RAISE USING or RAISE
+ level USING and put
+ everything else into the USING list.
+
+ The last variant of RAISE has no parameters at all.
+ This form can only be used inside a BEGIN block's
+ EXCEPTION clause;
+ it causes the error currently being handled to be re-thrown.
+
Note
+ Before PostgreSQL 9.1, RAISE without
+ parameters was interpreted as re-throwing the error from the block
+ containing the active exception handler. Thus an EXCEPTION
+ clause nested within that handler could not catch it, even if the
+ RAISE was within the nested EXCEPTION clause's
+ block. This was deemed surprising as well as being incompatible with
+ Oracle's PL/SQL.
+
+ If no condition name nor SQLSTATE is specified in a
+ RAISE EXCEPTION command, the default is to use
+ raise_exception (P0001).
+ If no message text is specified, the default is to use the condition
+ name or SQLSTATE as message text.
+
Note
+ When specifying an error code by SQLSTATE code, you are not
+ limited to the predefined error codes, but can select any
+ error code consisting of five digits and/or upper-case ASCII
+ letters, other than 00000. It is recommended that
+ you avoid throwing error codes that end in three zeroes, because
+ these are category codes and can only be trapped by trapping
+ the whole category.
+
43.9.2. Checking Assertions #
+ The ASSERT statement is a convenient shorthand for
+ inserting debugging checks into PL/pgSQL
+ functions.
+
+
+ASSERT condition [ , message ];
+
+
+ The condition is a Boolean
+ expression that is expected to always evaluate to true; if it does,
+ the ASSERT statement does nothing further. If the
+ result is false or null, then an ASSERT_FAILURE exception
+ is raised. (If an error occurs while evaluating
+ the condition, it is
+ reported as a normal error.)
+
+ If the optional message is
+ provided, it is an expression whose result (if not null) replaces the
+ default error message text “assertion failed”, should
+ the condition fail.
+ The message expression is
+ not evaluated in the normal case where the assertion succeeds.
+
+ Testing of assertions can be enabled or disabled via the configuration
+ parameter plpgsql.check_asserts, which takes a Boolean
+ value; the default is on. If this parameter
+ is off then ASSERT statements do nothing.
+
+ Note that ASSERT is meant for detecting program
+ bugs, not for reporting ordinary error conditions. Use
+ the RAISE statement, described above, for that.
+
+ All expressions used in PL/pgSQL
+ statements are processed using the server's main
+ SQL executor. For example, when you write
+ a PL/pgSQL statement like
+
+IF expression THEN ...
+
+ PL/pgSQL will evaluate the expression by
+ feeding a query like
+
+SELECT expression
+
+ to the main SQL engine. While forming the SELECT command,
+ any occurrences of PL/pgSQL variable names
+ are replaced by query parameters, as discussed in detail in
+ Section 43.11.1.
+ This allows the query plan for the SELECT to
+ be prepared just once and then reused for subsequent
+ evaluations with different values of the variables. Thus, what
+ really happens on first use of an expression is essentially a
+ PREPARE command. For example, if we have declared
+ two integer variables x and y, and we write
+
+IF x < y THEN ...
+
+ what happens behind the scenes is equivalent to
+
+PREPARE statement_name(integer, integer) AS SELECT $1 < $2;
+
+ and then this prepared statement is EXECUTEd for each
+ execution of the IF statement, with the current values
+ of the PL/pgSQL variables supplied as
+ parameter values. Normally these details are
+ not important to a PL/pgSQL user, but
+ they are useful to know when trying to diagnose a problem.
+ More information appears in Section 43.11.2.
+
+ Since an expression is converted to a
+ SELECT command, it can contain the same clauses
+ that an ordinary SELECT would, except that it
+ cannot include a top-level UNION,
+ INTERSECT, or EXCEPT clause.
+ Thus for example one could test whether a table is non-empty with
+
+IF count(*) > 0 FROM my_table THEN ...
+
+ since the expression
+ between IF and THEN is parsed as
+ though it were SELECT count(*) > 0 FROM my_table.
+ The SELECT must produce a single column, and not
+ more than one row. (If it produces no rows, the result is taken as
+ NULL.)
+
43.11. PL/pgSQL under the Hood #
+ This section discusses some implementation details that are
+ frequently important for PL/pgSQL users to know.
+
43.11.1. Variable Substitution #
+ SQL statements and expressions within a PL/pgSQL function
+ can refer to variables and parameters of the function. Behind the scenes,
+ PL/pgSQL substitutes query parameters for such references.
+ Query parameters will only be substituted in places where they are
+ syntactically permissible. As an extreme case, consider
+ this example of poor programming style:
+
+INSERT INTO foo (foo) VALUES (foo(foo));
+
+ The first occurrence of foo must syntactically be a table
+ name, so it will not be substituted, even if the function has a variable
+ named foo. The second occurrence must be the name of a
+ column of that table, so it will not be substituted either. Likewise
+ the third occurrence must be a function name, so it also will not be
+ substituted for. Only the last occurrence is a candidate to be a
+ reference to a variable of the PL/pgSQL
+ function.
+
+ Another way to understand this is that variable substitution can only
+ insert data values into an SQL command; it cannot dynamically change which
+ database objects are referenced by the command. (If you want to do
+ that, you must build a command string dynamically, as explained in
+ Section 43.5.4.)
+
+ Since the names of variables are syntactically no different from the names
+ of table columns, there can be ambiguity in statements that also refer to
+ tables: is a given name meant to refer to a table column, or a variable?
+ Let's change the previous example to
+
+INSERT INTO dest (col) SELECT foo + bar FROM src;
+
+ Here, dest and src must be table names, and
+ col must be a column of dest, but foo
+ and bar might reasonably be either variables of the function
+ or columns of src.
+
+ By default, PL/pgSQL will report an error if a name
+ in an SQL statement could refer to either a variable or a table column.
+ You can fix such a problem by renaming the variable or column,
+ or by qualifying the ambiguous reference, or by telling
+ PL/pgSQL which interpretation to prefer.
+
+ The simplest solution is to rename the variable or column.
+ A common coding rule is to use a
+ different naming convention for PL/pgSQL
+ variables than you use for column names. For example,
+ if you consistently name function variables
+ v_something while none of your
+ column names start with v_, no conflicts will occur.
+
+ Alternatively you can qualify ambiguous references to make them clear.
+ In the above example, src.foo would be an unambiguous reference
+ to the table column. To create an unambiguous reference to a variable,
+ declare it in a labeled block and use the block's label
+ (see Section 43.2). For example,
+
+<<block>>
+DECLARE
+ foo int;
+BEGIN
+ foo := ...;
+ INSERT INTO dest (col) SELECT block.foo + bar FROM src;
+
+ Here block.foo means the variable even if there is a column
+ foo in src. Function parameters, as well as
+ special variables such as FOUND, can be qualified by the
+ function's name, because they are implicitly declared in an outer block
+ labeled with the function's name.
+
+ Sometimes it is impractical to fix all the ambiguous references in a
+ large body of PL/pgSQL code. In such cases you can
+ specify that PL/pgSQL should resolve ambiguous references
+ as the variable (which is compatible with PL/pgSQL's
+ behavior before PostgreSQL 9.0), or as the
+ table column (which is compatible with some other systems such as
+ Oracle).
+
+ To change this behavior on a system-wide basis, set the configuration
+ parameter plpgsql.variable_conflict to one of
+ error, use_variable, or
+ use_column (where error is the factory default).
+ This parameter affects subsequent compilations
+ of statements in PL/pgSQL functions, but not statements
+ already compiled in the current session.
+ Because changing this setting
+ can cause unexpected changes in the behavior of PL/pgSQL
+ functions, it can only be changed by a superuser.
+
+ You can also set the behavior on a function-by-function basis, by
+ inserting one of these special commands at the start of the function
+ text:
+
+#variable_conflict error
+#variable_conflict use_variable
+#variable_conflict use_column
+
+ These commands affect only the function they are written in, and override
+ the setting of plpgsql.variable_conflict. An example is
+
+CREATE FUNCTION stamp_user(id int, comment text) RETURNS void AS $$
+ #variable_conflict use_variable
+ DECLARE
+ curtime timestamp := now();
+ BEGIN
+ UPDATE users SET last_modified = curtime, comment = comment
+ WHERE users.id = id;
+ END;
+$$ LANGUAGE plpgsql;
+
+ In the UPDATE command, curtime, comment,
+ and id will refer to the function's variable and parameters
+ whether or not users has columns of those names. Notice
+ that we had to qualify the reference to users.id in the
+ WHERE clause to make it refer to the table column.
+ But we did not have to qualify the reference to comment
+ as a target in the UPDATE list, because syntactically
+ that must be a column of users. We could write the same
+ function without depending on the variable_conflict setting
+ in this way:
+
+CREATE FUNCTION stamp_user(id int, comment text) RETURNS void AS $$
+ <<fn>>
+ DECLARE
+ curtime timestamp := now();
+ BEGIN
+ UPDATE users SET last_modified = fn.curtime, comment = stamp_user.comment
+ WHERE users.id = stamp_user.id;
+ END;
+$$ LANGUAGE plpgsql;
+
+
+ Variable substitution does not happen in a command string given
+ to EXECUTE or one of its variants. If you need to
+ insert a varying value into such a command, do so as part of
+ constructing the string value, or use USING, as illustrated in
+ Section 43.5.4.
+
+ Variable substitution currently works only in SELECT,
+ INSERT, UPDATE,
+ DELETE, and commands containing one of
+ these (such as EXPLAIN and CREATE TABLE
+ ... AS SELECT),
+ because the main SQL engine allows query parameters only in these
+ commands. To use a non-constant name or value in other statement
+ types (generically called utility statements), you must construct
+ the utility statement as a string and EXECUTE it.
+
+ The PL/pgSQL interpreter parses the function's source
+ text and produces an internal binary instruction tree the first time the
+ function is called (within each session). The instruction tree
+ fully translates the
+ PL/pgSQL statement structure, but individual
+ SQL expressions and SQL commands
+ used in the function are not translated immediately.
+
+
+ As each expression and SQL command is first
+ executed in the function, the PL/pgSQL interpreter
+ parses and analyzes the command to create a prepared statement,
+ using the SPI manager's
+ SPI_prepare function.
+ Subsequent visits to that expression or command
+ reuse the prepared statement. Thus, a function with conditional code
+ paths that are seldom visited will never incur the overhead of
+ analyzing those commands that are never executed within the current
+ session. A disadvantage is that errors
+ in a specific expression or command cannot be detected until that
+ part of the function is reached in execution. (Trivial syntax
+ errors will be detected during the initial parsing pass, but
+ anything deeper will not be detected until execution.)
+
+ PL/pgSQL (or more precisely, the SPI manager) can
+ furthermore attempt to cache the execution plan associated with any
+ particular prepared statement. If a cached plan is not used, then
+ a fresh execution plan is generated on each visit to the statement,
+ and the current parameter values (that is, PL/pgSQL
+ variable values) can be used to optimize the selected plan. If the
+ statement has no parameters, or is executed many times, the SPI manager
+ will consider creating a generic plan that is not dependent
+ on specific parameter values, and caching that for re-use. Typically
+ this will happen only if the execution plan is not very sensitive to
+ the values of the PL/pgSQL variables referenced in it.
+ If it is, generating a plan each time is a net win. See PREPARE for more information about the behavior of
+ prepared statements.
+
+ Because PL/pgSQL saves prepared statements
+ and sometimes execution plans in this way,
+ SQL commands that appear directly in a
+ PL/pgSQL function must refer to the
+ same tables and columns on every execution; that is, you cannot use
+ a parameter as the name of a table or column in an SQL command. To get
+ around this restriction, you can construct dynamic commands using
+ the PL/pgSQL EXECUTE
+ statement — at the price of performing new parse analysis and
+ constructing a new execution plan on every execution.
+
+ The mutable nature of record variables presents another problem in this
+ connection. When fields of a record variable are used in
+ expressions or statements, the data types of the fields must not
+ change from one call of the function to the next, since each
+ expression will be analyzed using the data type that is present
+ when the expression is first reached. EXECUTE can be
+ used to get around this problem when necessary.
+
+ If the same function is used as a trigger for more than one table,
+ PL/pgSQL prepares and caches statements
+ independently for each such table — that is, there is a cache
+ for each trigger function and table combination, not just for each
+ function. This alleviates some of the problems with varying
+ data types; for instance, a trigger function will be able to work
+ successfully with a column named key even if it happens
+ to have different types in different tables.
+
+ Likewise, functions having polymorphic argument types have a separate
+ statement cache for each combination of actual argument types they have
+ been invoked for, so that data type differences do not cause unexpected
+ failures.
+
+ Statement caching can sometimes have surprising effects on the
+ interpretation of time-sensitive values. For example there
+ is a difference between what these two functions do:
+
+
+CREATE FUNCTION logfunc1(logtxt text) RETURNS void AS $$
+ BEGIN
+ INSERT INTO logtable VALUES (logtxt, 'now');
+ END;
+$$ LANGUAGE plpgsql;
+
+
+ and:
+
+
+CREATE FUNCTION logfunc2(logtxt text) RETURNS void AS $$
+ DECLARE
+ curtime timestamp;
+ BEGIN
+ curtime := 'now';
+ INSERT INTO logtable VALUES (logtxt, curtime);
+ END;
+$$ LANGUAGE plpgsql;
+
+
+ In the case of logfunc1, the
+ PostgreSQL main parser knows when
+ analyzing the INSERT that the
+ string 'now' should be interpreted as
+ timestamp, because the target column of
+ logtable is of that type. Thus,
+ 'now' will be converted to a timestamp
+ constant when the
+ INSERT is analyzed, and then used in all
+ invocations of logfunc1 during the lifetime
+ of the session. Needless to say, this isn't what the programmer
+ wanted. A better idea is to use the now() or
+ current_timestamp function.
+
+ In the case of logfunc2, the
+ PostgreSQL main parser does not know
+ what type 'now' should become and therefore
+ it returns a data value of type text containing the string
+ now. During the ensuing assignment
+ to the local variable curtime, the
+ PL/pgSQL interpreter casts this
+ string to the timestamp type by calling the
+ textout and timestamp_in
+ functions for the conversion. So, the computed time stamp is updated
+ on each execution as the programmer expects. Even though this
+ happens to work as expected, it's not terribly efficient, so
+ use of the now() function would still be a better idea.
+
+ PL/pgSQL is a loadable procedural
+ language for the PostgreSQL database
+ system. The design goals of PL/pgSQL were to create
+ a loadable procedural language that
+
+
+ can be used to create functions, procedures, and triggers,
+
+ adds control structures to the SQL language,
+
+ can perform complex computations,
+
+ inherits all user-defined types, functions, procedures, and operators,
+
+ can be defined to be trusted by the server,
+
+ is easy to use.
+
+
+ Functions created with PL/pgSQL can be
+ used anywhere that built-in functions could be used.
+ For example, it is possible to
+ create complex conditional computation functions and later use
+ them to define operators or use them in index expressions.
+
+ In PostgreSQL 9.0 and later,
+ PL/pgSQL is installed by default.
+ However it is still a loadable module, so especially security-conscious
+ administrators could choose to remove it.
+
43.1.1. Advantages of Using PL/pgSQL #
+ SQL is the language PostgreSQL
+ and most other relational databases use as query language. It's
+ portable and easy to learn. But every SQL
+ statement must be executed individually by the database server.
+
+ That means that your client application must send each query to
+ the database server, wait for it to be processed, receive and
+ process the results, do some computation, then send further
+ queries to the server. All this incurs interprocess
+ communication and will also incur network overhead if your client
+ is on a different machine than the database server.
+
+ With PL/pgSQL you can group a block of
+ computation and a series of queries inside
+ the database server, thus having the power of a procedural
+ language and the ease of use of SQL, but with considerable
+ savings of client/server communication overhead.
+
Extra round trips between
+ client and server are eliminated
Intermediate results that the client does not
+ need do not have to be marshaled or transferred between server
+ and client
Multiple rounds of query
+ parsing can be avoided
This can result in a considerable performance increase as
+ compared to an application that does not use stored functions.
+
+ Also, with PL/pgSQL you can use all
+ the data types, operators and functions of SQL.
+
43.1.2. Supported Argument and Result Data Types #
+ Functions written in PL/pgSQL can accept
+ as arguments any scalar or array data type supported by the server,
+ and they can return a result of any of these types. They can also
+ accept or return any composite type (row type) specified by name.
+ It is also possible to declare a PL/pgSQL
+ function as accepting record, which means that any
+ composite type will do as input, or
+ as returning record, which means that the result
+ is a row type whose columns are determined by specification in the
+ calling query, as discussed in Section 7.2.1.4.
+
+ PL/pgSQL functions can be declared to accept a variable
+ number of arguments by using the VARIADIC marker. This
+ works exactly the same way as for SQL functions, as discussed in
+ Section 38.5.6.
+
+ PL/pgSQL functions can also be declared to
+ accept and return the polymorphic types described in
+ Section 38.2.5, thus allowing the actual data
+ types handled by the function to vary from call to call.
+ Examples appear in Section 43.3.1.
+
+ PL/pgSQL functions can also be declared to return
+ a “set” (or table) of any data type that can be returned as
+ a single instance. Such a function generates its output by executing
+ RETURN NEXT for each desired element of the result
+ set, or by using RETURN QUERY to output the result of
+ evaluating a query.
+
+ Finally, a PL/pgSQL function can be declared to return
+ void if it has no useful return value. (Alternatively, it
+ could be written as a procedure in that case.)
+
+ PL/pgSQL functions can also be declared with output
+ parameters in place of an explicit specification of the return type.
+ This does not add any fundamental capability to the language, but
+ it is often convenient, especially for returning multiple values.
+ The RETURNS TABLE notation can also be used in place
+ of RETURNS SETOF.
+
+ Specific examples appear in
+ Section 43.3.1 and
+ Section 43.6.1.
+
43.13. Porting from Oracle PL/SQL #
+ This section explains differences between
+ PostgreSQL's PL/pgSQL
+ language and Oracle's PL/SQL language,
+ to help developers who port applications from
+ Oracle® to PostgreSQL.
+
+ PL/pgSQL is similar to PL/SQL in many
+ aspects. It is a block-structured, imperative language, and all
+ variables have to be declared. Assignments, loops, and conditionals
+ are similar. The main differences you should keep in mind when
+ porting from PL/SQL to
+ PL/pgSQL are:
+
+
+ If a name used in an SQL command could be either a column name of a
+ table used in the command or a reference to a variable of the function,
+ PL/SQL treats it as a column name.
+ By default, PL/pgSQL will throw an error
+ complaining that the name is ambiguous. You can specify
+ plpgsql.variable_conflict = use_column
+ to change this behavior to match PL/SQL,
+ as explained in Section 43.11.1.
+ It's often best to avoid such ambiguities in the first place,
+ but if you have to port a large amount of code that depends on
+ this behavior, setting variable_conflict may be the
+ best solution.
+
+ In PostgreSQL the function body must be written as
+ a string literal. Therefore you need to use dollar quoting or escape
+ single quotes in the function body. (See Section 43.12.1.)
+
+ Data type names often need translation. For example, in Oracle string
+ values are commonly declared as being of type varchar2, which
+ is a non-SQL-standard type. In PostgreSQL,
+ use type varchar or text instead. Similarly, replace
+ type number with numeric, or use some other numeric
+ data type if there's a more appropriate one.
+
+ Instead of packages, use schemas to organize your functions
+ into groups.
+
+ Since there are no packages, there are no package-level variables
+ either. This is somewhat annoying. You can keep per-session state
+ in temporary tables instead.
+
+ Integer FOR loops with REVERSE work
+ differently: PL/SQL counts down from the second
+ number to the first, while PL/pgSQL counts down
+ from the first number to the second, requiring the loop bounds
+ to be swapped when porting. This incompatibility is unfortunate
+ but is unlikely to be changed. (See Section 43.6.5.5.)
+
+ FOR loops over queries (other than cursors) also work
+ differently: the target variable(s) must have been declared,
+ whereas PL/SQL always declares them implicitly.
+ An advantage of this is that the variable values are still accessible
+ after the loop exits.
+
+ There are various notational differences for the use of cursor
+ variables.
+
+
43.13.1. Porting Examples #
+ Example 43.9 shows how to port a simple
+ function from PL/SQL to PL/pgSQL.
+
Example 43.9. Porting a Simple Function from PL/SQL to PL/pgSQL
+ Here is an Oracle PL/SQL function:
+
+CREATE OR REPLACE FUNCTION cs_fmt_browser_version(v_name varchar2,
+ v_version varchar2)
+RETURN varchar2 IS
+BEGIN
+ IF v_version IS NULL THEN
+ RETURN v_name;
+ END IF;
+ RETURN v_name || '/' || v_version;
+END;
+/
+show errors;
+
+
+ Let's go through this function and see the differences compared to
+ PL/pgSQL:
+
+
+ The type name varchar2 has to be changed to varchar
+ or text. In the examples in this section, we'll
+ use varchar, but text is often a better choice if
+ you do not need specific string length limits.
+
+ The RETURN key word in the function
+ prototype (not the function body) becomes
+ RETURNS in
+ PostgreSQL.
+ Also, IS becomes AS, and you need to
+ add a LANGUAGE clause because PL/pgSQL
+ is not the only possible function language.
+
+ In PostgreSQL, the function body is considered
+ to be a string literal, so you need to use quote marks or dollar
+ quotes around it. This substitutes for the terminating /
+ in the Oracle approach.
+
+ The show errors command does not exist in
+ PostgreSQL, and is not needed since errors are
+ reported automatically.
+
+
+ This is how this function would look when ported to
+ PostgreSQL:
+
+
+CREATE OR REPLACE FUNCTION cs_fmt_browser_version(v_name varchar,
+ v_version varchar)
+RETURNS varchar AS $$
+BEGIN
+ IF v_version IS NULL THEN
+ RETURN v_name;
+ END IF;
+ RETURN v_name || '/' || v_version;
+END;
+$$ LANGUAGE plpgsql;
+
+
+ Example 43.10 shows how to port a
+ function that creates another function and how to handle the
+ ensuing quoting problems.
+
Example 43.10. Porting a Function that Creates Another Function from PL/SQL to PL/pgSQL
+ The following procedure grabs rows from a
+ SELECT statement and builds a large function
+ with the results in IF statements, for the
+ sake of efficiency.
+
+ This is the Oracle version:
+
+CREATE OR REPLACE PROCEDURE cs_update_referrer_type_proc IS
+ CURSOR referrer_keys IS
+ SELECT * FROM cs_referrer_keys
+ ORDER BY try_order;
+ func_cmd VARCHAR(4000);
+BEGIN
+ func_cmd := 'CREATE OR REPLACE FUNCTION cs_find_referrer_type(v_host IN VARCHAR2,
+ v_domain IN VARCHAR2, v_url IN VARCHAR2) RETURN VARCHAR2 IS BEGIN';
+
+ FOR referrer_key IN referrer_keys LOOP
+ func_cmd := func_cmd ||
+ ' IF v_' || referrer_key.kind
+ || ' LIKE ''' || referrer_key.key_string
+ || ''' THEN RETURN ''' || referrer_key.referrer_type
+ || '''; END IF;';
+ END LOOP;
+
+ func_cmd := func_cmd || ' RETURN NULL; END;';
+
+ EXECUTE IMMEDIATE func_cmd;
+END;
+/
+show errors;
+
+
+ Here is how this function would end up in PostgreSQL:
+
+CREATE OR REPLACE PROCEDURE cs_update_referrer_type_proc() AS $func$
+DECLARE
+ referrer_keys CURSOR IS
+ SELECT * FROM cs_referrer_keys
+ ORDER BY try_order;
+ func_body text;
+ func_cmd text;
+BEGIN
+ func_body := 'BEGIN';
+
+ FOR referrer_key IN referrer_keys LOOP
+ func_body := func_body ||
+ ' IF v_' || referrer_key.kind
+ || ' LIKE ' || quote_literal(referrer_key.key_string)
+ || ' THEN RETURN ' || quote_literal(referrer_key.referrer_type)
+ || '; END IF;' ;
+ END LOOP;
+
+ func_body := func_body || ' RETURN NULL; END;';
+
+ func_cmd :=
+ 'CREATE OR REPLACE FUNCTION cs_find_referrer_type(v_host varchar,
+ v_domain varchar,
+ v_url varchar)
+ RETURNS varchar AS '
+ || quote_literal(func_body)
+ || ' LANGUAGE plpgsql;' ;
+
+ EXECUTE func_cmd;
+END;
+$func$ LANGUAGE plpgsql;
+
+ Notice how the body of the function is built separately and passed
+ through quote_literal to double any quote marks in it. This
+ technique is needed because we cannot safely use dollar quoting for
+ defining the new function: we do not know for sure what strings will
+ be interpolated from the referrer_key.key_string field.
+ (We are assuming here that referrer_key.kind can be
+ trusted to always be host, domain, or
+ url, but referrer_key.key_string might be
+ anything, in particular it might contain dollar signs.) This function
+ is actually an improvement on the Oracle original, because it will
+ not generate broken code when referrer_key.key_string or
+ referrer_key.referrer_type contain quote marks.
+
+ Example 43.11 shows how to port a function
+ with OUT parameters and string manipulation.
+ PostgreSQL does not have a built-in
+ instr function, but you can create one
+ using a combination of other
+ functions. In Section 43.13.3 there is a
+ PL/pgSQL implementation of
+ instr that you can use to make your porting
+ easier.
+
Example 43.11. Porting a Procedure With String Manipulation and
+ OUT Parameters from PL/SQL to
+ PL/pgSQL
+ The following Oracle PL/SQL procedure is used
+ to parse a URL and return several elements (host, path, and query).
+
+ This is the Oracle version:
+
+CREATE OR REPLACE PROCEDURE cs_parse_url(
+ v_url IN VARCHAR2,
+ v_host OUT VARCHAR2, -- This will be passed back
+ v_path OUT VARCHAR2, -- This one too
+ v_query OUT VARCHAR2) -- And this one
+IS
+ a_pos1 INTEGER;
+ a_pos2 INTEGER;
+BEGIN
+ v_host := NULL;
+ v_path := NULL;
+ v_query := NULL;
+ a_pos1 := instr(v_url, '//');
+
+ IF a_pos1 = 0 THEN
+ RETURN;
+ END IF;
+ a_pos2 := instr(v_url, '/', a_pos1 + 2);
+ IF a_pos2 = 0 THEN
+ v_host := substr(v_url, a_pos1 + 2);
+ v_path := '/';
+ RETURN;
+ END IF;
+
+ v_host := substr(v_url, a_pos1 + 2, a_pos2 - a_pos1 - 2);
+ a_pos1 := instr(v_url, '?', a_pos2 + 1);
+
+ IF a_pos1 = 0 THEN
+ v_path := substr(v_url, a_pos2);
+ RETURN;
+ END IF;
+
+ v_path := substr(v_url, a_pos2, a_pos1 - a_pos2);
+ v_query := substr(v_url, a_pos1 + 1);
+END;
+/
+show errors;
+
+
+ Here is a possible translation into PL/pgSQL:
+
+CREATE OR REPLACE FUNCTION cs_parse_url(
+ v_url IN VARCHAR,
+ v_host OUT VARCHAR, -- This will be passed back
+ v_path OUT VARCHAR, -- This one too
+ v_query OUT VARCHAR) -- And this one
+AS $$
+DECLARE
+ a_pos1 INTEGER;
+ a_pos2 INTEGER;
+BEGIN
+ v_host := NULL;
+ v_path := NULL;
+ v_query := NULL;
+ a_pos1 := instr(v_url, '//');
+
+ IF a_pos1 = 0 THEN
+ RETURN;
+ END IF;
+ a_pos2 := instr(v_url, '/', a_pos1 + 2);
+ IF a_pos2 = 0 THEN
+ v_host := substr(v_url, a_pos1 + 2);
+ v_path := '/';
+ RETURN;
+ END IF;
+
+ v_host := substr(v_url, a_pos1 + 2, a_pos2 - a_pos1 - 2);
+ a_pos1 := instr(v_url, '?', a_pos2 + 1);
+
+ IF a_pos1 = 0 THEN
+ v_path := substr(v_url, a_pos2);
+ RETURN;
+ END IF;
+
+ v_path := substr(v_url, a_pos2, a_pos1 - a_pos2);
+ v_query := substr(v_url, a_pos1 + 1);
+END;
+$$ LANGUAGE plpgsql;
+
+
+ This function could be used like this:
+
+SELECT * FROM cs_parse_url('http://foobar.com/query.cgi?baz');
+
+
+ Example 43.12 shows how to port a procedure
+ that uses numerous features that are specific to Oracle.
+
Example 43.12. Porting a Procedure from PL/SQL to PL/pgSQL
+ The Oracle version:
+
+
+CREATE OR REPLACE PROCEDURE cs_create_job(v_job_id IN INTEGER) IS
+ a_running_job_count INTEGER;
+BEGIN
+ LOCK TABLE cs_jobs IN EXCLUSIVE MODE;
+
+ SELECT count(*) INTO a_running_job_count FROM cs_jobs WHERE end_stamp IS NULL;
+
+ IF a_running_job_count > 0 THEN
+ COMMIT; -- free lock
+ raise_application_error(-20000,
+ 'Unable to create a new job: a job is currently running.');
+ END IF;
+
+ DELETE FROM cs_active_job;
+ INSERT INTO cs_active_job(job_id) VALUES (v_job_id);
+
+ BEGIN
+ INSERT INTO cs_jobs (job_id, start_stamp) VALUES (v_job_id, now());
+ EXCEPTION
+ WHEN dup_val_on_index THEN NULL; -- don't worry if it already exists
+ END;
+ COMMIT;
+END;
+/
+show errors
+
+
+ This is how we could port this procedure to PL/pgSQL:
+
+
+CREATE OR REPLACE PROCEDURE cs_create_job(v_job_id integer) AS $$
+DECLARE
+ a_running_job_count integer;
+BEGIN
+ LOCK TABLE cs_jobs IN EXCLUSIVE MODE;
+
+ SELECT count(*) INTO a_running_job_count FROM cs_jobs WHERE end_stamp IS NULL;
+
+ IF a_running_job_count > 0 THEN
+ COMMIT; -- free lock
+ RAISE EXCEPTION 'Unable to create a new job: a job is currently running'; -- (1)
+ END IF;
+
+ DELETE FROM cs_active_job;
+ INSERT INTO cs_active_job(job_id) VALUES (v_job_id);
+
+ BEGIN
+ INSERT INTO cs_jobs (job_id, start_stamp) VALUES (v_job_id, now());
+ EXCEPTION
+ WHEN unique_violation THEN -- (2)
+ -- don't worry if it already exists
+ END;
+ COMMIT;
+END;
+$$ LANGUAGE plpgsql;
+
+
+
(1) |
+ The syntax of RAISE is considerably different from
+ Oracle's statement, although the basic case RAISE
+ exception_name works
+ similarly.
+ |
(2) |
+ The exception names supported by PL/pgSQL are
+ different from Oracle's. The set of built-in exception names
+ is much larger (see Appendix A). There
+ is not currently a way to declare user-defined exception names,
+ although you can throw user-chosen SQLSTATE values instead.
+ |
+
43.13.2. Other Things to Watch For #
+ This section explains a few other things to watch for when porting
+ Oracle PL/SQL functions to
+ PostgreSQL.
+
43.13.2.1. Implicit Rollback after Exceptions #
+ In PL/pgSQL, when an exception is caught by an
+ EXCEPTION clause, all database changes since the block's
+ BEGIN are automatically rolled back. That is, the behavior
+ is equivalent to what you'd get in Oracle with:
+
+
+BEGIN
+ SAVEPOINT s1;
+ ... code here ...
+EXCEPTION
+ WHEN ... THEN
+ ROLLBACK TO s1;
+ ... code here ...
+ WHEN ... THEN
+ ROLLBACK TO s1;
+ ... code here ...
+END;
+
+
+ If you are translating an Oracle procedure that uses
+ SAVEPOINT and ROLLBACK TO in this style,
+ your task is easy: just omit the SAVEPOINT and
+ ROLLBACK TO. If you have a procedure that uses
+ SAVEPOINT and ROLLBACK TO in a different way
+ then some actual thought will be required.
+
+ The PL/pgSQL version of
+ EXECUTE works similarly to the
+ PL/SQL version, but you have to remember to use
+ quote_literal and
+ quote_ident as described in Section 43.5.4. Constructs of the
+ type EXECUTE 'SELECT * FROM $1'; will not work
+ reliably unless you use these functions.
+
43.13.2.3. Optimizing PL/pgSQL Functions #
+ PostgreSQL gives you two function creation
+ modifiers to optimize execution: “volatility” (whether
+ the function always returns the same result when given the same
+ arguments) and “strictness” (whether the function
+ returns null if any argument is null). Consult the CREATE FUNCTION
+ reference page for details.
+
+ When making use of these optimization attributes, your
+ CREATE FUNCTION statement might look something
+ like this:
+
+
+CREATE FUNCTION foo(...) RETURNS integer AS $$
+...
+$$ LANGUAGE plpgsql STRICT IMMUTABLE;
+
+
+ This section contains the code for a set of Oracle-compatible
+ instr functions that you can use to simplify
+ your porting efforts.
+
+--
+-- instr functions that mimic Oracle's counterpart
+-- Syntax: instr(string1, string2 [, n [, m]])
+-- where [] denotes optional parameters.
+--
+-- Search string1, beginning at the nth character, for the mth occurrence
+-- of string2. If n is negative, search backwards, starting at the abs(n)'th
+-- character from the end of string1.
+-- If n is not passed, assume 1 (search starts at first character).
+-- If m is not passed, assume 1 (find first occurrence).
+-- Returns starting index of string2 in string1, or 0 if string2 is not found.
+--
+
+CREATE FUNCTION instr(varchar, varchar) RETURNS integer AS $$
+BEGIN
+ RETURN instr($1, $2, 1);
+END;
+$$ LANGUAGE plpgsql STRICT IMMUTABLE;
+
+
+CREATE FUNCTION instr(string varchar, string_to_search_for varchar,
+ beg_index integer)
+RETURNS integer AS $$
+DECLARE
+ pos integer NOT NULL DEFAULT 0;
+ temp_str varchar;
+ beg integer;
+ length integer;
+ ss_length integer;
+BEGIN
+ IF beg_index > 0 THEN
+ temp_str := substring(string FROM beg_index);
+ pos := position(string_to_search_for IN temp_str);
+
+ IF pos = 0 THEN
+ RETURN 0;
+ ELSE
+ RETURN pos + beg_index - 1;
+ END IF;
+ ELSIF beg_index < 0 THEN
+ ss_length := char_length(string_to_search_for);
+ length := char_length(string);
+ beg := length + 1 + beg_index;
+
+ WHILE beg > 0 LOOP
+ temp_str := substring(string FROM beg FOR ss_length);
+ IF string_to_search_for = temp_str THEN
+ RETURN beg;
+ END IF;
+
+ beg := beg - 1;
+ END LOOP;
+
+ RETURN 0;
+ ELSE
+ RETURN 0;
+ END IF;
+END;
+$$ LANGUAGE plpgsql STRICT IMMUTABLE;
+
+
+CREATE FUNCTION instr(string varchar, string_to_search_for varchar,
+ beg_index integer, occur_index integer)
+RETURNS integer AS $$
+DECLARE
+ pos integer NOT NULL DEFAULT 0;
+ occur_number integer NOT NULL DEFAULT 0;
+ temp_str varchar;
+ beg integer;
+ i integer;
+ length integer;
+ ss_length integer;
+BEGIN
+ IF occur_index <= 0 THEN
+ RAISE 'argument ''%'' is out of range', occur_index
+ USING ERRCODE = '22003';
+ END IF;
+
+ IF beg_index > 0 THEN
+ beg := beg_index - 1;
+ FOR i IN 1..occur_index LOOP
+ temp_str := substring(string FROM beg + 1);
+ pos := position(string_to_search_for IN temp_str);
+ IF pos = 0 THEN
+ RETURN 0;
+ END IF;
+ beg := beg + pos;
+ END LOOP;
+
+ RETURN beg;
+ ELSIF beg_index < 0 THEN
+ ss_length := char_length(string_to_search_for);
+ length := char_length(string);
+ beg := length + 1 + beg_index;
+
+ WHILE beg > 0 LOOP
+ temp_str := substring(string FROM beg FOR ss_length);
+ IF string_to_search_for = temp_str THEN
+ occur_number := occur_number + 1;
+ IF occur_number = occur_index THEN
+ RETURN beg;
+ END IF;
+ END IF;
+
+ beg := beg - 1;
+ END LOOP;
+
+ RETURN 0;
+ ELSE
+ RETURN 0;
+ END IF;
+END;
+$$ LANGUAGE plpgsql STRICT IMMUTABLE;
+
+
+ In this section and the following ones, we describe all the statement
+ types that are explicitly understood by
+ PL/pgSQL.
+ Anything not recognized as one of these statement types is presumed
+ to be an SQL command and is sent to the main database engine to execute,
+ as described in Section 43.5.2.
+
+ An assignment of a value to a PL/pgSQL
+ variable is written as:
+
+variable { := | = } expression;
+
+ As explained previously, the expression in such a statement is evaluated
+ by means of an SQL SELECT command sent to the main
+ database engine. The expression must yield a single value (possibly
+ a row value, if the variable is a row or record variable). The target
+ variable can be a simple variable (optionally qualified with a block
+ name), a field of a row or record target, or an element or slice of
+ an array target. Equal (=) can be
+ used instead of PL/SQL-compliant :=.
+
+ If the expression's result data type doesn't match the variable's
+ data type, the value will be coerced as though by an assignment cast
+ (see Section 10.4). If no assignment cast is known
+ for the pair of data types involved, the PL/pgSQL
+ interpreter will attempt to convert the result value textually, that is
+ by applying the result type's output function followed by the variable
+ type's input function. Note that this could result in run-time errors
+ generated by the input function, if the string form of the result value
+ is not acceptable to the input function.
+
+ Examples:
+
+tax := subtotal * 0.06;
+my_record.user_id := 20;
+my_array[j] := 20;
+my_array[1:3] := array[1,2,3];
+complex_array[n].realpart = 12.3;
+
+
43.5.2. Executing SQL Commands #
+ In general, any SQL command that does not return rows can be executed
+ within a PL/pgSQL function just by writing
+ the command. For example, you could create and fill a table by writing
+
+CREATE TABLE mytable (id int primary key, data text);
+INSERT INTO mytable VALUES (1,'one'), (2,'two');
+
+
+ If the command does return rows (for example SELECT,
+ or INSERT/UPDATE/DELETE
+ with RETURNING), there are two ways to proceed.
+ When the command will return at most one row, or you only care about
+ the first row of output, write the command as usual but add
+ an INTO clause to capture the output, as described
+ in Section 43.5.3.
+ To process all of the output rows, write the command as the data
+ source for a FOR loop, as described in
+ Section 43.6.6.
+
+ Usually it is not sufficient just to execute statically-defined SQL
+ commands. Typically you'll want a command to use varying data values,
+ or even to vary in more fundamental ways such as by using different
+ table names at different times. Again, there are two ways to proceed
+ depending on the situation.
+
+ PL/pgSQL variable values can be
+ automatically inserted into optimizable SQL commands, which
+ are SELECT, INSERT,
+ UPDATE, DELETE,
+ MERGE, and certain
+ utility commands that incorporate one of these, such
+ as EXPLAIN and CREATE TABLE ... AS
+ SELECT. In these commands,
+ any PL/pgSQL variable name appearing
+ in the command text is replaced by a query parameter, and then the
+ current value of the variable is provided as the parameter value
+ at run time. This is exactly like the processing described earlier
+ for expressions; for details see Section 43.11.1.
+
+ When executing an optimizable SQL command in this way,
+ PL/pgSQL may cache and re-use the execution
+ plan for the command, as discussed in
+ Section 43.11.2.
+
+ Non-optimizable SQL commands (also called utility commands) are not
+ capable of accepting query parameters. So automatic substitution
+ of PL/pgSQL variables does not work in such
+ commands. To include non-constant text in a utility command executed
+ from PL/pgSQL, you must build the utility
+ command as a string and then EXECUTE it, as
+ discussed in Section 43.5.4.
+
+ EXECUTE must also be used if you want to modify
+ the command in some other way than supplying a data value, for example
+ by changing a table name.
+
+ Sometimes it is useful to evaluate an expression or SELECT
+ query but discard the result, for example when calling a function
+ that has side-effects but no useful result value. To do
+ this in PL/pgSQL, use the
+ PERFORM statement:
+
+
+PERFORM query;
+
+
+ This executes query and discards the
+ result. Write the query the same
+ way you would write an SQL SELECT command, but replace the
+ initial keyword SELECT with PERFORM.
+ For WITH queries, use PERFORM and then
+ place the query in parentheses. (In this case, the query can only
+ return one row.)
+ PL/pgSQL variables will be
+ substituted into the query just as described above,
+ and the plan is cached in the same way. Also, the special variable
+ FOUND is set to true if the query produced at
+ least one row, or false if it produced no rows (see
+ Section 43.5.5).
+
Note
+ One might expect that writing SELECT directly
+ would accomplish this result, but at
+ present the only accepted way to do it is
+ PERFORM. An SQL command that can return rows,
+ such as SELECT, will be rejected as an error
+ unless it has an INTO clause as discussed in the
+ next section.
+
+ An example:
+
+PERFORM create_mv('cs_session_page_requests_mv', my_query);
+
+
43.5.3. Executing a Command with a Single-Row Result #
+ The result of an SQL command yielding a single row (possibly of multiple
+ columns) can be assigned to a record variable, row-type variable, or list
+ of scalar variables. This is done by writing the base SQL command and
+ adding an INTO clause. For example,
+
+
+SELECT select_expressions INTO [STRICT] target FROM ...;
+INSERT ... RETURNING expressions INTO [STRICT] target;
+UPDATE ... RETURNING expressions INTO [STRICT] target;
+DELETE ... RETURNING expressions INTO [STRICT] target;
+
+
+ where target can be a record variable, a row
+ variable, or a comma-separated list of simple variables and
+ record/row fields.
+ PL/pgSQL variables will be
+ substituted into the rest of the command (that is, everything but the
+ INTO clause) just as described above,
+ and the plan is cached in the same way.
+ This works for SELECT,
+ INSERT/UPDATE/DELETE with
+ RETURNING, and certain utility commands
+ that return row sets, such as EXPLAIN.
+ Except for the INTO clause, the SQL command is the same
+ as it would be written outside PL/pgSQL.
+
Tip
+ Note that this interpretation of SELECT with INTO
+ is quite different from PostgreSQL's regular
+ SELECT INTO command, wherein the INTO
+ target is a newly created table. If you want to create a table from a
+ SELECT result inside a
+ PL/pgSQL function, use the syntax
+ CREATE TABLE ... AS SELECT.
+
+ If a row variable or a variable list is used as target,
+ the command's result columns
+ must exactly match the structure of the target as to number and data
+ types, or else a run-time error
+ occurs. When a record variable is the target, it automatically
+ configures itself to the row type of the command's result columns.
+
+ The INTO clause can appear almost anywhere in the SQL
+ command. Customarily it is written either just before or just after
+ the list of select_expressions in a
+ SELECT command, or at the end of the command for other
+ command types. It is recommended that you follow this convention
+ in case the PL/pgSQL parser becomes
+ stricter in future versions.
+
+ If STRICT is not specified in the INTO
+ clause, then target will be set to the first
+ row returned by the command, or to nulls if the command returned no rows.
+ (Note that “the first row” is not
+ well-defined unless you've used ORDER BY.) Any result rows
+ after the first row are discarded.
+ You can check the special FOUND variable (see
+ Section 43.5.5) to
+ determine whether a row was returned:
+
+
+SELECT * INTO myrec FROM emp WHERE empname = myname;
+IF NOT FOUND THEN
+ RAISE EXCEPTION 'employee % not found', myname;
+END IF;
+
+
+ If the STRICT option is specified, the command must
+ return exactly one row or a run-time error will be reported, either
+ NO_DATA_FOUND (no rows) or TOO_MANY_ROWS
+ (more than one row). You can use an exception block if you wish
+ to catch the error, for example:
+
+
+BEGIN
+ SELECT * INTO STRICT myrec FROM emp WHERE empname = myname;
+ EXCEPTION
+ WHEN NO_DATA_FOUND THEN
+ RAISE EXCEPTION 'employee % not found', myname;
+ WHEN TOO_MANY_ROWS THEN
+ RAISE EXCEPTION 'employee % not unique', myname;
+END;
+
+ Successful execution of a command with STRICT
+ always sets FOUND to true.
+
+ For INSERT/UPDATE/DELETE with
+ RETURNING, PL/pgSQL reports
+ an error for more than one returned row, even when
+ STRICT is not specified. This is because there
+ is no option such as ORDER BY with which to determine
+ which affected row should be returned.
+
+ If print_strict_params is enabled for the function,
+ then when an error is thrown because the requirements
+ of STRICT are not met, the DETAIL part of
+ the error message will include information about the parameters
+ passed to the command.
+ You can change the print_strict_params
+ setting for all functions by setting
+ plpgsql.print_strict_params, though only subsequent
+ function compilations will be affected. You can also enable it
+ on a per-function basis by using a compiler option, for example:
+
+CREATE FUNCTION get_userid(username text) RETURNS int
+AS $$
+#print_strict_params on
+DECLARE
+userid int;
+BEGIN
+ SELECT users.userid INTO STRICT userid
+ FROM users WHERE users.username = get_userid.username;
+ RETURN userid;
+END;
+$$ LANGUAGE plpgsql;
+
+ On failure, this function might produce an error message such as
+
+ERROR: query returned no rows
+DETAIL: parameters: $1 = 'nosuchuser'
+CONTEXT: PL/pgSQL function get_userid(text) line 6 at SQL statement
+
+
Note
+ The STRICT option matches the behavior of
+ Oracle PL/SQL's SELECT INTO and related statements.
+
43.5.4. Executing Dynamic Commands #
+ Oftentimes you will want to generate dynamic commands inside your
+ PL/pgSQL functions, that is, commands
+ that will involve different tables or different data types each
+ time they are executed. PL/pgSQL's
+ normal attempts to cache plans for commands (as discussed in
+ Section 43.11.2) will not work in such
+ scenarios. To handle this sort of problem, the
+ EXECUTE statement is provided:
+
+
+EXECUTE command-string [ INTO [STRICT] target ] [ USING expression [, ... ] ];
+
+
+ where command-string is an expression
+ yielding a string (of type text) containing the
+ command to be executed. The optional target
+ is a record variable, a row variable, or a comma-separated list of
+ simple variables and record/row fields, into which the results of
+ the command will be stored. The optional USING expressions
+ supply values to be inserted into the command.
+
+ No substitution of PL/pgSQL variables is done on the
+ computed command string. Any required variable values must be inserted
+ in the command string as it is constructed; or you can use parameters
+ as described below.
+
+ Also, there is no plan caching for commands executed via
+ EXECUTE. Instead, the command is always planned
+ each time the statement is run. Thus the command
+ string can be dynamically created within the function to perform
+ actions on different tables and columns.
+
+ The INTO clause specifies where the results of
+ an SQL command returning rows should be assigned. If a row variable
+ or variable list is provided, it must exactly match the structure
+ of the command's results; if a
+ record variable is provided, it will configure itself to match the
+ result structure automatically. If multiple rows are returned,
+ only the first will be assigned to the INTO
+ variable(s). If no rows are returned, NULL is assigned to the
+ INTO variable(s). If no INTO
+ clause is specified, the command results are discarded.
+
+ If the STRICT option is given, an error is reported
+ unless the command produces exactly one row.
+
+ The command string can use parameter values, which are referenced
+ in the command as $1, $2, etc.
+ These symbols refer to values supplied in the USING
+ clause. This method is often preferable to inserting data values
+ into the command string as text: it avoids run-time overhead of
+ converting the values to text and back, and it is much less prone
+ to SQL-injection attacks since there is no need for quoting or escaping.
+ An example is:
+
+EXECUTE 'SELECT count(*) FROM mytable WHERE inserted_by = $1 AND inserted <= $2'
+ INTO c
+ USING checked_user, checked_date;
+
+
+ Note that parameter symbols can only be used for data values
+ — if you want to use dynamically determined table or column
+ names, you must insert them into the command string textually.
+ For example, if the preceding query needed to be done against a
+ dynamically selected table, you could do this:
+
+EXECUTE 'SELECT count(*) FROM '
+ || quote_ident(tabname)
+ || ' WHERE inserted_by = $1 AND inserted <= $2'
+ INTO c
+ USING checked_user, checked_date;
+
+ A cleaner approach is to use format()'s %I
+ specification to insert table or column names with automatic quoting:
+
+EXECUTE format('SELECT count(*) FROM %I '
+ 'WHERE inserted_by = $1 AND inserted <= $2', tabname)
+ INTO c
+ USING checked_user, checked_date;
+
+ (This example relies on the SQL rule that string literals separated by a
+ newline are implicitly concatenated.)
+
+ Another restriction on parameter symbols is that they only work in
+ optimizable SQL commands
+ (SELECT, INSERT, UPDATE,
+ DELETE, MERGE, and certain commands containing one of these).
+ In other statement
+ types (generically called utility statements), you must insert
+ values textually even if they are just data values.
+
+ An EXECUTE with a simple constant command string and some
+ USING parameters, as in the first example above, is
+ functionally equivalent to just writing the command directly in
+ PL/pgSQL and allowing replacement of
+ PL/pgSQL variables to happen automatically.
+ The important difference is that EXECUTE will re-plan
+ the command on each execution, generating a plan that is specific
+ to the current parameter values; whereas
+ PL/pgSQL may otherwise create a generic plan
+ and cache it for re-use. In situations where the best plan depends
+ strongly on the parameter values, it can be helpful to use
+ EXECUTE to positively ensure that a generic plan is not
+ selected.
+
+ SELECT INTO is not currently supported within
+ EXECUTE; instead, execute a plain SELECT
+ command and specify INTO as part of the EXECUTE
+ itself.
+
Note
+ The PL/pgSQL
+ EXECUTE statement is not related to the
+ EXECUTE SQL
+ statement supported by the
+ PostgreSQL server. The server's
+ EXECUTE statement cannot be used directly within
+ PL/pgSQL functions (and is not needed).
+
Example 43.1. Quoting Values in Dynamic Queries
+ When working with dynamic commands you will often have to handle escaping
+ of single quotes. The recommended method for quoting fixed text in your
+ function body is dollar quoting. (If you have legacy code that does
+ not use dollar quoting, please refer to the
+ overview in Section 43.12.1, which can save you
+ some effort when translating said code to a more reasonable scheme.)
+
+ Dynamic values require careful handling since they might contain
+ quote characters.
+ An example using format() (this assumes that you are
+ dollar quoting the function body so quote marks need not be doubled):
+
+EXECUTE format('UPDATE tbl SET %I = $1 '
+ 'WHERE key = $2', colname) USING newvalue, keyvalue;
+
+ It is also possible to call the quoting functions directly:
+
+EXECUTE 'UPDATE tbl SET '
+ || quote_ident(colname)
+ || ' = '
+ || quote_literal(newvalue)
+ || ' WHERE key = '
+ || quote_literal(keyvalue);
+
+
+ This example demonstrates the use of the
+ quote_ident and
+ quote_literal functions (see Section 9.4). For safety, expressions containing column
+ or table identifiers should be passed through
+ quote_ident before insertion in a dynamic query.
+ Expressions containing values that should be literal strings in the
+ constructed command should be passed through quote_literal.
+ These functions take the appropriate steps to return the input text
+ enclosed in double or single quotes respectively, with any embedded
+ special characters properly escaped.
+
+ Because quote_literal is labeled
+ STRICT, it will always return null when called with a
+ null argument. In the above example, if newvalue or
+ keyvalue were null, the entire dynamic query string would
+ become null, leading to an error from EXECUTE.
+ You can avoid this problem by using the quote_nullable
+ function, which works the same as quote_literal except that
+ when called with a null argument it returns the string NULL.
+ For example,
+
+EXECUTE 'UPDATE tbl SET '
+ || quote_ident(colname)
+ || ' = '
+ || quote_nullable(newvalue)
+ || ' WHERE key = '
+ || quote_nullable(keyvalue);
+
+ If you are dealing with values that might be null, you should usually
+ use quote_nullable in place of quote_literal.
+
+ As always, care must be taken to ensure that null values in a query do
+ not deliver unintended results. For example the WHERE clause
+
+'WHERE key = ' || quote_nullable(keyvalue)
+
+ will never succeed if keyvalue is null, because the
+ result of using the equality operator = with a null operand
+ is always null. If you wish null to work like an ordinary key value,
+ you would need to rewrite the above as
+
+'WHERE key IS NOT DISTINCT FROM ' || quote_nullable(keyvalue)
+
+ (At present, IS NOT DISTINCT FROM is handled much less
+ efficiently than =, so don't do this unless you must.
+ See Section 9.2 for
+ more information on nulls and IS DISTINCT.)
+
+ Note that dollar quoting is only useful for quoting fixed text.
+ It would be a very bad idea to try to write this example as:
+
+EXECUTE 'UPDATE tbl SET '
+ || quote_ident(colname)
+ || ' = $$'
+ || newvalue
+ || '$$ WHERE key = '
+ || quote_literal(keyvalue);
+
+ because it would break if the contents of newvalue
+ happened to contain $$. The same objection would
+ apply to any other dollar-quoting delimiter you might pick.
+ So, to safely quote text that is not known in advance, you
+ must use quote_literal,
+ quote_nullable, or quote_ident, as appropriate.
+
+ Dynamic SQL statements can also be safely constructed using the
+ format function (see Section 9.4.1). For example:
+
+EXECUTE format('UPDATE tbl SET %I = %L '
+ 'WHERE key = %L', colname, newvalue, keyvalue);
+
+ %I is equivalent to quote_ident, and
+ %L is equivalent to quote_nullable.
+ The format function can be used in conjunction with
+ the USING clause:
+
+EXECUTE format('UPDATE tbl SET %I = $1 WHERE key = $2', colname)
+ USING newvalue, keyvalue;
+
+ This form is better because the variables are handled in their native
+ data type format, rather than unconditionally converting them to
+ text and quoting them via %L. It is also more efficient.
+
+ A much larger example of a dynamic command and
+ EXECUTE can be seen in Example 43.10, which builds and executes a
+ CREATE FUNCTION command to define a new function.
+
43.5.5. Obtaining the Result Status #
+ There are several ways to determine the effect of a command. The
+ first method is to use the GET DIAGNOSTICS
+ command, which has the form:
+
+
+GET [ CURRENT ] DIAGNOSTICS variable { = | := } item [ , ... ];
+
+
+ This command allows retrieval of system status indicators.
+ CURRENT is a noise word (but see also GET STACKED
+ DIAGNOSTICS in Section 43.6.8.1).
+ Each item is a key word identifying a status
+ value to be assigned to the specified variable
+ (which should be of the right data type to receive it). The currently
+ available status items are shown
+ in Table 43.1. Colon-equal
+ (:=) can be used instead of the SQL-standard =
+ token. An example:
+
+GET DIAGNOSTICS integer_var = ROW_COUNT;
+
+
Table 43.1. Available Diagnostics Items
| Name | Type | Description |
|---|
ROW_COUNT | bigint | the number of rows processed by the most
+ recent SQL command |
PG_CONTEXT | text | line(s) of text describing the current call stack
+ (see Section 43.6.9) |
PG_ROUTINE_OID | oid | OID of the current function |
+ The second method to determine the effects of a command is to check the
+ special variable named FOUND, which is of
+ type boolean. FOUND starts out
+ false within each PL/pgSQL function call.
+ It is set by each of the following types of statements:
+
+
+ A SELECT INTO statement sets
+ FOUND true if a row is assigned, false if no
+ row is returned.
+
+ A PERFORM statement sets FOUND
+ true if it produces (and discards) one or more rows, false if
+ no row is produced.
+
+ UPDATE, INSERT, DELETE,
+ and MERGE
+ statements set FOUND true if at least one
+ row is affected, false if no row is affected.
+
+ A FETCH statement sets FOUND
+ true if it returns a row, false if no row is returned.
+
+ A MOVE statement sets FOUND
+ true if it successfully repositions the cursor, false otherwise.
+
+ A FOR or FOREACH statement sets
+ FOUND true
+ if it iterates one or more times, else false.
+ FOUND is set this way when the
+ loop exits; inside the execution of the loop,
+ FOUND is not modified by the
+ loop statement, although it might be changed by the
+ execution of other statements within the loop body.
+
+ RETURN QUERY and RETURN QUERY
+ EXECUTE statements set FOUND
+ true if the query returns at least one row, false if no row
+ is returned.
+
+
+ Other PL/pgSQL statements do not change
+ the state of FOUND.
+ Note in particular that EXECUTE
+ changes the output of GET DIAGNOSTICS, but
+ does not change FOUND.
+
+ FOUND is a local variable within each
+ PL/pgSQL function; any changes to it
+ affect only the current function.
+
43.5.6. Doing Nothing At All #
+ Sometimes a placeholder statement that does nothing is useful.
+ For example, it can indicate that one arm of an if/then/else
+ chain is deliberately empty. For this purpose, use the
+ NULL statement:
+
+
+NULL;
+
+
+ For example, the following two fragments of code are equivalent:
+
+BEGIN
+ y := x / 0;
+EXCEPTION
+ WHEN division_by_zero THEN
+ NULL; -- ignore the error
+END;
+
+
+
+BEGIN
+ y := x / 0;
+EXCEPTION
+ WHEN division_by_zero THEN -- ignore the error
+END;
+
+ Which is preferable is a matter of taste.
+
Note
+ In Oracle's PL/SQL, empty statement lists are not allowed, and so
+ NULL statements are required for situations
+ such as this. PL/pgSQL allows you to
+ just write nothing, instead.
+
43.2. Structure of PL/pgSQL #
+ Functions written in PL/pgSQL are defined
+ to the server by executing CREATE FUNCTION commands.
+ Such a command would normally look like, say,
+
+CREATE FUNCTION somefunc(integer, text) RETURNS integer
+AS 'function body text'
+LANGUAGE plpgsql;
+
+ The function body is simply a string literal so far as CREATE
+ FUNCTION is concerned. It is often helpful to use dollar quoting
+ (see Section 4.1.2.4) to write the function
+ body, rather than the normal single quote syntax. Without dollar quoting,
+ any single quotes or backslashes in the function body must be escaped by
+ doubling them. Almost all the examples in this chapter use dollar-quoted
+ literals for their function bodies.
+
+ PL/pgSQL is a block-structured language.
+ The complete text of a function body must be a
+ block. A block is defined as:
+
+
+[ <<label>> ]
+[ DECLARE
+ declarations ]
+BEGIN
+ statements
+END [ label ];
+
+
+ Each declaration and each statement within a block is terminated
+ by a semicolon. A block that appears within another block must
+ have a semicolon after END, as shown above;
+ however the final END that
+ concludes a function body does not require a semicolon.
+
Tip
+ A common mistake is to write a semicolon immediately after
+ BEGIN. This is incorrect and will result in a syntax error.
+
+ A label is only needed if you want to
+ identify the block for use
+ in an EXIT statement, or to qualify the names of the
+ variables declared in the block. If a label is given after
+ END, it must match the label at the block's beginning.
+
+ All key words are case-insensitive.
+ Identifiers are implicitly converted to lower case
+ unless double-quoted, just as they are in ordinary SQL commands.
+
+ Comments work the same way in PL/pgSQL code as in
+ ordinary SQL. A double dash (--) starts a comment
+ that extends to the end of the line. A /* starts a
+ block comment that extends to the matching occurrence of
+ */. Block comments nest.
+
+ Any statement in the statement section of a block
+ can be a subblock. Subblocks can be used for
+ logical grouping or to localize variables to a small group
+ of statements. Variables declared in a subblock mask any
+ similarly-named variables of outer blocks for the duration
+ of the subblock; but you can access the outer variables anyway
+ if you qualify their names with their block's label. For example:
+
+CREATE FUNCTION somefunc() RETURNS integer AS $$
+<< outerblock >>
+DECLARE
+ quantity integer := 30;
+BEGIN
+ RAISE NOTICE 'Quantity here is %', quantity; -- Prints 30
+ quantity := 50;
+ --
+ -- Create a subblock
+ --
+ DECLARE
+ quantity integer := 80;
+ BEGIN
+ RAISE NOTICE 'Quantity here is %', quantity; -- Prints 80
+ RAISE NOTICE 'Outer quantity here is %', outerblock.quantity; -- Prints 50
+ END;
+
+ RAISE NOTICE 'Quantity here is %', quantity; -- Prints 50
+
+ RETURN quantity;
+END;
+$$ LANGUAGE plpgsql;
+
+
Note
+ There is actually a hidden “outer block” surrounding the body
+ of any PL/pgSQL function. This block provides the
+ declarations of the function's parameters (if any), as well as some
+ special variables such as FOUND (see
+ Section 43.5.5). The outer block is
+ labeled with the function's name, meaning that parameters and special
+ variables can be qualified with the function's name.
+
+ It is important not to confuse the use of
+ BEGIN/END for grouping statements in
+ PL/pgSQL with the similarly-named SQL commands
+ for transaction
+ control. PL/pgSQL's BEGIN/END
+ are only for grouping; they do not start or end a transaction.
+ See Section 43.8 for information on managing
+ transactions in PL/pgSQL.
+ Also, a block containing an EXCEPTION clause effectively
+ forms a subtransaction that can be rolled back without affecting the
+ outer transaction. For more about that see Section 43.6.8.
+
43.8. Transaction Management #
+ In procedures invoked by the CALL command
+ as well as in anonymous code blocks (DO command),
+ it is possible to end transactions using the
+ commands COMMIT and ROLLBACK. A new
+ transaction is started automatically after a transaction is ended using
+ these commands, so there is no separate START
+ TRANSACTION command. (Note that BEGIN and
+ END have different meanings in PL/pgSQL.)
+
+ Here is a simple example:
+
+CREATE PROCEDURE transaction_test1()
+LANGUAGE plpgsql
+AS $$
+BEGIN
+ FOR i IN 0..9 LOOP
+ INSERT INTO test1 (a) VALUES (i);
+ IF i % 2 = 0 THEN
+ COMMIT;
+ ELSE
+ ROLLBACK;
+ END IF;
+ END LOOP;
+END;
+$$;
+
+CALL transaction_test1();
+
+
+ A new transaction starts out with default transaction characteristics such
+ as transaction isolation level. In cases where transactions are committed
+ in a loop, it might be desirable to start new transactions automatically
+ with the same characteristics as the previous one. The commands
+ COMMIT AND CHAIN and ROLLBACK AND
+ CHAIN accomplish this.
+
+ Transaction control is only possible in CALL or
+ DO invocations from the top level or nested
+ CALL or DO invocations without any
+ other intervening command. For example, if the call stack is
+ CALL proc1() → CALL proc2()
+ → CALL proc3(), then the second and third
+ procedures can perform transaction control actions. But if the call stack
+ is CALL proc1() → SELECT
+ func2() → CALL proc3(), then the last
+ procedure cannot do transaction control, because of the
+ SELECT in between.
+
+ Special considerations apply to cursor loops. Consider this example:
+
+CREATE PROCEDURE transaction_test2()
+LANGUAGE plpgsql
+AS $$
+DECLARE
+ r RECORD;
+BEGIN
+ FOR r IN SELECT * FROM test2 ORDER BY x LOOP
+ INSERT INTO test1 (a) VALUES (r.x);
+ COMMIT;
+ END LOOP;
+END;
+$$;
+
+CALL transaction_test2();
+
+ Normally, cursors are automatically closed at transaction commit.
+ However, a cursor created as part of a loop like this is automatically
+ converted to a holdable cursor by the first COMMIT or
+ ROLLBACK. That means that the cursor is fully
+ evaluated at the first COMMIT or
+ ROLLBACK rather than row by row. The cursor is still
+ removed automatically after the loop, so this is mostly invisible to the
+ user.
+
+ Transaction commands are not allowed in cursor loops driven by commands
+ that are not read-only (for example UPDATE
+ ... RETURNING).
+
+ A transaction cannot be ended inside a block with exception handlers.
+
43.10. Trigger Functions #
+ PL/pgSQL can be used to define trigger
+ functions on data changes or database events.
+ A trigger function is created with the CREATE FUNCTION
+ command, declaring it as a function with no arguments and a return type of
+ trigger (for data change triggers) or
+ event_trigger (for database event triggers).
+ Special local variables named TG_something are
+ automatically defined to describe the condition that triggered the call.
+
43.10.1. Triggers on Data Changes #
+ A data change trigger is declared as a
+ function with no arguments and a return type of trigger.
+ Note that the function must be declared with no arguments even if it
+ expects to receive some arguments specified in CREATE TRIGGER
+ — such arguments are passed via TG_ARGV, as described
+ below.
+
+ When a PL/pgSQL function is called as a
+ trigger, several special variables are created automatically in the
+ top-level block. They are:
+
+
NEW record #
+ new database row for INSERT/UPDATE operations in row-level
+ triggers. This variable is null in statement-level triggers
+ and for DELETE operations.
+
OLD record #
+ old database row for UPDATE/DELETE operations in row-level
+ triggers. This variable is null in statement-level triggers
+ and for INSERT operations.
+
TG_NAME name #
+ name of the trigger which fired.
+
TG_WHEN text #
+ BEFORE, AFTER, or
+ INSTEAD OF, depending on the trigger's definition.
+
TG_LEVEL text #
+ ROW or STATEMENT,
+ depending on the trigger's definition.
+
TG_OP text #
+ operation for which the trigger was fired:
+ INSERT, UPDATE,
+ DELETE, or TRUNCATE.
+
TG_RELID oid (references pg_class.oid) #
+ object ID of the table that caused the trigger invocation.
+
TG_RELNAME name #
+ table that caused the trigger
+ invocation. This is now deprecated, and could disappear in a future
+ release. Use TG_TABLE_NAME instead.
+
TG_TABLE_NAME name #
+ table that caused the trigger invocation.
+
TG_TABLE_SCHEMA name #
+ schema of the table that caused the trigger invocation.
+
TG_NARGS integer #
+ number of arguments given to the trigger
+ function in the CREATE TRIGGER statement.
+
TG_ARGV text[] #
+ arguments from
+ the CREATE TRIGGER statement.
+ The index counts from 0. Invalid
+ indexes (less than 0 or greater than or equal to tg_nargs)
+ result in a null value.
+
+
+ A trigger function must return either NULL or a
+ record/row value having exactly the structure of the table the
+ trigger was fired for.
+
+ Row-level triggers fired BEFORE can return null to signal the
+ trigger manager to skip the rest of the operation for this row
+ (i.e., subsequent triggers are not fired, and the
+ INSERT/UPDATE/DELETE does not occur
+ for this row). If a nonnull
+ value is returned then the operation proceeds with that row value.
+ Returning a row value different from the original value
+ of NEW alters the row that will be inserted or
+ updated. Thus, if the trigger function wants the triggering
+ action to succeed normally without altering the row
+ value, NEW (or a value equal thereto) has to be
+ returned. To alter the row to be stored, it is possible to
+ replace single values directly in NEW and return the
+ modified NEW, or to build a complete new record/row to
+ return. In the case of a before-trigger
+ on DELETE, the returned value has no direct
+ effect, but it has to be nonnull to allow the trigger action to
+ proceed. Note that NEW is null
+ in DELETE triggers, so returning that is
+ usually not sensible. The usual idiom in DELETE
+ triggers is to return OLD.
+
+ INSTEAD OF triggers (which are always row-level triggers,
+ and may only be used on views) can return null to signal that they did
+ not perform any updates, and that the rest of the operation for this
+ row should be skipped (i.e., subsequent triggers are not fired, and the
+ row is not counted in the rows-affected status for the surrounding
+ INSERT/UPDATE/DELETE).
+ Otherwise a nonnull value should be returned, to signal
+ that the trigger performed the requested operation. For
+ INSERT and UPDATE operations, the return value
+ should be NEW, which the trigger function may modify to
+ support INSERT RETURNING and UPDATE RETURNING
+ (this will also affect the row value passed to any subsequent triggers,
+ or passed to a special EXCLUDED alias reference within
+ an INSERT statement with an ON CONFLICT DO
+ UPDATE clause). For DELETE operations, the return
+ value should be OLD.
+
+ The return value of a row-level trigger
+ fired AFTER or a statement-level trigger
+ fired BEFORE or AFTER is
+ always ignored; it might as well be null. However, any of these types of
+ triggers might still abort the entire operation by raising an error.
+
+ Example 43.3 shows an example of a
+ trigger function in PL/pgSQL.
+
Example 43.3. A PL/pgSQL Trigger Function
+ This example trigger ensures that any time a row is inserted or updated
+ in the table, the current user name and time are stamped into the
+ row. And it checks that an employee's name is given and that the
+ salary is a positive value.
+
+CREATE TABLE emp (
+ empname text,
+ salary integer,
+ last_date timestamp,
+ last_user text
+);
+
+CREATE FUNCTION emp_stamp() RETURNS trigger AS $emp_stamp$
+ BEGIN
+ -- Check that empname and salary are given
+ IF NEW.empname IS NULL THEN
+ RAISE EXCEPTION 'empname cannot be null';
+ END IF;
+ IF NEW.salary IS NULL THEN
+ RAISE EXCEPTION '% cannot have null salary', NEW.empname;
+ END IF;
+
+ -- Who works for us when they must pay for it?
+ IF NEW.salary < 0 THEN
+ RAISE EXCEPTION '% cannot have a negative salary', NEW.empname;
+ END IF;
+
+ -- Remember who changed the payroll when
+ NEW.last_date := current_timestamp;
+ NEW.last_user := current_user;
+ RETURN NEW;
+ END;
+$emp_stamp$ LANGUAGE plpgsql;
+
+CREATE TRIGGER emp_stamp BEFORE INSERT OR UPDATE ON emp
+ FOR EACH ROW EXECUTE FUNCTION emp_stamp();
+
+ Another way to log changes to a table involves creating a new table that
+ holds a row for each insert, update, or delete that occurs. This approach
+ can be thought of as auditing changes to a table.
+ Example 43.4 shows an example of an
+ audit trigger function in PL/pgSQL.
+
Example 43.4. A PL/pgSQL Trigger Function for Auditing
+ This example trigger ensures that any insert, update or delete of a row
+ in the emp table is recorded (i.e., audited) in the emp_audit table.
+ The current time and user name are stamped into the row, together with
+ the type of operation performed on it.
+
+CREATE TABLE emp (
+ empname text NOT NULL,
+ salary integer
+);
+
+CREATE TABLE emp_audit(
+ operation char(1) NOT NULL,
+ stamp timestamp NOT NULL,
+ userid text NOT NULL,
+ empname text NOT NULL,
+ salary integer
+);
+
+CREATE OR REPLACE FUNCTION process_emp_audit() RETURNS TRIGGER AS $emp_audit$
+ BEGIN
+ --
+ -- Create a row in emp_audit to reflect the operation performed on emp,
+ -- making use of the special variable TG_OP to work out the operation.
+ --
+ IF (TG_OP = 'DELETE') THEN
+ INSERT INTO emp_audit SELECT 'D', now(), current_user, OLD.*;
+ ELSIF (TG_OP = 'UPDATE') THEN
+ INSERT INTO emp_audit SELECT 'U', now(), current_user, NEW.*;
+ ELSIF (TG_OP = 'INSERT') THEN
+ INSERT INTO emp_audit SELECT 'I', now(), current_user, NEW.*;
+ END IF;
+ RETURN NULL; -- result is ignored since this is an AFTER trigger
+ END;
+$emp_audit$ LANGUAGE plpgsql;
+
+CREATE TRIGGER emp_audit
+AFTER INSERT OR UPDATE OR DELETE ON emp
+ FOR EACH ROW EXECUTE FUNCTION process_emp_audit();
+
+ A variation of the previous example uses a view joining the main table
+ to the audit table, to show when each entry was last modified. This
+ approach still records the full audit trail of changes to the table,
+ but also presents a simplified view of the audit trail, showing just
+ the last modified timestamp derived from the audit trail for each entry.
+ Example 43.5 shows an example
+ of an audit trigger on a view in PL/pgSQL.
+
Example 43.5. A PL/pgSQL View Trigger Function for Auditing
+ This example uses a trigger on the view to make it updatable, and
+ ensure that any insert, update or delete of a row in the view is
+ recorded (i.e., audited) in the emp_audit table. The current time
+ and user name are recorded, together with the type of operation
+ performed, and the view displays the last modified time of each row.
+
+CREATE TABLE emp (
+ empname text PRIMARY KEY,
+ salary integer
+);
+
+CREATE TABLE emp_audit(
+ operation char(1) NOT NULL,
+ userid text NOT NULL,
+ empname text NOT NULL,
+ salary integer,
+ stamp timestamp NOT NULL
+);
+
+CREATE VIEW emp_view AS
+ SELECT e.empname,
+ e.salary,
+ max(ea.stamp) AS last_updated
+ FROM emp e
+ LEFT JOIN emp_audit ea ON ea.empname = e.empname
+ GROUP BY 1, 2;
+
+CREATE OR REPLACE FUNCTION update_emp_view() RETURNS TRIGGER AS $$
+ BEGIN
+ --
+ -- Perform the required operation on emp, and create a row in emp_audit
+ -- to reflect the change made to emp.
+ --
+ IF (TG_OP = 'DELETE') THEN
+ DELETE FROM emp WHERE empname = OLD.empname;
+ IF NOT FOUND THEN RETURN NULL; END IF;
+
+ OLD.last_updated = now();
+ INSERT INTO emp_audit VALUES('D', current_user, OLD.*);
+ RETURN OLD;
+ ELSIF (TG_OP = 'UPDATE') THEN
+ UPDATE emp SET salary = NEW.salary WHERE empname = OLD.empname;
+ IF NOT FOUND THEN RETURN NULL; END IF;
+
+ NEW.last_updated = now();
+ INSERT INTO emp_audit VALUES('U', current_user, NEW.*);
+ RETURN NEW;
+ ELSIF (TG_OP = 'INSERT') THEN
+ INSERT INTO emp VALUES(NEW.empname, NEW.salary);
+
+ NEW.last_updated = now();
+ INSERT INTO emp_audit VALUES('I', current_user, NEW.*);
+ RETURN NEW;
+ END IF;
+ END;
+$$ LANGUAGE plpgsql;
+
+CREATE TRIGGER emp_audit
+INSTEAD OF INSERT OR UPDATE OR DELETE ON emp_view
+ FOR EACH ROW EXECUTE FUNCTION update_emp_view();
+
+ One use of triggers is to maintain a summary table
+ of another table. The resulting summary can be used in place of the
+ original table for certain queries — often with vastly reduced run
+ times.
+ This technique is commonly used in Data Warehousing, where the tables
+ of measured or observed data (called fact tables) might be extremely large.
+ Example 43.6 shows an example of a
+ trigger function in PL/pgSQL that maintains
+ a summary table for a fact table in a data warehouse.
+
Example 43.6. A PL/pgSQL Trigger Function for Maintaining a Summary Table
+ The schema detailed here is partly based on the Grocery Store
+ example from The Data Warehouse Toolkit
+ by Ralph Kimball.
+
+--
+-- Main tables - time dimension and sales fact.
+--
+CREATE TABLE time_dimension (
+ time_key integer NOT NULL,
+ day_of_week integer NOT NULL,
+ day_of_month integer NOT NULL,
+ month integer NOT NULL,
+ quarter integer NOT NULL,
+ year integer NOT NULL
+);
+CREATE UNIQUE INDEX time_dimension_key ON time_dimension(time_key);
+
+CREATE TABLE sales_fact (
+ time_key integer NOT NULL,
+ product_key integer NOT NULL,
+ store_key integer NOT NULL,
+ amount_sold numeric(12,2) NOT NULL,
+ units_sold integer NOT NULL,
+ amount_cost numeric(12,2) NOT NULL
+);
+CREATE INDEX sales_fact_time ON sales_fact(time_key);
+
+--
+-- Summary table - sales by time.
+--
+CREATE TABLE sales_summary_bytime (
+ time_key integer NOT NULL,
+ amount_sold numeric(15,2) NOT NULL,
+ units_sold numeric(12) NOT NULL,
+ amount_cost numeric(15,2) NOT NULL
+);
+CREATE UNIQUE INDEX sales_summary_bytime_key ON sales_summary_bytime(time_key);
+
+--
+-- Function and trigger to amend summarized column(s) on UPDATE, INSERT, DELETE.
+--
+CREATE OR REPLACE FUNCTION maint_sales_summary_bytime() RETURNS TRIGGER
+AS $maint_sales_summary_bytime$
+ DECLARE
+ delta_time_key integer;
+ delta_amount_sold numeric(15,2);
+ delta_units_sold numeric(12);
+ delta_amount_cost numeric(15,2);
+ BEGIN
+
+ -- Work out the increment/decrement amount(s).
+ IF (TG_OP = 'DELETE') THEN
+
+ delta_time_key = OLD.time_key;
+ delta_amount_sold = -1 * OLD.amount_sold;
+ delta_units_sold = -1 * OLD.units_sold;
+ delta_amount_cost = -1 * OLD.amount_cost;
+
+ ELSIF (TG_OP = 'UPDATE') THEN
+
+ -- forbid updates that change the time_key -
+ -- (probably not too onerous, as DELETE + INSERT is how most
+ -- changes will be made).
+ IF ( OLD.time_key != NEW.time_key) THEN
+ RAISE EXCEPTION 'Update of time_key : % -> % not allowed',
+ OLD.time_key, NEW.time_key;
+ END IF;
+
+ delta_time_key = OLD.time_key;
+ delta_amount_sold = NEW.amount_sold - OLD.amount_sold;
+ delta_units_sold = NEW.units_sold - OLD.units_sold;
+ delta_amount_cost = NEW.amount_cost - OLD.amount_cost;
+
+ ELSIF (TG_OP = 'INSERT') THEN
+
+ delta_time_key = NEW.time_key;
+ delta_amount_sold = NEW.amount_sold;
+ delta_units_sold = NEW.units_sold;
+ delta_amount_cost = NEW.amount_cost;
+
+ END IF;
+
+
+ -- Insert or update the summary row with the new values.
+ <<insert_update>>
+ LOOP
+ UPDATE sales_summary_bytime
+ SET amount_sold = amount_sold + delta_amount_sold,
+ units_sold = units_sold + delta_units_sold,
+ amount_cost = amount_cost + delta_amount_cost
+ WHERE time_key = delta_time_key;
+
+ EXIT insert_update WHEN found;
+
+ BEGIN
+ INSERT INTO sales_summary_bytime (
+ time_key,
+ amount_sold,
+ units_sold,
+ amount_cost)
+ VALUES (
+ delta_time_key,
+ delta_amount_sold,
+ delta_units_sold,
+ delta_amount_cost
+ );
+
+ EXIT insert_update;
+
+ EXCEPTION
+ WHEN UNIQUE_VIOLATION THEN
+ -- do nothing
+ END;
+ END LOOP insert_update;
+
+ RETURN NULL;
+
+ END;
+$maint_sales_summary_bytime$ LANGUAGE plpgsql;
+
+CREATE TRIGGER maint_sales_summary_bytime
+AFTER INSERT OR UPDATE OR DELETE ON sales_fact
+ FOR EACH ROW EXECUTE FUNCTION maint_sales_summary_bytime();
+
+INSERT INTO sales_fact VALUES(1,1,1,10,3,15);
+INSERT INTO sales_fact VALUES(1,2,1,20,5,35);
+INSERT INTO sales_fact VALUES(2,2,1,40,15,135);
+INSERT INTO sales_fact VALUES(2,3,1,10,1,13);
+SELECT * FROM sales_summary_bytime;
+DELETE FROM sales_fact WHERE product_key = 1;
+SELECT * FROM sales_summary_bytime;
+UPDATE sales_fact SET units_sold = units_sold * 2;
+SELECT * FROM sales_summary_bytime;
+
+ AFTER triggers can also make use of transition
+ tables to inspect the entire set of rows changed by the triggering
+ statement. The CREATE TRIGGER command assigns names to one
+ or both transition tables, and then the function can refer to those names
+ as though they were read-only temporary tables.
+ Example 43.7 shows an example.
+
Example 43.7. Auditing with Transition Tables
+ This example produces the same results as
+ Example 43.4, but instead of using a
+ trigger that fires for every row, it uses a trigger that fires once
+ per statement, after collecting the relevant information in a transition
+ table. This can be significantly faster than the row-trigger approach
+ when the invoking statement has modified many rows. Notice that we must
+ make a separate trigger declaration for each kind of event, since the
+ REFERENCING clauses must be different for each case. But
+ this does not stop us from using a single trigger function if we choose.
+ (In practice, it might be better to use three separate functions and
+ avoid the run-time tests on TG_OP.)
+
+CREATE TABLE emp (
+ empname text NOT NULL,
+ salary integer
+);
+
+CREATE TABLE emp_audit(
+ operation char(1) NOT NULL,
+ stamp timestamp NOT NULL,
+ userid text NOT NULL,
+ empname text NOT NULL,
+ salary integer
+);
+
+CREATE OR REPLACE FUNCTION process_emp_audit() RETURNS TRIGGER AS $emp_audit$
+ BEGIN
+ --
+ -- Create rows in emp_audit to reflect the operations performed on emp,
+ -- making use of the special variable TG_OP to work out the operation.
+ --
+ IF (TG_OP = 'DELETE') THEN
+ INSERT INTO emp_audit
+ SELECT 'D', now(), current_user, o.* FROM old_table o;
+ ELSIF (TG_OP = 'UPDATE') THEN
+ INSERT INTO emp_audit
+ SELECT 'U', now(), current_user, n.* FROM new_table n;
+ ELSIF (TG_OP = 'INSERT') THEN
+ INSERT INTO emp_audit
+ SELECT 'I', now(), current_user, n.* FROM new_table n;
+ END IF;
+ RETURN NULL; -- result is ignored since this is an AFTER trigger
+ END;
+$emp_audit$ LANGUAGE plpgsql;
+
+CREATE TRIGGER emp_audit_ins
+ AFTER INSERT ON emp
+ REFERENCING NEW TABLE AS new_table
+ FOR EACH STATEMENT EXECUTE FUNCTION process_emp_audit();
+CREATE TRIGGER emp_audit_upd
+ AFTER UPDATE ON emp
+ REFERENCING OLD TABLE AS old_table NEW TABLE AS new_table
+ FOR EACH STATEMENT EXECUTE FUNCTION process_emp_audit();
+CREATE TRIGGER emp_audit_del
+ AFTER DELETE ON emp
+ REFERENCING OLD TABLE AS old_table
+ FOR EACH STATEMENT EXECUTE FUNCTION process_emp_audit();
+
43.10.2. Triggers on Events #
+ PL/pgSQL can be used to define
+ event triggers.
+ PostgreSQL requires that a function that
+ is to be called as an event trigger must be declared as a function with
+ no arguments and a return type of event_trigger.
+
+ When a PL/pgSQL function is called as an
+ event trigger, several special variables are created automatically
+ in the top-level block. They are:
+
+
TG_EVENT text #
+ event the trigger is fired for.
+
TG_TAG text #
+ command tag for which the trigger is fired.
+
+
+ Example 43.8 shows an example of an
+ event trigger function in PL/pgSQL.
+
Example 43.8. A PL/pgSQL Event Trigger Function
+ This example trigger simply raises a NOTICE message
+ each time a supported command is executed.
+
+CREATE OR REPLACE FUNCTION snitch() RETURNS event_trigger AS $$
+BEGIN
+ RAISE NOTICE 'snitch: % %', tg_event, tg_tag;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE EVENT TRIGGER snitch ON ddl_command_start EXECUTE FUNCTION snitch();
+
Chapter 43. PL/pgSQL — SQL Procedural Language
+ Generally speaking, the aim of PL/Python is to provide
+ a “natural” mapping between the PostgreSQL and the
+ Python worlds. This informs the data mapping rules described
+ below.
+
46.2.1. Data Type Mapping #
+ When a PL/Python function is called, its arguments are converted from
+ their PostgreSQL data type to a corresponding Python type:
+
+
+ PostgreSQL boolean is converted to Python bool.
+
+ PostgreSQL smallint, int, bigint
+ and oid are converted to Python int.
+
+ PostgreSQL real and double are converted to
+ Python float.
+
+ PostgreSQL numeric is converted to
+ Python Decimal. This type is imported from
+ the cdecimal package if that is available.
+ Otherwise,
+ decimal.Decimal from the standard library will be
+ used. cdecimal is significantly faster
+ than decimal. In Python 3.3 and up,
+ however, cdecimal has been integrated into the
+ standard library under the name decimal, so there is
+ no longer any difference.
+
+ PostgreSQL bytea is converted to Python bytes.
+
+ All other data types, including the PostgreSQL character string types,
+ are converted to a Python str (in Unicode like all Python
+ strings).
+
+ For nonscalar data types, see below.
+
+
+ When a PL/Python function returns, its return value is converted to the
+ function's declared PostgreSQL return data type as follows:
+
+
+ When the PostgreSQL return type is boolean, the
+ return value will be evaluated for truth according to the
+ Python rules. That is, 0 and empty string
+ are false, but notably 'f' is true.
+
+ When the PostgreSQL return type is bytea, the return value
+ will be converted to Python bytes using the respective
+ Python built-ins, with the result being converted to
+ bytea.
+
+ For all other PostgreSQL return types, the return value is converted
+ to a string using the Python built-in str, and the
+ result is passed to the input function of the PostgreSQL data type.
+ (If the Python value is a float, it is converted using
+ the repr built-in instead of str, to
+ avoid loss of precision.)
+
+ Strings are automatically converted to the PostgreSQL server encoding
+ when they are passed to PostgreSQL.
+
+ For nonscalar data types, see below.
+
+
+ Note that logical mismatches between the declared PostgreSQL
+ return type and the Python data type of the actual return object
+ are not flagged; the value will be converted in any case.
+
+ If an SQL null value is passed to a
+ function, the argument value will appear as None in
+ Python. For example, the function definition of pymax
+ shown in Section 46.1 will return the wrong answer for null
+ inputs. We could add STRICT to the function definition
+ to make PostgreSQL do something more reasonable:
+ if a null value is passed, the function will not be called at all,
+ but will just return a null result automatically. Alternatively,
+ we could check for null inputs in the function body:
+
+
+CREATE FUNCTION pymax (a integer, b integer)
+ RETURNS integer
+AS $$
+ if (a is None) or (b is None):
+ return None
+ if a > b:
+ return a
+ return b
+$$ LANGUAGE plpython3u;
+
+
+ As shown above, to return an SQL null value from a PL/Python
+ function, return the value None. This can be done whether the
+ function is strict or not.
+
+ SQL array values are passed into PL/Python as a Python list. To
+ return an SQL array value out of a PL/Python function, return a
+ Python list:
+
+
+CREATE FUNCTION return_arr()
+ RETURNS int[]
+AS $$
+return [1, 2, 3, 4, 5]
+$$ LANGUAGE plpython3u;
+
+SELECT return_arr();
+ return_arr
+-------------
+ {1,2,3,4,5}
+(1 row)
+
+
+ Multidimensional arrays are passed into PL/Python as nested Python lists.
+ A 2-dimensional array is a list of lists, for example. When returning
+ a multi-dimensional SQL array out of a PL/Python function, the inner
+ lists at each level must all be of the same size. For example:
+
+
+CREATE FUNCTION test_type_conversion_array_int4(x int4[]) RETURNS int4[] AS $$
+plpy.info(x, type(x))
+return x
+$$ LANGUAGE plpython3u;
+
+SELECT * FROM test_type_conversion_array_int4(ARRAY[[1,2,3],[4,5,6]]);
+INFO: ([[1, 2, 3], [4, 5, 6]], <type 'list'>)
+ test_type_conversion_array_int4
+---------------------------------
+ {{1,2,3},{4,5,6}}
+(1 row)
+
+
+ Other Python sequences, like tuples, are also accepted for
+ backwards-compatibility with PostgreSQL versions 9.6 and below, when
+ multi-dimensional arrays were not supported. However, they are always
+ treated as one-dimensional arrays, because they are ambiguous with
+ composite types. For the same reason, when a composite type is used in a
+ multi-dimensional array, it must be represented by a tuple, rather than a
+ list.
+
+ Note that in Python, strings are sequences, which can have
+ undesirable effects that might be familiar to Python programmers:
+
+
+CREATE FUNCTION return_str_arr()
+ RETURNS varchar[]
+AS $$
+return "hello"
+$$ LANGUAGE plpython3u;
+
+SELECT return_str_arr();
+ return_str_arr
+----------------
+ {h,e,l,l,o}
+(1 row)
+
+
46.2.4. Composite Types #
+ Composite-type arguments are passed to the function as Python mappings. The
+ element names of the mapping are the attribute names of the composite type.
+ If an attribute in the passed row has the null value, it has the value
+ None in the mapping. Here is an example:
+
+
+CREATE TABLE employee (
+ name text,
+ salary integer,
+ age integer
+);
+
+CREATE FUNCTION overpaid (e employee)
+ RETURNS boolean
+AS $$
+ if e["salary"] > 200000:
+ return True
+ if (e["age"] < 30) and (e["salary"] > 100000):
+ return True
+ return False
+$$ LANGUAGE plpython3u;
+
+
+ There are multiple ways to return row or composite types from a Python
+ function. The following examples assume we have:
+
+
+CREATE TYPE named_value AS (
+ name text,
+ value integer
+);
+
+
+ A composite result can be returned as a:
+
+
- Sequence type (a tuple or list, but not a set because
+ it is not indexable)
+ Returned sequence objects must have the same number of items as the
+ composite result type has fields. The item with index 0 is assigned to
+ the first field of the composite type, 1 to the second and so on. For
+ example:
+
+
+CREATE FUNCTION make_pair (name text, value integer)
+ RETURNS named_value
+AS $$
+ return ( name, value )
+ # or alternatively, as list: return [ name, value ]
+$$ LANGUAGE plpython3u;
+
+
+ To return an SQL null for any column, insert None at
+ the corresponding position.
+
+ When an array of composite types is returned, it cannot be returned as a list,
+ because it is ambiguous whether the Python list represents a composite type,
+ or another array dimension.
+
- Mapping (dictionary)
+ The value for each result type column is retrieved from the mapping
+ with the column name as key. Example:
+
+
+CREATE FUNCTION make_pair (name text, value integer)
+ RETURNS named_value
+AS $$
+ return { "name": name, "value": value }
+$$ LANGUAGE plpython3u;
+
+
+ Any extra dictionary key/value pairs are ignored. Missing keys are
+ treated as errors.
+ To return an SQL null value for any column, insert
+ None with the corresponding column name as the key.
+
- Object (any object providing method
__getattr__)
+ This works the same as a mapping.
+ Example:
+
+
+CREATE FUNCTION make_pair (name text, value integer)
+ RETURNS named_value
+AS $$
+ class named_value:
+ def __init__ (self, n, v):
+ self.name = n
+ self.value = v
+ return named_value(name, value)
+
+ # or simply
+ class nv: pass
+ nv.name = name
+ nv.value = value
+ return nv
+$$ LANGUAGE plpython3u;
+
+
+
+ Functions with OUT parameters are also supported. For example:
+
+CREATE FUNCTION multiout_simple(OUT i integer, OUT j integer) AS $$
+return (1, 2)
+$$ LANGUAGE plpython3u;
+
+SELECT * FROM multiout_simple();
+
+
+ Output parameters of procedures are passed back the same way. For example:
+
+CREATE PROCEDURE python_triple(INOUT a integer, INOUT b integer) AS $$
+return (a * 3, b * 3)
+$$ LANGUAGE plpython3u;
+
+CALL python_triple(5, 10);
+
+
46.2.5. Set-Returning Functions #
+ A PL/Python function can also return sets of
+ scalar or composite types. There are several ways to achieve this because
+ the returned object is internally turned into an iterator. The following
+ examples assume we have composite type:
+
+
+CREATE TYPE greeting AS (
+ how text,
+ who text
+);
+
+
+ A set result can be returned from a:
+
+
- Sequence type (tuple, list, set)
+
+CREATE FUNCTION greet (how text)
+ RETURNS SETOF greeting
+AS $$
+ # return tuple containing lists as composite types
+ # all other combinations work also
+ return ( [ how, "World" ], [ how, "PostgreSQL" ], [ how, "PL/Python" ] )
+$$ LANGUAGE plpython3u;
+
+
- Iterator (any object providing
__iter__ and
+ next methods)
+
+CREATE FUNCTION greet (how text)
+ RETURNS SETOF greeting
+AS $$
+ class producer:
+ def __init__ (self, how, who):
+ self.how = how
+ self.who = who
+ self.ndx = -1
+
+ def __iter__ (self):
+ return self
+
+ def next (self):
+ self.ndx += 1
+ if self.ndx == len(self.who):
+ raise StopIteration
+ return ( self.how, self.who[self.ndx] )
+
+ return producer(how, [ "World", "PostgreSQL", "PL/Python" ])
+$$ LANGUAGE plpython3u;
+
+
- Generator (
yield)
+
+CREATE FUNCTION greet (how text)
+ RETURNS SETOF greeting
+AS $$
+ for who in [ "World", "PostgreSQL", "PL/Python" ]:
+ yield ( how, who )
+$$ LANGUAGE plpython3u;
+
+
+
+
+ Set-returning functions with OUT parameters
+ (using RETURNS SETOF record) are also
+ supported. For example:
+
+CREATE FUNCTION multiout_simple_setof(n integer, OUT integer, OUT integer) RETURNS SETOF record AS $$
+return [(1, 2)] * n
+$$ LANGUAGE plpython3u;
+
+SELECT * FROM multiout_simple_setof(3);
+
+
+ The PL/Python language module automatically imports a Python module
+ called plpy. The functions and constants in
+ this module are available to you in the Python code as
+ plpy.foo.
+
46.6.1. Database Access Functions #
+ The plpy module provides several functions to execute
+ database commands:
+
plpy.execute(query [, limit])
+ Calling plpy.execute with a query string and an
+ optional row limit argument causes that query to be run and the result to
+ be returned in a result object.
+
+ If limit is specified and is greater than
+ zero, then plpy.execute retrieves at
+ most limit rows, much as if the query
+ included a LIMIT
+ clause. Omitting limit or specifying it as
+ zero results in no row limit.
+
+ The result object emulates a list or dictionary object. The result
+ object can be accessed by row number and column name. For example:
+
+rv = plpy.execute("SELECT * FROM my_table", 5)
+
+ returns up to 5 rows from my_table. If
+ my_table has a column
+ my_column, it would be accessed as:
+
+foo = rv[i]["my_column"]
+
+ The number of rows returned can be obtained using the built-in
+ len function.
+
+ The result object has these additional methods:
+
nrows()
+ Returns the number of rows processed by the command. Note that this
+ is not necessarily the same as the number of rows returned. For
+ example, an UPDATE command will set this value but
+ won't return any rows (unless RETURNING is used).
+
status()
+ The SPI_execute() return value.
+
colnames()
coltypes()
coltypmods()
+ Return a list of column names, list of column type OIDs, and list of
+ type-specific type modifiers for the columns, respectively.
+
+ These methods raise an exception when called on a result object from
+ a command that did not produce a result set, e.g.,
+ UPDATE without RETURNING, or
+ DROP TABLE. But it is OK to use these methods on
+ a result set containing zero rows.
+
__str__()
+ The standard __str__ method is defined so that it
+ is possible for example to debug query execution results
+ using plpy.debug(rv).
+
+
+ The result object can be modified.
+
+ Note that calling plpy.execute will cause the entire
+ result set to be read into memory. Only use that function when you are
+ sure that the result set will be relatively small. If you don't want to
+ risk excessive memory usage when fetching large results,
+ use plpy.cursor rather
+ than plpy.execute.
+
plpy.prepare(query [, argtypes])
plpy.execute(plan [, arguments [, limit]])
+
+ plpy.prepare prepares the execution plan for a
+ query. It is called with a query string and a list of parameter types,
+ if you have parameter references in the query. For example:
+
+plan = plpy.prepare("SELECT last_name FROM my_users WHERE first_name = $1", ["text"])
+
+ text is the type of the variable you will be passing
+ for $1. The second argument is optional if you don't
+ want to pass any parameters to the query.
+
+ After preparing a statement, you use a variant of the
+ function plpy.execute to run it:
+
+rv = plpy.execute(plan, ["name"], 5)
+
+ Pass the plan as the first argument (instead of the query string), and a
+ list of values to substitute into the query as the second argument. The
+ second argument is optional if the query does not expect any parameters.
+ The third argument is the optional row limit as before.
+
+ Alternatively, you can call the execute method on
+ the plan object:
+
+rv = plan.execute(["name"], 5)
+
+
+ Query parameters and result row fields are converted between PostgreSQL
+ and Python data types as described in Section 46.2.
+
+ When you prepare a plan using the PL/Python module it is automatically
+ saved. Read the SPI documentation (Chapter 47) for a
+ description of what this means. In order to make effective use of this
+ across function calls one needs to use one of the persistent storage
+ dictionaries SD or GD (see
+ Section 46.3). For example:
+
+CREATE FUNCTION usesavedplan() RETURNS trigger AS $$
+ if "plan" in SD:
+ plan = SD["plan"]
+ else:
+ plan = plpy.prepare("SELECT 1")
+ SD["plan"] = plan
+ # rest of function
+$$ LANGUAGE plpython3u;
+
+
plpy.cursor(query)
plpy.cursor(plan [, arguments])
+ The plpy.cursor function accepts the same arguments
+ as plpy.execute (except for the row limit) and returns
+ a cursor object, which allows you to process large result sets in smaller
+ chunks. As with plpy.execute, either a query string
+ or a plan object along with a list of arguments can be used, or
+ the cursor function can be called as a method of
+ the plan object.
+
+ The cursor object provides a fetch method that accepts
+ an integer parameter and returns a result object. Each time you
+ call fetch, the returned object will contain the next
+ batch of rows, never larger than the parameter value. Once all rows are
+ exhausted, fetch starts returning an empty result
+ object. Cursor objects also provide an
+ iterator
+ interface, yielding one row at a time until all rows are
+ exhausted. Data fetched that way is not returned as result objects, but
+ rather as dictionaries, each dictionary corresponding to a single result
+ row.
+
+ An example of two ways of processing data from a large table is:
+
+CREATE FUNCTION count_odd_iterator() RETURNS integer AS $$
+odd = 0
+for row in plpy.cursor("select num from largetable"):
+ if row['num'] % 2:
+ odd += 1
+return odd
+$$ LANGUAGE plpython3u;
+
+CREATE FUNCTION count_odd_fetch(batch_size integer) RETURNS integer AS $$
+odd = 0
+cursor = plpy.cursor("select num from largetable")
+while True:
+ rows = cursor.fetch(batch_size)
+ if not rows:
+ break
+ for row in rows:
+ if row['num'] % 2:
+ odd += 1
+return odd
+$$ LANGUAGE plpython3u;
+
+CREATE FUNCTION count_odd_prepared() RETURNS integer AS $$
+odd = 0
+plan = plpy.prepare("select num from largetable where num % $1 <> 0", ["integer"])
+rows = list(plpy.cursor(plan, [2])) # or: = list(plan.cursor([2]))
+
+return len(rows)
+$$ LANGUAGE plpython3u;
+
+
+ Cursors are automatically disposed of. But if you want to explicitly
+ release all resources held by a cursor, use the close
+ method. Once closed, a cursor cannot be fetched from anymore.
+
Tip
+ Do not confuse objects created by plpy.cursor with
+ DB-API cursors as defined by
+ the Python
+ Database API specification. They don't have anything in common
+ except for the name.
+
46.6.2. Trapping Errors #
+ Functions accessing the database might encounter errors, which
+ will cause them to abort and raise an exception. Both
+ plpy.execute and
+ plpy.prepare can raise an instance of a subclass of
+ plpy.SPIError, which by default will terminate
+ the function. This error can be handled just like any other
+ Python exception, by using the try/except
+ construct. For example:
+
+CREATE FUNCTION try_adding_joe() RETURNS text AS $$
+ try:
+ plpy.execute("INSERT INTO users(username) VALUES ('joe')")
+ except plpy.SPIError:
+ return "something went wrong"
+ else:
+ return "Joe added"
+$$ LANGUAGE plpython3u;
+
+
+ The actual class of the exception being raised corresponds to the
+ specific condition that caused the error. Refer
+ to Table A.1 for a list of possible
+ conditions. The module
+ plpy.spiexceptions defines an exception class
+ for each PostgreSQL condition, deriving
+ their names from the condition name. For
+ instance, division_by_zero
+ becomes DivisionByZero, unique_violation
+ becomes UniqueViolation, fdw_error
+ becomes FdwError, and so on. Each of these
+ exception classes inherits from SPIError. This
+ separation makes it easier to handle specific errors, for
+ instance:
+
+CREATE FUNCTION insert_fraction(numerator int, denominator int) RETURNS text AS $$
+from plpy import spiexceptions
+try:
+ plan = plpy.prepare("INSERT INTO fractions (frac) VALUES ($1 / $2)", ["int", "int"])
+ plpy.execute(plan, [numerator, denominator])
+except spiexceptions.DivisionByZero:
+ return "denominator cannot equal zero"
+except spiexceptions.UniqueViolation:
+ return "already have that fraction"
+except plpy.SPIError as e:
+ return "other error, SQLSTATE %s" % e.sqlstate
+else:
+ return "fraction inserted"
+$$ LANGUAGE plpython3u;
+
+ Note that because all exceptions from
+ the plpy.spiexceptions module inherit
+ from SPIError, an except
+ clause handling it will catch any database access error.
+
+ As an alternative way of handling different error conditions, you
+ can catch the SPIError exception and determine
+ the specific error condition inside the except
+ block by looking at the sqlstate attribute of
+ the exception object. This attribute is a string value containing
+ the “SQLSTATE” error code. This approach provides
+ approximately the same functionality
+
46.4. Anonymous Code Blocks #
+ PL/Python also supports anonymous code blocks called with the
+ DO statement:
+
+
+DO $$
+ # PL/Python code
+$$ LANGUAGE plpython3u;
+
+
+ An anonymous code block receives no arguments, and whatever value it
+ might return is discarded. Otherwise it behaves just like a function.
+
46.11. Environment Variables #
+ Some of the environment variables that are accepted by the Python
+ interpreter can also be used to affect PL/Python behavior. They
+ would need to be set in the environment of the main PostgreSQL
+ server process, for example in a start script. The available
+ environment variables depend on the version of Python; see the
+ Python documentation for details. At the time of this writing, the
+ following environment variables have an affect on PL/Python,
+ assuming an adequate Python version:
+
PYTHONHOME
PYTHONPATH
PYTHONY2K
PYTHONOPTIMIZE
PYTHONDEBUG
PYTHONVERBOSE
PYTHONCASEOK
PYTHONDONTWRITEBYTECODE
PYTHONIOENCODING
PYTHONUSERBASE
PYTHONHASHSEED
+
+ (It appears to be a Python implementation detail beyond the control
+ of PL/Python that some of the environment variables listed on
+ the python man page are only effective in a
+ command-line interpreter and not an embedded Python interpreter.)
+
46.1. PL/Python Functions #
+ Functions in PL/Python are declared via the
+ standard CREATE FUNCTION syntax:
+
+
+CREATE FUNCTION funcname (argument-list)
+ RETURNS return-type
+AS $$
+ # PL/Python function body
+$$ LANGUAGE plpython3u;
+
+
+ The body of a function is simply a Python script. When the function
+ is called, its arguments are passed as elements of the list
+ args; named arguments are also passed as
+ ordinary variables to the Python script. Use of named arguments is
+ usually more readable. The result is returned from the Python code
+ in the usual way, with return or
+ yield (in case of a result-set statement). If
+ you do not provide a return value, Python returns the default
+ None. PL/Python translates
+ Python's None into the SQL null value. In a procedure,
+ the result from the Python code must be None (typically
+ achieved by ending the procedure without a return
+ statement or by using a return statement without
+ argument); otherwise, an error will be raised.
+
+ For example, a function to return the greater of two integers can be
+ defined as:
+
+
+CREATE FUNCTION pymax (a integer, b integer)
+ RETURNS integer
+AS $$
+ if a > b:
+ return a
+ return b
+$$ LANGUAGE plpython3u;
+
+
+ The Python code that is given as the body of the function definition
+ is transformed into a Python function. For example, the above results in:
+
+
+def __plpython_procedure_pymax_23456():
+ if a > b:
+ return a
+ return b
+
+
+ assuming that 23456 is the OID assigned to the function by
+ PostgreSQL.
+
+ The arguments are set as global variables. Because of the scoping
+ rules of Python, this has the subtle consequence that an argument
+ variable cannot be reassigned inside the function to the value of
+ an expression that involves the variable name itself, unless the
+ variable is redeclared as global in the block. For example, the
+ following won't work:
+
+CREATE FUNCTION pystrip(x text)
+ RETURNS text
+AS $$
+ x = x.strip() # error
+ return x
+$$ LANGUAGE plpython3u;
+
+ because assigning to x
+ makes x a local variable for the entire block,
+ and so the x on the right-hand side of the
+ assignment refers to a not-yet-assigned local
+ variable x, not the PL/Python function
+ parameter. Using the global statement, this can
+ be made to work:
+
+CREATE FUNCTION pystrip(x text)
+ RETURNS text
+AS $$
+ global x
+ x = x.strip() # ok now
+ return x
+$$ LANGUAGE plpython3u;
+
+ But it is advisable not to rely on this implementation detail of
+ PL/Python. It is better to treat the function parameters as
+ read-only.
+
46.10. Python 2 vs. Python 3 #
+ PL/Python supports only Python 3. Past versions of
+ PostgreSQL supported Python 2, using the
+ plpythonu and plpython2u language
+ names.
+
+ The global dictionary SD is available to store
+ private data between repeated calls to the same function.
+ The global dictionary GD is public data,
+ that is available to all Python functions within a session; use with
+ care.
+
+ Each function gets its own execution environment in the
+ Python interpreter, so that global data and function arguments from
+ myfunc are not available to
+ myfunc2. The exception is the data in the
+ GD dictionary, as mentioned above.
+
46.7. Explicit Subtransactions #
+ Recovering from errors caused by database access as described in
+ Section 46.6.2 can lead to an undesirable
+ situation where some operations succeed before one of them fails,
+ and after recovering from that error the data is left in an
+ inconsistent state. PL/Python offers a solution to this problem in
+ the form of explicit subtransactions.
+
46.7.1. Subtransaction Context Managers #
+ Consider a function that implements a transfer between two
+ accounts:
+
+CREATE FUNCTION transfer_funds() RETURNS void AS $$
+try:
+ plpy.execute("UPDATE accounts SET balance = balance - 100 WHERE account_name = 'joe'")
+ plpy.execute("UPDATE accounts SET balance = balance + 100 WHERE account_name = 'mary'")
+except plpy.SPIError as e:
+ result = "error transferring funds: %s" % e.args
+else:
+ result = "funds transferred correctly"
+plan = plpy.prepare("INSERT INTO operations (result) VALUES ($1)", ["text"])
+plpy.execute(plan, [result])
+$$ LANGUAGE plpython3u;
+
+ If the second UPDATE statement results in an
+ exception being raised, this function will report the error, but
+ the result of the first UPDATE will
+ nevertheless be committed. In other words, the funds will be
+ withdrawn from Joe's account, but will not be transferred to
+ Mary's account.
+
+ To avoid such issues, you can wrap your
+ plpy.execute calls in an explicit
+ subtransaction. The plpy module provides a
+ helper object to manage explicit subtransactions that gets created
+ with the plpy.subtransaction() function.
+ Objects created by this function implement the
+
+ context manager interface. Using explicit subtransactions
+ we can rewrite our function as:
+
+CREATE FUNCTION transfer_funds2() RETURNS void AS $$
+try:
+ with plpy.subtransaction():
+ plpy.execute("UPDATE accounts SET balance = balance - 100 WHERE account_name = 'joe'")
+ plpy.execute("UPDATE accounts SET balance = balance + 100 WHERE account_name = 'mary'")
+except plpy.SPIError as e:
+ result = "error transferring funds: %s" % e.args
+else:
+ result = "funds transferred correctly"
+plan = plpy.prepare("INSERT INTO operations (result) VALUES ($1)", ["text"])
+plpy.execute(plan, [result])
+$$ LANGUAGE plpython3u;
+
+ Note that the use of try/except is still
+ required. Otherwise the exception would propagate to the top of
+ the Python stack and would cause the whole function to abort with
+ a PostgreSQL error, so that the
+ operations table would not have any row
+ inserted into it. The subtransaction context manager does not
+ trap errors, it only assures that all database operations executed
+ inside its scope will be atomically committed or rolled back. A
+ rollback of the subtransaction block occurs on any kind of
+ exception exit, not only ones caused by errors originating from
+ database access. A regular Python exception raised inside an
+ explicit subtransaction block would also cause the subtransaction
+ to be rolled back.
+
46.8. Transaction Management #
+ In a procedure called from the top level or an anonymous code block
+ (DO command) called from the top level it is possible to
+ control transactions. To commit the current transaction, call
+ plpy.commit(). To roll back the current transaction,
+ call plpy.rollback(). (Note that it is not possible to
+ run the SQL commands COMMIT or
+ ROLLBACK via plpy.execute or
+ similar. It has to be done using these functions.) After a transaction is
+ ended, a new transaction is automatically started, so there is no separate
+ function for that.
+
+ Here is an example:
+
+CREATE PROCEDURE transaction_test1()
+LANGUAGE plpython3u
+AS $$
+for i in range(0, 10):
+ plpy.execute("INSERT INTO test1 (a) VALUES (%d)" % i)
+ if i % 2 == 0:
+ plpy.commit()
+ else:
+ plpy.rollback()
+$$;
+
+CALL transaction_test1();
+
+
+ Transactions cannot be ended when an explicit subtransaction is active.
+
46.5. Trigger Functions #
+ When a function is used as a trigger, the dictionary
+ TD contains trigger-related values:
+
TD["event"]
+ contains the event as a string:
+ INSERT, UPDATE,
+ DELETE, or TRUNCATE.
+
TD["when"]
+ contains one of BEFORE, AFTER, or
+ INSTEAD OF.
+
TD["level"]
+ contains ROW or STATEMENT.
+
TD["new"]
TD["old"]
+ For a row-level trigger, one or both of these fields contain
+ the respective trigger rows, depending on the trigger event.
+
TD["name"]
+ contains the trigger name.
+
TD["table_name"]
+ contains the name of the table on which the trigger occurred.
+
TD["table_schema"]
+ contains the schema of the table on which the trigger occurred.
+
TD["relid"]
+ contains the OID of the table on which the trigger occurred.
+
TD["args"]
+ If the CREATE TRIGGER command
+ included arguments, they are available in TD["args"][0] to
+ TD["args"][n-1].
+
+
+ If TD["when"] is BEFORE or
+ INSTEAD OF and
+ TD["level"] is ROW, you can
+ return None or "OK" from the
+ Python function to indicate the row is unmodified,
+ "SKIP" to abort the event, or if TD["event"]
+ is INSERT or UPDATE you can return
+ "MODIFY" to indicate you've modified the new row.
+ Otherwise the return value is ignored.
+
46.9. Utility Functions #
+ The plpy module also provides the functions
+
plpy.debug(msg, **kwargs) |
plpy.log(msg, **kwargs) |
plpy.info(msg, **kwargs) |
plpy.notice(msg, **kwargs) |
plpy.warning(msg, **kwargs) |
plpy.error(msg, **kwargs) |
plpy.fatal(msg, **kwargs) |
+
+ plpy.error and plpy.fatal
+ actually raise a Python exception which, if uncaught, propagates out to
+ the calling query, causing the current transaction or subtransaction to
+ be aborted. raise plpy.Error(msg) and
+ raise plpy.Fatal(msg) are
+ equivalent to calling plpy.error(msg) and
+ plpy.fatal(msg), respectively but
+ the raise form does not allow passing keyword arguments.
+ The other functions only generate messages of different priority levels.
+ Whether messages of a particular priority are reported to the client,
+ written to the server log, or both is controlled by the
+ log_min_messages and
+ client_min_messages configuration
+ variables. See Chapter 20 for more information.
+
+ The msg argument is given as a positional argument. For
+ backward compatibility, more than one positional argument can be given. In
+ that case, the string representation of the tuple of positional arguments
+ becomes the message reported to the client.
+
+ The following keyword-only arguments are accepted:
+
detail |
hint |
sqlstate |
schema_name |
table_name |
column_name |
datatype_name |
constraint_name |
+ The string representation of the objects passed as keyword-only arguments
+ is used to enrich the messages reported to the client. For example:
+
+
+CREATE FUNCTION raise_custom_exception() RETURNS void AS $$
+plpy.error("custom exception message",
+ detail="some info about exception",
+ hint="hint for users")
+$$ LANGUAGE plpython3u;
+
+=# SELECT raise_custom_exception();
+ERROR: plpy.Error: custom exception message
+DETAIL: some info about exception
+HINT: hint for users
+CONTEXT: Traceback (most recent call last):
+ PL/Python function "raise_custom_exception", line 4, in <module>
+ hint="hint for users")
+PL/Python function "raise_custom_exception"
+
+
+ Another set of utility functions are
+ plpy.quote_literal(string),
+ plpy.quote_nullable(string), and
+ plpy.quote_ident(string). They
+ are equivalent to the built-in quoting functions described in Section 9.4. They are useful when constructing
+ ad-hoc queries. A PL/Python equivalent of dynamic SQL from Example 43.1 would be:
+
+plpy.execute("UPDATE tbl SET %s = %s WHERE key = %s" % (
+ plpy.quote_ident(colname),
+ plpy.quote_nullable(newvalue),
+ plpy.quote_literal(keyvalue)))
+
+
Chapter 46. PL/Python — Python Procedural Language
+ The PL/Python procedural language allows
+ PostgreSQL functions and procedures to be written in the
+ Python language.
+
+ To install PL/Python in a particular database, use
+ CREATE EXTENSION plpython3u.
+
Tip
+ If a language is installed into template1, all subsequently
+ created databases will have the language installed automatically.
+
+ PL/Python is only available as an “untrusted” language, meaning
+ it does not offer any way of restricting what users can do in it and
+ is therefore named plpython3u. A trusted
+ variant plpython might become available in the future
+ if a secure execution mechanism is developed in Python. The
+ writer of a function in untrusted PL/Python must take care that the
+ function cannot be used to do anything unwanted, since it will be
+ able to do anything that could be done by a user logged in as the
+ database administrator. Only superusers can create functions in
+ untrusted languages such as plpython3u.
+
Note
+ Users of source packages must specially enable the build of
+ PL/Python during the installation process. (Refer to the
+ installation instructions for more information.) Users of binary
+ packages might find PL/Python in a separate subpackage.
+
44.11. PL/Tcl Configuration #
+ This section lists configuration parameters that
+ affect PL/Tcl.
+
-
+
pltcl.start_proc (string)
+
+ #
+ This parameter, if set to a nonempty string, specifies the name
+ (possibly schema-qualified) of a parameterless PL/Tcl function that
+ is to be executed whenever a new Tcl interpreter is created for
+ PL/Tcl. Such a function can perform per-session initialization, such
+ as loading additional Tcl code. A new Tcl interpreter is created
+ when a PL/Tcl function is first executed in a database session, or
+ when an additional interpreter has to be created because a PL/Tcl
+ function is called by a new SQL role.
+
+ The referenced function must be written in the pltcl
+ language, and must not be marked SECURITY DEFINER.
+ (These restrictions ensure that it runs in the interpreter it's
+ supposed to initialize.) The current user must have permission to
+ call it, too.
+
+ If the function fails with an error it will abort the function call
+ that caused the new interpreter to be created and propagate out to
+ the calling query, causing the current transaction or subtransaction
+ to be aborted. Any actions already done within Tcl won't be undone;
+ however, that interpreter won't be used again. If the language is
+ used again the initialization will be attempted again within a fresh
+ Tcl interpreter.
+
+ Only superusers can change this setting. Although this setting
+ can be changed within a session, such changes will not affect Tcl
+ interpreters that have already been created.
+
-
+
pltclu.start_proc (string)
+
+ #
+ This parameter is exactly like pltcl.start_proc,
+ except that it applies to PL/TclU. The referenced function must
+ be written in the pltclu language.
+
44.3. Data Values in PL/Tcl #
+ The argument values supplied to a PL/Tcl function's code are simply
+ the input arguments converted to text form (just as if they had been
+ displayed by a SELECT statement). Conversely, the
+ return and return_next commands will accept
+ any string that is acceptable input format for the function's declared
+ result type, or for the specified column of a composite result type.
+
44.5. Database Access from PL/Tcl #
+ In this section, we follow the usual Tcl convention of using question
+ marks, rather than brackets, to indicate an optional element in a
+ syntax synopsis. The following commands are available to access
+ the database from the body of a PL/Tcl function:
+
+
spi_exec ?-count n? ?-array name? command ?loop-body?
+ Executes an SQL command given as a string. An error in the command
+ causes an error to be raised. Otherwise, the return value of spi_exec
+ is the number of rows processed (selected, inserted, updated, or
+ deleted) by the command, or zero if the command is a utility
+ statement. In addition, if the command is a SELECT statement, the
+ values of the selected columns are placed in Tcl variables as
+ described below.
+
+ The optional -count value tells
+ spi_exec to stop
+ once n rows have been retrieved,
+ much as if the query included a LIMIT clause.
+ If n is zero, the query is run to
+ completion, the same as when -count is omitted.
+
+ If the command is a SELECT statement, the values of the
+ result columns are placed into Tcl variables named after the columns.
+ If the -array option is given, the column values are
+ instead stored into elements of the named associative array, with the
+ column names used as array indexes. In addition, the current row
+ number within the result (counting from zero) is stored into the array
+ element named “.tupno”, unless that name is
+ in use as a column name in the result.
+
+ If the command is a SELECT statement and no loop-body
+ script is given, then only the first row of results are stored into
+ Tcl variables or array elements; remaining rows, if any, are ignored.
+ No storing occurs if the query returns no rows. (This case can be
+ detected by checking the result of spi_exec.)
+ For example:
+
+spi_exec "SELECT count(*) AS cnt FROM pg_proc"
+
+ will set the Tcl variable $cnt to the number of rows in
+ the pg_proc system catalog.
+
+ If the optional loop-body argument is given, it is
+ a piece of Tcl script that is executed once for each row in the
+ query result. (loop-body is ignored if the given
+ command is not a SELECT.)
+ The values of the current row's columns
+ are stored into Tcl variables or array elements before each iteration.
+ For example:
+
+spi_exec -array C "SELECT * FROM pg_class" {
+ elog DEBUG "have table $C(relname)"
+}
+
+ will print a log message for every row of pg_class. This
+ feature works similarly to other Tcl looping constructs; in
+ particular continue and break work in the
+ usual way inside the loop body.
+
+ If a column of a query result is null, the target
+ variable for it is “unset” rather than being set.
+
spi_prepare query typelist
+ Prepares and saves a query plan for later execution. The
+ saved plan will be retained for the life of the current
+ session.
+
+ The query can use parameters, that is, placeholders for
+ values to be supplied whenever the plan is actually executed.
+ In the query string, refer to parameters
+ by the symbols $1 ... $n.
+ If the query uses parameters, the names of the parameter types
+ must be given as a Tcl list. (Write an empty list for
+ typelist if no parameters are used.)
+
+ The return value from spi_prepare is a query ID
+ to be used in subsequent calls to spi_execp. See
+ spi_execp for an example.
+
spi_execp ?-count n? ?-array name? ?-nulls string? queryid ?value-list? ?loop-body?
+ Executes a query previously prepared with spi_prepare.
+ queryid is the ID returned by
+ spi_prepare. If the query references parameters,
+ a value-list must be supplied. This
+ is a Tcl list of actual values for the parameters. The list must be
+ the same length as the parameter type list previously given to
+ spi_prepare. Omit value-list
+ if the query has no parameters.
+
+ The optional value for -nulls is a string of spaces and
+ 'n' characters telling spi_execp
+ which of the parameters are null values. If given, it must have exactly the
+ same length as the value-list. If it
+ is not given, all the parameter values are nonnull.
+
+ Except for the way in which the query and its parameters are specified,
+ spi_execp works just like spi_exec.
+ The -count, -array, and
+ loop-body options are the same,
+ and so is the result value.
+
+ Here's an example of a PL/Tcl function using a prepared plan:
+
+
+CREATE FUNCTION t1_count(integer, integer) RETURNS integer AS $$
+ if {![ info exists GD(plan) ]} {
+ # prepare the saved plan on the first call
+ set GD(plan) [ spi_prepare \
+ "SELECT count(*) AS cnt FROM t1 WHERE num >= \$1 AND num <= \$2" \
+ [ list int4 int4 ] ]
+ }
+ spi_execp -count 1 $GD(plan) [ list $1 $2 ]
+ return $cnt
+$$ LANGUAGE pltcl;
+
+
+ We need backslashes inside the query string given to
+ spi_prepare to ensure that the
+ $n markers will be passed
+ through to spi_prepare as-is, and not replaced by Tcl
+ variable substitution.
+
+
subtransaction command
+ The Tcl script contained in command is
+ executed within an SQL subtransaction. If the script returns an
+ error, that entire subtransaction is rolled back before returning the
+ error out to the surrounding Tcl code.
+ See Section 44.9 for more details and an
+ example.
+
quote string
+ Doubles all occurrences of single quote and backslash characters
+ in the given string. This can be used to safely quote strings
+ that are to be inserted into SQL commands given
+ to spi_exec or
+ spi_prepare.
+ For example, think about an SQL command string like:
+
+
+"SELECT '$val' AS ret"
+
+
+ where the Tcl variable val actually contains
+ doesn't. This would result
+ in the final command string:
+
+
+SELECT 'doesn't' AS ret
+
+
+ which would cause a parse error during
+ spi_exec or
+ spi_prepare.
+ To work properly, the submitted command should contain:
+
+
+SELECT 'doesn''t' AS ret
+
+
+ which can be formed in PL/Tcl using:
+
+
+"SELECT '[ quote $val ]' AS ret"
+
+
+ One advantage of spi_execp is that you don't
+ have to quote parameter values like this, since the parameters are never
+ parsed as part of an SQL command string.
+
-
+
elog level msg
+
+
+ Emits a log or error message. Possible levels are
+ DEBUG, LOG, INFO,
+ NOTICE, WARNING, ERROR, and
+ FATAL. ERROR
+ raises an error condition; if this is not trapped by the surrounding
+ Tcl code, the error propagates out to the calling query, causing
+ the current transaction or subtransaction to be aborted. This
+ is effectively the same as the Tcl error command.
+ FATAL aborts the transaction and causes the current
+ session to shut down. (There is probably no good reason to use
+ this error level in PL/Tcl functions, but it's provided for
+ completeness.) The other levels only generate messages of different
+ priority levels.
+ Whether messages of a particular priority are reported to the client,
+ written to the server log, or both is controlled by the
+ log_min_messages and
+ client_min_messages configuration
+ variables. See Chapter 20
+ and Section 44.8
+ for more information.
+
+
44.8. Error Handling in PL/Tcl #
+ Tcl code within or called from a PL/Tcl function can raise an error,
+ either by executing some invalid operation or by generating an error
+ using the Tcl error command or
+ PL/Tcl's elog command. Such errors can be caught
+ within Tcl using the Tcl catch command. If an
+ error is not caught but is allowed to propagate out to the top level of
+ execution of the PL/Tcl function, it is reported as an SQL error in the
+ function's calling query.
+
+ Conversely, SQL errors that occur within PL/Tcl's
+ spi_exec, spi_prepare,
+ and spi_execp commands are reported as Tcl errors,
+ so they are catchable by Tcl's catch command.
+ (Each of these PL/Tcl commands runs its SQL operation in a
+ subtransaction, which is rolled back on error, so that any
+ partially-completed operation is automatically cleaned up.)
+ Again, if an error propagates out to the top level without being caught,
+ it turns back into an SQL error.
+
+ Tcl provides an errorCode variable that can represent
+ additional information about an error in a form that is easy for Tcl
+ programs to interpret. The contents are in Tcl list format, and the
+ first word identifies the subsystem or library reporting the error;
+ beyond that the contents are left to the individual subsystem or
+ library. For database errors reported by PL/Tcl commands, the first
+ word is POSTGRES, the second word is the PostgreSQL
+ version number, and additional words are field name/value pairs
+ providing detailed information about the error.
+ Fields SQLSTATE, condition,
+ and message are always supplied
+ (the first two represent the error code and condition name as shown
+ in Appendix A).
+ Fields that may be present include
+ detail, hint, context,
+ schema, table, column,
+ datatype, constraint,
+ statement, cursor_position,
+ filename, lineno, and
+ funcname.
+
+ A convenient way to work with PL/Tcl's errorCode
+ information is to load it into an array, so that the field names become
+ array subscripts. Code for doing that might look like
+
+if {[catch { spi_exec $sql_command }]} {
+ if {[lindex $::errorCode 0] == "POSTGRES"} {
+ array set errorArray $::errorCode
+ if {$errorArray(condition) == "undefined_table"} {
+ # deal with missing table
+ } else {
+ # deal with some other type of SQL error
+ }
+ }
+}
+
+ (The double colons explicitly specify that errorCode
+ is a global variable.)
+
44.7. Event Trigger Functions in PL/Tcl #
+ Event trigger functions can be written in PL/Tcl.
+ PostgreSQL requires that a function that is
+ to be called as an event trigger must be declared as a function with no
+ arguments and a return type of event_trigger.
+
+ The information from the trigger manager is passed to the function body
+ in the following variables:
+
+
$TG_event
+ The name of the event the trigger is fired for.
+
$TG_tag
+ The command tag for which the trigger is fired.
+
+
+ The return value of the trigger function is ignored.
+
+ Here's a little example event trigger function that simply raises
+ a NOTICE message each time a supported command is
+ executed:
+
+
+CREATE OR REPLACE FUNCTION tclsnitch() RETURNS event_trigger AS $$
+ elog NOTICE "tclsnitch: $TG_event $TG_tag"
+$$ LANGUAGE pltcl;
+
+CREATE EVENT TRIGGER tcl_a_snitch ON ddl_command_start EXECUTE FUNCTION tclsnitch();
+
+
44.2. PL/Tcl Functions and Arguments #
+ To create a function in the PL/Tcl language, use
+ the standard CREATE FUNCTION syntax:
+
+
+CREATE FUNCTION funcname (argument-types) RETURNS return-type AS $$
+ # PL/Tcl function body
+$$ LANGUAGE pltcl;
+
+
+ PL/TclU is the same, except that the language has to be specified as
+ pltclu.
+
+ The body of the function is simply a piece of Tcl script.
+ When the function is called, the argument values are passed to the
+ Tcl script as variables named 1
+ ... nreturn statement. In a procedure, the return value
+ from the Tcl code is ignored.
+
+ For example, a function
+ returning the greater of two integer values could be defined as:
+
+
+CREATE FUNCTION tcl_max(integer, integer) RETURNS integer AS $$
+ if {$1 > $2} {return $1}
+ return $2
+$$ LANGUAGE pltcl STRICT;
+
+
+ Note the clause STRICT, which saves us from
+ having to think about null input values: if a null value is passed, the
+ function will not be called at all, but will just return a null
+ result automatically.
+
+ In a nonstrict function,
+ if the actual value of an argument is null, the corresponding
+ $n variable will be set to an empty string.
+ To detect whether a particular argument is null, use the function
+ argisnull. For example, suppose that we wanted tcl_max
+ with one null and one nonnull argument to return the nonnull
+ argument, rather than null:
+
+
+CREATE FUNCTION tcl_max(integer, integer) RETURNS integer AS $$
+ if {[argisnull 1]} {
+ if {[argisnull 2]} { return_null }
+ return $2
+ }
+ if {[argisnull 2]} { return $1 }
+ if {$1 > $2} {return $1}
+ return $2
+$$ LANGUAGE pltcl;
+
+
+ As shown above,
+ to return a null value from a PL/Tcl function, execute
+ return_null. This can be done whether the
+ function is strict or not.
+
+ Composite-type arguments are passed to the function as Tcl
+ arrays. The element names of the array are the attribute names
+ of the composite type. If an attribute in the passed row has the
+ null value, it will not appear in the array. Here is an example:
+
+
+CREATE TABLE employee (
+ name text,
+ salary integer,
+ age integer
+);
+
+CREATE FUNCTION overpaid(employee) RETURNS boolean AS $$
+ if {200000.0 < $1(salary)} {
+ return "t"
+ }
+ if {$1(age) < 30 && 100000.0 < $1(salary)} {
+ return "t"
+ }
+ return "f"
+$$ LANGUAGE pltcl;
+
+
+ PL/Tcl functions can return composite-type results, too. To do this,
+ the Tcl code must return a list of column name/value pairs matching
+ the expected result type. Any column names omitted from the list
+ are returned as nulls, and an error is raised if there are unexpected
+ column names. Here is an example:
+
+
+CREATE FUNCTION square_cube(in int, out squared int, out cubed int) AS $$
+ return [list squared [expr {$1 * $1}] cubed [expr {$1 * $1 * $1}]]
+$$ LANGUAGE pltcl;
+
+
+ Output arguments of procedures are returned in the same way, for example:
+
+
+CREATE PROCEDURE tcl_triple(INOUT a integer, INOUT b integer) AS $$
+ return [list a [expr {$1 * 3}] b [expr {$2 * 3}]]
+$$ LANGUAGE pltcl;
+
+CALL tcl_triple(5, 10);
+
+
Tip
+ The result list can be made from an array representation of the
+ desired tuple with the array get Tcl command. For example:
+
+
+CREATE FUNCTION raise_pay(employee, delta int) RETURNS employee AS $$
+ set 1(salary) [expr {$1(salary) + $2}]
+ return [array get 1]
+$$ LANGUAGE pltcl;
+
+
+ PL/Tcl functions can return sets. To do this, the Tcl code should
+ call return_next once per row to be returned,
+ passing either the appropriate value when returning a scalar type,
+ or a list of column name/value pairs when returning a composite type.
+ Here is an example returning a scalar type:
+
+
+CREATE FUNCTION sequence(int, int) RETURNS SETOF int AS $$
+ for {set i $1} {$i < $2} {incr i} {
+ return_next $i
+ }
+$$ LANGUAGE pltcl;
+
+
+ and here is one returning a composite type:
+
+
+CREATE FUNCTION table_of_squares(int, int) RETURNS TABLE (x int, x2 int) AS $$
+ for {set i $1} {$i < $2} {incr i} {
+ return_next [list x $i x2 [expr {$i * $i}]]
+ }
+$$ LANGUAGE pltcl;
+
+
44.4. Global Data in PL/Tcl #
+ Sometimes it
+ is useful to have some global data that is held between two
+ calls to a function or is shared between different functions.
+ This is easily done in PL/Tcl, but there are some restrictions that
+ must be understood.
+
+ For security reasons, PL/Tcl executes functions called by any one SQL
+ role in a separate Tcl interpreter for that role. This prevents
+ accidental or malicious interference by one user with the behavior of
+ another user's PL/Tcl functions. Each such interpreter will have its own
+ values for any “global” Tcl variables. Thus, two PL/Tcl
+ functions will share the same global variables if and only if they are
+ executed by the same SQL role. In an application wherein a single
+ session executes code under multiple SQL roles (via SECURITY
+ DEFINER functions, use of SET ROLE, etc.) you may need to
+ take explicit steps to ensure that PL/Tcl functions can share data. To
+ do that, make sure that functions that should communicate are owned by
+ the same user, and mark them SECURITY DEFINER. You must of
+ course take care that such functions can't be used to do anything
+ unintended.
+
+ All PL/TclU functions used in a session execute in the same Tcl
+ interpreter, which of course is distinct from the interpreter(s)
+ used for PL/Tcl functions. So global data is automatically shared
+ between PL/TclU functions. This is not considered a security risk
+ because all PL/TclU functions execute at the same trust level,
+ namely that of a database superuser.
+
+ To help protect PL/Tcl functions from unintentionally interfering
+ with each other, a global
+ array is made available to each function via the upvar
+ command. The global name of this variable is the function's internal
+ name, and the local name is GD. It is recommended that
+ GD be used
+ for persistent private data of a function. Use regular Tcl global
+ variables only for values that you specifically intend to be shared among
+ multiple functions. (Note that the GD arrays are only
+ global within a particular interpreter, so they do not bypass the
+ security restrictions mentioned above.)
+
+ An example of using GD appears in the
+ spi_execp example below.
+
+ PL/Tcl offers most of the capabilities a function writer has in
+ the C language, with a few restrictions, and with the addition of
+ the powerful string processing libraries that are available for
+ Tcl.
+
+ One compelling good restriction is that
+ everything is executed from within the safety of the context of a
+ Tcl interpreter. In addition to the limited command set of safe
+ Tcl, only a few commands are available to access the database via
+ SPI and to raise messages via elog(). PL/Tcl
+ provides no way to access internals of the database server or to
+ gain OS-level access under the permissions of the
+ PostgreSQL server process, as a C
+ function can do. Thus, unprivileged database users can be trusted
+ to use this language; it does not give them unlimited authority.
+
+ The other notable implementation restriction is that Tcl functions
+ cannot be used to create input/output functions for new data
+ types.
+
+ Sometimes it is desirable to write Tcl functions that are not restricted
+ to safe Tcl. For example, one might want a Tcl function that sends
+ email. To handle these cases, there is a variant of PL/Tcl called PL/TclU
+ (for untrusted Tcl). This is exactly the same language except that a full
+ Tcl interpreter is used. If PL/TclU is used, it must be
+ installed as an untrusted procedural language so that only
+ database superusers can create functions in it. The writer of a PL/TclU
+ function must take care that the function cannot be used to do anything
+ unwanted, since it will be able to do anything that could be done by
+ a user logged in as the database administrator.
+
+ The shared object code for the PL/Tcl and
+ PL/TclU call handlers is automatically built and
+ installed in the PostgreSQL library
+ directory if Tcl support is specified in the configuration step of
+ the installation procedure. To install PL/Tcl
+ and/or PL/TclU in a particular database, use the
+ CREATE EXTENSION command, for example
+ CREATE EXTENSION pltcl or
+ CREATE EXTENSION pltclu.
+
44.12. Tcl Procedure Names #
+ In PostgreSQL, the same function name can be used for
+ different function definitions as long as the number of arguments or their types
+ differ. Tcl, however, requires all procedure names to be distinct.
+ PL/Tcl deals with this by making the internal Tcl procedure names contain
+ the object
+ ID of the function from the system table pg_proc as part of their name. Thus,
+ PostgreSQL functions with the same name
+ and different argument types will be different Tcl procedures, too. This
+ is not normally a concern for a PL/Tcl programmer, but it might be visible
+ when debugging.
+
44.9. Explicit Subtransactions in PL/Tcl #
+ Recovering from errors caused by database access as described in
+ Section 44.8 can lead to an undesirable
+ situation where some operations succeed before one of them fails,
+ and after recovering from that error the data is left in an
+ inconsistent state. PL/Tcl offers a solution to this problem in
+ the form of explicit subtransactions.
+
+ Consider a function that implements a transfer between two accounts:
+
+CREATE FUNCTION transfer_funds() RETURNS void AS $$
+ if [catch {
+ spi_exec "UPDATE accounts SET balance = balance - 100 WHERE account_name = 'joe'"
+ spi_exec "UPDATE accounts SET balance = balance + 100 WHERE account_name = 'mary'"
+ } errormsg] {
+ set result [format "error transferring funds: %s" $errormsg]
+ } else {
+ set result "funds transferred successfully"
+ }
+ spi_exec "INSERT INTO operations (result) VALUES ('[quote $result]')"
+$$ LANGUAGE pltcl;
+
+ If the second UPDATE statement results in an
+ exception being raised, this function will log the failure, but
+ the result of the first UPDATE will
+ nevertheless be committed. In other words, the funds will be
+ withdrawn from Joe's account, but will not be transferred to
+ Mary's account. This happens because each spi_exec
+ is a separate subtransaction, and only one of those subtransactions
+ got rolled back.
+
+ To handle such cases, you can wrap multiple database operations in an
+ explicit subtransaction, which will succeed or roll back as a whole.
+ PL/Tcl provides a subtransaction command to manage
+ this. We can rewrite our function as:
+
+CREATE FUNCTION transfer_funds2() RETURNS void AS $$
+ if [catch {
+ subtransaction {
+ spi_exec "UPDATE accounts SET balance = balance - 100 WHERE account_name = 'joe'"
+ spi_exec "UPDATE accounts SET balance = balance + 100 WHERE account_name = 'mary'"
+ }
+ } errormsg] {
+ set result [format "error transferring funds: %s" $errormsg]
+ } else {
+ set result "funds transferred successfully"
+ }
+ spi_exec "INSERT INTO operations (result) VALUES ('[quote $result]')"
+$$ LANGUAGE pltcl;
+
+ Note that use of catch is still required for this
+ purpose. Otherwise the error would propagate to the top level of the
+ function, preventing the desired insertion into
+ the operations table.
+ The subtransaction command does not trap errors, it
+ only assures that all database operations executed inside its scope will
+ be rolled back together when an error is reported.
+
+ A rollback of an explicit subtransaction occurs on any error reported
+ by the contained Tcl code, not only errors originating from database
+ access. Thus a regular Tcl exception raised inside
+ a subtransaction command will also cause the
+ subtransaction to be rolled back. However, non-error exits out of the
+ contained Tcl code (for instance, due to return) do
+ not cause a rollback.
+
44.10. Transaction Management #
+ In a procedure called from the top level or an anonymous code block
+ (DO command) called from the top level it is possible
+ to control transactions. To commit the current transaction, call the
+ commit command. To roll back the current transaction,
+ call the rollback command. (Note that it is not
+ possible to run the SQL commands COMMIT or
+ ROLLBACK via spi_exec or similar.
+ It has to be done using these functions.) After a transaction is ended,
+ a new transaction is automatically started, so there is no separate
+ command for that.
+
+ Here is an example:
+
+CREATE PROCEDURE transaction_test1()
+LANGUAGE pltcl
+AS $$
+for {set i 0} {$i < 10} {incr i} {
+ spi_exec "INSERT INTO test1 (a) VALUES ($i)"
+ if {$i % 2 == 0} {
+ commit
+ } else {
+ rollback
+ }
+}
+$$;
+
+CALL transaction_test1();
+
+
+ Transactions cannot be ended when an explicit subtransaction is active.
+
44.6. Trigger Functions in PL/Tcl #
+ Trigger functions can be written in PL/Tcl.
+ PostgreSQL requires that a function that is to be called
+ as a trigger must be declared as a function with no arguments
+ and a return type of trigger.
+
+ The information from the trigger manager is passed to the function body
+ in the following variables:
+
+
$TG_name
+ The name of the trigger from the CREATE TRIGGER statement.
+
$TG_relid
+ The object ID of the table that caused the trigger function
+ to be invoked.
+
$TG_table_name
+ The name of the table that caused the trigger function
+ to be invoked.
+
$TG_table_schema
+ The schema of the table that caused the trigger function
+ to be invoked.
+
$TG_relatts
+ A Tcl list of the table column names, prefixed with an empty list
+ element. So looking up a column name in the list with Tcl's
+ lsearch command returns the element's number starting
+ with 1 for the first column, the same way the columns are customarily
+ numbered in PostgreSQL. (Empty list
+ elements also appear in the positions of columns that have been
+ dropped, so that the attribute numbering is correct for columns
+ to their right.)
+
$TG_when
+ The string BEFORE, AFTER, or
+ INSTEAD OF, depending on the type of trigger event.
+
$TG_level
+ The string ROW or STATEMENT depending on the
+ type of trigger event.
+
$TG_op
+ The string INSERT, UPDATE,
+ DELETE, or TRUNCATE depending on the type of
+ trigger event.
+
$NEW
+ An associative array containing the values of the new table
+ row for INSERT or UPDATE actions, or
+ empty for DELETE. The array is indexed by column
+ name. Columns that are null will not appear in the array.
+ This is not set for statement-level triggers.
+
$OLD
+ An associative array containing the values of the old table
+ row for UPDATE or DELETE actions, or
+ empty for INSERT. The array is indexed by column
+ name. Columns that are null will not appear in the array.
+ This is not set for statement-level triggers.
+
$args
+ A Tcl list of the arguments to the function as given in the
+ CREATE TRIGGER statement. These arguments are also accessible as
+ $1 ... $n in the function body.
+
+
+ The return value from a trigger function can be one of the strings
+ OK or SKIP, or a list of column name/value pairs.
+ If the return value is OK,
+ the operation (INSERT/UPDATE/DELETE)
+ that fired the trigger will proceed
+ normally. SKIP tells the trigger manager to silently suppress
+ the operation for this row. If a list is returned, it tells PL/Tcl to
+ return a modified row to the trigger manager; the contents of the
+ modified row are specified by the column names and values in the list.
+ Any columns not mentioned in the list are set to null.
+ Returning a modified row is only meaningful
+ for row-level BEFORE INSERT or UPDATE
+ triggers, for which the modified row will be inserted instead of the one
+ given in $NEW; or for row-level INSTEAD OF
+ INSERT or UPDATE triggers where the returned row
+ is used as the source data for INSERT RETURNING or
+ UPDATE RETURNING clauses.
+ In row-level BEFORE DELETE or INSTEAD
+ OF DELETE triggers, returning a modified row has the same
+ effect as returning OK, that is the operation proceeds.
+ The trigger return value is ignored for all other types of triggers.
+
Tip
+ The result list can be made from an array representation of the
+ modified tuple with the array get Tcl command.
+
+ Here's a little example trigger function that forces an integer value
+ in a table to keep track of the number of updates that are performed on the
+ row. For new rows inserted, the value is initialized to 0 and then
+ incremented on every update operation.
+
+
+CREATE FUNCTION trigfunc_modcount() RETURNS trigger AS $$
+ switch $TG_op {
+ INSERT {
+ set NEW($1) 0
+ }
+ UPDATE {
+ set NEW($1) $OLD($1)
+ incr NEW($1)
+ }
+ default {
+ return OK
+ }
+ }
+ return [array get NEW]
+$$ LANGUAGE pltcl;
+
+CREATE TABLE mytab (num integer, description text, modcnt integer);
+
+CREATE TRIGGER trig_mytab_modcount BEFORE INSERT OR UPDATE ON mytab
+ FOR EACH ROW EXECUTE FUNCTION trigfunc_modcount('modcnt');
+
+
+ Notice that the trigger function itself does not know the column
+ name; that's supplied from the trigger arguments. This lets the
+ trigger function be reused with different tables.
+
Chapter 44. PL/Tcl — Tcl Procedural Language
+ PL/Tcl is a loadable procedural language for the
+ PostgreSQL database system
+ that enables the
+ Tcl language to be used to write
+ PostgreSQL functions and procedures.
+
14.4. Populating a Database #
+ One might need to insert a large amount of data when first populating
+ a database. This section contains some suggestions on how to make
+ this process as efficient as possible.
+
14.4.1. Disable Autocommit #
+ When using multiple INSERTs, turn off autocommit and just do
+ one commit at the end. (In plain
+ SQL, this means issuing BEGIN at the start and
+ COMMIT at the end. Some client libraries might
+ do this behind your back, in which case you need to make sure the
+ library does it when you want it done.) If you allow each
+ insertion to be committed separately,
+ PostgreSQL is doing a lot of work for
+ each row that is added. An additional benefit of doing all
+ insertions in one transaction is that if the insertion of one row
+ were to fail then the insertion of all rows inserted up to that
+ point would be rolled back, so you won't be stuck with partially
+ loaded data.
+
+ Use COPY to load
+ all the rows in one command, instead of using a series of
+ INSERT commands. The COPY
+ command is optimized for loading large numbers of rows; it is less
+ flexible than INSERT, but incurs significantly
+ less overhead for large data loads. Since COPY
+ is a single command, there is no need to disable autocommit if you
+ use this method to populate a table.
+
+ If you cannot use COPY, it might help to use PREPARE to create a
+ prepared INSERT statement, and then use
+ EXECUTE as many times as required. This avoids
+ some of the overhead of repeatedly parsing and planning
+ INSERT. Different interfaces provide this facility
+ in different ways; look for “prepared statements” in the interface
+ documentation.
+
+ Note that loading a large number of rows using
+ COPY is almost always faster than using
+ INSERT, even if PREPARE is used and
+ multiple insertions are batched into a single transaction.
+
+ COPY is fastest when used within the same
+ transaction as an earlier CREATE TABLE or
+ TRUNCATE command. In such cases no WAL
+ needs to be written, because in case of an error, the files
+ containing the newly loaded data will be removed anyway.
+ However, this consideration only applies when
+ wal_level is minimal
+ as all commands must write WAL otherwise.
+
+ If you are loading a freshly created table, the fastest method is to
+ create the table, bulk load the table's data using
+ COPY, then create any indexes needed for the
+ table. Creating an index on pre-existing data is quicker than
+ updating it incrementally as each row is loaded.
+
+ If you are adding large amounts of data to an existing table,
+ it might be a win to drop the indexes,
+ load the table, and then recreate the indexes. Of course, the
+ database performance for other users might suffer
+ during the time the indexes are missing. One should also think
+ twice before dropping a unique index, since the error checking
+ afforded by the unique constraint will be lost while the index is
+ missing.
+
14.4.4. Remove Foreign Key Constraints #
+ Just as with indexes, a foreign key constraint can be checked
+ “in bulk” more efficiently than row-by-row. So it might be
+ useful to drop foreign key constraints, load data, and re-create
+ the constraints. Again, there is a trade-off between data load
+ speed and loss of error checking while the constraint is missing.
+
+ What's more, when you load data into a table with existing foreign key
+ constraints, each new row requires an entry in the server's list of
+ pending trigger events (since it is the firing of a trigger that checks
+ the row's foreign key constraint). Loading many millions of rows can
+ cause the trigger event queue to overflow available memory, leading to
+ intolerable swapping or even outright failure of the command. Therefore
+ it may be necessary, not just desirable, to drop and re-apply
+ foreign keys when loading large amounts of data. If temporarily removing
+ the constraint isn't acceptable, the only other recourse may be to split
+ up the load operation into smaller transactions.
+
14.4.5. Increase maintenance_work_mem #
+ Temporarily increasing the maintenance_work_mem
+ configuration variable when loading large amounts of data can
+ lead to improved performance. This will help to speed up CREATE
+ INDEX commands and ALTER TABLE ADD FOREIGN KEY commands.
+ It won't do much for COPY itself, so this advice is
+ only useful when you are using one or both of the above techniques.
+
14.4.6. Increase max_wal_size #
+ Temporarily increasing the max_wal_size
+ configuration variable can also
+ make large data loads faster. This is because loading a large
+ amount of data into PostgreSQL will
+ cause checkpoints to occur more often than the normal checkpoint
+ frequency (specified by the checkpoint_timeout
+ configuration variable). Whenever a checkpoint occurs, all dirty
+ pages must be flushed to disk. By increasing
+ max_wal_size temporarily during bulk
+ data loads, the number of checkpoints that are required can be
+ reduced.
+
14.4.7. Disable WAL Archival and Streaming Replication #
+ When loading large amounts of data into an installation that uses
+ WAL archiving or streaming replication, it might be faster to take a
+ new base backup after the load has completed than to process a large
+ amount of incremental WAL data. To prevent incremental WAL logging
+ while loading, disable archiving and streaming replication, by setting
+ wal_level to minimal,
+ archive_mode to off, and
+ max_wal_senders to zero.
+ But note that changing these settings requires a server restart,
+ and makes any base backups taken before unavailable for archive
+ recovery and standby server, which may lead to data loss.
+
+ Aside from avoiding the time for the archiver or WAL sender to process the
+ WAL data, doing this will actually make certain commands faster, because
+ they do not to write WAL at all if wal_level
+ is minimal and the current subtransaction (or top-level
+ transaction) created or truncated the table or index they change. (They
+ can guarantee crash safety more cheaply by doing
+ an fsync at the end than by writing WAL.)
+
14.4.8. Run ANALYZE Afterwards #
+ Whenever you have significantly altered the distribution of data
+ within a table, running ANALYZE is strongly recommended. This
+ includes bulk loading large amounts of data into the table. Running
+ ANALYZE (or VACUUM ANALYZE)
+ ensures that the planner has up-to-date statistics about the
+ table. With no statistics or obsolete statistics, the planner might
+ make poor decisions during query planning, leading to poor
+ performance on any tables with inaccurate or nonexistent
+ statistics. Note that if the autovacuum daemon is enabled, it might
+ run ANALYZE automatically; see
+ Section 25.1.3
+ and Section 25.1.6 for more information.
+
14.4.9. Some Notes about pg_dump #
+ Dump scripts generated by pg_dump automatically apply
+ several, but not all, of the above guidelines. To restore a
+ pg_dump dump as quickly as possible, you need to
+ do a few extra things manually. (Note that these points apply while
+ restoring a dump, not while creating it.
+ The same points apply whether loading a text dump with
+ psql or using pg_restore to load
+ from a pg_dump archive file.)
+
+ By default, pg_dump uses COPY, and when
+ it is generating a complete schema-and-data dump, it is careful to
+ load data before creating indexes and foreign keys. So in this case
+ several guidelines are handled automatically. What is left
+ for you to do is to:
+
+ Set appropriate (i.e., larger than normal) values for
+ maintenance_work_mem and
+ max_wal_size.
+
+ If using WAL archiving or streaming replication, consider disabling
+ them during the restore. To do that, set archive_mode
+ to off,
+ wal_level to minimal, and
+ max_wal_senders to zero before loading the dump.
+ Afterwards, set them back to the right values and take a fresh
+ base backup.
+
+ Experiment with the parallel dump and restore modes of both
+ pg_dump and pg_restore and find the
+ optimal number of concurrent jobs to use. Dumping and restoring in
+ parallel by means of the -j option should give you a
+ significantly higher performance over the serial mode.
+
+ Consider whether the whole dump should be restored as a single
+ transaction. To do that, pass the -1 or
+ --single-transaction command-line option to
+ psql or pg_restore. When using this
+ mode, even the smallest of errors will rollback the entire restore,
+ possibly discarding many hours of processing. Depending on how
+ interrelated the data is, that might seem preferable to manual cleanup,
+ or not. COPY commands will run fastest if you use a single
+ transaction and have WAL archiving turned off.
+
+ If multiple CPUs are available in the database server, consider using
+ pg_restore's --jobs option. This
+ allows concurrent data loading and index creation.
+
+ Run ANALYZE afterwards.
+
+
+ A data-only dump will still use COPY, but it does not
+ drop or recreate indexes, and it does not normally touch foreign
+ keys.
+
+
+
+ So when loading a data-only dump, it is up to you to drop and recreate
+ indexes and foreign keys if you wish to use those techniques.
+ It's still useful to increase max_wal_size
+ while loading the data, but don't bother increasing
+ maintenance_work_mem; rather, you'd do that while
+ manually recreating indexes and foreign keys afterwards.
+ And don't forget to ANALYZE when you're done; see
+ Section 25.1.3
+ and Section 25.1.6 for more information.
+
F.38. postgres_fdw —
+ access data stored in external PostgreSQL
+ servers #
+ The postgres_fdw module provides the foreign-data wrapper
+ postgres_fdw, which can be used to access data
+ stored in external PostgreSQL servers.
+
+ The functionality provided by this module overlaps substantially
+ with the functionality of the older dblink module.
+ But postgres_fdw provides more transparent and
+ standards-compliant syntax for accessing remote tables, and can give
+ better performance in many cases.
+
+ To prepare for remote access using postgres_fdw:
+
+ Install the postgres_fdw extension using CREATE EXTENSION.
+
+ Create a foreign server object, using CREATE SERVER,
+ to represent each remote database you want to connect to.
+ Specify connection information, except user and
+ password, as options of the server object.
+
+ Create a user mapping, using CREATE USER MAPPING, for
+ each database user you want to allow to access each foreign server.
+ Specify the remote user name and password to use as
+ user and password options of the
+ user mapping.
+
+ Create a foreign table, using CREATE FOREIGN TABLE
+ or IMPORT FOREIGN SCHEMA,
+ for each remote table you want to access. The columns of the foreign
+ table must match the referenced remote table. You can, however, use
+ table and/or column names different from the remote table's, if you
+ specify the correct remote names as options of the foreign table object.
+
+
+ Now you need only SELECT from a foreign table to access
+ the data stored in its underlying remote table. You can also modify
+ the remote table using INSERT, UPDATE,
+ DELETE, COPY, or
+ TRUNCATE.
+ (Of course, the remote user you have specified in your user mapping must
+ have privileges to do these things.)
+
+ Note that the ONLY option specified in
+ SELECT, UPDATE,
+ DELETE or TRUNCATE
+ has no effect when accessing or modifying the remote table.
+
+ Note that postgres_fdw currently lacks support for
+ INSERT statements with an ON CONFLICT DO
+ UPDATE clause. However, the ON CONFLICT DO NOTHING
+ clause is supported, provided a unique index inference specification
+ is omitted.
+ Note also that postgres_fdw supports row movement
+ invoked by UPDATE statements executed on partitioned
+ tables, but it currently does not handle the case where a remote partition
+ chosen to insert a moved row into is also an UPDATE
+ target partition that will be updated elsewhere in the same command.
+
+ It is generally recommended that the columns of a foreign table be declared
+ with exactly the same data types, and collations if applicable, as the
+ referenced columns of the remote table. Although postgres_fdw
+ is currently rather forgiving about performing data type conversions at
+ need, surprising semantic anomalies may arise when types or collations do
+ not match, due to the remote server interpreting query conditions
+ differently from the local server.
+
+ Note that a foreign table can be declared with fewer columns, or with a
+ different column order, than its underlying remote table has. Matching
+ of columns to the remote table is by name, not position.
+
F.38.1. FDW Options of postgres_fdw #
F.38.1.1. Connection Options #
+ A foreign server using the postgres_fdw foreign data wrapper
+ can have the same options that libpq accepts in
+ connection strings, as described in Section 34.1.2,
+ except that these options are not allowed or have special handling:
+
+
+ user, password and sslpassword (specify these
+ in a user mapping, instead, or use a service file)
+
+ client_encoding (this is automatically set from the local
+ server encoding)
+
+ application_name - this may appear in
+ either or both a connection and
+ postgres_fdw.application_name.
+ If both are present, postgres_fdw.application_name
+ overrides the connection setting.
+ Unlike libpq,
+ postgres_fdw allows
+ application_name to include
+ “escape sequences”.
+ See postgres_fdw.application_name for details.
+
+ fallback_application_name (always set to
+ postgres_fdw)
+
+ sslkey and sslcert - these may
+ appear in either or both a connection and a user
+ mapping. If both are present, the user mapping setting overrides the
+ connection setting.
+
+
+ Only superusers may create or modify user mappings with the
+ sslcert or sslkey settings.
+
+ Non-superusers may connect to foreign servers using password
+ authentication or with GSSAPI delegated credentials, so specify the
+ password option for user mappings belonging to
+ non-superusers where password authentication is required.
+
+ A superuser may override this check on a per-user-mapping basis by setting
+ the user mapping option password_required 'false', e.g.,
+
+ALTER USER MAPPING FOR some_non_superuser SERVER loopback_nopw
+OPTIONS (ADD password_required 'false');
+
+ To prevent unprivileged users from exploiting the authentication rights
+ of the unix user the postgres server is running as to escalate to superuser
+ rights, only the superuser may set this option on a user mapping.
+
+ Care is required to ensure that this does not allow the mapped
+ user the ability to connect as superuser to the mapped database per
+ CVE-2007-3278 and CVE-2007-6601. Don't set
+ password_required=false
+ on the public role. Keep in mind that the mapped
+ user can potentially use any client certificates,
+ .pgpass,
+ .pg_service.conf etc. in the unix home directory of the
+ system user the postgres server runs as. They can also use any trust
+ relationship granted by authentication modes like peer
+ or ident authentication.
+
F.38.1.2. Object Name Options #
+ These options can be used to control the names used in SQL statements
+ sent to the remote PostgreSQL server. These
+ options are needed when a foreign table is created with names different
+ from the underlying remote table's names.
+
schema_name (string)
+ This option, which can be specified for a foreign table, gives the
+ schema name to use for the foreign table on the remote server. If this
+ option is omitted, the name of the foreign table's schema is used.
+
table_name (string)
+ This option, which can be specified for a foreign table, gives the
+ table name to use for the foreign table on the remote server. If this
+ option is omitted, the foreign table's name is used.
+
column_name (string)
+ This option, which can be specified for a column of a foreign table,
+ gives the column name to use for the column on the remote server.
+ If this option is omitted, the column's name is used.
+
F.38.1.3. Cost Estimation Options #
+ postgres_fdw retrieves remote data by executing queries
+ against remote servers, so ideally the estimated cost of scanning a
+ foreign table should be whatever it costs to be done on the remote
+ server, plus some overhead for communication. The most reliable way to
+ get such an estimate is to ask the remote server and then add something
+ for overhead — but for simple queries, it may not be worth the cost
+ of an additional remote query to get a cost estimate.
+ So postgres_fdw provides the following options to control
+ how cost estimation is done:
+
use_remote_estimate (boolean)
+ This option, which can be specified for a foreign table or a foreign
+ server, controls whether postgres_fdw issues remote
+ EXPLAIN commands to obtain cost estimates.
+ A setting for a foreign table overrides any setting for its server,
+ but only for that table.
+ The default is false.
+
fdw_startup_cost (floating point)
+ This option, which can be specified for a foreign server, is a floating
+ point value that is added to the estimated startup cost of any
+ foreign-table scan on that server. This represents the additional
+ overhead of establishing a connection, parsing and planning the query on
+ the remote side, etc.
+ The default value is 100.
+
fdw_tuple_cost (floating point)
+ This option, which can be specified for a foreign server, is a floating
+ point value that is used as extra cost per-tuple for foreign-table
+ scans on that server. This represents the additional overhead of
+ data transfer between servers. You might increase or decrease this
+ number to reflect higher or lower network delay to the remote server.
+ The default value is 0.01.
+
+ When use_remote_estimate is true,
+ postgres_fdw obtains row count and cost estimates from the
+ remote server and then adds fdw_startup_cost and
+ fdw_tuple_cost to the cost estimates. When
+ use_remote_estimate is false,
+ postgres_fdw performs local row count and cost estimation
+ and then adds fdw_startup_cost and
+ fdw_tuple_cost to the cost estimates. This local
+ estimation is unlikely to be very accurate unless local copies of the
+ remote table's statistics are available. Running
+ ANALYZE on the foreign table is the way to update
+ the local statistics; this will perform a scan of the remote table and
+ then calculate and store statistics just as though the table were local.
+ Keeping local statistics can be a useful way to reduce per-query planning
+ overhead for a remote table — but if the remote table is
+ frequently updated, the local statistics will soon be obsolete.
+
+ The following option controls how such an ANALYZE
+ operation behaves:
+
analyze_sampling (string)
+ This option, which can be specified for a foreign table or a foreign
+ server, determines if ANALYZE on a foreign table
+ samples the data on the remote side, or reads and transfers all data
+ and performs the sampling locally. The supported values
+ are off, random,
+ system, bernoulli
+ and auto. off disables remote
+ sampling, so all data are transferred and sampled locally.
+ random performs remote sampling using the
+ random() function to choose returned rows,
+ while system and bernoulli rely
+ on the built-in TABLESAMPLE methods of those
+ names. random works on all remote server versions,
+ while TABLESAMPLE is supported only since 9.5.
+ auto (the default) picks the recommended sampling
+ method automatically; currently it means
+ either bernoulli or random
+ depending on the remote server version.
+
F.38.1.4. Remote Execution Options #
+ By default, only WHERE clauses using built-in operators and
+ functions will be considered for execution on the remote server. Clauses
+ involving non-built-in functions are checked locally after rows are
+ fetched. If such functions are available on the remote server and can be
+ relied on to produce the same results as they do locally, performance can
+ be improved by sending such WHERE clauses for remote
+ execution. This behavior can be controlled using the following option:
+
extensions (string)
+ This option is a comma-separated list of names
+ of PostgreSQL extensions that are installed, in
+ compatible versions, on both the local and remote servers. Functions
+ and operators that are immutable and belong to a listed extension will
+ be considered shippable to the remote server.
+ This option can only be specified for foreign servers, not per-table.
+
+ When using the extensions option, it is the
+ user's responsibility that the listed extensions exist and behave
+ identically on both the local and remote servers. Otherwise, remote
+ queries may fail or behave unexpectedly.
+
fetch_size (integer)
+ This option specifies the number of rows postgres_fdw
+ should get in each fetch operation. It can be specified for a foreign
+ table or a foreign server. The option specified on a table overrides
+ an option specified for the server.
+ The default is 100.
+
batch_size (integer)
+ This option specifies the number of rows postgres_fdw
+ should insert in each insert operation. It can be specified for a
+ foreign table or a foreign server. The option specified on a table
+ overrides an option specified for the server.
+ The default is 1.
+
+ Note the actual number of rows postgres_fdw inserts at
+ once depends on the number of columns and the provided
+ batch_size value. The batch is executed as a single
+ query, and the libpq protocol (which postgres_fdw
+ uses to connect to a remote server) limits the number of parameters in a
+ single query to 65535. When the number of columns * batch_size
+ exceeds the limit, the batch_size will be adjusted to
+ avoid an error.
+
+ This option also applies when copying into foreign tables. In that case
+ the actual number of rows postgres_fdw copies at
+ once is determined in a similar way to the insert case, but it is
+ limited to at most 1000 due to implementation restrictions of the
+ COPY command.
+
F.38.1.5. Asynchronous Execution Options #
+ postgres_fdw supports asynchronous execution, which
+ runs multiple parts of an Append node
+ concurrently rather than serially to improve performance.
+ This execution can be controlled using the following option:
+
async_capable (boolean)
+ This option controls whether postgres_fdw allows
+ foreign tables to be scanned concurrently for asynchronous execution.
+ It can be specified for a foreign table or a foreign server.
+ A table-level option overrides a server-level option.
+ The default is false.
+
+ In order to ensure that the data being returned from a foreign server
+ is consistent, postgres_fdw will only open one
+ connection for a given foreign server and will run all queries against
+ that server sequentially even if there are multiple foreign tables
+ involved, unless those tables are subject to different user mappings.
+ In such a case, it may be more performant to disable this option to
+ eliminate the overhead associated with running queries asynchronously.
+
+ Asynchronous execution is applied even when an
+ Append node contains subplan(s) executed
+ synchronously as well as subplan(s) executed asynchronously.
+ In such a case, if the asynchronous subplans are ones processed using
+ postgres_fdw, tuples from the asynchronous
+ subplans are not returned until after at least one synchronous subplan
+ returns all tuples, as that subplan is executed while the asynchronous
+ subplans are waiting for the results of asynchronous queries sent to
+ foreign servers.
+ This behavior might change in a future release.
+
F.38.1.6. Transaction Management Options #
+ As described in the Transaction Management section, in
+ postgres_fdw transactions are managed by creating
+ corresponding remote transactions, and subtransactions are managed by
+ creating corresponding remote subtransactions. When multiple remote
+ transactions are involved in the current local transaction, by default
+ postgres_fdw commits or aborts those remote
+ transactions serially when the local transaction is committed or aborted.
+ When multiple remote subtransactions are involved in the current local
+ subtransaction, by default postgres_fdw commits or
+ aborts those remote subtransactions serially when the local subtransaction
+ is committed or aborted.
+ Performance can be improved with the following options:
+
parallel_commit (boolean)
+ This option controls whether postgres_fdw commits,
+ in parallel, remote transactions opened on a foreign server in a local
+ transaction when the local transaction is committed. This setting also
+ applies to remote and local subtransactions. This option can only be
+ specified for foreign servers, not per-table. The default is
+ false.
+
parallel_abort (boolean)
+ This option controls whether postgres_fdw aborts,
+ in parallel, remote transactions opened on a foreign server in a local
+ transaction when the local transaction is aborted. This setting also
+ applies to remote and local subtransactions. This option can only be
+ specified for foreign servers, not per-table. The default is
+ false.
+
+ If multiple foreign servers with these options enabled are involved in a
+ local transaction, multiple remote transactions on those foreign servers
+ are committed or aborted in parallel across those foreign servers when
+ the local transaction is committed or aborted.
+
+ When these options are enabled, a foreign server with many remote
+ transactions may see a negative performance impact when the local
+ transaction is committed or aborted.
+
F.38.1.7. Updatability Options #
+ By default all foreign tables using postgres_fdw are assumed
+ to be updatable. This may be overridden using the following option:
+
updatable (boolean)
+ This option controls whether postgres_fdw allows foreign
+ tables to be modified using INSERT, UPDATE and
+ DELETE commands. It can be specified for a foreign table
+ or a foreign server. A table-level option overrides a server-level
+ option.
+ The default is true.
+
+ Of course, if the remote table is not in fact updatable, an error
+ would occur anyway. Use of this option primarily allows the error to
+ be thrown locally without querying the remote server. Note however
+ that the information_schema views will report a
+ postgres_fdw foreign table to be updatable (or not)
+ according to the setting of this option, without any check of the
+ remote server.
+
F.38.1.8. Truncatability Options #
+ By default all foreign tables using postgres_fdw are assumed
+ to be truncatable. This may be overridden using the following option:
+
truncatable (boolean)
+ This option controls whether postgres_fdw allows
+ foreign tables to be truncated using the TRUNCATE
+ command. It can be specified for a foreign table or a foreign server.
+ A table-level option overrides a server-level option.
+ The default is true.
+
+ Of course, if the remote table is not in fact truncatable, an error
+ would occur anyway. Use of this option primarily allows the error to
+ be thrown locally without querying the remote server.
+
F.38.1.9. Importing Options #
+ postgres_fdw is able to import foreign table definitions
+ using IMPORT FOREIGN SCHEMA. This command creates
+ foreign table definitions on the local server that match tables or
+ views present on the remote server. If the remote tables to be imported
+ have columns of user-defined data types, the local server must have
+ compatible types of the same names.
+
+ Importing behavior can be customized with the following options
+ (given in the IMPORT FOREIGN SCHEMA command):
+
import_collate (boolean)
+ This option controls whether column COLLATE options
+ are included in the definitions of foreign tables imported
+ from a foreign server. The default is true. You might
+ need to turn this off if the remote server has a different set of
+ collation names than the local server does, which is likely to be the
+ case if it's running on a different operating system.
+ If you do so, however, there is a very severe risk that the imported
+ table columns' collations will not match the underlying data, resulting
+ in anomalous query behavior.
+
+ Even when this parameter is set to true, importing
+ columns whose collation is the remote server's default can be risky.
+ They will be imported with COLLATE "default", which
+ will select the local server's default collation, which could be
+ different.
+
import_default (boolean)
+ This option controls whether column DEFAULT expressions
+ are included in the definitions of foreign tables imported
+ from a foreign server. The default is false. If you
+ enable this option, be wary of defaults that might get computed
+ differently on the local server than they would be on the remote
+ server; nextval() is a common source of problems.
+ The IMPORT will fail altogether if an imported default
+ expression uses a function or operator that does not exist locally.
+
import_generated (boolean)
+ This option controls whether column GENERATED expressions
+ are included in the definitions of foreign tables imported
+ from a foreign server. The default is true.
+ The IMPORT will fail altogether if an imported generated
+ expression uses a function or operator that does not exist locally.
+
import_not_null (boolean)
+ This option controls whether column NOT NULL
+ constraints are included in the definitions of foreign tables imported
+ from a foreign server. The default is true.
+
+ Note that constraints other than NOT NULL will never be
+ imported from the remote tables. Although PostgreSQL
+ does support check constraints on foreign tables, there is no
+ provision for importing them automatically, because of the risk that a
+ constraint expression could evaluate differently on the local and remote
+ servers. Any such inconsistency in the behavior of a check
+ constraint could lead to hard-to-detect errors in query optimization.
+ So if you wish to import check constraints, you must do so
+ manually, and you should verify the semantics of each one carefully.
+ For more detail about the treatment of check constraints on
+ foreign tables, see CREATE FOREIGN TABLE.
+
+ Tables or foreign tables which are partitions of some other table are
+ imported only when they are explicitly specified in
+ LIMIT TO clause. Otherwise they are automatically
+ excluded from IMPORT FOREIGN SCHEMA.
+ Since all data can be accessed through the partitioned table
+ which is the root of the partitioning hierarchy, importing only
+ partitioned tables should allow access to all the data without
+ creating extra objects.
+
F.38.1.10. Connection Management Options #
+ By default, all connections that postgres_fdw
+ establishes to foreign servers are kept open in the local session
+ for re-use.
+
keep_connections (boolean)
+ This option controls whether postgres_fdw keeps
+ the connections to the foreign server open so that subsequent
+ queries can re-use them. It can only be specified for a foreign server.
+ The default is on. If set to off,
+ all connections to this foreign server will be discarded at the end of
+ each transaction.
+
postgres_fdw_get_connections(OUT server_name text, OUT valid boolean) returns setof record
+ This function returns the foreign server names of all the open
+ connections that postgres_fdw established from
+ the local session to the foreign servers. It also returns whether
+ each connection is valid or not. false is returned
+ if the foreign server connection is used in the current local
+ transaction but its foreign server or user mapping is changed or
+ dropped (Note that server name of an invalid connection will be
+ NULL if the server is dropped),
+ and then such invalid connection will be closed at
+ the end of that transaction. true is returned
+ otherwise. If there are no open connections, no record is returned.
+ Example usage of the function:
+
+postgres=# SELECT * FROM postgres_fdw_get_connections() ORDER BY 1;
+ server_name | valid
+-------------+-------
+ loopback1 | t
+ loopback2 | f
+
+
postgres_fdw_disconnect(server_name text) returns boolean
+ This function discards the open connections that are established by
+ postgres_fdw from the local session to
+ the foreign server with the given name. Note that there can be
+ multiple connections to the given server using different user mappings.
+ If the connections are used in the current local transaction,
+ they are not disconnected and warning messages are reported.
+ This function returns true if it disconnects
+ at least one connection, otherwise false.
+ If no foreign server with the given name is found, an error is reported.
+ Example usage of the function:
+
+postgres=# SELECT postgres_fdw_disconnect('loopback1');
+ postgres_fdw_disconnect
+-------------------------
+ t
+
+
postgres_fdw_disconnect_all() returns boolean
+ This function discards all the open connections that are established by
+ postgres_fdw from the local session to
+ foreign servers. If the connections are used in the current local
+ transaction, they are not disconnected and warning messages are reported.
+ This function returns true if it disconnects
+ at least one connection, otherwise false.
+ Example usage of the function:
+
+postgres=# SELECT postgres_fdw_disconnect_all();
+ postgres_fdw_disconnect_all
+-----------------------------
+ t
+
+
F.38.3. Connection Management #
+ postgres_fdw establishes a connection to a
+ foreign server during the first query that uses a foreign table
+ associated with the foreign server. By default this connection
+ is kept and re-used for subsequent queries in the same session.
+ This behavior can be controlled using
+ keep_connections option for a foreign server. If
+ multiple user identities (user mappings) are used to access the foreign
+ server, a connection is established for each user mapping.
+
+ When changing the definition of or removing a foreign server or
+ a user mapping, the associated connections are closed.
+ But note that if any connections are in use in the current local transaction,
+ they are kept until the end of the transaction.
+ Closed connections will be re-established when they are necessary
+ by future queries using a foreign table.
+
+ Once a connection to a foreign server has been established,
+ it's by default kept until the local or corresponding remote
+ session exits. To disconnect a connection explicitly,
+ keep_connections option for a foreign server
+ may be disabled, or
+ postgres_fdw_disconnect and
+ postgres_fdw_disconnect_all functions
+ may be used. For example, these are useful to close
+ connections that are no longer necessary, thereby releasing
+ connections on the foreign server.
+
F.38.4. Transaction Management #
+ During a query that references any remote tables on a foreign server,
+ postgres_fdw opens a transaction on the
+ remote server if one is not already open corresponding to the current
+ local transaction. The remote transaction is committed or aborted when
+ the local transaction commits or aborts. Savepoints are similarly
+ managed by creating corresponding remote savepoints.
+
+ The remote transaction uses SERIALIZABLE
+ isolation level when the local transaction has SERIALIZABLE
+ isolation level; otherwise it uses REPEATABLE READ
+ isolation level. This choice ensures that if a query performs multiple
+ table scans on the remote server, it will get snapshot-consistent results
+ for all the scans. A consequence is that successive queries within a
+ single transaction will see the same data from the remote server, even if
+ concurrent updates are occurring on the remote server due to other
+ activities. That behavior would be expected anyway if the local
+ transaction uses SERIALIZABLE or REPEATABLE READ
+ isolation level, but it might be surprising for a READ
+ COMMITTED local transaction. A future
+ PostgreSQL release might modify these rules.
+
+ Note that it is currently not supported by
+ postgres_fdw to prepare the remote transaction for
+ two-phase commit.
+
F.38.5. Remote Query Optimization #
+ postgres_fdw attempts to optimize remote queries to reduce
+ the amount of data transferred from foreign servers. This is done by
+ sending query WHERE clauses to the remote server for
+ execution, and by not retrieving table columns that are not needed for
+ the current query. To reduce the risk of misexecution of queries,
+ WHERE clauses are not sent to the remote server unless they use
+ only data types, operators, and functions that are built-in or belong to an
+ extension that's listed in the foreign server's extensions
+ option. Operators and functions in such clauses must
+ be IMMUTABLE as well.
+ For an UPDATE or DELETE query,
+ postgres_fdw attempts to optimize the query execution by
+ sending the whole query to the remote server if there are no query
+ WHERE clauses that cannot be sent to the remote server,
+ no local joins for the query, no row-level local BEFORE or
+ AFTER triggers or stored generated columns on the target
+ table, and no CHECK OPTION constraints from parent
+ views. In UPDATE,
+ expressions to assign to target columns must use only built-in data types,
+ IMMUTABLE operators, or IMMUTABLE functions,
+ to reduce the risk of misexecution of the query.
+
+ When postgres_fdw encounters a join between foreign tables on
+ the same foreign server, it sends the entire join to the foreign server,
+ unless for some reason it believes that it will be more efficient to fetch
+ rows from each table individually, or unless the table references involved
+ are subject to different user mappings. While sending the JOIN
+ clauses, it takes the same precautions as mentioned above for the
+ WHERE clauses.
+
+ The query that is actually sent to the remote server for execution can
+ be examined using EXPLAIN VERBOSE.
+
F.38.6. Remote Query Execution Environment #
+ In the remote sessions opened by postgres_fdw,
+ the search_path parameter is set to
+ just pg_catalog, so that only built-in objects are visible
+ without schema qualification. This is not an issue for queries
+ generated by postgres_fdw itself, because it always
+ supplies such qualification. However, this can pose a hazard for
+ functions that are executed on the remote server via triggers or rules
+ on remote tables. For example, if a remote table is actually a view,
+ any functions used in that view will be executed with the restricted
+ search path. It is recommended to schema-qualify all names in such
+ functions, or else attach SET search_path options
+ (see CREATE FUNCTION) to such functions
+ to establish their expected search path environment.
+
+ postgres_fdw likewise establishes remote session settings
+ for various parameters:
+
+ These are less likely to be problematic than search_path, but
+ can be handled with function SET options if the need arises.
+
+ It is not recommended that you override this behavior by
+ changing the session-level settings of these parameters; that is likely
+ to cause postgres_fdw to malfunction.
+
F.38.7. Cross-Version Compatibility #
+ postgres_fdw can be used with remote servers dating back
+ to PostgreSQL 8.3. Read-only capability is available
+ back to 8.1. A limitation however is that postgres_fdw
+ generally assumes that immutable built-in functions and operators are
+ safe to send to the remote server for execution, if they appear in a
+ WHERE clause for a foreign table. Thus, a built-in
+ function that was added since the remote server's release might be sent
+ to it for execution, resulting in “function does not exist” or
+ a similar error. This type of failure can be worked around by
+ rewriting the query, for example by embedding the foreign table
+ reference in a sub-SELECT with OFFSET 0 as an
+ optimization fence, and placing the problematic function or operator
+ outside the sub-SELECT.
+
F.38.8. Configuration Parameters #
-
+
postgres_fdw.application_name (string)
+
+ #
+ Specifies a value for application_name
+ configuration parameter used when postgres_fdw
+ establishes a connection to a foreign server. This overrides
+ application_name option of the server object.
+ Note that change of this parameter doesn't affect any existing
+ connections until they are re-established.
+
+ postgres_fdw.application_name can be any string
+ of any length and contain even non-ASCII characters. However when
+ it's passed to and used as application_name
+ in a foreign server, note that it will be truncated to less than
+ NAMEDATALEN characters.
+ Anything other than printable ASCII characters are replaced with C-style hexadecimal escapes.
+ See application_name for details.
+
+ % characters begin “escape sequences”
+ that are replaced with status information as outlined below.
+ Unrecognized escapes are ignored. Other characters are copied straight
+ to the application name. Note that it's not allowed to specify a
+ plus/minus sign or a numeric literal after the %
+ and before the option, for alignment and padding.
+
+ For example, suppose user local_user establishes
+ a connection from database local_db to
+ foreign_db as user foreign_user,
+ the setting 'db=%d, user=%u' is replaced with
+ 'db=local_db, user=local_user'.
+
+ Here is an example of creating a foreign table with
+ postgres_fdw. First install the extension:
+
+CREATE EXTENSION postgres_fdw;
+
+ Then create a foreign server using CREATE SERVER.
+ In this example we wish to connect to a PostgreSQL server
+ on host 192.83.123.89 listening on
+ port 5432. The database to which the connection is made
+ is named foreign_db on the remote server:
+
+
+CREATE SERVER foreign_server
+ FOREIGN DATA WRAPPER postgres_fdw
+ OPTIONS (host '192.83.123.89', port '5432', dbname 'foreign_db');
+
+
+ A user mapping, defined with CREATE USER MAPPING, is
+ needed as well to identify the role that will be used on the remote
+ server:
+
+
+CREATE USER MAPPING FOR local_user
+ SERVER foreign_server
+ OPTIONS (user 'foreign_user', password 'password');
+
+
+ Now it is possible to create a foreign table with
+ CREATE FOREIGN TABLE. In this example we
+ wish to access the table named some_schema.some_table
+ on the remote server. The local name for it will
+ be foreign_table:
+
+
+CREATE FOREIGN TABLE foreign_table (
+ id integer NOT NULL,
+ data text
+)
+ SERVER foreign_server
+ OPTIONS (schema_name 'some_schema', table_name 'some_table');
+
+
+ It's essential that the data types and other properties of the columns
+ declared in CREATE FOREIGN TABLE match the actual remote table.
+ Column names must match as well, unless you attach column_name
+ options to the individual columns to show how they are named in the remote
+ table.
+ In many cases, use of IMPORT FOREIGN SCHEMA is
+ preferable to constructing foreign table definitions manually.
+
19.1. The PostgreSQL User Account #
+ As with any server daemon that is accessible to the outside world,
+ it is advisable to run PostgreSQL under a
+ separate user account. This user account should only own the data
+ that is managed by the server, and should not be shared with other
+ daemons. (For example, using the user nobody is a bad
+ idea.) In particular, it is advisable that this user account not own
+ the PostgreSQL executable files, to ensure
+ that a compromised server process could not modify those executables.
+
+ Pre-packaged versions of PostgreSQL will
+ typically create a suitable user account automatically during
+ package installation.
+
+ To add a Unix user account to your system, look for a command
+ useradd or adduser. The user
+ name postgres is often used, and is assumed
+ throughout this book, but you can use another name if you like.
+
+ PostgreSQL provides a set of predefined roles
+ that provide access to certain, commonly needed, privileged capabilities
+ and information. Administrators (including roles that have the
+ CREATEROLE privilege) can GRANT these
+ roles to users and/or other roles in their environment, providing those
+ users with access to the specified capabilities and information.
+
+ The predefined roles are described in Table 22.1.
+ Note that the specific permissions for each of the roles may change in
+ the future as additional capabilities are added. Administrators
+ should monitor the release notes for changes.
+
Table 22.1. Predefined Roles
| Role | Allowed Access |
|---|
| pg_read_all_data | Read all data (tables, views, sequences), as if having
+ SELECT rights on those objects, and USAGE rights on
+ all schemas, even without having it explicitly. This role does not have
+ the role attribute BYPASSRLS set. If RLS is being
+ used, an administrator may wish to set BYPASSRLS on
+ roles which this role is GRANTed to. |
| pg_write_all_data | Write all data (tables, views, sequences), as if having
+ INSERT, UPDATE, and
+ DELETE rights on those objects, and USAGE rights on
+ all schemas, even without having it explicitly. This role does not have
+ the role attribute BYPASSRLS set. If RLS is being
+ used, an administrator may wish to set BYPASSRLS on
+ roles which this role is GRANTed to. |
| pg_read_all_settings | Read all configuration variables, even those normally visible only to
+ superusers. |
| pg_read_all_stats | Read all pg_stat_* views and use various statistics related extensions,
+ even those normally visible only to superusers. |
| pg_stat_scan_tables | Execute monitoring functions that may take ACCESS SHARE locks on tables,
+ potentially for a long time. |
| pg_monitor | Read/execute various monitoring views and functions.
+ This role is a member of pg_read_all_settings,
+ pg_read_all_stats and
+ pg_stat_scan_tables. |
| pg_database_owner | None. Membership consists, implicitly, of the current database owner. |
| pg_signal_backend | Signal another backend to cancel a query or terminate its session. |
| pg_read_server_files | Allow reading files from any location the database can access on the server with COPY and
+ other file-access functions. |
| pg_write_server_files | Allow writing to files in any location the database can access on the server with COPY and
+ other file-access functions. |
| pg_execute_server_program | Allow executing programs on the database server as the user the database runs as with
+ COPY and other functions which allow executing a server-side program. |
| pg_checkpoint | Allow executing
+ the CHECKPOINT
+ command. |
| pg_use_reserved_connections | Allow use of connection slots reserved via
+ reserved_connections. |
| pg_create_subscription | Allow users with CREATE permission on the
+ database to issue
+ CREATE SUBSCRIPTION. |
+ The pg_monitor, pg_read_all_settings,
+ pg_read_all_stats and pg_stat_scan_tables
+ roles are intended to allow administrators to easily configure a role for the
+ purpose of monitoring the database server. They grant a set of common privileges
+ allowing the role to read various useful configuration settings, statistics and
+ other system information normally restricted to superusers.
+
+ The pg_database_owner role has one implicit,
+ situation-dependent member, namely the owner of the current database. Like
+ any role, it can own objects or receive grants of access privileges.
+ Consequently, once pg_database_owner has rights within a
+ template database, each owner of a database instantiated from that template
+ will exercise those rights. pg_database_owner cannot be
+ a member of any role, and it cannot have non-implicit members. Initially,
+ this role owns the public schema, so each database owner
+ governs local use of the schema.
+
+ The pg_signal_backend role is intended to allow
+ administrators to enable trusted, but non-superuser, roles to send signals
+ to other backends. Currently this role enables sending of signals for
+ canceling a query on another backend or terminating its session. A user
+ granted this role cannot however send signals to a backend owned by a
+ superuser. See Section 9.27.2.
+
+ The pg_read_server_files, pg_write_server_files and
+ pg_execute_server_program roles are intended to allow administrators to have
+ trusted, but non-superuser, roles which are able to access files and run programs on the
+ database server as the user the database runs as. As these roles are able to access any file on
+ the server file system, they bypass all database-level permission checks when accessing files
+ directly and they could be used to gain superuser-level access, therefore
+ great care should be taken when granting these roles to users.
+
+ Care should be taken when granting these roles to ensure they are only used where
+ needed and with the understanding that these roles grant access to privileged
+ information.
+
+ Administrators can grant access to these roles to users using the
+ GRANT command, for example:
+
+
+GRANT pg_signal_backend TO admin_user;
+
+
+ This book is the official documentation of
+ PostgreSQL. It has been written by the
+ PostgreSQL developers and other
+ volunteers in parallel to the development of the
+ PostgreSQL software. It describes all
+ the functionality that the current version of
+ PostgreSQL officially supports.
+
+ To make the large amount of information about
+ PostgreSQL manageable, this book has been
+ organized in several parts. Each part is targeted at a different
+ class of users, or at users in different stages of their
+ PostgreSQL experience:
+
+
+ Part I is an informal introduction for new users.
+
+ Part II documents the SQL query
+ language environment, including data types and functions, as well
+ as user-level performance tuning. Every
+ PostgreSQL user should read this.
+
+ Part III describes the installation and
+ administration of the server. Everyone who runs a
+ PostgreSQL server, be it for private
+ use or for others, should read this part.
+
+ Part IV describes the programming
+ interfaces for PostgreSQL client
+ programs.
+
+ Part V contains information for
+ advanced users about the extensibility capabilities of the
+ server. Topics include user-defined data types and
+ functions.
+
+ Part VI contains reference information about
+ SQL commands, client and server programs. This part supports
+ the other parts with structured information sorted by command or
+ program.
+
+ Part VII contains assorted information that might be of
+ use to PostgreSQL developers.
+
+
19.7. Preventing Server Spoofing #
+ While the server is running, it is not possible for a malicious user
+ to take the place of the normal database server. However, when the
+ server is down, it is possible for a local user to spoof the normal
+ server by starting their own server. The spoof server could read
+ passwords and queries sent by clients, but could not return any data
+ because the PGDATA directory would still be secure because
+ of directory permissions. Spoofing is possible because any user can
+ start a database server; a client cannot identify an invalid server
+ unless it is specially configured.
+
+ One way to prevent spoofing of local
+ connections is to use a Unix domain socket directory (unix_socket_directories) that has write permission only
+ for a trusted local user. This prevents a malicious user from creating
+ their own socket file in that directory. If you are concerned that
+ some applications might still reference /tmp for the
+ socket file and hence be vulnerable to spoofing, during operating system
+ startup create a symbolic link /tmp/.s.PGSQL.5432 that points
+ to the relocated socket file. You also might need to modify your
+ /tmp cleanup script to prevent removal of the symbolic link.
+
+ Another option for local connections is for clients to use
+ requirepeer
+ to specify the required owner of the server process connected to
+ the socket.
+
+ To prevent spoofing on TCP connections, either use
+ SSL certificates and make sure that clients check the server's certificate,
+ or use GSSAPI encryption (or both, if they're on separate connections).
+
+ To prevent spoofing with SSL, the server
+ must be configured to accept only hostssl connections (Section 21.1) and have SSL key and certificate files
+ (Section 19.9). The TCP client must connect using
+ sslmode=verify-ca or
+ verify-full and have the appropriate root certificate
+ file installed (Section 34.19.1). Alternatively the
+ system CA pool can be used using sslrootcert=system; in
+ this case, sslmode=verify-full is forced for safety, since
+ it is generally trivial to obtain certificates which are signed by a public
+ CA.
+
+ To prevent server spoofing from occurring when using
+ scram-sha-256 password authentication
+ over a network, you should ensure that you connect to the server using SSL
+ and with one of the anti-spoofing methods described in the previous
+ paragraph. Additionally, the SCRAM implementation in
+ libpq cannot protect the entire authentication
+ exchange, but using the channel_binding=require connection
+ parameter provides a mitigation against server spoofing. An attacker that
+ uses a rogue server to intercept a SCRAM exchange can use offline analysis to
+ potentially determine the hashed password from the client.
+
+ To prevent spoofing with GSSAPI, the server must be configured to accept
+ only hostgssenc connections
+ (Section 21.1) and use gss
+ authentication with them. The TCP client must connect
+ using gssencmode=require.
+
28.4. Progress Reporting #
+ PostgreSQL has the ability to report the progress of
+ certain commands during command execution. Currently, the only commands
+ which support progress reporting are ANALYZE,
+ CLUSTER,
+ CREATE INDEX, VACUUM,
+ COPY,
+ and BASE_BACKUP (i.e., replication
+ command that pg_basebackup issues to take
+ a base backup).
+ This may be expanded in the future.
+
28.4.1. ANALYZE Progress Reporting #
+ Whenever ANALYZE is running, the
+ pg_stat_progress_analyze view will contain a
+ row for each backend that is currently running that command. The tables
+ below describe the information that will be reported and provide
+ information about how to interpret it.
+
Table 28.37. pg_stat_progress_analyze View
+ Column Type
+
+
+ Description
+ |
|---|
+ pid integer
+
+
+ Process ID of backend.
+ |
+ datid oid
+
+
+ OID of the database to which this backend is connected.
+ |
+ datname name
+
+
+ Name of the database to which this backend is connected.
+ |
+ relid oid
+
+
+ OID of the table being analyzed.
+ |
+ phase text
+
+
+ Current processing phase. See Table 28.38.
+ |
+ sample_blks_total bigint
+
+
+ Total number of heap blocks that will be sampled.
+ |
+ sample_blks_scanned bigint
+
+
+ Number of heap blocks scanned.
+ |
+ ext_stats_total bigint
+
+
+ Number of extended statistics.
+ |
+ ext_stats_computed bigint
+
+
+ Number of extended statistics computed. This counter only advances
+ when the phase is computing extended statistics.
+ |
+ child_tables_total bigint
+
+
+ Number of child tables.
+ |
+ child_tables_done bigint
+
+
+ Number of child tables scanned. This counter only advances when the
+ phase is acquiring inherited sample rows.
+ |
+ current_child_table_relid oid
+
+
+ OID of the child table currently being scanned. This field is
+ only valid when the phase is
+ acquiring inherited sample rows.
+ |
Table 28.38. ANALYZE Phases
| Phase | Description |
|---|
initializing |
+ The command is preparing to begin scanning the heap. This phase is
+ expected to be very brief.
+ |
acquiring sample rows |
+ The command is currently scanning the table given by
+ relid to obtain sample rows.
+ |
acquiring inherited sample rows |
+ The command is currently scanning child tables to obtain sample rows.
+ Columns child_tables_total,
+ child_tables_done, and
+ current_child_table_relid contain the
+ progress information for this phase.
+ |
computing statistics |
+ The command is computing statistics from the sample rows obtained
+ during the table scan.
+ |
computing extended statistics |
+ The command is computing extended statistics from the sample rows
+ obtained during the table scan.
+ |
finalizing analyze |
+ The command is updating pg_class. When this
+ phase is completed, ANALYZE will end.
+ |
Note
+ Note that when ANALYZE is run on a partitioned table,
+ all of its partitions are also recursively analyzed.
+ In that case, ANALYZE
+ progress is reported first for the parent table, whereby its inheritance
+ statistics are collected, followed by that for each partition.
+
28.4.2. CLUSTER Progress Reporting #
+ Whenever CLUSTER or VACUUM FULL is
+ running, the pg_stat_progress_cluster view will
+ contain a row for each backend that is currently running either command.
+ The tables below describe the information that will be reported and
+ provide information about how to interpret it.
+
Table 28.39. pg_stat_progress_cluster View
+ Column Type
+
+
+ Description
+ |
|---|
+ pid integer
+
+
+ Process ID of backend.
+ |
+ datid oid
+
+
+ OID of the database to which this backend is connected.
+ |
+ datname name
+
+
+ Name of the database to which this backend is connected.
+ |
+ relid oid
+
+
+ OID of the table being clustered.
+ |
+ command text
+
+
+ The command that is running. Either CLUSTER or VACUUM FULL.
+ |
+ phase text
+
+
+ Current processing phase. See Table 28.40.
+ |
+ cluster_index_relid oid
+
+
+ If the table is being scanned using an index, this is the OID of the
+ index being used; otherwise, it is zero.
+ |
+ heap_tuples_scanned bigint
+
+
+ Number of heap tuples scanned.
+ This counter only advances when the phase is
+ seq scanning heap,
+ index scanning heap
+ or writing new heap.
+ |
+ heap_tuples_written bigint
+
+
+ Number of heap tuples written.
+ This counter only advances when the phase is
+ seq scanning heap,
+ index scanning heap
+ or writing new heap.
+ |
+ heap_blks_total bigint
+
+
+ Total number of heap blocks in the table. This number is reported
+ as of the beginning of seq scanning heap.
+ |
+ heap_blks_scanned bigint
+
+
+ Number of heap blocks scanned. This counter only advances when the
+ phase is seq scanning heap.
+ |
+ index_rebuild_count bigint
+
+
+ Number of indexes rebuilt. This counter only advances when the phase
+ is rebuilding index.
+ |
Table 28.40. CLUSTER and VACUUM FULL Phases
| Phase | Description |
|---|
initializing |
+ The command is preparing to begin scanning the heap. This phase is
+ expected to be very brief.
+ |
seq scanning heap |
+ The command is currently scanning the table using a sequential scan.
+ |
index scanning heap |
+ CLUSTER is currently scanning the table using an index scan.
+ |
sorting tuples |
+ CLUSTER is currently sorting tuples.
+ |
writing new heap |
+ CLUSTER is currently writing the new heap.
+ |
swapping relation files |
+ The command is currently swapping newly-built files into place.
+ |
rebuilding index |
+ The command is currently rebuilding an index.
+ |
performing final cleanup |
+ The command is performing final cleanup. When this phase is
+ completed, CLUSTER
+ or VACUUM FULL will end.
+ |
28.4.3. COPY Progress Reporting #
+ Whenever COPY is running, the
+ pg_stat_progress_copy view will contain one row
+ for each backend that is currently running a COPY command.
+ The table below describes the information that will be reported and provides
+ information about how to interpret it.
+
Table 28.41. pg_stat_progress_copy View
+ Column Type
+
+
+ Description
+ |
|---|
+ pid integer
+
+
+ Process ID of backend.
+ |
+ datid oid
+
+
+ OID of the database to which this backend is connected.
+ |
+ datname name
+
+
+ Name of the database to which this backend is connected.
+ |
+ relid oid
+
+
+ OID of the table on which the COPY command is
+ executed. It is set to 0 if copying from a
+ SELECT query.
+ |
+ command text
+
+
+ The command that is running: COPY FROM, or
+ COPY TO.
+ |
+ type text
+
+
+ The io type that the data is read from or written to:
+ FILE, PROGRAM,
+ PIPE (for COPY FROM STDIN and
+ COPY TO STDOUT), or CALLBACK
+ (used for example during the initial table synchronization in
+ logical replication).
+ |
+ bytes_processed bigint
+
+
+ Number of bytes already processed by COPY command.
+ |
+ bytes_total bigint
+
+
+ Size of source file for COPY FROM command in bytes.
+ It is set to 0 if not available.
+ |
+ tuples_processed bigint
+
+
+ Number of tuples already processed by COPY command.
+ |
+ tuples_excluded bigint
+
+
+ Number of tuples not processed because they were excluded by the
+ WHERE clause of the COPY command.
+ |
28.4.4. CREATE INDEX Progress Reporting #
+ Whenever CREATE INDEX or REINDEX is running, the
+ pg_stat_progress_create_index view will contain
+ one row for each backend that is currently creating indexes. The tables
+ below describe the information that will be reported and provide information
+ about how to interpret it.
+
Table 28.42. pg_stat_progress_create_index View
+ Column Type
+
+
+ Description
+ |
|---|
+ pid integer
+
+
+ Process ID of the backend creating indexes.
+ |
+ datid oid
+
+
+ OID of the database to which this backend is connected.
+ |
+ datname name
+
+
+ Name of the database to which this backend is connected.
+ |
+ relid oid
+
+
+ OID of the table on which the index is being created.
+ |
+ index_relid oid
+
+
+ OID of the index being created or reindexed. During a
+ non-concurrent CREATE INDEX, this is 0.
+ |
+ command text
+
+
+ Specific command type: CREATE INDEX,
+ CREATE INDEX CONCURRENTLY,
+ REINDEX, or REINDEX CONCURRENTLY.
+ |
+ phase text
+
+
+ Current processing phase of index creation. See Table 28.43.
+ |
+ lockers_total bigint
+
+
+ Total number of lockers to wait for, when applicable.
+ |
+ lockers_done bigint
+
+
+ Number of lockers already waited for.
+ |
+ current_locker_pid bigint
+
+
+ Process ID of the locker currently being waited for.
+ |
+ blocks_total bigint
+
+
+ Total number of blocks to be processed in the current phase.
+ |
+ blocks_done bigint
+
+
+ Number of blocks already processed in the current phase.
+ |
+ tuples_total bigint
+
+
+ Total number of tuples to be processed in the current phase.
+ |
+ tuples_done bigint
+
+
+ Number of tuples already processed in the current phase.
+ |
+ partitions_total bigint
+
+
+ Total number of partitions on which the index is to be created
+ or attached, including both direct and indirect partitions.
+ 0 during a REINDEX, or when
+ the index is not partitioned.
+ |
+ partitions_done bigint
+
+
+ Number of partitions on which the index has already been created
+ or attached, including both direct and indirect partitions.
+ 0 during a REINDEX, or when
+ the index is not partitioned.
+ |
Table 28.43. CREATE INDEX Phases
| Phase | Description |
|---|
initializing |
+ CREATE INDEX or REINDEX is preparing to create the index. This
+ phase is expected to be very brief.
+ |
waiting for writers before build |
+ CREATE INDEX CONCURRENTLY or REINDEX CONCURRENTLY is waiting for transactions
+ with write locks that can potentially see the table to finish.
+ This phase is skipped when not in concurrent mode.
+ Columns lockers_total, lockers_done
+ and current_locker_pid contain the progress
+ information for this phase.
+ |
building index |
+ The index is being built by the access method-specific code. In this phase,
+ access methods that support progress reporting fill in their own progress data,
+ and the subphase is indicated in this column. Typically,
+ blocks_total and blocks_done
+ will contain progress data, as well as potentially
+ tuples_total and tuples_done.
+ |
waiting for writers before validation |
+ CREATE INDEX CONCURRENTLY or REINDEX CONCURRENTLY is waiting for transactions
+ with write locks that can potentially write into the table to finish.
+ This phase is skipped when not in concurrent mode.
+ Columns lockers_total, lockers_done
+ and current_locker_pid contain the progress
+ information for this phase.
+ |
index validation: scanning index |
+ CREATE INDEX CONCURRENTLY is scanning the index searching
+ for tuples that need to be validated.
+ This phase is skipped when not in concurrent mode.
+ Columns blocks_total (set to the total size of the index)
+ and blocks_done contain the progress information for this phase.
+ |
index validation: sorting tuples |
+ CREATE INDEX CONCURRENTLY is sorting the output of the
+ index scanning phase.
+ |
index validation: scanning table |
+ CREATE INDEX CONCURRENTLY is scanning the table
+ to validate the index tuples collected in the previous two phases.
+ This phase is skipped when not in concurrent mode.
+ Columns blocks_total (set to the total size of the table)
+ and blocks_done contain the progress information for this phase.
+ |
waiting for old snapshots |
+ CREATE INDEX CONCURRENTLY or REINDEX CONCURRENTLY is waiting for transactions
+ that can potentially see the table to release their snapshots. This
+ phase is skipped when not in concurrent mode.
+ Columns lockers_total, lockers_done
+ and current_locker_pid contain the progress
+ information for this phase.
+ |
waiting for readers before marking dead |
+ REINDEX CONCURRENTLY is waiting for transactions
+ with read locks on the table to finish, before marking the old index dead.
+ This phase is skipped when not in concurrent mode.
+ Columns lockers_total, lockers_done
+ and current_locker_pid contain the progress
+ information for this phase.
+ |
waiting for readers before dropping |
+ REINDEX CONCURRENTLY is waiting for transactions
+ with read locks on the table to finish, before dropping the old index.
+ This phase is skipped when not in concurrent mode.
+ Columns lockers_total, lockers_done
+ and current_locker_pid contain the progress
+ information for this phase.
+ |
28.4.5. VACUUM Progress Reporting #
+ Whenever VACUUM is running, the
+ pg_stat_progress_vacuum view will contain
+ one row for each backend (including autovacuum worker processes) that is
+ currently vacuuming. The tables below describe the information
+ that will be reported and provide information about how to interpret it.
+ Progress for VACUUM FULL commands is reported via
+ pg_stat_progress_cluster
+ because both VACUUM FULL and CLUSTER
+ rewrite the table, while regular VACUUM only modifies it
+ in place. See Section 28.4.2.
+
Table 28.44. pg_stat_progress_vacuum View
+ Column Type
+
+
+ Description
+ |
|---|
+ pid integer
+
+
+ Process ID of backend.
+ |
+ datid oid
+
+
+ OID of the database to which this backend is connected.
+ |
+ datname name
+
+
+ Name of the database to which this backend is connected.
+ |
+ relid oid
+
+
+ OID of the table being vacuumed.
+ |
+ phase text
+
+
+ Current processing phase of vacuum. See Table 28.45.
+ |
+ heap_blks_total bigint
+
+
+ Total number of heap blocks in the table. This number is reported
+ as of the beginning of the scan; blocks added later will not be (and
+ need not be) visited by this VACUUM.
+ |
+ heap_blks_scanned bigint
+
+
+ Number of heap blocks scanned. Because the
+ visibility map is used to optimize scans,
+ some blocks will be skipped without inspection; skipped blocks are
+ included in this total, so that this number will eventually become
+ equal to heap_blks_total when the vacuum is complete.
+ This counter only advances when the phase is scanning heap.
+ |
+ heap_blks_vacuumed bigint
+
+
+ Number of heap blocks vacuumed. Unless the table has no indexes, this
+ counter only advances when the phase is vacuuming heap.
+ Blocks that contain no dead tuples are skipped, so the counter may
+ sometimes skip forward in large increments.
+ |
+ index_vacuum_count bigint
+
+
+ Number of completed index vacuum cycles.
+ |
+ max_dead_tuples bigint
+
+
+ Number of dead tuples that we can store before needing to perform
+ an index vacuum cycle, based on
+ maintenance_work_mem.
+ |
+ num_dead_tuples bigint
+
+
+ Number of dead tuples collected since the last index vacuum cycle.
+ |
Table 28.45. VACUUM Phases
| Phase | Description |
|---|
initializing |
+ VACUUM is preparing to begin scanning the heap. This
+ phase is expected to be very brief.
+ |
scanning heap |
+ VACUUM is currently scanning the heap. It will prune and
+ defragment each page if required, and possibly perform freezing
+ activity. The heap_blks_scanned column can be used
+ to monitor the progress of the scan.
+ |
vacuuming indexes |
+ VACUUM is currently vacuuming the indexes. If a table has
+ any indexes, this will happen at least once per vacuum, after the heap
+ has been completely scanned. It may happen multiple times per vacuum
+ if maintenance_work_mem (or, in the case of autovacuum,
+ autovacuum_work_mem if set) is insufficient to store
+ the number of dead tuples found.
+ |
vacuuming heap |
+ VACUUM is currently vacuuming the heap. Vacuuming the heap
+ is distinct from scanning the heap, and occurs after each instance of
+ vacuuming indexes. If heap_blks_scanned is less than
+ heap_blks_total, the system will return to scanning
+ the heap after this phase is completed; otherwise, it will begin
+ cleaning up indexes after this phase is completed.
+ |
cleaning up indexes |
+ VACUUM is currently cleaning up indexes. This occurs after
+ the heap has been completely scanned and all vacuuming of the indexes
+ and the heap has been completed.
+ |
truncating heap |
+ VACUUM is currently truncating the heap so as to return
+ empty pages at the end of the relation to the operating system. This
+ occurs after cleaning up indexes.
+ |
performing final cleanup |
+ VACUUM is performing final cleanup. During this phase,
+ VACUUM will vacuum the free space map, update statistics
+ in pg_class, and report statistics to the cumulative
+ statistics system. When this phase is completed, VACUUM will end.
+ |
28.4.6. Base Backup Progress Reporting #
+ Whenever an application like pg_basebackup
+ is taking a base backup, the
+ pg_stat_progress_basebackup
+ view will contain a row for each WAL sender process that is currently
+ running the BASE_BACKUP replication command
+ and streaming the backup. The tables below describe the information
+ that will be reported and provide information about how to interpret it.
+
Table 28.46. pg_stat_progress_basebackup View
+ Column Type
+
+
+ Description
+ |
|---|
+ pid integer
+
+
+ Process ID of a WAL sender process.
+ |
+ phase text
+
+
+ Current processing phase. See Table 28.47.
+ |
+ backup_total bigint
+
+
+ Total amount of data that will be streamed. This is estimated and
+ reported as of the beginning of
+ streaming database files phase. Note that
+ this is only an approximation since the database
+ may change during streaming database files phase
+ and WAL log may be included in the backup later. This is always
+ the same value as backup_streamed
+ once the amount of data streamed exceeds the estimated
+ total size. If the estimation is disabled in
+ pg_basebackup
+ (i.e., --no-estimate-size option is specified),
+ this is NULL.
+ |
+ backup_streamed bigint
+
+
+ Amount of data streamed. This counter only advances
+ when the phase is streaming database files or
+ transferring wal files.
+ |
+ tablespaces_total bigint
+
+
+ Total number of tablespaces that will be streamed.
+ |
+ tablespaces_streamed bigint
+
+
+ Number of tablespaces streamed. This counter only
+ advances when the phase is streaming database files.
+ |
Table 28.47. Base Backup Phases
| Phase | Description |
|---|
initializing |
+ The WAL sender process is preparing to begin the backup.
+ This phase is expected to be very brief.
+ |
waiting for checkpoint to finish |
+ The WAL sender process is currently performing
+ pg_backup_start to prepare to
+ take a base backup, and waiting for the start-of-backup
+ checkpoint to finish.
+ |
estimating backup size |
+ The WAL sender process is currently estimating the total amount
+ of database files that will be streamed as a base backup.
+ |
streaming database files |
+ The WAL sender process is currently streaming database files
+ as a base backup.
+ |
waiting for wal archiving to finish |
+ The WAL sender process is currently performing
+ pg_backup_stop to finish the backup,
+ and waiting for all the WAL files required for the base backup
+ to be successfully archived.
+ If either --wal-method=none or
+ --wal-method=stream is specified in
+ pg_basebackup, the backup will end
+ when this phase is completed.
+ |
transferring wal files |
+ The WAL sender process is currently transferring all WAL logs
+ generated during the backup. This phase occurs after
+ waiting for wal archiving to finish phase if
+ --wal-method=fetch is specified in
+ pg_basebackup. The backup will end
+ when this phase is completed.
+ |
55.10. Summary of Changes since Protocol 2.0 #
+ This section provides a quick checklist of changes, for the benefit of
+ developers trying to update existing client libraries to protocol 3.0.
+
+ The initial startup packet uses a flexible list-of-strings format
+ instead of a fixed format. Notice that session default values for run-time
+ parameters can now be specified directly in the startup packet. (Actually,
+ you could do that before using the options field, but given the
+ limited width of options and the lack of any way to quote
+ whitespace in the values, it wasn't a very safe technique.)
+
+ All messages now have a length count immediately following the message type
+ byte (except for startup packets, which have no type byte). Also note that
+ PasswordMessage now has a type byte.
+
+ ErrorResponse and NoticeResponse ('E' and 'N')
+ messages now contain multiple fields, from which the client code can
+ assemble an error message of the desired level of verbosity. Note that
+ individual fields will typically not end with a newline, whereas the single
+ string sent in the older protocol always did.
+
+ The ReadyForQuery ('Z') message includes a transaction status
+ indicator.
+
+ The distinction between BinaryRow and DataRow message types is gone; the
+ single DataRow message type serves for returning data in all formats.
+ Note that the layout of DataRow has changed to make it easier to parse.
+ Also, the representation of binary values has changed: it is no longer
+ directly tied to the server's internal representation.
+
+ There is a new “extended query” sub-protocol, which adds the frontend
+ message types Parse, Bind, Execute, Describe, Close, Flush, and Sync, and the
+ backend message types ParseComplete, BindComplete, PortalSuspended,
+ ParameterDescription, NoData, and CloseComplete. Existing clients do not
+ have to concern themselves with this sub-protocol, but making use of it
+ might allow improvements in performance or functionality.
+
+ COPY data is now encapsulated into CopyData and CopyDone messages. There
+ is a well-defined way to recover from errors during COPY. The special
+ “\.” last line is not needed anymore, and is not sent
+ during COPY OUT.
+ (It is still recognized as a terminator during COPY IN, but its use is
+ deprecated and will eventually be removed.) Binary COPY is supported.
+ The CopyInResponse and CopyOutResponse messages include fields indicating
+ the number of columns and the format of each column.
+
+ The layout of FunctionCall and FunctionCallResponse messages has changed.
+ FunctionCall can now support passing NULL arguments to functions. It also
+ can handle passing parameters and retrieving results in either text or
+ binary format. There is no longer any reason to consider FunctionCall a
+ potential security hole, since it does not offer direct access to internal
+ server data representations.
+
+ The backend sends ParameterStatus ('S') messages during connection
+ startup for all parameters it considers interesting to the client library.
+ Subsequently, a ParameterStatus message is sent whenever the active value
+ changes for any of these parameters.
+
+ The RowDescription ('T') message carries new table OID and column
+ number fields for each column of the described row. It also shows the format
+ code for each column.
+
+ The CursorResponse ('P') message is no longer generated by
+ the backend.
+
+ The NotificationResponse ('A') message has an additional string
+ field, which can carry a “payload” string passed
+ from the NOTIFY event sender.
+
+ The EmptyQueryResponse ('I') message used to include an empty
+ string parameter; this has been removed.
+
55.8. Error and Notice Message Fields #
+ This section describes the fields that can appear in ErrorResponse and
+ NoticeResponse messages. Each field type has a single-byte identification
+ token. Note that any given field type should appear at most once per
+ message.
+
S
+ Severity: the field contents are
+ ERROR, FATAL, or
+ PANIC (in an error message), or
+ WARNING, NOTICE, DEBUG,
+ INFO, or LOG (in a notice message),
+ or a localized translation of one of these. Always present.
+
V
+ Severity: the field contents are
+ ERROR, FATAL, or
+ PANIC (in an error message), or
+ WARNING, NOTICE, DEBUG,
+ INFO, or LOG (in a notice message).
+ This is identical to the S field except
+ that the contents are never localized. This is present only in
+ messages generated by PostgreSQL versions 9.6
+ and later.
+
C
+ Code: the SQLSTATE code for the error (see Appendix A). Not localizable. Always present.
+
M
+ Message: the primary human-readable error message.
+ This should be accurate but terse (typically one line).
+ Always present.
+
D
+ Detail: an optional secondary error message carrying more
+ detail about the problem. Might run to multiple lines.
+
H
+ Hint: an optional suggestion what to do about the problem.
+ This is intended to differ from Detail in that it offers advice
+ (potentially inappropriate) rather than hard facts.
+ Might run to multiple lines.
+
P
+ Position: the field value is a decimal ASCII integer, indicating
+ an error cursor position as an index into the original query string.
+ The first character has index 1, and positions are measured in
+ characters not bytes.
+
p
+ Internal position: this is defined the same as the P
+ field, but it is used when the cursor position refers to an internally
+ generated command rather than the one submitted by the client.
+ The q field will always appear when this field appears.
+
q
+ Internal query: the text of a failed internally-generated command.
+ This could be, for example, an SQL query issued by a PL/pgSQL function.
+
W
+ Where: an indication of the context in which the error occurred.
+ Presently this includes a call stack traceback of active
+ procedural language functions and internally-generated queries.
+ The trace is one entry per line, most recent first.
+
s
+ Schema name: if the error was associated with a specific database
+ object, the name of the schema containing that object, if any.
+
t
+ Table name: if the error was associated with a specific table, the
+ name of the table. (Refer to the schema name field for the name of
+ the table's schema.)
+
c
+ Column name: if the error was associated with a specific table column,
+ the name of the column. (Refer to the schema and table name fields to
+ identify the table.)
+
d
+ Data type name: if the error was associated with a specific data type,
+ the name of the data type. (Refer to the schema name field for the
+ name of the data type's schema.)
+
n
+ Constraint name: if the error was associated with a specific
+ constraint, the name of the constraint. Refer to fields listed above
+ for the associated table or domain. (For this purpose, indexes are
+ treated as constraints, even if they weren't created with constraint
+ syntax.)
+
F
+ File: the file name of the source-code location where the error
+ was reported.
+
L
+ Line: the line number of the source-code location where the error
+ was reported.
+
R
+ Routine: the name of the source-code routine reporting the error.
+
Note
+ The fields for schema name, table name, column name, data type name, and
+ constraint name are supplied only for a limited number of error types;
+ see Appendix A. Frontends should not assume that
+ the presence of any of these fields guarantees the presence of another
+ field. Core error sources observe the interrelationships noted above, but
+ user-defined functions may use these fields in other ways. In the same
+ vein, clients should not assume that these fields denote contemporary
+ objects in the current database.
+
+ The client is responsible for formatting displayed information to meet its
+ needs; in particular it should break long lines as needed. Newline characters
+ appearing in the error message fields should be treated as paragraph breaks,
+ not line breaks.
+
+ This section describes the message flow and the semantics of each
+ message type. (Details of the exact representation of each message
+ appear in Section 55.7.) There are
+ several different sub-protocols depending on the state of the
+ connection: start-up, query, function call,
+ COPY, and termination. There are also special
+ provisions for asynchronous operations (including notification
+ responses and command cancellation), which can occur at any time
+ after the start-up phase.
+
+ To begin a session, a frontend opens a connection to the server and sends
+ a startup message. This message includes the names of the user and of the
+ database the user wants to connect to; it also identifies the particular
+ protocol version to be used. (Optionally, the startup message can include
+ additional settings for run-time parameters.)
+ The server then uses this information and
+ the contents of its configuration files (such as
+ pg_hba.conf) to determine
+ whether the connection is provisionally acceptable, and what additional
+ authentication is required (if any).
+
+ The server then sends an appropriate authentication request message,
+ to which the frontend must reply with an appropriate authentication
+ response message (such as a password).
+ For all authentication methods except GSSAPI, SSPI and SASL, there is at
+ most one request and one response. In some methods, no response
+ at all is needed from the frontend, and so no authentication request
+ occurs. For GSSAPI, SSPI and SASL, multiple exchanges of packets may be
+ needed to complete the authentication.
+
+ The authentication cycle ends with the server either rejecting the
+ connection attempt (ErrorResponse), or sending AuthenticationOk.
+
+ The possible messages from the server in this phase are:
+
+
- ErrorResponse
+ The connection attempt has been rejected.
+ The server then immediately closes the connection.
+
- AuthenticationOk
+ The authentication exchange is successfully completed.
+
- AuthenticationKerberosV5
+ The frontend must now take part in a Kerberos V5
+ authentication dialog (not described here, part of the
+ Kerberos specification) with the server. If this is
+ successful, the server responds with an AuthenticationOk,
+ otherwise it responds with an ErrorResponse. This is no
+ longer supported.
+
- AuthenticationCleartextPassword
+ The frontend must now send a PasswordMessage containing the
+ password in clear-text form. If
+ this is the correct password, the server responds with an
+ AuthenticationOk, otherwise it responds with an ErrorResponse.
+
- AuthenticationMD5Password
+ The frontend must now send a PasswordMessage containing the
+ password (with user name) encrypted via MD5, then encrypted
+ again using the 4-byte random salt specified in the
+ AuthenticationMD5Password message. If this is the correct
+ password, the server responds with an AuthenticationOk,
+ otherwise it responds with an ErrorResponse. The actual
+ PasswordMessage can be computed in SQL as concat('md5',
+ md5(concat(md5(concat(password, username)), random-salt))).
+ (Keep in mind the md5() function returns its
+ result as a hex string.)
+
- AuthenticationGSS
+ The frontend must now initiate a GSSAPI negotiation. The frontend
+ will send a GSSResponse message with the first part of the GSSAPI
+ data stream in response to this. If further messages are needed,
+ the server will respond with AuthenticationGSSContinue.
+
- AuthenticationSSPI
+ The frontend must now initiate an SSPI negotiation. The frontend
+ will send a GSSResponse with the first part of the SSPI
+ data stream in response to this. If further messages are needed,
+ the server will respond with AuthenticationGSSContinue.
+
- AuthenticationGSSContinue
+ This message contains the response data from the previous step
+ of GSSAPI or SSPI negotiation (AuthenticationGSS, AuthenticationSSPI
+ or a previous AuthenticationGSSContinue). If the GSSAPI
+ or SSPI data in this message
+ indicates more data is needed to complete the authentication,
+ the frontend must send that data as another GSSResponse message. If
+ GSSAPI or SSPI authentication is completed by this message, the server
+ will next send AuthenticationOk to indicate successful authentication
+ or ErrorResponse to indicate failure.
+
- AuthenticationSASL
+ The frontend must now initiate a SASL negotiation, using one of the
+ SASL mechanisms listed in the message. The frontend will send a
+ SASLInitialResponse with the name of the selected mechanism, and the
+ first part of the SASL data stream in response to this. If further
+ messages are needed, the server will respond with
+ AuthenticationSASLContinue. See Section 55.3
+ for details.
+
- AuthenticationSASLContinue
+ This message contains challenge data from the previous step of SASL
+ negotiation (AuthenticationSASL, or a previous
+ AuthenticationSASLContinue). The frontend must respond with a
+ SASLResponse message.
+
- AuthenticationSASLFinal
+ SASL authentication has completed with additional mechanism-specific
+ data for the client. The server will next send AuthenticationOk to
+ indicate successful authentication, or an ErrorResponse to indicate
+ failure. This message is sent only if the SASL mechanism specifies
+ additional data to be sent from server to client at completion.
+
- NegotiateProtocolVersion
+ The server does not support the minor protocol version requested
+ by the client, but does support an earlier version of the protocol;
+ this message indicates the highest supported minor version. This
+ message will also be sent if the client requested unsupported protocol
+ options (i.e., beginning with _pq_.) in the
+ startup packet. This message will be followed by an ErrorResponse or
+ a message indicating the success or failure of authentication.
+
+
+ If the frontend does not support the authentication method
+ requested by the server, then it should immediately close the
+ connection.
+
+ After having received AuthenticationOk, the frontend must wait
+ for further messages from the server. In this phase a backend process
+ is being started, and the frontend is just an interested bystander.
+ It is still possible for the startup attempt
+ to fail (ErrorResponse) or the server to decline support for the requested
+ minor protocol version (NegotiateProtocolVersion), but in the normal case
+ the backend will send some ParameterStatus messages, BackendKeyData, and
+ finally ReadyForQuery.
+
+ During this phase the backend will attempt to apply any additional
+ run-time parameter settings that were given in the startup message.
+ If successful, these values become session defaults. An error causes
+ ErrorResponse and exit.
+
+ The possible messages from the backend in this phase are:
+
+
- BackendKeyData
+ This message provides secret-key data that the frontend must
+ save if it wants to be able to issue cancel requests later.
+ The frontend should not respond to this message, but should
+ continue listening for a ReadyForQuery message.
+
- ParameterStatus
+ This message informs the frontend about the current (initial)
+ setting of backend parameters, such as client_encoding or DateStyle.
+ The frontend can ignore this message, or record the settings
+ for its future use; see Section 55.2.7 for
+ more details. The frontend should not respond to this
+ message, but should continue listening for a ReadyForQuery
+ message.
+
- ReadyForQuery
+ Start-up is completed. The frontend can now issue commands.
+
- ErrorResponse
+ Start-up failed. The connection is closed after sending this
+ message.
+
- NoticeResponse
+ A warning message has been issued. The frontend should
+ display the message but continue listening for ReadyForQuery
+ or ErrorResponse.
+
+
+ The ReadyForQuery message is the same one that the backend will
+ issue after each command cycle. Depending on the coding needs of
+ the frontend, it is reasonable to consider ReadyForQuery as
+ starting a command cycle, or to consider ReadyForQuery as ending the
+ start-up phase and each subsequent command cycle.
+
+ A simple query cycle is initiated by the frontend sending a Query message
+ to the backend. The message includes an SQL command (or commands)
+ expressed as a text string.
+ The backend then sends one or more response
+ messages depending on the contents of the query command string,
+ and finally a ReadyForQuery response message. ReadyForQuery
+ informs the frontend that it can safely send a new command.
+ (It is not actually necessary for the frontend to wait for
+ ReadyForQuery before issuing another command, but the frontend must
+ then take responsibility for figuring out what happens if the earlier
+ command fails and already-issued later commands succeed.)
+
+ The possible response messages from the backend are:
+
+
- CommandComplete
+ An SQL command completed normally.
+
- CopyInResponse
+ The backend is ready to copy data from the frontend to a
+ table; see Section 55.2.6.
+
- CopyOutResponse
+ The backend is ready to copy data from a table to the
+ frontend; see Section 55.2.6.
+
- RowDescription
+ Indicates that rows are about to be returned in response to
+ a SELECT, FETCH, etc. query.
+ The contents of this message describe the column layout of the rows.
+ This will be followed by a DataRow message for each row being returned
+ to the frontend.
+
- DataRow
+ One of the set of rows returned by
+ a SELECT, FETCH, etc. query.
+
- EmptyQueryResponse
+ An empty query string was recognized.
+
- ErrorResponse
+ An error has occurred.
+
- ReadyForQuery
+ Processing of the query string is complete. A separate
+ message is sent to indicate this because the query string might
+ contain multiple SQL commands. (CommandComplete marks the
+ end of processing one SQL command, not the whole string.)
+ ReadyForQuery will always be sent, whether processing
+ terminates successfully or with an error.
+
- NoticeResponse
+ A warning message has been issued in relation to the query.
+ Notices are in addition to other responses, i.e., the backend
+ will continue processing the command.
+
+
+ The response to a SELECT query (or other queries that
+ return row sets, such as EXPLAIN or SHOW)
+ normally consists of RowDescription, zero or more
+ DataRow messages, and then CommandComplete.
+ COPY to or from the frontend invokes special protocol
+ as described in Section 55.2.6.
+ All other query types normally produce only
+ a CommandComplete message.
+
+ Since a query string could contain several queries (separated by
+ semicolons), there might be several such response sequences before the
+ backend finishes processing the query string. ReadyForQuery is issued
+ when the entire string has been processed and the backend is ready to
+ accept a new query string.
+
+ If a completely empty (no contents other than whitespace) query string
+ is received, the response is EmptyQueryResponse followed by ReadyForQuery.
+
+ In the event of an error, ErrorResponse is issued followed by
+ ReadyForQuery. All further processing of the query string is aborted by
+ ErrorResponse (even if more queries remained in it). Note that this
+ might occur partway through the sequence of messages generated by an
+ individual query.
+
+ In simple Query mode, the format of retrieved values is always text,
+ except when the given command is a FETCH from a cursor
+ declared with the BINARY option. In that case, the
+ retrieved values are in binary format. The format codes given in
+ the RowDescription message tell which format is being used.
+
+ A frontend must be prepared to accept ErrorResponse and
+ NoticeResponse messages whenever it is expecting any other type of
+ message. See also Section 55.2.7 concerning messages
+ that the backend might generate due to outside events.
+
+ Recommended practice is to code frontends in a state-machine style
+ that will accept any message type at any time that it could make sense,
+ rather than wiring in assumptions about the exact sequence of messages.
+
55.2.2.1. Multiple Statements in a Simple Query #
+ When a simple Query message contains more than one SQL statement
+ (separated by semicolons), those statements are executed as a single
+ transaction, unless explicit transaction control commands are included
+ to force a different behavior. For example, if the message contains
+
+INSERT INTO mytable VALUES(1);
+SELECT 1/0;
+INSERT INTO mytable VALUES(2);
+
+ then the divide-by-zero failure in the SELECT will force
+ rollback of the first INSERT. Furthermore, because
+ execution of the message is abandoned at the first error, the second
+ INSERT is never attempted at all.
+
+ If instead the message contains
+
+BEGIN;
+INSERT INTO mytable VALUES(1);
+COMMIT;
+INSERT INTO mytable VALUES(2);
+SELECT 1/0;
+
+ then the first INSERT is committed by the
+ explicit COMMIT command. The second INSERT
+ and the SELECT are still treated as a single transaction,
+ so that the divide-by-zero failure will roll back the
+ second INSERT, but not the first one.
+
+ This behavior is implemented by running the statements in a
+ multi-statement Query message in an implicit transaction
+ block unless there is some explicit transaction block for them to
+ run in. The main difference between an implicit transaction block and
+ a regular one is that an implicit block is closed automatically at the
+ end of the Query message, either by an implicit commit if there was no
+ error, or an implicit rollback if there was an error. This is similar
+ to the implicit commit or rollback that happens for a statement
+ executed by itself (when not in a transaction block).
+
+ If the session is already in a transaction block, as a result of
+ a BEGIN in some previous message, then the Query message
+ simply continues that transaction block, whether the message contains
+ one statement or several. However, if the Query message contains
+ a COMMIT or ROLLBACK closing the existing
+ transaction block, then any following statements are executed in an
+ implicit transaction block.
+ Conversely, if a BEGIN appears in a multi-statement Query
+ message, then it starts a regular transaction block that will only be
+ terminated by an explicit COMMIT or ROLLBACK,
+ whether that appears in this Query message or a later one.
+ If the BEGIN follows some statements that were executed as
+ an implicit transaction block, those statements are not immediately
+ committed; in effect, they are retroactively included into the new
+ regular transaction block.
+
+ A COMMIT or ROLLBACK appearing in an implicit
+ transaction block is executed as normal, closing the implicit block;
+ however, a warning will be issued since a COMMIT
+ or ROLLBACK without a previous BEGIN might
+ represent a mistake. If more statements follow, a new implicit
+ transaction block will be started for them.
+
+ Savepoints are not allowed in an implicit transaction block, since
+ they would conflict with the behavior of automatically closing the
+ block upon any error.
+
+ Remember that, regardless of any transaction control commands that may
+ be present, execution of the Query message stops at the first error.
+ Thus for example given
+
+BEGIN;
+SELECT 1/0;
+ROLLBACK;
+
+ in a single Query message, the session will be left inside a failed
+ regular transaction block, since the ROLLBACK is not
+ reached after the divide-by-zero error. Another ROLLBACK
+ will be needed to restore the session to a usable state.
+
+ Another behavior of note is that initial lexical and syntactic
+ analysis is done on the entire query string before any of it is
+ executed. Thus simple errors (such as a misspelled keyword) in later
+ statements can prevent execution of any of the statements. This
+ is normally invisible to users since the statements would all roll
+ back anyway when done as an implicit transaction block. However,
+ it can be visible when attempting to do multiple transactions within a
+ multi-statement Query. For instance, if a typo turned our previous
+ example into
+
+BEGIN;
+INSERT INTO mytable VALUES(1);
+COMMIT;
+INSERT INTO mytable VALUES(2);
+SELCT 1/0;
+
+ then none of the statements would get run, resulting in the visible
+ difference that the first INSERT is not committed.
+ Errors detected at semantic analysis or later, such as a misspelled
+ table or column name, do not have this effect.
+
+ The extended query protocol breaks down the above-described simple
+ query protocol into multiple steps. The results of preparatory
+ steps can be re-used multiple times for improved efficiency.
+ Furthermore, additional features are available, such as the possibility
+ of supplying data values as separate parameters instead of having to
+ insert them directly into a query string.
+
+ In the extended protocol, the frontend first sends a Parse message,
+ which contains a textual query string, optionally some information
+ about data types of parameter placeholders, and the
+ name of a destination prepared-statement object (an empty string
+ selects the unnamed prepared statement). The response is
+ either ParseComplete or ErrorResponse. Parameter data types can be
+ specified by OID; if not given, the parser attempts to infer the
+ data types in the same way as it would do for untyped literal string
+ constants.
+
Note
+ A parameter data type can be left unspecified by setting it to zero,
+ or by making the array of parameter type OIDs shorter than the
+ number of parameter symbols ($n)
+ used in the query string. Another special case is that a parameter's
+ type can be specified as void (that is, the OID of the
+ void pseudo-type). This is meant to allow parameter symbols
+ to be used for function parameters that are actually OUT parameters.
+ Ordinarily there is no context in which a void parameter
+ could be used, but if such a parameter symbol appears in a function's
+ parameter list, it is effectively ignored. For example, a function
+ call such as foo($1,$2,$3,$4) could match a function with
+ two IN and two OUT arguments, if $3 and $4
+ are specified as having type void.
+
Note
+ The query string contained in a Parse message cannot include more
+ than one SQL statement; else a syntax error is reported. This
+ restriction does not exist in the simple-query protocol, but it
+ does exist in the extended protocol, because allowing prepared
+ statements or portals to contain multiple commands would complicate
+ the protocol unduly.
+
+ If successfully created, a named prepared-statement object lasts till
+ the end of the current session, unless explicitly destroyed. An unnamed
+ prepared statement lasts only until the next Parse statement specifying
+ the unnamed statement as destination is issued. (Note that a simple
+ Query message also destroys the unnamed statement.) Named prepared
+ statements must be explicitly closed before they can be redefined by
+ another Parse message, but this is not required for the unnamed statement.
+ Named prepared statements can also be created and accessed at the SQL
+ command level, using PREPARE and EXECUTE.
+
+ Once a prepared statement exists, it can be readied for execution using a
+ Bind message. The Bind message gives the name of the source prepared
+ statement (empty string denotes the unnamed prepared statement), the name
+ of the destination portal (empty string denotes the unnamed portal), and
+ the values to use for any parameter placeholders present in the prepared
+ statement. The
+ supplied parameter set must match those needed by the prepared statement.
+ (If you declared any void parameters in the Parse message,
+ pass NULL values for them in the Bind message.)
+ Bind also specifies the format to use for any data returned
+ by the query; the format can be specified overall, or per-column.
+ The response is either BindComplete or ErrorResponse.
+
Note
+ The choice between text and binary output is determined by the format
+ codes given in Bind, regardless of the SQL command involved. The
+ BINARY attribute in cursor declarations is irrelevant when
+ using extended query protocol.
+
+ Query planning typically occurs when the Bind message is processed.
+ If the prepared statement has no parameters, or is executed repeatedly,
+ the server might save the created plan and re-use it during subsequent
+ Bind messages for the same prepared statement. However, it will do so
+ only if it finds that a generic plan can be created that is not much
+ less efficient than a plan that depends on the specific parameter values
+ supplied. This happens transparently so far as the protocol is concerned.
+
+ If successfully created, a named portal object lasts till the end of the
+ current transaction, unless explicitly destroyed. An unnamed portal is
+ destroyed at the end of the transaction, or as soon as the next Bind
+ statement specifying the unnamed portal as destination is issued. (Note
+ that a simple Query message also destroys the unnamed portal.) Named
+ portals must be explicitly closed before they can be redefined by another
+ Bind message, but this is not required for the unnamed portal.
+ Named portals can also be created and accessed at the SQL
+ command level, using DECLARE CURSOR and FETCH.
+
+ Once a portal exists, it can be executed using an Execute message.
+ The Execute message specifies the portal name (empty string denotes the
+ unnamed portal) and
+ a maximum result-row count (zero meaning “fetch all rows”).
+ The result-row count is only meaningful for portals
+ containing commands that return row sets; in other cases the command is
+ always executed to completion, and the row count is ignored.
+ The possible
+ responses to Execute are the same as those described above for queries
+ issued via simple query protocol, except that Execute doesn't cause
+ ReadyForQuery or RowDescription to be issued.
+
+ If Execute terminates before completing the execution of a portal
+ (due to reaching a nonzero result-row count), it will send a
+ PortalSuspended message; the appearance of this message tells the frontend
+ that another Execute should be issued against the same portal to
+ complete the operation. The CommandComplete message indicating
+ completion of the source SQL command is not sent until
+ the portal's execution is completed. Therefore, an Execute phase is
+ always terminated by the appearance of exactly one of these messages:
+ CommandComplete, EmptyQueryResponse (if the portal was created from
+ an empty query string), ErrorResponse, or PortalSuspended.
+
+ At completion of each series of extended-query messages, the frontend
+ should issue a Sync message. This parameterless message causes the
+ backend to close the current transaction if it's not inside a
+ BEGIN/COMMIT transaction block (“close”
+ meaning to commit if no error, or roll back if error). Then a
+ ReadyForQuery response is issued. The purpose of Sync is to provide
+ a resynchronization point for error recovery. When an error is detected
+ while processing any extended-query message, the backend issues
+ ErrorResponse, then reads and discards messages until a Sync is reached,
+ then issues ReadyForQuery and returns to normal message processing.
+ (But note that no skipping occurs if an error is detected
+ while processing Sync — this ensures that there is one
+ and only one ReadyForQuery sent for each Sync.)
+
Note
+ Sync does not cause a transaction block opened with BEGIN
+ to be closed. It is possible to detect this situation since the
+ ReadyForQuery message includes transaction status information.
+
+ In addition to these fundamental, required operations, there are several
+ optional operations that can be used with extended-query protocol.
+
+ The Describe message (portal variant) specifies the name of an existing
+ portal (or an empty string for the unnamed portal). The response is a
+ RowDescription message describing the rows that will be returned by
+ executing the portal; or a NoData message if the portal does not contain a
+ query that will return rows; or ErrorResponse if there is no such portal.
+
+ The Describe message (statement variant) specifies the name of an existing
+ prepared statement (or an empty string for the unnamed prepared
+ statement). The response is a ParameterDescription message describing the
+ parameters needed by the statement, followed by a RowDescription message
+ describing the rows that will be returned when the statement is eventually
+ executed (or a NoData message if the statement will not return rows).
+ ErrorResponse is issued if there is no such prepared statement. Note that
+ since Bind has not yet been issued, the formats to be used for returned
+ columns are not yet known to the backend; the format code fields in the
+ RowDescription message will be zeroes in this case.
+
Tip
+ In most scenarios the frontend should issue one or the other variant
+ of Describe before issuing Execute, to ensure that it knows how to
+ interpret the results it will get back.
+
+ The Close message closes an existing prepared statement or portal
+ and releases resources. It is not an error to issue Close against
+ a nonexistent statement or portal name. The response is normally
+ CloseComplete, but could be ErrorResponse if some difficulty is
+ encountered while releasing resources. Note that closing a prepared
+ statement implicitly closes any open portals that were constructed
+ from that statement.
+
+ The Flush message does not cause any specific output to be generated,
+ but forces the backend to deliver any data pending in its output
+ buffers. A Flush must be sent after any extended-query command except
+ Sync, if the frontend wishes to examine the results of that command before
+ issuing more commands. Without Flush, messages returned by the backend
+ will be combined into the minimum possible number of packets to minimize
+ network overhead.
+
Note
+ The simple Query message is approximately equivalent to the series Parse,
+ Bind, portal Describe, Execute, Close, Sync, using the unnamed prepared
+ statement and portal objects and no parameters. One difference is that
+ it will accept multiple SQL statements in the query string, automatically
+ performing the bind/describe/execute sequence for each one in succession.
+ Another difference is that it will not return ParseComplete, BindComplete,
+ CloseComplete, or NoData messages.
+
+ Use of the extended query protocol
+ allows pipelining, which means sending a series
+ of queries without waiting for earlier ones to complete. This reduces
+ the number of network round trips needed to complete a given series of
+ operations. However, the user must carefully consider the required
+ behavior if one of the steps fails, since later queries will already
+ be in flight to the server.
+
+ One way to deal with that is to make the whole query series be a
+ single transaction, that is wrap it in BEGIN ...
+ COMMIT. However, this does not help if one wishes
+ for some of the commands to commit independently of others.
+
+ The extended query protocol provides another way to manage this
+ concern, which is to omit sending Sync messages between steps that
+ are dependent. Since, after an error, the backend will skip command
+ messages until it finds Sync, this allows later commands in a pipeline
+ to be skipped automatically when an earlier one fails, without the
+ client having to manage that explicitly with BEGIN
+ and COMMIT. Independently-committable segments
+ of the pipeline can be separated by Sync messages.
+
+ If the client has not issued an explicit BEGIN,
+ then each Sync ordinarily causes an implicit COMMIT
+ if the preceding step(s) succeeded, or an
+ implicit ROLLBACK if they failed. However, there
+ are a few DDL commands (such as CREATE DATABASE)
+ that cannot be executed inside a transaction block. If one of
+ these is executed in a pipeline, it will fail unless it is the first
+ command in the pipeline. Furthermore, upon success it will force an
+ immediate commit to preserve database consistency. Thus a Sync
+ immediately following one of these commands has no effect except to
+ respond with ReadyForQuery.
+
+ When using this method, completion of the pipeline must be determined
+ by counting ReadyForQuery messages and waiting for that to reach the
+ number of Syncs sent. Counting command completion responses is
+ unreliable, since some of the commands may be skipped and thus not
+ produce a completion message.
+
+ The Function Call sub-protocol allows the client to request a direct
+ call of any function that exists in the database's
+ pg_proc system catalog. The client must have
+ execute permission for the function.
+
Note
+ The Function Call sub-protocol is a legacy feature that is probably best
+ avoided in new code. Similar results can be accomplished by setting up
+ a prepared statement that does SELECT function($1, ...).
+ The Function Call cycle can then be replaced with Bind/Execute.
+
+ A Function Call cycle is initiated by the frontend sending a
+ FunctionCall message to the backend. The backend then sends one
+ or more response messages depending on the results of the function
+ call, and finally a ReadyForQuery response message. ReadyForQuery
+ informs the frontend that it can safely send a new query or
+ function call.
+
+ The possible response messages from the backend are:
+
+
- ErrorResponse
+ An error has occurred.
+
- FunctionCallResponse
+ The function call was completed and returned the result given
+ in the message.
+ (Note that the Function Call protocol can only handle a single
+ scalar result, not a row type or set of results.)
+
- ReadyForQuery
+ Processing of the function call is complete. ReadyForQuery
+ will always be sent, whether processing terminates
+ successfully or with an error.
+
- NoticeResponse
+ A warning message has been issued in relation to the function
+ call. Notices are in addition to other responses, i.e., the
+ backend will continue processing the command.
+
+
55.2.6. COPY Operations #
+ The COPY command allows high-speed bulk data transfer
+ to or from the server. Copy-in and copy-out operations each switch
+ the connection into a distinct sub-protocol, which lasts until the
+ operation is completed.
+
+ Copy-in mode (data transfer to the server) is initiated when the
+ backend executes a COPY FROM STDIN SQL statement. The backend
+ sends a CopyInResponse message to the frontend. The frontend should
+ then send zero or more CopyData messages, forming a stream of input
+ data. (The message boundaries are not required to have anything to do
+ with row boundaries, although that is often a reasonable choice.)
+ The frontend can terminate the copy-in mode by sending either a CopyDone
+ message (allowing successful termination) or a CopyFail message (which
+ will cause the COPY SQL statement to fail with an
+ error). The backend then reverts to the command-processing mode it was
+ in before the COPY started, which will be either simple or
+ extended query protocol. It will next send either CommandComplete
+ (if successful) or ErrorResponse (if not).
+
+ In the event of a backend-detected error during copy-in mode (including
+ receipt of a CopyFail message), the backend will issue an ErrorResponse
+ message. If the COPY command was issued via an extended-query
+ message, the backend will now discard frontend messages until a Sync
+ message is received, then it will issue ReadyForQuery and return to normal
+ processing. If the COPY command was issued in a simple
+ Query message, the rest of that message is discarded and ReadyForQuery
+ is issued. In either case, any subsequent CopyData, CopyDone, or CopyFail
+ messages issued by the frontend will simply be dropped.
+
+ The backend will ignore Flush and Sync messages received during copy-in
+ mode. Receipt of any other non-copy message type constitutes an error
+ that will abort the copy-in state as described above. (The exception for
+ Flush and Sync is for the convenience of client libraries that always
+ send Flush or Sync after an Execute message, without checking whether
+ the command to be executed is a COPY FROM STDIN.)
+
+ Copy-out mode (data transfer from the server) is initiated when the
+ backend executes a COPY TO STDOUT SQL statement. The backend
+ sends a CopyOutResponse message to the frontend, followed by
+ zero or more CopyData messages (always one per row), followed by CopyDone.
+ The backend then reverts to the command-processing mode it was
+ in before the COPY started, and sends CommandComplete.
+ The frontend cannot abort the transfer (except by closing the connection
+ or issuing a Cancel request),
+ but it can discard unwanted CopyData and CopyDone messages.
+
+ In the event of a backend-detected error during copy-out mode,
+ the backend will issue an ErrorResponse message and revert to normal
+ processing. The frontend should treat receipt of ErrorResponse as
+ terminating the copy-out mode.
+
+ It is possible for NoticeResponse and ParameterStatus messages to be
+ interspersed between CopyData messages; frontends must handle these cases,
+ and should be prepared for other asynchronous message types as well (see
+ Section 55.2.7). Otherwise, any message type other than
+ CopyData or CopyDone may be treated as terminating copy-out mode.
+
+ There is another Copy-related mode called copy-both, which allows
+ high-speed bulk data transfer to and from the server.
+ Copy-both mode is initiated when a backend in walsender mode
+ executes a START_REPLICATION statement. The
+ backend sends a CopyBothResponse message to the frontend. Both
+ the backend and the frontend may then send CopyData messages
+ until either end sends a CopyDone message. After the client
+ sends a CopyDone message, the connection goes from copy-both mode to
+ copy-out mode, and the client may not send any more CopyData messages.
+ Similarly, when the server sends a CopyDone message, the connection
+ goes into copy-in mode, and the server may not send any more CopyData
+ messages. After both sides have sent a CopyDone message, the copy mode
+ is terminated, and the backend reverts to the command-processing mode.
+ In the event of a backend-detected error during copy-both mode,
+ the backend will issue an ErrorResponse message, discard frontend messages
+ until a Sync message is received, and then issue ReadyForQuery and return
+ to normal processing. The frontend should treat receipt of ErrorResponse
+ as terminating the copy in both directions; no CopyDone should be sent
+ in this case. See Section 55.4 for more
+ information on the subprotocol transmitted over copy-both mode.
+
+ The CopyInResponse, CopyOutResponse and CopyBothResponse messages
+ include fields that inform the frontend of the number of columns
+ per row and the format codes being used for each column. (As of
+ the present implementation, all columns in a given COPY
+ operation will use the same format, but the message design does not
+ assume this.)
+
55.2.7. Asynchronous Operations #
+ There are several cases in which the backend will send messages that
+ are not specifically prompted by the frontend's command stream.
+ Frontends must be prepared to deal with these messages at any time,
+ even when not engaged in a query.
+ At minimum, one should check for these cases before beginning to
+ read a query response.
+
+ It is possible for NoticeResponse messages to be generated due to
+ outside activity; for example, if the database administrator commands
+ a “fast” database shutdown, the backend will send a NoticeResponse
+ indicating this fact before closing the connection. Accordingly,
+ frontends should always be prepared to accept and display NoticeResponse
+ messages, even when the connection is nominally idle.
+
+ ParameterStatus messages will be generated whenever the active
+ value changes for any of the parameters the backend believes the
+ frontend should know about. Most commonly this occurs in response
+ to a SET SQL command executed by the frontend, and
+ this case is effectively synchronous — but it is also possible
+ for parameter status changes to occur because the administrator
+ changed a configuration file and then sent the
+ SIGHUP signal to the server. Also,
+ if a SET command is rolled back, an appropriate
+ ParameterStatus message will be generated to report the current
+ effective value.
+
+ At present there is a hard-wired set of parameters for which
+ ParameterStatus will be generated. They are:
+
application_name | is_superuser |
client_encoding | scram_iterations |
DateStyle | server_encoding |
default_transaction_read_only | server_version |
in_hot_standby | session_authorization |
integer_datetimes | standard_conforming_strings |
IntervalStyle | TimeZone |
+ (server_encoding, TimeZone, and
+ integer_datetimes were not reported by releases before 8.0;
+ standard_conforming_strings was not reported by releases
+ before 8.1;
+ IntervalStyle was not reported by releases before 8.4;
+ application_name was not reported by releases before
+ 9.0;
+ default_transaction_read_only and
+ in_hot_standby were not reported by releases before
+ 14; scram_iterations was not reported by releases
+ before 16.)
+ Note that
+ server_version,
+ server_encoding and
+ integer_datetimes
+ are pseudo-parameters that cannot change after startup.
+ This set might change in the future, or even become configurable.
+ Accordingly, a frontend should simply ignore ParameterStatus for
+ parameters that it does not understand or care about.
+
+ If a frontend issues a LISTEN command, then the
+ backend will send a NotificationResponse message (not to be
+ confused with NoticeResponse!) whenever a
+ NOTIFY command is executed for the same
+ channel name.
+
Note
+ At present, NotificationResponse can only be sent outside a
+ transaction, and thus it will not occur in the middle of a
+ command-response series, though it might occur just before ReadyForQuery.
+ It is unwise to design frontend logic that assumes that, however.
+ Good practice is to be able to accept NotificationResponse at any
+ point in the protocol.
+
55.2.8. Canceling Requests in Progress #
+ During the processing of a query, the frontend might request
+ cancellation of the query. The cancel request is not sent
+ directly on the open connection to the backend for reasons of
+ implementation efficiency: we don't want to have the backend
+ constantly checking for new input from the frontend during query
+ processing. Cancel requests should be relatively infrequent, so
+ we make them slightly cumbersome in order to avoid a penalty in
+ the normal case.
+
+ To issue a cancel request, the frontend opens a new connection to
+ the server and sends a CancelRequest message, rather than the
+ StartupMessage message that would ordinarily be sent across a new
+ connection. The server will process this request and then close
+ the connection. For security reasons, no direct reply is made to
+ the cancel request message.
+
+ A CancelRequest message will be ignored unless it contains the
+ same key data (PID and secret key) passed to the frontend during
+ connection start-up. If the request matches the PID and secret
+ key for a currently executing backend, the processing of the
+ current query is aborted. (In the existing implementation, this is
+ done by sending a special signal to the backend process that is
+ processing the query.)
+
+ The cancellation signal might or might not have any effect — for
+ example, if it arrives after the backend has finished processing
+ the query, then it will have no effect. If the cancellation is
+ effective, it results in the current command being terminated
+ early with an error message.
+
+ The upshot of all this is that for reasons of both security and
+ efficiency, the frontend has no direct way to tell whether a
+ cancel request has succeeded. It must continue to wait for the
+ backend to respond to the query. Issuing a cancel simply improves
+ the odds that the current query will finish soon, and improves the
+ odds that it will fail with an error message instead of
+ succeeding.
+
+ Since the cancel request is sent across a new connection to the
+ server and not across the regular frontend/backend communication
+ link, it is possible for the cancel request to be issued by any
+ process, not just the frontend whose query is to be canceled.
+ This might provide additional flexibility when building
+ multiple-process applications. It also introduces a security
+ risk, in that unauthorized persons might try to cancel queries.
+ The security risk is addressed by requiring a dynamically
+ generated secret key to be supplied in cancel requests.
+
+ The normal, graceful termination procedure is that the frontend
+ sends a Terminate message and immediately closes the connection.
+ On receipt of this message, the backend closes the connection and
+ terminates.
+
+ In rare cases (such as an administrator-commanded database shutdown)
+ the backend might disconnect without any frontend request to do so.
+ In such cases the backend will attempt to send an error or notice message
+ giving the reason for the disconnection before it closes the connection.
+
+ Other termination scenarios arise from various failure cases, such as core
+ dump at one end or the other, loss of the communications link, loss of
+ message-boundary synchronization, etc. If either frontend or backend sees
+ an unexpected closure of the connection, it should clean
+ up and terminate. The frontend has the option of launching a new backend
+ by recontacting the server if it doesn't want to terminate itself.
+ Closing the connection is also advisable if an unrecognizable message type
+ is received, since this probably indicates loss of message-boundary sync.
+
+ For either normal or abnormal termination, any open transaction is
+ rolled back, not committed. One should note however that if a
+ frontend disconnects while a non-SELECT query
+ is being processed, the backend will probably finish the query
+ before noticing the disconnection. If the query is outside any
+ transaction block (BEGIN ... COMMIT
+ sequence) then its results might be committed before the
+ disconnection is recognized.
+
55.2.10. SSL Session Encryption #
+ If PostgreSQL was built with
+ SSL support, frontend/backend communications
+ can be encrypted using SSL. This provides
+ communication security in environments where attackers might be
+ able to capture the session traffic. For more information on
+ encrypting PostgreSQL sessions with
+ SSL, see Section 19.9.
+
+ To initiate an SSL-encrypted connection, the
+ frontend initially sends an SSLRequest message rather than a
+ StartupMessage. The server then responds with a single byte
+ containing S or N, indicating that it is
+ willing or unwilling to perform SSL,
+ respectively. The frontend might close the connection at this point
+ if it is dissatisfied with the response. To continue after
+ S, perform an SSL startup handshake
+ (not described here, part of the SSL
+ specification) with the server. If this is successful, continue
+ with sending the usual StartupMessage. In this case the
+ StartupMessage and all subsequent data will be
+ SSL-encrypted. To continue after
+ N, send the usual StartupMessage and proceed without
+ encryption.
+ (Alternatively, it is permissible to issue a GSSENCRequest message
+ after an N response to try to
+ use GSSAPI encryption instead
+ of SSL.)
+
+ The frontend should also be prepared to handle an ErrorMessage
+ response to SSLRequest from the server. This would only occur if
+ the server predates the addition of SSL support
+ to PostgreSQL. (Such servers are now very ancient,
+ and likely do not exist in the wild anymore.)
+ In this case the connection must
+ be closed, but the frontend might choose to open a fresh connection
+ and proceed without requesting SSL.
+
+ When SSL encryption can be performed, the server
+ is expected to send only the single S byte and then
+ wait for the frontend to initiate an SSL handshake.
+ If additional bytes are available to read at this point, it likely
+ means that a man-in-the-middle is attempting to perform a
+ buffer-stuffing attack
+ (CVE-2021-23222).
+ Frontends should be coded either to read exactly one byte from the
+ socket before turning the socket over to their SSL library, or to
+ treat it as a protocol violation if they find they have read additional
+ bytes.
+
+ An initial SSLRequest can also be used in a connection that is being
+ opened to send a CancelRequest message.
+
+ While the protocol itself does not provide a way for the server to
+ force SSL encryption, the administrator can
+ configure the server to reject unencrypted sessions as a byproduct
+ of authentication checking.
+
55.2.11. GSSAPI Session Encryption #
+ If PostgreSQL was built with
+ GSSAPI support, frontend/backend communications
+ can be encrypted using GSSAPI. This provides
+ communication security in environments where attackers might be
+ able to capture the session traffic. For more information on
+ encrypting PostgreSQL sessions with
+ GSSAPI, see Section 19.10.
+
+ To initiate a GSSAPI-encrypted connection, the
+ frontend initially sends a GSSENCRequest message rather than a
+ StartupMessage. The server then responds with a single byte
+ containing G or N, indicating that it
+ is willing or unwilling to perform GSSAPI encryption,
+ respectively. The frontend might close the connection at this point
+ if it is dissatisfied with the response. To continue after
+ G, using the GSSAPI C bindings as discussed in
+ RFC 2744
+ or equivalent, perform a GSSAPI initialization by
+ calling gss_init_sec_context() in a loop and sending
+ the result to the server, starting with an empty input and then with each
+ result from the server, until it returns no output. When sending the
+ results of gss_init_sec_context() to the server,
+ prepend the length of the message as a four byte integer in network byte
+ order.
+ To continue after
+ N, send the usual StartupMessage and proceed without
+ encryption.
+ (Alternatively, it is permissible to issue an SSLRequest message
+ after an N response to try to
+ use SSL encryption instead
+ of GSSAPI.)
+
+ The frontend should also be prepared to handle an ErrorMessage
+ response to GSSENCRequest from the server. This would only occur if
+ the server predates the addition of GSSAPI encryption
+ support to PostgreSQL. In this case the
+ connection must be closed, but the frontend might choose to open a fresh
+ connection and proceed without requesting GSSAPI
+ encryption.
+
+ When GSSAPI encryption can be performed, the server
+ is expected to send only the single G byte and then
+ wait for the frontend to initiate a GSSAPI handshake.
+ If additional bytes are available to read at this point, it likely
+ means that a man-in-the-middle is attempting to perform a
+ buffer-stuffing attack
+ (CVE-2021-23222).
+ Frontends should be coded either to read exactly one byte from the
+ socket before turning the socket over to their GSSAPI library, or to
+ treat it as a protocol violation if they find they have read additional
+ bytes.
+
+ An initial GSSENCRequest can also be used in a connection that is being
+ opened to send a CancelRequest message.
+
+ Once GSSAPI encryption has been successfully
+ established, use gss_wrap() to
+ encrypt the usual StartupMessage and all subsequent data, prepending the
+ length of the result from gss_wrap() as a four byte
+ integer in network byte order to the actual encrypted payload. Note that
+ the server will only accept encrypted packets from the client which are less
+ than 16kB; gss_wrap_size_limit() should be used by the
+ client to determine the size of the unencrypted message which will fit
+ within this limit and larger messages should be broken up into multiple
+ gss_wrap() calls. Typical segments are 8kB of
+ unencrypted data, resulting in encrypted packets of slightly larger than 8kB
+ but well within the 16kB maximum. The server can be expected to not send
+ encrypted packets of larger than 16kB to the client.
+
+ While the protocol itself does not provide a way for the server to
+ force GSSAPI encryption, the administrator can
+ configure the server to reject unencrypted sessions as a byproduct
+ of authentication checking.
+
55.5. Logical Streaming Replication Protocol #
+ This section describes the logical replication protocol, which is the message
+ flow started by the START_REPLICATION
+ SLOT slot_name
+ LOGICAL replication command.
+
+ The logical streaming replication protocol builds on the primitives of
+ the physical streaming replication protocol.
+
+ PostgreSQL logical decoding supports output
+ plugins. pgoutput is the standard one used for
+ the built-in logical replication.
+
55.5.1. Logical Streaming Replication Parameters #
+ Using the START_REPLICATION command,
+ pgoutput accepts the following options:
+
+
-
+ proto_version
+
+ Protocol version. Currently versions 1, 2,
+ 3, and 4 are supported. A valid
+ version is required.
+
+ Version 2 is supported only for server version 14
+ and above, and it allows streaming of large in-progress transactions.
+
+ Version 3 is supported only for server version 15
+ and above, and it allows streaming of two-phase commits.
+
+ Version 4 is supported only for server version 16
+ and above, and it allows streams of large in-progress transactions to
+ be applied in parallel.
+
-
+ publication_names
+
+ Comma separated list of publication names for which to subscribe
+ (receive changes). The individual publication names are treated
+ as standard objects names and can be quoted the same as needed.
+ At least one publication name is required.
+
-
+ binary
+
+ Boolean option to use binary transfer mode. Binary mode is faster
+ than the text mode but slightly less robust.
+
-
+ messages
+
+ Boolean option to enable sending the messages that are written
+ by pg_logical_emit_message.
+
-
+ streaming
+
+ Boolean option to enable streaming of in-progress transactions.
+ It accepts an additional value "parallel" to enable sending extra
+ information with some messages to be used for parallelisation.
+ Minimum protocol version 2 is required to turn it on. Minimum protocol
+ version 4 is required for the "parallel" option.
+
-
+ two_phase
+
+ Boolean option to enable two-phase transactions. Minimum protocol
+ version 3 is required to turn it on.
+
-
+ origin
+
+ Option to send changes by their origin. Possible values are "none"
+ to only send the changes that have no origin associated, or "any"
+ to send the changes regardless of their origin. This can be used
+ to avoid loops (infinite replication of the same data) among
+ replication nodes.
+
+
+
55.5.2. Logical Replication Protocol Messages #
+ The individual protocol messages are discussed in the following
+ subsections. Individual messages are described in
+ Section 55.9.
+
+ All top-level protocol messages begin with a message type byte.
+ While represented in code as a character, this is a signed byte with no
+ associated encoding.
+
+ Since the streaming replication protocol supplies a message length there
+ is no need for top-level protocol messages to embed a length in their
+ header.
+
55.5.3. Logical Replication Protocol Message Flow #
+ With the exception of the START_REPLICATION command and
+ the replay progress messages, all information flows only from the backend
+ to the frontend.
+
+ The logical replication protocol sends individual transactions one by one.
+ This means that all messages between a pair of Begin and Commit messages
+ belong to the same transaction. Similarly, all messages between a pair of
+ Begin Prepare and Prepare messages belong to the same transaction.
+ It also sends changes of large in-progress transactions between a pair of
+ Stream Start and Stream Stop messages. The last stream of such a transaction
+ contains a Stream Commit or Stream Abort message.
+
+ Every sent transaction contains zero or more DML messages (Insert,
+ Update, Delete). In case of a cascaded setup it can also contain Origin
+ messages. The origin message indicates that the transaction originated on
+ different replication node. Since a replication node in the scope of logical
+ replication protocol can be pretty much anything, the only identifier
+ is the origin name. It's downstream's responsibility to handle this as
+ needed (if needed). The Origin message is always sent before any DML
+ messages in the transaction.
+
+ Every DML message contains a relation OID, identifying the publisher's
+ relation that was acted on. Before the first DML message for a given
+ relation OID, a Relation message will be sent, describing the schema of
+ that relation. Subsequently, a new Relation message will be sent if
+ the relation's definition has changed since the last Relation message
+ was sent for it. (The protocol assumes that the client is capable of
+ remembering this metadata for as many relations as needed.)
+
+ Relation messages identify column types by their OIDs. In the case
+ of a built-in type, it is assumed that the client can look up that
+ type OID locally, so no additional data is needed. For a non-built-in
+ type OID, a Type message will be sent before the Relation message,
+ to provide the type name associated with that OID. Thus, a client that
+ needs to specifically identify the types of relation columns should
+ cache the contents of Type messages, and first consult that cache to
+ see if the type OID is defined there. If not, look up the type OID
+ locally.
+
55.6. Message Data Types #
+ This section describes the base data types used in messages.
+
- Int
n(i)
+ An n-bit integer in network byte
+ order (most significant byte first).
+ If i is specified it
+ is the exact value that will appear, otherwise the value
+ is variable. Eg. Int16, Int32(42).
+
- Int
n[k]
+ An array of k
+ n-bit integers, each in network
+ byte order. The array length k
+ is always determined by an earlier field in the message.
+ Eg. Int16[M].
+
- String(
s)
+ A null-terminated string (C-style string). There is no
+ specific length limitation on strings.
+ If s is specified it is the exact
+ value that will appear, otherwise the value is variable.
+ Eg. String, String("user").
+
Note
+ There is no predefined limit on the length of a string
+ that can be returned by the backend. Good coding strategy for a frontend
+ is to use an expandable buffer so that anything that fits in memory can be
+ accepted. If that's not feasible, read the full string and discard trailing
+ characters that don't fit into your fixed-size buffer.
+
- Byte
n(c)
+ Exactly n bytes. If the field
+ width n is not a constant, it is
+ always determinable from an earlier field in the message.
+ If c is specified it is the exact
+ value. Eg. Byte2, Byte1('\n').
+
+ The protocol has separate phases for startup and normal operation.
+ In the startup phase, the frontend opens a connection to the server
+ and authenticates itself to the satisfaction of the server. (This might
+ involve a single message, or multiple messages depending on the
+ authentication method being used.) If all goes well, the server then sends
+ status information to the frontend, and finally enters normal operation.
+ Except for the initial startup-request message, this part of the
+ protocol is driven by the server.
+
+ During normal operation, the frontend sends queries and
+ other commands to the backend, and the backend sends back query results
+ and other responses. There are a few cases (such as NOTIFY)
+ wherein the
+ backend will send unsolicited messages, but for the most part this portion
+ of a session is driven by frontend requests.
+
+ Termination of the session is normally by frontend choice, but can be
+ forced by the backend in certain cases. In any case, when the backend
+ closes the connection, it will roll back any open (incomplete) transaction
+ before exiting.
+
+ Within normal operation, SQL commands can be executed through either of
+ two sub-protocols. In the “simple query” protocol, the frontend
+ just sends a textual query string, which is parsed and immediately
+ executed by the backend. In the “extended query” protocol,
+ processing of queries is separated into multiple steps: parsing,
+ binding of parameter values, and execution. This offers flexibility
+ and performance benefits, at the cost of extra complexity.
+
+ Normal operation has additional sub-protocols for special operations
+ such as COPY.
+
55.1.1. Messaging Overview #
+ All communication is through a stream of messages. The first byte of a
+ message identifies the message type, and the next four bytes specify the
+ length of the rest of the message (this length count includes itself, but
+ not the message-type byte). The remaining contents of the message are
+ determined by the message type. For historical reasons, the very first
+ message sent by the client (the startup message) has no initial
+ message-type byte.
+
+ To avoid losing synchronization with the message stream, both servers and
+ clients typically read an entire message into a buffer (using the byte
+ count) before attempting to process its contents. This allows easy
+ recovery if an error is detected while processing the contents. In
+ extreme situations (such as not having enough memory to buffer the
+ message), the receiver can use the byte count to determine how much
+ input to skip before it resumes reading messages.
+
+ Conversely, both servers and clients must take care never to send an
+ incomplete message. This is commonly done by marshaling the entire message
+ in a buffer before beginning to send it. If a communications failure
+ occurs partway through sending or receiving a message, the only sensible
+ response is to abandon the connection, since there is little hope of
+ recovering message-boundary synchronization.
+
55.1.2. Extended Query Overview #
+ In the extended-query protocol, execution of SQL commands is divided
+ into multiple steps. The state retained between steps is represented
+ by two types of objects: prepared statements and
+ portals. A prepared statement represents the result of
+ parsing and semantic analysis of a textual query string.
+ A prepared statement is not in itself ready to execute, because it might
+ lack specific values for parameters. A portal represents
+ a ready-to-execute or already-partially-executed statement, with any
+ missing parameter values filled in. (For SELECT statements,
+ a portal is equivalent to an open cursor, but we choose to use a different
+ term since cursors don't handle non-SELECT statements.)
+
+ The overall execution cycle consists of a parse step,
+ which creates a prepared statement from a textual query string; a
+ bind step, which creates a portal given a prepared
+ statement and values for any needed parameters; and an
+ execute step that runs a portal's query. In the case of
+ a query that returns rows (SELECT, SHOW, etc.),
+ the execute step can be told to fetch only
+ a limited number of rows, so that multiple execute steps might be needed
+ to complete the operation.
+
+ The backend can keep track of multiple prepared statements and portals
+ (but note that these exist only within a session, and are never shared
+ across sessions). Existing prepared statements and portals are
+ referenced by names assigned when they were created. In addition,
+ an “unnamed” prepared statement and portal exist. Although these
+ behave largely the same as named objects, operations on them are optimized
+ for the case of executing a query only once and then discarding it,
+ whereas operations on named objects are optimized on the expectation
+ of multiple uses.
+
55.4. Streaming Replication Protocol #
+ To initiate streaming replication, the frontend sends the
+ replication parameter in the startup message. A Boolean
+ value of true (or on,
+ yes, 1) tells the backend to go into
+ physical replication walsender mode, wherein a small set of replication
+ commands, shown below, can be issued instead of SQL statements.
+
+ Passing database as the value for the
+ replication parameter instructs the backend to go into
+ logical replication walsender mode, connecting to the database specified in
+ the dbname parameter. In logical replication walsender
+ mode, the replication commands shown below as well as normal SQL commands can
+ be issued.
+
+ In either physical replication or logical replication walsender mode, only the
+ simple query protocol can be used.
+
+ For the purpose of testing replication commands, you can make a replication
+ connection via psql or any other
+ libpq-using tool with a connection string including
+ the replication option,
+ e.g.:
+
+psql "dbname=postgres replication=database" -c "IDENTIFY_SYSTEM;"
+
+ However, it is often more useful to use
+ pg_receivewal (for physical replication) or
+ pg_recvlogical (for logical replication).
+
+ Replication commands are logged in the server log when
+ log_replication_commands is enabled.
+
+ The commands accepted in replication mode are:
+
+
IDENTIFY_SYSTEM
+
+ #
+ Requests the server to identify itself. Server replies with a result
+ set of a single row, containing four fields:
+
systemid (text)
+ The unique system identifier identifying the cluster. This
+ can be used to check that the base backup used to initialize the
+ standby came from the same cluster.
+
timeline (int8)
+ Current timeline ID. Also useful to check that the standby is
+ consistent with the primary.
+
xlogpos (text)
+ Current WAL flush location. Useful to get a known location in the
+ write-ahead log where streaming can start.
+
dbname (text)
+ Database connected to or null.
+
SHOW name
+
+ #
+ Requests the server to send the current setting of a run-time parameter.
+ This is similar to the SQL command SHOW.
+
name
+ The name of a run-time parameter. Available parameters are documented
+ in Chapter 20.
+
TIMELINE_HISTORY tli
+
+ #
+ Requests the server to send over the timeline history file for timeline
+ tli. Server replies with a
+ result set of a single row, containing two fields. While the fields
+ are labeled as text, they effectively return raw bytes,
+ with no encoding conversion:
+
filename (text)
+ File name of the timeline history file, e.g., 00000002.history.
+
content (text)
+ Contents of the timeline history file.
+
CREATE_REPLICATION_SLOT slot_name [ TEMPORARY ] { PHYSICAL | LOGICAL output_plugin } [ ( option [, ...] ) ]
+
+ #
+ Create a physical or logical replication
+ slot. See Section 27.2.6 for more about
+ replication slots.
+
slot_name
+ The name of the slot to create. Must be a valid replication slot
+ name (see Section 27.2.6.1).
+
output_plugin
+ The name of the output plugin used for logical decoding
+ (see Section 49.6).
+
TEMPORARY
+ Specify that this replication slot is a temporary one. Temporary
+ slots are not saved to disk and are automatically dropped on error
+ or when the session has finished.
+
The following options are supported:
TWO_PHASE [ boolean ]
+ If true, this logical replication slot supports decoding of two-phase
+ commit. With this option, commands related to two-phase commit such as
+ PREPARE TRANSACTION, COMMIT PREPARED
+ and ROLLBACK PREPARED are decoded and transmitted.
+ The transaction will be decoded and transmitted at
+ PREPARE TRANSACTION time.
+ The default is false.
+
RESERVE_WAL [ boolean ]
+ If true, this physical replication slot reserves WAL
+ immediately. Otherwise, WAL is only reserved upon
+ connection from a streaming replication client.
+ The default is false.
+
SNAPSHOT { 'export' | 'use' | 'nothing' }
+ Decides what to do with the snapshot created during logical slot
+ initialization. 'export', which is the default,
+ will export the snapshot for use in other sessions. This option can't
+ be used inside a transaction. 'use' will use the
+ snapshot for the current transaction executing the command. This
+ option must be used in a transaction, and
+ CREATE_REPLICATION_SLOT must be the first command
+ run in that transaction. Finally, 'nothing' will
+ just use the snapshot for logical decoding as normal but won't do
+ anything else with it.
+
+ In response to this command, the server will send a one-row result set
+ containing the following fields:
+
+
slot_name (text)
+ The name of the newly-created replication slot.
+
consistent_point (text)
+ The WAL location at which the slot became consistent. This is the
+ earliest location from which streaming can start on this replication
+ slot.
+
snapshot_name (text)
+ The identifier of the snapshot exported by the command. The
+ snapshot is valid until a new command is executed on this connection
+ or the replication connection is closed. Null if the created slot
+ is physical.
+
output_plugin (text)
+ The name of the output plugin used by the newly-created replication
+ slot. Null if the created slot is physical.
+
+
CREATE_REPLICATION_SLOT slot_name [ TEMPORARY ] { PHYSICAL [ RESERVE_WAL ] | LOGICAL output_plugin [ EXPORT_SNAPSHOT | NOEXPORT_SNAPSHOT | USE_SNAPSHOT | TWO_PHASE ] }
+ #
+ For compatibility with older releases, this alternative syntax for
+ the CREATE_REPLICATION_SLOT command is still supported.
+
READ_REPLICATION_SLOT slot_name
+
+ #
+ Read some information associated with a replication slot. Returns a tuple
+ with NULL values if the replication slot does not
+ exist. This command is currently only supported for physical replication
+ slots.
+
+ In response to this command, the server will return a one-row result set,
+ containing the following fields:
+
slot_type (text)
+ The replication slot's type, either physical or
+ NULL.
+
restart_lsn (text)
+ The replication slot's restart_lsn.
+
restart_tli (int8)
+ The timeline ID associated with restart_lsn,
+ following the current timeline history.
+
+
START_REPLICATION [ SLOT slot_name ] [ PHYSICAL ] XXX/XXX [ TIMELINE tli ]
+
+ #
+ Instructs server to start streaming WAL, starting at
+ WAL location XXX/XXX.
+ If TIMELINE option is specified,
+ streaming starts on timeline tli;
+ otherwise, the server's current timeline is selected. The server can
+ reply with an error, for example if the requested section of WAL has already
+ been recycled. On success, the server responds with a CopyBothResponse
+ message, and then starts to stream WAL to the frontend.
+
+ If a slot's name is provided
+ via slot_name, it will be updated
+ as replication progresses so that the server knows which WAL segments,
+ and if hot_standby_feedback is on which transactions,
+ are still needed by the standby.
+
+ If the client requests a timeline that's not the latest but is part of
+ the history of the server, the server will stream all the WAL on that
+ timeline starting from the requested start point up to the point where
+ the server switched to another timeline. If the client requests
+ streaming at exactly the end of an old timeline, the server skips COPY
+ mode entirely.
+
+ After streaming all the WAL on a timeline that is not the latest one,
+ the server will end streaming by exiting the COPY mode. When the client
+ acknowledges this by also exiting COPY mode, the server sends a result
+ set with one row and two columns, indicating the next timeline in this
+ server's history. The first column is the next timeline's ID (type int8), and the
+ second column is the WAL location where the switch happened (type text). Usually,
+ the switch position is the end of the WAL that was streamed, but there
+ are corner cases where the server can send some WAL from the old
+ timeline that it has not itself replayed before promoting. Finally, the
+ server sends two CommandComplete messages (one that ends the CopyData
+ and the other ends the START_REPLICATION itself), and
+ is ready to accept a new command.
+
+ WAL data is sent as a series of CopyData messages. (This allows
+ other information to be intermixed; in particular the server can send
+ an ErrorResponse message if it encounters a failure after beginning
+ to stream.) The payload of each CopyData message from server to the
+ client contains a message of one of the following formats:
+
- XLogData (B) #
- Byte1('w')
+ Identifies the message as WAL data.
+
- Int64
+ The starting point of the WAL data in this message.
+
- Int64
+ The current end of WAL on the server.
+
- Int64
+ The server's system clock at the time of transmission, as
+ microseconds since midnight on 2000-01-01.
+
- Byte
n
+ A section of the WAL data stream.
+
+ A single WAL record is never split across two XLogData messages.
+ When a WAL record crosses a WAL page boundary, and is therefore
+ already split using continuation records, it can be split at the page
+ boundary. In other words, the first main WAL record and its
+ continuation records can be sent in different XLogData messages.
+
- Primary keepalive message (B) #
- Byte1('k')
+ Identifies the message as a sender keepalive.
+
- Int64
+ The current end of WAL on the server.
+
- Int64
+ The server's system clock at the time of transmission, as
+ microseconds since midnight on 2000-01-01.
+
- Byte1
+ 1 means that the client should reply to this message as soon as
+ possible, to avoid a timeout disconnect. 0 otherwise.
+
+ The receiving process can send replies back to the sender at any time,
+ using one of the following message formats (also in the payload of a
+ CopyData message):
+
- Standby status update (F) #
- Byte1('r')
+ Identifies the message as a receiver status update.
+
- Int64
+ The location of the last WAL byte + 1 received and written to disk
+ in the standby.
+
- Int64
+ The location of the last WAL byte + 1 flushed to disk in
+ the standby.
+
- Int64
+ The location of the last WAL byte + 1 applied in the standby.
+
- Int64
+ The client's system clock at the time of transmission, as
+ microseconds since midnight on 2000-01-01.
+
- Byte1
+ If 1, the client requests the server to reply to this message
+ immediately. This can be used to ping the server, to test if
+ the connection is still healthy.
+
- Hot standby feedback message (F) #
- Byte1('h')
+ Identifies the message as a hot standby feedback message.
+
- Int64
+ The client's system clock at the time of transmission, as
+ microseconds since midnight on 2000-01-01.
+
- Int32
+ The standby's current global xmin, excluding the catalog_xmin from any
+ replication slots. If both this value and the following
+ catalog_xmin are 0 this is treated as a notification that hot standby
+ feedback will no longer be sent on this connection. Later non-zero
+ messages may reinitiate the feedback mechanism.
+
- Int32
+ The epoch of the global xmin xid on the standby.
+
- Int32
+ The lowest catalog_xmin of any replication slots on the standby. Set to 0
+ if no catalog_xmin exists on the standby or if hot standby feedback is being
+ disabled.
+
- Int32
+ The epoch of the catalog_xmin xid on the standby.
+
START_REPLICATION SLOT slot_name LOGICAL XXX/XXX [ ( option_name [ option_value ] [, ...] ) ] #
+ Instructs server to start streaming WAL for logical replication,
+ starting at either WAL location XXX/XXX or the slot's
+ confirmed_flush_lsn (see Section 54.19), whichever is greater. This
+ behavior makes it easier for clients to avoid updating their local LSN
+ status when there is no data to process. However, starting at a
+ different LSN than requested might not catch certain kinds of client
+ errors; so the client may wish to check that
+ confirmed_flush_lsn matches its expectations before
+ issuing START_REPLICATION.
+
+ The server can reply with an error, for example if the
+ slot does not exist. On success, the server responds with a CopyBothResponse
+ message, and then starts to stream WAL to the frontend.
+
+ The messages inside the CopyBothResponse messages are of the same format
+ documented for START_REPLICATION ... PHYSICAL, including
+ two CommandComplete messages.
+
+ The output plugin associated with the selected slot is used
+ to process the output for streaming.
+
SLOT slot_name
+ The name of the slot to stream changes from. This parameter is required,
+ and must correspond to an existing logical replication slot created
+ with CREATE_REPLICATION_SLOT in
+ LOGICAL mode.
+
XXX/XXX
+ The WAL location to begin streaming at.
+
option_name
+ The name of an option passed to the slot's logical decoding output
+ plugin. See Section 55.5 for
+ options that are accepted by the standard (pgoutput)
+ plugin.
+
option_value
+ Optional value, in the form of a string constant, associated with the
+ specified option.
+
-
+
DROP_REPLICATION_SLOT slot_name [ WAIT ]
+
+ #
+ Drops a replication slot, freeing any reserved server-side resources.
+ If the slot is a logical slot that was created in a database other than
+ the database the walsender is connected to, this command fails.
+
slot_name
+ The name of the slot to drop.
+
WAIT
+ This option causes the command to wait if the slot is active until
+ it becomes inactive, instead of the default behavior of raising an
+ error.
+
BASE_BACKUP [ ( option [, ...] ) ]
+
+ #
+ Instructs the server to start streaming a base backup.
+ The system will automatically be put in backup mode before the backup
+ is started, and taken out of it when the backup is complete. The
+ following options are accepted:
+
+
LABEL 'label'
+ Sets the label of the backup. If none is specified, a backup label
+ of base backup will be used. The quoting rules
+ for the label are the same as a standard SQL string with
+ standard_conforming_strings turned on.
+
TARGET 'target'
+ Tells the server where to send the backup. If the target is
+ client, which is the default, the backup data is
+ sent to the client. If it is server, the backup
+ data is written to the server at the pathname specified by the
+ TARGET_DETAIL option. If it is
+ blackhole, the backup data is not sent
+ anywhere; it is simply discarded.
+
+ The server target requires superuser privilege or
+ being granted the pg_write_server_files role.
+
TARGET_DETAIL 'detail'
+ Provides additional information about the backup target.
+
+ Currently, this option can only be used when the backup target is
+ server. It specifies the server directory
+ to which the backup should be written.
+
PROGRESS [ boolean ]
+ If set to true, request information required to generate a progress
+ report. This will send back an approximate size in the header of each
+ tablespace, which can be used to calculate how far along the stream
+ is done. This is calculated by enumerating all the file sizes once
+ before the transfer is even started, and might as such have a
+ negative impact on the performance. In particular, it might take
+ longer before the first data
+ is streamed. Since the database files can change during the backup,
+ the size is only approximate and might both grow and shrink between
+ the time of approximation and the sending of the actual files.
+ The default is false.
+
CHECKPOINT { 'fast' | 'spread' }
+ Sets the type of checkpoint to be performed at the beginning of the
+ base backup. The default is spread.
+
WAL [ boolean ]
+ If set to true, include the necessary WAL segments in the backup.
+ This will include all the files between start and stop backup in the
+ pg_wal directory of the base directory tar
+ file. The default is false.
+
WAIT [ boolean ]
+ If set to true, the backup will wait until the last required WAL
+ segment has been archived, or emit a warning if WAL archiving is
+ not enabled. If false, the backup will neither wait nor warn,
+ leaving the client responsible for ensuring the required log is
+ available. The default is true.
+
COMPRESSION 'method'
+ Instructs the server to compress the backup using the specified
+ method. Currently, the supported methods are gzip,
+ lz4, and zstd.
+
COMPRESSION_DETAIL detail
+ Specifies details for the chosen compression method. This should only
+ be used in conjunction with the COMPRESSION
+ option. If the value is an integer, it specifies the compression
+ level. Otherwise, it should be a comma-separated list of items,
+ each of the form keyword or
+ keyword=value. Currently, the supported
+ keywords are level, long and
+ workers.
+
+ The level keyword sets the compression level.
+ For gzip the compression level should be an
+ integer between 1 and 9
+ (default Z_DEFAULT_COMPRESSION or
+ -1), for lz4 an integer
+ between 1 and 12 (default 0 for fast compression
+ mode), and for zstd an integer between
+ ZSTD_minCLevel() (usually -131072)
+ and ZSTD_maxCLevel() (usually 22),
+ (default ZSTD_CLEVEL_DEFAULT or
+ 3).
+
+ The long keyword enables long-distance matching
+ mode, for improved compression ratio, at the expense of higher memory
+ use. Long-distance mode is supported only for
+ zstd.
+
+ The workers keyword sets the number of threads
+ that should be used for parallel compression. Parallel compression
+ is supported only for zstd.
+
MAX_RATE rate
+ Limit (throttle) the maximum amount of data transferred from server
+ to client per unit of time. The expected unit is kilobytes per second.
+ If this option is specified, the value must either be equal to zero
+ or it must fall within the range from 32 kB through 1 GB (inclusive).
+ If zero is passed or the option is not specified, no restriction is
+ imposed on the transfer.
+
TABLESPACE_MAP [ boolean ]
+ If true, include information about symbolic links present in the
+ directory pg_tblspc in a file named
+ tablespace_map. The tablespace map file includes
+ each symbolic link name as it exists in the directory
+ pg_tblspc/ and the full path of that symbolic link.
+ The default is false.
+
VERIFY_CHECKSUMS [ boolean ]
+ If true, checksums are verified during a base backup if they are
+ enabled. If false, this is skipped. The default is true.
+
MANIFEST manifest_option
+ When this option is specified with a value of yes
+ or force-encode, a backup manifest is created
+ and sent along with the backup. The manifest is a list of every
+ file present in the backup with the exception of any WAL files that
+ may be included. It also stores the size, last modification time, and
+ optionally a checksum for each file.
+ A value of force-encode forces all filenames
+ to be hex-encoded; otherwise, this type of encoding is performed only
+ for files whose names are non-UTF8 octet sequences.
+ force-encode is intended primarily for testing
+ purposes, to be sure that clients which read the backup manifest
+ can handle this case. For compatibility with previous releases,
+ the default is MANIFEST 'no'.
+
MANIFEST_CHECKSUMS checksum_algorithm
+ Specifies the checksum algorithm that should be applied to each file included
+ in the backup manifest. Currently, the available
+ algorithms are NONE, CRC32C,
+ SHA224, SHA256,
+ SHA384, and SHA512.
+ The default is CRC32C.
+
+
+ When the backup is started, the server will first send two
+ ordinary result sets, followed by one or more CopyOutResponse
+ results.
+
+ The first ordinary result set contains the starting position of the
+ backup, in a single row with two columns. The first column contains
+ the start position given in XLogRecPtr format, and the second column
+ contains the corresponding timeline ID.
+
+ The second ordinary result set has one row for each tablespace.
+ The fields in this row are:
+
+
spcoid (oid)
+ The OID of the tablespace, or null if it's the base
+ directory.
+
spclocation (text)
+ The full path of the tablespace directory, or null
+ if it's the base directory.
+
size (int8)
+ The approximate size of the tablespace, in kilobytes (1024 bytes),
+ if progress report has been requested; otherwise it's null.
+
+
+ After the second regular result set, a CopyOutResponse will be sent.
+ The payload of each CopyData message will contain a message in one of
+ the following formats:
+
- new archive (B)
- Byte1('n')
+ Identifies the message as indicating the start of a new archive.
+ There will be one archive for the main data directory and one
+ for each additional tablespace; each will use tar format
+ (following the “ustar interchange format” specified
+ in the POSIX 1003.1-2008 standard).
+
- String
+ The file name for this archive.
+
- String
+ For the main data directory, an empty string. For other
+ tablespaces, the full path to the directory from which this
+ archive was created.
+
- manifest (B)
- Byte1('m')
+ Identifies the message as indicating the start of the backup
+ manifest.
+
- archive or manifest data (B)
- Byte1('d')
+ Identifies the message as containing archive or manifest data.
+
- Byte
n
+ Data bytes.
+
- progress report (B)
- Byte1('p')
+ Identifies the message as a progress report.
+
- Int64
+ The number of bytes from the current tablespace for which
+ processing has been completed.
+
+ After the CopyOutResponse, or all such responses, have been sent, a
+ final ordinary result set will be sent, containing the WAL end position
+ of the backup, in the same format as the start position.
+
+ The tar archive for the data directory and each tablespace will contain
+ all files in the directories, regardless of whether they are
+ PostgreSQL files or other files added to the same
+ directory. The only excluded files are:
+
+
+ postmaster.pid
+
+ postmaster.opts
+
+ pg_internal.init (found in multiple directories)
+
+ Various temporary files and directories created during the operation
+ of the PostgreSQL server, such as any file or directory beginning
+ with pgsql_tmp and temporary relations.
+
+ Unlogged relations, except for the init fork which is required to
+ recreate the (empty) unlogged relation on recovery.
+
+ pg_wal, including subdirectories. If the backup is run
+ with WAL files included, a synthesized version of pg_wal will be
+ included, but it will only contain the files necessary for the
+ backup to work, not the rest of the contents.
+
+ pg_dynshmem, pg_notify,
+ pg_replslot, pg_serial,
+ pg_snapshots, pg_stat_tmp, and
+ pg_subtrans are copied as empty directories (even if
+ they are symbolic links).
+
+ Files other than regular files and directories, such as symbolic
+ links (other than for the directories listed above) and special
+ device and operating system files, are skipped. (Symbolic links
+ in pg_tblspc are maintained.)
+
+ Owner, group, and file mode are set if the underlying file system on
+ the server supports it.
+
+
Chapter 55. Frontend/Backend Protocol
+ PostgreSQL uses a message-based protocol
+ for communication between frontends and backends (clients and servers).
+ The protocol is supported over TCP/IP and also over
+ Unix-domain sockets. Port number 5432 has been registered with IANA as
+ the customary TCP port number for servers supporting this protocol, but
+ in practice any non-privileged port number can be used.
+
+ This document describes version 3.0 of the protocol, implemented in
+ PostgreSQL 7.4 and later. For descriptions
+ of the earlier protocol versions, see previous releases of the
+ PostgreSQL documentation. A single server
+ can support multiple protocol versions. The initial startup-request
+ message tells the server which protocol version the client is attempting to
+ use. If the major version requested by the client is not supported by
+ the server, the connection will be rejected (for example, this would occur
+ if the client requested protocol version 4.0, which does not exist as of
+ this writing). If the minor version requested by the client is not
+ supported by the server (e.g., the client requests version 3.1, but the
+ server supports only 3.0), the server may either reject the connection or
+ may respond with a NegotiateProtocolVersion message containing the highest
+ minor protocol version which it supports. The client may then choose either
+ to continue with the connection using the specified protocol version or
+ to abort the connection.
+
+ In order to serve multiple clients efficiently, the server launches
+ a new “backend” process for each client.
+ In the current implementation, a new child
+ process is created immediately after an incoming connection is detected.
+ This is transparent to the protocol, however. For purposes of the
+ protocol, the terms “backend” and “server” are
+ interchangeable; likewise “frontend” and “client”
+ are interchangeable.
+
+ LIMIT and OFFSET allow you to retrieve just
+ a portion of the rows that are generated by the rest of the query:
+
+SELECT select_list
+ FROM table_expression
+ [ ORDER BY ... ]
+ [ LIMIT { number | ALL } ] [ OFFSET number ]
+
+
+ If a limit count is given, no more than that many rows will be
+ returned (but possibly fewer, if the query itself yields fewer rows).
+ LIMIT ALL is the same as omitting the LIMIT
+ clause, as is LIMIT with a NULL argument.
+
+ OFFSET says to skip that many rows before beginning to
+ return rows. OFFSET 0 is the same as omitting the
+ OFFSET clause, as is OFFSET with a NULL argument.
+
+ If both OFFSET
+ and LIMIT appear, then OFFSET rows are
+ skipped before starting to count the LIMIT rows that
+ are returned.
+
+ When using LIMIT, it is important to use an
+ ORDER BY clause that constrains the result rows into a
+ unique order. Otherwise you will get an unpredictable subset of
+ the query's rows. You might be asking for the tenth through
+ twentieth rows, but tenth through twentieth in what ordering? The
+ ordering is unknown, unless you specified ORDER BY.
+
+ The query optimizer takes LIMIT into account when
+ generating query plans, so you are very likely to get different
+ plans (yielding different row orders) depending on what you give
+ for LIMIT and OFFSET. Thus, using
+ different LIMIT/OFFSET values to select
+ different subsets of a query result will give
+ inconsistent results unless you enforce a predictable
+ result ordering with ORDER BY. This is not a bug; it
+ is an inherent consequence of the fact that SQL does not promise to
+ deliver the results of a query in any particular order unless
+ ORDER BY is used to constrain the order.
+
+ The rows skipped by an OFFSET clause still have to be
+ computed inside the server; therefore a large OFFSET
+ might be inefficient.
+
7.5. Sorting Rows (ORDER BY) #
+ After a query has produced an output table (after the select list
+ has been processed) it can optionally be sorted. If sorting is not
+ chosen, the rows will be returned in an unspecified order. The actual
+ order in that case will depend on the scan and join plan types and
+ the order on disk, but it must not be relied on. A particular
+ output ordering can only be guaranteed if the sort step is explicitly
+ chosen.
+
+ The ORDER BY clause specifies the sort order:
+
+SELECT select_list
+ FROM table_expression
+ ORDER BY sort_expression1 [ASC | DESC] [NULLS { FIRST | LAST }]
+ [, sort_expression2 [ASC | DESC] [NULLS { FIRST | LAST }] ...]
+
+ The sort expression(s) can be any expression that would be valid in the
+ query's select list. An example is:
+
+SELECT a, b FROM table1 ORDER BY a + b, c;
+
+ When more than one expression is specified,
+ the later values are used to sort rows that are equal according to the
+ earlier values. Each expression can be followed by an optional
+ ASC or DESC keyword to set the sort direction to
+ ascending or descending. ASC order is the default.
+ Ascending order puts smaller values first, where
+ “smaller” is defined in terms of the
+ < operator. Similarly, descending order is
+ determined with the > operator.
+
+
+ The NULLS FIRST and NULLS LAST options can be
+ used to determine whether nulls appear before or after non-null values
+ in the sort ordering. By default, null values sort as if larger than any
+ non-null value; that is, NULLS FIRST is the default for
+ DESC order, and NULLS LAST otherwise.
+
+ Note that the ordering options are considered independently for each
+ sort column. For example ORDER BY x, y DESC means
+ ORDER BY x ASC, y DESC, which is not the same as
+ ORDER BY x DESC, y DESC.
+
+ A sort_expression can also be the column label or number
+ of an output column, as in:
+
+SELECT a + b AS sum, c FROM table1 ORDER BY sum;
+SELECT a, max(b) FROM table1 GROUP BY a ORDER BY 1;
+
+ both of which sort by the first output column. Note that an output
+ column name has to stand alone, that is, it cannot be used in an expression
+ — for example, this is not correct:
+
+SELECT a + b AS sum, c FROM table1 ORDER BY sum + c; -- wrong
+
+ This restriction is made to reduce ambiguity. There is still
+ ambiguity if an ORDER BY item is a simple name that
+ could match either an output column name or a column from the table
+ expression. The output column is used in such cases. This would
+ only cause confusion if you use AS to rename an output
+ column to match some other table column's name.
+
+ ORDER BY can be applied to the result of a
+ UNION, INTERSECT, or EXCEPT
+ combination, but in this case it is only permitted to sort by
+ output column names or numbers, not by expressions.
+
+ The process of retrieving or the command to retrieve data from a
+ database is called a query. In SQL the
+ SELECT command is
+ used to specify queries. The general syntax of the
+ SELECT command is
+
+[WITH with_queries] SELECT select_list FROM table_expression [sort_specification]
+
+ The following sections describe the details of the select list, the
+ table expression, and the sort specification. WITH
+ queries are treated last since they are an advanced feature.
+
+ A simple kind of query has the form:
+
+SELECT * FROM table1;
+
+ Assuming that there is a table called table1,
+ this command would retrieve all rows and all user-defined columns from
+ table1. (The method of retrieval depends on the
+ client application. For example, the
+ psql program will display an ASCII-art
+ table on the screen, while client libraries will offer functions to
+ extract individual values from the query result.) The select list
+ specification * means all columns that the table
+ expression happens to provide. A select list can also select a
+ subset of the available columns or make calculations using the
+ columns. For example, if
+ table1 has columns named a,
+ b, and c (and perhaps others) you can make
+ the following query:
+
+SELECT a, b + c FROM table1;
+
+ (assuming that b and c are of a numerical
+ data type).
+ See Section 7.3 for more details.
+
+ FROM table1 is a simple kind of
+ table expression: it reads just one table. In general, table
+ expressions can be complex constructs of base tables, joins, and
+ subqueries. But you can also omit the table expression entirely and
+ use the SELECT command as a calculator:
+
+SELECT 3 * 4;
+
+ This is more useful if the expressions in the select list return
+ varying results. For example, you could call a function this way:
+
+SELECT random();
+
+
+ As shown in the previous section,
+ the table expression in the SELECT command
+ constructs an intermediate virtual table by possibly combining
+ tables, views, eliminating rows, grouping, etc. This table is
+ finally passed on to processing by the select list. The select
+ list determines which columns of the
+ intermediate table are actually output.
+
7.3.1. Select-List Items #
+ The simplest kind of select list is * which
+ emits all columns that the table expression produces. Otherwise,
+ a select list is a comma-separated list of value expressions (as
+ defined in Section 4.2). For instance, it
+ could be a list of column names:
+
+SELECT a, b, c FROM ...
+
+ The columns names a, b, and c
+ are either the actual names of the columns of tables referenced
+ in the FROM clause, or the aliases given to them as
+ explained in Section 7.2.1.2. The name
+ space available in the select list is the same as in the
+ WHERE clause, unless grouping is used, in which case
+ it is the same as in the HAVING clause.
+
+ If more than one table has a column of the same name, the table
+ name must also be given, as in:
+
+SELECT tbl1.a, tbl2.a, tbl1.b FROM ...
+
+ When working with multiple tables, it can also be useful to ask for
+ all the columns of a particular table:
+
+SELECT tbl1.*, tbl2.a FROM ...
+
+ See Section 8.16.5 for more about
+ the table_name.* notation.
+
+ If an arbitrary value expression is used in the select list, it
+ conceptually adds a new virtual column to the returned table. The
+ value expression is evaluated once for each result row, with
+ the row's values substituted for any column references. But the
+ expressions in the select list do not have to reference any
+ columns in the table expression of the FROM clause;
+ they can be constant arithmetic expressions, for instance.
+
+ The entries in the select list can be assigned names for subsequent
+ processing, such as for use in an ORDER BY clause
+ or for display by the client application. For example:
+
+SELECT a AS value, b + c AS sum FROM ...
+
+
+ If no output column name is specified using AS,
+ the system assigns a default column name. For simple column references,
+ this is the name of the referenced column. For function
+ calls, this is the name of the function. For complex expressions,
+ the system will generate a generic name.
+
+ The AS key word is usually optional, but in some
+ cases where the desired column name matches a
+ PostgreSQL key word, you must write
+ AS or double-quote the column name in order to
+ avoid ambiguity.
+ (Appendix C shows which key words
+ require AS to be used as a column label.)
+ For example, FROM is one such key word, so this
+ does not work:
+
+SELECT a from, b + c AS sum FROM ...
+
+ but either of these do:
+
+SELECT a AS from, b + c AS sum FROM ...
+SELECT a "from", b + c AS sum FROM ...
+
+ For greatest safety against possible
+ future key word additions, it is recommended that you always either
+ write AS or double-quote the output column name.
+
Note
+ The naming of output columns here is different from that done in
+ the FROM clause (see Section 7.2.1.2). It is possible
+ to rename the same column twice, but the name assigned in
+ the select list is the one that will be passed on.
+
+ After the select list has been processed, the result table can
+ optionally be subject to the elimination of duplicate rows. The
+ DISTINCT key word is written directly after
+ SELECT to specify this:
+
+SELECT DISTINCT select_list ...
+
+ (Instead of DISTINCT the key word ALL
+ can be used to specify the default behavior of retaining all rows.)
+
+ Obviously, two rows are considered distinct if they differ in at
+ least one column value. Null values are considered equal in this
+ comparison.
+
+ Alternatively, an arbitrary expression can determine what rows are
+ to be considered distinct:
+
+SELECT DISTINCT ON (expression [, expression ...]) select_list ...
+
+ Here expression is an arbitrary value
+ expression that is evaluated for all rows. A set of rows for
+ which all the expressions are equal are considered duplicates, and
+ only the first row of the set is kept in the output. Note that
+ the “first row” of a set is unpredictable unless the
+ query is sorted on enough columns to guarantee a unique ordering
+ of the rows arriving at the DISTINCT filter.
+ (DISTINCT ON processing occurs after ORDER
+ BY sorting.)
+
+ The DISTINCT ON clause is not part of the SQL standard
+ and is sometimes considered bad style because of the potentially
+ indeterminate nature of its results. With judicious use of
+ GROUP BY and subqueries in FROM, this
+ construct can be avoided, but it is often the most convenient
+ alternative.
+
+ A table expression computes a table. The
+ table expression contains a FROM clause that is
+ optionally followed by WHERE, GROUP BY, and
+ HAVING clauses. Trivial table expressions simply refer
+ to a table on disk, a so-called base table, but more complex
+ expressions can be used to modify or combine base tables in various
+ ways.
+
+ The optional WHERE, GROUP BY, and
+ HAVING clauses in the table expression specify a
+ pipeline of successive transformations performed on the table
+ derived in the FROM clause. All these transformations
+ produce a virtual table that provides the rows that are passed to
+ the select list to compute the output rows of the query.
+
+ The FROM clause derives a
+ table from one or more other tables given in a comma-separated
+ table reference list.
+
+FROM table_reference [, table_reference [, ...]]
+
+
+ A table reference can be a table name (possibly schema-qualified),
+ or a derived table such as a subquery, a JOIN construct, or
+ complex combinations of these. If more than one table reference is
+ listed in the FROM clause, the tables are cross-joined
+ (that is, the Cartesian product of their rows is formed; see below).
+ The result of the FROM list is an intermediate virtual
+ table that can then be subject to
+ transformations by the WHERE, GROUP BY,
+ and HAVING clauses and is finally the result of the
+ overall table expression.
+
+ When a table reference names a table that is the parent of a
+ table inheritance hierarchy, the table reference produces rows of
+ not only that table but all of its descendant tables, unless the
+ key word ONLY precedes the table name. However, the
+ reference produces only the columns that appear in the named table
+ — any columns added in subtables are ignored.
+
+ Instead of writing ONLY before the table name, you can write
+ * after the table name to explicitly specify that descendant
+ tables are included. There is no real reason to use this syntax any more,
+ because searching descendant tables is now always the default behavior.
+ However, it is supported for compatibility with older releases.
+
+ A joined table is a table derived from two other (real or
+ derived) tables according to the rules of the particular join
+ type. Inner, outer, and cross-joins are available.
+ The general syntax of a joined table is
+
+T1 join_type T2 [ join_condition ]
+
+ Joins of all types can be chained together, or nested: either or
+ both T1 and
+ T2 can be joined tables. Parentheses
+ can be used around JOIN clauses to control the join
+ order. In the absence of parentheses, JOIN clauses
+ nest left-to-right.
+
Join Types
- Cross join
+
+
+
+
+T1 CROSS JOIN T2
+
+ For every possible combination of rows from
+ T1 and
+ T2 (i.e., a Cartesian product),
+ the joined table will contain a
+ row consisting of all columns in T1
+ followed by all columns in T2. If
+ the tables have N and M rows respectively, the joined
+ table will have N * M rows.
+
+ FROM T1 CROSS JOIN
+ T2 is equivalent to
+ FROM T1 INNER JOIN
+ T2 ON TRUE (see below).
+ It is also equivalent to
+ FROM T1,
+ T2.
+
Note
+ This latter equivalence does not hold exactly when more than two
+ tables appear, because JOIN binds more tightly than
+ comma. For example
+ FROM T1 CROSS JOIN
+ T2 INNER JOIN T3
+ ON condition
+ is not the same as
+ FROM T1,
+ T2 INNER JOIN T3
+ ON condition
+ because the condition can
+ reference T1 in the first case but not
+ the second.
+
+
- Qualified joins
+
+
+
+
+T1 { [INNER] | { LEFT | RIGHT | FULL } [OUTER] } JOIN T2 ON boolean_expression
+T1 { [INNER] | { LEFT | RIGHT | FULL } [OUTER] } JOIN T2 USING ( join column list )
+T1 NATURAL { [INNER] | { LEFT | RIGHT | FULL } [OUTER] } JOIN T2
+
+ The words INNER and
+ OUTER are optional in all forms.
+ INNER is the default;
+ LEFT, RIGHT, and
+ FULL imply an outer join.
+
+ The join condition is specified in the
+ ON or USING clause, or implicitly by
+ the word NATURAL. The join condition determines
+ which rows from the two source tables are considered to
+ “match”, as explained in detail below.
+
+ The possible types of qualified join are:
+
+
INNER JOIN
+ For each row R1 of T1, the joined table has a row for each
+ row in T2 that satisfies the join condition with R1.
+
LEFT OUTER JOIN
+
+
+
+
+ First, an inner join is performed. Then, for each row in
+ T1 that does not satisfy the join condition with any row in
+ T2, a joined row is added with null values in columns of
+ T2. Thus, the joined table always has at least
+ one row for each row in T1.
+
RIGHT OUTER JOIN
+
+
+
+
+ First, an inner join is performed. Then, for each row in
+ T2 that does not satisfy the join condition with any row in
+ T1, a joined row is added with null values in columns of
+ T1. This is the converse of a left join: the result table
+ will always have a row for each row in T2.
+
FULL OUTER JOIN
+ First, an inner join is performed. Then, for each row in
+ T1 that does not satisfy the join condition with any row in
+ T2, a joined row is added with null values in columns of
+ T2. Also, for each row of T2 that does not satisfy the
+ join condition with any row in T1, a joined row with null
+ values in the columns of T1 is added.
+
+
+ The ON clause is the most general kind of join
+ condition: it takes a Boolean value expression of the same
+ kind as is used in a WHERE clause. A pair of rows
+ from T1 and T2 match if the
+ ON expression evaluates to true.
+
+ The USING clause is a shorthand that allows you to take
+ advantage of the specific situation where both sides of the join use
+ the same name for the joining column(s). It takes a
+ comma-separated list of the shared column names
+ and forms a join condition that includes an equality comparison
+ for each one. For example, joining T1
+ and T2 with USING (a, b) produces
+ the join condition ON T1.a
+ = T2.a AND T1.b
+ = T2.b.
+
+ Furthermore, the output of JOIN USING suppresses
+ redundant columns: there is no need to print both of the matched
+ columns, since they must have equal values. While JOIN
+ ON produces all columns from T1 followed by all
+ columns from T2, JOIN USING produces one
+ output column for each of the listed column pairs (in the listed
+ order), followed by any remaining columns from T1,
+ followed by any remaining columns from T2.
+
+
+
+ Finally, NATURAL is a shorthand form of
+ USING: it forms a USING list
+ consisting of all column names that appear in both
+ input tables. As with USING, these columns appear
+ only once in the output table. If there are no common
+ column names, NATURAL JOIN behaves like
+ JOIN ... ON TRUE, producing a cross-product join.
+
Note
+ USING is reasonably safe from column changes
+ in the joined relations since only the listed columns
+ are combined. NATURAL is considerably more risky since
+ any schema changes to either relation that cause a new matching
+ column name to be present will cause the join to combine that new
+ column as well.
+
+ To put this together, assume we have tables t1:
+
+ num | name
+-----+------
+ 1 | a
+ 2 | b
+ 3 | c
+
+ and t2:
+
+ num | value
+-----+-------
+ 1 | xxx
+ 3 | yyy
+ 5 | zzz
+
+ then we get the following results for the various joins:
+
+=> SELECT * FROM t1 CROSS JOIN t2;
+ num | name | num | value
+-----+------+-----+-------
+ 1 | a | 1 | xxx
+ 1 | a | 3 | yyy
+ 1 | a | 5 | zzz
+ 2 | b | 1 | xxx
+ 2 | b | 3 | yyy
+ 2 | b | 5 | zzz
+ 3 | c | 1 | xxx
+ 3 | c | 3 | yyy
+ 3 | c | 5 | zzz
+(9 rows)
+
+=> SELECT * FROM t1 INNER JOIN t2 ON t1.num = t2.num;
+ num | name | num | value
+-----+------+-----+-------
+ 1 | a | 1 | xxx
+ 3 | c | 3 | yyy
+(2 rows)
+
+=> SELECT * FROM t1 INNER JOIN t2 USING (num);
+ num | name | value
+-----+------+-------
+ 1 | a | xxx
+ 3 | c | yyy
+(2 rows)
+
+=> SELECT * FROM t1 NATURAL INNER JOIN t2;
+ num | name | value
+-----+------+-------
+ 1 | a | xxx
+ 3 | c | yyy
+(2 rows)
+
+=> SELECT * FROM t1 LEFT JOIN t2 ON t1.num = t2.num;
+ num | name | num | value
+-----+------+-----+-------
+ 1 | a | 1 | xxx
+ 2 | b | |
+ 3 | c | 3 | yyy
+(3 rows)
+
+=> SELECT * FROM t1 LEFT JOIN t2 USING (num);
+ num | name | value
+-----+------+-------
+ 1 | a | xxx
+ 2 | b |
+ 3 | c | yyy
+(3 rows)
+
+=> SELECT * FROM t1 RIGHT JOIN t2 ON t1.num = t2.num;
+ num | name | num | value
+-----+------+-----+-------
+ 1 | a | 1 | xxx
+ 3 | c | 3 | yyy
+ | | 5 | zzz
+(3 rows)
+
+=> SELECT * FROM t1 FULL JOIN t2 ON t1.num = t2.num;
+ num | name | num | value
+-----+------+-----+-------
+ 1 | a | 1 | xxx
+ 2 | b | |
+ 3 | c | 3 | yyy
+ | | 5 | zzz
+(4 rows)
+
+
+ The join condition specified with ON can also contain
+ conditions that do not relate directly to the join. This can
+ prove useful for some queries but needs to be thought out
+ carefully. For example:
+
+=> SELECT * FROM t1 LEFT JOIN t2 ON t1.num = t2.num AND t2.value = 'xxx';
+ num | name | num | value
+-----+------+-----+-------
+ 1 | a | 1 | xxx
+ 2 | b | |
+ 3 | c | |
+(3 rows)
+
+ Notice that placing the restriction in the WHERE clause
+ produces a different result:
+
+=> SELECT * FROM t1 LEFT JOIN t2 ON t1.num = t2.num WHERE t2.value = 'xxx';
+ num | name | num | value
+-----+------+-----+-------
+ 1 | a | 1 | xxx
+(1 row)
+
+ This is because a restriction placed in the ON
+ clause is processed before the join, while
+ a restriction placed in the WHERE clause is processed
+ after the join.
+ That does not matter with inner joins, but it matters a lot with outer
+ joins.
+
7.2.1.2. Table and Column Aliases #
+ A temporary name can be given to tables and complex table
+ references to be used for references to the derived table in
+ the rest of the query. This is called a table
+ alias.
+
+ To create a table alias, write
+
+FROM table_reference AS alias
+
+ or
+
+FROM table_reference alias
+
+ The AS key word is optional noise.
+ alias can be any identifier.
+
+ A typical application of table aliases is to assign short
+ identifiers to long table names to keep the join clauses
+ readable. For example:
+
+SELECT * FROM some_very_long_table_name s JOIN another_fairly_long_name a ON s.id = a.num;
+
+
+ The alias becomes the new name of the table reference so far as the
+ current query is concerned — it is not allowed to refer to the
+ table by the original name elsewhere in the query. Thus, this is not
+ valid:
+
+SELECT * FROM my_table AS m WHERE my_table.a > 5; -- wrong
+
+
+ Table aliases are mainly for notational convenience, but it is
+ necessary to use them when joining a table to itself, e.g.:
+
+SELECT * FROM people AS mother JOIN people AS child ON mother.id = child.mother_id;
+
+
+ Parentheses are used to resolve ambiguities. In the following example,
+ the first statement assigns the alias b to the second
+ instance of my_table, but the second statement assigns the
+ alias to the result of the join:
+
+SELECT * FROM my_table AS a CROSS JOIN my_table AS b ...
+SELECT * FROM (my_table AS a CROSS JOIN my_table) AS b ...
+
+
+ Another form of table aliasing gives temporary names to the columns of
+ the table, as well as the table itself:
+
+FROM table_reference [AS] alias ( column1 [, column2 [, ...]] )
+
+ If fewer column aliases are specified than the actual table has
+ columns, the remaining columns are not renamed. This syntax is
+ especially useful for self-joins or subqueries.
+
+ When an alias is applied to the output of a JOIN
+ clause, the alias hides the original
+ name(s) within the JOIN. For example:
+
+SELECT a.* FROM my_table AS a JOIN your_table AS b ON ...
+
+ is valid SQL, but:
+
+SELECT a.* FROM (my_table AS a JOIN your_table AS b ON ...) AS c
+
+ is not valid; the table alias a is not visible
+ outside the alias c.
+
+ Subqueries specifying a derived table must be enclosed in
+ parentheses. They may be assigned a table alias name, and optionally
+ column alias names (as in Section 7.2.1.2).
+ For example:
+
+FROM (SELECT * FROM table1) AS alias_name
+
+
+ This example is equivalent to FROM table1 AS
+ alias_name. More interesting cases, which cannot be
+ reduced to a plain join, arise when the subquery involves
+ grouping or aggregation.
+
+ A subquery can also be a VALUES list:
+
+FROM (VALUES ('anne', 'smith'), ('bob', 'jones'), ('joe', 'blow'))
+ AS names(first, last)
+
+ Again, a table alias is optional. Assigning alias names to the columns
+ of the VALUES list is optional, but is good practice.
+ For more information see Section 7.7.
+
+ According to the SQL standard, a table alias name must be supplied
+ for a subquery. PostgreSQL
+ allows AS and the alias to be omitted, but
+ writing one is good practice in SQL code that might be ported to
+ another system.
+
7.2.1.4. Table Functions #
+ Table functions are functions that produce a set of rows, made up
+ of either base data types (scalar types) or composite data types
+ (table rows). They are used like a table, view, or subquery in
+ the FROM clause of a query. Columns returned by table
+ functions can be included in SELECT,
+ JOIN, or WHERE clauses in the same manner
+ as columns of a table, view, or subquery.
+
+ Table functions may also be combined using the ROWS FROM
+ syntax, with the results returned in parallel columns; the number of
+ result rows in this case is that of the largest function result, with
+ smaller results padded with null values to match.
+
+function_call [WITH ORDINALITY] [[AS] table_alias [(column_alias [, ... ])]]
+ROWS FROM( function_call [, ... ] ) [WITH ORDINALITY] [[AS] table_alias [(column_alias [, ... ])]]
+
+ If the WITH ORDINALITY clause is specified, an
+ additional column of type bigint will be added to the
+ function result columns. This column numbers the rows of the function
+ result set, starting from 1. (This is a generalization of the
+ SQL-standard syntax for UNNEST ... WITH ORDINALITY.)
+ By default, the ordinal column is called ordinality, but
+ a different column name can be assigned to it using
+ an AS clause.
+
+ The special table function UNNEST may be called with
+ any number of array parameters, and it returns a corresponding number of
+ columns, as if UNNEST
+ (Section 9.19) had been called on each parameter
+ separately and combined using the ROWS FROM construct.
+
+UNNEST( array_expression [, ... ] ) [WITH ORDINALITY] [[AS] table_alias [(column_alias [, ... ])]]
+
+ If no table_alias is specified, the function
+ name is used as the table name; in the case of a ROWS FROM()
+ construct, the first function's name is used.
+
+ If column aliases are not supplied, then for a function returning a base
+ data type, the column name is also the same as the function name. For a
+ function returning a composite type, the result columns get the names
+ of the individual attributes of the type.
+
+ Some examples:
+
+CREATE TABLE foo (fooid int, foosubid int, fooname text);
+
+CREATE FUNCTION getfoo(int) RETURNS SETOF foo AS $$
+ SELECT * FROM foo WHERE fooid = $1;
+$$ LANGUAGE SQL;
+
+SELECT * FROM getfoo(1) AS t1;
+
+SELECT * FROM foo
+ WHERE foosubid IN (
+ SELECT foosubid
+ FROM getfoo(foo.fooid) z
+ WHERE z.fooid = foo.fooid
+ );
+
+CREATE VIEW vw_getfoo AS SELECT * FROM getfoo(1);
+
+SELECT * FROM vw_getfoo;
+
+
+ In some cases it is useful to define table functions that can
+ return different column sets depending on how they are invoked.
+ To support this, the table function can be declared as returning
+ the pseudo-type record with no OUT
+ parameters. When such a function is used in
+ a query, the expected row structure must be specified in the
+ query itself, so that the system can know how to parse and plan
+ the query. This syntax looks like:
+
+function_call [AS] alias (column_definition [, ... ])
+function_call AS [alias] (column_definition [, ... ])
+ROWS FROM( ... function_call AS (column_definition [, ... ]) [, ... ] )
+
+ When not using the ROWS FROM() syntax,
+ the column_definition list replaces the column
+ alias list that could otherwise be attached to the FROM
+ item; the names in the column definitions serve as column aliases.
+ When using the ROWS FROM() syntax,
+ a column_definition list can be attached to
+ each member function separately; or if there is only one member function
+ and no WITH ORDINALITY clause,
+ a column_definition list can be written in
+ place of a column alias list following ROWS FROM().
+
+ Consider this example:
+
+SELECT *
+ FROM dblink('dbname=mydb', 'SELECT proname, prosrc FROM pg_proc')
+ AS t1(proname name, prosrc text)
+ WHERE proname LIKE 'bytea%';
+
+ The dblink function
+ (part of the dblink module) executes
+ a remote query. It is declared to return
+ record since it might be used for any kind of query.
+ The actual column set must be specified in the calling query so
+ that the parser knows, for example, what * should
+ expand to.
+
+ This example uses ROWS FROM:
+
+SELECT *
+FROM ROWS FROM
+ (
+ json_to_recordset('[{"a":40,"b":"foo"},{"a":"100","b":"bar"}]')
+ AS (a INTEGER, b TEXT),
+ generate_series(1, 3)
+ ) AS x (p, q, s)
+ORDER BY p;
+
+ p | q | s
+-----+-----+---
+ 40 | foo | 1
+ 100 | bar | 2
+ | | 3
+
+ It joins two functions into a single FROM
+ target. json_to_recordset() is instructed
+ to return two columns, the first integer
+ and the second text. The result of
+ generate_series() is used directly.
+ The ORDER BY clause sorts the column values
+ as integers.
+
7.2.1.5. LATERAL Subqueries #
+ Subqueries appearing in FROM can be
+ preceded by the key word LATERAL. This allows them to
+ reference columns provided by preceding FROM items.
+ (Without LATERAL, each subquery is
+ evaluated independently and so cannot cross-reference any other
+ FROM item.)
+
+ Table functions appearing in FROM can also be
+ preceded by the key word LATERAL, but for functions the
+ key word is optional; the function's arguments can contain references
+ to columns provided by preceding FROM items in any case.
+
+ A LATERAL item can appear at the top level in the
+ FROM list, or within a JOIN tree. In the latter
+ case it can also refer to any items that are on the left-hand side of a
+ JOIN that it is on the right-hand side of.
+
+ When a FROM item contains LATERAL
+ cross-references, evaluation proceeds as follows: for each row of the
+ FROM item providing the cross-referenced column(s), or
+ set of rows of multiple FROM items providing the
+ columns, the LATERAL item is evaluated using that
+ row or row set's values of the columns. The resulting row(s) are
+ joined as usual with the rows they were computed from. This is
+ repeated for each row or set of rows from the column source table(s).
+
+ A trivial example of LATERAL is
+
+SELECT * FROM foo, LATERAL (SELECT * FROM bar WHERE bar.id = foo.bar_id) ss;
+
+ This is not especially useful since it has exactly the same result as
+ the more conventional
+
+SELECT * FROM foo, bar WHERE bar.id = foo.bar_id;
+
+ LATERAL is primarily useful when the cross-referenced
+ column is necessary for computing the row(s) to be joined. A common
+ application is providing an argument value for a set-returning function.
+ For example, supposing that vertices(polygon) returns the
+ set of vertices of a polygon, we could identify close-together vertices
+ of polygons stored in a table with:
+
+SELECT p1.id, p2.id, v1, v2
+FROM polygons p1, polygons p2,
+ LATERAL vertices(p1.poly) v1,
+ LATERAL vertices(p2.poly) v2
+WHERE (v1 <-> v2) < 10 AND p1.id != p2.id;
+
+ This query could also be written
+
+SELECT p1.id, p2.id, v1, v2
+FROM polygons p1 CROSS JOIN LATERAL vertices(p1.poly) v1,
+ polygons p2 CROSS JOIN LATERAL vertices(p2.poly) v2
+WHERE (v1 <-> v2) < 10 AND p1.id != p2.id;
+
+ or in several other equivalent formulations. (As already mentioned,
+ the LATERAL key word is unnecessary in this example, but
+ we use it for clarity.)
+
+ It is often particularly handy to LEFT JOIN to a
+ LATERAL subquery, so that source rows will appear in
+ the result even if the LATERAL subquery produces no
+ rows for them. For example, if get_product_names() returns
+ the names of products made by a manufacturer, but some manufacturers in
+ our table currently produce no products, we could find out which ones
+ those are like this:
+
+SELECT m.name
+FROM manufacturers m LEFT JOIN LATERAL get_product_names(m.id) pname ON true
+WHERE pname IS NULL;
+
+
7.2.2. The WHERE Clause #
+ The syntax of the WHERE
+ clause is
+
+WHERE search_condition
+
+ where search_condition is any value
+ expression (see Section 4.2) that
+ returns a value of type boolean.
+
+ After the processing of the FROM clause is done, each
+ row of the derived virtual table is checked against the search
+ condition. If the result of the condition is true, the row is
+ kept in the output table, otherwise (i.e., if the result is
+ false or null) it is discarded. The search condition typically
+ references at least one column of the table generated in the
+ FROM clause; this is not required, but otherwise the
+ WHERE clause will be fairly useless.
+
Note
+ The join condition of an inner join can be written either in
+ the WHERE clause or in the JOIN clause.
+ For example, these table expressions are equivalent:
+
+FROM a, b WHERE a.id = b.id AND b.val > 5
+
+ and:
+
+FROM a INNER JOIN b ON (a.id = b.id) WHERE b.val > 5
+
+ or perhaps even:
+
+FROM a NATURAL JOIN b WHERE b.val > 5
+
+ Which one of these you use is mainly a matter of style. The
+ JOIN syntax in the FROM clause is
+ probably not as portable to other SQL database management systems,
+ even though it is in the SQL standard. For
+ outer joins there is no choice: they must be done in
+ the FROM clause. The ON or USING
+ clause of an outer join is not equivalent to a
+ WHERE condition, because it results in the addition
+ of rows (for unmatched input rows) as well as the removal of rows
+ in the final result.
+
+ Here are some examples of WHERE clauses:
+
+SELECT ... FROM fdt WHERE c1 > 5
+
+SELECT ... FROM fdt WHERE c1 IN (1, 2, 3)
+
+SELECT ... FROM fdt WHERE c1 IN (SELECT c1 FROM t2)
+
+SELECT ... FROM fdt WHERE c1 IN (SELECT c3 FROM t2 WHERE c2 = fdt.c1 + 10)
+
+SELECT ... FROM fdt WHERE c1 BETWEEN (SELECT c3 FROM t2 WHERE c2 = fdt.c1 + 10) AND 100
+
+SELECT ... FROM fdt WHERE EXISTS (SELECT c1 FROM t2 WHERE c2 > fdt.c1)
+
+ fdt is the table derived in the
+ FROM clause. Rows that do not meet the search
+ condition of the WHERE clause are eliminated from
+ fdt. Notice the use of scalar subqueries as
+ value expressions. Just like any other query, the subqueries can
+ employ complex table expressions. Notice also how
+ fdt is referenced in the subqueries.
+ Qualifying c1 as fdt.c1 is only necessary
+ if c1 is also the name of a column in the derived
+ input table of the subquery. But qualifying the column name adds
+ clarity even when it is not needed. This example shows how the column
+ naming scope of an outer query extends into its inner queries.
+
7.2.3. The GROUP BY and HAVING Clauses #
+ After passing the WHERE filter, the derived input
+ table might be subject to grouping, using the GROUP BY
+ clause, and elimination of group rows using the HAVING
+ clause.
+
+SELECT select_list
+ FROM ...
+ [WHERE ...]
+ GROUP BY grouping_column_reference [, grouping_column_reference]...
+
+ The GROUP BY clause is
+ used to group together those rows in a table that have the same
+ values in all the columns listed. The order in which the columns
+ are listed does not matter. The effect is to combine each set
+ of rows having common values into one group row that
+ represents all rows in the group. This is done to
+ eliminate redundancy in the output and/or compute aggregates that
+ apply to these groups. For instance:
+
+=> SELECT * FROM test1;
+ x | y
+---+---
+ a | 3
+ c | 2
+ b | 5
+ a | 1
+(4 rows)
+
+=> SELECT x FROM test1 GROUP BY x;
+ x
+---
+ a
+ b
+ c
+(3 rows)
+
+
+ In the second query, we could not have written SELECT *
+ FROM test1 GROUP BY x, because there is no single value
+ for the column y that could be associated with each
+ group. The grouped-by columns can be referenced in the select list since
+ they have a single value in each group.
+
+ In general, if a table is grouped, columns that are not
+ listed in GROUP BY cannot be referenced except in aggregate
+ expressions. An example with aggregate expressions is:
+
+=> SELECT x, sum(y) FROM test1 GROUP BY x;
+ x | sum
+---+-----
+ a | 4
+ b | 5
+ c | 2
+(3 rows)
+
+ Here sum is an aggregate function that
+ computes a single value over the entire group. More information
+ about the available aggregate functions can be found in Section 9.21.
+
Tip
+ Grouping without aggregate expressions effectively calculates the
+ set of distinct values in a column. This can also be achieved
+ using the DISTINCT clause (see Section 7.3.3).
+
+ Here is another example: it calculates the total sales for each
+ product (rather than the total sales of all products):
+
+SELECT product_id, p.name, (sum(s.units) * p.price) AS sales
+ FROM products p LEFT JOIN sales s USING (product_id)
+ GROUP BY product_id, p.name, p.price;
+
+ In this example, the columns product_id,
+ p.name, and p.price must be
+ in the GROUP BY clause since they are referenced in
+ the query select list (but see below). The column
+ s.units does not have to be in the GROUP
+ BY list since it is only used in an aggregate expression
+ (sum(...)), which represents the sales
+ of a product. For each product, the query returns a summary row about
+ all sales of the product.
+
+ If the products table is set up so that, say,
+ product_id is the primary key, then it would be
+ enough to group by product_id in the above example,
+ since name and price would be functionally
+ dependent on the product ID, and so there would be no
+ ambiguity about which name and price value to return for each product
+ ID group.
+
+ In strict SQL, GROUP BY can only group by columns of
+ the source table but PostgreSQL extends
+ this to also allow GROUP BY to group by columns in the
+ select list. Grouping by value expressions instead of simple
+ column names is also allowed.
+
+ If a table has been grouped using GROUP BY,
+ but only certain groups are of interest, the
+ HAVING clause can be used, much like a
+ WHERE clause, to eliminate groups from the result.
+ The syntax is:
+
+SELECT select_list FROM ... [WHERE ...] GROUP BY ... HAVING boolean_expression
+
+ Expressions in the HAVING clause can refer both to
+ grouped expressions and to ungrouped expressions (which necessarily
+ involve an aggregate function).
+
+ Example:
+
+=> SELECT x, sum(y) FROM test1 GROUP BY x HAVING sum(y) > 3;
+ x | sum
+---+-----
+ a | 4
+ b | 5
+(2 rows)
+
+=> SELECT x, sum(y) FROM test1 GROUP BY x HAVING x < 'c';
+ x | sum
+---+-----
+ a | 4
+ b | 5
+(2 rows)
+
+
+ Again, a more realistic example:
+
+SELECT product_id, p.name, (sum(s.units) * (p.price - p.cost)) AS profit
+ FROM products p LEFT JOIN sales s USING (product_id)
+ WHERE s.date > CURRENT_DATE - INTERVAL '4 weeks'
+ GROUP BY product_id, p.name, p.price, p.cost
+ HAVING sum(p.price * s.units) > 5000;
+
+ In the example above, the WHERE clause is selecting
+ rows by a column that is not grouped (the expression is only true for
+ sales during the last four weeks), while the HAVING
+ clause restricts the output to groups with total gross sales over
+ 5000. Note that the aggregate expressions do not necessarily need
+ to be the same in all parts of the query.
+
+ If a query contains aggregate function calls, but no GROUP BY
+ clause, grouping still occurs: the result is a single group row (or
+ perhaps no rows at all, if the single row is then eliminated by
+ HAVING).
+ The same is true if it contains a HAVING clause, even
+ without any aggregate function calls or GROUP BY clause.
+
7.2.4. GROUPING SETS, CUBE, and ROLLUP #
+ More complex grouping operations than those described above are possible
+ using the concept of grouping sets. The data selected by
+ the FROM and WHERE clauses is grouped separately
+ by each specified grouping set, aggregates computed for each group just as
+ for simple GROUP BY clauses, and then the results returned.
+ For example:
+
+=> SELECT * FROM items_sold;
+ brand | size | sales
+-------+------+-------
+ Foo | L | 10
+ Foo | M | 20
+ Bar | M | 15
+ Bar | L | 5
+(4 rows)
+
+=> SELECT brand, size, sum(sales) FROM items_sold GROUP BY GROUPING SETS ((brand), (size), ());
+ brand | size | sum
+-------+------+-----
+ Foo | | 30
+ Bar | | 20
+ | L | 15
+ | M | 35
+ | | 50
+(5 rows)
+
+
+ Each sublist of GROUPING SETS may specify zero or more columns
+ or expressions and is interpreted the same way as though it were directly
+ in the GROUP BY clause. An empty grouping set means that all
+ rows are aggregated down to a single group (which is output even if no
+ input rows were present), as described above for the case of aggregate
+ functions with no GROUP BY clause.
+
+ References to the grouping columns or expressions are replaced
+ by null values in result rows for grouping sets in which those
+ columns do not appear. To distinguish which grouping a particular output
+ row resulted from, see Table 9.63.
+
+ A shorthand notation is provided for specifying two common types of grouping set.
+ A clause of the form
+
+ROLLUP ( e1, e2, e3, ... )
+
+ represents the given list of expressions and all prefixes of the list including
+ the empty list; thus it is equivalent to
+
+GROUPING SETS (
+ ( e1, e2, e3, ... ),
+ ...
+ ( e1, e2 ),
+ ( e1 ),
+ ( )
+)
+
+ This is commonly used for analysis over hierarchical data; e.g., total
+ salary by department, division, and company-wide total.
+
+ A clause of the form
+
+CUBE ( e1, e2, ... )
+
+ represents the given list and all of its possible subsets (i.e., the power
+ set). Thus
+
+CUBE ( a, b, c )
+
+ is equivalent to
+
+GROUPING SETS (
+ ( a, b, c ),
+ ( a, b ),
+ ( a, c ),
+ ( a ),
+ ( b, c ),
+ ( b ),
+ ( c ),
+ ( )
+)
+
+
+ The individual elements of a CUBE or ROLLUP
+ clause may be either individual expressions, or sublists of elements in
+ parentheses. In the latter case, the sublists are treated as single
+ units for the purposes of generating the individual grouping sets.
+ For example:
+
+CUBE ( (a, b), (c, d) )
+
+ is equivalent to
+
+GROUPING SETS (
+ ( a, b, c, d ),
+ ( a, b ),
+ ( c, d ),
+ ( )
+)
+
+ and
+
+ROLLUP ( a, (b, c), d )
+
+ is equivalent to
+
+GROUPING SETS (
+ ( a, b, c, d ),
+ ( a, b, c ),
+ ( a ),
+ ( )
+)
+
+
+ The CUBE and ROLLUP constructs can be used either
+ directly in the GROUP BY clause, or nested inside a
+ GROUPING SETS clause. If one GROUPING SETS clause
+ is nested inside another, the effect is the same as if all the elements of
+ the inner clause had been written directly in the outer clause.
+
+ If multiple grouping items are specified in a single GROUP BY
+ clause, then the final list of grouping sets is the cross product of the
+ individual items. For example:
+
+GROUP BY a, CUBE (b, c), GROUPING SETS ((d), (e))
+
+ is equivalent to
+
+GROUP BY GROUPING SETS (
+ (a, b, c, d), (a, b, c, e),
+ (a, b, d), (a, b, e),
+ (a, c, d), (a, c, e),
+ (a, d), (a, e)
+)
+
+
+
+
+ When specifying multiple grouping items together, the final set of grouping
+ sets might contain duplicates. For example:
+
+GROUP BY ROLLUP (a, b), ROLLUP (a, c)
+
+ is equivalent to
+
+GROUP BY GROUPING SETS (
+ (a, b, c),
+ (a, b),
+ (a, b),
+ (a, c),
+ (a),
+ (a),
+ (a, c),
+ (a),
+ ()
+)
+
+ If these duplicates are undesirable, they can be removed using the
+ DISTINCT clause directly on the GROUP BY.
+ Therefore:
+
+GROUP BY DISTINCT ROLLUP (a, b), ROLLUP (a, c)
+
+ is equivalent to
+
+GROUP BY GROUPING SETS (
+ (a, b, c),
+ (a, b),
+ (a, c),
+ (a),
+ ()
+)
+
+ This is not the same as using SELECT DISTINCT because the output
+ rows may still contain duplicates. If any of the ungrouped columns contains NULL,
+ it will be indistinguishable from the NULL used when that same column is grouped.
+
Note
+ The construct (a, b) is normally recognized in expressions as
+ a row constructor.
+ Within the GROUP BY clause, this does not apply at the top
+ levels of expressions, and (a, b) is parsed as a list of
+ expressions as described above. If for some reason you need
+ a row constructor in a grouping expression, use ROW(a, b).
+
7.2.5. Window Function Processing #
+ If the query contains any window functions (see
+ Section 3.5,
+ Section 9.22 and
+ Section 4.2.8), these functions are evaluated
+ after any grouping, aggregation, and HAVING filtering is
+ performed. That is, if the query uses any aggregates, GROUP
+ BY, or HAVING, then the rows seen by the window functions
+ are the group rows instead of the original table rows from
+ FROM/WHERE.
+
+ When multiple window functions are used, all the window functions having
+ syntactically equivalent PARTITION BY and ORDER BY
+ clauses in their window definitions are guaranteed to be evaluated in a
+ single pass over the data. Therefore they will see the same sort ordering,
+ even if the ORDER BY does not uniquely determine an ordering.
+ However, no guarantees are made about the evaluation of functions having
+ different PARTITION BY or ORDER BY specifications.
+ (In such cases a sort step is typically required between the passes of
+ window function evaluations, and the sort is not guaranteed to preserve
+ ordering of rows that its ORDER BY sees as equivalent.)
+
+ Currently, window functions always require presorted data, and so the
+ query output will be ordered according to one or another of the window
+ functions' PARTITION BY/ORDER BY clauses.
+ It is not recommended to rely on this, however. Use an explicit
+ top-level ORDER BY clause if you want to be sure the
+ results are sorted in a particular way.
+
7.4. Combining Queries (UNION, INTERSECT, EXCEPT) #
+ The results of two queries can be combined using the set operations
+ union, intersection, and difference. The syntax is
+
+query1 UNION [ALL] query2
+query1 INTERSECT [ALL] query2
+query1 EXCEPT [ALL] query2
+
+ where query1 and
+ query2 are queries that can use any of
+ the features discussed up to this point.
+
+ UNION effectively appends the result of
+ query2 to the result of
+ query1 (although there is no guarantee
+ that this is the order in which the rows are actually returned).
+ Furthermore, it eliminates duplicate rows from its result, in the same
+ way as DISTINCT, unless UNION ALL is used.
+
+ INTERSECT returns all rows that are both in the result
+ of query1 and in the result of
+ query2. Duplicate rows are eliminated
+ unless INTERSECT ALL is used.
+
+ EXCEPT returns all rows that are in the result of
+ query1 but not in the result of
+ query2. (This is sometimes called the
+ difference between two queries.) Again, duplicates
+ are eliminated unless EXCEPT ALL is used.
+
+ In order to calculate the union, intersection, or difference of two
+ queries, the two queries must be “union compatible”,
+ which means that they return the same number of columns and
+ the corresponding columns have compatible data types, as
+ described in Section 10.5.
+
+ Set operations can be combined, for example
+
+query1 UNION query2 EXCEPT query3
+
+ which is equivalent to
+
+(query1 UNION query2) EXCEPT query3
+
+ As shown here, you can use parentheses to control the order of
+ evaluation. Without parentheses, UNION
+ and EXCEPT associate left-to-right,
+ but INTERSECT binds more tightly than those two
+ operators. Thus
+
+query1 UNION query2 INTERSECT query3
+
+ means
+
+query1 UNION (query2 INTERSECT query3)
+
+ You can also surround an individual query
+ with parentheses. This is important if
+ the query needs to use any of the clauses
+ discussed in following sections, such as LIMIT.
+ Without parentheses, you'll get a syntax error, or else the clause will
+ be understood as applying to the output of the set operation rather
+ than one of its inputs. For example,
+
+SELECT a FROM b UNION SELECT x FROM y LIMIT 10
+
+ is accepted, but it means
+
+(SELECT a FROM b UNION SELECT x FROM y) LIMIT 10
+
+ not
+
+SELECT a FROM b UNION (SELECT x FROM y LIMIT 10)
+
+
+ VALUES provides a way to generate a “constant table”
+ that can be used in a query without having to actually create and populate
+ a table on-disk. The syntax is
+
+VALUES ( expression [, ...] ) [, ...]
+
+ Each parenthesized list of expressions generates a row in the table.
+ The lists must all have the same number of elements (i.e., the number
+ of columns in the table), and corresponding entries in each list must
+ have compatible data types. The actual data type assigned to each column
+ of the result is determined using the same rules as for UNION
+ (see Section 10.5).
+
+ As an example:
+
+VALUES (1, 'one'), (2, 'two'), (3, 'three');
+
+
+ will return a table of two columns and three rows. It's effectively
+ equivalent to:
+
+SELECT 1 AS column1, 'one' AS column2
+UNION ALL
+SELECT 2, 'two'
+UNION ALL
+SELECT 3, 'three';
+
+
+ By default, PostgreSQL assigns the names
+ column1, column2, etc. to the columns of a
+ VALUES table. The column names are not specified by the
+ SQL standard and different database systems do it differently, so
+ it's usually better to override the default names with a table alias
+ list, like this:
+
+=> SELECT * FROM (VALUES (1, 'one'), (2, 'two'), (3, 'three')) AS t (num,letter);
+ num | letter
+-----+--------
+ 1 | one
+ 2 | two
+ 3 | three
+(3 rows)
+
+
+ Syntactically, VALUES followed by expression lists is
+ treated as equivalent to:
+
+SELECT select_list FROM table_expression
+
+ and can appear anywhere a SELECT can. For example, you can
+ use it as part of a UNION, or attach a
+ sort_specification (ORDER BY,
+ LIMIT, and/or OFFSET) to it. VALUES
+ is most commonly used as the data source in an INSERT command,
+ and next most commonly as a subquery.
+
+ For more information see VALUES.
+
7.8. WITH Queries (Common Table Expressions) #
+ WITH provides a way to write auxiliary statements for use in a
+ larger query. These statements, which are often referred to as Common
+ Table Expressions or CTEs, can be thought of as defining
+ temporary tables that exist just for one query. Each auxiliary statement
+ in a WITH clause can be a SELECT,
+ INSERT, UPDATE, or DELETE; and the
+ WITH clause itself is attached to a primary statement that can
+ be a SELECT, INSERT, UPDATE,
+ DELETE, or MERGE.
+
+ The basic value of SELECT in WITH is to
+ break down complicated queries into simpler parts. An example is:
+
+
+WITH regional_sales AS (
+ SELECT region, SUM(amount) AS total_sales
+ FROM orders
+ GROUP BY region
+), top_regions AS (
+ SELECT region
+ FROM regional_sales
+ WHERE total_sales > (SELECT SUM(total_sales)/10 FROM regional_sales)
+)
+SELECT region,
+ product,
+ SUM(quantity) AS product_units,
+ SUM(amount) AS product_sales
+FROM orders
+WHERE region IN (SELECT region FROM top_regions)
+GROUP BY region, product;
+
+
+ which displays per-product sales totals in only the top sales regions.
+ The WITH clause defines two auxiliary statements named
+ regional_sales and top_regions,
+ where the output of regional_sales is used in
+ top_regions and the output of top_regions
+ is used in the primary SELECT query.
+ This example could have been written without WITH,
+ but we'd have needed two levels of nested sub-SELECTs. It's a bit
+ easier to follow this way.
+
7.8.2. Recursive Queries #
+
+ The optional RECURSIVE modifier changes WITH
+ from a mere syntactic convenience into a feature that accomplishes
+ things not otherwise possible in standard SQL. Using
+ RECURSIVE, a WITH query can refer to its own
+ output. A very simple example is this query to sum the integers from 1
+ through 100:
+
+
+WITH RECURSIVE t(n) AS (
+ VALUES (1)
+ UNION ALL
+ SELECT n+1 FROM t WHERE n < 100
+)
+SELECT sum(n) FROM t;
+
+
+ The general form of a recursive WITH query is always a
+ non-recursive term, then UNION (or
+ UNION ALL), then a
+ recursive term, where only the recursive term can contain
+ a reference to the query's own output. Such a query is executed as
+ follows:
+
Recursive Query Evaluation
+ Evaluate the non-recursive term. For UNION (but not
+ UNION ALL), discard duplicate rows. Include all remaining
+ rows in the result of the recursive query, and also place them in a
+ temporary working table.
+
+ So long as the working table is not empty, repeat these steps:
+
+ Evaluate the recursive term, substituting the current contents of
+ the working table for the recursive self-reference.
+ For UNION (but not UNION ALL), discard
+ duplicate rows and rows that duplicate any previous result row.
+ Include all remaining rows in the result of the recursive query, and
+ also place them in a temporary intermediate table.
+
+ Replace the contents of the working table with the contents of the
+ intermediate table, then empty the intermediate table.
+
Note
+ While RECURSIVE allows queries to be specified
+ recursively, internally such queries are evaluated iteratively.
+
+ In the example above, the working table has just a single row in each step,
+ and it takes on the values from 1 through 100 in successive steps. In
+ the 100th step, there is no output because of the WHERE
+ clause, and so the query terminates.
+
+ Recursive queries are typically used to deal with hierarchical or
+ tree-structured data. A useful example is this query to find all the
+ direct and indirect sub-parts of a product, given only a table that
+ shows immediate inclusions:
+
+
+WITH RECURSIVE included_parts(sub_part, part, quantity) AS (
+ SELECT sub_part, part, quantity FROM parts WHERE part = 'our_product'
+ UNION ALL
+ SELECT p.sub_part, p.part, p.quantity * pr.quantity
+ FROM included_parts pr, parts p
+ WHERE p.part = pr.sub_part
+)
+SELECT sub_part, SUM(quantity) as total_quantity
+FROM included_parts
+GROUP BY sub_part
+
+
+ When computing a tree traversal using a recursive query, you might want to
+ order the results in either depth-first or breadth-first order. This can
+ be done by computing an ordering column alongside the other data columns
+ and using that to sort the results at the end. Note that this does not
+ actually control in which order the query evaluation visits the rows; that
+ is as always in SQL implementation-dependent. This approach merely
+ provides a convenient way to order the results afterwards.
+
+ To create a depth-first order, we compute for each result row an array of
+ rows that we have visited so far. For example, consider the following
+ query that searches a table tree using a
+ link field:
+
+
+WITH RECURSIVE search_tree(id, link, data) AS (
+ SELECT t.id, t.link, t.data
+ FROM tree t
+ UNION ALL
+ SELECT t.id, t.link, t.data
+ FROM tree t, search_tree st
+ WHERE t.id = st.link
+)
+SELECT * FROM search_tree;
+
+
+ To add depth-first ordering information, you can write this:
+
+
+WITH RECURSIVE search_tree(id, link, data, path) AS (
+ SELECT t.id, t.link, t.data, ARRAY[t.id]
+ FROM tree t
+ UNION ALL
+ SELECT t.id, t.link, t.data, path || t.id
+ FROM tree t, search_tree st
+ WHERE t.id = st.link
+)
+SELECT * FROM search_tree ORDER BY path;
+
+
+ In the general case where more than one field needs to be used to identify
+ a row, use an array of rows. For example, if we needed to track fields
+ f1 and f2:
+
+
+WITH RECURSIVE search_tree(id, link, data, path) AS (
+ SELECT t.id, t.link, t.data, ARRAY[ROW(t.f1, t.f2)]
+ FROM tree t
+ UNION ALL
+ SELECT t.id, t.link, t.data, path || ROW(t.f1, t.f2)
+ FROM tree t, search_tree st
+ WHERE t.id = st.link
+)
+SELECT * FROM search_tree ORDER BY path;
+
+
Tip
+ Omit the ROW() syntax in the common case where only one
+ field needs to be tracked. This allows a simple array rather than a
+ composite-type array to be used, gaining efficiency.
+
+ To create a breadth-first order, you can add a column that tracks the depth
+ of the search, for example:
+
+
+WITH RECURSIVE search_tree(id, link, data, depth) AS (
+ SELECT t.id, t.link, t.data, 0
+ FROM tree t
+ UNION ALL
+ SELECT t.id, t.link, t.data, depth + 1
+ FROM tree t, search_tree st
+ WHERE t.id = st.link
+)
+SELECT * FROM search_tree ORDER BY depth;
+
+
+ To get a stable sort, add data columns as secondary sorting columns.
+
Tip
+ The recursive query evaluation algorithm produces its output in
+ breadth-first search order. However, this is an implementation detail and
+ it is perhaps unsound to rely on it. The order of the rows within each
+ level is certainly undefined, so some explicit ordering might be desired
+ in any case.
+
+ There is built-in syntax to compute a depth- or breadth-first sort column.
+ For example:
+
+
+WITH RECURSIVE search_tree(id, link, data) AS (
+ SELECT t.id, t.link, t.data
+ FROM tree t
+ UNION ALL
+ SELECT t.id, t.link, t.data
+ FROM tree t, search_tree st
+ WHERE t.id = st.link
+) SEARCH DEPTH FIRST BY id SET ordercol
+SELECT * FROM search_tree ORDER BY ordercol;
+
+WITH RECURSIVE search_tree(id, link, data) AS (
+ SELECT t.id, t.link, t.data
+ FROM tree t
+ UNION ALL
+ SELECT t.id, t.link, t.data
+ FROM tree t, search_tree st
+ WHERE t.id = st.link
+) SEARCH BREADTH FIRST BY id SET ordercol
+SELECT * FROM search_tree ORDER BY ordercol;
+
+ This syntax is internally expanded to something similar to the above
+ hand-written forms. The SEARCH clause specifies whether
+ depth- or breadth first search is wanted, the list of columns to track for
+ sorting, and a column name that will contain the result data that can be
+ used for sorting. That column will implicitly be added to the output rows
+ of the CTE.
+
7.8.2.2. Cycle Detection #
+ When working with recursive queries it is important to be sure that
+ the recursive part of the query will eventually return no tuples,
+ or else the query will loop indefinitely. Sometimes, using
+ UNION instead of UNION ALL can accomplish this
+ by discarding rows that duplicate previous output rows. However, often a
+ cycle does not involve output rows that are completely duplicate: it may be
+ necessary to check just one or a few fields to see if the same point has
+ been reached before. The standard method for handling such situations is
+ to compute an array of the already-visited values. For example, consider again
+ the following query that searches a table graph using a
+ link field:
+
+
+WITH RECURSIVE search_graph(id, link, data, depth) AS (
+ SELECT g.id, g.link, g.data, 0
+ FROM graph g
+ UNION ALL
+ SELECT g.id, g.link, g.data, sg.depth + 1
+ FROM graph g, search_graph sg
+ WHERE g.id = sg.link
+)
+SELECT * FROM search_graph;
+
+
+ This query will loop if the link relationships contain
+ cycles. Because we require a “depth” output, just changing
+ UNION ALL to UNION would not eliminate the looping.
+ Instead we need to recognize whether we have reached the same row again
+ while following a particular path of links. We add two columns
+ is_cycle and path to the loop-prone query:
+
+
+WITH RECURSIVE search_graph(id, link, data, depth, is_cycle, path) AS (
+ SELECT g.id, g.link, g.data, 0,
+ false,
+ ARRAY[g.id]
+ FROM graph g
+ UNION ALL
+ SELECT g.id, g.link, g.data, sg.depth + 1,
+ g.id = ANY(path),
+ path || g.id
+ FROM graph g, search_graph sg
+ WHERE g.id = sg.link AND NOT is_cycle
+)
+SELECT * FROM search_graph;
+
+
+ Aside from preventing cycles, the array value is often useful in its own
+ right as representing the “path” taken to reach any particular row.
+
+ In the general case where more than one field needs to be checked to
+ recognize a cycle, use an array of rows. For example, if we needed to
+ compare fields f1 and f2:
+
+
+WITH RECURSIVE search_graph(id, link, data, depth, is_cycle, path) AS (
+ SELECT g.id, g.link, g.data, 0,
+ false,
+ ARRAY[ROW(g.f1, g.f2)]
+ FROM graph g
+ UNION ALL
+ SELECT g.id, g.link, g.data, sg.depth + 1,
+ ROW(g.f1, g.f2) = ANY(path),
+ path || ROW(g.f1, g.f2)
+ FROM graph g, search_graph sg
+ WHERE g.id = sg.link AND NOT is_cycle
+)
+SELECT * FROM search_graph;
+
+
Tip
+ Omit the ROW() syntax in the common case where only one field
+ needs to be checked to recognize a cycle. This allows a simple array
+ rather than a composite-type array to be used, gaining efficiency.
+
+ There is built-in syntax to simplify cycle detection. The above query can
+ also be written like this:
+
+WITH RECURSIVE search_graph(id, link, data, depth) AS (
+ SELECT g.id, g.link, g.data, 1
+ FROM graph g
+ UNION ALL
+ SELECT g.id, g.link, g.data, sg.depth + 1
+ FROM graph g, search_graph sg
+ WHERE g.id = sg.link
+) CYCLE id SET is_cycle USING path
+SELECT * FROM search_graph;
+
+ and it will be internally rewritten to the above form. The
+ CYCLE clause specifies first the list of columns to
+ track for cycle detection, then a column name that will show whether a
+ cycle has been detected, and finally the name of another column that will track the
+ path. The cycle and path columns will implicitly be added to the output
+ rows of the CTE.
+
Tip
+ The cycle path column is computed in the same way as the depth-first
+ ordering column show in the previous section. A query can have both a
+ SEARCH and a CYCLE clause, but a
+ depth-first search specification and a cycle detection specification would
+ create redundant computations, so it's more efficient to just use the
+ CYCLE clause and order by the path column. If
+ breadth-first ordering is wanted, then specifying both
+ SEARCH and CYCLE can be useful.
+
+ A helpful trick for testing queries
+ when you are not certain if they might loop is to place a LIMIT
+ in the parent query. For example, this query would loop forever without
+ the LIMIT:
+
+
+WITH RECURSIVE t(n) AS (
+ SELECT 1
+ UNION ALL
+ SELECT n+1 FROM t
+)
+SELECT n FROM t LIMIT 100;
+
+
+ This works because PostgreSQL's implementation
+ evaluates only as many rows of a WITH query as are actually
+ fetched by the parent query. Using this trick in production is not
+ recommended, because other systems might work differently. Also, it
+ usually won't work if you make the outer query sort the recursive query's
+ results or join them to some other table, because in such cases the
+ outer query will usually try to fetch all of the WITH query's
+ output anyway.
+
7.8.3. Common Table Expression Materialization #
+ A useful property of WITH queries is that they are
+ normally evaluated only once per execution of the parent query, even if
+ they are referred to more than once by the parent query or
+ sibling WITH queries.
+ Thus, expensive calculations that are needed in multiple places can be
+ placed within a WITH query to avoid redundant work. Another
+ possible application is to prevent unwanted multiple evaluations of
+ functions with side-effects.
+ However, the other side of this coin is that the optimizer is not able to
+ push restrictions from the parent query down into a multiply-referenced
+ WITH query, since that might affect all uses of the
+ WITH query's output when it should affect only one.
+ The multiply-referenced WITH query will be
+ evaluated as written, without suppression of rows that the parent query
+ might discard afterwards. (But, as mentioned above, evaluation might stop
+ early if the reference(s) to the query demand only a limited number of
+ rows.)
+
+ However, if a WITH query is non-recursive and
+ side-effect-free (that is, it is a SELECT containing
+ no volatile functions) then it can be folded into the parent query,
+ allowing joint optimization of the two query levels. By default, this
+ happens if the parent query references the WITH query
+ just once, but not if it references the WITH query
+ more than once. You can override that decision by
+ specifying MATERIALIZED to force separate calculation
+ of the WITH query, or by specifying NOT
+ MATERIALIZED to force it to be merged into the parent query.
+ The latter choice risks duplicate computation of
+ the WITH query, but it can still give a net savings if
+ each usage of the WITH query needs only a small part
+ of the WITH query's full output.
+
+ A simple example of these rules is
+
+WITH w AS (
+ SELECT * FROM big_table
+)
+SELECT * FROM w WHERE key = 123;
+
+ This WITH query will be folded, producing the same
+ execution plan as
+
+SELECT * FROM big_table WHERE key = 123;
+
+ In particular, if there's an index on key,
+ it will probably be used to fetch just the rows having key =
+ 123. On the other hand, in
+
+WITH w AS (
+ SELECT * FROM big_table
+)
+SELECT * FROM w AS w1 JOIN w AS w2 ON w1.key = w2.ref
+WHERE w2.key = 123;
+
+ the WITH query will be materialized, producing a
+ temporary copy of big_table that is then
+ joined with itself — without benefit of any index. This query
+ will be executed much more efficiently if written as
+
+WITH w AS NOT MATERIALIZED (
+ SELECT * FROM big_table
+)
+SELECT * FROM w AS w1 JOIN w AS w2 ON w1.key = w2.ref
+WHERE w2.key = 123;
+
+ so that the parent query's restrictions can be applied directly
+ to scans of big_table.
+
+ An example where NOT MATERIALIZED could be
+ undesirable is
+
+WITH w AS (
+ SELECT key, very_expensive_function(val) as f FROM some_table
+)
+SELECT * FROM w AS w1 JOIN w AS w2 ON w1.f = w2.f;
+
+ Here, materialization of the WITH query ensures
+ that very_expensive_function is evaluated only
+ once per table row, not twice.
+
+ The examples above only show WITH being used with
+ SELECT, but it can be attached in the same way to
+ INSERT, UPDATE,
+ DELETE, or MERGE.
+ In each case it effectively provides temporary table(s) that can
+ be referred to in the main command.
+
7.8.4. Data-Modifying Statements in WITH #
+ You can use most data-modifying statements (INSERT,
+ UPDATE, or DELETE, but not
+ MERGE) in WITH. This
+ allows you to perform several different operations in the same query.
+ An example is:
+
+
+WITH moved_rows AS (
+ DELETE FROM products
+ WHERE
+ "date" >= '2010-10-01' AND
+ "date" < '2010-11-01'
+ RETURNING *
+)
+INSERT INTO products_log
+SELECT * FROM moved_rows;
+
+
+ This query effectively moves rows from products to
+ products_log. The DELETE in WITH
+ deletes the specified rows from products, returning their
+ contents by means of its RETURNING clause; and then the
+ primary query reads that output and inserts it into
+ products_log.
+
+ A fine point of the above example is that the WITH clause is
+ attached to the INSERT, not the sub-SELECT within
+ the INSERT. This is necessary because data-modifying
+ statements are only allowed in WITH clauses that are attached
+ to the top-level statement. However, normal WITH visibility
+ rules apply, so it is possible to refer to the WITH
+ statement's output from the sub-SELECT.
+
+ Data-modifying statements in WITH usually have
+ RETURNING clauses (see Section 6.4),
+ as shown in the example above.
+ It is the output of the RETURNING clause, not the
+ target table of the data-modifying statement, that forms the temporary
+ table that can be referred to by the rest of the query. If a
+ data-modifying statement in WITH lacks a RETURNING
+ clause, then it forms no temporary table and cannot be referred to in
+ the rest of the query. Such a statement will be executed nonetheless.
+ A not-particularly-useful example is:
+
+
+WITH t AS (
+ DELETE FROM foo
+)
+DELETE FROM bar;
+
+
+ This example would remove all rows from tables foo and
+ bar. The number of affected rows reported to the client
+ would only include rows removed from bar.
+
+ Recursive self-references in data-modifying statements are not
+ allowed. In some cases it is possible to work around this limitation by
+ referring to the output of a recursive WITH, for example:
+
+
+WITH RECURSIVE included_parts(sub_part, part) AS (
+ SELECT sub_part, part FROM parts WHERE part = 'our_product'
+ UNION ALL
+ SELECT p.sub_part, p.part
+ FROM included_parts pr, parts p
+ WHERE p.part = pr.sub_part
+)
+DELETE FROM parts
+ WHERE part IN (SELECT part FROM included_parts);
+
+
+ This query would remove all direct and indirect subparts of a product.
+
+ Data-modifying statements in WITH are executed exactly once,
+ and always to completion, independently of whether the primary query
+ reads all (or indeed any) of their output. Notice that this is different
+ from the rule for SELECT in WITH: as stated in the
+ previous section, execution of a SELECT is carried only as far
+ as the primary query demands its output.
+
+ The sub-statements in WITH are executed concurrently with
+ each other and with the main query. Therefore, when using data-modifying
+ statements in WITH, the order in which the specified updates
+ actually happen is unpredictable. All the statements are executed with
+ the same snapshot (see Chapter 13), so they
+ cannot “see” one another's effects on the target tables. This
+ alleviates the effects of the unpredictability of the actual order of row
+ updates, and means that RETURNING data is the only way to
+ communicate changes between different WITH sub-statements and
+ the main query. An example of this is that in
+
+
+WITH t AS (
+ UPDATE products SET price = price * 1.05
+ RETURNING *
+)
+SELECT * FROM products;
+
+
+ the outer SELECT would return the original prices before the
+ action of the UPDATE, while in
+
+
+WITH t AS (
+ UPDATE products SET price = price * 1.05
+ RETURNING *
+)
+SELECT * FROM t;
+
+
+ the outer SELECT would return the updated data.
+
+ Trying to update the same row twice in a single statement is not
+ supported. Only one of the modifications takes place, but it is not easy
+ (and sometimes not possible) to reliably predict which one. This also
+ applies to deleting a row that was already updated in the same statement:
+ only the update is performed. Therefore you should generally avoid trying
+ to modify a single row twice in a single statement. In particular avoid
+ writing WITH sub-statements that could affect the same rows
+ changed by the main statement or a sibling sub-statement. The effects
+ of such a statement will not be predictable.
+
+ At present, any table used as the target of a data-modifying statement in
+ WITH must not have a conditional rule, nor an ALSO
+ rule, nor an INSTEAD rule that expands to multiple statements.
+
+ The previous chapters explained how to create tables, how to fill
+ them with data, and how to manipulate that data. Now we finally
+ discuss how to retrieve the data from the database.
+
52.1. The Path of a Query #
+ Here we give a short overview of the stages a query has to pass
+ to obtain a result.
+
+ A connection from an application program to the PostgreSQL
+ server has to be established. The application program transmits a
+ query to the server and waits to receive the results sent back by the
+ server.
+
+ The parser stage checks the query
+ transmitted by the application
+ program for correct syntax and creates
+ a query tree.
+
+ The rewrite system takes
+ the query tree created by the parser stage and looks for
+ any rules (stored in the
+ system catalogs) to apply to
+ the query tree. It performs the
+ transformations given in the rule bodies.
+
+ One application of the rewrite system is in the realization of
+ views.
+ Whenever a query against a view
+ (i.e., a virtual table) is made,
+ the rewrite system rewrites the user's query to
+ a query that accesses the base tables given in
+ the view definition instead.
+
+ The planner/optimizer takes
+ the (rewritten) query tree and creates a
+ query plan that will be the input to the
+ executor.
+
+ It does so by first creating all possible paths
+ leading to the same result. For example if there is an index on a
+ relation to be scanned, there are two paths for the
+ scan. One possibility is a simple sequential scan and the other
+ possibility is to use the index. Next the cost for the execution of
+ each path is estimated and the cheapest path is chosen. The cheapest
+ path is expanded into a complete plan that the executor can use.
+
+ The executor recursively steps through
+ the plan tree and
+ retrieves rows in the way represented by the plan.
+ The executor makes use of the
+ storage system while scanning
+ relations, performs sorts and joins,
+ evaluates qualifications and finally hands back the rows derived.
+
+ In the following sections we will cover each of the above listed items
+ in more detail to give a better understanding of PostgreSQL's internal
+ control and data structures.
+
+ To understand how the rule system works it is necessary to know
+ when it is invoked and what its input and results are.
+
+ The rule system is located between the parser and the planner.
+ It takes the output of the parser, one query tree, and the user-defined
+ rewrite rules, which are also
+ query trees with some extra information, and creates zero or more
+ query trees as result. So its input and output are always things
+ the parser itself could have produced and thus, anything it sees
+ is basically representable as an SQL statement.
+
+ Now what is a query tree? It is an internal representation of an
+ SQL statement where the single parts that it is
+ built from are stored separately. These query trees can be shown
+ in the server log if you set the configuration parameters
+ debug_print_parse,
+ debug_print_rewritten, or
+ debug_print_plan. The rule actions are also
+ stored as query trees, in the system catalog
+ pg_rewrite. They are not formatted like
+ the log output, but they contain exactly the same information.
+
+ Reading a raw query tree requires some experience. But since
+ SQL representations of query trees are
+ sufficient to understand the rule system, this chapter will not
+ teach how to read them.
+
+ When reading the SQL representations of the
+ query trees in this chapter it is necessary to be able to identify
+ the parts the statement is broken into when it is in the query tree
+ structure. The parts of a query tree are
+
+
-
+ the command type
+
+ This is a simple value telling which command
+ (SELECT, INSERT,
+ UPDATE, DELETE) produced
+ the query tree.
+
-
+ the range table
+
+
+ The range table is a list of relations that are used in the query.
+ In a SELECT statement these are the relations given after
+ the FROM key word.
+
+ Every range table entry identifies a table or view and tells
+ by which name it is called in the other parts of the query.
+ In the query tree, the range table entries are referenced by
+ number rather than by name, so here it doesn't matter if there
+ are duplicate names as it would in an SQL
+ statement. This can happen after the range tables of rules
+ have been merged in. The examples in this chapter will not have
+ this situation.
+
-
+ the result relation
+
+ This is an index into the range table that identifies the
+ relation where the results of the query go.
+
+ SELECT queries don't have a result
+ relation. (The special case of SELECT INTO is
+ mostly identical to CREATE TABLE followed by
+ INSERT ... SELECT, and is not discussed
+ separately here.)
+
+ For INSERT, UPDATE, and
+ DELETE commands, the result relation is the table
+ (or view!) where the changes are to take effect.
+
-
+ the target list
+
+
+ The target list is a list of expressions that define the
+ result of the query. In the case of a
+ SELECT, these expressions are the ones that
+ build the final output of the query. They correspond to the
+ expressions between the key words SELECT
+ and FROM. (* is just an
+ abbreviation for all the column names of a relation. It is
+ expanded by the parser into the individual columns, so the
+ rule system never sees it.)
+
+ DELETE commands don't need a normal target list
+ because they don't produce any result. Instead, the planner
+ adds a special CTID entry to the empty target list,
+ to allow the executor to find the row to be deleted.
+ (CTID is added when the result relation is an ordinary
+ table. If it is a view, a whole-row variable is added instead, by
+ the rule system, as described in Section 41.2.4.)
+
+ For INSERT commands, the target list describes
+ the new rows that should go into the result relation. It consists of the
+ expressions in the VALUES clause or the ones from the
+ SELECT clause in INSERT
+ ... SELECT. The first step of the rewrite process adds
+ target list entries for any columns that were not assigned to by
+ the original command but have defaults. Any remaining columns (with
+ neither a given value nor a default) will be filled in by the
+ planner with a constant null expression.
+
+ For UPDATE commands, the target list
+ describes the new rows that should replace the old ones. In the
+ rule system, it contains just the expressions from the SET
+ column = expression part of the command. The planner will
+ handle missing columns by inserting expressions that copy the values
+ from the old row into the new one. Just as for DELETE,
+ a CTID or whole-row variable is added so that
+ the executor can identify the old row to be updated.
+
+ Every entry in the target list contains an expression that can
+ be a constant value, a variable pointing to a column of one
+ of the relations in the range table, a parameter, or an expression
+ tree made of function calls, constants, variables, operators, etc.
+
-
+ the qualification
+
+ The query's qualification is an expression much like one of
+ those contained in the target list entries. The result value of
+ this expression is a Boolean that tells whether the operation
+ (INSERT, UPDATE,
+ DELETE, or SELECT) for the
+ final result row should be executed or not. It corresponds to the WHERE clause
+ of an SQL statement.
+
-
+ the join tree
+
+ The query's join tree shows the structure of the FROM clause.
+ For a simple query like SELECT ... FROM a, b, c, the join tree is just
+ a list of the FROM items, because we are allowed to join them in
+ any order. But when JOIN expressions, particularly outer joins,
+ are used, we have to join in the order shown by the joins.
+ In that case, the join tree shows the structure of the JOIN expressions. The
+ restrictions associated with particular JOIN clauses (from ON or
+ USING expressions) are stored as qualification expressions attached
+ to those join-tree nodes. It turns out to be convenient to store
+ the top-level WHERE expression as a qualification attached to the
+ top-level join-tree item, too. So really the join tree represents
+ both the FROM and WHERE clauses of a SELECT.
+
-
+ the others
+
+ The other parts of the query tree like the ORDER BY
+ clause aren't of interest here. The rule system
+ substitutes some entries there while applying rules, but that
+ doesn't have much to do with the fundamentals of the rule
+ system.
+
+
+ Range types are data types representing a range of values of some
+ element type (called the range's subtype).
+ For instance, ranges
+ of timestamp might be used to represent the ranges of
+ time that a meeting room is reserved. In this case the data type
+ is tsrange (short for “timestamp range”),
+ and timestamp is the subtype. The subtype must have
+ a total order so that it is well-defined whether element values are
+ within, before, or after a range of values.
+
+ Range types are useful because they represent many element values in a
+ single range value, and because concepts such as overlapping ranges can
+ be expressed clearly. The use of time and date ranges for scheduling
+ purposes is the clearest example; but price ranges, measurement
+ ranges from an instrument, and so forth can also be useful.
+
+ Every range type has a corresponding multirange type. A multirange is
+ an ordered list of non-contiguous, non-empty, non-null ranges. Most
+ range operators also work on multiranges, and they have a few functions
+ of their own.
+
8.17.1. Built-in Range and Multirange Types #
+ PostgreSQL comes with the following built-in range types:
+
+ int4range — Range of integer,
+ int4multirange — corresponding Multirange
+
+ int8range — Range of bigint,
+ int8multirange — corresponding Multirange
+
+ numrange — Range of numeric,
+ nummultirange — corresponding Multirange
+
+ tsrange — Range of timestamp without time zone,
+ tsmultirange — corresponding Multirange
+
+ tstzrange — Range of timestamp with time zone,
+ tstzmultirange — corresponding Multirange
+
+ daterange — Range of date,
+ datemultirange — corresponding Multirange
+
+ In addition, you can define your own range types;
+ see CREATE TYPE for more information.
+
+
+CREATE TABLE reservation (room int, during tsrange);
+INSERT INTO reservation VALUES
+ (1108, '[2010-01-01 14:30, 2010-01-01 15:30)');
+
+-- Containment
+SELECT int4range(10, 20) @> 3;
+
+-- Overlaps
+SELECT numrange(11.1, 22.2) && numrange(20.0, 30.0);
+
+-- Extract the upper bound
+SELECT upper(int8range(15, 25));
+
+-- Compute the intersection
+SELECT int4range(10, 20) * int4range(15, 25);
+
+-- Is the range empty?
+SELECT isempty(numrange(1, 5));
+
+
+ See Table 9.55
+ and Table 9.57 for complete lists of
+ operators and functions on range types.
+
8.17.3. Inclusive and Exclusive Bounds #
+ Every non-empty range has two bounds, the lower bound and the upper
+ bound. All points between these values are included in the range. An
+ inclusive bound means that the boundary point itself is included in
+ the range as well, while an exclusive bound means that the boundary
+ point is not included in the range.
+
+ In the text form of a range, an inclusive lower bound is represented by
+ “[” while an exclusive lower bound is
+ represented by “(”. Likewise, an inclusive upper bound is represented by
+ “]”, while an exclusive upper bound is
+ represented by “)”.
+ (See Section 8.17.5 for more details.)
+
+ The functions lower_inc
+ and upper_inc test the inclusivity of the lower
+ and upper bounds of a range value, respectively.
+
8.17.4. Infinite (Unbounded) Ranges #
+ The lower bound of a range can be omitted, meaning that all
+ values less than the upper bound are included in the range, e.g.,
+ (,3]. Likewise, if the upper bound of the range
+ is omitted, then all values greater than the lower bound are included
+ in the range. If both lower and upper bounds are omitted, all values
+ of the element type are considered to be in the range. Specifying a
+ missing bound as inclusive is automatically converted to exclusive,
+ e.g., [,] is converted to (,).
+ You can think of these missing values as +/-infinity, but they are
+ special range type values and are considered to be beyond any range
+ element type's +/-infinity values.
+
+ Element types that have the notion of “infinity” can
+ use them as explicit bound values. For example, with timestamp
+ ranges, [today,infinity) excludes the special
+ timestamp value infinity,
+ while [today,infinity] include it, as does
+ [today,) and [today,].
+
+ The functions lower_inf
+ and upper_inf test for infinite lower
+ and upper bounds of a range, respectively.
+
8.17.5. Range Input/Output #
+ The input for a range value must follow one of the following patterns:
+
+(lower-bound,upper-bound)
+(lower-bound,upper-bound]
+[lower-bound,upper-bound)
+[lower-bound,upper-bound]
+empty
+
+ The parentheses or brackets indicate whether the lower and upper bounds
+ are exclusive or inclusive, as described previously.
+ Notice that the final pattern is empty, which
+ represents an empty range (a range that contains no points).
+
+ The lower-bound may be either a string
+ that is valid input for the subtype, or empty to indicate no
+ lower bound. Likewise, upper-bound may be
+ either a string that is valid input for the subtype, or empty to
+ indicate no upper bound.
+
+ Each bound value can be quoted using " (double quote)
+ characters. This is necessary if the bound value contains parentheses,
+ brackets, commas, double quotes, or backslashes, since these characters
+ would otherwise be taken as part of the range syntax. To put a double
+ quote or backslash in a quoted bound value, precede it with a
+ backslash. (Also, a pair of double quotes within a double-quoted bound
+ value is taken to represent a double quote character, analogously to the
+ rules for single quotes in SQL literal strings.) Alternatively, you can
+ avoid quoting and use backslash-escaping to protect all data characters
+ that would otherwise be taken as range syntax. Also, to write a bound
+ value that is an empty string, write "", since writing
+ nothing means an infinite bound.
+
+ Whitespace is allowed before and after the range value, but any whitespace
+ between the parentheses or brackets is taken as part of the lower or upper
+ bound value. (Depending on the element type, it might or might not be
+ significant.)
+
Note
+ These rules are very similar to those for writing field values in
+ composite-type literals. See Section 8.16.6 for
+ additional commentary.
+
+ Examples:
+
+-- includes 3, does not include 7, and does include all points in between
+SELECT '[3,7)'::int4range;
+
+-- does not include either 3 or 7, but includes all points in between
+SELECT '(3,7)'::int4range;
+
+-- includes only the single point 4
+SELECT '[4,4]'::int4range;
+
+-- includes no points (and will be normalized to 'empty')
+SELECT '[4,4)'::int4range;
+
+
+ The input for a multirange is curly brackets ({ and
+ }) containing zero or more valid ranges,
+ separated by commas. Whitespace is permitted around the brackets and
+ commas. This is intended to be reminiscent of array syntax, although
+ multiranges are much simpler: they have just one dimension and there is
+ no need to quote their contents. (The bounds of their ranges may be
+ quoted as above however.)
+
+ Examples:
+
+SELECT '{}'::int4multirange;
+SELECT '{[3,7)}'::int4multirange;
+SELECT '{[3,7), [8,9)}'::int4multirange;
+
+
8.17.6. Constructing Ranges and Multiranges #
+ Each range type has a constructor function with the same name as the range
+ type. Using the constructor function is frequently more convenient than
+ writing a range literal constant, since it avoids the need for extra
+ quoting of the bound values. The constructor function
+ accepts two or three arguments. The two-argument form constructs a range
+ in standard form (lower bound inclusive, upper bound exclusive), while
+ the three-argument form constructs a range with bounds of the form
+ specified by the third argument.
+ The third argument must be one of the strings
+ “()”,
+ “(]”,
+ “[)”, or
+ “[]”.
+ For example:
+
+
+-- The full form is: lower bound, upper bound, and text argument indicating
+-- inclusivity/exclusivity of bounds.
+SELECT numrange(1.0, 14.0, '(]');
+
+-- If the third argument is omitted, '[)' is assumed.
+SELECT numrange(1.0, 14.0);
+
+-- Although '(]' is specified here, on display the value will be converted to
+-- canonical form, since int8range is a discrete range type (see below).
+SELECT int8range(1, 14, '(]');
+
+-- Using NULL for either bound causes the range to be unbounded on that side.
+SELECT numrange(NULL, 2.2);
+
+
+ Each range type also has a multirange constructor with the same name as the
+ multirange type. The constructor function takes zero or more arguments
+ which are all ranges of the appropriate type.
+ For example:
+
+
+SELECT nummultirange();
+SELECT nummultirange(numrange(1.0, 14.0));
+SELECT nummultirange(numrange(1.0, 14.0), numrange(20.0, 25.0));
+
+
8.17.7. Discrete Range Types #
+ A discrete range is one whose element type has a well-defined
+ “step”, such as integer or date.
+ In these types two elements can be said to be adjacent, when there are
+ no valid values between them. This contrasts with continuous ranges,
+ where it's always (or almost always) possible to identify other element
+ values between two given values. For example, a range over the
+ numeric type is continuous, as is a range over timestamp.
+ (Even though timestamp has limited precision, and so could
+ theoretically be treated as discrete, it's better to consider it continuous
+ since the step size is normally not of interest.)
+
+ Another way to think about a discrete range type is that there is a clear
+ idea of a “next” or “previous” value for each element value.
+ Knowing that, it is possible to convert between inclusive and exclusive
+ representations of a range's bounds, by choosing the next or previous
+ element value instead of the one originally given.
+ For example, in an integer range type [4,8] and
+ (3,9) denote the same set of values; but this would not be so
+ for a range over numeric.
+
+ A discrete range type should have a canonicalization
+ function that is aware of the desired step size for the element type.
+ The canonicalization function is charged with converting equivalent values
+ of the range type to have identical representations, in particular
+ consistently inclusive or exclusive bounds.
+ If a canonicalization function is not specified, then ranges with different
+ formatting will always be treated as unequal, even though they might
+ represent the same set of values in reality.
+
+ The built-in range types int4range, int8range,
+ and daterange all use a canonical form that includes
+ the lower bound and excludes the upper bound; that is,
+ [). User-defined range types can use other conventions,
+ however.
+
8.17.8. Defining New Range Types #
+ Users can define their own range types. The most common reason to do
+ this is to use ranges over subtypes not provided among the built-in
+ range types.
+ For example, to define a new range type of subtype float8:
+
+
+CREATE TYPE floatrange AS RANGE (
+ subtype = float8,
+ subtype_diff = float8mi
+);
+
+SELECT '[1.234, 5.678]'::floatrange;
+
+
+ Because float8 has no meaningful
+ “step”, we do not define a canonicalization
+ function in this example.
+
+ When you define your own range you automatically get a corresponding
+ multirange type.
+
+ Defining your own range type also allows you to specify a different
+ subtype B-tree operator class or collation to use, so as to change the sort
+ ordering that determines which values fall into a given range.
+
+ If the subtype is considered to have discrete rather than continuous
+ values, the CREATE TYPE command should specify a
+ canonical function.
+ The canonicalization function takes an input range value, and must return
+ an equivalent range value that may have different bounds and formatting.
+ The canonical output for two ranges that represent the same set of values,
+ for example the integer ranges [1, 7] and [1,
+ 8), must be identical. It doesn't matter which representation
+ you choose to be the canonical one, so long as two equivalent values with
+ different formattings are always mapped to the same value with the same
+ formatting. In addition to adjusting the inclusive/exclusive bounds
+ format, a canonicalization function might round off boundary values, in
+ case the desired step size is larger than what the subtype is capable of
+ storing. For instance, a range type over timestamp could be
+ defined to have a step size of an hour, in which case the canonicalization
+ function would need to round off bounds that weren't a multiple of an hour,
+ or perhaps throw an error instead.
+
+ In addition, any range type that is meant to be used with GiST or SP-GiST
+ indexes should define a subtype difference, or subtype_diff,
+ function. (The index will still work without subtype_diff,
+ but it is likely to be considerably less efficient than if a difference
+ function is provided.) The subtype difference function takes two input
+ values of the subtype, and returns their difference
+ (i.e., X minus Y) represented as
+ a float8 value. In our example above, the
+ function float8mi that underlies the regular float8
+ minus operator can be used; but for any other subtype, some type
+ conversion would be necessary. Some creative thought about how to
+ represent differences as numbers might be needed, too. To the greatest
+ extent possible, the subtype_diff function should agree with
+ the sort ordering implied by the selected operator class and collation;
+ that is, its result should be positive whenever its first argument is
+ greater than its second according to the sort ordering.
+
+ A less-oversimplified example of a subtype_diff function is:
+
+CREATE FUNCTION time_subtype_diff(x time, y time) RETURNS float8 AS
+'SELECT EXTRACT(EPOCH FROM (x - y))' LANGUAGE sql STRICT IMMUTABLE;
+
+CREATE TYPE timerange AS RANGE (
+ subtype = time,
+ subtype_diff = time_subtype_diff
+);
+
+SELECT '[11:10, 23:00]'::timerange;
+
+ See CREATE TYPE for more information about creating
+ range types.
+
+ GiST and SP-GiST indexes can be created for table columns of range types.
+ GiST indexes can be also created for table columns of multirange types.
+ For instance, to create a GiST index:
+
+CREATE INDEX reservation_idx ON reservation USING GIST (during);
+
+ A GiST or SP-GiST index on ranges can accelerate queries involving these
+ range operators:
+ =,
+ &&,
+ <@,
+ @>,
+ <<,
+ >>,
+ -|-,
+ &<, and
+ &>.
+ A GiST index on multiranges can accelerate queries involving the same
+ set of multirange operators.
+ A GiST index on ranges and GiST index on multiranges can also accelerate
+ queries involving these cross-type range to multirange and multirange to
+ range operators correspondingly:
+ &&,
+ <@,
+ @>,
+ <<,
+ >>,
+ -|-,
+ &<, and
+ &>.
+ See Table 9.55 for more information.
+
+ In addition, B-tree and hash indexes can be created for table columns of
+ range types. For these index types, basically the only useful range
+ operation is equality. There is a B-tree sort ordering defined for range
+ values, with corresponding < and > operators,
+ but the ordering is rather arbitrary and not usually useful in the real
+ world. Range types' B-tree and hash support is primarily meant to
+ allow sorting and hashing internally in queries, rather than creation of
+ actual indexes.
+
8.17.10. Constraints on Ranges #
+ While UNIQUE is a natural constraint for scalar
+ values, it is usually unsuitable for range types. Instead, an
+ exclusion constraint is often more appropriate
+ (see CREATE TABLE
+ ... CONSTRAINT ... EXCLUDE). Exclusion constraints allow the
+ specification of constraints such as “non-overlapping” on a
+ range type. For example:
+
+
+CREATE TABLE reservation (
+ during tsrange,
+ EXCLUDE USING GIST (during WITH &&)
+);
+
+
+ That constraint will prevent any overlapping values from existing
+ in the table at the same time:
+
+
+INSERT INTO reservation VALUES
+ ('[2010-01-01 11:30, 2010-01-01 15:00)');
+INSERT 0 1
+
+INSERT INTO reservation VALUES
+ ('[2010-01-01 14:45, 2010-01-01 15:45)');
+ERROR: conflicting key value violates exclusion constraint "reservation_during_excl"
+DETAIL: Key (during)=(["2010-01-01 14:45:00","2010-01-01 15:45:00")) conflicts
+with existing key (during)=(["2010-01-01 11:30:00","2010-01-01 15:00:00")).
+
+
+ You can use the btree_gist
+ extension to define exclusion constraints on plain scalar data types, which
+ can then be combined with range exclusions for maximum flexibility. For
+ example, after btree_gist is installed, the following
+ constraint will reject overlapping ranges only if the meeting room numbers
+ are equal:
+
+
+CREATE EXTENSION btree_gist;
+CREATE TABLE room_reservation (
+ room text,
+ during tsrange,
+ EXCLUDE USING GIST (room WITH =, during WITH &&)
+);
+
+INSERT INTO room_reservation VALUES
+ ('123A', '[2010-01-01 14:00, 2010-01-01 15:00)');
+INSERT 0 1
+
+INSERT INTO room_reservation VALUES
+ ('123A', '[2010-01-01 14:30, 2010-01-01 15:30)');
+ERROR: conflicting key value violates exclusion constraint "room_reservation_room_during_excl"
+DETAIL: Key (room, during)=(123A, ["2010-01-01 14:30:00","2010-01-01 15:30:00")) conflicts
+with existing key (room, during)=(123A, ["2010-01-01 14:00:00","2010-01-01 15:00:00")).
+
+INSERT INTO room_reservation VALUES
+ ('123B', '[2010-01-01 14:30, 2010-01-01 15:30)');
+INSERT 0 1
+
+
O.1. recovery.conf file merged into postgresql.conf #
+ PostgreSQL 11 and below used a configuration file named
+ recovery.conf
+
+ to manage replicas and standbys. Support for this file was removed in PostgreSQL 12. See
+ the release notes for PostgreSQL 12 for details
+ on this change.
+
+ On PostgreSQL 12 and above,
+ archive recovery, streaming replication, and PITR
+ are configured using
+ normal server configuration parameters.
+ These are set in postgresql.conf or via
+ ALTER SYSTEM
+ like any other parameter.
+
+ The server will not start if a recovery.conf exists.
+
+ PostgreSQL 15 and below had a setting
+ promote_trigger_file, or
+ trigger_file before 12.
+ Use pg_ctl promote or call
+ pg_promote() to promote a standby instead.
+
+ The
+ standby_mode
+
+ setting has been removed. A standby.signal file in the data directory
+ is used instead. See Standby Server Operation for details.
+
PostgreSQL Client Applications
+ This part contains reference information for
+ PostgreSQL client applications and
+ utilities. Not all of these commands are of general utility; some
+ might require special privileges. The common feature of these
+ applications is that they can be run on any host, independent of
+ where the database server resides.
+
+ When specified on the command line, user and database names have
+ their case preserved — the presence of spaces or special
+ characters might require quoting. Table names and other identifiers
+ do not have their case preserved, except where documented, and
+ might require quoting.
+
Table of Contents
- clusterdb — cluster a PostgreSQL database
- createdb — create a new PostgreSQL database
- createuser — define a new PostgreSQL user account
- dropdb — remove a PostgreSQL database
- dropuser — remove a PostgreSQL user account
- ecpg — embedded SQL C preprocessor
- pg_amcheck — checks for corruption in one or more
+ PostgreSQL databases
- pg_basebackup — take a base backup of a PostgreSQL cluster
- pgbench — run a benchmark test on PostgreSQL
- pg_config — retrieve information about the installed version of PostgreSQL
- pg_dump —
+ extract a PostgreSQL database into a script file or other archive file
+
- pg_dumpall — extract a PostgreSQL database cluster into a script file
- pg_isready — check the connection status of a PostgreSQL server
- pg_receivewal — stream write-ahead logs from a PostgreSQL server
- pg_recvlogical — control PostgreSQL logical decoding streams
- pg_restore —
+ restore a PostgreSQL database from an
+ archive file created by pg_dump
+
- pg_verifybackup — verify the integrity of a base backup of a
+ PostgreSQL cluster
- psql —
+ PostgreSQL interactive terminal
+
- reindexdb — reindex a PostgreSQL database
- vacuumdb — garbage-collect and analyze a PostgreSQL database
PostgreSQL Server Applications
+ This part contains reference information for
+ PostgreSQL server applications and
+ support utilities. These commands can only be run usefully on the
+ host where the database server resides. Other utility programs
+ are listed in PostgreSQL Client Applications.
+
Table of Contents
- initdb — create a new PostgreSQL database cluster
- pg_archivecleanup — clean up PostgreSQL WAL archive files
- pg_checksums — enable, disable or check data checksums in a PostgreSQL database cluster
- pg_controldata — display control information of a PostgreSQL database cluster
- pg_ctl — initialize, start, stop, or control a PostgreSQL server
- pg_resetwal — reset the write-ahead log and other control information of a PostgreSQL database cluster
- pg_rewind — synchronize a PostgreSQL data directory with another data directory that was forked from it
- pg_test_fsync — determine fastest
wal_sync_method for PostgreSQL - pg_test_timing — measure timing overhead
- pg_upgrade — upgrade a PostgreSQL server instance
- pg_waldump — display a human-readable rendering of the write-ahead log of a PostgreSQL database cluster
- postgres — PostgreSQL database server
+ The entries in this Reference are meant to provide in reasonable
+ length an authoritative, complete, and formal summary about their
+ respective subjects. More information about the use of
+ PostgreSQL, in narrative, tutorial, or
+ example form, can be found in other parts of this book. See the
+ cross-references listed on each reference page.
+
+ The reference entries are also available as traditional
+ “man” pages.
+
33.5. Test Coverage Examination #
+ The PostgreSQL source code can be compiled with coverage testing
+ instrumentation, so that it becomes possible to examine which
+ parts of the code are covered by the regression tests or any other
+ test suite that is run with the code. This is currently supported
+ when compiling with GCC, and it requires the gcov
+ and lcov packages.
+
33.5.2. Coverage with Meson #
+ A typical workflow looks like this:
+
+meson setup -Db_coverage=true ... OTHER OPTIONS ... builddir/
+meson compile -C builddir/
+meson test -C builddir/
+cd builddir/
+ninja coverage-html
+
+ Then point your HTML browser
+ to ./meson-logs/coveragereport/index.html.
+
+ You can run several different tests before making the coverage report;
+ the execution counts will accumulate.
+
+ Some properly installed and fully functional
+ PostgreSQL installations can
+ “fail” some of these regression tests due to
+ platform-specific artifacts such as varying floating-point representation
+ and message wording. The tests are currently evaluated using a simple
+ diff comparison against the outputs
+ generated on a reference system, so the results are sensitive to
+ small system differences. When a test is reported as
+ “failed”, always examine the differences between
+ expected and actual results; you might find that the
+ differences are not significant. Nonetheless, we still strive to
+ maintain accurate reference files across all supported platforms,
+ so it can be expected that all tests pass.
+
+ The actual outputs of the regression tests are in files in the
+ src/test/regress/results directory. The test
+ script uses diff to compare each output
+ file against the reference outputs stored in the
+ src/test/regress/expected directory. Any
+ differences are saved for your inspection in
+ src/test/regress/regression.diffs.
+ (When running a test suite other than the core tests, these files
+ of course appear in the relevant subdirectory,
+ not src/test/regress.)
+
+ If you don't
+ like the diff options that are used by default, set the
+ environment variable PG_REGRESS_DIFF_OPTS, for
+ instance PG_REGRESS_DIFF_OPTS='-c'. (Or you
+ can run diff yourself, if you prefer.)
+
+ If for some reason a particular platform generates a “failure”
+ for a given test, but inspection of the output convinces you that
+ the result is valid, you can add a new comparison file to silence
+ the failure report in future test runs. See
+ Section 33.3 for details.
+
33.2.1. Error Message Differences #
+ Some of the regression tests involve intentional invalid input
+ values. Error messages can come from either the
+ PostgreSQL code or from the host
+ platform system routines. In the latter case, the messages can
+ vary between platforms, but should reflect similar
+ information. These differences in messages will result in a
+ “failed” regression test that can be validated by
+ inspection.
+
33.2.2. Locale Differences #
+ If you run the tests against a server that was
+ initialized with a collation-order locale other than C, then
+ there might be differences due to sort order and subsequent
+ failures. The regression test suite is set up to handle this
+ problem by providing alternate result files that together are
+ known to handle a large number of locales.
+
+ To run the tests in a different locale when using the
+ temporary-installation method, pass the appropriate
+ locale-related environment variables on
+ the make command line, for example:
+
+make check LANG=de_DE.utf8
+
+ (The regression test driver unsets LC_ALL, so it
+ does not work to choose the locale using that variable.) To use
+ no locale, either unset all locale-related environment variables
+ (or set them to C) or use the following
+ special invocation:
+
+make check NO_LOCALE=1
+
+ When running the tests against an existing installation, the
+ locale setup is determined by the existing installation. To
+ change it, initialize the database cluster with a different
+ locale by passing the appropriate options
+ to initdb.
+
+ In general, it is advisable to try to run the
+ regression tests in the locale setup that is wanted for
+ production use, as this will exercise the locale- and
+ encoding-related code portions that will actually be used in
+ production. Depending on the operating system environment, you
+ might get failures, but then you will at least know what
+ locale-specific behaviors to expect when running real
+ applications.
+
33.2.3. Date and Time Differences #
+ Most of the date and time results are dependent on the time zone
+ environment. The reference files are generated for time zone
+ PST8PDT (Berkeley, California), and there will be
+ apparent failures if the tests are not run with that time zone setting.
+ The regression test driver sets environment variable
+ PGTZ to PST8PDT, which normally
+ ensures proper results.
+
33.2.4. Floating-Point Differences #
+ Some of the tests involve computing 64-bit floating-point numbers (double
+ precision) from table columns. Differences in
+ results involving mathematical functions of double
+ precision columns have been observed. The float8 and
+ geometry tests are particularly prone to small differences
+ across platforms, or even with different compiler optimization settings.
+ Human eyeball comparison is needed to determine the real
+ significance of these differences which are usually 10 places to
+ the right of the decimal point.
+
+ Some systems display minus zero as -0, while others
+ just show 0.
+
+ Some systems signal errors from pow() and
+ exp() differently from the mechanism
+ expected by the current PostgreSQL
+ code.
+
33.2.5. Row Ordering Differences #
+You might see differences in which the same rows are output in a
+different order than what appears in the expected file. In most cases
+this is not, strictly speaking, a bug. Most of the regression test
+scripts are not so pedantic as to use an ORDER BY for every single
+SELECT, and so their result row orderings are not well-defined
+according to the SQL specification. In practice, since we are
+looking at the same queries being executed on the same data by the same
+software, we usually get the same result ordering on all platforms,
+so the lack of ORDER BY is not a problem. Some queries do exhibit
+cross-platform ordering differences, however. When testing against an
+already-installed server, ordering differences can also be caused by
+non-C locale settings or non-default parameter settings, such as custom values
+of work_mem or the planner cost parameters.
+
+Therefore, if you see an ordering difference, it's not something to
+worry about, unless the query does have an ORDER BY that your
+result is violating. However, please report it anyway, so that we can add an
+ORDER BY to that particular query to eliminate the bogus
+“failure” in future releases.
+
+You might wonder why we don't order all the regression test queries explicitly
+to get rid of this issue once and for all. The reason is that that would
+make the regression tests less useful, not more, since they'd tend
+to exercise query plan types that produce ordered results to the
+exclusion of those that don't.
+
33.2.6. Insufficient Stack Depth #
+ If the errors test results in a server crash
+ at the select infinite_recurse() command, it means that
+ the platform's limit on process stack size is smaller than the
+ max_stack_depth parameter indicates. This
+ can be fixed by running the server under a higher stack
+ size limit (4MB is recommended with the default value of
+ max_stack_depth). If you are unable to do that, an
+ alternative is to reduce the value of max_stack_depth.
+
+ On platforms supporting getrlimit(), the server should
+ automatically choose a safe value of max_stack_depth;
+ so unless you've manually overridden this setting, a failure of this
+ kind is a reportable bug.
+
33.2.7. The “random” Test #
+ The random test script is intended to produce
+ random results. In very rare cases, this causes that regression
+ test to fail. Typing:
+
+diff results/random.out expected/random.out
+
+ should produce only one or a few lines of differences. You need
+ not worry unless the random test fails repeatedly.
+
33.2.8. Configuration Parameters #
+ When running the tests against an existing installation, some non-default
+ parameter settings could cause the tests to fail. For example, changing
+ parameters such as enable_seqscan or
+ enable_indexscan could cause plan changes that would
+ affect the results of tests that use EXPLAIN.
+
33.1. Running the Tests #
+ The regression tests can be run against an already installed and
+ running server, or using a temporary installation within the build
+ tree. Furthermore, there is a “parallel” and a
+ “sequential” mode for running the tests. The
+ sequential method runs each test script alone, while the
+ parallel method starts up multiple server processes to run groups
+ of tests in parallel. Parallel testing adds confidence that
+ interprocess communication and locking are working correctly.
+ Some tests may run sequentially even in the “parallel”
+ mode in case this is required by the test.
+
33.1.1. Running the Tests Against a Temporary Installation #
+ To run the parallel regression tests after building but before installation,
+ type:
+
+make check
+
+ in the top-level directory. (Or you can change to
+ src/test/regress and run the command there.)
+ Tests which are run in parallel are prefixed with “+”, and
+ tests which run sequentially are prefixed with “-”.
+ At the end you should see something like:
+
+
+# All 213 tests passed.
+
+
+ or otherwise a note about which tests failed. See Section 33.2 below before assuming that a
+ “failure” represents a serious problem.
+
+ Because this test method runs a temporary server, it will not work
+ if you did the build as the root user, since the server will not start as
+ root. Recommended procedure is not to do the build as root, or else to
+ perform testing after completing the installation.
+
+ If you have configured PostgreSQL to install
+ into a location where an older PostgreSQL
+ installation already exists, and you perform make check
+ before installing the new version, you might find that the tests fail
+ because the new programs try to use the already-installed shared
+ libraries. (Typical symptoms are complaints about undefined symbols.)
+ If you wish to run the tests before overwriting the old installation,
+ you'll need to build with configure --disable-rpath.
+ It is not recommended that you use this option for the final installation,
+ however.
+
+ The parallel regression test starts quite a few processes under your
+ user ID. Presently, the maximum concurrency is twenty parallel test
+ scripts, which means forty processes: there's a server process and a
+ psql process for each test script.
+ So if your system enforces a per-user limit on the number of processes,
+ make sure this limit is at least fifty or so, else you might get
+ random-seeming failures in the parallel test. If you are not in
+ a position to raise the limit, you can cut down the degree of parallelism
+ by setting the MAX_CONNECTIONS parameter. For example:
+
+make MAX_CONNECTIONS=10 check
+
+ runs no more than ten tests concurrently.
+
33.1.2. Running the Tests Against an Existing Installation #
+ To run the tests after installation (see Chapter 17),
+ initialize a data directory and start the
+ server as explained in Chapter 19, then type:
+
+make installcheck
+
+or for a parallel test:
+
+make installcheck-parallel
+
+ The tests will expect to contact the server at the local host and the
+ default port number, unless directed otherwise by PGHOST and
+ PGPORT environment variables. The tests will be run in a
+ database named regression; any existing database by this name
+ will be dropped.
+
+ The tests will also transiently create some cluster-wide objects, such as
+ roles, tablespaces, and subscriptions. These objects will have names
+ beginning with regress_. Beware of
+ using installcheck mode with an installation that has
+ any actual global objects named that way.
+
33.1.3. Additional Test Suites #
+ The make check and make installcheck commands
+ run only the “core” regression tests, which test built-in
+ functionality of the PostgreSQL server. The source
+ distribution contains many additional test suites, most of them having
+ to do with add-on functionality such as optional procedural languages.
+
+ To run all test suites applicable to the modules that have been selected
+ to be built, including the core tests, type one of these commands at the
+ top of the build tree:
+
+make check-world
+make installcheck-world
+
+ These commands run the tests using temporary servers or an
+ already-installed server, respectively, just as previously explained
+ for make check and make installcheck. Other
+ considerations are the same as previously explained for each method.
+ Note that make check-world builds a separate instance
+ (temporary data directory) for each tested module, so it requires more
+ time and disk space than make installcheck-world.
+
+ On a modern machine with multiple CPU cores and no tight operating-system
+ limits, you can make things go substantially faster with parallelism.
+ The recipe that most PostgreSQL developers actually use for running all
+ tests is something like
+
+make check-world -j8 >/dev/null
+
+ with a -j limit near to or a bit more than the number
+ of available cores. Discarding stdout
+ eliminates chatter that's not interesting when you just want to verify
+ success. (In case of failure, the stderr
+ messages are usually enough to determine where to look closer.)
+
+ Alternatively, you can run individual test suites by typing
+ make check or make installcheck in the appropriate
+ subdirectory of the build tree. Keep in mind that make
+ installcheck assumes you've installed the relevant module(s), not
+ only the core server.
+
+ The additional tests that can be invoked this way include:
+
+ Regression tests for optional procedural languages.
+ These are located under src/pl.
+
+ Regression tests for contrib modules,
+ located under contrib.
+ Not all contrib modules have tests.
+
+ Regression tests for the interface libraries,
+ located in src/interfaces/libpq/test and
+ src/interfaces/ecpg/test.
+
+ Tests for core-supported authentication methods,
+ located in src/test/authentication.
+ (See below for additional authentication-related tests.)
+
+ Tests stressing behavior of concurrent sessions,
+ located in src/test/isolation.
+
+ Tests for crash recovery and physical replication,
+ located in src/test/recovery.
+
+ Tests for logical replication,
+ located in src/test/subscription.
+
+ Tests of client programs, located under src/bin.
+
+ When using installcheck mode, these tests will create
+ and destroy test databases whose names
+ include regression, for
+ example pl_regression
+ or contrib_regression. Beware of
+ using installcheck mode with an installation that has
+ any non-test databases named that way.
+
+ Some of these auxiliary test suites use the TAP infrastructure explained
+ in Section 33.4.
+ The TAP-based tests are run only when PostgreSQL was configured with the
+ option --enable-tap-tests. This is recommended for
+ development, but can be omitted if there is no suitable Perl installation.
+
+ Some test suites are not run by default, either because they are not secure
+ to run on a multiuser system, because they require special software or
+ because they are resource intensive. You can decide which test suites to
+ run additionally by setting the make or environment
+ variable PG_TEST_EXTRA to a whitespace-separated list,
+ for example:
+
+make check-world PG_TEST_EXTRA='kerberos ldap ssl load_balance'
+
+ The following values are currently supported:
+
kerberos
+ Runs the test suite under src/test/kerberos. This
+ requires an MIT Kerberos installation and opens TCP/IP listen sockets.
+
ldap
+ Runs the test suite under src/test/ldap. This
+ requires an OpenLDAP installation and opens
+ TCP/IP listen sockets.
+
ssl
+ Runs the test suite under src/test/ssl. This opens TCP/IP listen sockets.
+
load_balance
+ Runs the test src/interfaces/libpq/t/004_load_balance_dns.pl.
+ This requires editing the system hosts file and
+ opens TCP/IP listen sockets.
+
wal_consistency_checking
+ Uses wal_consistency_checking=all while running
+ certain tests under src/test/recovery. Not
+ enabled by default because it is resource intensive.
+
+
+ Tests for features that are not supported by the current build
+ configuration are not run even if they are mentioned in
+ PG_TEST_EXTRA.
+
+ In addition, there are tests in src/test/modules
+ which will be run by make check-world but not
+ by make installcheck-world. This is because they
+ install non-production extensions or have other side-effects that are
+ considered undesirable for a production installation. You can
+ use make install and make
+ installcheck in one of those subdirectories if you wish,
+ but it's not recommended to do so with a non-test server.
+
33.1.4. Locale and Encoding #
+ By default, tests using a temporary installation use the
+ locale defined in the current environment and the corresponding
+ database encoding as determined by initdb. It
+ can be useful to test different locales by setting the appropriate
+ environment variables, for example:
+
+make check LANG=C
+make check LC_COLLATE=en_US.utf8 LC_CTYPE=fr_CA.utf8
+
+ For implementation reasons, setting LC_ALL does not
+ work for this purpose; all the other locale-related environment
+ variables do work.
+
+ When testing against an existing installation, the locale is
+ determined by the existing database cluster and cannot be set
+ separately for the test run.
+
+ You can also choose the database encoding explicitly by setting
+ the variable ENCODING, for example:
+
+make check LANG=C ENCODING=EUC_JP
+
+ Setting the database encoding this way typically only makes sense
+ if the locale is C; otherwise the encoding is chosen automatically
+ from the locale, and specifying an encoding that does not match
+ the locale will result in an error.
+
+ The database encoding can be set for tests against either a temporary or
+ an existing installation, though in the latter case it must be
+ compatible with the installation's locale.
+
33.1.5. Custom Server Settings #
+ Custom server settings to use when running a regression test suite can be
+ set in the PGOPTIONS environment variable (for settings
+ that allow this):
+
+make check PGOPTIONS="-c debug_parallel_query=regress -c work_mem=50MB"
+
+ When running against a temporary installation, custom settings can also be
+ set by supplying a pre-written postgresql.conf:
+
+echo 'log_checkpoints = on' > test_postgresql.conf
+echo 'work_mem = 50MB' >> test_postgresql.conf
+make check EXTRA_REGRESS_OPTS="--temp-config=test_postgresql.conf"
+
+
+ This can be useful to enable additional logging, adjust resource limits,
+ or enable extra run-time checks such as debug_discard_caches.
+
+ Various tests, particularly the client program tests
+ under src/bin, use the Perl TAP tools and are run
+ using the Perl testing program prove. You can pass
+ command-line options to prove by setting
+ the make variable PROVE_FLAGS, for example:
+
+make -C src/bin check PROVE_FLAGS='--timer'
+
+ See the manual page of prove for more information.
+
+ The make variable PROVE_TESTS
+ can be used to define a whitespace-separated list of paths relative
+ to the Makefile invoking prove
+ to run the specified subset of tests instead of the default
+ t/*.pl. For example:
+
+make check PROVE_TESTS='t/001_test1.pl t/003_test3.pl'
+
+
+ The TAP tests require the Perl module IPC::Run.
+ This module is available from
+ CPAN
+ or an operating system package.
+ They also require PostgreSQL to be
+ configured with the option --enable-tap-tests.
+
+ Generically speaking, the TAP tests will test the executables in a
+ previously-installed installation tree if you say make
+ installcheck, or will build a new local installation tree from
+ current sources if you say make check. In either
+ case they will initialize a local instance (data directory) and
+ transiently run a server in it. Some of these tests run more than one
+ server. Thus, these tests can be fairly resource-intensive.
+
+ It's important to realize that the TAP tests will start test server(s)
+ even when you say make installcheck; this is unlike
+ the traditional non-TAP testing infrastructure, which expects to use an
+ already-running test server in that case. Some PostgreSQL
+ subdirectories contain both traditional-style and TAP-style tests,
+ meaning that make installcheck will produce a mix of
+ results from temporary servers and the already-running test server.
+
33.4.1. Environment Variables #
+ Data directories are named according to the test filename, and will be
+ retained if a test fails. If the environment variable
+ PG_TEST_NOCLEAN is set, data directories will be
+ retained regardless of test status. For example, retaining the data
+ directory regardless of test results when running the
+ pg_dump tests:
+
+PG_TEST_NOCLEAN=1 make -C src/bin/pg_dump check
+
+ This environment variable also prevents the test's temporary directories
+ from being removed.
+
+ Many operations in the test suites use a 180-second timeout, which on slow
+ hosts may lead to load-induced timeouts. Setting the environment variable
+ PG_TEST_TIMEOUT_DEFAULT to a higher number will change
+ the default to avoid this.
+
33.3. Variant Comparison Files #
+ Since some of the tests inherently produce environment-dependent
+ results, we have provided ways to specify alternate “expected”
+ result files. Each regression test can have several comparison files
+ showing possible results on different platforms. There are two
+ independent mechanisms for determining which comparison file is used
+ for each test.
+
+ The first mechanism allows comparison files to be selected for
+ specific platforms. There is a mapping file,
+ src/test/regress/resultmap, that defines
+ which comparison file to use for each platform.
+ To eliminate bogus test “failures” for a particular platform,
+ you first choose or make a variant result file, and then add a line to the
+ resultmap file.
+
+ Each line in the mapping file is of the form
+
+testname:output:platformpattern=comparisonfilename
+
+ The test name is just the name of the particular regression test
+ module. The output value indicates which output file to check. For the
+ standard regression tests, this is always out. The
+ value corresponds to the file extension of the output file.
+ The platform pattern is a pattern in the style of the Unix
+ tool expr (that is, a regular expression with an implicit
+ ^ anchor at the start). It is matched against the
+ platform name as printed by config.guess.
+ The comparison file name is the base name of the substitute result
+ comparison file.
+
+ For example: some systems lack a working strtof function,
+ for which our workaround causes rounding errors in the
+ float4 regression test.
+ Therefore, we provide a variant comparison file,
+ float4-misrounded-input.out, which includes
+ the results to be expected on these systems. To silence the bogus
+ “failure” message on Cygwin
+ platforms, resultmap includes:
+
+float4:out:.*-.*-cygwin.*=float4-misrounded-input.out
+
+ which will trigger on any machine where the output of
+ config.guess matches .*-.*-cygwin.*.
+ Other lines in resultmap select the variant comparison
+ file for other platforms where it's appropriate.
+
+ The second selection mechanism for variant comparison files is
+ much more automatic: it simply uses the “best match” among
+ several supplied comparison files. The regression test driver
+ script considers both the standard comparison file for a test,
+ testname.outtestname_digit.outdigit is any single digit
+ 0-9). If any such file is an exact match,
+ the test is considered to pass; otherwise, the one that generates
+ the shortest diff is used to create the failure report. (If
+ resultmap includes an entry for the particular
+ test, then the base testname is the substitute
+ name given in resultmap.)
+
+ For example, for the char test, the comparison file
+ char.out contains results that are expected
+ in the C and POSIX locales, while
+ the file char_1.out contains results sorted as
+ they appear in many other locales.
+
+ The best-match mechanism was devised to cope with locale-dependent
+ results, but it can be used in any situation where the test results
+ cannot be predicted easily from the platform name alone. A limitation of
+ this mechanism is that the test driver cannot tell which variant is
+ actually “correct” for the current environment; it will just pick
+ the variant that seems to work best. Therefore it is safest to use this
+ mechanism only for variant results that you are willing to consider
+ equally valid in all contexts.
+
Chapter 33. Regression Tests
+ The regression tests are a comprehensive set of tests for the SQL
+ implementation in PostgreSQL. They test
+ standard SQL operations as well as the extended capabilities of
+ PostgreSQL.
+
Release date: 2023-11-09
+ This release contains a variety of fixes from 16.0.
+ For information about new features in major release 16, see
+ Section E.4.
+
E.3.1. Migration to Version 16.1 #
+ A dump/restore is not required for those running 16.X.
+
+ However, several mistakes have been discovered that could lead to
+ certain types of indexes yielding wrong search results or being
+ unnecessarily inefficient. It is advisable
+ to REINDEX potentially-affected indexes after
+ installing this update. See the fourth through seventh changelog
+ entries below.
+
+ Fix handling of unknown-type arguments
+ in DISTINCT "any" aggregate
+ functions (Tom Lane)
+
+ This error led to a text-type value being interpreted
+ as an unknown-type value (that is, a zero-terminated
+ string) at runtime. This could result in disclosure of server
+ memory following the text value.
+
+ The PostgreSQL Project thanks Jingzhou Fu
+ for reporting this problem.
+ (CVE-2023-5868)
+
+ Detect integer overflow while computing new array dimensions
+ (Tom Lane)
+
+ When assigning new elements to array subscripts that are outside the
+ current array bounds, an undetected integer overflow could occur in
+ edge cases. Memory stomps that are potentially exploitable for
+ arbitrary code execution are possible, and so is disclosure of
+ server memory.
+
+ The PostgreSQL Project thanks Pedro
+ Gallegos for reporting this problem.
+ (CVE-2023-5869)
+
+ Prevent the pg_signal_backend role from
+ signalling background workers and autovacuum processes
+ (Noah Misch, Jelte Fennema-Nio)
+
+ The documentation says that pg_signal_backend
+ cannot issue signals to superuser-owned processes. It was able to
+ signal these background processes, though, because they advertise a
+ role OID of zero. Treat that as indicating superuser ownership.
+ The security implications of cancelling one of these process types
+ are fairly small so far as the core code goes (we'll just start
+ another one), but extensions might add background workers that are
+ more vulnerable.
+
+ Also ensure that the is_superuser parameter is
+ set correctly in such processes. No specific security consequences
+ are known for that oversight, but it might be significant for some
+ extensions.
+
+ The PostgreSQL Project thanks
+ Hemanth Sandrana and Mahendrakar Srinivasarao
+ for reporting this problem.
+ (CVE-2023-5870)
+
+ Fix misbehavior during recursive page split in GiST index build
+ (Heikki Linnakangas)
+
+ Fix a case where the location of a page downlink was incorrectly
+ tracked, and introduce some logic to allow recovering from such
+ situations rather than silently doing the wrong thing. This error
+ could result in incorrect answers from subsequent index searches.
+ It may be advisable to reindex all GiST indexes after installing
+ this update.
+
+ Prevent de-duplication of btree index entries
+ for interval columns (Noah Misch)
+
+ There are interval values that are distinguishable but
+ compare equal, for example 24:00:00
+ and 1 day. This breaks assumptions made by btree
+ de-duplication, so interval columns need to be excluded
+ from de-duplication. This oversight can cause incorrect results
+ from index-only scans. Moreover, after
+ updating amcheck will report an error for
+ almost all such indexes. Users should reindex any btree indexes
+ on interval columns.
+
+ Process date values more sanely in
+ BRIN datetime_minmax_multi_ops indexes
+ (Tomas Vondra)
+
+ The distance calculation for dates was backward, causing poor
+ decisions about which entries to merge. The index still produces
+ correct results, but is much less efficient than it should be.
+ Reindexing BRIN minmax_multi indexes
+ on date columns is advisable.
+
+ Process large timestamp and timestamptz
+ values more sanely in
+ BRIN datetime_minmax_multi_ops indexes
+ (Tomas Vondra)
+
+ Infinities were mistakenly treated as having distance zero rather
+ than a large distance from other values, causing poor decisions
+ about which entries to merge. Also, finite-but-very-large values
+ (near the endpoints of the representable timestamp range) could
+ result in internal overflows, again causing poor decisions. The
+ index still produces correct results, but is much less efficient
+ than it should be. Reindexing BRIN minmax_multi
+ indexes on timestamp and timestamptz
+ columns is advisable if the column contains, or has contained,
+ infinities or large finite values.
+
+ Avoid calculation overflows in
+ BRIN interval_minmax_multi_ops indexes with
+ extreme interval values (Tomas Vondra)
+
+ This bug might have caused unexpected failures while trying to
+ insert large interval values into such an index.
+
+ Fix partition step generation and runtime partition pruning for
+ hash-partitioned tables with multiple partition keys (David Rowley)
+
+ Some cases involving an IS NULL condition on one
+ of the partition keys could result in a crash.
+
+ Fix inconsistent rechecking of concurrently-updated rows
+ during MERGE (Dean Rasheed)
+
+ In READ COMMITTED mode, an update that finds that
+ its target row was just updated by a concurrent transaction will
+ recheck the query's WHERE conditions on the
+ updated row. MERGE failed to ensure that the
+ proper rows of other joined tables were used during this recheck,
+ possibly resulting in incorrect decisions about whether the
+ newly-updated row should be updated again
+ by MERGE.
+
+ Correctly identify the target table in an
+ inherited UPDATE/DELETE/MERGE
+ even when the parent table is excluded by constraints (Amit Langote,
+ Tom Lane)
+
+ If the initially-named table is excluded by constraints, but not all
+ its inheritance descendants are, the first non-excluded descendant
+ was identified as the primary target table. This would lead to
+ firing statement-level triggers associated with that table, rather
+ than the initially-named table as should happen. In v16, the same
+ oversight could also lead to “invalid perminfoindex 0 in RTE
+ with relid NNNN” errors.
+
+ Fix edge case in btree mark/restore processing of ScalarArrayOpExpr
+ clauses (Peter Geoghegan)
+
+ When restoring an indexscan to a previously marked position, the
+ code could miss required setup steps if the scan had advanced
+ exactly to the end of the matches for a ScalarArrayOpExpr (that is,
+ an indexcol = ANY(ARRAY[])) clause. This could
+ result in missing some rows that should have been fetched.
+
+ Fix intra-query memory leak in Memoize execution
+ (Orlov Aleksej, David Rowley)
+
+ Fix intra-query memory leak when a set-returning function repeatedly
+ returns zero rows (Tom Lane)
+
+ Don't crash if cursor_to_xmlschema() is applied
+ to a non-data-returning Portal (Boyu Yang)
+
+ Fix improper sharing of origin filter condition across
+ successive pg_logical_slot_get_changes() calls
+ (Hou Zhijie)
+
+ The origin condition set by one call of this function would be
+ re-used by later calls that did not specify the origin argument.
+ This was not intended.
+
+ Throw the intended error if pgrowlocks() is
+ applied to a partitioned table (David Rowley)
+
+ Previously, a not-on-point complaint “only heap AM is
+ supported” would be raised.
+
+ Handle invalid indexes more cleanly in assorted SQL functions
+ (Noah Misch)
+
+ Report an error if pgstatindex(),
+ pgstatginindex(),
+ pgstathashindex(),
+ or pgstattuple() is applied to an invalid
+ index. If brin_desummarize_range(),
+ brin_summarize_new_values(),
+ brin_summarize_range(),
+ or gin_clean_pending_list() is applied to an
+ invalid index, do nothing except to report a debug-level message.
+ Formerly these functions attempted to process the index, and might
+ fail in strange ways depending on what the failed CREATE
+ INDEX had left behind.
+
+ Avoid premature memory allocation failure with long inputs
+ to to_tsvector() (Tom Lane)
+
+ Fix over-allocation of the constructed tsvector
+ in tsvectorrecv() (Denis Erokhin)
+
+ If the incoming vector includes position data, the binary receive
+ function left wasted space (roughly equal to the size of the
+ position data) in the finished tsvector. In extreme
+ cases this could lead to “maximum total lexeme length
+ exceeded” failures for vectors that were under the length
+ limit when emitted. In any case it could lead to wasted space
+ on-disk.
+
+ Improve checks for corrupt PGLZ compressed data (Flavien Guedez)
+
+ Fix ALTER SUBSCRIPTION so that a commanded change
+ in the run_as_owner option is actually applied
+ (Hou Zhijie)
+
+ Fix bulk table insertion into partitioned tables (Andres Freund)
+
+ Improper sharing of insertion state across partitions could result
+ in failures during COPY FROM, typically
+ manifesting as “could not read block NNNN in file XXXX: read
+ only 0 of 8192 bytes” errors.
+
+ In COPY FROM, avoid evaluating column default
+ values that will not be needed by the command (Laurenz Albe)
+
+ This avoids a possible error if the default value isn't actually
+ valid for the column, or if the default's expression would fail in
+ the current execution context. Such edge cases sometimes arise
+ while restoring dumps, for example. Previous releases did not fail
+ in this situation, so prevent v16 from doing so.
+
+ In COPY FROM, fail cleanly when an unsupported
+ encoding conversion is needed (Tom Lane)
+
+ Recent refactoring accidentally removed the intended error check for
+ this, such that it ended in “cache lookup failed for function
+ 0” instead of a useful error message.
+
+ Avoid crash in EXPLAIN if a parameter marked to
+ be displayed by EXPLAIN has a NULL boot-time
+ value (Xing Guo, Aleksander Alekseev, Tom Lane)
+
+ No built-in parameter fits this description, but an extension could
+ define such a parameter.
+
+ Ensure we have a snapshot while dropping ON COMMIT
+ DROP temp tables (Tom Lane)
+
+ This prevents possible misbehavior if any catalog entries for the
+ temp tables have fields wide enough to require toasting (such as a
+ very complex CHECK condition).
+
+ Avoid improper response to shutdown signals in child processes
+ just forked by system() (Nathan Bossart)
+
+ This fix avoids a race condition in which a child process that has
+ been forked off by system(), but hasn't yet
+ exec'd the intended child program, might receive and act on a signal
+ intended for the parent server process. That would lead to
+ duplicate cleanup actions being performed, which will not end well.
+
+ Cope with torn reads of pg_control in frontend
+ programs (Thomas Munro)
+
+ On some file systems, reading pg_control may
+ not be an atomic action when the server concurrently writes that
+ file. This is detectable via a bad CRC. Retry a few times to see
+ if the file becomes valid before we report error.
+
+ Avoid torn reads of pg_control in relevant SQL
+ functions (Thomas Munro)
+
+ Acquire the appropriate lock before
+ reading pg_control, to ensure we get a
+ consistent view of that file.
+
+ Fix “could not find pathkey item to sort” errors
+ occurring while planning aggregate functions with ORDER
+ BY or DISTINCT options (David Rowley)
+
+ Avoid integer overflow when computing size of backend activity
+ string array (Jakub Wartak)
+
+ On 64-bit machines we will allow values
+ of track_activity_query_size large enough to
+ cause 32-bit overflow when multiplied by the allowed number of
+ connections. The code actually allocating the per-backend local
+ array was careless about this though, and allocated the array
+ incorrectly.
+
+ Fix briefly showing inconsistent progress statistics
+ for ANALYZE on inherited tables
+ (Heikki Linnakangas)
+
+ The block-level counters should be reset to zero at the same time we
+ update the current-relation field.
+
+ Fix the background writer to report any WAL writes it makes to the
+ statistics counters (Nazir Bilal Yavuz)
+
+ Fix confusion about forced-flush behavior
+ in pgstat_report_wal()
+ (Ryoga Yoshida, Michael Paquier)
+
+ This could result in some statistics about WAL I/O being forgotten
+ in a shutdown.
+
+ Fix statistics tracking of temporary-table extensions (Karina
+ Litskevich, Andres Freund)
+
+ These were counted as normal-table writes when they should be
+ counted as temp-table writes.
+
+ When track_io_timing is enabled, include the
+ time taken by relation extension operations as write time
+ (Nazir Bilal Yavuz)
+
+ Track the dependencies of cached CALL statements,
+ and re-plan them when needed (Tom Lane)
+
+ DDL commands, such as replacement of a function that has been
+ inlined into a CALL argument, can create the need
+ to re-plan a CALL that has been cached by
+ PL/pgSQL. That was not happening, leading to misbehavior or strange
+ errors such as “cache lookup failed”.
+
+ Avoid a possible pfree-a-NULL-pointer crash after an error in
+ OpenSSL connection setup (Sergey Shinderuk)
+
+ Track nesting depth correctly when
+ inspecting RECORD-type Vars from outer query levels
+ (Richard Guo)
+
+ This oversight could lead to assertion failures, core dumps,
+ or “bogus varno” errors.
+
+ Track hash function and negator function dependencies of
+ ScalarArrayOpExpr plan nodes (David Rowley)
+
+ In most cases this oversight was harmless, since these functions
+ would be unlikely to disappear while the node's original operator
+ remains present.
+
+ Fix error-handling bug in RECORD type cache management
+ (Thomas Munro)
+
+ An out-of-memory error occurring at just the wrong point could leave
+ behind inconsistent state that would lead to an infinite loop.
+
+ Treat out-of-memory failures as fatal while reading WAL
+ (Michael Paquier)
+
+ Previously this would be treated as a bogus-data condition, leading
+ to the conclusion that we'd reached the end of WAL, which is
+ incorrect and could lead to inconsistent WAL replay.
+
+ Fix possible recovery failure due to trying to allocate memory based
+ on a bogus WAL record length field (Thomas Munro, Michael Paquier)
+
+ Fix “could not duplicate handle” error occurring on
+ Windows when min_dynamic_shared_memory is set
+ above zero (Thomas Munro)
+
+ Fix order of operations in GenericXLogFinish
+ (Jeff Davis)
+
+ This code violated the conditions required for crash safety by
+ writing WAL before marking changed buffers dirty. No core code uses
+ this function, but extensions do (contrib/bloom
+ does, for example).
+
+ Remove incorrect assertion in PL/Python exception handling
+ (Alexander Lakhin)
+
+ Fix pg_dump to dump the
+ new run_as_owner option of subscriptions
+ (Philip Warner)
+
+ Due to this oversight, subscriptions would always be restored
+ with run_as_owner set
+ to false, which is not equivalent to their
+ behavior in pre-v16 releases.
+
+ Fix pg_restore so that selective restores
+ will include both table-level and column-level ACLs for selected
+ tables (Euler Taveira, Tom Lane)
+
+ Formerly, only the table-level ACL would get restored if both types
+ were present.
+
+ Add logic to pg_upgrade to check for use
+ of abstime, reltime,
+ and tinterval data types (Álvaro Herrera)
+
+ These obsolete data types were removed
+ in PostgreSQL version 12, so check to
+ make sure they aren't present in an older database before claiming
+ it can be upgraded.
+
+ Avoid false “too many client connections” errors
+ in pgbench on Windows (Noah Misch)
+
+ Fix vacuumdb's handling of
+ multiple -N switches (Nathan Bossart, Kuwamura
+ Masaki)
+
+ Multiple -N switches should exclude tables
+ in multiple schemas, but in fact excluded nothing due to faulty
+ construction of a generated query.
+
+ Fix vacuumdb to honor
+ its --buffer-usage-limit option in analyze-only
+ mode (Ryoga Yoshida, David Rowley)
+
+ In contrib/amcheck, do not report interrupted
+ page deletion as corruption (Noah Misch)
+
+ This fix prevents false-positive reports of “the first child
+ of leftmost target page is not leftmost of its
+ level”, “block NNNN is not leftmost”
+ or “left link/right link pair in index XXXX not in
+ agreement”. They appeared
+ if amcheck ran after an unfinished btree
+ index page deletion and before VACUUM had cleaned
+ things up.
+
+ Fix failure of contrib/btree_gin indexes
+ on interval columns,
+ when an indexscan using the <
+ or <= operator is performed (Dean Rasheed)
+
+ Such an indexscan failed to return all the entries it should.
+
+ Add support for LLVM 16 and 17 (Thomas Munro, Dmitry Dolgov)
+
+ Suppress assorted build-time warnings on
+ recent macOS (Tom Lane)
+
+ Xcode 15 (released
+ with macOS Sonoma) changed the linker's
+ behavior in a way that causes many duplicate-library warnings while
+ building PostgreSQL. These were
+ harmless, but they're annoying so avoid citing the same libraries
+ twice. Also remove use of the -multiply_defined
+ suppress linker switch, which apparently has been a no-op
+ for a long time, and is now actively complained of.
+
+ When building contrib/unaccent's rules file,
+ fall back to using python
+ if --with-python was not given and make
+ variable PYTHON was not set (Japin Li)
+
+ Remove PHOT (Phoenix Islands Time) from the
+ default timezone abbreviations list (Tom Lane)
+
+ Presence of this abbreviation in the default list can cause failures
+ on recent Debian and Ubuntu releases, as they no longer install the
+ underlying tzdb entry by default. Since this is a made-up
+ abbreviation for a zone with a total human population of about two
+ dozen, it seems unlikely that anyone will miss it. If someone does,
+ they can put it back via a custom abbreviations file.
+
Release date: 2024-02-08
+ This release contains a variety of fixes from 16.1.
+ For information about new features in major release 16, see
+ Section E.4.
+
E.2.1. Migration to Version 16.2 #
+ A dump/restore is not required for those running 16.X.
+
+ However, one bug was fixed that could have resulted in corruption of
+ GIN indexes during concurrent updates. If you suspect such
+ corruption, reindex affected indexes after installing this update.
+
+ Also, if you are upgrading from a version earlier than 16.1,
+ see Section E.3.
+
+ Tighten security restrictions within REFRESH MATERIALIZED
+ VIEW CONCURRENTLY (Heikki Linnakangas)
+
+ One step of a concurrent refresh command was run under weak security
+ restrictions. If a materialized view's owner could persuade a
+ superuser or other high-privileged user to perform a concurrent
+ refresh on that view, the view's owner could control code executed
+ with the privileges of the user running REFRESH.
+ Fix things so that all user-determined code is run as the view's
+ owner, as expected.
+
+ The only known exploit for this error does not work
+ in PostgreSQL 16.0 and later, so it may
+ be that v16 is not vulnerable in practice.
+
+ The PostgreSQL Project thanks Pedro
+ Gallegos for reporting this problem.
+ (CVE-2024-0985)
+
+ Fix memory leak when performing JIT inlining (Andres Freund,
+ Daniel Gustafsson)
+
+ There have been multiple reports of backend processes suffering
+ out-of-memory conditions after sufficiently many JIT compilations.
+ This fix should resolve that.
+
+ Avoid generating incorrect partitioned-join plans (Richard Guo)
+
+ Some uncommon situations involving lateral references could create
+ incorrect plans. Affected queries could produce wrong answers, or
+ odd failures such as “variable not found in subplan target
+ list”, or executor crashes.
+
+ Fix incorrect wrapping of subquery output expressions in
+ PlaceHolderVars (Tom Lane)
+
+ This fixes incorrect results when a subquery is underneath an outer
+ join and has an output column that laterally references something
+ outside the outer join's scope. The output column might not appear
+ as NULL when it should do so due to the action of the outer join.
+
+ Fix misprocessing of window function run conditions (Richard Guo)
+
+ This oversight could lead to “WindowFunc not found in subplan
+ target lists” errors.
+
+ Fix detection of inner-side uniqueness for Memoize plans
+ (Richard Guo)
+
+ This mistake could lead to “cache entry already
+ complete” errors.
+
+ Fix computation of nullingrels when constant-folding field selection
+ (Richard Guo)
+
+ Failure to do this led to errors like “wrong varnullingrels
+ (b) (expected (b 3)) for Var 2/2”.
+
+ Skip inappropriate actions when MERGE causes a
+ cross-partition update (Dean Rasheed)
+
+ When executing a MERGE UPDATE action on a
+ partitioned table, if the UPDATE is turned into
+ a DELETE and INSERT due to
+ changing a partition key column, skip firing AFTER
+ UPDATE ROW triggers, as well as other post-update actions
+ such as RLS checks. These actions would typically fail, which is
+ why a regular UPDATE doesn't do them in such
+ cases; MERGE shouldn't either.
+
+ Cope with BEFORE ROW DELETE triggers in
+ cross-partition MERGE updates (Dean Rasheed)
+
+ If such a trigger attempted to prevent the update by returning
+ NULL, MERGE would suffer an error or assertion
+ failure.
+
+ Prevent access to a no-longer-pinned buffer in BEFORE ROW
+ UPDATE triggers (Alexander Lakhin, Tom Lane)
+
+ If the tuple being updated had just been updated and moved to
+ another page by another session, there was a narrow window where
+ we would attempt to fetch data from the new tuple version without
+ any pin on its buffer. In principle this could result in garbage
+ data appearing in non-updated columns of the proposed new tuple.
+ The odds of problems in practice seem rather low, however.
+
+ Avoid requesting an oversize shared-memory area in parallel hash
+ join (Thomas Munro, Andrei Lepikhov, Alexander Korotkov)
+
+ The limiting value was too large, allowing “invalid DSA memory
+ alloc request size” errors to occur with sufficiently large
+ expected hash table sizes.
+
+ Fix corruption of local buffer state when an error occurs while
+ trying to extend a temporary table (Tender Wang)
+
+ Fix use of wrong tuple slot while
+ evaluating DISTINCT aggregates that have multiple
+ arguments (David Rowley)
+
+ This mistake could lead to errors such as “attribute 1 of type
+ record has wrong type”.
+
+ Avoid assertion failures in heap_update()
+ and heap_delete() when a tuple to be updated by
+ a foreign-key enforcement trigger fails the extra visibility
+ crosscheck (Alexander Lakhin)
+
+ This error had no impact in non-assert builds.
+
+ Fix overly tight assertion
+ about false_positive_rate parameter of
+ BRIN bloom operator classes (Alexander Lakhin)
+
+ This error had no impact in non-assert builds, either.
+
+ Fix possible failure during ALTER TABLE ADD
+ COLUMN on a complex inheritance tree (Tender Wang)
+
+ If a grandchild table would inherit the new column via multiple
+ intermediate parents, the command failed with “tuple already
+ updated by self”.
+
+ Fix problems with duplicate token names in ALTER TEXT
+ SEARCH CONFIGURATION ... MAPPING commands (Tender Wang,
+ Michael Paquier)
+
+ Fix DROP ROLE with duplicate role names
+ (Michael Paquier)
+
+ Previously this led to a “tuple already updated by
+ self” failure. Instead, ignore the duplicate.
+
+ Properly lock the associated table during DROP
+ STATISTICS (Tomas Vondra)
+
+ Failure to acquire the lock could result in “tuple
+ concurrently deleted” errors if the DROP
+ executes concurrently with ANALYZE.
+
+ Fix function volatility checking for GENERATED
+ and DEFAULT expressions (Tom Lane)
+
+ These places could fail to detect insertion of a volatile function
+ default-argument expression, or decide that a polymorphic function
+ is volatile although it is actually immutable on the datatype of
+ interest. This could lead to improperly rejecting or accepting
+ a GENERATED clause, or to mistakenly applying the
+ constant-default-value optimization in ALTER TABLE ADD
+ COLUMN.
+
+ Detect that a new catalog cache entry became stale while detoasting
+ its fields (Tom Lane)
+
+ We expand any out-of-line fields in a catalog tuple before inserting
+ it into the catalog caches. That involves database access which
+ might cause invalidation of catalog cache entries — but the
+ new entry isn't in the cache yet, so we would miss noticing that it
+ should get invalidated. The result is a race condition in which an
+ already-stale cache entry could get made, and then persist
+ indefinitely. This would lead to hard-to-predict misbehavior.
+ Fix by rechecking the tuple's visibility after detoasting.
+
+ Fix edge-case integer overflow detection bug on some platforms (Dean
+ Rasheed)
+
+ Computing 0 - INT64_MIN should result in an
+ overflow error, and did on most platforms. However, platforms with
+ neither integer overflow builtins nor 128-bit integers would fail to
+ spot the overflow, instead returning INT64_MIN.
+
+ Detect Julian-date overflow when adding or subtracting
+ an interval to/from a timestamp (Tom Lane)
+
+ Some cases that should cause an out-of-range error produced an
+ incorrect result instead.
+
+ Add more checks for overflow in interval_mul()
+ and interval_div() (Dean Rasheed)
+
+ Some cases that should cause an out-of-range error produced an
+ incorrect result instead.
+
+ Allow scram_SaltedPassword() to be interrupted
+ (Bowen Shi)
+
+ With large scram_iterations values, this function
+ could take a long time to run. Allow it to be interrupted by query
+ cancel requests.
+
+ Ensure cached statistics are discarded after a change
+ to stats_fetch_consistency (Shinya Kato)
+
+ In some code paths, it was possible for stale statistics to be
+ returned.
+
+ Make the pg_file_settings view check
+ validity of unapplied values for settings
+ with backend
+ or superuser-backend context (Tom Lane)
+
+ Invalid values were not noted in the view as intended. This escaped
+ detection because there are very few settings in these groups.
+
+ Match collation too when matching an existing index to a new
+ partitioned index (Peter Eisentraut)
+
+ Previously we could accept an index that has a different collation
+ from the corresponding element of the partition key, possibly
+ leading to misbehavior.
+
+ Avoid failure if a child index is dropped concurrently
+ with REINDEX INDEX on a partitioned index
+ (Fei Changhong)
+
+ Fix insufficient locking when cleaning up an incomplete split of
+ a GIN index's internal page (Fei Changhong, Heikki Linnakangas)
+
+ The code tried to do this with shared rather than exclusive lock on
+ the buffer. This could lead to index corruption if two processes
+ attempted the cleanup concurrently.
+
+ Avoid premature release of buffer pin in GIN index insertion
+ (Tom Lane)
+
+ If an index root page split occurs concurrently with our own
+ insertion, the code could fail with “buffer NNNN is not owned
+ by resource owner”.
+
+ Avoid failure with partitioned SP-GiST indexes (Tom Lane)
+
+ Trying to use an index of this kind could lead to “No such
+ file or directory” errors.
+
+ Fix ownership tests for large objects (Tom Lane)
+
+ Operations on large objects that require ownership privilege failed
+ with “unrecognized class ID: 2613”, unless run by a
+ superuser.
+
+ Fix ownership change reporting for large objects (Tom Lane)
+
+ A no-op ALTER LARGE OBJECT OWNER command (that
+ is, one selecting the existing owner) passed the wrong class ID to
+ the PostAlterHook, probably confusing any
+ extension using that hook.
+
+ Fix reporting of I/O timing data in EXPLAIN
+ (BUFFERS) (Michael Paquier)
+
+ The numbers labeled as “shared/local” actually refer
+ only to shared buffers, so change that label
+ to “shared”.
+
+ Ensure durability of CREATE DATABASE (Noah Misch)
+
+ If an operating system crash occurred during or shortly
+ after CREATE DATABASE, recovery could fail, or
+ subsequent connections to the new database could fail. If a base
+ backup was taken in that window, similar problems could be observed
+ when trying to use the backup. The symptom would be that the
+ database directory, PG_VERSION file, or
+ pg_filenode.map file was missing or empty.
+
+ Add more LOG messages when starting and ending
+ recovery from a backup (Andres Freund)
+
+ This change provides additional information in the postmaster log
+ that may be useful for diagnosing recovery problems.
+
+ Prevent standby servers from incorrectly processing dead index
+ tuples during subtransactions (Fei Changhong)
+
+ The startedInRecovery flag was not
+ correctly set for a subtransaction. This affects only processing of
+ dead index tuples. It could allow a query in a subtransaction to
+ ignore index entries that it should return (if they are already dead
+ on the primary server, but not dead to the standby transaction), or
+ to prematurely mark index entries as dead that are not yet dead on
+ the primary. It is not clear that the latter case has any serious
+ consequences, but it's not the intended behavior.
+
+ Fix signal handling in walreceiver processes (Heikki Linnakangas)
+
+ Revert a change that made walreceivers non-responsive
+ to SIGTERM while waiting for the
+ replication connection to be established.
+
+ Fix integer overflow hazard in checking whether a record will fit
+ into the WAL decoding buffer (Thomas Munro)
+
+ This bug appears to be only latent except when running a
+ 32-bit PostgreSQL build on a 64-bit
+ platform.
+
+ Fix deadlock between a logical replication apply worker, its
+ tablesync worker, and a session process trying to alter the
+ subscription (Shlok Kyal)
+
+ One edge of the deadlock loop did not involve a lock wait, so the
+ deadlock went undetected and would persist until manual
+ intervention.
+
+ Ensure that column default values are correctly transmitted by
+ the pgoutput logical replication plugin
+ (Nikhil Benesch)
+
+ ALTER TABLE ADD COLUMN with a constant default
+ value for the new column avoids rewriting existing tuples, instead
+ expecting that reading code will insert the correct default into a
+ tuple that lacks that column. If replication was subsequently
+ initiated on the table, pgoutput would
+ transmit NULL instead of the correct default for such a column,
+ causing incorrect replication on the subscriber.
+
+ Fix failure of logical replication's initial sync for a table with
+ no columns (Vignesh C)
+
+ This case generated an improperly-formatted COPY
+ command.
+
+ Re-validate a subscription's connection string before use (Vignesh C)
+
+ This is meant to detect cases where a subscription was created
+ without a password (which is allowed to superusers) but then the
+ subscription owner is changed to a non-superuser.
+
+ Return the correct status code when a new client disconnects without
+ responding to the server's password challenge (Liu Lang, Tom Lane)
+
+ In some cases we'd treat this as a loggable error, which was not the
+ intention and tends to create log spam, since common clients
+ like psql frequently do this. It may
+ also confuse extensions that
+ use ClientAuthentication_hook.
+
+ Fix incompatibility with OpenSSL 3.2
+ (Tristan Partin, Bo Andreson)
+
+ Use the BIO “app_data” field for our private storage,
+ instead of assuming it's okay to use the “data” field.
+ This mistake didn't cause problems before, but with 3.2 it leads
+ to crashes and complaints about double frees.
+
+ Be more wary about OpenSSL not
+ setting errno on error (Tom Lane)
+
+ If errno isn't set, assume the cause of the
+ reported failure is read EOF. This fixes rare cases of strange
+ error reports like “could not accept SSL connection:
+ Success”.
+
+ Fix file descriptor leakage when a foreign data
+ wrapper's ForeignAsyncRequest function fails
+ (Heikki Linnakangas)
+
+ Fix minor memory leak in connection string validation
+ for CREATE SUBSCRIPTION (Jeff Davis)
+
+ Report ENOMEM errors from file-related system
+ calls as ERRCODE_OUT_OF_MEMORY,
+ not ERRCODE_INTERNAL_ERROR (Alexander Kuzmenkov)
+
+ In PL/pgSQL, support SQL commands that
+ are CREATE FUNCTION/CREATE
+ PROCEDURE with SQL-standard bodies (Tom Lane)
+
+ Previously, such cases failed with parsing errors due to the
+ semicolon(s) appearing in the function body.
+
+ Fix libpq's
+ handling of errors in pipelines (Álvaro Herrera)
+
+ The pipeline state could get out of sync if an error is returned
+ for reasons other than a query problem (for example, if the
+ connection is lost). Potentially this would lead to a busy-loop in
+ the calling application.
+
+ Make libpq's
+ PQsendFlushRequest() function flush the client
+ output buffer under the same rules as
+ other PQsend functions (Jelte Fennema-Nio)
+
+ In pipeline mode, it may still be necessary to
+ call PQflush() as well; but this change removes
+ some inconsistency.
+
+ Avoid race condition when libpq
+ initializes OpenSSL support concurrently in two different threads
+ (Willi Mann, Michael Paquier)
+
+ Fix timing-dependent failure in GSSAPI data transmission (Tom Lane)
+
+ When using GSSAPI encryption in non-blocking
+ mode, libpq sometimes failed
+ with “GSSAPI caller failed to retransmit all data needing to
+ be retried”.
+
+ Change initdb to always un-comment
+ the postgresql.conf entries for
+ the lc_xxx parameters
+ (Kyotaro Horiguchi)
+
+ initdb used to work this way before v16,
+ and now it does again. The change
+ caused initdb's --no-locale
+ option to not have the intended effect
+ on lc_messages.
+
+ In pg_dump, don't dump RLS policies or
+ security labels for extension member objects (Tom Lane, Jacob
+ Champion)
+
+ Previously, commands would be included in the dump to set these
+ properties, which is really incorrect since they should be
+ considered as internal affairs of the extension. Moreover, the
+ restoring user might not have adequate privilege to set them, and
+ indeed the dumping user might not have enough privilege to dump them
+ (since dumping RLS policies requires acquiring lock on their table).
+
+ In pg_dump, don't dump an extended
+ statistics object if its underlying table isn't being dumped
+ (Rian McGuire, Tom Lane)
+
+ This conforms to the behavior for other dependent objects such as
+ indexes.
+
+ Properly detect out-of-memory in one code path
+ in pg_dump (Daniel Gustafsson)
+
+ Make it an error for a pgbench script to
+ end with an open pipeline (Anthonin Bonnefoy)
+
+ Previously, pgbench would behave oddly if
+ a \startpipeline command lacked a
+ matching \endpipeline. This seems like a
+ scripting mistake rather than a case
+ that pgbench needs to handle nicely, so
+ throw an error.
+
+ Fix crash in contrib/intarray if an array with
+ an element equal to INT_MAX is inserted into
+ a gist__int_ops index
+ (Alexander Lakhin, Tom Lane)
+
+ Report a better error
+ when contrib/pageinspect's
+ hash_bitmap_info() function is applied to a
+ partitioned hash index (Alexander Lakhin, Michael Paquier)
+
+ Report a better error
+ when contrib/pgstattuple's
+ pgstathashindex() function is applied to a
+ partitioned hash index (Alexander Lakhin)
+
+ On Windows, suppress autorun options when launching subprocesses
+ in pg_ctl
+ and pg_regress (Kyotaro Horiguchi)
+
+ When launching a child process via cmd.exe,
+ pass the /D flag to prevent executing any autorun
+ commands specified in the registry. This avoids possibly-surprising
+ side effects.
+
+ Move is_valid_ascii()
+ from mb/pg_wchar.h
+ to utils/ascii.h (Jubilee Young)
+
+ This change avoids the need to
+ include <simd.h>
+ in pg_wchar.h, which was causing problems for
+ some third-party code.
+
+ Fix compilation failures with libxml2
+ version 2.12.0 and later (Tom Lane)
+
+ Fix compilation failure of WAL_DEBUG code on
+ Windows (Bharath Rupireddy)
+
+ Suppress compiler warnings from Python's header files
+ (Peter Eisentraut, Tom Lane)
+
+ Our preferred compiler options provoke warnings about constructs
+ appearing in recent versions of Python's header files. When using
+ gcc, we can suppress these warnings with
+ a pragma.
+
+ Avoid deprecation warning when compiling with LLVM 18 (Thomas Munro)
+
+ Update time zone data files to tzdata
+ release 2024a for DST law changes in Greenland, Kazakhstan, and
+ Palestine, plus corrections for the Antarctic stations Casey and
+ Vostok. Also historical corrections for Vietnam, Toronto, and
+ Miquelon.
+
Release date: 2024-05-09
+ This release contains a variety of fixes from 16.2.
+ For information about new features in major release 16, see
+ Section E.4.
+
E.1.1. Migration to Version 16.3 #
+ A dump/restore is not required for those running 16.X.
+
+ However, a security vulnerability was found in the system
+ views pg_stats_ext
+ and pg_stats_ext_exprs, potentially allowing
+ authenticated database users to see data they shouldn't. If this is
+ of concern in your installation, follow the steps in the first
+ changelog entry below to rectify it.
+
+ Also, if you are upgrading from a version earlier than 16.2,
+ see Section E.2.
+
+ Restrict visibility of pg_stats_ext and
+ pg_stats_ext_exprs entries to the table
+ owner (Nathan Bossart)
+
+ These views failed to hide statistics for expressions that involve
+ columns the accessing user does not have permission to read. View
+ columns such as most_common_vals might
+ expose security-relevant data. The potential interactions here are
+ not fully clear, so in the interest of erring on the side of safety,
+ make rows in these views visible only to the owner of the associated
+ table.
+
+ The PostgreSQL Project thanks
+ Lukas Fittl for reporting this problem.
+ (CVE-2024-4317)
+
+ By itself, this fix will only fix the behavior in newly initdb'd
+ database clusters. If you wish to apply this change in an existing
+ cluster, you will need to do the following:
+
+ Find the SQL script fix-CVE-2024-4317.sql in
+ the share directory of
+ the PostgreSQL installation (typically
+ located someplace like /usr/share/postgresql/).
+ Be sure to use the script appropriate to
+ your PostgreSQL major version.
+ If you do not see this file, either your version is not vulnerable
+ (only v14–v16 are affected) or your minor version is too
+ old to have the fix.
+
+ In each database of the cluster, run
+ the fix-CVE-2024-4317.sql script as superuser.
+ In psql this would look like
+
+\i /usr/share/postgresql/fix-CVE-2024-4317.sql
+
+ (adjust the file path as appropriate). Any error probably indicates
+ that you've used the wrong script version. It will not hurt to run
+ the script more than once.
+
+ Do not forget to include the template0
+ and template1 databases, or the vulnerability
+ will still exist in databases you create later. To
+ fix template0, you'll need to temporarily make
+ it accept connections. Do that with
+
+ALTER DATABASE template0 WITH ALLOW_CONNECTIONS true;
+
+ and then after fixing template0, undo it with
+
+ALTER DATABASE template0 WITH ALLOW_CONNECTIONS false;
+
+
+ Fix INSERT from
+ multiple VALUES rows into a target column that is
+ a domain over an array or composite type (Tom Lane)
+
+ Such cases would either fail with surprising complaints about
+ mismatched datatypes, or insert unexpected coercions that could lead
+ to odd results.
+
+ Require SELECT privilege on the target table
+ for MERGE with a DO NOTHING
+ clause (Álvaro Herrera)
+
+ SELECT privilege would be required in all
+ practical cases anyway, but require it even if the query reads no
+ columns of the target table. This avoids an edge case in
+ which MERGE would require no privileges whatever,
+ which seems undesirable even when it's a do-nothing command.
+
+ Fix handling of self-modified tuples in MERGE
+ (Dean Rasheed)
+
+ Throw an error if a target row joins to more than one source row, as
+ required by the SQL standard. (The previous coding could silently
+ ignore this condition if a concurrent update was involved.) Also,
+ throw a non-misleading error if a target row is already updated by a
+ later command in the current transaction, thanks to
+ a BEFORE trigger or a volatile function used in
+ the query.
+
+ Fix incorrect pruning of NULL partition when a table is partitioned
+ on a boolean column and the query has a boolean IS
+ NOT clause (David Rowley)
+
+ A NULL value satisfies a clause such
+ as boolcol IS NOT
+ FALSE
+ Make ALTER FOREIGN TABLE SET SCHEMA move any
+ owned sequences into the new schema (Tom Lane)
+
+ Moving a regular table to a new schema causes any sequences owned by
+ the table to be moved to that schema too (along with indexes and
+ constraints). This was overlooked for foreign tables, however.
+
+ Make ALTER TABLE ... ADD COLUMN create
+ identity/serial sequences with the same persistence as their owning
+ tables (Peter Eisentraut)
+
+ CREATE UNLOGGED TABLE will make any owned
+ sequences be unlogged too. ALTER TABLE missed
+ that consideration, so that an added identity column would have a
+ logged sequence, which seems pointless.
+
+ Improve ALTER TABLE ... ALTER COLUMN TYPE's error
+ message when there is a dependent function or publication (Tom Lane)
+
+ In CREATE DATABASE, recognize strategy keywords
+ case-insensitively for consistency with other options (Tomas Vondra)
+
+ Fix EXPLAIN's counting of heap pages accessed by
+ a bitmap heap scan (Melanie Plageman)
+
+ Previously, heap pages that contain no visible tuples were not
+ counted; but it seems more consistent to count all pages returned by
+ the bitmap index scan.
+
+ Fix EXPLAIN's output for subplans
+ in MERGE (Dean Rasheed)
+
+ EXPLAIN would sometimes fail to properly display
+ subplan Params referencing variables in other parts of the plan tree.
+
+ Avoid deadlock during removal of orphaned temporary tables
+ (Mikhail Zhilin)
+
+ If the session that creates a temporary table crashes without
+ removing the table, autovacuum will eventually try to remove the
+ orphaned table. However, an incoming session that's been assigned
+ the same temporary namespace will do that too. If a temporary table
+ has a dependency (such as an owned sequence) then a deadlock could
+ result between these two cleanup attempts.
+
+ Fix updating of visibility map state in VACUUM
+ with the DISABLE_PAGE_SKIPPING option (Heikki
+ Linnakangas)
+
+ Due to an oversight, this mode caused all heap pages to be dirtied,
+ resulting in excess I/O. Also, visibility map bits that were
+ incorrectly set would not get cleared.
+
+ Avoid race condition while examining per-relation frozen-XID values
+ (Noah Misch)
+
+ VACUUM's computation of per-database frozen-XID
+ values from per-relation values could get confused by a concurrent
+ update of those values by another VACUUM.
+
+ Fix buffer usage reporting for parallel vacuuming (Anthonin Bonnefoy)
+
+ Buffer accesses performed by parallel workers were not getting
+ counted in the statistics reported in VERBOSE
+ mode.
+
+ Ensure that join conditions generated from equivalence classes are
+ applied at the correct plan level (Tom Lane)
+
+ In versions before PostgreSQL 16, it was
+ possible for generated conditions to be evaluated below outer joins
+ when they should be evaluated above (after) the outer join, leading
+ to incorrect query results. All versions have a similar hazard when
+ considering joins to UNION ALL trees that have
+ constant outputs for the join column in
+ some SELECT arms.
+
+ Fix “could not find pathkey item to sort” errors
+ occurring while planning aggregate functions with ORDER
+ BY or DISTINCT options (David Rowley)
+
+ This is similar to a fix applied in 16.1, but it solves the problem
+ for parallel plans.
+
+ Prevent potentially-incorrect optimization of some window functions
+ (David Rowley)
+
+ Disable “run condition” optimization
+ of ntile() and count()
+ with non-constant arguments. This avoids possible misbehavior with
+ sub-selects, typically leading to errors like “WindowFunc not
+ found in subplan target lists”.
+
+ Avoid unnecessary use of moving-aggregate mode with a non-moving
+ window frame (Vallimaharajan G)
+
+ When a plain aggregate is used as a window function, and the window
+ frame start is specified as UNBOUNDED PRECEDING,
+ the frame's head cannot move so we do not need to use the special
+ (and more expensive) moving-aggregate mode. This optimization was
+ intended all along, but due to a coding error it never triggered.
+
+ Avoid use of already-freed data while planning partition-wise joins
+ under GEQO (Tom Lane)
+
+ This would typically end in a crash or unexpected error message.
+
+ Avoid freeing still-in-use data in Memoize (Tender Wang, Andrei
+ Lepikhov)
+
+ In production builds this error frequently didn't cause any
+ problems, as the freed data would most likely not get overwritten
+ before it was used.
+
+ Fix incorrectly-reported statistics kind codes in “requested
+ statistics kind X is not yet
+ built” error messages (David Rowley)
+
+ Use a hash table instead of linear search for “catcache
+ list” objects (Tom Lane)
+
+ This change solves performance problems that were reported for
+ certain operations in installations with many thousands of roles.
+
+ Be more careful with RECORD-returning functions
+ in FROM (Tom Lane)
+
+ The output columns of such a function call must be defined by
+ an AS clause that specifies the column names and
+ data types. If the actual function output value doesn't match that,
+ an error is supposed to be thrown at runtime. However, some code
+ paths would examine the actual value prematurely, and potentially
+ issue strange errors or suffer assertion failures if it doesn't
+ match expectations.
+
+ Fix confusion about the return rowtype of SQL-language procedures
+ (Tom Lane)
+
+ A procedure implemented in SQL language that returns a single
+ composite-type column would cause an assertion failure or core dump.
+
+ Add protective stack depth checks to some recursive functions
+ (Egor Chindyaskin)
+
+ Fix mis-rounding and overflow hazards
+ in date_bin() (Moaaz Assali)
+
+ In the case where the source timestamp is before the origin
+ timestamp and their difference is already an exact multiple of the
+ stride, the code incorrectly subtracted the stride anyway. Also,
+ detect some integer-overflow cases that would have produced
+ incorrect results.
+
+ Detect integer overflow when adding or subtracting
+ an interval to/from a timestamp
+ (Joseph Koshakow)
+
+ Some cases that should cause an out-of-range error produced an
+ incorrect result instead.
+
+ Avoid race condition in pg_get_expr()
+ (Tom Lane)
+
+ If the relation referenced by the argument is dropped concurrently,
+ the function's intention is to return NULL, but sometimes it failed
+ instead.
+
+ Fix detection of old transaction IDs in XID status functions
+ (Karina Litskevich)
+
+ Transaction IDs more than 231
+ transactions in the past could be misidentified as recent,
+ leading to misbehavior of pg_xact_status()
+ or txid_status().
+
+ Ensure that a table's freespace map won't return a page that's past
+ the end of the table (Ronan Dunklau)
+
+ Because the freespace map isn't WAL-logged, this was possible in
+ edge cases involving an OS crash, a replica promote, or a PITR
+ restore. The result would be a “could not read block”
+ error.
+
+ Fix file descriptor leakage when an error is thrown while waiting
+ in WaitEventSetWait (Etsuro Fujita)
+
+ Avoid corrupting exception stack if an FDW implements async append
+ but doesn't configure any wait conditions for the Append plan node
+ to wait for (Alexander Pyhalov)
+
+ Throw an error if an index is accessed while it is being reindexed
+ (Tom Lane)
+
+ Previously this was just an assertion check, but promote it into a
+ regular runtime error. This will provide a more on-point error
+ message when reindexing a user-defined index expression that
+ attempts to access its own table.
+
+ Ensure that index-only scans on name columns return a
+ fully-padded value (David Rowley)
+
+ The value physically stored in the index is truncated, and
+ previously a pointer to that value was returned to callers. This
+ provoked complaints when testing under valgrind. In theory it could
+ result in crashes, though none have been reported.
+
+ Fix race condition that could lead to reporting an incorrect
+ conflict cause when invalidating a replication slot (Bertrand
+ Drouvot)
+
+ Fix race condition in deciding whether a table sync operation is
+ needed in logical replication (Vignesh C)
+
+ An invalidation event arriving while a subscriber identifies which
+ tables need to be synced would be forgotten about, so that any
+ tables newly in need of syncing might not get processed in a timely
+ fashion.
+
+ Fix crash with DSM allocations larger than 4GB (Heikki Linnakangas)
+
+ Disconnect if a new server session's client socket cannot be put
+ into non-blocking mode (Heikki Linnakangas)
+
+ It was once theoretically possible for us to operate with a socket
+ that's in blocking mode; but that hasn't worked fully in a long
+ time, so fail at connection start rather than misbehave later.
+
+ Fix inadequate error reporting
+ with OpenSSL 3.0.0 and later (Heikki
+ Linnakangas, Tom Lane)
+
+ System-reported errors passed through by OpenSSL were reported with
+ a numeric error code rather than anything readable.
+
+ Fix thread-safety of error reporting
+ for getaddrinfo() on Windows (Thomas Munro)
+
+ A multi-threaded libpq client program
+ could get an incorrect or corrupted error message after a network
+ lookup failure.
+
+ Avoid concurrent calls to bindtextdomain()
+ in libpq
+ and ecpglib (Tom Lane)
+
+ Although GNU gettext's implementation
+ seems to be fine with concurrent calls, the version available on
+ Windows is not.
+
+ Fix crash in ecpg's preprocessor if
+ the program tries to redefine a macro that was defined on the
+ preprocessor command line (Tom Lane)
+
+ In ecpg, avoid issuing
+ false “unsupported feature will be passed to server”
+ warnings (Tom Lane)
+
+ Ensure that the string result
+ of ecpg's intoasc()
+ function is correctly zero-terminated (Oleg Tselebrovskiy)
+
+ In initdb's -c option,
+ match parameter names case-insensitively (Tom Lane)
+
+ The server treats parameter names case-insensitively, so this code
+ should too. This avoids putting redundant entries into the
+ generated postgresql.conf file.
+
+ In psql, avoid leaking a query result
+ after the query is cancelled (Tom Lane)
+
+ This happened only when cancelling a non-last query in a query
+ string made with \; separators.
+
+ Fix pg_dumpall so that role comments, if
+ present, will be dumped regardless of the setting
+ of --no-role-passwords (Daniel Gustafsson,
+ Álvaro Herrera)
+
+ Skip files named .DS_Store
+ in pg_basebackup,
+ pg_checksums,
+ and pg_rewind (Daniel Gustafsson)
+
+ This avoids problems on macOS, where the Finder may create such
+ files.
+
+ Fix PL/pgSQL's parsing of single-line
+ comments (---style comments) following
+ expressions (Erik Wienhold, Tom Lane)
+
+ This mistake caused parse errors if such a comment followed
+ a WHEN expression in
+ a PL/pgSQL CASE
+ statement.
+
+ In contrib/amcheck, don't report false match
+ failures due to short- versus long-header values (Andrey Borodin,
+ Michael Zhilin)
+
+ A variable-length datum in a heap tuple or index tuple could have
+ either a short or a long header, depending on compression parameters
+ that applied when it was made. Treat these cases as equivalent
+ rather than complaining if there's a difference.
+
+ Fix bugs in BRIN output functions (Tomas Vondra)
+
+ These output functions are only used for displaying index entries
+ in contrib/pageinspect, so the errors are of
+ limited practical concern.
+
+ In contrib/postgres_fdw, avoid emitting
+ requests to sort by a constant (David Rowley)
+
+ This could occur in cases involving UNION ALL
+ with constant-emitting subqueries. Sorting by a constant is useless
+ of course, but it also risks being misinterpreted by the remote
+ server, leading to “ORDER BY
+ position N is not in select list”
+ errors.
+
+ Make contrib/postgres_fdw set the remote
+ session's time zone to GMT
+ not UTC (Tom Lane)
+
+ This should have the same results for practical purposes.
+ However, GMT is recognized by hard-wired code in
+ the server, while UTC is looked up in the
+ timezone database. So the old code could fail in the unlikely event
+ that the remote server's timezone database is missing entries.
+
+ In contrib/xml2, avoid use of library functions
+ that have been deprecated in recent versions
+ of libxml2 (Dmitry Koval)
+
+ Fix incompatibility with LLVM 18 (Thomas Munro, Dmitry Dolgov)
+
+ Allow make check to work with
+ the musl C library (Thomas Munro, Bruce
+ Momjian, Tom Lane)
+
Release date: 2023-09-14
+ PostgreSQL 16 contains many new features
+ and enhancements, including:
+
+ Allow parallelization of FULL and internal right OUTER hash joins
+
+ Allow logical replication from standby servers
+
+ Allow logical replication subscribers to apply large transactions in parallel
+
+ Allow monitoring of I/O statistics using the new pg_stat_io view
+
+ Add SQL/JSON constructors and identity functions
+
+ Improve performance of vacuum freezing
+
+ Add support for regular expression matching of user and database names in pg_hba.conf, and user names in pg_ident.conf
+
+ The above items and other new features of
+ PostgreSQL 16 are explained in more detail
+ in the sections below.
+
E.4.2. Migration to Version 16 #
+ A dump/restore using pg_dumpall or use of
+ pg_upgrade or logical replication is required for
+ those wishing to migrate data from any previous release. See Section 19.6 for general information on migrating to new
+ major releases.
+
+ Version 16 contains a number of changes that may affect compatibility
+ with previous releases. Observe the following incompatibilities:
+
+ Change assignment rules for PL/pgSQL
+ bound cursor variables (Tom Lane)
+
+ Previously, the string value of such variables
+ was set to match the variable name during cursor
+ assignment; now it will be assigned during OPEN,
+ and will not match the variable name. To restore the previous
+ behavior, assign the desired portal name to the cursor variable
+ before OPEN.
+
+ Disallow NULLS NOT
+ DISTINCT indexes for primary keys (Daniel
+ Gustafsson)
+
+ Change REINDEX
+ DATABASE and reindexdb
+ to not process indexes on system catalogs (Simon Riggs)
+
+ Processing such indexes is still possible using REINDEX
+ SYSTEM and reindexdb
+ --system.
+
+ Tighten GENERATED
+ expression restrictions on inherited and partitioned tables (Amit
+ Langote, Tom Lane)
+
+ Columns of parent/partitioned and child/partition tables must all
+ have the same generation status, though now the actual generation
+ expressions can be different.
+
+ Remove pg_walinspect
+ functions
+ pg_get_wal_records_info_till_end_of_wal()
+ and pg_get_wal_stats_till_end_of_wal()
+ (Bharath Rupireddy)
+
+ Rename server variable
+ force_parallel_mode to debug_parallel_query
+ (David Rowley)
+
+ Remove the ability to create
+ views manually with ON SELECT rules
+ (Tom Lane)
+
+ Remove the server variable
+ vacuum_defer_cleanup_age (Andres Freund)
+
+ This has been unnecessary since hot_standby_feedback
+ and replication
+ slots were added.
+
+ Remove server variable promote_trigger_file
+ (Simon Riggs)
+
+ This was used to promote a standby to primary, but is now more easily
+ accomplished with pg_ctl
+ promote or pg_promote().
+
+ Remove read-only server variables lc_collate
+ and lc_ctype (Peter Eisentraut)
+
+ Collations and locales can vary between databases so having them
+ as read-only server variables was unhelpful.
+
+ Role inheritance now controls the default
+ inheritance status of member roles added during GRANT (Robert Haas)
+
+ The role's default inheritance behavior can be overridden with the
+ new GRANT ... WITH INHERIT clause. This allows
+ inheritance of some roles and not others because the members'
+ inheritance status is set at GRANT time.
+ Previously the inheritance status of member roles was controlled
+ only by the role's inheritance status, and changes to a role's
+ inheritance status affected all previous and future member roles.
+
+ Restrict the privileges of CREATEROLE
+ and its ability to modify other roles (Robert Haas)
+
+ Previously roles with CREATEROLE privileges could
+ change many aspects of any non-superuser role. Such changes,
+ including adding members, now require the role requesting
+ the change to have ADMIN OPTION permission.
+ For example, they can now change the CREATEDB,
+ REPLICATION, and BYPASSRLS
+ properties only if they also have those permissions.
+
+ Remove symbolic links for the postmaster
+ binary (Peter Eisentraut)
+
+ Below you will find a detailed account of the changes between
+ PostgreSQL 16 and the previous major
+ release.
+
+ Allow incremental sorts in more cases, including
+ DISTINCT (David Rowley)
+
+ Add the ability for aggregates having ORDER BY
+ or DISTINCT to use pre-sorted data (David
+ Rowley)
+
+ The new server variable enable_presorted_aggregate
+ can be used to disable this.
+
+ Allow memoize atop a UNION ALL (Richard Guo)
+
+ Allow anti-joins to be performed with the non-nullable input as
+ the inner relation (Richard Guo)
+
+ Allow parallelization of FULL and internal
+ right OUTER hash joins (Melanie Plageman,
+ Thomas Munro)
+
+ Improve the accuracy of GIN index access optimizer
+ costs (Ronan Dunklau)
+
+ Add system view pg_stat_io
+ view to track I/O statistics (Melanie Plageman)
+
+ Record statistics on the last sequential and index scans on tables
+ (Dave Page)
+
+ This information appears in pg_stat_*_tables
+ and pg_stat_*_indexes.
+
+ Record statistics on the occurrence of updated rows moving to
+ new pages (Corey Huinker)
+
+ The pg_stat_*_tables column is n_tup_newpage_upd.
+
+ Add speculative lock information to the pg_locks
+ system view (Masahiko Sawada, Noriyoshi Shinoda)
+
+ The transaction id is displayed in the
+ transactionid column and
+ the speculative insertion token is displayed in the
+ objid column.
+
+ Add the display of prepared statement result types to the pg_prepared_statements
+ view (Dagfinn Ilmari Mannsåker)
+
+ Create subscription statistics
+ entries at subscription creation time so stats_reset
+ is accurate (Andres Freund)
+
+ Previously entries were created only when the first statistics
+ were reported.
+
+ Correct the I/O
+ accounting for temp relation writes shown in pg_stat_database
+ (Melanie Plageman)
+
+ Add function pg_stat_get_backend_subxact()
+ to report on a session's subtransaction cache (Dilip Kumar)
+
+ Have pg_stat_get_backend_idset(),
+ pg_stat_get_backend_activity(), and related
+ functions use the unchanging backend id (Nathan Bossart)
+
+ Previously the index values might change during the lifetime of
+ the session.
+
+ Report stand-alone backends with a special backend type (Melanie
+ Plageman)
+
+ Add wait event SpinDelay
+ to report spinlock sleep delays (Andres Freund)
+
+ Create new wait event DSMAllocate
+ to indicate waiting for dynamic shared memory allocation (Thomas
+ Munro)
+
+ Previously this type of wait was reported as
+ DSMFillZeroWrite, which was also used by
+ mmap() allocations.
+
+ Add the database name to the process title of logical
+ WAL senders (Tatsuhiro Nakamori)
+
+ Physical WAL senders do not display a database
+ name.
+
+ Add checkpoint and REDO LSN information to log_checkpoints
+ messages (Bharath Rupireddy, Kyotaro Horiguchi)
+
+ Provide additional details during client certificate failures
+ (Jacob Champion)
+
+ Add predefined role pg_create_subscription
+ with permission to create subscriptions (Robert Haas)
+
+ Allow subscriptions to not require passwords (Robert Haas)
+
+ This is accomplished with the option password_required=false.
+
+ Simplify permissions for LOCK
+ TABLE (Jeff Davis)
+
+ Previously a user's ability to perform LOCK
+ TABLE at various lock levels was limited to the
+ lock levels required by the commands they had permission
+ to execute on the table. For example, someone with UPDATE
+ permission could perform all lock levels except ACCESS
+ SHARE, even though it was a lesser lock level. Now users
+ can issue lesser lock levels if they already have permission for
+ greater lock levels.
+
+ Allow ALTER GROUP group_name
+ ADD USER user_name to be performed with ADMIN
+ OPTION (Robert Haas)
+
+ Previously CREATEROLE permission was required.
+
+ Allow GRANT
+ to use WITH ADMIN TRUE/FALSE
+ syntax (Robert Haas)
+
+ Previously only the WITH ADMIN OPTION syntax
+ was supported.
+
+ Allow roles that create other roles to automatically
+ inherit the new role's rights or the ability to SET ROLE to the
+ new role (Robert Haas, Shi Yu)
+
+ This is controlled by server variable createrole_self_grant.
+
+ Prevent users from changing the default privileges of non-inherited
+ roles (Robert Haas)
+
+ This is now only allowed for inherited roles.
+
+ When granting role membership, require the granted-by role to be
+ a role that has appropriate permissions (Robert Haas)
+
+ This is a requirement even when a non-bootstrap superuser is
+ granting role membership.
+
+ Allow non-superusers to grant permissions using a granted-by user
+ that is not the current user (Robert Haas)
+
+ The current user still must have sufficient permissions given by
+ the specified granted-by user.
+
+ Add GRANT to
+ control permission to use SET
+ ROLE (Robert Haas)
+
+ This is controlled by a new GRANT ... SET
+ option.
+
+ Add dependency tracking to roles which have granted privileges
+ (Robert Haas)
+
+ For example, removing ADMIN OPTION will fail if
+ there are privileges using that option; CASCADE
+ must be used to revoke dependent permissions.
+
+ Add dependency tracking of grantors for GRANT records
+ (Robert Haas)
+
+ This guarantees that pg_auth_members.grantor
+ values are always valid.
+
+ Allow multiple role membership records (Robert Haas)
+
+ Previously a new membership grant would remove a previous matching
+ membership grant, even if other aspects of the grant did not match.
+
+ Prevent removal of superuser privileges for the bootstrap user
+ (Robert Haas)
+
+ Restoring such users could lead to errors.
+
+ Allow makeaclitem()
+ to accept multiple privilege names (Robins Tharakan)
+
+ Previously only a single privilege name, like SELECT, was
+ accepted.
+
E.4.3.1.5. Server Configuration #
+ Add support for Kerberos credential
+ delegation (Stephen Frost)
+
+ This is enabled with server variable gss_accept_delegation
+ and libpq connection parameter gssdelegation.
+
+ Allow the SCRAM iteration
+ count to be set with server variable scram_iterations
+ (Daniel Gustafsson)
+
+ Improve performance of server variable management (Tom Lane)
+
+ Tighten restrictions on which server variables can be reset
+ (Masahiko Sawada)
+
+ Previously, while certain variables, like transaction_isolation,
+ were not affected by RESET
+ ALL, they could be individually reset in
+ inappropriate situations.
+
+ Move various postgresql.conf
+ items into new categories (Shinya Kato)
+
+ This also affects the categories displayed in the pg_settings
+ view.
+
+ Prevent configuration file recursion beyond 10 levels (Julien
+ Rouhaud)
+
+ Allow autovacuum to more
+ frequently honor changes to delay settings (Melanie Plageman)
+
+ Rather than honor changes only at the start of each relation,
+ honor them at the start of each block.
+
+ Remove restrictions that archive files be durably renamed
+ (Nathan Bossart)
+
+ The archive_command
+ command is now more likely to be called with already-archived
+ files after a crash.
+
+ Prevent archive_library
+ and archive_command
+ from being set at the same time (Nathan Bossart)
+
+ Previously archive_library would override
+ archive_command.
+
+ Allow the postmaster to terminate children with an abort signal
+ (Tom Lane)
+
+ This allows collection of a core dump for a
+ stuck child process. This is controlled by send_abort_for_crash
+ and send_abort_for_kill.
+ The postmaster's -T switch is now the same as
+ setting send_abort_for_crash.
+
+ Remove the non-functional postmaster -n option
+ (Tom Lane)
+
+ Allow the server to reserve backend slots for roles with pg_use_reserved_connections
+ membership (Nathan Bossart)
+
+ The number of reserved slots is set by server variable reserved_connections.
+
+ Allow huge pages to
+ work on newer versions of Windows
+ 10 (Thomas Munro)
+
+ This adds the special handling required to enable huge pages
+ on newer versions of Windows
+ 10.
+
+ Add debug_io_direct
+ setting for developer usage (Thomas Munro, Andres Freund,
+ Bharath Rupireddy)
+
+ While primarily for developers, wal_sync_method=open_sync/open_datasync
+ has been modified to not use direct I/O with
+ wal_level=minimal; this is now enabled with
+ debug_io_direct=wal.
+
+ Add function pg_split_walfile_name()
+ to report the segment and timeline values of WAL
+ file names (Bharath Rupireddy)
+
+ Add support for regular expression matching on database and role
+ entries in pg_hba.conf (Bertrand Drouvot)
+
+ Regular expression patterns are prefixed with a slash. Database
+ and role names that begin with slashes need to be double-quoted
+ if referenced in pg_hba.conf.
+
+ Improve user-column handling of pg_ident.conf
+ to match pg_hba.conf (Jelte Fennema)
+
+ Specifically, add support for all, role
+ membership with +, and regular expressions
+ with a leading slash. Any user name that matches these patterns
+ must be double-quoted.
+
+ Allow include files in pg_hba.conf and
+ pg_ident.conf (Julien Rouhaud)
+
+ These are controlled by include,
+ include_if_exists, and
+ include_dir. System views pg_hba_file_rules
+ and pg_ident_file_mappings
+ now display the file name.
+
+ Allow pg_hba.conf tokens to be of unlimited
+ length (Tom Lane)
+
+ Add rule and map numbers to the system view pg_hba_file_rules
+ (Julien Rouhaud)
+
+ Determine the default encoding from the locale when using
+ ICU (Jeff Davis)
+
+ Previously the default was always UTF-8.
+
+ Have CREATE
+ DATABASE and CREATE
+ COLLATION's LOCALE options, and
+ initdb
+ and createdb
+ --locale options, control
+ non-libc collation providers (Jeff
+ Davis)
+
+ Previously they only controlled libc
+ providers.
+
+ Add predefined collations unicode and
+ ucs_basic (Peter Eisentraut)
+
+ This only works if ICU support is enabled.
+
+ Allow custom ICU collation rules to be created
+ (Peter Eisentraut)
+
+ This is done using CREATE
+ COLLATION's new RULES
+ clause, as well as new options for CREATE
+ DATABASE, createdb,
+ and initdb.
+
+ Allow Windows to import
+ system locales automatically (Juan José Santamaría Flecha)
+
+ Previously, only ICU locales could be imported
+ on Windows.
+
+ Allow logical decoding
+ on standbys (Bertrand Drouvot, Andres Freund, Amit Khandekar)
+
+ Snapshot WAL records are
+ required for logical slot creation but cannot be
+ created on standbys. To avoid delays, the new function pg_log_standby_snapshot()
+ allows creation of such records.
+
+ Add server variable to control how logical decoding publishers
+ transfer changes and how subscribers apply them (Shi Yu)
+
+ The variable is debug_logical_replication_streaming.
+
+ Allow logical replication initial table synchronization to copy
+ rows in binary format (Melih Mutlu)
+
+ This is only possible for subscriptions marked as binary.
+
+ Allow parallel application of logical replication (Hou Zhijie,
+ Wang Wei, Amit Kapila)
+
+ The CREATE
+ SUBSCRIPTION STREAMING
+ option now supports parallel to enable
+ application of large transactions by parallel workers. The number
+ of parallel workers is controlled by the new server variable max_parallel_apply_workers_per_subscription.
+ Wait events LogicalParallelApplyMain,
+ LogicalParallelApplyStateChange, and
+ LogicalApplySendData were also added. Column
+ leader_pid was added to system view pg_stat_subscription
+ to track parallel activity.
+
+ Improve performance for logical replication
+ apply without a primary key (Onder Kalaci, Amit Kapila)
+
+ Specifically, REPLICA IDENTITY FULL can now
+ use btree indexes rather than sequentially scanning the table to
+ find matches.
+
+ Allow logical replication subscribers to process only changes that
+ have no origin (Vignesh C, Amit Kapila)
+
+ This can be used to avoid replication loops. This is controlled
+ by the new CREATE SUBSCRIPTION ... ORIGIN option.
+
+ Perform logical replication SELECT and
+ DML actions as the table owner (Robert Haas)
+
+ This improves security and now requires subscription
+ owners to be either superusers or to have SET ROLE
+ permission on all roles owning tables in the replication set.
+ The previous behavior of performing all operations as the
+ subscription owner can be enabled with the subscription run_as_owner
+ option.
+
+ Have wal_retrieve_retry_interval
+ operate on a per-subscription basis (Nathan Bossart)
+
+ Previously the retry time was applied
+ globally. This also adds wait events >LogicalRepLauncherDSA
+ and LogicalRepLauncherHash.
+
E.4.3.3. Utility Commands #
+ Add EXPLAIN
+ option GENERIC_PLAN to display the generic plan
+ for a parameterized query (Laurenz Albe)
+
+ Allow a COPY FROM
+ value to map to a column's DEFAULT (Israel
+ Barth Rubio)
+
+ Allow COPY
+ into foreign tables to add rows in batches (Andrey Lepikhov,
+ Etsuro Fujita)
+
+ This is controlled by the postgres_fdw
+ option batch_size.
+
+ Allow the STORAGE type to be specified by CREATE TABLE
+ (Teodor Sigaev, Aleksander Alekseev)
+
+ Previously only ALTER
+ TABLE could control this.
+
+ Allow truncate triggers
+ on foreign tables (Yugo Nagata)
+
+ Allow VACUUM and vacuumdb
+ to only process TOAST tables
+ (Nathan Bossart)
+
+ This is accomplished by having VACUUM
+ turn off PROCESS_MAIN or by vacuumdb
+ using the --no-process-main option.
+
+ Add VACUUM
+ options to skip or update all frozen statistics (Tom Lane,
+ Nathan Bossart)
+
+ The options are SKIP_DATABASE_STATS and
+ ONLY_DATABASE_STATS.
+
+ Change REINDEX
+ DATABASE and REINDEX SYSTEM
+ to no longer require an argument (Simon Riggs)
+
+ Previously the database name had to be specified.
+
+ Allow CREATE
+ STATISTICS to generate a statistics name if none
+ is specified (Simon Riggs)
+
+ Allow non-decimal integer
+ literals (Peter Eisentraut)
+
+ For example, 0x42F, 0o273,
+ and 0b100101.
+
+ Allow NUMERIC
+ to process hexadecimal, octal, and binary integers of any size
+ (Dean Rasheed)
+
+ Previously only unquoted eight-byte integers were supported with
+ these non-decimal bases.
+
+ Allow underscores in integer and numeric constants (Peter Eisentraut,
+ Dean Rasheed)
+
+ This can improve readability for long strings of digits.
+
+ Accept the spelling +infinity in datetime input
+ (Vik Fearing)
+
+ Prevent the specification of epoch and
+ infinity together with other fields in datetime
+ strings (Joseph Koshakow)
+
+ Remove undocumented support for date input in the form
+ YyearMmonthDday
+ (Joseph Koshakow)
+
+ Add functions pg_input_is_valid()
+ and pg_input_error_info() to check for type
+ conversion errors (Tom Lane)
+
E.4.3.5. General Queries #
+ Allow subqueries in the FROM clause to omit
+ aliases (Dean Rasheed)
+
+ Add support for enhanced numeric literals in
+ SQL/JSON paths (Peter Eisentraut)
+
+ For example, allow hexadecimal, octal, and binary integers and
+ underscores between digits.
+
+ Add SQL/JSON constructors (Nikita Glukhov,
+ Teodor Sigaev, Oleg Bartunov, Alexander Korotkov, Amit Langote)
+
+ The new functions JSON_ARRAY(),
+ JSON_ARRAYAGG(),
+ JSON_OBJECT(), and
+ JSON_OBJECTAGG() are part of the
+ SQL standard.
+
+ Add SQL/JSON object checks (Nikita Glukhov,
+ Teodor Sigaev, Oleg Bartunov, Alexander Korotkov, Amit Langote,
+ Andrew Dunstan)
+
+ The IS
+ JSON checks include checks for values, arrays,
+ objects, scalars, and unique keys.
+
+ Allow JSON string parsing to use vector
+ operations (John Naylor)
+
+ Improve the handling of full text highlighting function ts_headline()
+ for OR and NOT expressions
+ (Tom Lane)
+
+ Add functions to add, subtract, and generate
+ timestamptz values in a specified time zone (Przemyslaw
+ Sztoch, Gurjeet Singh)
+
+ The functions are date_add(),
+ date_subtract(), and generate_series().
+
+ Change date_trunc(unit,
+ timestamptz, time_zone) to be an immutable
+ function (Przemyslaw Sztoch)
+
+ This allows the creation of expression indexes using this function.
+
+ Add server variable SYSTEM_USER
+ (Bertrand Drouvot)
+
+ This reports the authentication method and its authenticated user.
+
+ Add functions array_sample()
+ and array_shuffle() (Martin Kalcher)
+
+ Add aggregate function ANY_VALUE()
+ which returns any value from a set (Vik Fearing)
+
+ Add function random_normal()
+ to supply normally-distributed random numbers (Paul Ramsey)
+
+ Add error function erf()
+ and its complement erfc() (Dean Rasheed)
+
+ Improve the accuracy of numeric power()
+ for integer exponents (Dean Rasheed)
+
+ Add XMLSERIALIZE()
+ option INDENT to pretty-print its output
+ (Jim Jones)
+
+ Change pg_collation_actual_version()
+ to return a reasonable value for the default collation (Jeff Davis)
+
+ Previously it returned NULL.
+
+ Allow pg_read_file()
+ and pg_read_binary_file() to ignore missing
+ files (Kyotaro Horiguchi)
+
+ Add byte specification (B) to pg_size_bytes()
+ (Peter Eisentraut)
+
+ Allow to_reg*
+ functions to accept numeric OIDs as input
+ (Tom Lane)
+
+ Add libpq connection option require_auth
+ to specify a list of acceptable authentication methods (Jacob
+ Champion)
+
+ This can also be used to disallow certain authentication methods.
+
+ Allow multiple libpq-specified hosts
+ to be randomly selected (Jelte Fennema)
+
+ This is enabled with load_balance_hosts=random
+ and can be used for load balancing.
+
+ Add libpq option sslcertmode
+ to control transmission of the client certificate (Jacob Champion)
+
+ The option values are disable,
+ allow, and require.
+
+ Allow libpq to use the system certificate
+ pool for certificate verification (Jacob Champion, Thomas Habets)
+
+ This is enabled with sslrootcert=system,
+ which also enables sslmode=verify-full.
+
E.4.3.9. Client Applications #
+ Allow ECPG
+ variable declarations to use typedef names that match unreserved
+ SQL keywords (Tom Lane)
+
+ This change does prevent keywords which match C typedef names from
+ being processed as keywords in later EXEC SQL
+ blocks.
+
+ Allow psql to control the maximum
+ width of header lines in expanded format (Platon Pronko)
+
+ This is controlled by xheader_width.
+
+ Add psql command \drg
+ to show role membership details (Pavel Luzanov)
+
+ The Member of output column has been removed
+ from \du and \dg because
+ this new command displays this information in more detail.
+
+ Allow psql's access privilege commands
+ to show system objects (Nathan Bossart)
+
+ The options are \dpS
+ and \zS.
+
+ Add FOREIGN designation
+ to psql \d+
+ for foreign table children and partitions (Ian Lawrence Barwick)
+
+ Prevent \df+
+ from showing function source code (Isaac Morland)
+
+ Function bodies are more easily viewed with \sf.
+
+ Allow psql to submit queries using
+ the extended query protocol (Peter Eisentraut)
+
+ Passing arguments to such queries is done
+ using the new psql \bind
+ command.
+
+ Allow psql \watch
+ to limit the number of executions (Andrey Borodin)
+
+ The \watch options can now be named when
+ specified.
+
+ Detect invalid values for psql \watch,
+ and allow zero to specify no delay (Andrey Borodin)
+
+ Allow psql scripts to obtain the exit
+ status of shell commands and queries
+ (Corey Huinker, Tom Lane)
+
+ The new psql control variables are SHELL_ERROR
+ and SHELL_EXIT_CODE.
+
+ Various psql tab completion improvements
+ (Vignesh C, Aleksander Alekseev, Dagfinn Ilmari Mannsåker,
+ Shi Yu, Michael Paquier, Ken Kato, Peter Smith)
+
+ Add pg_dump control of dumping child
+ tables and partitions (Gilles Darold)
+
+ The new options are --table-and-children,
+ --exclude-table-and-children, and
+ --exclude-table-data-and-children.
+
+ Add LZ4 and
+ Zstandard compression to
+ pg_dump (Georgios Kokolatos, Justin
+ Pryzby)
+
+ Allow pg_dump and pg_basebackup
+ to use long mode for compression (Justin Pryzby)
+
+ Improve pg_dump to accept a more
+ consistent compression syntax (Georgios Kokolatos)
+
+ Options like --compress=gzip:5.
+
E.4.3.10. Server Applications #
+ Add initdb
+ option to set server variables for the duration of
+ initdb and all future server starts
+ (Tom Lane)
+
+ The option is -c name=value.
+
+ Add options to createuser
+ to control more user options (Shinya Kato)
+
+ Specifically, the new options control the valid-until date,
+ bypassing of row-level security, and role membership.
+
+ Deprecate createuser
+ option --role (Nathan Bossart)
+
+ This option could be easily confused with new
+ createuser role membership options,
+ so option --member-of has been added with the
+ same functionality. The --role option can still
+ be used.
+
+ Allow control of vacuumdb
+ schema processing (Gilles Darold)
+
+ These are controlled by options --schema and
+ --exclude-schema.
+
+ Use new VACUUM
+ options to improve the performance of vacuumdb
+ (Tom Lane, Nathan Bossart)
+
+ Have pg_upgrade
+ set the new cluster's locale and encoding (Jeff Davis)
+
+ This removes the requirement that the new cluster be created with
+ the same locale and encoding settings.
+
+ Add pg_upgrade
+ option to specify the default transfer mode (Peter Eisentraut)
+
+ The option is --copy.
+
+ Improve pg_basebackup
+ to accept numeric compression options (Georgios Kokolatos,
+ Michael Paquier)
+
+ Options like --compress=server-5 are now supported.
+
+ Fix pg_basebackup
+ to handle tablespaces stored in the PGDATA directory
+ (Robert Haas)
+
+ Add pg_waldump
+ option --save-fullpage to dump full page images
+ (David Christensen)
+
+ Allow pg_waldump
+ options -t/--timeline to accept
+ hexadecimal values (Peter Eisentraut)
+
+ Add support for progress reporting to pg_verifybackup
+ (Masahiko Sawada)
+
+ Allow pg_rewind
+ to properly track timeline changes (Heikki Linnakangas)
+
+ Previously if pg_rewind was run after
+ a timeline switch but before a checkpoint was issued, it might
+ incorrectly determine that a rewind was unnecessary.
+
+ Have pg_receivewal
+ and pg_recvlogical
+ cleanly exit on SIGTERM (Christoph Berg)
+
+ This signal is often used by systemd.
+
+ Build ICU support by default (Jeff Davis)
+
+ This removes build
+ flag --with-icu and adds flag
+ --without-icu.
+
+ Add support for SSE2 (Streaming SIMD Extensions
+ 2) vector operations on x86-64 architectures (John Naylor)
+
+ Add support for Advanced SIMD (Single
+ Instruction Multiple Data) (NEON) instructions
+ on ARM architectures (Nathan Bossart)
+
+ Have Windows
+ binaries built with MSVC use
+ RandomizedBaseAddress (ASLR)
+ (Michael Paquier)
+
+ This was already enabled on MinGW builds.
+
+ Prevent extension libraries from exporting their symbols by default
+ (Andres Freund, Tom Lane)
+
+ Functions that need to be called from the core backend
+ or other extensions must now be explicitly marked
+ PGDLLEXPORT.
+
+ Require Windows 10 or
+ newer versions (Michael Paquier, Juan José Santamaría Flecha)
+
+ Previously Windows Vista and
+ Windows XP were supported.
+
+ Require Perl version 5.14 or later
+ (John Naylor)
+
+ Require Bison version 2.3 or later
+ (John Naylor)
+
+ Require Flex version 2.5.35 or later
+ (John Naylor)
+
+ Require MIT Kerberos for
+ GSSAPI support (Stephen Frost)
+
+ Remove support for Visual Studio 2013
+ (Michael Paquier)
+
+ Remove support for HP-UX
+ (Thomas Munro)
+
+ Remove support for HP/Intel Itanium
+ (Thomas Munro)
+
+ Remove support for M68K,
+ M88K, M32R,
+ and SuperH CPU
+ architectures (Thomas Munro)
+
+ Remove libpq
+ support for SCM credential authentication
+ (Michael Paquier)
+
+ Backend support for this authentication method was removed in
+ PostgresSQL 9.1.
+
+ Add meson
+ build system (Andres Freund, Nazir Bilal Yavuz, Peter Eisentraut)
+
+ This eventually will replace the Autoconf
+ and Windows-based
+ MSVC build systems.
+
+ Allow control of the location of the
+ openssl binary used by the build system
+ (Peter Eisentraut)
+
+ Make finding openssl
+ program a configure or
+ meson option
+
+ Add build option to allow testing of small table segment sizes
+ (Andres Freund)
+
+ The build options are --with-segsize-blocks
+ and -Dsegsize_blocks.
+
+ Add pgindent options
+ (Andrew Dunstan)
+
+ The new options are --show-diff,
+ --silent-diff, --commit,
+ and --help, and allow multiple
+ --exclude options. Also require the typedef file
+ to be explicitly specified. Options --code-base
+ and --build were also removed.
+
+ Add pg_bsd_indent
+ source code to the main tree (Tom Lane)
+
+ Improve make_ctags and
+ make_etags (Yugo Nagata)
+
+ Adjust pg_attribute
+ columns for efficiency (Peter Eisentraut)
+
E.4.3.12. Additional Modules #
+ Improve use of extension-based indexes on boolean columns (Zongliang
+ Quan, Tom Lane)
+
+ Add support for Daitch-Mokotoff Soundex to fuzzystrmatch
+ (Dag Lem)
+
+ Allow auto_explain
+ to log values passed to parameterized statements (Dagfinn Ilmari
+ Mannsåker)
+
+ This affects queries using server-side PREPARE/EXECUTE
+ and client-side parse/bind. Logging is controlled by auto_explain.log_parameter_max_length;
+ by default query parameters will be logged with no length
+ restriction.
+
+ Have auto_explain's
+ log_verbose mode honor the value of compute_query_id
+ (Atsushi Torikoshi)
+
+ Previously even if
+ compute_query_id was enabled, log_verbose
+ was not showing the query identifier.
+
+ Change the maximum length of ltree labels
+ from 256 to 1000 and allow hyphens (Garen Torikian)
+
+ Have pg_stat_statements
+ normalize constants used in utility commands (Michael Paquier)
+
+ Previously constants appeared instead of placeholders, e.g.,
+ $1.
+
+ Add pg_walinspect
+ function pg_get_wal_block_info()
+ to report WAL block information (Michael Paquier,
+ Melanie Plageman, Bharath Rupireddy)
+
+ Change how pg_walinspect
+ functions pg_get_wal_records_info()
+ and pg_get_wal_stats()
+ interpret ending LSNs (Bharath Rupireddy)
+
+ Previously ending LSNs which represent
+ nonexistent WAL locations would generate
+ an error, while they will now be interpreted as the end of the
+ WAL.
+
+ Add detailed descriptions of WAL records in pg_walinspect
+ and pg_waldump
+ (Melanie Plageman, Peter Geoghegan)
+
+ Add pageinspect
+ function bt_multi_page_stats()
+ to report statistics on multiple pages (Hamid Akhtar)
+
+ This is similar to bt_page_stats() except it
+ can report on a range of pages.
+
+ Add empty range output column to pageinspect
+ function brin_page_items()
+ (Tomas Vondra)
+
+ Redesign archive modules to be more flexible (Nathan Bossart)
+
+ Initialization changes will require modules written for older
+ versions of Postgres to be updated.
+
+ Correct inaccurate pg_stat_statements
+ row tracking extended query protocol statements (Sami Imseih)
+
+ Add pg_buffercache
+ function pg_buffercache_usage_counts() to
+ report usage totals (Nathan Bossart)
+
+ Add pg_buffercache
+ function pg_buffercache_summary() to report
+ summarized buffer statistics (Melih Mutlu)
+
+ Allow the schemas of required extensions to be
+ referenced in extension scripts using the new syntax
+ @extschema:referenced_extension_name@
+ (Regina Obe)
+
+ Allow required extensions to
+ be marked as non-relocatable using no_relocate
+ (Regina Obe)
+
+ This allows @extschema:referenced_extension_name@
+ to be treated as a constant for the lifetime of the extension.
+
+ Allow postgres_fdw to do aborts in
+ parallel (Etsuro Fujita)
+
+ This is enabled with
+ postgres_fdw option parallel_abort.
+
+ Make ANALYZE
+ on foreign postgres_fdw tables more
+ efficient (Tomas Vondra)
+
+ The postgres_fdw option analyze_sampling
+ controls the sampling method.
+
+ Restrict shipment of reg* type constants
+ in postgres_fdw to those referencing
+ built-in objects or extensions marked as shippable (Tom Lane)
+
+ Have postgres_fdw and dblink handle
+ interrupts during connection establishment (Andres Freund)
+
+ The following individuals (in alphabetical order) have contributed
+ to this release as patch authors, committers, reviewers, testers,
+ or reporters of issues.
+
| Abhijit Menon-Sen |
| Adam Mackler |
| Adrian Klaver |
| Ahsan Hadi |
| Ajin Cherian |
| Ajit Awekar |
| Alan Hodgson |
| Aleksander Alekseev |
| Alex Denman |
| Alex Kozhemyakin |
| Alexander Korolev |
| Alexander Korotkov |
| Alexander Lakhin |
| Alexander Pyhalov |
| Alexey Borzov |
| Alexey Ermakov |
| Alexey Makhmutov |
| Álvaro Herrera |
| Amit Kapila |
| Amit Khandekar |
| Amit Langote |
| Amul Sul |
| Anastasia Lubennikova |
| Anban Company |
| Andreas Dijkman |
| Andreas Karlsson |
| Andreas Scherbaum |
| Andrei Zubkov |
| Andres Freund |
| Andrew Alsup |
| Andrew Bille |
| Andrew Dunstan |
| Andrew Gierth |
| Andrew Kesper |
| Andrey Borodin |
| Andrey Lepikhov |
| Andrey Sokolov |
| Ankit Kumar Pandey |
| Ante Kresic |
| Anton Melnikov |
| Anton Sidyakin |
| Anton Voloshin |
| Antonin Houska |
| Arne Roland |
| Artem Anisimov |
| Arthur Zakirov |
| Ashutosh Bapat |
| Ashutosh Sharma |
| Asim Praveen |
| Atsushi Torikoshi |
| Ayaki Tachikake |
| Balazs Szilfai |
| Benoit Lobréau |
| Bernd Helmle |
| Bertrand Drouvot |
| Bharath Rupireddy |
| Bilva Sanaba |
| Bob Krier |
| Boris Zentner |
| Brad Nicholson |
| Brar Piening |
| Bruce Momjian |
| Bruno da Silva |
| Carl Sopchak |
| Cary Huang |
| Changhong Fei |
| Chris Travers |
| Christoph Berg |
| Christophe Pettus |
| Corey Huinker |
| Craig Ringer |
| Curt Kolovson |
| Dag Lem |
| Dagfinn Ilmari Mannsåker |
| Daniel Gustafsson |
| Daniel Vérité |
| Daniel Watzinger |
| Daniel Westermann |
| Daniele Varrazzo |
| Daniil Anisimov |
| Danny Shemesh |
| Dave Page |
| David Christensen |
| David G. Johnston |
| David Geier |
| David Gilman |
| David Kimura |
| David Rowley |
| David Steele |
| David Turon |
| David Zhang |
| Davinder Singh |
| Dean Rasheed |
| Denis Laxalde |
| Dilip Kumar |
| Dimos Stamatakis |
| Dmitriy Kuzmin |
| Dmitry Astapov |
| Dmitry Dolgov |
| Dmitry Koval |
| Dong Wook Lee |
| Dongming Liu |
| Drew DeVault |
| Duncan Sands |
| Ed Maste |
| Egor Chindyaskin |
| Ekaterina Kiryanova |
| Elena Indrupskaya |
| Emmanuel Quincerot |
| Eric Mutta |
| Erik Rijkers |
| Erki Eessaar |
| Erwin Brandstetter |
| Etsuro Fujita |
| Eugeny Zhuzhnev |
| Euler Taveira |
| Evan Jones |
| Evgeny Morozov |
| Fabrízio de Royes Mello |
| Farias de Oliveira |
| Florin Irion |
| Franz-Josef Färber |
| Garen Torikian |
| Georgios Kokolatos |
| Gilles Darold |
| Greg Stark |
| Guillaume Lelarge |
| Gunnar Bluth |
| Gunnar Morling |
| Gurjeet Singh |
| Haiyang Wang |
| Haiying Tang |
| Hamid Akhtar |
| Hans Buschmann |
| Hao Wu |
| Hayato Kuroda |
| Heath Lord |
| Heikki Linnakangas |
| Himanshu Upadhyaya |
| Hisahiro Kauchi |
| Hongyu Song |
| Hubert Lubaczewski |
| Hung Nguyen |
| Ian Barwick |
| Ibrar Ahmed |
| Ilya Gladyshev |
| Ilya Nenashev |
| Isaac Morland |
| Israel Barth Rubio |
| Jacob Champion |
| Jacob Speidel |
| Jaime Casanova |
| Jakub Wartak |
| James Coleman |
| James Inform |
| James Vanns |
| Jan Wieck |
| Japin Li |
| Jeevan Ladhe |
| Jeff Davis |
| Jeff Janes |
| Jehan-Guillaume de Rorthais |
| Jelte Fennema |
| Jian He |
| Jim Jones |
| Jinbao Chen |
| Joe Conway |
| Joel Jacobson |
| John Naylor |
| Jonathan Katz |
| Josef Simanek |
| Joseph Koshakow |
| Juan José Santamaría Flecha |
| Julien Rouhaud |
| Julien Roze |
| Junwang Zhao |
| Justin Pryzby |
| Justin Zhang |
| Karina Litskevich |
| Karl O. Pinc |
| Keisuke Kuroda |
| Ken Kato |
| Kevin McKibbin |
| Kieran McCusker |
| Kirk Wolak |
| Konstantin Knizhnik |
| Koshi Shibagaki |
| Kotaro Kawamoto |
| Kui Liu |
| Kyotaro Horiguchi |
| Lakshmi Narayanan Sreethar |
| Laurence Parry |
| Laurenz Albe |
| Luca Ferrari |
| Lukas Fittl |
| Maciek Sakrejda |
| Magnus Hagander |
| Maja Zaloznik |
| Marcel Hofstetter |
| Marina Polyakova |
| Mark Dilger |
| Marko Tiikkaja |
| Markus Winand |
| Martijn van Oosterhout |
| Martin Jurca |
| Martin Kalcher |
| Mary Xu |
| Masahiko Sawada |
| Masahiro Ikeda |
| Masao Fujii |
| Mason Sharp |
| Matheus Alcantara |
| Mats Kindahl |
| Matthias van de Meent |
| Matthijs van der Vleuten |
| Maxim Orlov |
| Maxim Yablokov |
| Mehmet Emin Karakas |
| Melanie Plageman |
| Melih Mutlu |
| Micah Gates |
| Michael Banck |
| Michael Paquier |
| Michail Nikolaev |
| Michel Pelletier |
| Mike Oh |
| Mikhail Gribkov |
| Mingli Zhang |
| Miroslav Bendik |
| Mitsuru Hinata |
| Myo Wai Thant |
| Naeem Akhter |
| Naoki Okano |
| Nathan Bossart |
| Nazir Bilal Yavuz |
| Neha Sharma |
| Nick Babadzhanian |
| Nicola Contu |
| Nikhil Shetty |
| Nikita Glukhov |
| Nikolay Samokhvalov |
| Nikolay Shaplov |
| Nishant Sharma |
| Nitin Jadhav |
| Noah Misch |
| Noboru Saito |
| Noriyoshi Shinoda |
| Nuko Yokohama |
| Oleg Bartunov |
| Oleg Tselebrovskiy |
| Olly Betts |
| Onder Kalaci |
| Onur Tirtir |
| Pablo Federico |
| Palle Girgensohn |
| Paul Guo |
| Paul Jungwirth |
| Paul Ramsey |
| Pavel Borisov |
| Pavel Kulakov |
| Pavel Luzanov |
| Pavel Stehule |
| Peifeng Qiu |
| Peter Eisentraut |
| Peter Geoghegan |
| Peter Smith |
| Phil Florent |
| Philippe Godfrin |
| Platon Pronko |
| Przemyslaw Sztoch |
| Rachel Heaton |
| Ranier Vilela |
| Regina Obe |
| Reid Thompson |
| Reiner Peterke |
| Richard Guo |
| Riivo Kolka |
| Rishu Bagga |
| Robert Haas |
| Robert Sjöblom |
| Robert Treat |
| Roberto Mello |
| Robins Tharakan |
| Roman Zharkov |
| Ronan Dunklau |
| Rushabh Lathia |
| Ryo Matsumura |
| Samay Sharma |
| Sami Imseih |
| Sandeep Thakkar |
| Sandro Santilli |
| Sebastien Flaesch |
| Sébastien Lardière |
| Sehrope Sarkuni |
| Sergey Belyashov |
| Sergey Pankov |
| Sergey Shinderuk |
| Shi Yu |
| Shinya Kato |
| Sho Kato |
| Shruthi Gowda |
| Shveta Mallik |
| Simon Riggs |
| Sindy Senorita |
| Sirisha Chamarthi |
| Sravan Kumar |
| Stéphane Tachoires |
| Stephen Frost |
| Steve Chavez |
| Stone Tickle |
| Sven Klemm |
| Takamichi Osumi |
| Takeshi Ideriha |
| Tatsuhiro Nakamori |
| Tatsuo Ishii |
| Teja Mupparti |
| Tender Wang |
| Teodor Sigaev |
| Thiago Nunes |
| Thom Brown |
| Thomas Habets |
| Thomas Mc Kay |
| Thomas Munro |
| Tim Carey-Smith |
| Tim Field |
| Timo Stolz |
| Tom Lane |
| Tomas Vondra |
| Tor Erik Linnerud |
| Torsten Förtsch |
| Tristan Partin |
| Troy Frericks |
| Tushar Ahuja |
| Valerie Woolard |
| Vibhor Kumar |
| Victor Spirin |
| Victoria Shepard |
| Vignesh C |
| Vik Fearing |
| Vitaly Burovoy |
| Vitaly Davydov |
| Wang Wei |
| Wenjing Zeng |
| Whale Song |
| Will Mortensen |
| Wolfgang Walther |
| Xin Wen |
| Xing Guo |
| Xingwang Xu |
| XueJing Zhao |
| Yanliang Lei |
| Youmiu Mo |
| Yugo Nagata |
| Yura Sokolov |
| Yuta Katsuragi |
| Zhen Mingyang |
| Zheng Li |
| Zhihong Yu |
| Zhijie Hou |
| Zongliang Quan |
| Zuming Jiang |
Appendix E. Release Notes
+ The release notes contain the significant changes in each
+ PostgreSQL release, with major features and migration
+ issues listed at the top. The release notes do not contain changes
+ that affect only a few users or changes that are internal and therefore not
+ user-visible. For example, the optimizer is improved in almost every
+ release, but the improvements are usually observed by users as simply
+ faster queries.
+
+ A complete list of changes for each release can be obtained by
+ viewing the Git logs for each release.
+ The pgsql-committers
+ email list records all source code changes as well. There is also
+ a web
+ interface that shows changes to specific files.
+
+ The name appearing next to each item represents the major developer for
+ that item. Of course all changes involve community discussion and patch
+ review, so each item is truly a community effort.
+
Chapter 50. Replication Progress Tracking
+ Replication origins are intended to make it easier to implement
+ logical replication solutions on top
+ of logical decoding.
+ They provide a solution to two common problems:
+
How to safely keep track of replication progress
How to change replication behavior based on the
+ origin of a row; for example, to prevent loops in bi-directional
+ replication setups
+
+ Replication origins have just two properties, a name and an ID. The name,
+ which is what should be used to refer to the origin across systems, is
+ free-form text. It should be used in a way that makes conflicts
+ between replication origins created by different replication solutions
+ unlikely; e.g., by prefixing the replication solution's name to it.
+ The ID is used only to avoid having to store the long version
+ in situations where space efficiency is important. It should never be shared
+ across systems.
+
+ Replication origins can be created using the function
+ pg_replication_origin_create();
+ dropped using
+ pg_replication_origin_drop();
+ and seen in the
+ pg_replication_origin
+ system catalog.
+
+ One nontrivial part of building a replication solution is to keep track of
+ replay progress in a safe manner. When the applying process, or the whole
+ cluster, dies, it needs to be possible to find out up to where data has
+ successfully been replicated. Naive solutions to this, such as updating a
+ row in a table for every replayed transaction, have problems like run-time
+ overhead and database bloat.
+
+ Using the replication origin infrastructure a session can be
+ marked as replaying from a remote node (using the
+ pg_replication_origin_session_setup()
+ function). Additionally the LSN and commit
+ time stamp of every source transaction can be configured on a per
+ transaction basis using
+ pg_replication_origin_xact_setup().
+ If that's done replication progress will persist in a crash safe
+ manner. Replay progress for all replication origins can be seen in the
+
+ pg_replication_origin_status
+ view. An individual origin's progress, e.g., when resuming
+ replication, can be acquired using
+ pg_replication_origin_progress()
+ for any origin or
+ pg_replication_origin_session_progress()
+ for the origin configured in the current session.
+
+ In replication topologies more complex than replication from exactly one
+ system to one other system, another problem can be that it is hard to avoid
+ replicating replayed rows again. That can lead both to cycles in the
+ replication and inefficiencies. Replication origins provide an optional
+ mechanism to recognize and prevent that. When configured using the functions
+ referenced in the previous paragraph, every change and transaction passed to
+ output plugin callbacks (see Section 49.6)
+ generated by the session is tagged with the replication origin of the
+ generating session. This allows treating them differently in the output
+ plugin, e.g., ignoring all but locally-originating rows. Additionally
+ the
+ filter_by_origin_cb callback can be used
+ to filter the logical decoding change stream based on the
+ source. While less flexible, filtering via that callback is
+ considerably more efficient than doing it in the output plugin.
+
+ Besides the documentation, that is, this book, there are other
+ resources about PostgreSQL:
+
+
- Wiki
+ The PostgreSQL wiki contains the project's FAQ
+ (Frequently Asked Questions) list, TODO list, and
+ detailed information about many more topics.
+
- Web Site
+ The PostgreSQL
+ web site
+ carries details on the latest release and other
+ information to make your work or play with
+ PostgreSQL more productive.
+
- Mailing Lists
+ The mailing lists are a good place to have your questions
+ answered, to share experiences with other users, and to contact
+ the developers. Consult the PostgreSQL web site
+ for details.
+
- Yourself!
+ PostgreSQL is an open-source project.
+ As such, it depends on the user community for ongoing support.
+ As you begin to use PostgreSQL, you
+ will rely on others for help, either through the documentation
+ or through the mailing lists. Consider contributing your
+ knowledge back. Read the mailing lists and answer questions. If
+ you learn something which is not in the documentation, write it
+ up and contribute it. If you add features to the code,
+ contribute them.
+
+
+ A database role can have a number of attributes that define its
+ privileges and interact with the client authentication system.
+
+
- login privilege
+ Only roles that have the LOGIN attribute can be used
+ as the initial role name for a database connection. A role with
+ the LOGIN attribute can be considered the same
+ as a “database user”. To create a role with login privilege,
+ use either:
+
+CREATE ROLE name LOGIN;
+CREATE USER name;
+
+ (CREATE USER is equivalent to CREATE ROLE
+ except that CREATE USER includes LOGIN by
+ default, while CREATE ROLE does not.)
+
- superuser status
+ A database superuser bypasses all permission checks, except the right
+ to log in. This is a dangerous privilege and should not be used
+ carelessly; it is best to do most of your work as a role that is not a
+ superuser. To create a new database superuser, use CREATE
+ ROLE name SUPERUSER. You must do
+ this as a role that is already a superuser.
+
- database creation
+ A role must be explicitly given permission to create databases
+ (except for superusers, since those bypass all permission
+ checks). To create such a role, use CREATE ROLE
+ name CREATEDB.
+
- role creation
+ A role must be explicitly given permission to create more roles
+ (except for superusers, since those bypass all permission
+ checks). To create such a role, use CREATE ROLE
+ name CREATEROLE.
+ A role with CREATEROLE privilege can alter and drop
+ roles which have been granted to the CREATEROLE
+ user with the ADMIN option. Such a grant occurs
+ automatically when a CREATEROLE user that is not
+ a superuser creates a new role, so that by default, a
+ CREATEROLE user can alter and drop the roles
+ which they have created.
+ Altering a role includes most changes that can be made using
+ ALTER ROLE, including, for example, changing
+ passwords. It also includes modifications to a role that can
+ be made using the COMMENT and
+ SECURITY LABEL commands.
+
+ However, CREATEROLE does not convey the ability to
+ create SUPERUSER roles, nor does it convey any
+ power over SUPERUSER roles that already exist.
+ Furthermore, CREATEROLE does not convey the power
+ to create REPLICATION users, nor the ability to
+ grant or revoke the REPLICATION privilege, nor the
+ ability to modify the role properties of such users. However, it does
+ allow ALTER ROLE ... SET and
+ ALTER ROLE ... RENAME to be used on
+ REPLICATION roles, as well as the use of
+ COMMENT ON ROLE,
+ SECURITY LABEL ON ROLE,
+ and DROP ROLE.
+ Finally, CREATEROLE does not
+ confer the ability to grant or revoke the BYPASSRLS
+ privilege.
+
- initiating replication
+ A role must explicitly be given permission to initiate streaming
+ replication (except for superusers, since those bypass all permission
+ checks). A role used for streaming replication must
+ have LOGIN permission as well. To create such a role, use
+ CREATE ROLE name REPLICATION
+ LOGIN.
+
- password
+ A password is only significant if the client authentication
+ method requires the user to supply a password when connecting
+ to the database. The password and
+ md5 authentication methods
+ make use of passwords. Database passwords are separate from
+ operating system passwords. Specify a password upon role
+ creation with CREATE ROLE
+ name PASSWORD 'string'.
+
- inheritance of privileges
+ A role inherits the privileges of roles it is a member of, by default.
+ However, to create a role which does not inherit privileges by
+ default, use CREATE ROLE name
+ NOINHERIT. Alternatively, inheritance can be overridden
+ for individual grants by using WITH INHERIT TRUE
+ or WITH INHERIT FALSE.
+
- bypassing row-level security
+ A role must be explicitly given permission to bypass every row-level security (RLS) policy
+ (except for superusers, since those bypass all permission checks).
+ To create such a role, use CREATE ROLE name BYPASSRLS as a superuser.
+
- connection limit
+ Connection limit can specify how many concurrent connections a role can make.
+ -1 (the default) means no limit. Specify connection limit upon role creation with
+ CREATE ROLE name CONNECTION LIMIT 'integer'.
+
+
+ A role's attributes can be modified after creation with
+ ALTER ROLE.
+ See the reference pages for the CREATE ROLE
+ and ALTER ROLE commands for details.
+
+ A role can also have role-specific defaults for many of the run-time
+ configuration settings described in Chapter 20. For example, if for some reason you
+ want to disable index scans (hint: not a good idea) anytime you
+ connect, you can use:
+
+ALTER ROLE myname SET enable_indexscan TO off;
+
+ This will save the setting (but not set it immediately). In
+ subsequent connections by this role it will appear as though
+ SET enable_indexscan TO off had been executed
+ just before the session started.
+ You can still alter this setting during the session; it will only
+ be the default. To remove a role-specific default setting, use
+ ALTER ROLE rolename RESET varname.
+ Note that role-specific defaults attached to roles without
+ LOGIN privilege are fairly useless, since they will never
+ be invoked.
+
+ When a non-superuser creates a role using the CREATEROLE
+ privilege, the created role is automatically granted back to the creating
+ user, just as if the bootstrap superuser had executed the command
+ GRANT created_user TO creating_user WITH ADMIN TRUE, SET FALSE,
+ INHERIT FALSE. Since a CREATEROLE user can
+ only exercise special privileges with regard to an existing role if they
+ have ADMIN OPTION on it, this grant is just sufficient
+ to allow a CREATEROLE user to administer the roles they
+ created. However, because it is created with INHERIT FALSE, SET
+ FALSE, the CREATEROLE user doesn't inherit the
+ privileges of the created role, nor can it access the privileges of that
+ role using SET ROLE. However, since any user who has
+ ADMIN OPTION on a role can grant membership in that
+ role to any other user, the CREATEROLE user can gain
+ access to the created role by simply granting that role back to
+ themselves with the INHERIT and/or SET
+ options. Thus, the fact that privileges are not inherited by default nor
+ is SET ROLE granted by default is a safeguard against
+ accidents, not a security feature. Also note that, because this automatic
+ grant is granted by the bootstrap user, it cannot be removed or changed by
+ the CREATEROLE user; however, any superuser could
+ revoke it, modify it, and/or issue additional such grants to other
+ CREATEROLE users. Whichever CREATEROLE
+ users have ADMIN OPTION on a role at any given time
+ can administer it.
+
+ It is frequently convenient to group users together to ease
+ management of privileges: that way, privileges can be granted to, or
+ revoked from, a group as a whole. In PostgreSQL
+ this is done by creating a role that represents the group, and then
+ granting membership in the group role to individual user
+ roles.
+
+ To set up a group role, first create the role:
+
+CREATE ROLE name;
+
+ Typically a role being used as a group would not have the LOGIN
+ attribute, though you can set it if you wish.
+
+ Once the group role exists, you can add and remove members using the
+ GRANT and
+ REVOKE commands:
+
+GRANT group_role TO role1, ... ;
+REVOKE group_role FROM role1, ... ;
+
+ You can grant membership to other group roles, too (since there isn't
+ really any distinction between group roles and non-group roles). The
+ database will not let you set up circular membership loops. Also,
+ it is not permitted to grant membership in a role to
+ PUBLIC.
+
+ The members of a group role can use the privileges of the role in two
+ ways. First, member roles that have been granted membership with the
+ SET option can do
+ SET ROLE to
+ temporarily “become” the group role. In this state, the
+ database session has access to the privileges of the group role rather
+ than the original login role, and any database objects created are
+ considered owned by the group role not the login role. Second, member
+ roles that have been granted membership with the
+ INHERIT option automatically have use of the
+ privileges of those directly or indirectly a member of, though the
+ chain stops at memberships lacking the inherit option. As an example,
+ suppose we have done:
+
+CREATE ROLE joe LOGIN;
+CREATE ROLE admin;
+CREATE ROLE wheel;
+CREATE ROLE island;
+GRANT admin TO joe WITH INHERIT TRUE;
+GRANT wheel TO admin WITH INHERIT FALSE;
+GRANT island TO joe WITH INHERIT TRUE, SET FALSE;
+
+ Immediately after connecting as role joe, a database
+ session will have use of privileges granted directly to joe
+ plus any privileges granted to admin and
+ island, because joe
+ “inherits” those privileges. However, privileges
+ granted to wheel are not available, because even though
+ joe is indirectly a member of wheel, the
+ membership is via admin which was granted using
+ WITH INHERIT FALSE. After:
+
+SET ROLE admin;
+
+ the session would have use of only those privileges granted to
+ admin, and not those granted to joe or
+ island. After:
+
+SET ROLE wheel;
+
+ the session would have use of only those privileges granted to
+ wheel, and not those granted to either joe
+ or admin. The original privilege state can be restored
+ with any of:
+
+SET ROLE joe;
+SET ROLE NONE;
+RESET ROLE;
+
+
Note
+ The SET ROLE command always allows selecting any role
+ that the original login role is directly or indirectly a member of,
+ provided that there is a chain of membership grants each of which has
+ SET TRUE (which is the default).
+ Thus, in the above example, it is not necessary to become
+ admin before becoming wheel.
+ On the other hand, it is not possible to become island
+ at all; joe can only access those privileges via
+ inheritance.
+
Note
+ In the SQL standard, there is a clear distinction between users and roles,
+ and users do not automatically inherit privileges while roles do. This
+ behavior can be obtained in PostgreSQL by giving
+ roles being used as SQL roles the INHERIT attribute, while
+ giving roles being used as SQL users the NOINHERIT attribute.
+ However, PostgreSQL defaults to giving all roles
+ the INHERIT attribute, for backward compatibility with pre-8.1
+ releases in which users always had use of permissions granted to groups
+ they were members of.
+
+ The role attributes LOGIN, SUPERUSER,
+ CREATEDB, and CREATEROLE can be thought of as
+ special privileges, but they are never inherited as ordinary privileges
+ on database objects are. You must actually SET ROLE to a
+ specific role having one of these attributes in order to make use of
+ the attribute. Continuing the above example, we might choose to
+ grant CREATEDB and CREATEROLE to the
+ admin role. Then a session connecting as role joe
+ would not have these privileges immediately, only after doing
+ SET ROLE admin.
+
+
+ To destroy a group role, use DROP ROLE:
+
+DROP ROLE name;
+
+ Any memberships in the group role are automatically revoked (but the
+ member roles are not otherwise affected).
+
+ Because roles can own database objects and can hold privileges
+ to access other objects, dropping a role is often not just a matter of a
+ quick DROP ROLE. Any objects owned by the role must
+ first be dropped or reassigned to other owners; and any permissions
+ granted to the role must be revoked.
+
+ Ownership of objects can be transferred one at a time
+ using ALTER commands, for example:
+
+ALTER TABLE bobs_table OWNER TO alice;
+
+ Alternatively, the REASSIGN OWNED command can be
+ used to reassign ownership of all objects owned by the role-to-be-dropped
+ to a single other role. Because REASSIGN OWNED cannot access
+ objects in other databases, it is necessary to run it in each database
+ that contains objects owned by the role. (Note that the first
+ such REASSIGN OWNED will change the ownership of any
+ shared-across-databases objects, that is databases or tablespaces, that
+ are owned by the role-to-be-dropped.)
+
+ Once any valuable objects have been transferred to new owners, any
+ remaining objects owned by the role-to-be-dropped can be dropped with
+ the DROP OWNED command. Again, this command cannot
+ access objects in other databases, so it is necessary to run it in each
+ database that contains objects owned by the role. Also, DROP
+ OWNED will not drop entire databases or tablespaces, so it is
+ necessary to do that manually if the role owns any databases or
+ tablespaces that have not been transferred to new owners.
+
+ DROP OWNED also takes care of removing any privileges granted
+ to the target role for objects that do not belong to it.
+ Because REASSIGN OWNED does not touch such objects, it's
+ typically necessary to run both REASSIGN OWNED
+ and DROP OWNED (in that order!) to fully remove the
+ dependencies of a role to be dropped.
+
+ In short then, the most general recipe for removing a role that has been
+ used to own objects is:
+
+REASSIGN OWNED BY doomed_role TO successor_role;
+DROP OWNED BY doomed_role;
+-- repeat the above commands in each database of the cluster
+DROP ROLE doomed_role;
+
+ When not all owned objects are to be transferred to the same successor
+ owner, it's best to handle the exceptions manually and then perform
+ the above steps to mop up.
+
+ If DROP ROLE is attempted while dependent objects still
+ remain, it will issue messages identifying which objects need to be
+ reassigned or dropped.
+
25.2. Routine Reindexing #
+ In some situations it is worthwhile to rebuild indexes periodically
+ with the REINDEX command or a series of individual
+ rebuilding steps.
+
+
+ B-tree index pages that have become completely empty are reclaimed for
+ re-use. However, there is still a possibility
+ of inefficient use of space: if all but a few index keys on a page have
+ been deleted, the page remains allocated. Therefore, a usage
+ pattern in which most, but not all, keys in each range are eventually
+ deleted will see poor use of space. For such usage patterns,
+ periodic reindexing is recommended.
+
+ The potential for bloat in non-B-tree indexes has not been well
+ researched. It is a good idea to periodically monitor the index's physical
+ size when using any non-B-tree index type.
+
+ Also, for B-tree indexes, a freshly-constructed index is slightly faster to
+ access than one that has been updated many times because logically
+ adjacent pages are usually also physically adjacent in a newly built index.
+ (This consideration does not apply to non-B-tree indexes.) It
+ might be worthwhile to reindex periodically just to improve access speed.
+
+ REINDEX can be used safely and easily in all cases.
+ This command requires an ACCESS EXCLUSIVE lock by
+ default, hence it is often preferable to execute it with its
+ CONCURRENTLY option, which requires only a
+ SHARE UPDATE EXCLUSIVE lock.
+
25.1. Routine Vacuuming #
+ PostgreSQL databases require periodic
+ maintenance known as vacuuming. For many installations, it
+ is sufficient to let vacuuming be performed by the autovacuum
+ daemon, which is described in Section 25.1.6. You might
+ need to adjust the autovacuuming parameters described there to obtain best
+ results for your situation. Some database administrators will want to
+ supplement or replace the daemon's activities with manually-managed
+ VACUUM commands, which typically are executed according to a
+ schedule by cron or Task
+ Scheduler scripts. To set up manually-managed vacuuming properly,
+ it is essential to understand the issues discussed in the next few
+ subsections. Administrators who rely on autovacuuming may still wish
+ to skim this material to help them understand and adjust autovacuuming.
+
25.1.1. Vacuuming Basics #
+ PostgreSQL's
+ VACUUM command has to
+ process each table on a regular basis for several reasons:
+
+
- To recover or reuse disk space occupied by updated or deleted
+ rows.
- To update data statistics used by the
+ PostgreSQL query planner.
- To update the visibility map, which speeds
+ up index-only
+ scans.
- To protect against loss of very old data due to
+ transaction ID wraparound or
+ multixact ID wraparound.
+
+ Each of these reasons dictates performing VACUUM operations
+ of varying frequency and scope, as explained in the following subsections.
+
+ There are two variants of VACUUM: standard VACUUM
+ and VACUUM FULL. VACUUM FULL can reclaim more
+ disk space but runs much more slowly. Also,
+ the standard form of VACUUM can run in parallel with production
+ database operations. (Commands such as SELECT,
+ INSERT, UPDATE, and
+ DELETE will continue to function normally, though you
+ will not be able to modify the definition of a table with commands such as
+ ALTER TABLE while it is being vacuumed.)
+ VACUUM FULL requires an
+ ACCESS EXCLUSIVE lock on the table it is
+ working on, and therefore cannot be done in parallel with other use
+ of the table. Generally, therefore,
+ administrators should strive to use standard VACUUM and
+ avoid VACUUM FULL.
+
+ VACUUM creates a substantial amount of I/O
+ traffic, which can cause poor performance for other active sessions.
+ There are configuration parameters that can be adjusted to reduce the
+ performance impact of background vacuuming — see
+ Section 20.4.4.
+
25.1.2. Recovering Disk Space #
+ In PostgreSQL, an
+ UPDATE or DELETE of a row does not
+ immediately remove the old version of the row.
+ This approach is necessary to gain the benefits of multiversion
+ concurrency control (MVCC, see Chapter 13): the row version
+ must not be deleted while it is still potentially visible to other
+ transactions. But eventually, an outdated or deleted row version is no
+ longer of interest to any transaction. The space it occupies must then be
+ reclaimed for reuse by new rows, to avoid unbounded growth of disk
+ space requirements. This is done by running VACUUM.
+
+ The standard form of VACUUM removes dead row
+ versions in tables and indexes and marks the space available for
+ future reuse. However, it will not return the space to the operating
+ system, except in the special case where one or more pages at the
+ end of a table become entirely free and an exclusive table lock can be
+ easily obtained. In contrast, VACUUM FULL actively compacts
+ tables by writing a complete new version of the table file with no dead
+ space. This minimizes the size of the table, but can take a long time.
+ It also requires extra disk space for the new copy of the table, until
+ the operation completes.
+
+ The usual goal of routine vacuuming is to do standard VACUUMs
+ often enough to avoid needing VACUUM FULL. The
+ autovacuum daemon attempts to work this way, and in fact will
+ never issue VACUUM FULL. In this approach, the idea
+ is not to keep tables at their minimum size, but to maintain steady-state
+ usage of disk space: each table occupies space equivalent to its
+ minimum size plus however much space gets used up between vacuum runs.
+ Although VACUUM FULL can be used to shrink a table back
+ to its minimum size and return the disk space to the operating system,
+ there is not much point in this if the table will just grow again in the
+ future. Thus, moderately-frequent standard VACUUM runs are a
+ better approach than infrequent VACUUM FULL runs for
+ maintaining heavily-updated tables.
+
+ Some administrators prefer to schedule vacuuming themselves, for example
+ doing all the work at night when load is low.
+ The difficulty with doing vacuuming according to a fixed schedule
+ is that if a table has an unexpected spike in update activity, it may
+ get bloated to the point that VACUUM FULL is really necessary
+ to reclaim space. Using the autovacuum daemon alleviates this problem,
+ since the daemon schedules vacuuming dynamically in response to update
+ activity. It is unwise to disable the daemon completely unless you
+ have an extremely predictable workload. One possible compromise is
+ to set the daemon's parameters so that it will only react to unusually
+ heavy update activity, thus keeping things from getting out of hand,
+ while scheduled VACUUMs are expected to do the bulk of the
+ work when the load is typical.
+
+ For those not using autovacuum, a typical approach is to schedule a
+ database-wide VACUUM once a day during a low-usage period,
+ supplemented by more frequent vacuuming of heavily-updated tables as
+ necessary. (Some installations with extremely high update rates vacuum
+ their busiest tables as often as once every few minutes.) If you have
+ multiple databases in a cluster, don't forget to
+ VACUUM each one; the program vacuumdb might be helpful.
+
Tip
+ Plain VACUUM may not be satisfactory when
+ a table contains large numbers of dead row versions as a result of
+ massive update or delete activity. If you have such a table and
+ you need to reclaim the excess disk space it occupies, you will need
+ to use VACUUM FULL, or alternatively
+ CLUSTER
+ or one of the table-rewriting variants of
+ ALTER TABLE.
+ These commands rewrite an entire new copy of the table and build
+ new indexes for it. All these options require an
+ ACCESS EXCLUSIVE lock. Note that
+ they also temporarily use extra disk space approximately equal to the size
+ of the table, since the old copies of the table and indexes can't be
+ released until the new ones are complete.
+
Tip
+ If you have a table whose entire contents are deleted on a periodic
+ basis, consider doing it with
+ TRUNCATE rather
+ than using DELETE followed by
+ VACUUM. TRUNCATE removes the
+ entire content of the table immediately, without requiring a
+ subsequent VACUUM or VACUUM
+ FULL to reclaim the now-unused disk space.
+ The disadvantage is that strict MVCC semantics are violated.
+
25.1.3. Updating Planner Statistics #
+ The PostgreSQL query planner relies on
+ statistical information about the contents of tables in order to
+ generate good plans for queries. These statistics are gathered by
+ the ANALYZE command,
+ which can be invoked by itself or
+ as an optional step in VACUUM. It is important to have
+ reasonably accurate statistics, otherwise poor choices of plans might
+ degrade database performance.
+
+ The autovacuum daemon, if enabled, will automatically issue
+ ANALYZE commands whenever the content of a table has
+ changed sufficiently. However, administrators might prefer to rely
+ on manually-scheduled ANALYZE operations, particularly
+ if it is known that update activity on a table will not affect the
+ statistics of “interesting” columns. The daemon schedules
+ ANALYZE strictly as a function of the number of rows
+ inserted or updated; it has no knowledge of whether that will lead
+ to meaningful statistical changes.
+
+ Tuples changed in partitions and inheritance children do not trigger
+ analyze on the parent table. If the parent table is empty or rarely
+ changed, it may never be processed by autovacuum, and the statistics for
+ the inheritance tree as a whole won't be collected. It is necessary to
+ run ANALYZE on the parent table manually in order to
+ keep the statistics up to date.
+
+ As with vacuuming for space recovery, frequent updates of statistics
+ are more useful for heavily-updated tables than for seldom-updated
+ ones. But even for a heavily-updated table, there might be no need for
+ statistics updates if the statistical distribution of the data is
+ not changing much. A simple rule of thumb is to think about how much
+ the minimum and maximum values of the columns in the table change.
+ For example, a timestamp column that contains the time
+ of row update will have a constantly-increasing maximum value as
+ rows are added and updated; such a column will probably need more
+ frequent statistics updates than, say, a column containing URLs for
+ pages accessed on a website. The URL column might receive changes just
+ as often, but the statistical distribution of its values probably
+ changes relatively slowly.
+
+ It is possible to run ANALYZE on specific tables and even
+ just specific columns of a table, so the flexibility exists to update some
+ statistics more frequently than others if your application requires it.
+ In practice, however, it is usually best to just analyze the entire
+ database, because it is a fast operation. ANALYZE uses a
+ statistically random sampling of the rows of a table rather than reading
+ every single row.
+
Tip
+ Although per-column tweaking of ANALYZE frequency might not be
+ very productive, you might find it worthwhile to do per-column
+ adjustment of the level of detail of the statistics collected by
+ ANALYZE. Columns that are heavily used in WHERE
+ clauses and have highly irregular data distributions might require a
+ finer-grain data histogram than other columns. See ALTER TABLE
+ SET STATISTICS, or change the database-wide default using the default_statistics_target configuration parameter.
+
+ Also, by default there is limited information available about
+ the selectivity of functions. However, if you create a statistics
+ object or an expression
+ index that uses a function call, useful statistics will be
+ gathered about the function, which can greatly improve query
+ plans that use the expression index.
+
Tip
+ The autovacuum daemon does not issue ANALYZE commands for
+ foreign tables, since it has no means of determining how often that
+ might be useful. If your queries require statistics on foreign tables
+ for proper planning, it's a good idea to run manually-managed
+ ANALYZE commands on those tables on a suitable schedule.
+
Tip
+ The autovacuum daemon does not issue ANALYZE commands
+ for partitioned tables. Inheritance parents will only be analyzed if the
+ parent itself is changed - changes to child tables do not trigger
+ autoanalyze on the parent table. If your queries require statistics on
+ parent tables for proper planning, it is necessary to periodically run
+ a manual ANALYZE on those tables to keep the statistics
+ up to date.
+
25.1.4. Updating the Visibility Map #
+ Vacuum maintains a visibility map for each
+ table to keep track of which pages contain only tuples that are known to be
+ visible to all active transactions (and all future transactions, until the
+ page is again modified). This has two purposes. First, vacuum
+ itself can skip such pages on the next run, since there is nothing to
+ clean up.
+
+ Second, it allows PostgreSQL to answer some
+ queries using only the index, without reference to the underlying table.
+ Since PostgreSQL indexes don't contain tuple
+ visibility information, a normal index scan fetches the heap tuple for each
+ matching index entry, to check whether it should be seen by the current
+ transaction.
+ An index-only
+ scan, on the other hand, checks the visibility map first.
+ If it's known that all tuples on the page are
+ visible, the heap fetch can be skipped. This is most useful on
+ large data sets where the visibility map can prevent disk accesses.
+ The visibility map is vastly smaller than the heap, so it can easily be
+ cached even when the heap is very large.
+
25.1.5. Preventing Transaction ID Wraparound Failures #
+ PostgreSQL's
+ MVCC transaction semantics
+ depend on being able to compare transaction ID (XID)
+ numbers: a row version with an insertion XID greater than the current
+ transaction's XID is “in the future” and should not be visible
+ to the current transaction. But since transaction IDs have limited size
+ (32 bits) a cluster that runs for a long time (more
+ than 4 billion transactions) would suffer transaction ID
+ wraparound: the XID counter wraps around to zero, and all of a sudden
+ transactions that were in the past appear to be in the future — which
+ means their output become invisible. In short, catastrophic data loss.
+ (Actually the data is still there, but that's cold comfort if you cannot
+ get at it.) To avoid this, it is necessary to vacuum every table
+ in every database at least once every two billion transactions.
+
+ The reason that periodic vacuuming solves the problem is that
+ VACUUM will mark rows as frozen, indicating that
+ they were inserted by a transaction that committed sufficiently far in
+ the past that the effects of the inserting transaction are certain to be
+ visible to all current and future transactions.
+ Normal XIDs are
+ compared using modulo-232 arithmetic. This means
+ that for every normal XID, there are two billion XIDs that are
+ “older” and two billion that are “newer”; another
+ way to say it is that the normal XID space is circular with no
+ endpoint. Therefore, once a row version has been created with a particular
+ normal XID, the row version will appear to be “in the past” for
+ the next two billion transactions, no matter which normal XID we are
+ talking about. If the row version still exists after more than two billion
+ transactions, it will suddenly appear to be in the future. To
+ prevent this, PostgreSQL reserves a special XID,
+ FrozenTransactionId, which does not follow the normal XID
+ comparison rules and is always considered older
+ than every normal XID.
+ Frozen row versions are treated as if the inserting XID were
+ FrozenTransactionId, so that they will appear to be
+ “in the past” to all normal transactions regardless of wraparound
+ issues, and so such row versions will be valid until deleted, no matter
+ how long that is.
+
Note
+ In PostgreSQL versions before 9.4, freezing was
+ implemented by actually replacing a row's insertion XID
+ with FrozenTransactionId, which was visible in the
+ row's xmin system column. Newer versions just set a flag
+ bit, preserving the row's original xmin for possible
+ forensic use. However, rows with xmin equal
+ to FrozenTransactionId (2) may still be found
+ in databases pg_upgrade'd from pre-9.4 versions.
+
+ Also, system catalogs may contain rows with xmin equal
+ to BootstrapTransactionId (1), indicating that they were
+ inserted during the first phase of initdb.
+ Like FrozenTransactionId, this special XID is treated as
+ older than every normal XID.
+
+ vacuum_freeze_min_age
+ controls how old an XID value has to be before rows bearing that XID will be
+ frozen. Increasing this setting may avoid unnecessary work if the
+ rows that would otherwise be frozen will soon be modified again,
+ but decreasing this setting increases
+ the number of transactions that can elapse before the table must be
+ vacuumed again.
+
+ VACUUM uses the visibility map
+ to determine which pages of a table must be scanned. Normally, it
+ will skip pages that don't have any dead row versions even if those pages
+ might still have row versions with old XID values. Therefore, normal
+ VACUUMs won't always freeze every old row version in the table.
+ When that happens, VACUUM will eventually need to perform an
+ aggressive vacuum, which will freeze all eligible unfrozen
+ XID and MXID values, including those from all-visible but not all-frozen pages.
+ In practice most tables require periodic aggressive vacuuming.
+ vacuum_freeze_table_age
+ controls when VACUUM does that: all-visible but not all-frozen
+ pages are scanned if the number of transactions that have passed since the
+ last such scan is greater than vacuum_freeze_table_age minus
+ vacuum_freeze_min_age. Setting
+ vacuum_freeze_table_age to 0 forces VACUUM to
+ always use its aggressive strategy.
+
+ The maximum time that a table can go unvacuumed is two billion
+ transactions minus the vacuum_freeze_min_age value at
+ the time of the last aggressive vacuum. If it were to go
+ unvacuumed for longer than
+ that, data loss could result. To ensure that this does not happen,
+ autovacuum is invoked on any table that might contain unfrozen rows with
+ XIDs older than the age specified by the configuration parameter autovacuum_freeze_max_age. (This will happen even if
+ autovacuum is disabled.)
+
+ This implies that if a table is not otherwise vacuumed,
+ autovacuum will be invoked on it approximately once every
+ autovacuum_freeze_max_age minus
+ vacuum_freeze_min_age transactions.
+ For tables that are regularly vacuumed for space reclamation purposes,
+ this is of little importance. However, for static tables
+ (including tables that receive inserts, but no updates or deletes),
+ there is no need to vacuum for space reclamation, so it can
+ be useful to try to maximize the interval between forced autovacuums
+ on very large static tables. Obviously one can do this either by
+ increasing autovacuum_freeze_max_age or decreasing
+ vacuum_freeze_min_age.
+
+ The effective maximum for vacuum_freeze_table_age is 0.95 *
+ autovacuum_freeze_max_age; a setting higher than that will be
+ capped to the maximum. A value higher than
+ autovacuum_freeze_max_age wouldn't make sense because an
+ anti-wraparound autovacuum would be triggered at that point anyway, and
+ the 0.95 multiplier leaves some breathing room to run a manual
+ VACUUM before that happens. As a rule of thumb,
+ vacuum_freeze_table_age should be set to a value somewhat
+ below autovacuum_freeze_max_age, leaving enough gap so that
+ a regularly scheduled VACUUM or an autovacuum triggered by
+ normal delete and update activity is run in that window. Setting it too
+ close could lead to anti-wraparound autovacuums, even though the table
+ was recently vacuumed to reclaim space, whereas lower values lead to more
+ frequent aggressive vacuuming.
+
+ The sole disadvantage of increasing autovacuum_freeze_max_age
+ (and vacuum_freeze_table_age along with it) is that
+ the pg_xact and pg_commit_ts
+ subdirectories of the database cluster will take more space, because it
+ must store the commit status and (if track_commit_timestamp is
+ enabled) timestamp of all transactions back to
+ the autovacuum_freeze_max_age horizon. The commit status uses
+ two bits per transaction, so if
+ autovacuum_freeze_max_age is set to its maximum allowed value
+ of two billion, pg_xact can be expected to grow to about half
+ a gigabyte and pg_commit_ts to about 20GB. If this
+ is trivial compared to your total database size,
+ setting autovacuum_freeze_max_age to its maximum allowed value
+ is recommended. Otherwise, set it depending on what you are willing to
+ allow for pg_xact and pg_commit_ts storage.
+ (The default, 200 million transactions, translates to about 50MB
+ of pg_xact storage and about 2GB of pg_commit_ts
+ storage.)
+
+ One disadvantage of decreasing vacuum_freeze_min_age is that
+ it might cause VACUUM to do useless work: freezing a row
+ version is a waste of time if the row is modified
+ soon thereafter (causing it to acquire a new XID). So the setting should
+ be large enough that rows are not frozen until they are unlikely to change
+ any more.
+
+ To track the age of the oldest unfrozen XIDs in a database,
+ VACUUM stores XID
+ statistics in the system tables pg_class and
+ pg_database. In particular,
+ the relfrozenxid column of a table's
+ pg_class row contains the oldest remaining unfrozen
+ XID at the end of the most recent VACUUM that successfully
+ advanced relfrozenxid (typically the most recent
+ aggressive VACUUM). Similarly, the
+ datfrozenxid column of a database's
+ pg_database row is a lower bound on the unfrozen XIDs
+ appearing in that database — it is just the minimum of the
+ per-table relfrozenxid values within the database.
+ A convenient way to
+ examine this information is to execute queries such as:
+
+
+SELECT c.oid::regclass as table_name,
+ greatest(age(c.relfrozenxid),age(t.relfrozenxid)) as age
+FROM pg_class c
+LEFT JOIN pg_class t ON c.reltoastrelid = t.oid
+WHERE c.relkind IN ('r', 'm');
+
+SELECT datname, age(datfrozenxid) FROM pg_database;
+
+
+ The age column measures the number of transactions from the
+ cutoff XID to the current transaction's XID.
+
Tip
+ When the VACUUM command's VERBOSE
+ parameter is specified, VACUUM prints various
+ statistics about the table. This includes information about how
+ relfrozenxid and
+ relminmxid advanced, and the number of
+ newly frozen pages. The same details appear in the server log when
+ autovacuum logging (controlled by log_autovacuum_min_duration) reports on a
+ VACUUM operation executed by autovacuum.
+
+ VACUUM normally only scans pages that have been modified
+ since the last vacuum, but relfrozenxid can only be
+ advanced when every page of the table
+ that might contain unfrozen XIDs is scanned. This happens when
+ relfrozenxid is more than
+ vacuum_freeze_table_age transactions old, when
+ VACUUM's FREEZE option is used, or when all
+ pages that are not already all-frozen happen to
+ require vacuuming to remove dead row versions. When VACUUM
+ scans every page in the table that is not already all-frozen, it should
+ set age(relfrozenxid) to a value just a little more than the
+ vacuum_freeze_min_age setting
+ that was used (more by the number of transactions started since the
+ VACUUM started). VACUUM
+ will set relfrozenxid to the oldest XID
+ that remains in the table, so it's possible that the final value
+ will be much more recent than strictly required.
+ If no relfrozenxid-advancing
+ VACUUM is issued on the table until
+ autovacuum_freeze_max_age is reached, an autovacuum will soon
+ be forced for the table.
+
+ If for some reason autovacuum fails to clear old XIDs from a table, the
+ system will begin to emit warning messages like this when the database's
+ oldest XIDs reach forty million transactions from the wraparound point:
+
+
+WARNING: database "mydb" must be vacuumed within 39985967 transactions
+HINT: To avoid a database shutdown, execute a database-wide VACUUM in that database.
+
+
+ (A manual VACUUM should fix the problem, as suggested by the
+ hint; but note that the VACUUM should be performed by a
+ superuser, else it will fail to process system catalogs, which prevent it from
+ being able to advance the database's datfrozenxid.)
+ If these warnings are ignored, the system will refuse to assign new XIDs once
+ there are fewer than three million transactions left until wraparound:
+
+
+ERROR: database is not accepting commands to avoid wraparound data loss in database "mydb"
+HINT: Stop the postmaster and vacuum that database in single-user mode.
+
+
+ In this condition any transactions already in progress can continue,
+ but only read-only transactions can be started. Operations that
+ modify database records or truncate relations will fail.
+ The VACUUM command can still be run normally.
+ Contrary to what the hint states, it is not necessary or desirable to stop the
+ postmaster or enter single user-mode in order to restore normal operation.
+ Instead, follow these steps:
+
+
- Resolve old prepared transactions. You can find these by checking
+ pg_prepared_xacts for rows where
+
age(transactionid) is large. Such transactions should be
+ committed or rolled back. - End long-running open transactions. You can find these by checking
+ pg_stat_activity for rows where
+
age(backend_xid) or age(backend_xmin) is
+ large. Such transactions should be committed or rolled back, or the session
+ can be terminated using pg_terminate_backend. - Drop any old replication slots. Use
+ pg_stat_replication to
+ find slots where
age(xmin) or age(catalog_xmin)
+ is large. In many cases, such slots were created for replication to servers that no
+ longer exist, or that have been down for a long time. If you drop a slot for a server
+ that still exists and might still try to connect to that slot, that replica may
+ need to be rebuilt. - Execute
VACUUM in the target database. A database-wide
+ VACUUM is simplest; to reduce the time required, it as also possible
+ to issue manual VACUUM commands on the tables where
+ relminxid is oldest. Do not use VACUUM FULL
+ in this scenario, because it requires an XID and will therefore fail, except in super-user
+ mode, where it will instead consume an XID and thus increase the risk of transaction ID
+ wraparound. Do not use VACUUM FREEZE either, because it will do
+ more than the minimum amount of work required to restore normal operation. - Once normal operation is restored, ensure that autovacuum is properly configured
+ in the target database in order to avoid future problems.
+
Note
+ In earlier versions, it was sometimes necessary to stop the postmaster and
+ VACUUM the database in a single-user mode. In typical scenarios, this
+ is no longer necessary, and should be avoided whenever possible, since it involves taking
+ the system down. It is also riskier, since it disables transaction ID wraparound safeguards
+ that are designed to prevent data loss. The only reason to use single-user mode in this
+ scenario is if you wish to TRUNCATE or DROP unneeded
+ tables to avoid needing to VACUUM them. The three-million-transaction
+ safety margin exists to let the administrator do this. See the
+ postgres reference page for details about using single-user mode.
+
25.1.5.1. Multixacts and Wraparound #
+ Multixact IDs are used to support row locking by
+ multiple transactions. Since there is only limited space in a tuple
+ header to store lock information, that information is encoded as
+ a “multiple transaction ID”, or multixact ID for short,
+ whenever there is more than one transaction concurrently locking a
+ row. Information about which transaction IDs are included in any
+ particular multixact ID is stored separately in
+ the pg_multixact subdirectory, and only the multixact ID
+ appears in the xmax field in the tuple header.
+ Like transaction IDs, multixact IDs are implemented as a
+ 32-bit counter and corresponding storage, all of which requires
+ careful aging management, storage cleanup, and wraparound handling.
+ There is a separate storage area which holds the list of members in
+ each multixact, which also uses a 32-bit counter and which must also
+ be managed.
+
+ Whenever VACUUM scans any part of a table, it will replace
+ any multixact ID it encounters which is older than
+ vacuum_multixact_freeze_min_age
+ by a different value, which can be the zero value, a single
+ transaction ID, or a newer multixact ID. For each table,
+ pg_class.relminmxid stores the oldest
+ possible multixact ID still appearing in any tuple of that table.
+ If this value is older than
+ vacuum_multixact_freeze_table_age, an aggressive
+ vacuum is forced. As discussed in the previous section, an aggressive
+ vacuum means that only those pages which are known to be all-frozen will
+ be skipped. mxid_age() can be used on
+ pg_class.relminmxid to find its age.
+
+ Aggressive VACUUMs, regardless of what causes
+ them, are guaranteed to be able to advance
+ the table's relminmxid.
+ Eventually, as all tables in all databases are scanned and their
+ oldest multixact values are advanced, on-disk storage for older
+ multixacts can be removed.
+
+ As a safety device, an aggressive vacuum scan will
+ occur for any table whose multixact-age is greater than autovacuum_multixact_freeze_max_age. Also, if the
+ storage occupied by multixacts members exceeds 2GB, aggressive vacuum
+ scans will occur more often for all tables, starting with those that
+ have the oldest multixact-age. Both of these kinds of aggressive
+ scans will occur even if autovacuum is nominally disabled.
+
+ Similar to the XID case, if autovacuum fails to clear old MXIDs from a table, the
+ system will begin to emit warning messages when the database's oldest MXIDs reach forty
+ million transactions from the wraparound point. And, just as an the XID case, if these
+ warnings are ignored, the system will refuse to generate new MXIDs once there are fewer
+ than three million left until wraparound.
+
+ Normal operation when MXIDs are exhausted can be restored in much the same way as
+ when XIDs are exhausted. Follow the same steps in the previous section, but with the
+ following differences:
+
+
- Running transactions and prepared transactions can be ignored if there
+ is no chance that they might appear in a multixact.
- MXID information is not directly visible in system views such as
+
pg_stat_activity; however, looking for old XIDs is still a good
+ way of determining which transactions are causing MXID wraparound problems. - XID exhaustion will block all write transactions, but MXID exhaustion will
+ only block a subset of write transactions, specifically those that involve
+ row locks that require an MXID.
+
25.1.6. The Autovacuum Daemon #
+ PostgreSQL has an optional but highly
+ recommended feature called autovacuum,
+ whose purpose is to automate the execution of
+ VACUUM and ANALYZE commands.
+ When enabled, autovacuum checks for
+ tables that have had a large number of inserted, updated or deleted
+ tuples. These checks use the statistics collection facility;
+ therefore, autovacuum cannot be used unless track_counts is set to true.
+ In the default configuration, autovacuuming is enabled and the related
+ configuration parameters are appropriately set.
+
+ The “autovacuum daemon” actually consists of multiple processes.
+ There is a persistent daemon process, called the
+ autovacuum launcher, which is in charge of starting
+ autovacuum worker processes for all databases. The
+ launcher will distribute the work across time, attempting to start one
+ worker within each database every autovacuum_naptime
+ seconds. (Therefore, if the installation has N databases,
+ a new worker will be launched every
+ autovacuum_naptime/N seconds.)
+ A maximum of autovacuum_max_workers worker processes
+ are allowed to run at the same time. If there are more than
+ autovacuum_max_workers databases to be processed,
+ the next database will be processed as soon as the first worker finishes.
+ Each worker process will check each table within its database and
+ execute VACUUM and/or ANALYZE as needed.
+ log_autovacuum_min_duration can be set to monitor
+ autovacuum workers' activity.
+
+ If several large tables all become eligible for vacuuming in a short
+ amount of time, all autovacuum workers might become occupied with
+ vacuuming those tables for a long period. This would result
+ in other tables and databases not being vacuumed until a worker becomes
+ available. There is no limit on how many workers might be in a
+ single database, but workers do try to avoid repeating work that has
+ already been done by other workers. Note that the number of running
+ workers does not count towards max_connections or
+ superuser_reserved_connections limits.
+
+ Tables whose relfrozenxid value is more than
+ autovacuum_freeze_max_age transactions old are always
+ vacuumed (this also applies to those tables whose freeze max age has
+ been modified via storage parameters; see below). Otherwise, if the
+ number of tuples obsoleted since the last
+ VACUUM exceeds the “vacuum threshold”, the
+ table is vacuumed. The vacuum threshold is defined as:
+
+vacuum threshold = vacuum base threshold + vacuum scale factor * number of tuples
+
+ where the vacuum base threshold is
+ autovacuum_vacuum_threshold,
+ the vacuum scale factor is
+ autovacuum_vacuum_scale_factor,
+ and the number of tuples is
+ pg_class.reltuples.
+
+ The table is also vacuumed if the number of tuples inserted since the last
+ vacuum has exceeded the defined insert threshold, which is defined as:
+
+vacuum insert threshold = vacuum base insert threshold + vacuum insert scale factor * number of tuples
+
+ where the vacuum insert base threshold is
+ autovacuum_vacuum_insert_threshold,
+ and vacuum insert scale factor is
+ autovacuum_vacuum_insert_scale_factor.
+ Such vacuums may allow portions of the table to be marked as
+ all visible and also allow tuples to be frozen, which
+ can reduce the work required in subsequent vacuums.
+ For tables which receive INSERT operations but no or
+ almost no UPDATE/DELETE operations,
+ it may be beneficial to lower the table's
+ autovacuum_freeze_min_age as this may allow
+ tuples to be frozen by earlier vacuums. The number of obsolete tuples and
+ the number of inserted tuples are obtained from the cumulative statistics system;
+ it is a semi-accurate count updated by each UPDATE,
+ DELETE and INSERT operation. (It is
+ only semi-accurate because some information might be lost under heavy
+ load.) If the relfrozenxid value of the table
+ is more than vacuum_freeze_table_age transactions old,
+ an aggressive vacuum is performed to freeze old tuples and advance
+ relfrozenxid; otherwise, only pages that have been modified
+ since the last vacuum are scanned.
+
+ For analyze, a similar condition is used: the threshold, defined as:
+
+analyze threshold = analyze base threshold + analyze scale factor * number of tuples
+
+ is compared to the total number of tuples inserted, updated, or deleted
+ since the last ANALYZE.
+
+ Partitioned tables do not directly store tuples and consequently
+ are not processed by autovacuum. (Autovacuum does process table
+ partitions just like other tables.) Unfortunately, this means that
+ autovacuum does not run ANALYZE on partitioned
+ tables, and this can cause suboptimal plans for queries that reference
+ partitioned table statistics. You can work around this problem by
+ manually running ANALYZE on partitioned tables
+ when they are first populated, and again whenever the distribution
+ of data in their partitions changes significantly.
+
+ Temporary tables cannot be accessed by autovacuum. Therefore,
+ appropriate vacuum and analyze operations should be performed via
+ session SQL commands.
+
+ The default thresholds and scale factors are taken from
+ postgresql.conf, but it is possible to override them
+ (and many other autovacuum control parameters) on a per-table basis; see
+ Storage Parameters for more information.
+ If a setting has been changed via a table's storage parameters, that value
+ is used when processing that table; otherwise the global settings are
+ used. See Section 20.10 for more details on
+ the global settings.
+
+ When multiple workers are running, the autovacuum cost delay parameters
+ (see Section 20.4.4) are
+ “balanced” among all the running workers, so that the
+ total I/O impact on the system is the same regardless of the number
+ of workers actually running. However, any workers processing tables whose
+ per-table autovacuum_vacuum_cost_delay or
+ autovacuum_vacuum_cost_limit storage parameters have been set
+ are not considered in the balancing algorithm.
+
+ Autovacuum workers generally don't block other commands. If a process
+ attempts to acquire a lock that conflicts with the
+ SHARE UPDATE EXCLUSIVE lock held by autovacuum, lock
+ acquisition will interrupt the autovacuum. For conflicting lock modes,
+ see Table 13.2. However, if the autovacuum
+ is running to prevent transaction ID wraparound (i.e., the autovacuum query
+ name in the pg_stat_activity view ends with
+ (to prevent wraparound)), the autovacuum is not
+ automatically interrupted.
+
Warning
+ Regularly running commands that acquire locks conflicting with a
+ SHARE UPDATE EXCLUSIVE lock (e.g., ANALYZE) can
+ effectively prevent autovacuums from ever completing.
+
76.1. Row Estimation Examples #
+ The examples shown below use tables in the PostgreSQL
+ regression test database.
+ The outputs shown are taken from version 8.3.
+ The behavior of earlier (or later) versions might vary.
+ Note also that since ANALYZE uses random sampling
+ while producing statistics, the results will change slightly after
+ any new ANALYZE.
+
+ Let's start with a very simple query:
+
+
+EXPLAIN SELECT * FROM tenk1;
+
+ QUERY PLAN
+-------------------------------------------------------------
+ Seq Scan on tenk1 (cost=0.00..458.00 rows=10000 width=244)
+
+
+ How the planner determines the cardinality of tenk1
+ is covered in Section 14.2, but is repeated here for
+ completeness. The number of pages and rows is looked up in
+ pg_class:
+
+
+SELECT relpages, reltuples FROM pg_class WHERE relname = 'tenk1';
+
+ relpages | reltuples
+----------+-----------
+ 358 | 10000
+
+
+ These numbers are current as of the last VACUUM or
+ ANALYZE on the table. The planner then fetches the
+ actual current number of pages in the table (this is a cheap operation,
+ not requiring a table scan). If that is different from
+ relpages then
+ reltuples is scaled accordingly to
+ arrive at a current number-of-rows estimate. In the example above, the value of
+ relpages is up-to-date so the rows estimate is
+ the same as reltuples.
+
+ Let's move on to an example with a range condition in its
+ WHERE clause:
+
+
+EXPLAIN SELECT * FROM tenk1 WHERE unique1 < 1000;
+
+ QUERY PLAN
+--------------------------------------------------------------------------------
+ Bitmap Heap Scan on tenk1 (cost=24.06..394.64 rows=1007 width=244)
+ Recheck Cond: (unique1 < 1000)
+ -> Bitmap Index Scan on tenk1_unique1 (cost=0.00..23.80 rows=1007 width=0)
+ Index Cond: (unique1 < 1000)
+
+
+ The planner examines the WHERE clause condition
+ and looks up the selectivity function for the operator
+ < in pg_operator.
+ This is held in the column oprrest,
+ and the entry in this case is scalarltsel.
+ The scalarltsel function retrieves the histogram for
+ unique1 from
+ pg_statistic. For manual queries it is more
+ convenient to look in the simpler pg_stats
+ view:
+
+
+SELECT histogram_bounds FROM pg_stats
+WHERE tablename='tenk1' AND attname='unique1';
+
+ histogram_bounds
+------------------------------------------------------
+ {0,993,1997,3050,4040,5036,5957,7057,8029,9016,9995}
+
+
+ Next the fraction of the histogram occupied by “< 1000”
+ is worked out. This is the selectivity. The histogram divides the range
+ into equal frequency buckets, so all we have to do is locate the bucket
+ that our value is in and count part of it and
+ all of the ones before. The value 1000 is clearly in
+ the second bucket (993–1997). Assuming a linear distribution of
+ values inside each bucket, we can calculate the selectivity as:
+
+
+selectivity = (1 + (1000 - bucket[2].min)/(bucket[2].max - bucket[2].min))/num_buckets
+ = (1 + (1000 - 993)/(1997 - 993))/10
+ = 0.100697
+
+
+ that is, one whole bucket plus a linear fraction of the second, divided by
+ the number of buckets. The estimated number of rows can now be calculated as
+ the product of the selectivity and the cardinality of
+ tenk1:
+
+
+rows = rel_cardinality * selectivity
+ = 10000 * 0.100697
+ = 1007 (rounding off)
+
+
+ Next let's consider an example with an equality condition in its
+ WHERE clause:
+
+
+EXPLAIN SELECT * FROM tenk1 WHERE stringu1 = 'CRAAAA';
+
+ QUERY PLAN
+----------------------------------------------------------
+ Seq Scan on tenk1 (cost=0.00..483.00 rows=30 width=244)
+ Filter: (stringu1 = 'CRAAAA'::name)
+
+
+ Again the planner examines the WHERE clause condition
+ and looks up the selectivity function for =, which is
+ eqsel. For equality estimation the histogram is
+ not useful; instead the list of most
+ common values (MCVs) is used to determine the
+ selectivity. Let's have a look at the MCVs, with some additional columns
+ that will be useful later:
+
+
+SELECT null_frac, n_distinct, most_common_vals, most_common_freqs FROM pg_stats
+WHERE tablename='tenk1' AND attname='stringu1';
+
+null_frac | 0
+n_distinct | 676
+most_common_vals | {EJAAAA,BBAAAA,CRAAAA,FCAAAA,FEAAAA,GSAAAA,JOAAAA,MCAAAA,NAAAAA,WGAAAA}
+most_common_freqs | {0.00333333,0.003,0.003,0.003,0.003,0.003,0.003,0.003,0.003,0.003}
+
+
+
+ Since CRAAAA appears in the list of MCVs, the selectivity is
+ merely the corresponding entry in the list of most common frequencies
+ (MCFs):
+
+
+selectivity = mcf[3]
+ = 0.003
+
+
+ As before, the estimated number of rows is just the product of this with the
+ cardinality of tenk1:
+
+
+rows = 10000 * 0.003
+ = 30
+
+
+ Now consider the same query, but with a constant that is not in the
+ MCV list:
+
+
+EXPLAIN SELECT * FROM tenk1 WHERE stringu1 = 'xxx';
+
+ QUERY PLAN
+----------------------------------------------------------
+ Seq Scan on tenk1 (cost=0.00..483.00 rows=15 width=244)
+ Filter: (stringu1 = 'xxx'::name)
+
+
+ This is quite a different problem: how to estimate the selectivity when the
+ value is not in the MCV list.
+ The approach is to use the fact that the value is not in the list,
+ combined with the knowledge of the frequencies for all of the
+ MCVs:
+
+
+selectivity = (1 - sum(mcv_freqs))/(num_distinct - num_mcv)
+ = (1 - (0.00333333 + 0.003 + 0.003 + 0.003 + 0.003 + 0.003 +
+ 0.003 + 0.003 + 0.003 + 0.003))/(676 - 10)
+ = 0.0014559
+
+
+ That is, add up all the frequencies for the MCVs and
+ subtract them from one, then
+ divide by the number of other distinct values.
+ This amounts to assuming that the fraction of the column that is not any
+ of the MCVs is evenly distributed among all the other distinct values.
+ Notice that there are no null values so we don't have to worry about those
+ (otherwise we'd subtract the null fraction from the numerator as well).
+ The estimated number of rows is then calculated as usual:
+
+
+rows = 10000 * 0.0014559
+ = 15 (rounding off)
+
+
+ The previous example with unique1 < 1000 was an
+ oversimplification of what scalarltsel really does;
+ now that we have seen an example of the use of MCVs, we can fill in some
+ more detail. The example was correct as far as it went, because since
+ unique1 is a unique column it has no MCVs (obviously, no
+ value is any more common than any other value). For a non-unique
+ column, there will normally be both a histogram and an MCV list, and
+ the histogram does not include the portion of the column
+ population represented by the MCVs. We do things this way because
+ it allows more precise estimation. In this situation
+ scalarltsel directly applies the condition (e.g.,
+ “< 1000”) to each value of the MCV list, and adds up the
+ frequencies of the MCVs for which the condition is true. This gives
+ an exact estimate of the selectivity within the portion of the table
+ that is MCVs. The histogram is then used in the same way as above
+ to estimate the selectivity in the portion of the table that is not
+ MCVs, and then the two numbers are combined to estimate the overall
+ selectivity. For example, consider
+
+
+EXPLAIN SELECT * FROM tenk1 WHERE stringu1 < 'IAAAAA';
+
+ QUERY PLAN
+------------------------------------------------------------
+ Seq Scan on tenk1 (cost=0.00..483.00 rows=3077 width=244)
+ Filter: (stringu1 < 'IAAAAA'::name)
+
+
+ We already saw the MCV information for stringu1,
+ and here is its histogram:
+
+
+SELECT histogram_bounds FROM pg_stats
+WHERE tablename='tenk1' AND attname='stringu1';
+
+ histogram_bounds
+--------------------------------------------------------------------------------
+ {AAAAAA,CQAAAA,FRAAAA,IBAAAA,KRAAAA,NFAAAA,PSAAAA,SGAAAA,VAAAAA,XLAAAA,ZZAAAA}
+
+
+ Checking the MCV list, we find that the condition stringu1 <
+ 'IAAAAA' is satisfied by the first six entries and not the last four,
+ so the selectivity within the MCV part of the population is
+
+
+selectivity = sum(relevant mvfs)
+ = 0.00333333 + 0.003 + 0.003 + 0.003 + 0.003 + 0.003
+ = 0.01833333
+
+
+ Summing all the MCFs also tells us that the total fraction of the
+ population represented by MCVs is 0.03033333, and therefore the
+ fraction represented by the histogram is 0.96966667 (again, there
+ are no nulls, else we'd have to exclude them here). We can see
+ that the value IAAAAA falls nearly at the end of the
+ third histogram bucket. Using some rather cheesy assumptions
+ about the frequency of different characters, the planner arrives
+ at the estimate 0.298387 for the portion of the histogram population
+ that is less than IAAAAA. We then combine the estimates
+ for the MCV and non-MCV populations:
+
+
+selectivity = mcv_selectivity + histogram_selectivity * histogram_fraction
+ = 0.01833333 + 0.298387 * 0.96966667
+ = 0.307669
+
+rows = 10000 * 0.307669
+ = 3077 (rounding off)
+
+
+ In this particular example, the correction from the MCV list is fairly
+ small, because the column distribution is actually quite flat (the
+ statistics showing these particular values as being more common than
+ others are mostly due to sampling error). In a more typical case where
+ some values are significantly more common than others, this complicated
+ process gives a useful improvement in accuracy because the selectivity
+ for the most common values is found exactly.
+
+ Now let's consider a case with more than one
+ condition in the WHERE clause:
+
+
+EXPLAIN SELECT * FROM tenk1 WHERE unique1 < 1000 AND stringu1 = 'xxx';
+
+ QUERY PLAN
+--------------------------------------------------------------------------------
+ Bitmap Heap Scan on tenk1 (cost=23.80..396.91 rows=1 width=244)
+ Recheck Cond: (unique1 < 1000)
+ Filter: (stringu1 = 'xxx'::name)
+ -> Bitmap Index Scan on tenk1_unique1 (cost=0.00..23.80 rows=1007 width=0)
+ Index Cond: (unique1 < 1000)
+
+
+ The planner assumes that the two conditions are independent, so that
+ the individual selectivities of the clauses can be multiplied together:
+
+
+selectivity = selectivity(unique1 < 1000) * selectivity(stringu1 = 'xxx')
+ = 0.100697 * 0.0014559
+ = 0.0001466
+
+rows = 10000 * 0.0001466
+ = 1 (rounding off)
+
+
+ Notice that the number of rows estimated to be returned from the bitmap
+ index scan reflects only the condition used with the index; this is
+ important since it affects the cost estimate for the subsequent heap
+ fetches.
+
+ Finally we will examine a query that involves a join:
+
+
+EXPLAIN SELECT * FROM tenk1 t1, tenk2 t2
+WHERE t1.unique1 < 50 AND t1.unique2 = t2.unique2;
+
+ QUERY PLAN
+--------------------------------------------------------------------------------------
+ Nested Loop (cost=4.64..456.23 rows=50 width=488)
+ -> Bitmap Heap Scan on tenk1 t1 (cost=4.64..142.17 rows=50 width=244)
+ Recheck Cond: (unique1 < 50)
+ -> Bitmap Index Scan on tenk1_unique1 (cost=0.00..4.63 rows=50 width=0)
+ Index Cond: (unique1 < 50)
+ -> Index Scan using tenk2_unique2 on tenk2 t2 (cost=0.00..6.27 rows=1 width=244)
+ Index Cond: (unique2 = t1.unique2)
+
+
+ The restriction on tenk1,
+ unique1 < 50,
+ is evaluated before the nested-loop join.
+ This is handled analogously to the previous range example. This time the
+ value 50 falls into the first bucket of the
+ unique1 histogram:
+
+
+selectivity = (0 + (50 - bucket[1].min)/(bucket[1].max - bucket[1].min))/num_buckets
+ = (0 + (50 - 0)/(993 - 0))/10
+ = 0.005035
+
+rows = 10000 * 0.005035
+ = 50 (rounding off)
+
+
+ The restriction for the join is t2.unique2 = t1.unique2.
+ The operator is just
+ our familiar =, however the selectivity function is
+ obtained from the oprjoin column of
+ pg_operator, and is eqjoinsel.
+ eqjoinsel looks up the statistical information for both
+ tenk2 and tenk1:
+
+
+SELECT tablename, null_frac,n_distinct, most_common_vals FROM pg_stats
+WHERE tablename IN ('tenk1', 'tenk2') AND attname='unique2';
+
+tablename | null_frac | n_distinct | most_common_vals
+-----------+-----------+------------+------------------
+ tenk1 | 0 | -1 |
+ tenk2 | 0 | -1 |
+
+
+ In this case there is no MCV information for
+ unique2 because all the values appear to be
+ unique, so we use an algorithm that relies only on the number of
+ distinct values for both relations together with their null fractions:
+
+
+selectivity = (1 - null_frac1) * (1 - null_frac2) * min(1/num_distinct1, 1/num_distinct2)
+ = (1 - 0) * (1 - 0) / max(10000, 10000)
+ = 0.0001
+
+
+ This is, subtract the null fraction from one for each of the relations,
+ and divide by the maximum of the numbers of distinct values.
+ The number of rows
+ that the join is likely to emit is calculated as the cardinality of the
+ Cartesian product of the two inputs, multiplied by the
+ selectivity:
+
+
+rows = (outer_cardinality * inner_cardinality) * selectivity
+ = (50 * 10000) * 0.0001
+ = 50
+
+
+ Had there been MCV lists for the two columns,
+ eqjoinsel would have used direct comparison of the MCV
+ lists to determine the join selectivity within the part of the column
+ populations represented by the MCVs. The estimate for the remainder of the
+ populations follows the same approach shown here.
+
+ Notice that we showed inner_cardinality as 10000, that is,
+ the unmodified size of tenk2. It might appear from
+ inspection of the EXPLAIN output that the estimate of
+ join rows comes from 50 * 1, that is, the number of outer rows times
+ the estimated number of rows obtained by each inner index scan on
+ tenk2. But this is not the case: the join relation size
+ is estimated before any particular join plan has been considered. If
+ everything is working well then the two ways of estimating the join
+ size will produce about the same answer, but due to round-off error and
+ other factors they sometimes diverge significantly.
+
+ For those interested in further details, estimation of the size of
+ a table (before any WHERE clauses) is done in
+ src/backend/optimizer/util/plancat.c. The generic
+ logic for clause selectivities is in
+ src/backend/optimizer/path/clausesel.c. The
+ operator-specific selectivity functions are mostly found
+ in src/backend/utils/adt/selfuncs.c.
+
+ A composite type represents the structure of a row or record;
+ it is essentially just a list of field names and their data types.
+ PostgreSQL allows composite types to be
+ used in many of the same ways that simple types can be used. For example, a
+ column of a table can be declared to be of a composite type.
+
8.16.1. Declaration of Composite Types #
+ Here are two simple examples of defining composite types:
+
+CREATE TYPE complex AS (
+ r double precision,
+ i double precision
+);
+
+CREATE TYPE inventory_item AS (
+ name text,
+ supplier_id integer,
+ price numeric
+);
+
+ The syntax is comparable to CREATE TABLE, except that only
+ field names and types can be specified; no constraints (such as NOT
+ NULL) can presently be included. Note that the AS keyword
+ is essential; without it, the system will think a different kind
+ of CREATE TYPE command is meant, and you will get odd syntax
+ errors.
+
+ Having defined the types, we can use them to create tables:
+
+
+CREATE TABLE on_hand (
+ item inventory_item,
+ count integer
+);
+
+INSERT INTO on_hand VALUES (ROW('fuzzy dice', 42, 1.99), 1000);
+
+
+ or functions:
+
+
+CREATE FUNCTION price_extension(inventory_item, integer) RETURNS numeric
+AS 'SELECT $1.price * $2' LANGUAGE SQL;
+
+SELECT price_extension(item, 10) FROM on_hand;
+
+
+
+ Whenever you create a table, a composite type is also automatically
+ created, with the same name as the table, to represent the table's
+ row type. For example, had we said:
+
+CREATE TABLE inventory_item (
+ name text,
+ supplier_id integer REFERENCES suppliers,
+ price numeric CHECK (price > 0)
+);
+
+ then the same inventory_item composite type shown above would
+ come into being as a
+ byproduct, and could be used just as above. Note however an important
+ restriction of the current implementation: since no constraints are
+ associated with a composite type, the constraints shown in the table
+ definition do not apply to values of the composite type
+ outside the table. (To work around this, create a
+ domain over the composite
+ type, and apply the desired constraints as CHECK
+ constraints of the domain.)
+
8.16.2. Constructing Composite Values #
+ To write a composite value as a literal constant, enclose the field
+ values within parentheses and separate them by commas. You can put double
+ quotes around any field value, and must do so if it contains commas or
+ parentheses. (More details appear below.) Thus, the general format of
+ a composite constant is the following:
+
+'( val1 , val2 , ... )'
+
+ An example is:
+
+'("fuzzy dice",42,1.99)'
+
+ which would be a valid value of the inventory_item type
+ defined above. To make a field be NULL, write no characters at all
+ in its position in the list. For example, this constant specifies
+ a NULL third field:
+
+'("fuzzy dice",42,)'
+
+ If you want an empty string rather than NULL, write double quotes:
+
+'("",42,)'
+
+ Here the first field is a non-NULL empty string, the third is NULL.
+
+ (These constants are actually only a special case of
+ the generic type constants discussed in Section 4.1.2.7. The constant is initially
+ treated as a string and passed to the composite-type input conversion
+ routine. An explicit type specification might be necessary to tell
+ which type to convert the constant to.)
+
+ The ROW expression syntax can also be used to
+ construct composite values. In most cases this is considerably
+ simpler to use than the string-literal syntax since you don't have
+ to worry about multiple layers of quoting. We already used this
+ method above:
+
+ROW('fuzzy dice', 42, 1.99)
+ROW('', 42, NULL)
+
+ The ROW keyword is actually optional as long as you have more than one
+ field in the expression, so these can be simplified to:
+
+('fuzzy dice', 42, 1.99)
+('', 42, NULL)
+
+ The ROW expression syntax is discussed in more detail in Section 4.2.13.
+
8.16.3. Accessing Composite Types #
+ To access a field of a composite column, one writes a dot and the field
+ name, much like selecting a field from a table name. In fact, it's so
+ much like selecting from a table name that you often have to use parentheses
+ to keep from confusing the parser. For example, you might try to select
+ some subfields from our on_hand example table with something
+ like:
+
+
+SELECT item.name FROM on_hand WHERE item.price > 9.99;
+
+
+ This will not work since the name item is taken to be a table
+ name, not a column name of on_hand, per SQL syntax rules.
+ You must write it like this:
+
+
+SELECT (item).name FROM on_hand WHERE (item).price > 9.99;
+
+
+ or if you need to use the table name as well (for instance in a multitable
+ query), like this:
+
+
+SELECT (on_hand.item).name FROM on_hand WHERE (on_hand.item).price > 9.99;
+
+
+ Now the parenthesized object is correctly interpreted as a reference to
+ the item column, and then the subfield can be selected from it.
+
+ Similar syntactic issues apply whenever you select a field from a composite
+ value. For instance, to select just one field from the result of a function
+ that returns a composite value, you'd need to write something like:
+
+
+SELECT (my_func(...)).field FROM ...
+
+
+ Without the extra parentheses, this will generate a syntax error.
+
+ The special field name * means “all fields”, as
+ further explained in Section 8.16.5.
+
8.16.4. Modifying Composite Types #
+ Here are some examples of the proper syntax for inserting and updating
+ composite columns.
+ First, inserting or updating a whole column:
+
+
+INSERT INTO mytab (complex_col) VALUES((1.1,2.2));
+
+UPDATE mytab SET complex_col = ROW(1.1,2.2) WHERE ...;
+
+
+ The first example omits ROW, the second uses it; we
+ could have done it either way.
+
+ We can update an individual subfield of a composite column:
+
+
+UPDATE mytab SET complex_col.r = (complex_col).r + 1 WHERE ...;
+
+
+ Notice here that we don't need to (and indeed cannot)
+ put parentheses around the column name appearing just after
+ SET, but we do need parentheses when referencing the same
+ column in the expression to the right of the equal sign.
+
+ And we can specify subfields as targets for INSERT, too:
+
+
+INSERT INTO mytab (complex_col.r, complex_col.i) VALUES(1.1, 2.2);
+
+
+ Had we not supplied values for all the subfields of the column, the
+ remaining subfields would have been filled with null values.
+
8.16.5. Using Composite Types in Queries #
+ There are various special syntax rules and behaviors associated with
+ composite types in queries. These rules provide useful shortcuts,
+ but can be confusing if you don't know the logic behind them.
+
+ In PostgreSQL, a reference to a table name (or alias)
+ in a query is effectively a reference to the composite value of the
+ table's current row. For example, if we had a table
+ inventory_item as shown
+ above, we could write:
+
+SELECT c FROM inventory_item c;
+
+ This query produces a single composite-valued column, so we might get
+ output like:
+
+ c
+------------------------
+ ("fuzzy dice",42,1.99)
+(1 row)
+
+ Note however that simple names are matched to column names before table
+ names, so this example works only because there is no column
+ named c in the query's tables.
+
+ The ordinary qualified-column-name
+ syntax table_name.column_name
+ can be understood as applying field
+ selection to the composite value of the table's current row.
+ (For efficiency reasons, it's not actually implemented that way.)
+
+ When we write
+
+SELECT c.* FROM inventory_item c;
+
+ then, according to the SQL standard, we should get the contents of the
+ table expanded into separate columns:
+
+ name | supplier_id | price
+------------+-------------+-------
+ fuzzy dice | 42 | 1.99
+(1 row)
+
+ as if the query were
+
+SELECT c.name, c.supplier_id, c.price FROM inventory_item c;
+
+ PostgreSQL will apply this expansion behavior to
+ any composite-valued expression, although as shown above, you need to write parentheses
+ around the value that .* is applied to whenever it's not a
+ simple table name. For example, if myfunc() is a function
+ returning a composite type with columns a,
+ b, and c, then these two queries have the
+ same result:
+
+SELECT (myfunc(x)).* FROM some_table;
+SELECT (myfunc(x)).a, (myfunc(x)).b, (myfunc(x)).c FROM some_table;
+
+
Tip
+ PostgreSQL handles column expansion by
+ actually transforming the first form into the second. So, in this
+ example, myfunc() would get invoked three times per row
+ with either syntax. If it's an expensive function you may wish to
+ avoid that, which you can do with a query like:
+
+SELECT m.* FROM some_table, LATERAL myfunc(x) AS m;
+
+ Placing the function in
+ a LATERAL FROM item keeps it from
+ being invoked more than once per row. m.* is still
+ expanded into m.a, m.b, m.c, but now those variables
+ are just references to the output of the FROM item.
+ (The LATERAL keyword is optional here, but we show it
+ to clarify that the function is getting x
+ from some_table.)
+
+ The composite_value.* syntax results in
+ column expansion of this kind when it appears at the top level of
+ a SELECT output
+ list, a RETURNING
+ list in INSERT/UPDATE/DELETE,
+ a VALUES clause, or
+ a row constructor.
+ In all other contexts (including when nested inside one of those
+ constructs), attaching .* to a composite value does not
+ change the value, since it means “all columns” and so the
+ same composite value is produced again. For example,
+ if somefunc() accepts a composite-valued argument,
+ these queries are the same:
+
+
+SELECT somefunc(c.*) FROM inventory_item c;
+SELECT somefunc(c) FROM inventory_item c;
+
+
+ In both cases, the current row of inventory_item is
+ passed to the function as a single composite-valued argument.
+ Even though .* does nothing in such cases, using it is good
+ style, since it makes clear that a composite value is intended. In
+ particular, the parser will consider c in c.* to
+ refer to a table name or alias, not to a column name, so that there is
+ no ambiguity; whereas without .*, it is not clear
+ whether c means a table name or a column name, and in fact
+ the column-name interpretation will be preferred if there is a column
+ named c.
+
+ Another example demonstrating these concepts is that all these queries
+ mean the same thing:
+
+SELECT * FROM inventory_item c ORDER BY c;
+SELECT * FROM inventory_item c ORDER BY c.*;
+SELECT * FROM inventory_item c ORDER BY ROW(c.*);
+
+ All of these ORDER BY clauses specify the row's composite
+ value, resulting in sorting the rows according to the rules described
+ in Section 9.24.6. However,
+ if inventory_item contained a column
+ named c, the first case would be different from the
+ others, as it would mean to sort by that column only. Given the column
+ names previously shown, these queries are also equivalent to those above:
+
+SELECT * FROM inventory_item c ORDER BY ROW(c.name, c.supplier_id, c.price);
+SELECT * FROM inventory_item c ORDER BY (c.name, c.supplier_id, c.price);
+
+ (The last case uses a row constructor with the key word ROW
+ omitted.)
+
+ Another special syntactical behavior associated with composite values is
+ that we can use functional notation for extracting a field
+ of a composite value. The simple way to explain this is that
+ the notations field(table)table.field
+SELECT c.name FROM inventory_item c WHERE c.price > 1000;
+SELECT name(c) FROM inventory_item c WHERE price(c) > 1000;
+
+
+ Moreover, if we have a function that accepts a single argument of a
+ composite type, we can call it with either notation. These queries are
+ all equivalent:
+
+
+SELECT somefunc(c) FROM inventory_item c;
+SELECT somefunc(c.*) FROM inventory_item c;
+SELECT c.somefunc FROM inventory_item c;
+
+
+ This equivalence between functional notation and field notation
+ makes it possible to use functions on composite types to implement
+ “computed fields”.
+
+
+ An application using the last query above wouldn't need to be directly
+ aware that somefunc isn't a real column of the table.
+
Tip
+ Because of this behavior, it's unwise to give a function that takes a
+ single composite-type argument the same name as any of the fields of
+ that composite type. If there is ambiguity, the field-name
+ interpretation will be chosen if field-name syntax is used, while the
+ function will be chosen if function-call syntax is used. However,
+ PostgreSQL versions before 11 always chose the
+ field-name interpretation, unless the syntax of the call required it to
+ be a function call. One way to force the function interpretation in
+ older versions is to schema-qualify the function name, that is, write
+ schema.func(compositevalue)
8.16.6. Composite Type Input and Output Syntax #
+ The external text representation of a composite value consists of items that
+ are interpreted according to the I/O conversion rules for the individual
+ field types, plus decoration that indicates the composite structure.
+ The decoration consists of parentheses (( and ))
+ around the whole value, plus commas (,) between adjacent
+ items. Whitespace outside the parentheses is ignored, but within the
+ parentheses it is considered part of the field value, and might or might not be
+ significant depending on the input conversion rules for the field data type.
+ For example, in:
+
+'( 42)'
+
+ the whitespace will be ignored if the field type is integer, but not if
+ it is text.
+
+ As shown previously, when writing a composite value you can write double
+ quotes around any individual field value.
+ You must do so if the field value would otherwise
+ confuse the composite-value parser. In particular, fields containing
+ parentheses, commas, double quotes, or backslashes must be double-quoted.
+ To put a double quote or backslash in a quoted composite field value,
+ precede it with a backslash. (Also, a pair of double quotes within a
+ double-quoted field value is taken to represent a double quote character,
+ analogously to the rules for single quotes in SQL literal strings.)
+ Alternatively, you can avoid quoting and use backslash-escaping to
+ protect all data characters
+ that would otherwise be taken as composite syntax.
+
+ A completely empty field value (no characters at all between the commas
+ or parentheses) represents a NULL. To write a value that is an empty
+ string rather than NULL, write "".
+
+ The composite output routine will put double quotes around field values
+ if they are empty strings or contain parentheses, commas,
+ double quotes, backslashes, or white space. (Doing so for white space
+ is not essential, but aids legibility.) Double quotes and backslashes
+ embedded in field values will be doubled.
+
Note
+ Remember that what you write in an SQL command will first be interpreted
+ as a string literal, and then as a composite. This doubles the number of
+ backslashes you need (assuming escape string syntax is used).
+ For example, to insert a text field
+ containing a double quote and a backslash in a composite
+ value, you'd need to write:
+
+INSERT ... VALUES ('("\"\\")');
+
+ The string-literal processor removes one level of backslashes, so that
+ what arrives at the composite-value parser looks like
+ ("\"\\"). In turn, the string
+ fed to the text data type's input routine
+ becomes "\. (If we were working
+ with a data type whose input routine also treated backslashes specially,
+ bytea for example, we might need as many as eight backslashes
+ in the command to get one backslash into the stored composite field.)
+ Dollar quoting (see Section 4.1.2.4) can be
+ used to avoid the need to double backslashes.
+
Tip
+ The ROW constructor syntax is usually easier to work with
+ than the composite-literal syntax when writing composite values in SQL
+ commands.
+ In ROW, individual field values are written the same way
+ they would be written when not members of a composite.
+
52.4. The PostgreSQL Rule System #
+ PostgreSQL supports a powerful
+ rule system for the specification
+ of views and ambiguous view updates.
+ Originally the PostgreSQL
+ rule system consisted of two implementations:
+
+
+ The first one worked using row level processing and was
+ implemented deep in the executor. The rule system was
+ called whenever an individual row had been accessed. This
+ implementation was removed in 1995 when the last official release
+ of the Berkeley Postgres project was
+ transformed into Postgres95.
+
+ The second implementation of the rule system is a technique
+ called query rewriting.
+ The rewrite system is a module
+ that exists between the parser stage and the
+ planner/optimizer. This technique is still implemented.
+
+
+ The query rewriter is discussed in some detail in
+ Chapter 41, so there is no need to cover it here.
+ We will only point out that both the input and the output of the
+ rewriter are query trees, that is, there is no change in the
+ representation or level of semantic detail in the trees. Rewriting
+ can be thought of as a form of macro expansion.
+
41.3. Materialized Views #
+ Materialized views in PostgreSQL use the
+ rule system like views do, but persist the results in a table-like form.
+ The main differences between:
+
+
+CREATE MATERIALIZED VIEW mymatview AS SELECT * FROM mytab;
+
+
+ and:
+
+
+CREATE TABLE mymatview AS SELECT * FROM mytab;
+
+
+ are that the materialized view cannot subsequently be directly updated
+ and that the query used to create the materialized view is stored in
+ exactly the same way that a view's query is stored, so that fresh data
+ can be generated for the materialized view with:
+
+
+REFRESH MATERIALIZED VIEW mymatview;
+
+
+ The information about a materialized view in the
+ PostgreSQL system catalogs is exactly
+ the same as it is for a table or view. So for the parser, a
+ materialized view is a relation, just like a table or a view. When
+ a materialized view is referenced in a query, the data is returned
+ directly from the materialized view, like from a table; the rule is
+ only used for populating the materialized view.
+
+ While access to the data stored in a materialized view is often much
+ faster than accessing the underlying tables directly or through a view,
+ the data is not always current; yet sometimes current data is not needed.
+ Consider a table which records sales:
+
+
+CREATE TABLE invoice (
+ invoice_no integer PRIMARY KEY,
+ seller_no integer, -- ID of salesperson
+ invoice_date date, -- date of sale
+ invoice_amt numeric(13,2) -- amount of sale
+);
+
+
+ If people want to be able to quickly graph historical sales data, they
+ might want to summarize, and they may not care about the incomplete data
+ for the current date:
+
+
+CREATE MATERIALIZED VIEW sales_summary AS
+ SELECT
+ seller_no,
+ invoice_date,
+ sum(invoice_amt)::numeric(13,2) as sales_amt
+ FROM invoice
+ WHERE invoice_date < CURRENT_DATE
+ GROUP BY
+ seller_no,
+ invoice_date;
+
+CREATE UNIQUE INDEX sales_summary_seller
+ ON sales_summary (seller_no, invoice_date);
+
+
+ This materialized view might be useful for displaying a graph in the
+ dashboard created for salespeople. A job could be scheduled to update
+ the statistics each night using this SQL statement:
+
+
+REFRESH MATERIALIZED VIEW sales_summary;
+
+
+ Another use for a materialized view is to allow faster access to data
+ brought across from a remote system through a foreign data wrapper.
+ A simple example using file_fdw is below, with timings,
+ but since this is using cache on the local system the performance
+ difference compared to access to a remote system would usually be greater
+ than shown here. Notice we are also exploiting the ability to put an
+ index on the materialized view, whereas file_fdw does
+ not support indexes; this advantage might not apply for other sorts of
+ foreign data access.
+
+ Setup:
+
+
+CREATE EXTENSION file_fdw;
+CREATE SERVER local_file FOREIGN DATA WRAPPER file_fdw;
+CREATE FOREIGN TABLE words (word text NOT NULL)
+ SERVER local_file
+ OPTIONS (filename '/usr/share/dict/words');
+CREATE MATERIALIZED VIEW wrd AS SELECT * FROM words;
+CREATE UNIQUE INDEX wrd_word ON wrd (word);
+CREATE EXTENSION pg_trgm;
+CREATE INDEX wrd_trgm ON wrd USING gist (word gist_trgm_ops);
+VACUUM ANALYZE wrd;
+
+
+ Now let's spell-check a word. Using file_fdw directly:
+
+
+SELECT count(*) FROM words WHERE word = 'caterpiler';
+
+ count
+-------
+ 0
+(1 row)
+
+
+ With EXPLAIN ANALYZE, we see:
+
+
+ Aggregate (cost=21763.99..21764.00 rows=1 width=0) (actual time=188.180..188.181 rows=1 loops=1)
+ -> Foreign Scan on words (cost=0.00..21761.41 rows=1032 width=0) (actual time=188.177..188.177 rows=0 loops=1)
+ Filter: (word = 'caterpiler'::text)
+ Rows Removed by Filter: 479829
+ Foreign File: /usr/share/dict/words
+ Foreign File Size: 4953699
+ Planning time: 0.118 ms
+ Execution time: 188.273 ms
+
+
+ If the materialized view is used instead, the query is much faster:
+
+
+ Aggregate (cost=4.44..4.45 rows=1 width=0) (actual time=0.042..0.042 rows=1 loops=1)
+ -> Index Only Scan using wrd_word on wrd (cost=0.42..4.44 rows=1 width=0) (actual time=0.039..0.039 rows=0 loops=1)
+ Index Cond: (word = 'caterpiler'::text)
+ Heap Fetches: 0
+ Planning time: 0.164 ms
+ Execution time: 0.117 ms
+
+
+ Either way, the word is spelled wrong, so let's look for what we might
+ have wanted. Again using file_fdw and
+ pg_trgm:
+
+
+SELECT word FROM words ORDER BY word <-> 'caterpiler' LIMIT 10;
+
+ word
+---------------
+ cater
+ caterpillar
+ Caterpillar
+ caterpillars
+ caterpillar's
+ Caterpillar's
+ caterer
+ caterer's
+ caters
+ catered
+(10 rows)
+
+
+
+ Limit (cost=11583.61..11583.64 rows=10 width=32) (actual time=1431.591..1431.594 rows=10 loops=1)
+ -> Sort (cost=11583.61..11804.76 rows=88459 width=32) (actual time=1431.589..1431.591 rows=10 loops=1)
+ Sort Key: ((word <-> 'caterpiler'::text))
+ Sort Method: top-N heapsort Memory: 25kB
+ -> Foreign Scan on words (cost=0.00..9672.05 rows=88459 width=32) (actual time=0.057..1286.455 rows=479829 loops=1)
+ Foreign File: /usr/share/dict/words
+ Foreign File Size: 4953699
+ Planning time: 0.128 ms
+ Execution time: 1431.679 ms
+
+
+ Using the materialized view:
+
+
+ Limit (cost=0.29..1.06 rows=10 width=10) (actual time=187.222..188.257 rows=10 loops=1)
+ -> Index Scan using wrd_trgm on wrd (cost=0.29..37020.87 rows=479829 width=10) (actual time=187.219..188.252 rows=10 loops=1)
+ Order By: (word <-> 'caterpiler'::text)
+ Planning time: 0.196 ms
+ Execution time: 198.640 ms
+
+
+ If you can tolerate periodic update of the remote data to the local
+ database, the performance benefit can be substantial.
+
41.5. Rules and Privileges #
+ Due to rewriting of queries by the PostgreSQL
+ rule system, other tables/views than those used in the original
+ query get accessed. When update rules are used, this can include write access
+ to tables.
+
+ Rewrite rules don't have a separate owner. The owner of
+ a relation (table or view) is automatically the owner of the
+ rewrite rules that are defined for it.
+ The PostgreSQL rule system changes the
+ behavior of the default access control system. With the exception of
+ SELECT rules associated with security invoker views
+ (see CREATE VIEW),
+ all relations that are used due to rules get checked against the
+ privileges of the rule owner, not the user invoking the rule.
+ This means that, except for security invoker views, users only need the
+ required privileges for the tables/views that are explicitly named in
+ their queries.
+
+ For example: A user has a list of phone numbers where some of
+ them are private, the others are of interest for the assistant of the office.
+ The user can construct the following:
+
+
+CREATE TABLE phone_data (person text, phone text, private boolean);
+CREATE VIEW phone_number AS
+ SELECT person, CASE WHEN NOT private THEN phone END AS phone
+ FROM phone_data;
+GRANT SELECT ON phone_number TO assistant;
+
+
+ Nobody except that user (and the database superusers) can access the
+ phone_data table. But because of the GRANT,
+ the assistant can run a SELECT on the
+ phone_number view. The rule system will rewrite the
+ SELECT from phone_number into a
+ SELECT from phone_data.
+ Since the user is the owner of
+ phone_number and therefore the owner of the rule, the
+ read access to phone_data is now checked against the user's
+ privileges and the query is permitted. The check for accessing
+ phone_number is also performed, but this is done
+ against the invoking user, so nobody but the user and the
+ assistant can use it.
+
+ The privileges are checked rule by rule. So the assistant is for now the
+ only one who can see the public phone numbers. But the assistant can set up
+ another view and grant access to that to the public. Then, anyone
+ can see the phone_number data through the assistant's view.
+ What the assistant cannot do is to create a view that directly
+ accesses phone_data. (Actually the assistant can, but it will not work since
+ every access will be denied during the permission checks.)
+ And as soon as the user notices that the assistant opened
+ their phone_number view, the user can revoke the assistant's access. Immediately, any
+ access to the assistant's view would fail.
+
+ One might think that this rule-by-rule checking is a security
+ hole, but in fact it isn't. But if it did not work this way, the assistant
+ could set up a table with the same columns as phone_number and
+ copy the data to there once per day. Then it's the assistant's own data and
+ the assistant can grant access to everyone they want. A
+ GRANT command means, “I trust you”.
+ If someone you trust does the thing above, it's time to
+ think it over and then use REVOKE.
+
+ Note that while views can be used to hide the contents of certain
+ columns using the technique shown above, they cannot be used to reliably
+ conceal the data in unseen rows unless the
+ security_barrier flag has been set. For example,
+ the following view is insecure:
+
+CREATE VIEW phone_number AS
+ SELECT person, phone FROM phone_data WHERE phone NOT LIKE '412%';
+
+ This view might seem secure, since the rule system will rewrite any
+ SELECT from phone_number into a
+ SELECT from phone_data and add the
+ qualification that only entries where phone does not begin
+ with 412 are wanted. But if the user can create their own functions,
+ it is not difficult to convince the planner to execute the user-defined
+ function prior to the NOT LIKE expression.
+ For example:
+
+CREATE FUNCTION tricky(text, text) RETURNS bool AS $$
+BEGIN
+ RAISE NOTICE '% => %', $1, $2;
+ RETURN true;
+END;
+$$ LANGUAGE plpgsql COST 0.0000000000000000000001;
+
+SELECT * FROM phone_number WHERE tricky(person, phone);
+
+ Every person and phone number in the phone_data table will be
+ printed as a NOTICE, because the planner will choose to
+ execute the inexpensive tricky function before the
+ more expensive NOT LIKE. Even if the user is
+ prevented from defining new functions, built-in functions can be used in
+ similar attacks. (For example, most casting functions include their
+ input values in the error messages they produce.)
+
+ Similar considerations apply to update rules. In the examples of
+ the previous section, the owner of the tables in the example
+ database could grant the privileges SELECT,
+ INSERT, UPDATE, and DELETE on
+ the shoelace view to someone else, but only
+ SELECT on shoelace_log. The rule action to
+ write log entries will still be executed successfully, and that
+ other user could see the log entries. But they could not create fake
+ entries, nor could they manipulate or remove existing ones. In this
+ case, there is no possibility of subverting the rules by convincing
+ the planner to alter the order of operations, because the only rule
+ which references shoelace_log is an unqualified
+ INSERT. This might not be true in more complex scenarios.
+
+ When it is necessary for a view to provide row-level security, the
+ security_barrier attribute should be applied to
+ the view. This prevents maliciously-chosen functions and operators from
+ being passed values from rows until after the view has done its work. For
+ example, if the view shown above had been created like this, it would
+ be secure:
+
+CREATE VIEW phone_number WITH (security_barrier) AS
+ SELECT person, phone FROM phone_data WHERE phone NOT LIKE '412%';
+
+ Views created with the security_barrier may perform
+ far worse than views created without this option. In general, there is
+ no way to avoid this: the fastest possible plan must be rejected
+ if it may compromise security. For this reason, this option is not
+ enabled by default.
+
+ The query planner has more flexibility when dealing with functions that
+ have no side effects. Such functions are referred to as LEAKPROOF, and
+ include many simple, commonly used operators, such as many equality
+ operators. The query planner can safely allow such functions to be evaluated
+ at any point in the query execution process, since invoking them on rows
+ invisible to the user will not leak any information about the unseen rows.
+ Further, functions which do not take arguments or which are not passed any
+ arguments from the security barrier view do not have to be marked as
+ LEAKPROOF to be pushed down, as they never receive data
+ from the view. In contrast, a function that might throw an error depending
+ on the values received as arguments (such as one that throws an error in the
+ event of overflow or division by zero) is not leak-proof, and could provide
+ significant information about the unseen rows if applied before the security
+ view's row filters.
+
+ It is important to understand that even a view created with the
+ security_barrier option is intended to be secure only
+ in the limited sense that the contents of the invisible tuples will not be
+ passed to possibly-insecure functions. The user may well have other means
+ of making inferences about the unseen data; for example, they can see the
+ query plan using EXPLAIN, or measure the run time of
+ queries against the view. A malicious attacker might be able to infer
+ something about the amount of unseen data, or even gain some information
+ about the data distribution or most common values (since these things may
+ affect the run time of the plan; or even, since they are also reflected in
+ the optimizer statistics, the choice of plan). If these types of "covert
+ channel" attacks are of concern, it is probably unwise to grant any access
+ to the data at all.
+
41.6. Rules and Command Status #
+ The PostgreSQL server returns a command
+ status string, such as INSERT 149592 1, for each
+ command it receives. This is simple enough when there are no rules
+ involved, but what happens when the query is rewritten by rules?
+
+ Rules affect the command status as follows:
+
+
+ If there is no unconditional INSTEAD rule for the query, then
+ the originally given query will be executed, and its command
+ status will be returned as usual. (But note that if there were
+ any conditional INSTEAD rules, the negation of their qualifications
+ will have been added to the original query. This might reduce the
+ number of rows it processes, and if so the reported status will
+ be affected.)
+
+ If there is any unconditional INSTEAD rule for the query, then
+ the original query will not be executed at all. In this case,
+ the server will return the command status for the last query
+ that was inserted by an INSTEAD rule (conditional or
+ unconditional) and is of the same command type
+ (INSERT, UPDATE, or
+ DELETE) as the original query. If no query
+ meeting those requirements is added by any rule, then the
+ returned command status shows the original query type and
+ zeroes for the row-count and OID fields.
+
+
+ The programmer can ensure that any desired INSTEAD rule is the one
+ that sets the command status in the second case, by giving it the
+ alphabetically last rule name among the active rules, so that it
+ gets applied last.
+
41.7. Rules Versus Triggers #
+ Many things that can be done using triggers can also be
+ implemented using the PostgreSQL
+ rule system. One of the things that cannot be implemented by
+ rules are some kinds of constraints, especially foreign keys. It is possible
+ to place a qualified rule that rewrites a command to NOTHING
+ if the value of a column does not appear in another table.
+ But then the data is silently thrown away and that's
+ not a good idea. If checks for valid values are required,
+ and in the case of an invalid value an error message should
+ be generated, it must be done by a trigger.
+
+ In this chapter, we focused on using rules to update views. All of
+ the update rule examples in this chapter can also be implemented
+ using INSTEAD OF triggers on the views. Writing such
+ triggers is often easier than writing rules, particularly if complex
+ logic is required to perform the update.
+
+ For the things that can be implemented by both, which is best
+ depends on the usage of the database.
+ A trigger is fired once for each affected row. A rule modifies
+ the query or generates an additional query. So if many
+ rows are affected in one statement, a rule issuing one extra
+ command is likely to be faster than a trigger that is
+ called for every single row and must re-determine what to do
+ many times. However, the trigger approach is conceptually far
+ simpler than the rule approach, and is easier for novices to get right.
+
+ Here we show an example of how the choice of rules versus triggers
+ plays out in one situation. There are two tables:
+
+
+CREATE TABLE computer (
+ hostname text, -- indexed
+ manufacturer text -- indexed
+);
+
+CREATE TABLE software (
+ software text, -- indexed
+ hostname text -- indexed
+);
+
+
+ Both tables have many thousands of rows and the indexes on
+ hostname are unique. The rule or trigger should
+ implement a constraint that deletes rows from software
+ that reference a deleted computer. The trigger would use this command:
+
+
+DELETE FROM software WHERE hostname = $1;
+
+
+ Since the trigger is called for each individual row deleted from
+ computer, it can prepare and save the plan for this
+ command and pass the hostname value in the
+ parameter. The rule would be written as:
+
+
+CREATE RULE computer_del AS ON DELETE TO computer
+ DO DELETE FROM software WHERE hostname = OLD.hostname;
+
+
+ Now we look at different types of deletes. In the case of a:
+
+
+DELETE FROM computer WHERE hostname = 'mypc.local.net';
+
+
+ the table computer is scanned by index (fast), and the
+ command issued by the trigger would also use an index scan (also fast).
+ The extra command from the rule would be:
+
+
+DELETE FROM software WHERE computer.hostname = 'mypc.local.net'
+ AND software.hostname = computer.hostname;
+
+
+ Since there are appropriate indexes set up, the planner
+ will create a plan of
+
+
+Nestloop
+ -> Index Scan using comp_hostidx on computer
+ -> Index Scan using soft_hostidx on software
+
+
+ So there would be not that much difference in speed between
+ the trigger and the rule implementation.
+
+ With the next delete we want to get rid of all the 2000 computers
+ where the hostname starts with
+ old. There are two possible commands to do that. One
+ is:
+
+
+DELETE FROM computer WHERE hostname >= 'old'
+ AND hostname < 'ole'
+
+
+ The command added by the rule will be:
+
+
+DELETE FROM software WHERE computer.hostname >= 'old' AND computer.hostname < 'ole'
+ AND software.hostname = computer.hostname;
+
+
+ with the plan
+
+
+Hash Join
+ -> Seq Scan on software
+ -> Hash
+ -> Index Scan using comp_hostidx on computer
+
+
+ The other possible command is:
+
+
+DELETE FROM computer WHERE hostname ~ '^old';
+
+
+ which results in the following executing plan for the command
+ added by the rule:
+
+
+Nestloop
+ -> Index Scan using comp_hostidx on computer
+ -> Index Scan using soft_hostidx on software
+
+
+ This shows, that the planner does not realize that the
+ qualification for hostname in
+ computer could also be used for an index scan on
+ software when there are multiple qualification
+ expressions combined with AND, which is what it does
+ in the regular-expression version of the command. The trigger will
+ get invoked once for each of the 2000 old computers that have to be
+ deleted, and that will result in one index scan over
+ computer and 2000 index scans over
+ software. The rule implementation will do it with two
+ commands that use indexes. And it depends on the overall size of
+ the table software whether the rule will still be faster in the
+ sequential scan situation. 2000 command executions from the trigger over the SPI
+ manager take some time, even if all the index blocks will soon be in the cache.
+
+ The last command we look at is:
+
+
+DELETE FROM computer WHERE manufacturer = 'bim';
+
+
+ Again this could result in many rows to be deleted from
+ computer. So the trigger will again run many commands
+ through the executor. The command generated by the rule will be:
+
+
+DELETE FROM software WHERE computer.manufacturer = 'bim'
+ AND software.hostname = computer.hostname;
+
+
+ The plan for that command will again be the nested loop over two
+ index scans, only using a different index on computer:
+
+
+Nestloop
+ -> Index Scan using comp_manufidx on computer
+ -> Index Scan using soft_hostidx on software
+
+
+ In any of these cases, the extra commands from the rule system
+ will be more or less independent from the number of affected rows
+ in a command.
+
+ The summary is, rules will only be significantly slower than
+ triggers if their actions result in large and badly qualified
+ joins, a situation where the planner fails.
+
41.4. Rules on INSERT, UPDATE, and DELETE #
+ Rules that are defined on INSERT, UPDATE,
+ and DELETE are significantly different from the view rules
+ described in the previous sections. First, their CREATE
+ RULE command allows more:
+
+
+ They are allowed to have no action.
+
+ They can have multiple actions.
+
+ They can be INSTEAD or ALSO (the default).
+
+ The pseudorelations NEW and OLD become useful.
+
+ They can have rule qualifications.
+
+
+ Second, they don't modify the query tree in place. Instead they
+ create zero or more new query trees and can throw away the
+ original one.
+
Caution
+ In many cases, tasks that could be performed by rules
+ on INSERT/UPDATE/DELETE are better done
+ with triggers. Triggers are notationally a bit more complicated, but their
+ semantics are much simpler to understand. Rules tend to have surprising
+ results when the original query contains volatile functions: volatile
+ functions may get executed more times than expected in the process of
+ carrying out the rules.
+
+ Also, there are some cases that are not supported by these types of rules at
+ all, notably including WITH clauses in the original query and
+ multiple-assignment sub-SELECTs in the SET list
+ of UPDATE queries. This is because copying these constructs
+ into a rule query would result in multiple evaluations of the sub-query,
+ contrary to the express intent of the query's author.
+
41.4.1. How Update Rules Work #
+ Keep the syntax:
+
+
+CREATE [ OR REPLACE ] RULE name AS ON event
+ TO table [ WHERE condition ]
+ DO [ ALSO | INSTEAD ] { NOTHING | command | ( command ; command ... ) }
+
+
+ in mind.
+ In the following, update rules means rules that are defined
+ on INSERT, UPDATE, or DELETE.
+
+ Update rules get applied by the rule system when the result
+ relation and the command type of a query tree are equal to the
+ object and event given in the CREATE RULE command.
+ For update rules, the rule system creates a list of query trees.
+ Initially the query-tree list is empty.
+ There can be zero (NOTHING key word), one, or multiple actions.
+ To simplify, we will look at a rule with one action. This rule
+ can have a qualification or not and it can be INSTEAD or
+ ALSO (the default).
+
+ What is a rule qualification? It is a restriction that tells
+ when the actions of the rule should be done and when not. This
+ qualification can only reference the pseudorelations NEW and/or OLD,
+ which basically represent the relation that was given as object (but with a
+ special meaning).
+
+ So we have three cases that produce the following query trees for
+ a one-action rule.
+
+
- No qualification, with either
ALSO or
+ INSTEAD
+ the query tree from the rule action with the original query
+ tree's qualification added
+
- Qualification given and
ALSO
+ the query tree from the rule action with the rule
+ qualification and the original query tree's qualification
+ added
+
- Qualification given and
INSTEAD
+ the query tree from the rule action with the rule
+ qualification and the original query tree's qualification; and
+ the original query tree with the negated rule qualification
+ added
+
+
+ Finally, if the rule is ALSO, the unchanged original query tree is
+ added to the list. Since only qualified INSTEAD rules already add the
+ original query tree, we end up with either one or two output query trees
+ for a rule with one action.
+
+ For ON INSERT rules, the original query (if not suppressed by INSTEAD)
+ is done before any actions added by rules. This allows the actions to
+ see the inserted row(s). But for ON UPDATE and ON
+ DELETE rules, the original query is done after the actions added by rules.
+ This ensures that the actions can see the to-be-updated or to-be-deleted
+ rows; otherwise, the actions might do nothing because they find no rows
+ matching their qualifications.
+
+ The query trees generated from rule actions are thrown into the
+ rewrite system again, and maybe more rules get applied resulting
+ in additional or fewer query trees.
+ So a rule's actions must have either a different
+ command type or a different result relation than the rule itself is
+ on, otherwise this recursive process will end up in an infinite loop.
+ (Recursive expansion of a rule will be detected and reported as an
+ error.)
+
+ The query trees found in the actions of the
+ pg_rewrite system catalog are only
+ templates. Since they can reference the range-table entries for
+ NEW and OLD, some substitutions have to be made before they can be
+ used. For any reference to NEW, the target list of the original
+ query is searched for a corresponding entry. If found, that
+ entry's expression replaces the reference. Otherwise, NEW means the
+ same as OLD (for an UPDATE) or is replaced by
+ a null value (for an INSERT). Any reference to OLD is
+ replaced by a reference to the range-table entry that is the
+ result relation.
+
+ After the system is done applying update rules, it applies view rules to the
+ produced query tree(s). Views cannot insert new update actions so
+ there is no need to apply update rules to the output of view rewriting.
+
41.4.1.1. A First Rule Step by Step #
+ Say we want to trace changes to the sl_avail column in the
+ shoelace_data relation. So we set up a log table
+ and a rule that conditionally writes a log entry when an
+ UPDATE is performed on
+ shoelace_data.
+
+
+CREATE TABLE shoelace_log (
+ sl_name text, -- shoelace changed
+ sl_avail integer, -- new available value
+ log_who text, -- who did it
+ log_when timestamp -- when
+);
+
+CREATE RULE log_shoelace AS ON UPDATE TO shoelace_data
+ WHERE NEW.sl_avail <> OLD.sl_avail
+ DO INSERT INTO shoelace_log VALUES (
+ NEW.sl_name,
+ NEW.sl_avail,
+ current_user,
+ current_timestamp
+ );
+
+
+ Now someone does:
+
+
+UPDATE shoelace_data SET sl_avail = 6 WHERE sl_name = 'sl7';
+
+
+ and we look at the log table:
+
+
+SELECT * FROM shoelace_log;
+
+ sl_name | sl_avail | log_who | log_when
+---------+----------+---------+----------------------------------
+ sl7 | 6 | Al | Tue Oct 20 16:14:45 1998 MET DST
+(1 row)
+
+
+ That's what we expected. What happened in the background is the following.
+ The parser created the query tree:
+
+
+UPDATE shoelace_data SET sl_avail = 6
+ FROM shoelace_data shoelace_data
+ WHERE shoelace_data.sl_name = 'sl7';
+
+
+ There is a rule log_shoelace that is ON UPDATE with the rule
+ qualification expression:
+
+
+NEW.sl_avail <> OLD.sl_avail
+
+
+ and the action:
+
+
+INSERT INTO shoelace_log VALUES (
+ new.sl_name, new.sl_avail,
+ current_user, current_timestamp )
+ FROM shoelace_data new, shoelace_data old;
+
+
+ (This looks a little strange since you cannot normally write
+ INSERT ... VALUES ... FROM. The FROM
+ clause here is just to indicate that there are range-table entries
+ in the query tree for new and old.
+ These are needed so that they can be referenced by variables in
+ the INSERT command's query tree.)
+
+ The rule is a qualified ALSO rule, so the rule system
+ has to return two query trees: the modified rule action and the original
+ query tree. In step 1, the range table of the original query is
+ incorporated into the rule's action query tree. This results in:
+
+
+INSERT INTO shoelace_log VALUES (
+ new.sl_name, new.sl_avail,
+ current_user, current_timestamp )
+ FROM shoelace_data new, shoelace_data old,
+ shoelace_data shoelace_data;
+
+
+ In step 2, the rule qualification is added to it, so the result set
+ is restricted to rows where sl_avail changes:
+
+
+INSERT INTO shoelace_log VALUES (
+ new.sl_name, new.sl_avail,
+ current_user, current_timestamp )
+ FROM shoelace_data new, shoelace_data old,
+ shoelace_data shoelace_data
+ WHERE new.sl_avail <> old.sl_avail;
+
+
+ (This looks even stranger, since INSERT ... VALUES doesn't have
+ a WHERE clause either, but the planner and executor will have no
+ difficulty with it. They need to support this same functionality
+ anyway for INSERT ... SELECT.)
+
+ In step 3, the original query tree's qualification is added,
+ restricting the result set further to only the rows that would have been touched
+ by the original query:
+
+
+INSERT INTO shoelace_log VALUES (
+ new.sl_name, new.sl_avail,
+ current_user, current_timestamp )
+ FROM shoelace_data new, shoelace_data old,
+ shoelace_data shoelace_data
+ WHERE new.sl_avail <> old.sl_avail
+ AND shoelace_data.sl_name = 'sl7';
+
+
+ Step 4 replaces references to NEW by the target list entries from the
+ original query tree or by the matching variable references
+ from the result relation:
+
+
+INSERT INTO shoelace_log VALUES (
+ shoelace_data.sl_name, 6,
+ current_user, current_timestamp )
+ FROM shoelace_data new, shoelace_data old,
+ shoelace_data shoelace_data
+ WHERE 6 <> old.sl_avail
+ AND shoelace_data.sl_name = 'sl7';
+
+
+
+ Step 5 changes OLD references into result relation references:
+
+
+INSERT INTO shoelace_log VALUES (
+ shoelace_data.sl_name, 6,
+ current_user, current_timestamp )
+ FROM shoelace_data new, shoelace_data old,
+ shoelace_data shoelace_data
+ WHERE 6 <> shoelace_data.sl_avail
+ AND shoelace_data.sl_name = 'sl7';
+
+
+ That's it. Since the rule is ALSO, we also output the
+ original query tree. In short, the output from the rule system
+ is a list of two query trees that correspond to these statements:
+
+
+INSERT INTO shoelace_log VALUES (
+ shoelace_data.sl_name, 6,
+ current_user, current_timestamp )
+ FROM shoelace_data
+ WHERE 6 <> shoelace_data.sl_avail
+ AND shoelace_data.sl_name = 'sl7';
+
+UPDATE shoelace_data SET sl_avail = 6
+ WHERE sl_name = 'sl7';
+
+
+ These are executed in this order, and that is exactly what
+ the rule was meant to do.
+
+ The substitutions and the added qualifications
+ ensure that, if the original query would be, say:
+
+
+UPDATE shoelace_data SET sl_color = 'green'
+ WHERE sl_name = 'sl7';
+
+
+ no log entry would get written. In that case, the original query
+ tree does not contain a target list entry for
+ sl_avail, so NEW.sl_avail will get
+ replaced by shoelace_data.sl_avail. Thus, the extra
+ command generated by the rule is:
+
+
+INSERT INTO shoelace_log VALUES (
+ shoelace_data.sl_name, shoelace_data.sl_avail,
+ current_user, current_timestamp )
+ FROM shoelace_data
+ WHERE shoelace_data.sl_avail <> shoelace_data.sl_avail
+ AND shoelace_data.sl_name = 'sl7';
+
+
+ and that qualification will never be true.
+
+ It will also work if the original query modifies multiple rows. So
+ if someone issued the command:
+
+
+UPDATE shoelace_data SET sl_avail = 0
+ WHERE sl_color = 'black';
+
+
+ four rows in fact get updated (sl1, sl2, sl3, and sl4).
+ But sl3 already has sl_avail = 0. In this case, the original
+ query trees qualification is different and that results
+ in the extra query tree:
+
+
+INSERT INTO shoelace_log
+SELECT shoelace_data.sl_name, 0,
+ current_user, current_timestamp
+ FROM shoelace_data
+ WHERE 0 <> shoelace_data.sl_avail
+ AND shoelace_data.sl_color = 'black';
+
+
+ being generated by the rule. This query tree will surely insert
+ three new log entries. And that's absolutely correct.
+
+ Here we can see why it is important that the original query tree
+ is executed last. If the UPDATE had been
+ executed first, all the rows would have already been set to zero, so the
+ logging INSERT would not find any row where
+ 0 <> shoelace_data.sl_avail.
+
41.4.2. Cooperation with Views #
+ A simple way to protect view relations from the mentioned
+ possibility that someone can try to run INSERT,
+ UPDATE, or DELETE on them is
+ to let those query trees get thrown away. So we could create the rules:
+
+
+CREATE RULE shoe_ins_protect AS ON INSERT TO shoe
+ DO INSTEAD NOTHING;
+CREATE RULE shoe_upd_protect AS ON UPDATE TO shoe
+ DO INSTEAD NOTHING;
+CREATE RULE shoe_del_protect AS ON DELETE TO shoe
+ DO INSTEAD NOTHING;
+
+
+ If someone now tries to do any of these operations on the view
+ relation shoe, the rule system will
+ apply these rules. Since the rules have
+ no actions and are INSTEAD, the resulting list of
+ query trees will be empty and the whole query will become
+ nothing because there is nothing left to be optimized or
+ executed after the rule system is done with it.
+
+ A more sophisticated way to use the rule system is to
+ create rules that rewrite the query tree into one that
+ does the right operation on the real tables. To do that
+ on the shoelace view, we create
+ the following rules:
+
+
+CREATE RULE shoelace_ins AS ON INSERT TO shoelace
+ DO INSTEAD
+ INSERT INTO shoelace_data VALUES (
+ NEW.sl_name,
+ NEW.sl_avail,
+ NEW.sl_color,
+ NEW.sl_len,
+ NEW.sl_unit
+ );
+
+CREATE RULE shoelace_upd AS ON UPDATE TO shoelace
+ DO INSTEAD
+ UPDATE shoelace_data
+ SET sl_name = NEW.sl_name,
+ sl_avail = NEW.sl_avail,
+ sl_color = NEW.sl_color,
+ sl_len = NEW.sl_len,
+ sl_unit = NEW.sl_unit
+ WHERE sl_name = OLD.sl_name;
+
+CREATE RULE shoelace_del AS ON DELETE TO shoelace
+ DO INSTEAD
+ DELETE FROM shoelace_data
+ WHERE sl_name = OLD.sl_name;
+
+
+ If you want to support RETURNING queries on the view,
+ you need to make the rules include RETURNING clauses that
+ compute the view rows. This is usually pretty trivial for views on a
+ single table, but it's a bit tedious for join views such as
+ shoelace. An example for the insert case is:
+
+
+CREATE RULE shoelace_ins AS ON INSERT TO shoelace
+ DO INSTEAD
+ INSERT INTO shoelace_data VALUES (
+ NEW.sl_name,
+ NEW.sl_avail,
+ NEW.sl_color,
+ NEW.sl_len,
+ NEW.sl_unit
+ )
+ RETURNING
+ shoelace_data.*,
+ (SELECT shoelace_data.sl_len * u.un_fact
+ FROM unit u WHERE shoelace_data.sl_unit = u.un_name);
+
+
+ Note that this one rule supports both INSERT and
+ INSERT RETURNING queries on the view — the
+ RETURNING clause is simply ignored for INSERT.
+
+ Now assume that once in a while, a pack of shoelaces arrives at
+ the shop and a big parts list along with it. But you don't want
+ to manually update the shoelace view every
+ time. Instead we set up two little tables: one where you can
+ insert the items from the part list, and one with a special
+ trick. The creation commands for these are:
+
+
+CREATE TABLE shoelace_arrive (
+ arr_name text,
+ arr_quant integer
+);
+
+CREATE TABLE shoelace_ok (
+ ok_name text,
+ ok_quant integer
+);
+
+CREATE RULE shoelace_ok_ins AS ON INSERT TO shoelace_ok
+ DO INSTEAD
+ UPDATE shoelace
+ SET sl_avail = sl_avail + NEW.ok_quant
+ WHERE sl_name = NEW.ok_name;
+
+
+ Now you can fill the table shoelace_arrive with
+ the data from the parts list:
+
+
+SELECT * FROM shoelace_arrive;
+
+ arr_name | arr_quant
+----------+-----------
+ sl3 | 10
+ sl6 | 20
+ sl8 | 20
+(3 rows)
+
+
+ Take a quick look at the current data:
+
+
+SELECT * FROM shoelace;
+
+ sl_name | sl_avail | sl_color | sl_len | sl_unit | sl_len_cm
+----------+----------+----------+--------+---------+-----------
+ sl1 | 5 | black | 80 | cm | 80
+ sl2 | 6 | black | 100 | cm | 100
+ sl7 | 6 | brown | 60 | cm | 60
+ sl3 | 0 | black | 35 | inch | 88.9
+ sl4 | 8 | black | 40 | inch | 101.6
+ sl8 | 1 | brown | 40 | inch | 101.6
+ sl5 | 4 | brown | 1 | m | 100
+ sl6 | 0 | brown | 0.9 | m | 90
+(8 rows)
+
+
+ Now move the arrived shoelaces in:
+
+
+INSERT INTO shoelace_ok SELECT * FROM shoelace_arrive;
+
+
+ and check the results:
+
+
+SELECT * FROM shoelace ORDER BY sl_name;
+
+ sl_name | sl_avail | sl_color | sl_len | sl_unit | sl_len_cm
+----------+----------+----------+--------+---------+-----------
+ sl1 | 5 | black | 80 | cm | 80
+ sl2 | 6 | black | 100 | cm | 100
+ sl7 | 6 | brown | 60 | cm | 60
+ sl4 | 8 | black | 40 | inch | 101.6
+ sl3 | 10 | black | 35 | inch | 88.9
+ sl8 | 21 | brown | 40 | inch | 101.6
+ sl5 | 4 | brown | 1 | m | 100
+ sl6 | 20 | brown | 0.9 | m | 90
+(8 rows)
+
+SELECT * FROM shoelace_log;
+
+ sl_name | sl_avail | log_who| log_when
+---------+----------+--------+----------------------------------
+ sl7 | 6 | Al | Tue Oct 20 19:14:45 1998 MET DST
+ sl3 | 10 | Al | Tue Oct 20 19:25:16 1998 MET DST
+ sl6 | 20 | Al | Tue Oct 20 19:25:16 1998 MET DST
+ sl8 | 21 | Al | Tue Oct 20 19:25:16 1998 MET DST
+(4 rows)
+
+
+ It's a long way from the one INSERT ... SELECT
+ to these results. And the description of the query-tree
+ transformation will be the last in this chapter. First, there is
+ the parser's output:
+
+
+INSERT INTO shoelace_ok
+SELECT shoelace_arrive.arr_name, shoelace_arrive.arr_quant
+ FROM shoelace_arrive shoelace_arrive, shoelace_ok shoelace_ok;
+
+
+ Now the first rule shoelace_ok_ins is applied and turns this
+ into:
+
+
+UPDATE shoelace
+ SET sl_avail = shoelace.sl_avail + shoelace_arrive.arr_quant
+ FROM shoelace_arrive shoelace_arrive, shoelace_ok shoelace_ok,
+ shoelace_ok old, shoelace_ok new,
+ shoelace shoelace
+ WHERE shoelace.sl_name = shoelace_arrive.arr_name;
+
+
+ and throws away the original INSERT on
+ shoelace_ok. This rewritten query is passed to
+ the rule system again, and the second applied rule
+ shoelace_upd produces:
+
+
+UPDATE shoelace_data
+ SET sl_name = shoelace.sl_name,
+ sl_avail = shoelace.sl_avail + shoelace_arrive.arr_quant,
+ sl_color = shoelace.sl_color,
+ sl_len = shoelace.sl_len,
+ sl_unit = shoelace.sl_unit
+ FROM shoelace_arrive shoelace_arrive, shoelace_ok shoelace_ok,
+ shoelace_ok old, shoelace_ok new,
+ shoelace shoelace, shoelace old,
+ shoelace new, shoelace_data shoelace_data
+ WHERE shoelace.sl_name = shoelace_arrive.arr_name
+ AND shoelace_data.sl_name = shoelace.sl_name;
+
+
+ Again it's an INSTEAD rule and the previous query tree is trashed.
+ Note that this query still uses the view shoelace.
+ But the rule system isn't finished with this step, so it continues
+ and applies the _RETURN rule on it, and we get:
+
+
+UPDATE shoelace_data
+ SET sl_name = s.sl_name,
+ sl_avail = s.sl_avail + shoelace_arrive.arr_quant,
+ sl_color = s.sl_color,
+ sl_len = s.sl_len,
+ sl_unit = s.sl_unit
+ FROM shoelace_arrive shoelace_arrive, shoelace_ok shoelace_ok,
+ shoelace_ok old, shoelace_ok new,
+ shoelace shoelace, shoelace old,
+ shoelace new, shoelace_data shoelace_data,
+ shoelace old, shoelace new,
+ shoelace_data s, unit u
+ WHERE s.sl_name = shoelace_arrive.arr_name
+ AND shoelace_data.sl_name = s.sl_name;
+
+
+ Finally, the rule log_shoelace gets applied,
+ producing the extra query tree:
+
+
+INSERT INTO shoelace_log
+SELECT s.sl_name,
+ s.sl_avail + shoelace_arrive.arr_quant,
+ current_user,
+ current_timestamp
+ FROM shoelace_arrive shoelace_arrive, shoelace_ok shoelace_ok,
+ shoelace_ok old, shoelace_ok new,
+ shoelace shoelace, shoelace old,
+ shoelace new, shoelace_data shoelace_data,
+ shoelace old, shoelace new,
+ shoelace_data s, unit u,
+ shoelace_data old, shoelace_data new
+ shoelace_log shoelace_log
+ WHERE s.sl_name = shoelace_arrive.arr_name
+ AND shoelace_data.sl_name = s.sl_name
+ AND (s.sl_avail + shoelace_arrive.arr_quant) <> s.sl_avail;
+
+
+ After that the rule system runs out of rules and returns the
+ generated query trees.
+
+ So we end up with two final query trees that are equivalent to the
+ SQL statements:
+
+
+INSERT INTO shoelace_log
+SELECT s.sl_name,
+ s.sl_avail + shoelace_arrive.arr_quant,
+ current_user,
+ current_timestamp
+ FROM shoelace_arrive shoelace_arrive, shoelace_data shoelace_data,
+ shoelace_data s
+ WHERE s.sl_name = shoelace_arrive.arr_name
+ AND shoelace_data.sl_name = s.sl_name
+ AND s.sl_avail + shoelace_arrive.arr_quant <> s.sl_avail;
+
+UPDATE shoelace_data
+ SET sl_avail = shoelace_data.sl_avail + shoelace_arrive.arr_quant
+ FROM shoelace_arrive shoelace_arrive,
+ shoelace_data shoelace_data,
+ shoelace_data s
+ WHERE s.sl_name = shoelace_arrive.sl_name
+ AND shoelace_data.sl_name = s.sl_name;
+
+
+ The result is that data coming from one relation inserted into another,
+ changed into updates on a third, changed into updating
+ a fourth plus logging that final update in a fifth
+ gets reduced into two queries.
+
+ There is a little detail that's a bit ugly. Looking at the two
+ queries, it turns out that the shoelace_data
+ relation appears twice in the range table where it could
+ definitely be reduced to one. The planner does not handle it and
+ so the execution plan for the rule systems output of the
+ INSERT will be
+
+
+Nested Loop
+ -> Merge Join
+ -> Seq Scan
+ -> Sort
+ -> Seq Scan on s
+ -> Seq Scan
+ -> Sort
+ -> Seq Scan on shoelace_arrive
+ -> Seq Scan on shoelace_data
+
+
+ while omitting the extra range table entry would result in a
+
+
+Merge Join
+ -> Seq Scan
+ -> Sort
+ -> Seq Scan on s
+ -> Seq Scan
+ -> Sort
+ -> Seq Scan on shoelace_arrive
+
+
+ which produces exactly the same entries in the log table. Thus,
+ the rule system caused one extra scan on the table
+ shoelace_data that is absolutely not
+ necessary. And the same redundant scan is done once more in the
+ UPDATE. But it was a really hard job to make
+ that all possible at all.
+
+ Now we make a final demonstration of the
+ PostgreSQL rule system and its power.
+ Say you add some shoelaces with extraordinary colors to your
+ database:
+
+
+INSERT INTO shoelace VALUES ('sl9', 0, 'pink', 35.0, 'inch', 0.0);
+INSERT INTO shoelace VALUES ('sl10', 1000, 'magenta', 40.0, 'inch', 0.0);
+
+
+ We would like to make a view to check which
+ shoelace entries do not fit any shoe in color.
+ The view for this is:
+
+
+CREATE VIEW shoelace_mismatch AS
+ SELECT * FROM shoelace WHERE NOT EXISTS
+ (SELECT shoename FROM shoe WHERE slcolor = sl_color);
+
+
+ Its output is:
+
+
+SELECT * FROM shoelace_mismatch;
+
+ sl_name | sl_avail | sl_color | sl_len | sl_unit | sl_len_cm
+---------+----------+----------+--------+---------+-----------
+ sl9 | 0 | pink | 35 | inch | 88.9
+ sl10 | 1000 | magenta | 40 | inch | 101.6
+
+
+ Now we want to set it up so that mismatching shoelaces that are
+ not in stock are deleted from the database.
+ To make it a little harder for PostgreSQL,
+ we don't delete it directly. Instead we create one more view:
+
+
+CREATE VIEW shoelace_can_delete AS
+ SELECT * FROM shoelace_mismatch WHERE sl_avail = 0;
+
+
+ and do it this way:
+
+
+DELETE FROM shoelace WHERE EXISTS
+ (SELECT * FROM shoelace_can_delete
+ WHERE sl_name = shoelace.sl_name);
+
+
+ The results are:
+
+
+SELECT * FROM shoelace;
+
+ sl_name | sl_avail | sl_color | sl_len | sl_unit | sl_len_cm
+---------+----------+----------+--------+---------+-----------
+ sl1 | 5 | black | 80 | cm | 80
+ sl2 | 6 | black | 100 | cm | 100
+ sl7 | 6 | brown | 60 | cm | 60
+ sl4 | 8 | black | 40 | inch | 101.6
+ sl3 | 10 | black | 35 | inch | 88.9
+ sl8 | 21 | brown | 40 | inch | 101.6
+ sl10 | 1000 | magenta | 40 | inch | 101.6
+ sl5 | 4 | brown | 1 | m | 100
+ sl6 | 20 | brown | 0.9 | m | 90
+(9 rows)
+
+
+ A DELETE on a view, with a subquery qualification that
+ in total uses 4 nesting/joined views, where one of them
+ itself has a subquery qualification containing a view
+ and where calculated view columns are used,
+ gets rewritten into
+ one single query tree that deletes the requested data
+ from a real table.
+
+ There are probably only a few situations out in the real world
+ where such a construct is necessary. But it makes you feel
+ comfortable that it works.
+
41.2. Views and the Rule System #
+ Views in PostgreSQL are implemented
+ using the rule system. A view is basically an empty table (having no
+ actual storage) with an ON SELECT DO INSTEAD rule.
+ Conventionally, that rule is named _RETURN.
+ So a view like
+
+
+CREATE VIEW myview AS SELECT * FROM mytab;
+
+
+ is very nearly the same thing as
+
+
+CREATE TABLE myview (same column list as mytab);
+CREATE RULE "_RETURN" AS ON SELECT TO myview DO INSTEAD
+ SELECT * FROM mytab;
+
+
+ although you can't actually write that, because tables are not
+ allowed to have ON SELECT rules.
+
+ A view can also have other kinds of DO INSTEAD
+ rules, allowing INSERT, UPDATE,
+ or DELETE commands to be performed on the view
+ despite its lack of underlying storage.
+ This is discussed further below, in
+ Section 41.2.4.
+
41.2.1. How SELECT Rules Work #
+ Rules ON SELECT are applied to all queries as the last step, even
+ if the command given is an INSERT,
+ UPDATE or DELETE. And they
+ have different semantics from rules on the other command types in that they modify the
+ query tree in place instead of creating a new one. So
+ SELECT rules are described first.
+
+ Currently, there can be only one action in an ON SELECT rule, and it must
+ be an unconditional SELECT action that is INSTEAD. This restriction was
+ required to make rules safe enough to open them for ordinary users, and
+ it restricts ON SELECT rules to act like views.
+
+ The examples for this chapter are two join views that do some
+ calculations and some more views using them in turn. One of the
+ two first views is customized later by adding rules for
+ INSERT, UPDATE, and
+ DELETE operations so that the final result will
+ be a view that behaves like a real table with some magic
+ functionality. This is not such a simple example to start from and
+ this makes things harder to get into. But it's better to have one
+ example that covers all the points discussed step by step rather
+ than having many different ones that might mix up in mind.
+
+ The real tables we need in the first two rule system descriptions
+ are these:
+
+
+CREATE TABLE shoe_data (
+ shoename text, -- primary key
+ sh_avail integer, -- available number of pairs
+ slcolor text, -- preferred shoelace color
+ slminlen real, -- minimum shoelace length
+ slmaxlen real, -- maximum shoelace length
+ slunit text -- length unit
+);
+
+CREATE TABLE shoelace_data (
+ sl_name text, -- primary key
+ sl_avail integer, -- available number of pairs
+ sl_color text, -- shoelace color
+ sl_len real, -- shoelace length
+ sl_unit text -- length unit
+);
+
+CREATE TABLE unit (
+ un_name text, -- primary key
+ un_fact real -- factor to transform to cm
+);
+
+
+ As you can see, they represent shoe-store data.
+
+ The views are created as:
+
+
+CREATE VIEW shoe AS
+ SELECT sh.shoename,
+ sh.sh_avail,
+ sh.slcolor,
+ sh.slminlen,
+ sh.slminlen * un.un_fact AS slminlen_cm,
+ sh.slmaxlen,
+ sh.slmaxlen * un.un_fact AS slmaxlen_cm,
+ sh.slunit
+ FROM shoe_data sh, unit un
+ WHERE sh.slunit = un.un_name;
+
+CREATE VIEW shoelace AS
+ SELECT s.sl_name,
+ s.sl_avail,
+ s.sl_color,
+ s.sl_len,
+ s.sl_unit,
+ s.sl_len * u.un_fact AS sl_len_cm
+ FROM shoelace_data s, unit u
+ WHERE s.sl_unit = u.un_name;
+
+CREATE VIEW shoe_ready AS
+ SELECT rsh.shoename,
+ rsh.sh_avail,
+ rsl.sl_name,
+ rsl.sl_avail,
+ least(rsh.sh_avail, rsl.sl_avail) AS total_avail
+ FROM shoe rsh, shoelace rsl
+ WHERE rsl.sl_color = rsh.slcolor
+ AND rsl.sl_len_cm >= rsh.slminlen_cm
+ AND rsl.sl_len_cm <= rsh.slmaxlen_cm;
+
+
+ The CREATE VIEW command for the
+ shoelace view (which is the simplest one we
+ have) will create a relation shoelace and an entry in
+ pg_rewrite that tells that there is a
+ rewrite rule that must be applied whenever the relation shoelace
+ is referenced in a query's range table. The rule has no rule
+ qualification (discussed later, with the non-SELECT rules, since
+ SELECT rules currently cannot have them) and it is INSTEAD. Note
+ that rule qualifications are not the same as query qualifications.
+ The action of our rule has a query qualification.
+ The action of the rule is one query tree that is a copy of the
+ SELECT statement in the view creation command.
+
Note
+ The two extra range
+ table entries for NEW and OLD that you can see in
+ the pg_rewrite entry aren't of interest
+ for SELECT rules.
+
+ Now we populate unit, shoe_data
+ and shoelace_data and run a simple query on a view:
+
+
+INSERT INTO unit VALUES ('cm', 1.0);
+INSERT INTO unit VALUES ('m', 100.0);
+INSERT INTO unit VALUES ('inch', 2.54);
+
+INSERT INTO shoe_data VALUES ('sh1', 2, 'black', 70.0, 90.0, 'cm');
+INSERT INTO shoe_data VALUES ('sh2', 0, 'black', 30.0, 40.0, 'inch');
+INSERT INTO shoe_data VALUES ('sh3', 4, 'brown', 50.0, 65.0, 'cm');
+INSERT INTO shoe_data VALUES ('sh4', 3, 'brown', 40.0, 50.0, 'inch');
+
+INSERT INTO shoelace_data VALUES ('sl1', 5, 'black', 80.0, 'cm');
+INSERT INTO shoelace_data VALUES ('sl2', 6, 'black', 100.0, 'cm');
+INSERT INTO shoelace_data VALUES ('sl3', 0, 'black', 35.0 , 'inch');
+INSERT INTO shoelace_data VALUES ('sl4', 8, 'black', 40.0 , 'inch');
+INSERT INTO shoelace_data VALUES ('sl5', 4, 'brown', 1.0 , 'm');
+INSERT INTO shoelace_data VALUES ('sl6', 0, 'brown', 0.9 , 'm');
+INSERT INTO shoelace_data VALUES ('sl7', 7, 'brown', 60 , 'cm');
+INSERT INTO shoelace_data VALUES ('sl8', 1, 'brown', 40 , 'inch');
+
+SELECT * FROM shoelace;
+
+ sl_name | sl_avail | sl_color | sl_len | sl_unit | sl_len_cm
+-----------+----------+----------+--------+---------+-----------
+ sl1 | 5 | black | 80 | cm | 80
+ sl2 | 6 | black | 100 | cm | 100
+ sl7 | 7 | brown | 60 | cm | 60
+ sl3 | 0 | black | 35 | inch | 88.9
+ sl4 | 8 | black | 40 | inch | 101.6
+ sl8 | 1 | brown | 40 | inch | 101.6
+ sl5 | 4 | brown | 1 | m | 100
+ sl6 | 0 | brown | 0.9 | m | 90
+(8 rows)
+
+
+ This is the simplest SELECT you can do on our
+ views, so we take this opportunity to explain the basics of view
+ rules. The SELECT * FROM shoelace was
+ interpreted by the parser and produced the query tree:
+
+
+SELECT shoelace.sl_name, shoelace.sl_avail,
+ shoelace.sl_color, shoelace.sl_len,
+ shoelace.sl_unit, shoelace.sl_len_cm
+ FROM shoelace shoelace;
+
+
+ and this is given to the rule system. The rule system walks through the
+ range table and checks if there are rules
+ for any relation. When processing the range table entry for
+ shoelace (the only one up to now) it finds the
+ _RETURN rule with the query tree:
+
+
+SELECT s.sl_name, s.sl_avail,
+ s.sl_color, s.sl_len, s.sl_unit,
+ s.sl_len * u.un_fact AS sl_len_cm
+ FROM shoelace old, shoelace new,
+ shoelace_data s, unit u
+ WHERE s.sl_unit = u.un_name;
+
+
+ To expand the view, the rewriter simply creates a subquery range-table
+ entry containing the rule's action query tree, and substitutes this
+ range table entry for the original one that referenced the view. The
+ resulting rewritten query tree is almost the same as if you had typed:
+
+
+SELECT shoelace.sl_name, shoelace.sl_avail,
+ shoelace.sl_color, shoelace.sl_len,
+ shoelace.sl_unit, shoelace.sl_len_cm
+ FROM (SELECT s.sl_name,
+ s.sl_avail,
+ s.sl_color,
+ s.sl_len,
+ s.sl_unit,
+ s.sl_len * u.un_fact AS sl_len_cm
+ FROM shoelace_data s, unit u
+ WHERE s.sl_unit = u.un_name) shoelace;
+
+
+ There is one difference however: the subquery's range table has two
+ extra entries shoelace old and shoelace new. These entries don't
+ participate directly in the query, since they aren't referenced by
+ the subquery's join tree or target list. The rewriter uses them
+ to store the access privilege check information that was originally present
+ in the range-table entry that referenced the view. In this way, the
+ executor will still check that the user has proper privileges to access
+ the view, even though there's no direct use of the view in the rewritten
+ query.
+
+ That was the first rule applied. The rule system will continue checking
+ the remaining range-table entries in the top query (in this example there
+ are no more), and it will recursively check the range-table entries in
+ the added subquery to see if any of them reference views. (But it
+ won't expand old or new — otherwise we'd have infinite recursion!)
+ In this example, there are no rewrite rules for shoelace_data or unit,
+ so rewriting is complete and the above is the final result given to
+ the planner.
+
+ Now we want to write a query that finds out for which shoes currently in the store
+ we have the matching shoelaces (color and length) and where the
+ total number of exactly matching pairs is greater than or equal to two.
+
+
+SELECT * FROM shoe_ready WHERE total_avail >= 2;
+
+ shoename | sh_avail | sl_name | sl_avail | total_avail
+----------+----------+---------+----------+-------------
+ sh1 | 2 | sl1 | 5 | 2
+ sh3 | 4 | sl7 | 7 | 4
+(2 rows)
+
+
+ The output of the parser this time is the query tree:
+
+
+SELECT shoe_ready.shoename, shoe_ready.sh_avail,
+ shoe_ready.sl_name, shoe_ready.sl_avail,
+ shoe_ready.total_avail
+ FROM shoe_ready shoe_ready
+ WHERE shoe_ready.total_avail >= 2;
+
+
+ The first rule applied will be the one for the
+ shoe_ready view and it results in the
+ query tree:
+
+
+SELECT shoe_ready.shoename, shoe_ready.sh_avail,
+ shoe_ready.sl_name, shoe_ready.sl_avail,
+ shoe_ready.total_avail
+ FROM (SELECT rsh.shoename,
+ rsh.sh_avail,
+ rsl.sl_name,
+ rsl.sl_avail,
+ least(rsh.sh_avail, rsl.sl_avail) AS total_avail
+ FROM shoe rsh, shoelace rsl
+ WHERE rsl.sl_color = rsh.slcolor
+ AND rsl.sl_len_cm >= rsh.slminlen_cm
+ AND rsl.sl_len_cm <= rsh.slmaxlen_cm) shoe_ready
+ WHERE shoe_ready.total_avail >= 2;
+
+
+ Similarly, the rules for shoe and
+ shoelace are substituted into the range table of
+ the subquery, leading to a three-level final query tree:
+
+
+SELECT shoe_ready.shoename, shoe_ready.sh_avail,
+ shoe_ready.sl_name, shoe_ready.sl_avail,
+ shoe_ready.total_avail
+ FROM (SELECT rsh.shoename,
+ rsh.sh_avail,
+ rsl.sl_name,
+ rsl.sl_avail,
+ least(rsh.sh_avail, rsl.sl_avail) AS total_avail
+ FROM (SELECT sh.shoename,
+ sh.sh_avail,
+ sh.slcolor,
+ sh.slminlen,
+ sh.slminlen * un.un_fact AS slminlen_cm,
+ sh.slmaxlen,
+ sh.slmaxlen * un.un_fact AS slmaxlen_cm,
+ sh.slunit
+ FROM shoe_data sh, unit un
+ WHERE sh.slunit = un.un_name) rsh,
+ (SELECT s.sl_name,
+ s.sl_avail,
+ s.sl_color,
+ s.sl_len,
+ s.sl_unit,
+ s.sl_len * u.un_fact AS sl_len_cm
+ FROM shoelace_data s, unit u
+ WHERE s.sl_unit = u.un_name) rsl
+ WHERE rsl.sl_color = rsh.slcolor
+ AND rsl.sl_len_cm >= rsh.slminlen_cm
+ AND rsl.sl_len_cm <= rsh.slmaxlen_cm) shoe_ready
+ WHERE shoe_ready.total_avail > 2;
+
+
+ This might look inefficient, but the planner will collapse this into a
+ single-level query tree by “pulling up” the subqueries,
+ and then it will plan the joins just as if we'd written them out
+ manually. So collapsing the query tree is an optimization that the
+ rewrite system doesn't have to concern itself with.
+
41.2.2. View Rules in Non-SELECT Statements #
+ Two details of the query tree aren't touched in the description of
+ view rules above. These are the command type and the result relation.
+ In fact, the command type is not needed by view rules, but the result
+ relation may affect the way in which the query rewriter works, because
+ special care needs to be taken if the result relation is a view.
+
+ There are only a few differences between a query tree for a
+ SELECT and one for any other
+ command. Obviously, they have a different command type and for a
+ command other than a SELECT, the result
+ relation points to the range-table entry where the result should
+ go. Everything else is absolutely the same. So having two tables
+ t1 and t2 with columns a and
+ b, the query trees for the two statements:
+
+
+SELECT t2.b FROM t1, t2 WHERE t1.a = t2.a;
+
+UPDATE t1 SET b = t2.b FROM t2 WHERE t1.a = t2.a;
+
+
+ are nearly identical. In particular:
+
+
+ The range tables contain entries for the tables t1 and t2.
+
+ The target lists contain one variable that points to column
+ b of the range table entry for table t2.
+
+ The qualification expressions compare the columns a of both
+ range-table entries for equality.
+
+ The join trees show a simple join between t1 and t2.
+
+
+ The consequence is, that both query trees result in similar
+ execution plans: They are both joins over the two tables. For the
+ UPDATE the missing columns from t1 are added to
+ the target list by the planner and the final query tree will read
+ as:
+
+
+UPDATE t1 SET a = t1.a, b = t2.b FROM t2 WHERE t1.a = t2.a;
+
+
+ and thus the executor run over the join will produce exactly the
+ same result set as:
+
+
+SELECT t1.a, t2.b FROM t1, t2 WHERE t1.a = t2.a;
+
+
+ But there is a little problem in
+ UPDATE: the part of the executor plan that does
+ the join does not care what the results from the join are
+ meant for. It just produces a result set of rows. The fact that
+ one is a SELECT command and the other is an
+ UPDATE is handled higher up in the executor, where
+ it knows that this is an UPDATE, and it knows that
+ this result should go into table t1. But which of the rows
+ that are there has to be replaced by the new row?
+
+ To resolve this problem, another entry is added to the target list
+ in UPDATE (and also in
+ DELETE) statements: the current tuple ID
+ (CTID).
+ This is a system column containing the
+ file block number and position in the block for the row. Knowing
+ the table, the CTID can be used to retrieve the
+ original row of t1 to be updated. After adding the
+ CTID to the target list, the query actually looks like:
+
+
+SELECT t1.a, t2.b, t1.ctid FROM t1, t2 WHERE t1.a = t2.a;
+
+
+ Now another detail of PostgreSQL enters
+ the stage. Old table rows aren't overwritten, and this
+ is why ROLLBACK is fast. In an UPDATE,
+ the new result row is inserted into the table (after stripping the
+ CTID) and in the row header of the old row, which the
+ CTID pointed to, the cmax and
+ xmax entries are set to the current command counter
+ and current transaction ID. Thus the old row is hidden, and after
+ the transaction commits the vacuum cleaner can eventually remove
+ the dead row.
+
+ Knowing all that, we can simply apply view rules in absolutely
+ the same way to any command. There is no difference.
+
41.2.3. The Power of Views in PostgreSQL #
+ The above demonstrates how the rule system incorporates view
+ definitions into the original query tree. In the second example, a
+ simple SELECT from one view created a final
+ query tree that is a join of 4 tables (unit was used twice with
+ different names).
+
+ The benefit of implementing views with the rule system is
+ that the planner has all
+ the information about which tables have to be scanned plus the
+ relationships between these tables plus the restrictive
+ qualifications from the views plus the qualifications from
+ the original query
+ in one single query tree. And this is still the situation
+ when the original query is already a join over views.
+ The planner has to decide which is
+ the best path to execute the query, and the more information
+ the planner has, the better this decision can be. And
+ the rule system as implemented in PostgreSQL
+ ensures that this is all information available about the query
+ up to that point.
+
41.2.4. Updating a View #
+ What happens if a view is named as the target relation for an
+ INSERT, UPDATE, or
+ DELETE? Doing the substitutions
+ described above would give a query tree in which the result
+ relation points at a subquery range-table entry, which will not
+ work. There are several ways in which PostgreSQL
+ can support the appearance of updating a view, however.
+ In order of user-experienced complexity those are: automatically substitute
+ in the underlying table for the view, execute a user-defined trigger,
+ or rewrite the query per a user-defined rule.
+ These options are discussed below.
+
+ If the subquery selects from a single base relation and is simple
+ enough, the rewriter can automatically replace the subquery with the
+ underlying base relation so that the INSERT,
+ UPDATE, or DELETE is applied to
+ the base relation in the appropriate way. Views that are
+ “simple enough” for this are called automatically
+ updatable. For detailed information on the kinds of view that can
+ be automatically updated, see CREATE VIEW.
+
+ Alternatively, the operation may be handled by a user-provided
+ INSTEAD OF trigger on the view
+ (see CREATE TRIGGER).
+ Rewriting works slightly differently
+ in this case. For INSERT, the rewriter does
+ nothing at all with the view, leaving it as the result relation
+ for the query. For UPDATE and
+ DELETE, it's still necessary to expand the
+ view query to produce the “old” rows that the command will
+ attempt to update or delete. So the view is expanded as normal,
+ but another unexpanded range-table entry is added to the query
+ to represent the view in its capacity as the result relation.
+
+ The problem that now arises is how to identify the rows to be
+ updated in the view. Recall that when the result relation
+ is a table, a special CTID entry is added to the target
+ list to identify the physical locations of the rows to be updated.
+ This does not work if the result relation is a view, because a view
+ does not have any CTID, since its rows do not have
+ actual physical locations. Instead, for an UPDATE
+ or DELETE operation, a special wholerow
+ entry is added to the target list, which expands to include all
+ columns from the view. The executor uses this value to supply the
+ “old” row to the INSTEAD OF trigger. It is
+ up to the trigger to work out what to update based on the old and
+ new row values.
+
+ Another possibility is for the user to define INSTEAD
+ rules that specify substitute actions for INSERT,
+ UPDATE, and DELETE commands on
+ a view. These rules will rewrite the command, typically into a command
+ that updates one or more tables, rather than views. That is the topic
+ of Section 41.4.
+
+ Note that rules are evaluated first, rewriting the original query
+ before it is planned and executed. Therefore, if a view has
+ INSTEAD OF triggers as well as rules on INSERT,
+ UPDATE, or DELETE, then the rules will be
+ evaluated first, and depending on the result, the triggers may not be
+ used at all.
+
+ Automatic rewriting of an INSERT,
+ UPDATE, or DELETE query on a
+ simple view is always tried last. Therefore, if a view has rules or
+ triggers, they will override the default behavior of automatically
+ updatable views.
+
+ If there are no INSTEAD rules or INSTEAD OF
+ triggers for the view, and the rewriter cannot automatically rewrite
+ the query as an update on the underlying base relation, an error will
+ be thrown because the executor cannot update a view as such.
+
Chapter 41. The Rule System
+ This chapter discusses the rule system in
+ PostgreSQL. Production rule systems
+ are conceptually simple, but there are many subtle points
+ involved in actually using them.
+
+ Some other database systems define active database rules, which
+ are usually stored procedures and triggers. In
+ PostgreSQL, these can be implemented
+ using functions and triggers as well.
+
+ The rule system (more precisely speaking, the query rewrite rule
+ system) is totally different from stored procedures and triggers.
+ It modifies queries to take rules into consideration, and then
+ passes the modified query to the query planner for planning and
+ execution. It is very powerful, and can be used for many things
+ such as query language procedures, views, and versions. The
+ theoretical foundations and the power of this rule system are
+ also discussed in [ston90b] and [ong90].
+
20.10. Automatic Vacuuming #
+ These settings control the behavior of the autovacuum
+ feature. Refer to Section 25.1.6 for more information.
+ Note that many of these settings can be overridden on a per-table
+ basis; see Storage Parameters.
+
autovacuum (boolean)
+
+ #
+ Controls whether the server should run the
+ autovacuum launcher daemon. This is on by default; however,
+ track_counts must also be enabled for
+ autovacuum to work.
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line; however, autovacuuming can be
+ disabled for individual tables by changing table storage parameters.
+
+ Note that even when this parameter is disabled, the system
+ will launch autovacuum processes if necessary to
+ prevent transaction ID wraparound. See Section 25.1.5 for more information.
+
autovacuum_max_workers (integer)
+
+ #
+ Specifies the maximum number of autovacuum processes (other than the
+ autovacuum launcher) that may be running at any one time. The default
+ is three. This parameter can only be set at server start.
+
autovacuum_naptime (integer)
+
+ #
+ Specifies the minimum delay between autovacuum runs on any given
+ database. In each round the daemon examines the
+ database and issues VACUUM and ANALYZE commands
+ as needed for tables in that database.
+ If this value is specified without units, it is taken as seconds.
+ The default is one minute (1min).
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
autovacuum_vacuum_threshold (integer)
+
+ #
+ Specifies the minimum number of updated or deleted tuples needed
+ to trigger a VACUUM in any one table.
+ The default is 50 tuples.
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line;
+ but the setting can be overridden for individual tables by
+ changing table storage parameters.
+
autovacuum_vacuum_insert_threshold (integer)
+
+ #
+ Specifies the number of inserted tuples needed to trigger a
+ VACUUM in any one table.
+ The default is 1000 tuples. If -1 is specified, autovacuum will not
+ trigger a VACUUM operation on any tables based on
+ the number of inserts.
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line;
+ but the setting can be overridden for individual tables by
+ changing table storage parameters.
+
autovacuum_analyze_threshold (integer)
+
+ #
+ Specifies the minimum number of inserted, updated or deleted tuples
+ needed to trigger an ANALYZE in any one table.
+ The default is 50 tuples.
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line;
+ but the setting can be overridden for individual tables by
+ changing table storage parameters.
+
autovacuum_vacuum_scale_factor (floating point)
+
+ #
+ Specifies a fraction of the table size to add to
+ autovacuum_vacuum_threshold
+ when deciding whether to trigger a VACUUM.
+ The default is 0.2 (20% of table size).
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line;
+ but the setting can be overridden for individual tables by
+ changing table storage parameters.
+
autovacuum_vacuum_insert_scale_factor (floating point)
+
+ #
+ Specifies a fraction of the table size to add to
+ autovacuum_vacuum_insert_threshold
+ when deciding whether to trigger a VACUUM.
+ The default is 0.2 (20% of table size).
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line;
+ but the setting can be overridden for individual tables by
+ changing table storage parameters.
+
autovacuum_analyze_scale_factor (floating point)
+
+ #
+ Specifies a fraction of the table size to add to
+ autovacuum_analyze_threshold
+ when deciding whether to trigger an ANALYZE.
+ The default is 0.1 (10% of table size).
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line;
+ but the setting can be overridden for individual tables by
+ changing table storage parameters.
+
autovacuum_freeze_max_age (integer)
+
+ #
+ Specifies the maximum age (in transactions) that a table's
+ pg_class.relfrozenxid field can
+ attain before a VACUUM operation is forced
+ to prevent transaction ID wraparound within the table.
+ Note that the system will launch autovacuum processes to
+ prevent wraparound even when autovacuum is otherwise disabled.
+
+ Vacuum also allows removal of old files from the
+ pg_xact subdirectory, which is why the default
+ is a relatively low 200 million transactions.
+ This parameter can only be set at server start, but the setting
+ can be reduced for individual tables by
+ changing table storage parameters.
+ For more information see Section 25.1.5.
+
autovacuum_multixact_freeze_max_age (integer)
+
+ #
+ Specifies the maximum age (in multixacts) that a table's
+ pg_class.relminmxid field can
+ attain before a VACUUM operation is forced to
+ prevent multixact ID wraparound within the table.
+ Note that the system will launch autovacuum processes to
+ prevent wraparound even when autovacuum is otherwise disabled.
+
+ Vacuuming multixacts also allows removal of old files from the
+ pg_multixact/members and pg_multixact/offsets
+ subdirectories, which is why the default is a relatively low
+ 400 million multixacts.
+ This parameter can only be set at server start, but the setting can
+ be reduced for individual tables by changing table storage parameters.
+ For more information see Section 25.1.5.1.
+
autovacuum_vacuum_cost_delay (floating point)
+
+ #
+ Specifies the cost delay value that will be used in automatic
+ VACUUM operations. If -1 is specified, the regular
+ vacuum_cost_delay value will be used.
+ If this value is specified without units, it is taken as milliseconds.
+ The default value is 2 milliseconds.
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line;
+ but the setting can be overridden for individual tables by
+ changing table storage parameters.
+
autovacuum_vacuum_cost_limit (integer)
+
+ #
+ Specifies the cost limit value that will be used in automatic
+ VACUUM operations. If -1 is specified (which is the
+ default), the regular
+ vacuum_cost_limit value will be used. Note that
+ the value is distributed proportionally among the running autovacuum
+ workers, if there is more than one, so that the sum of the limits for
+ each worker does not exceed the value of this variable.
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line;
+ but the setting can be overridden for individual tables by
+ changing table storage parameters.
+
20.11. Client Connection Defaults #
20.11.1. Statement Behavior #
client_min_messages (enum)
+
+ #
+ Controls which
+ message levels
+ are sent to the client.
+ Valid values are DEBUG5,
+ DEBUG4, DEBUG3, DEBUG2,
+ DEBUG1, LOG, NOTICE,
+ WARNING, and ERROR.
+ Each level includes all the levels that follow it. The later the level,
+ the fewer messages are sent. The default is
+ NOTICE. Note that LOG has a different
+ rank here than in log_min_messages.
+
+ INFO level messages are always sent to the client.
+
search_path (string)
+
+
+ #
+ This variable specifies the order in which schemas are searched
+ when an object (table, data type, function, etc.) is referenced by a
+ simple name with no schema specified. When there are objects of
+ identical names in different schemas, the one found first
+ in the search path is used. An object that is not in any of the
+ schemas in the search path can only be referenced by specifying
+ its containing schema with a qualified (dotted) name.
+
+ The value for search_path must be a comma-separated
+ list of schema names. Any name that is not an existing schema, or is
+ a schema for which the user does not have USAGE
+ permission, is silently ignored.
+
+ If one of the list items is the special name
+ $user, then the schema having the name returned by
+ CURRENT_USER is substituted, if there is such a schema
+ and the user has USAGE permission for it.
+ (If not, $user is ignored.)
+
+ The system catalog schema, pg_catalog, is always
+ searched, whether it is mentioned in the path or not. If it is
+ mentioned in the path then it will be searched in the specified
+ order. If pg_catalog is not in the path then it will
+ be searched before searching any of the path items.
+
+ Likewise, the current session's temporary-table schema,
+ pg_temp_nnn, is always searched if it
+ exists. It can be explicitly listed in the path by using the
+ alias pg_temp. If it is not listed in the path then
+ it is searched first (even before pg_catalog). However,
+ the temporary schema is only searched for relation (table, view,
+ sequence, etc.) and data type names. It is never searched for
+ function or operator names.
+
+ When objects are created without specifying a particular target
+ schema, they will be placed in the first valid schema named in
+ search_path. An error is reported if the search
+ path is empty.
+
+ The default value for this parameter is
+ "$user", public.
+ This setting supports shared use of a database (where no users
+ have private schemas, and all share use of public),
+ private per-user schemas, and combinations of these. Other
+ effects can be obtained by altering the default search path
+ setting, either globally or per-user.
+
+ For more information on schema handling, see
+ Section 5.9. In particular, the default
+ configuration is suitable only when the database has a single user or
+ a few mutually-trusting users.
+
+ The current effective value of the search path can be examined
+ via the SQL function
+ current_schemas
+ (see Section 9.26).
+ This is not quite the same as
+ examining the value of search_path, since
+ current_schemas shows how the items
+ appearing in search_path were resolved.
+
row_security (boolean)
+
+ #
+ This variable controls whether to raise an error in lieu of applying a
+ row security policy. When set to on, policies apply
+ normally. When set to off, queries fail which would
+ otherwise apply at least one policy. The default is on.
+ Change to off where limited row visibility could cause
+ incorrect results; for example, pg_dump makes that
+ change by default. This variable has no effect on roles which bypass
+ every row security policy, to wit, superusers and roles with
+ the BYPASSRLS attribute.
+
+ For more information on row security policies,
+ see CREATE POLICY.
+
default_table_access_method (string)
+
+ #
+ This parameter specifies the default table access method to use when
+ creating tables or materialized views if the CREATE
+ command does not explicitly specify an access method, or when
+ SELECT ... INTO is used, which does not allow
+ specifying a table access method. The default is heap.
+
default_tablespace (string)
+
+
+ #
+ This variable specifies the default tablespace in which to create
+ objects (tables and indexes) when a CREATE command does
+ not explicitly specify a tablespace.
+
+ The value is either the name of a tablespace, or an empty string
+ to specify using the default tablespace of the current database.
+ If the value does not match the name of any existing tablespace,
+ PostgreSQL will automatically use the default
+ tablespace of the current database. If a nondefault tablespace
+ is specified, the user must have CREATE privilege
+ for it, or creation attempts will fail.
+
+ This variable is not used for temporary tables; for them,
+ temp_tablespaces is consulted instead.
+
+ This variable is also not used when creating databases.
+ By default, a new database inherits its tablespace setting from
+ the template database it is copied from.
+
+ If this parameter is set to a value other than the empty string
+ when a partitioned table is created, the partitioned table's
+ tablespace will be set to that value, which will be used as
+ the default tablespace for partitions created in the future,
+ even if default_tablespace has changed since then.
+
+ For more information on tablespaces,
+ see Section 23.6.
+
default_toast_compression (enum)
+
+ #
+ This variable sets the default
+ TOAST
+ compression method for values of compressible columns.
+ (This can be overridden for individual columns by setting
+ the COMPRESSION column option in
+ CREATE TABLE or
+ ALTER TABLE.)
+ The supported compression methods are pglz and
+ (if PostgreSQL was compiled with
+ --with-lz4) lz4.
+ The default is pglz.
+
temp_tablespaces (string)
+
+
+ #
+ This variable specifies tablespaces in which to create temporary
+ objects (temp tables and indexes on temp tables) when a
+ CREATE command does not explicitly specify a tablespace.
+ Temporary files for purposes such as sorting large data sets
+ are also created in these tablespaces.
+
+ The value is a list of names of tablespaces. When there is more than
+ one name in the list, PostgreSQL chooses a random
+ member of the list each time a temporary object is to be created;
+ except that within a transaction, successively created temporary
+ objects are placed in successive tablespaces from the list.
+ If the selected element of the list is an empty string,
+ PostgreSQL will automatically use the default
+ tablespace of the current database instead.
+
+ When temp_tablespaces is set interactively, specifying a
+ nonexistent tablespace is an error, as is specifying a tablespace for
+ which the user does not have CREATE privilege. However,
+ when using a previously set value, nonexistent tablespaces are
+ ignored, as are tablespaces for which the user lacks
+ CREATE privilege. In particular, this rule applies when
+ using a value set in postgresql.conf.
+
+ The default value is an empty string, which results in all temporary
+ objects being created in the default tablespace of the current
+ database.
+
+ See also default_tablespace.
+
check_function_bodies (boolean)
+
+ #
+ This parameter is normally on. When set to off, it
+ disables validation of the routine body string during CREATE FUNCTION and CREATE PROCEDURE. Disabling validation avoids side
+ effects of the validation process, in particular preventing false
+ positives due to problems such as forward references.
+ Set this parameter
+ to off before loading functions on behalf of other
+ users; pg_dump does so automatically.
+
default_transaction_isolation (enum)
+
+
+ #
+ Each SQL transaction has an isolation level, which can be
+ either “read uncommitted”, “read
+ committed”, “repeatable read”, or
+ “serializable”. This parameter controls the
+ default isolation level of each new transaction. The default
+ is “read committed”.
+
+ Consult Chapter 13 and SET TRANSACTION for more information.
+
default_transaction_read_only (boolean)
+
+
+ #
+ A read-only SQL transaction cannot alter non-temporary tables.
+ This parameter controls the default read-only status of each new
+ transaction. The default is off (read/write).
+
+ Consult SET TRANSACTION for more information.
+
default_transaction_deferrable (boolean)
+
+
+ #
+ When running at the serializable isolation level,
+ a deferrable read-only SQL transaction may be delayed before
+ it is allowed to proceed. However, once it begins executing
+ it does not incur any of the overhead required to ensure
+ serializability; so serialization code will have no reason to
+ force it to abort because of concurrent updates, making this
+ option suitable for long-running read-only transactions.
+
+ This parameter controls the default deferrable status of each
+ new transaction. It currently has no effect on read-write
+ transactions or those operating at isolation levels lower
+ than serializable. The default is off.
+
+ Consult SET TRANSACTION for more information.
+
transaction_isolation (enum)
+
+
+ #
+ This parameter reflects the current transaction's isolation level.
+ At the beginning of each transaction, it is set to the current value
+ of default_transaction_isolation.
+ Any subsequent attempt to change it is equivalent to a SET TRANSACTION command.
+
transaction_read_only (boolean)
+
+
+ #
+ This parameter reflects the current transaction's read-only status.
+ At the beginning of each transaction, it is set to the current value
+ of default_transaction_read_only.
+ Any subsequent attempt to change it is equivalent to a SET TRANSACTION command.
+
transaction_deferrable (boolean)
+
+
+ #
+ This parameter reflects the current transaction's deferrability status.
+ At the beginning of each transaction, it is set to the current value
+ of default_transaction_deferrable.
+ Any subsequent attempt to change it is equivalent to a SET TRANSACTION command.
+
session_replication_role (enum)
+
+ #
+ Controls firing of replication-related triggers and rules for the
+ current session.
+ Possible values are origin (the default),
+ replica and local.
+ Setting this parameter results in discarding any previously cached
+ query plans.
+ Only superusers and users with the appropriate SET
+ privilege can change this setting.
+
+ The intended use of this setting is that logical replication systems
+ set it to replica when they are applying replicated
+ changes. The effect of that will be that triggers and rules (that
+ have not been altered from their default configuration) will not fire
+ on the replica. See the ALTER TABLE clauses
+ ENABLE TRIGGER and ENABLE RULE
+ for more information.
+
+ PostgreSQL treats the settings origin and
+ local the same internally. Third-party replication
+ systems may use these two values for their internal purposes, for
+ example using local to designate a session whose
+ changes should not be replicated.
+
+ Since foreign keys are implemented as triggers, setting this parameter
+ to replica also disables all foreign key checks,
+ which can leave data in an inconsistent state if improperly used.
+
statement_timeout (integer)
+
+ #
+ Abort any statement that takes more than the specified amount of time.
+ If log_min_error_statement is set
+ to ERROR or lower, the statement that timed out
+ will also be logged.
+ If this value is specified without units, it is taken as milliseconds.
+ A value of zero (the default) disables the timeout.
+
+ The timeout is measured from the time a command arrives at the
+ server until it is completed by the server. If multiple SQL
+ statements appear in a single simple-Query message, the timeout
+ is applied to each statement separately.
+ (PostgreSQL versions before 13 usually
+ treated the timeout as applying to the whole query string.)
+ In extended query protocol, the timeout starts running when any
+ query-related message (Parse, Bind, Execute, Describe) arrives, and
+ it is canceled by completion of an Execute or Sync message.
+
+ Setting statement_timeout in
+ postgresql.conf is not recommended because it would
+ affect all sessions.
+
lock_timeout (integer)
+
+ #
+ Abort any statement that waits longer than the specified amount of
+ time while attempting to acquire a lock on a table, index,
+ row, or other database object. The time limit applies separately to
+ each lock acquisition attempt. The limit applies both to explicit
+ locking requests (such as LOCK TABLE, or SELECT
+ FOR UPDATE without NOWAIT) and to implicitly-acquired
+ locks.
+ If this value is specified without units, it is taken as milliseconds.
+ A value of zero (the default) disables the timeout.
+
+ Unlike statement_timeout, this timeout can only occur
+ while waiting for locks. Note that if statement_timeout
+ is nonzero, it is rather pointless to set lock_timeout to
+ the same or larger value, since the statement timeout would always
+ trigger first. If log_min_error_statement is set to
+ ERROR or lower, the statement that timed out will be
+ logged.
+
+ Setting lock_timeout in
+ postgresql.conf is not recommended because it would
+ affect all sessions.
+
idle_in_transaction_session_timeout (integer)
+
+ #
+ Terminate any session that has been idle (that is, waiting for a
+ client query) within an open transaction for longer than the
+ specified amount of time.
+ If this value is specified without units, it is taken as milliseconds.
+ A value of zero (the default) disables the timeout.
+
+ This option can be used to ensure that idle sessions do not hold
+ locks for an unreasonable amount of time. Even when no significant
+ locks are held, an open transaction prevents vacuuming away
+ recently-dead tuples that may be visible only to this transaction;
+ so remaining idle for a long time can contribute to table bloat.
+ See Section 25.1 for more details.
+
idle_session_timeout (integer)
+
+ #
+ Terminate any session that has been idle (that is, waiting for a
+ client query), but not within an open transaction, for longer than
+ the specified amount of time.
+ If this value is specified without units, it is taken as milliseconds.
+ A value of zero (the default) disables the timeout.
+
+ Unlike the case with an open transaction, an idle session without a
+ transaction imposes no large costs on the server, so there is less
+ need to enable this timeout
+ than idle_in_transaction_session_timeout.
+
+ Be wary of enforcing this timeout on connections made through
+ connection-pooling software or other middleware, as such a layer
+ may not react well to unexpected connection closure. It may be
+ helpful to enable this timeout only for interactive sessions,
+ perhaps by applying it only to particular users.
+
vacuum_freeze_table_age (integer)
+
+ #
+ VACUUM performs an aggressive scan if the table's
+ pg_class.relfrozenxid field has reached
+ the age specified by this setting. An aggressive scan differs from
+ a regular VACUUM in that it visits every page that might
+ contain unfrozen XIDs or MXIDs, not just those that might contain dead
+ tuples. The default is 150 million transactions. Although users can
+ set this value anywhere from zero to two billion, VACUUM
+ will silently limit the effective value to 95% of
+ autovacuum_freeze_max_age, so that a
+ periodic manual VACUUM has a chance to run before an
+ anti-wraparound autovacuum is launched for the table. For more
+ information see
+ Section 25.1.5.
+
vacuum_freeze_min_age (integer)
+
+ #
+ Specifies the cutoff age (in transactions) that
+ VACUUM should use to decide whether to
+ trigger freezing of pages that have an older XID.
+ The default is 50 million transactions. Although
+ users can set this value anywhere from zero to one billion,
+ VACUUM will silently limit the effective value to half
+ the value of autovacuum_freeze_max_age, so
+ that there is not an unreasonably short time between forced
+ autovacuums. For more information see Section 25.1.5.
+
vacuum_failsafe_age (integer)
+
+ #
+ Specifies the maximum age (in transactions) that a table's
+ pg_class.relfrozenxid
+ field can attain before VACUUM takes
+ extraordinary measures to avoid system-wide transaction ID
+ wraparound failure. This is VACUUM's
+ strategy of last resort. The failsafe typically triggers
+ when an autovacuum to prevent transaction ID wraparound has
+ already been running for some time, though it's possible for
+ the failsafe to trigger during any VACUUM.
+
+ When the failsafe is triggered, any cost-based delay that is
+ in effect will no longer be applied, further non-essential
+ maintenance tasks (such as index vacuuming) are bypassed, and any
+ Buffer Access Strategy
+ in use will be disabled resulting in VACUUM being
+ free to make use of all of
+ shared buffers.
+
+ The default is 1.6 billion transactions. Although users can
+ set this value anywhere from zero to 2.1 billion,
+ VACUUM will silently adjust the effective
+ value to no less than 105% of autovacuum_freeze_max_age.
+
vacuum_multixact_freeze_table_age (integer)
+
+ #
+ VACUUM performs an aggressive scan if the table's
+ pg_class.relminmxid field has reached
+ the age specified by this setting. An aggressive scan differs from
+ a regular VACUUM in that it visits every page that might
+ contain unfrozen XIDs or MXIDs, not just those that might contain dead
+ tuples. The default is 150 million multixacts.
+ Although users can set this value anywhere from zero to two billion,
+ VACUUM will silently limit the effective value to 95% of
+ autovacuum_multixact_freeze_max_age, so that a
+ periodic manual VACUUM has a chance to run before an
+ anti-wraparound is launched for the table.
+ For more information see Section 25.1.5.1.
+
vacuum_multixact_freeze_min_age (integer)
+
+ #
+ Specifies the cutoff age (in multixacts) that VACUUM
+ should use to decide whether to trigger freezing of pages with
+ an older multixact ID. The default is 5 million multixacts.
+ Although users can set this value anywhere from zero to one billion,
+ VACUUM will silently limit the effective value to half
+ the value of autovacuum_multixact_freeze_max_age,
+ so that there is not an unreasonably short time between forced
+ autovacuums.
+ For more information see Section 25.1.5.1.
+
vacuum_multixact_failsafe_age (integer)
+
+ #
+ Specifies the maximum age (in multixacts) that a table's
+ pg_class.relminmxid
+ field can attain before VACUUM takes
+ extraordinary measures to avoid system-wide multixact ID
+ wraparound failure. This is VACUUM's
+ strategy of last resort. The failsafe typically triggers when
+ an autovacuum to prevent transaction ID wraparound has already
+ been running for some time, though it's possible for the
+ failsafe to trigger during any VACUUM.
+
+ When the failsafe is triggered, any cost-based delay that is
+ in effect will no longer be applied, and further non-essential
+ maintenance tasks (such as index vacuuming) are bypassed.
+
+ The default is 1.6 billion multixacts. Although users can set
+ this value anywhere from zero to 2.1 billion,
+ VACUUM will silently adjust the effective
+ value to no less than 105% of autovacuum_multixact_freeze_max_age.
+
bytea_output (enum)
+
+ #
+ Sets the output format for values of type bytea.
+ Valid values are hex (the default)
+ and escape (the traditional PostgreSQL
+ format). See Section 8.4 for more
+ information. The bytea type always
+ accepts both formats on input, regardless of this setting.
+
xmlbinary (enum)
+
+ #
+ Sets how binary values are to be encoded in XML. This applies
+ for example when bytea values are converted to
+ XML by the functions xmlelement or
+ xmlforest. Possible values are
+ base64 and hex, which
+ are both defined in the XML Schema standard. The default is
+ base64. For further information about
+ XML-related functions, see Section 9.15.
+
+ The actual choice here is mostly a matter of taste,
+ constrained only by possible restrictions in client
+ applications. Both methods support all possible values,
+ although the hex encoding will be somewhat larger than the
+ base64 encoding.
+
xmloption (enum)
+
+
+
+ #
+ Sets whether DOCUMENT or
+ CONTENT is implicit when converting between
+ XML and character string values. See Section 8.13 for a description of this. Valid
+ values are DOCUMENT and
+ CONTENT. The default is
+ CONTENT.
+
+ According to the SQL standard, the command to set this option is
+
+SET XML OPTION { DOCUMENT | CONTENT };
+
+ This syntax is also available in PostgreSQL.
+
gin_pending_list_limit (integer)
+
+ #
+ Sets the maximum size of a GIN index's pending list, which is used
+ when fastupdate is enabled. If the list grows
+ larger than this maximum size, it is cleaned up by moving
+ the entries in it to the index's main GIN data structure in bulk.
+ If this value is specified without units, it is taken as kilobytes.
+ The default is four megabytes (4MB). This setting
+ can be overridden for individual GIN indexes by changing
+ index storage parameters.
+ See Section 70.4.1 and Section 70.5
+ for more information.
+
createrole_self_grant (string)
+
+ #
+ If a user who has CREATEROLE but not
+ SUPERUSER creates a role, and if this
+ is set to a non-empty value, the newly-created role will be granted
+ to the creating user with the options specified. The value must be
+ set, inherit, or a
+ comma-separated list of these. The default value is an empty string,
+ which disables the feature.
+
+ The purpose of this option is to allow a CREATEROLE
+ user who is not a superuser to automatically inherit, or automatically
+ gain the ability to SET ROLE to, any created users.
+ Since a CREATEROLE user is always implicitly granted
+ ADMIN OPTION on created roles, that user could
+ always execute a GRANT statement that would achieve
+ the same effect as this setting. However, it can be convenient for
+ usability reasons if the grant happens automatically. A superuser
+ automatically inherits the privileges of every role and can always
+ SET ROLE to any role, and this setting can be used
+ to produce a similar behavior for CREATEROLE users
+ for users which they create.
+
20.11.3. Shared Library Preloading #
+ Several settings are available for preloading shared libraries into the
+ server, in order to load additional functionality or achieve performance
+ benefits. For example, a setting of
+ '$libdir/mylib' would cause
+ mylib.so (or on some platforms,
+ mylib.sl) to be preloaded from the installation's standard
+ library directory. The differences between the settings are when they
+ take effect and what privileges are required to change them.
+
+ PostgreSQL procedural language libraries can
+ be preloaded in this way, typically by using the
+ syntax '$libdir/plXXX' where
+ XXX is pgsql, perl,
+ tcl, or python.
+
+ Only shared libraries specifically intended to be used with PostgreSQL
+ can be loaded this way. Every PostgreSQL-supported library has
+ a “magic block” that is checked to guarantee compatibility. For
+ this reason, non-PostgreSQL libraries cannot be loaded in this way. You
+ might be able to use operating-system facilities such
+ as LD_PRELOAD for that.
+
+ In general, refer to the documentation of a specific module for the
+ recommended way to load that module.
+
local_preload_libraries (string)
+
+
+ #
+ This variable specifies one or more shared libraries that are to be
+ preloaded at connection start.
+ It contains a comma-separated list of library names, where each name
+ is interpreted as for the LOAD command.
+ Whitespace between entries is ignored; surround a library name with
+ double quotes if you need to include whitespace or commas in the name.
+ The parameter value only takes effect at the start of the connection.
+ Subsequent changes have no effect. If a specified library is not
+ found, the connection attempt will fail.
+
+ This option can be set by any user. Because of that, the libraries
+ that can be loaded are restricted to those appearing in the
+ plugins subdirectory of the installation's
+ standard library directory. (It is the database administrator's
+ responsibility to ensure that only “safe” libraries
+ are installed there.) Entries in local_preload_libraries
+ can specify this directory explicitly, for example
+ $libdir/plugins/mylib, or just specify
+ the library name — mylib would have
+ the same effect as $libdir/plugins/mylib.
+
+ The intent of this feature is to allow unprivileged users to load
+ debugging or performance-measurement libraries into specific sessions
+ without requiring an explicit LOAD command. To that end,
+ it would be typical to set this parameter using
+ the PGOPTIONS environment variable on the client or by
+ using
+ ALTER ROLE SET.
+
+ However, unless a module is specifically designed to be used in this way by
+ non-superusers, this is usually not the right setting to use. Look
+ at session_preload_libraries instead.
+
session_preload_libraries (string)
+
+ #
+ This variable specifies one or more shared libraries that are to be
+ preloaded at connection start.
+ It contains a comma-separated list of library names, where each name
+ is interpreted as for the LOAD command.
+ Whitespace between entries is ignored; surround a library name with
+ double quotes if you need to include whitespace or commas in the name.
+ The parameter value only takes effect at the start of the connection.
+ Subsequent changes have no effect. If a specified library is not
+ found, the connection attempt will fail.
+ Only superusers and users with the appropriate SET
+ privilege can change this setting.
+
+ The intent of this feature is to allow debugging or
+ performance-measurement libraries to be loaded into specific sessions
+ without an explicit
+ LOAD command being given. For
+ example, auto_explain could be enabled for all
+ sessions under a given user name by setting this parameter
+ with ALTER ROLE SET. Also, this parameter can be changed
+ without restarting the server (but changes only take effect when a new
+ session is started), so it is easier to add new modules this way, even
+ if they should apply to all sessions.
+
+ Unlike shared_preload_libraries, there is no large
+ performance advantage to loading a library at session start rather than
+ when it is first used. There is some advantage, however, when
+ connection pooling is used.
+
shared_preload_libraries (string)
+
+ #
+ This variable specifies one or more shared libraries to be preloaded at
+ server start.
+ It contains a comma-separated list of library names, where each name
+ is interpreted as for the LOAD command.
+ Whitespace between entries is ignored; surround a library name with
+ double quotes if you need to include whitespace or commas in the name.
+ This parameter can only be set at server start. If a specified
+ library is not found, the server will fail to start.
+
+ Some libraries need to perform certain operations that can only take
+ place at postmaster start, such as allocating shared memory, reserving
+ light-weight locks, or starting background workers. Those libraries
+ must be loaded at server start through this parameter. See the
+ documentation of each library for details.
+
+ Other libraries can also be preloaded. By preloading a shared library,
+ the library startup time is avoided when the library is first used.
+ However, the time to start each new server process might increase
+ slightly, even if that process never uses the library. So this
+ parameter is recommended only for libraries that will be used in most
+ sessions. Also, changing this parameter requires a server restart, so
+ this is not the right setting to use for short-term debugging tasks,
+ say. Use session_preload_libraries for that
+ instead.
+
Note
+ On Windows hosts, preloading a library at server start will not reduce
+ the time required to start each new server process; each server process
+ will re-load all preload libraries. However, shared_preload_libraries
+ is still useful on Windows hosts for libraries that need to
+ perform operations at postmaster start time.
+
jit_provider (string)
+
+ #
+ This variable is the name of the JIT provider library to be used
+ (see Section 32.4.2).
+ The default is llvmjit.
+ This parameter can only be set at server start.
+
+ If set to a non-existent library, JIT will not be
+ available, but no error will be raised. This allows JIT support to be
+ installed separately from the main
+ PostgreSQL package.
+
20.11.4. Other Defaults #
dynamic_library_path (string)
+
+
+ #
+ If a dynamically loadable module needs to be opened and the
+ file name specified in the CREATE FUNCTION or
+ LOAD command
+ does not have a directory component (i.e., the
+ name does not contain a slash), the system will search this
+ path for the required file.
+
+ The value for dynamic_library_path must be a
+ list of absolute directory paths separated by colons (or semi-colons
+ on Windows). If a list element starts
+ with the special string $libdir, the
+ compiled-in PostgreSQL package
+ library directory is substituted for $libdir; this
+ is where the modules provided by the standard
+ PostgreSQL distribution are installed.
+ (Use pg_config --pkglibdir to find out the name of
+ this directory.) For example:
+
+dynamic_library_path = '/usr/local/lib/postgresql:/home/my_project/lib:$libdir'
+
+ or, in a Windows environment:
+
+dynamic_library_path = 'C:\tools\postgresql;H:\my_project\lib;$libdir'
+
+
+ The default value for this parameter is
+ '$libdir'. If the value is set to an empty
+ string, the automatic path search is turned off.
+
+ This parameter can be changed at run time by superusers and users
+ with the appropriate SET privilege, but a
+ setting done that way will only persist until the end of the
+ client connection, so this method should be reserved for
+ development purposes. The recommended way to set this parameter
+ is in the postgresql.conf configuration
+ file.
+
gin_fuzzy_search_limit (integer)
+
+ #
+ Soft upper limit of the size of the set returned by GIN index scans. For more
+ information see Section 70.5.
+
20.13. Version and Platform Compatibility #
20.13.1. Previous PostgreSQL Versions #
array_nulls (boolean)
+
+ #
+ This controls whether the array input parser recognizes
+ unquoted NULL as specifying a null array element.
+ By default, this is on, allowing array values containing
+ null values to be entered. However, PostgreSQL versions
+ before 8.2 did not support null values in arrays, and therefore would
+ treat NULL as specifying a normal array element with
+ the string value “NULL”. For backward compatibility with
+ applications that require the old behavior, this variable can be
+ turned off.
+
+ Note that it is possible to create array values containing null values
+ even when this variable is off.
+
backslash_quote (enum)
+
+
+ #
+ This controls whether a quote mark can be represented by
+ \' in a string literal. The preferred, SQL-standard way
+ to represent a quote mark is by doubling it ('') but
+ PostgreSQL has historically also accepted
+ \'. However, use of \' creates security risks
+ because in some client character set encodings, there are multibyte
+ characters in which the last byte is numerically equivalent to ASCII
+ \. If client-side code does escaping incorrectly then an
+ SQL-injection attack is possible. This risk can be prevented by
+ making the server reject queries in which a quote mark appears to be
+ escaped by a backslash.
+ The allowed values of backslash_quote are
+ on (allow \' always),
+ off (reject always), and
+ safe_encoding (allow only if client encoding does not
+ allow ASCII \ within a multibyte character).
+ safe_encoding is the default setting.
+
+ Note that in a standard-conforming string literal, \ just
+ means \ anyway. This parameter only affects the handling of
+ non-standard-conforming literals, including
+ escape string syntax (E'...').
+
escape_string_warning (boolean)
+
+
+ #
+ When on, a warning is issued if a backslash (\)
+ appears in an ordinary string literal ('...'
+ syntax) and standard_conforming_strings is off.
+ The default is on.
+
+ Applications that wish to use backslash as escape should be
+ modified to use escape string syntax (E'...'),
+ because the default behavior of ordinary strings is now to treat
+ backslash as an ordinary character, per SQL standard. This variable
+ can be enabled to help locate code that needs to be changed.
+
lo_compat_privileges (boolean)
+
+ #
+ In PostgreSQL releases prior to 9.0, large objects
+ did not have access privileges and were, therefore, always readable
+ and writable by all users. Setting this variable to on
+ disables the new privilege checks, for compatibility with prior
+ releases. The default is off.
+ Only superusers and users with the appropriate SET
+ privilege can change this setting.
+
+ Setting this variable does not disable all security checks related to
+ large objects — only those for which the default behavior has
+ changed in PostgreSQL 9.0.
+
quote_all_identifiers (boolean)
+
+ #
+ When the database generates SQL, force all identifiers to be quoted,
+ even if they are not (currently) keywords. This will affect the
+ output of EXPLAIN as well as the results of functions
+ like pg_get_viewdef. See also the
+ --quote-all-identifiers option of
+ pg_dump and pg_dumpall.
+
standard_conforming_strings (boolean)
+
+
+ #
+ This controls whether ordinary string literals
+ ('...') treat backslashes literally, as specified in
+ the SQL standard.
+ Beginning in PostgreSQL 9.1, the default is
+ on (prior releases defaulted to off).
+ Applications can check this
+ parameter to determine how string literals will be processed.
+ The presence of this parameter can also be taken as an indication
+ that the escape string syntax (E'...') is supported.
+ Escape string syntax (Section 4.1.2.2)
+ should be used if an application desires
+ backslashes to be treated as escape characters.
+
synchronize_seqscans (boolean)
+
+ #
+ This allows sequential scans of large tables to synchronize with each
+ other, so that concurrent scans read the same block at about the
+ same time and hence share the I/O workload. When this is enabled,
+ a scan might start in the middle of the table and then “wrap
+ around” the end to cover all rows, so as to synchronize with the
+ activity of scans already in progress. This can result in
+ unpredictable changes in the row ordering returned by queries that
+ have no ORDER BY clause. Setting this parameter to
+ off ensures the pre-8.3 behavior in which a sequential
+ scan always starts from the beginning of the table. The default
+ is on.
+
20.13.2. Platform and Client Compatibility #
transform_null_equals (boolean)
+
+
+ #
+ When on, expressions of the form expr =
+ NULLNULL =
+ expr) are treated as
+ expr IS NULLexpr evaluates to the null value,
+ and false otherwise. The correct SQL-spec-compliant behavior of
+ expr = NULLoff.
+
+ However, filtered forms in Microsoft
+ Access generate queries that appear to use
+ expr = NULLexpr = NULL
+ Note that this option only affects the exact form = NULL,
+ not other comparison operators or other expressions
+ that are computationally equivalent to some expression
+ involving the equals operator (such as IN).
+ Thus, this option is not a general fix for bad programming.
+
+ Refer to Section 9.2 for related information.
+
20.3. Connections and Authentication #
20.3.1. Connection Settings #
listen_addresses (string)
+
+ #
+ Specifies the TCP/IP address(es) on which the server is
+ to listen for connections from client applications.
+ The value takes the form of a comma-separated list of host names
+ and/or numeric IP addresses. The special entry *
+ corresponds to all available IP interfaces. The entry
+ 0.0.0.0 allows listening for all IPv4 addresses and
+ :: allows listening for all IPv6 addresses.
+ If the list is empty, the server does not listen on any IP interface
+ at all, in which case only Unix-domain sockets can be used to connect
+ to it. If the list is not empty, the server will start if it
+ can listen on at least one TCP/IP address. A warning will be
+ emitted for any TCP/IP address which cannot be opened.
+ The default value is localhost,
+ which allows only local TCP/IP “loopback” connections to be
+ made.
+
+ While client authentication (Chapter 21) allows fine-grained control
+ over who can access the server, listen_addresses
+ controls which interfaces accept connection attempts, which
+ can help prevent repeated malicious connection requests on
+ insecure network interfaces. This parameter can only be set
+ at server start.
+
port (integer)
+
+ #
+ The TCP port the server listens on; 5432 by default. Note that the
+ same port number is used for all IP addresses the server listens on.
+ This parameter can only be set at server start.
+
max_connections (integer)
+
+ #
+ Determines the maximum number of concurrent connections to the
+ database server. The default is typically 100 connections, but
+ might be less if your kernel settings will not support it (as
+ determined during initdb). This parameter can
+ only be set at server start.
+
+ When running a standby server, you must set this parameter to the
+ same or higher value than on the primary server. Otherwise, queries
+ will not be allowed in the standby server.
+
reserved_connections (integer)
+
+ #
+ Determines the number of connection “slots” that are
+ reserved for connections by roles with privileges of the
+ pg_use_reserved_connections
+ role. Whenever the number of free connection slots is greater than
+ superuser_reserved_connections but less than or
+ equal to the sum of superuser_reserved_connections
+ and reserved_connections, new connections will be
+ accepted only for superusers and roles with privileges of
+ pg_use_reserved_connections. If
+ superuser_reserved_connections or fewer connection
+ slots are available, new connections will be accepted only for
+ superusers.
+
+ The default value is zero connections. The value must be less than
+ max_connections minus
+ superuser_reserved_connections. This parameter can
+ only be set at server start.
+
superuser_reserved_connections
+ (integer)
+
+ #
+ Determines the number of connection “slots” that
+ are reserved for connections by PostgreSQL
+ superusers. At most max_connections
+ connections can ever be active simultaneously. Whenever the
+ number of active concurrent connections is at least
+ max_connections minus
+ superuser_reserved_connections, new
+ connections will be accepted only for superusers. The connection slots
+ reserved by this parameter are intended as final reserve for emergency
+ use after the slots reserved by
+ reserved_connections have been exhausted.
+
+ The default value is three connections. The value must be less
+ than max_connections minus
+ reserved_connections.
+ This parameter can only be set at server start.
+
unix_socket_directories (string)
+
+ #
+ Specifies the directory of the Unix-domain socket(s) on which the
+ server is to listen for connections from client applications.
+ Multiple sockets can be created by listing multiple directories
+ separated by commas. Whitespace between entries is
+ ignored; surround a directory name with double quotes if you need
+ to include whitespace or commas in the name.
+ An empty value
+ specifies not listening on any Unix-domain sockets, in which case
+ only TCP/IP sockets can be used to connect to the server.
+
+ A value that starts with @ specifies that a
+ Unix-domain socket in the abstract namespace should be created
+ (currently supported on Linux only). In that case, this value
+ does not specify a “directory” but a prefix from which
+ the actual socket name is computed in the same manner as for the
+ file-system namespace. While the abstract socket name prefix can be
+ chosen freely, since it is not a file-system location, the convention
+ is to nonetheless use file-system-like values such as
+ @/tmp.
+
+ The default value is normally
+ /tmp, but that can be changed at build time.
+ On Windows, the default is empty, which means no Unix-domain socket is
+ created by default.
+ This parameter can only be set at server start.
+
+ In addition to the socket file itself, which is named
+ .s.PGSQL.nnnn where
+ nnnn is the server's port number, an ordinary file
+ named .s.PGSQL.nnnn.lock will be
+ created in each of the unix_socket_directories directories.
+ Neither file should ever be removed manually.
+ For sockets in the abstract namespace, no lock file is created.
+
unix_socket_group (string)
+
+ #
+ Sets the owning group of the Unix-domain socket(s). (The owning
+ user of the sockets is always the user that starts the
+ server.) In combination with the parameter
+ unix_socket_permissions this can be used as
+ an additional access control mechanism for Unix-domain connections.
+ By default this is the empty string, which uses the default
+ group of the server user. This parameter can only be set at
+ server start.
+
+ This parameter is not supported on Windows. Any setting will be
+ ignored. Also, sockets in the abstract namespace have no file owner,
+ so this setting is also ignored in that case.
+
unix_socket_permissions (integer)
+
+ #
+ Sets the access permissions of the Unix-domain socket(s). Unix-domain
+ sockets use the usual Unix file system permission set.
+ The parameter value is expected to be a numeric mode
+ specified in the format accepted by the
+ chmod and umask
+ system calls. (To use the customary octal format the number
+ must start with a 0 (zero).)
+
+ The default permissions are 0777, meaning
+ anyone can connect. Reasonable alternatives are
+ 0770 (only user and group, see also
+ unix_socket_group) and 0700
+ (only user). (Note that for a Unix-domain socket, only write
+ permission matters, so there is no point in setting or revoking
+ read or execute permissions.)
+
+ This access control mechanism is independent of the one
+ described in Chapter 21.
+
+ This parameter can only be set at server start.
+
+ This parameter is irrelevant on systems, notably Solaris as of Solaris
+ 10, that ignore socket permissions entirely. There, one can achieve a
+ similar effect by pointing unix_socket_directories to a
+ directory having search permission limited to the desired audience.
+
+ Sockets in the abstract namespace have no file permissions, so this
+ setting is also ignored in that case.
+
bonjour (boolean)
+
+ #
+ Enables advertising the server's existence via
+ Bonjour. The default is off.
+ This parameter can only be set at server start.
+
bonjour_name (string)
+
+ #
+ Specifies the Bonjour service
+ name. The computer name is used if this parameter is set to the
+ empty string '' (which is the default). This parameter is
+ ignored if the server was not compiled with
+ Bonjour support.
+ This parameter can only be set at server start.
+
tcp_keepalives_idle (integer)
+
+ #
+ Specifies the amount of time with no network activity after which
+ the operating system should send a TCP keepalive message to the client.
+ If this value is specified without units, it is taken as seconds.
+ A value of 0 (the default) selects the operating system's default.
+ On Windows, setting a value of 0 will set this parameter to 2 hours,
+ since Windows does not provide a way to read the system default value.
+ This parameter is supported only on systems that support
+ TCP_KEEPIDLE or an equivalent socket option, and on
+ Windows; on other systems, it must be zero.
+ In sessions connected via a Unix-domain socket, this parameter is
+ ignored and always reads as zero.
+
tcp_keepalives_interval (integer)
+
+ #
+ Specifies the amount of time after which a TCP keepalive message
+ that has not been acknowledged by the client should be retransmitted.
+ If this value is specified without units, it is taken as seconds.
+ A value of 0 (the default) selects the operating system's default.
+ On Windows, setting a value of 0 will set this parameter to 1 second,
+ since Windows does not provide a way to read the system default value.
+ This parameter is supported only on systems that support
+ TCP_KEEPINTVL or an equivalent socket option, and on
+ Windows; on other systems, it must be zero.
+ In sessions connected via a Unix-domain socket, this parameter is
+ ignored and always reads as zero.
+
tcp_keepalives_count (integer)
+
+ #
+ Specifies the number of TCP keepalive messages that can be lost before
+ the server's connection to the client is considered dead.
+ A value of 0 (the default) selects the operating system's default.
+ This parameter is supported only on systems that support
+ TCP_KEEPCNT or an equivalent socket option (which does not include Windows);
+ on other systems, it must be zero.
+ In sessions connected via a Unix-domain socket, this parameter is
+ ignored and always reads as zero.
+
tcp_user_timeout (integer)
+
+ #
+ Specifies the amount of time that transmitted data may
+ remain unacknowledged before the TCP connection is forcibly closed.
+ If this value is specified without units, it is taken as milliseconds.
+ A value of 0 (the default) selects the operating system's default.
+ This parameter is supported only on systems that support
+ TCP_USER_TIMEOUT (which does not include Windows); on other systems, it must be zero.
+ In sessions connected via a Unix-domain socket, this parameter is
+ ignored and always reads as zero.
+
client_connection_check_interval (integer)
+
+ #
+ Sets the time interval between optional checks that the client is still
+ connected, while running queries. The check is performed by polling
+ the socket, and allows long running queries to be aborted sooner if
+ the kernel reports that the connection is closed.
+
+ This option relies on kernel events exposed by Linux, macOS, illumos
+ and the BSD family of operating systems, and is not currently available
+ on other systems.
+
+ If the value is specified without units, it is taken as milliseconds.
+ The default value is 0, which disables connection
+ checks. Without connection checks, the server will detect the loss of
+ the connection only at the next interaction with the socket, when it
+ waits for, receives or sends data.
+
+ For the kernel itself to detect lost TCP connections reliably and within
+ a known timeframe in all scenarios including network failure, it may
+ also be necessary to adjust the TCP keepalive settings of the operating
+ system, or the tcp_keepalives_idle,
+ tcp_keepalives_interval and
+ tcp_keepalives_count settings of
+ PostgreSQL.
+
authentication_timeout (integer)
+
+
+
+ #
+ Maximum amount of time allowed to complete client authentication. If a
+ would-be client has not completed the authentication protocol in
+ this much time, the server closes the connection. This prevents
+ hung clients from occupying a connection indefinitely.
+ If this value is specified without units, it is taken as seconds.
+ The default is one minute (1m).
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
password_encryption (enum)
+
+ #
+ When a password is specified in CREATE ROLE or
+ ALTER ROLE, this parameter determines the
+ algorithm to use to encrypt the password. Possible values are
+ scram-sha-256, which will encrypt the password with
+ SCRAM-SHA-256, and md5, which stores the password
+ as an MD5 hash. The default is scram-sha-256.
+
+ Note that older clients might lack support for the SCRAM authentication
+ mechanism, and hence not work with passwords encrypted with
+ SCRAM-SHA-256. See Section 21.5 for more details.
+
scram_iterations (integer)
+
+ #
+ The number of computational iterations to be performed when encrypting
+ a password using SCRAM-SHA-256. The default is 4096.
+ A higher number of iterations provides additional protection against
+ brute-force attacks on stored passwords, but makes authentication
+ slower. Changing the value has no effect on existing passwords
+ encrypted with SCRAM-SHA-256 as the iteration count is fixed at the
+ time of encryption. In order to make use of a changed value, a new
+ password must be set.
+
krb_server_keyfile (string)
+
+ #
+ Sets the location of the server's Kerberos key file. The default is
+ FILE:/usr/local/pgsql/etc/krb5.keytab
+ (where the directory part is whatever was specified
+ as sysconfdir at build time; use
+ pg_config --sysconfdir to determine that).
+ If this parameter is set to an empty string, it is ignored and a
+ system-dependent default is used.
+ This parameter can only be set in the
+ postgresql.conf file or on the server command line.
+ See Section 21.6 for more information.
+
krb_caseins_users (boolean)
+
+ #
+ Sets whether GSSAPI user names should be treated
+ case-insensitively.
+ The default is off (case sensitive). This parameter can only be
+ set in the postgresql.conf file or on the server command line.
+
gss_accept_delegation (boolean)
+
+ #
+ Sets whether GSSAPI delegation should be accepted from the client.
+ The default is off meaning credentials from the client will
+ not be accepted. Changing this to on will make the server
+ accept credentials delegated to it from the client. This parameter can only be
+ set in the postgresql.conf file or on the server command line.
+
db_user_namespace (boolean)
+
+ #
+ This parameter enables per-database user names. It is off by default.
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
+ If this is on, you should create users as username@dbname.
+ When username is passed by a connecting client,
+ @ and the database name are appended to the user
+ name and that database-specific user name is looked up by the
+ server. Note that when you create users with names containing
+ @ within the SQL environment, you will need to
+ quote the user name.
+
+ With this parameter enabled, you can still create ordinary global
+ users. Simply append @ when specifying the user
+ name in the client, e.g., joe@. The @
+ will be stripped off before the user name is looked up by the
+ server.
+
+ db_user_namespace causes the client's and
+ server's user name representation to differ.
+ Authentication checks are always done with the server's user name
+ so authentication methods must be configured for the
+ server's user name, not the client's. Because
+ md5 uses the user name as salt on both the
+ client and server, md5 cannot be used with
+ db_user_namespace.
+
Note
+ This feature is intended as a temporary measure until a
+ complete solution is found. At that time, this option will
+ be removed.
+
+ See Section 19.9 for more information about setting up
+ SSL. The configuration parameters for controlling
+ transfer encryption using TLS protocols are named
+ ssl for historic reasons, even though support for
+ the SSL protocol has been deprecated.
+ SSL is in this context used interchangeably with
+ TLS.
+
ssl (boolean)
+
+ #
+ Enables SSL connections.
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+ The default is off.
+
ssl_ca_file (string)
+
+ #
+ Specifies the name of the file containing the SSL server certificate
+ authority (CA).
+ Relative paths are relative to the data directory.
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+ The default is empty, meaning no CA file is loaded,
+ and client certificate verification is not performed.
+
ssl_cert_file (string)
+
+ #
+ Specifies the name of the file containing the SSL server certificate.
+ Relative paths are relative to the data directory.
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+ The default is server.crt.
+
ssl_crl_file (string)
+
+ #
+ Specifies the name of the file containing the SSL client certificate
+ revocation list (CRL).
+ Relative paths are relative to the data directory.
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+ The default is empty, meaning no CRL file is loaded (unless
+ ssl_crl_dir is set).
+
ssl_crl_dir (string)
+
+ #
+ Specifies the name of the directory containing the SSL client
+ certificate revocation list (CRL). Relative paths are relative to the
+ data directory. This parameter can only be set in
+ the postgresql.conf file or on the server command
+ line. The default is empty, meaning no CRLs are used (unless
+ ssl_crl_file is set).
+
+ The directory needs to be prepared with the
+ OpenSSL command
+ openssl rehash or c_rehash. See
+ its documentation for details.
+
+ When using this setting, CRLs in the specified directory are loaded
+ on-demand at connection time. New CRLs can be added to the directory
+ and will be used immediately. This is unlike ssl_crl_file, which causes the CRL in the file to be
+ loaded at server start time or when the configuration is reloaded.
+ Both settings can be used together.
+
ssl_key_file (string)
+
+ #
+ Specifies the name of the file containing the SSL server private key.
+ Relative paths are relative to the data directory.
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+ The default is server.key.
+
ssl_ciphers (string)
+
+ #
+ Specifies a list of SSL cipher suites that are
+ allowed to be used by SSL connections. See the
+ ciphers
+ manual page in the OpenSSL package for the
+ syntax of this setting and a list of supported values. Only
+ connections using TLS version 1.2 and lower are affected. There is
+ currently no setting that controls the cipher choices used by TLS
+ version 1.3 connections. The default value is
+ HIGH:MEDIUM:+3DES:!aNULL. The default is usually a
+ reasonable choice unless you have specific security requirements.
+
+ This parameter can only be set in the
+ postgresql.conf file or on the server command
+ line.
+
+ Explanation of the default value:
+
HIGH #
+ Cipher suites that use ciphers from HIGH group (e.g.,
+ AES, Camellia, 3DES)
+
MEDIUM #
+ Cipher suites that use ciphers from MEDIUM group
+ (e.g., RC4, SEED)
+
+3DES #
+ The OpenSSL default order for
+ HIGH is problematic because it orders 3DES
+ higher than AES128. This is wrong because 3DES offers less
+ security than AES128, and it is also much slower.
+ +3DES reorders it after all other
+ HIGH and MEDIUM ciphers.
+
!aNULL #
+ Disables anonymous cipher suites that do no authentication. Such
+ cipher suites are vulnerable to MITM attacks and
+ therefore should not be used.
+
+
+ Available cipher suite details will vary across
+ OpenSSL versions. Use the command
+ openssl ciphers -v 'HIGH:MEDIUM:+3DES:!aNULL' to
+ see actual details for the currently installed
+ OpenSSL version. Note that this list is
+ filtered at run time based on the server key type.
+
ssl_prefer_server_ciphers (boolean)
+
+ #
+ Specifies whether to use the server's SSL cipher preferences, rather
+ than the client's.
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+ The default is on.
+
+ Older PostgreSQL versions do not have this setting and always use the
+ client's preferences. This setting is mainly for backward
+ compatibility with those versions. Using the server's preferences is
+ usually better because it is more likely that the server is appropriately
+ configured.
+
ssl_ecdh_curve (string)
+
+ #
+ Specifies the name of the curve to use in ECDH key
+ exchange. It needs to be supported by all clients that connect.
+ It does not need to be the same curve used by the server's Elliptic
+ Curve key.
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+ The default is prime256v1.
+
+ OpenSSL names for the most common curves
+ are:
+ prime256v1 (NIST P-256),
+ secp384r1 (NIST P-384),
+ secp521r1 (NIST P-521).
+ The full list of available curves can be shown with the command
+ openssl ecparam -list_curves. Not all of them
+ are usable in TLS though.
+
ssl_min_protocol_version (enum)
+
+ #
+ Sets the minimum SSL/TLS protocol version to use. Valid values are
+ currently: TLSv1, TLSv1.1,
+ TLSv1.2, TLSv1.3. Older
+ versions of the OpenSSL library do not
+ support all values; an error will be raised if an unsupported setting
+ is chosen. Protocol versions before TLS 1.0, namely SSL version 2 and
+ 3, are always disabled.
+
+ The default is TLSv1.2, which satisfies industry
+ best practices as of this writing.
+
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
ssl_max_protocol_version (enum)
+
+ #
+ Sets the maximum SSL/TLS protocol version to use. Valid values are as
+ for ssl_min_protocol_version, with addition of
+ an empty string, which allows any protocol version. The default is to
+ allow any version. Setting the maximum protocol version is mainly
+ useful for testing or if some component has issues working with a
+ newer protocol.
+
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
ssl_dh_params_file (string)
+
+ #
+ Specifies the name of the file containing Diffie-Hellman parameters
+ used for so-called ephemeral DH family of SSL ciphers. The default is
+ empty, in which case compiled-in default DH parameters used. Using
+ custom DH parameters reduces the exposure if an attacker manages to
+ crack the well-known compiled-in DH parameters. You can create your own
+ DH parameters file with the command
+ openssl dhparam -out dhparams.pem 2048.
+
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
ssl_passphrase_command (string)
+
+ #
+ Sets an external command to be invoked when a passphrase for
+ decrypting an SSL file such as a private key needs to be obtained. By
+ default, this parameter is empty, which means the built-in prompting
+ mechanism is used.
+
+ The command must print the passphrase to the standard output and exit
+ with code 0. In the parameter value, %p is
+ replaced by a prompt string. (Write %% for a
+ literal %.) Note that the prompt string will
+ probably contain whitespace, so be sure to quote adequately. A single
+ newline is stripped from the end of the output if present.
+
+ The command does not actually have to prompt the user for a
+ passphrase. It can read it from a file, obtain it from a keychain
+ facility, or similar. It is up to the user to make sure the chosen
+ mechanism is adequately secure.
+
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
ssl_passphrase_command_supports_reload (boolean)
+
+ #
+ This parameter determines whether the passphrase command set by
+ ssl_passphrase_command will also be called during a
+ configuration reload if a key file needs a passphrase. If this
+ parameter is off (the default), then
+ ssl_passphrase_command will be ignored during a
+ reload and the SSL configuration will not be reloaded if a passphrase
+ is needed. That setting is appropriate for a command that requires a
+ TTY for prompting, which might not be available when the server is
+ running. Setting this parameter to on might be appropriate if the
+ passphrase is obtained from a file, for example.
+
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
20.16. Customized Options #
+ This feature was designed to allow parameters not normally known to
+ PostgreSQL to be added by add-on modules
+ (such as procedural languages). This allows extension modules to be
+ configured in the standard ways.
+
+ Custom options have two-part names: an extension name, then a dot, then
+ the parameter name proper, much like qualified names in SQL. An example
+ is plpgsql.variable_conflict.
+
+ Because custom options may need to be set in processes that have not
+ loaded the relevant extension module, PostgreSQL
+ will accept a setting for any two-part parameter name. Such variables
+ are treated as placeholders and have no function until the module that
+ defines them is loaded. When an extension module is loaded, it will add
+ its variable definitions and convert any placeholder values according to
+ those definitions. If there are any unrecognized placeholders
+ that begin with its extension name, warnings are issued and those
+ placeholders are removed.
+
20.17. Developer Options #
+ The following parameters are intended for developer testing, and
+ should never be used on a production database. However, some of
+ them can be used to assist with the recovery of severely damaged
+ databases. As such, they have been excluded from the sample
+ postgresql.conf file. Note that many of these
+ parameters require special source compilation flags to work at all.
+
allow_in_place_tablespaces (boolean)
+
+ #
+ Allows tablespaces to be created as directories inside
+ pg_tblspc, when an empty location string
+ is provided to the CREATE TABLESPACE command. This
+ is intended to allow testing replication scenarios where primary and
+ standby servers are running on the same machine. Such directories
+ are likely to confuse backup tools that expect to find only symbolic
+ links in that location.
+ Only superusers and users with the appropriate SET
+ privilege can change this setting.
+
allow_system_table_mods (boolean)
+
+ #
+ Allows modification of the structure of system tables as well as
+ certain other risky actions on system tables. This is otherwise not
+ allowed even for superusers. Ill-advised use of this setting can
+ cause irretrievable data loss or seriously corrupt the database
+ system.
+ Only superusers and users with the appropriate SET
+ privilege can change this setting.
+
backtrace_functions (string)
+
+ #
+ This parameter contains a comma-separated list of C function names.
+ If an error is raised and the name of the internal C function where
+ the error happens matches a value in the list, then a backtrace is
+ written to the server log together with the error message. This can
+ be used to debug specific areas of the source code.
+
+ Backtrace support is not available on all platforms, and the quality
+ of the backtraces depends on compilation options.
+
+ Only superusers and users with the appropriate SET
+ privilege can change this setting.
+
debug_discard_caches (integer)
+
+ #
+ When set to 1, each system catalog cache entry is
+ invalidated at the first possible opportunity, whether or not
+ anything that would render it invalid really occurred. Caching of
+ system catalogs is effectively disabled as a result, so the server
+ will run extremely slowly. Higher values run the cache invalidation
+ recursively, which is even slower and only useful for testing
+ the caching logic itself. The default value of 0
+ selects normal catalog caching behavior.
+
+ This parameter can be very helpful when trying to trigger
+ hard-to-reproduce bugs involving concurrent catalog changes, but it
+ is otherwise rarely needed. See the source code files
+ inval.c and
+ pg_config_manual.h for details.
+
+ This parameter is supported when
+ DISCARD_CACHES_ENABLED was defined at compile time
+ (which happens automatically when using the
+ configure option
+ --enable-cassert). In production builds, its value
+ will always be 0 and attempts to set it to another
+ value will raise an error.
+
debug_io_direct (string)
+
+ #
+ Ask the kernel to minimize caching effects for relation data and WAL
+ files using O_DIRECT (most Unix-like systems),
+ F_NOCACHE (macOS) or
+ FILE_FLAG_NO_BUFFERING (Windows).
+
+ May be set to an empty string (the default) to disable use of direct
+ I/O, or a comma-separated list of operations that should use direct I/O.
+ The valid options are data for
+ main data files, wal for WAL files, and
+ wal_init for WAL files when being initially
+ allocated.
+
+ Some operating systems and file systems do not support direct I/O, so
+ non-default settings may be rejected at startup or cause errors.
+
+ Currently this feature reduces performance, and is intended for
+ developer testing only.
+
debug_parallel_query (enum)
+
+ #
+ Allows the use of parallel queries for testing purposes even in cases
+ where no performance benefit is expected.
+ The allowed values of debug_parallel_query are
+ off (use parallel mode only when it is expected to improve
+ performance), on (force parallel query for all queries
+ for which it is thought to be safe), and regress (like
+ on, but with additional behavior changes as explained
+ below).
+
+ More specifically, setting this value to on will add
+ a Gather node to the top of any query plan for which this
+ appears to be safe, so that the query runs inside of a parallel worker.
+ Even when a parallel worker is not available or cannot be used,
+ operations such as starting a subtransaction that would be prohibited
+ in a parallel query context will be prohibited unless the planner
+ believes that this will cause the query to fail. If failures or
+ unexpected results occur when this option is set, some functions used
+ by the query may need to be marked PARALLEL UNSAFE
+ (or, possibly, PARALLEL RESTRICTED).
+
+ Setting this value to regress has all of the same effects
+ as setting it to on plus some additional effects that are
+ intended to facilitate automated regression testing. Normally,
+ messages from a parallel worker include a context line indicating that,
+ but a setting of regress suppresses this line so that the
+ output is the same as in non-parallel execution. Also,
+ the Gather nodes added to plans by this setting are hidden
+ in EXPLAIN output so that the output matches what
+ would be obtained if this setting were turned off.
+
ignore_system_indexes (boolean)
+
+ #
+ Ignore system indexes when reading system tables (but still
+ update the indexes when modifying the tables). This is useful
+ when recovering from damaged system indexes.
+ This parameter cannot be changed after session start.
+
post_auth_delay (integer)
+
+ #
+ The amount of time to delay when a new
+ server process is started, after it conducts the
+ authentication procedure. This is intended to give developers an
+ opportunity to attach to the server process with a debugger.
+ If this value is specified without units, it is taken as seconds.
+ A value of zero (the default) disables the delay.
+ This parameter cannot be changed after session start.
+
pre_auth_delay (integer)
+
+ #
+ The amount of time to delay just after a
+ new server process is forked, before it conducts the
+ authentication procedure. This is intended to give developers an
+ opportunity to attach to the server process with a debugger to
+ trace down misbehavior in authentication.
+ If this value is specified without units, it is taken as seconds.
+ A value of zero (the default) disables the delay.
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
trace_notify (boolean)
+
+ #
+ Generates a great amount of debugging output for the
+ LISTEN and NOTIFY
+ commands. client_min_messages or
+ log_min_messages must be
+ DEBUG1 or lower to send this output to the
+ client or server logs, respectively.
+
trace_recovery_messages (enum)
+
+ #
+ Enables logging of recovery-related debugging output that otherwise
+ would not be logged. This parameter allows the user to override the
+ normal setting of log_min_messages, but only for
+ specific messages. This is intended for use in debugging hot standby.
+ Valid values are DEBUG5, DEBUG4,
+ DEBUG3, DEBUG2, DEBUG1, and
+ LOG. The default, LOG, does not affect
+ logging decisions at all. The other values cause recovery-related
+ debug messages of that priority or higher to be logged as though they
+ had LOG priority; for common settings of
+ log_min_messages this results in unconditionally sending
+ them to the server log.
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
trace_sort (boolean)
+
+ #
+ If on, emit information about resource usage during sort operations.
+ This parameter is only available if the TRACE_SORT macro
+ was defined when PostgreSQL was compiled.
+ (However, TRACE_SORT is currently defined by default.)
+
trace_locks (boolean)
+
+ #
+ If on, emit information about lock usage. Information dumped
+ includes the type of lock operation, the type of lock and the unique
+ identifier of the object being locked or unlocked. Also included
+ are bit masks for the lock types already granted on this object as
+ well as for the lock types awaited on this object. For each lock
+ type a count of the number of granted locks and waiting locks is
+ also dumped as well as the totals. An example of the log file output
+ is shown here:
+
+LOG: LockAcquire: new: lock(0xb7acd844) id(24688,24696,0,0,0,1)
+ grantMask(0) req(0,0,0,0,0,0,0)=0 grant(0,0,0,0,0,0,0)=0
+ wait(0) type(AccessShareLock)
+LOG: GrantLock: lock(0xb7acd844) id(24688,24696,0,0,0,1)
+ grantMask(2) req(1,0,0,0,0,0,0)=1 grant(1,0,0,0,0,0,0)=1
+ wait(0) type(AccessShareLock)
+LOG: UnGrantLock: updated: lock(0xb7acd844) id(24688,24696,0,0,0,1)
+ grantMask(0) req(0,0,0,0,0,0,0)=0 grant(0,0,0,0,0,0,0)=0
+ wait(0) type(AccessShareLock)
+LOG: CleanUpLock: deleting: lock(0xb7acd844) id(24688,24696,0,0,0,1)
+ grantMask(0) req(0,0,0,0,0,0,0)=0 grant(0,0,0,0,0,0,0)=0
+ wait(0) type(INVALID)
+
+ Details of the structure being dumped may be found in
+ src/include/storage/lock.h.
+
+ This parameter is only available if the LOCK_DEBUG
+ macro was defined when PostgreSQL was
+ compiled.
+
trace_lwlocks (boolean)
+
+ #
+ If on, emit information about lightweight lock usage. Lightweight
+ locks are intended primarily to provide mutual exclusion of access
+ to shared-memory data structures.
+
+ This parameter is only available if the LOCK_DEBUG
+ macro was defined when PostgreSQL was
+ compiled.
+
trace_userlocks (boolean)
+
+ #
+ If on, emit information about user lock usage. Output is the same
+ as for trace_locks, only for advisory locks.
+
+ This parameter is only available if the LOCK_DEBUG
+ macro was defined when PostgreSQL was
+ compiled.
+
trace_lock_oidmin (integer)
+
+ #
+ If set, do not trace locks for tables below this OID (used to avoid
+ output on system tables).
+
+ This parameter is only available if the LOCK_DEBUG
+ macro was defined when PostgreSQL was
+ compiled.
+
trace_lock_table (integer)
+
+ #
+ Unconditionally trace locks on this table (OID).
+
+ This parameter is only available if the LOCK_DEBUG
+ macro was defined when PostgreSQL was
+ compiled.
+
debug_deadlocks (boolean)
+
+ #
+ If set, dumps information about all current locks when a
+ deadlock timeout occurs.
+
+ This parameter is only available if the LOCK_DEBUG
+ macro was defined when PostgreSQL was
+ compiled.
+
log_btree_build_stats (boolean)
+
+ #
+ If set, logs system resource usage statistics (memory and CPU) on
+ various B-tree operations.
+
+ This parameter is only available if the BTREE_BUILD_STATS
+ macro was defined when PostgreSQL was
+ compiled.
+
wal_consistency_checking (string)
+
+ #
+ This parameter is intended to be used to check for bugs in the WAL
+ redo routines. When enabled, full-page images of any buffers modified
+ in conjunction with the WAL record are added to the record.
+ If the record is subsequently replayed, the system will first apply
+ each record and then test whether the buffers modified by the record
+ match the stored images. In certain cases (such as hint bits), minor
+ variations are acceptable, and will be ignored. Any unexpected
+ differences will result in a fatal error, terminating recovery.
+
+ The default value of this setting is the empty string, which disables
+ the feature. It can be set to all to check all
+ records, or to a comma-separated list of resource managers to check
+ only records originating from those resource managers. Currently,
+ the supported resource managers are heap,
+ heap2, btree, hash,
+ gin, gist, sequence,
+ spgist, brin, and generic.
+ Extensions may define additional resource managers. Only superusers and users with
+ the appropriate SET privilege can change this setting.
+
wal_debug (boolean)
+
+ #
+ If on, emit WAL-related debugging output. This parameter is
+ only available if the WAL_DEBUG macro was
+ defined when PostgreSQL was
+ compiled.
+
ignore_checksum_failure (boolean)
+
+ #
+ Only has effect if data checksums are enabled.
+
+ Detection of a checksum failure during a read normally causes
+ PostgreSQL to report an error, aborting the current
+ transaction. Setting ignore_checksum_failure to on causes
+ the system to ignore the failure (but still report a warning), and
+ continue processing. This behavior may cause crashes, propagate
+ or hide corruption, or other serious problems. However, it may allow
+ you to get past the error and retrieve undamaged tuples that might still be
+ present in the table if the block header is still sane. If the header is
+ corrupt an error will be reported even if this option is enabled. The
+ default setting is off.
+ Only superusers and users with the appropriate SET
+ privilege can change this setting.
+
zero_damaged_pages (boolean)
+
+ #
+ Detection of a damaged page header normally causes
+ PostgreSQL to report an error, aborting the current
+ transaction. Setting zero_damaged_pages to on causes
+ the system to instead report a warning, zero out the damaged
+ page in memory, and continue processing. This behavior will destroy data,
+ namely all the rows on the damaged page. However, it does allow you to get
+ past the error and retrieve rows from any undamaged pages that might
+ be present in the table. It is useful for recovering data if
+ corruption has occurred due to a hardware or software error. You should
+ generally not set this on until you have given up hope of recovering
+ data from the damaged pages of a table. Zeroed-out pages are not
+ forced to disk so it is recommended to recreate the table or
+ the index before turning this parameter off again. The
+ default setting is off.
+ Only superusers and users with the appropriate SET
+ privilege can change this setting.
+
ignore_invalid_pages (boolean)
+
+ #
+ If set to off (the default), detection of
+ WAL records having references to invalid pages during
+ recovery causes PostgreSQL to
+ raise a PANIC-level error, aborting the recovery. Setting
+ ignore_invalid_pages to on
+ causes the system to ignore invalid page references in WAL records
+ (but still report a warning), and continue the recovery.
+ This behavior may cause crashes, data loss,
+ propagate or hide corruption, or other serious problems.
+ However, it may allow you to get past the PANIC-level error,
+ to finish the recovery, and to cause the server to start up.
+ The parameter can only be set at server start. It only has effect
+ during recovery or in standby mode.
+
jit_debugging_support (boolean)
+
+ #
+ If LLVM has the required functionality, register generated functions
+ with GDB. This makes debugging easier.
+ The default setting is off.
+ This parameter can only be set at server start.
+
jit_dump_bitcode (boolean)
+
+ #
+ Writes the generated LLVM IR out to the
+ file system, inside data_directory. This is only
+ useful for working on the internals of the JIT implementation.
+ The default setting is off.
+ Only superusers and users with the appropriate SET
+ privilege can change this setting.
+
jit_expressions (boolean)
+
+ #
+ Determines whether expressions are JIT compiled, when JIT compilation
+ is activated (see Section 32.2). The default is
+ on.
+
jit_profiling_support (boolean)
+
+ #
+ If LLVM has the required functionality, emit the data needed to allow
+ perf to profile functions generated by JIT.
+ This writes out files to ~/.debug/jit/; the
+ user is responsible for performing cleanup when desired.
+ The default setting is off.
+ This parameter can only be set at server start.
+
jit_tuple_deforming (boolean)
+
+ #
+ Determines whether tuple deforming is JIT compiled, when JIT
+ compilation is activated (see Section 32.2).
+ The default is on.
+
remove_temp_files_after_crash (boolean)
+
+ #
+ When set to on, which is the default,
+ PostgreSQL will automatically remove
+ temporary files after a backend crash. If disabled, the files will be
+ retained and may be used for debugging, for example. Repeated crashes
+ may however result in accumulation of useless files. This parameter
+ can only be set in the postgresql.conf file or on
+ the server command line.
+
send_abort_for_crash (boolean)
+
+ #
+ By default, after a backend crash the postmaster will stop remaining
+ child processes by sending them SIGQUIT
+ signals, which permits them to exit more-or-less gracefully. When
+ this option is set to on,
+ SIGABRT is sent instead. That normally
+ results in production of a core dump file for each such child
+ process.
+ This can be handy for investigating the states of other processes
+ after a crash. It can also consume lots of disk space in the event
+ of repeated crashes, so do not enable this on systems you are not
+ monitoring carefully.
+ Beware that no support exists for cleaning up the core file(s)
+ automatically.
+ This parameter can only be set in
+ the postgresql.conf file or on the server
+ command line.
+
send_abort_for_kill (boolean)
+
+ #
+ By default, after attempting to stop a child process with
+ SIGQUIT, the postmaster will wait five
+ seconds and then send SIGKILL to force
+ immediate termination. When this option is set
+ to on, SIGABRT is sent
+ instead of SIGKILL. That normally results
+ in production of a core dump file for each such child process.
+ This can be handy for investigating the states
+ of “stuck” child processes. It can also consume lots
+ of disk space in the event of repeated crashes, so do not enable
+ this on systems you are not monitoring carefully.
+ Beware that no support exists for cleaning up the core file(s)
+ automatically.
+ This parameter can only be set in
+ the postgresql.conf file or on the server
+ command line.
+
debug_logical_replication_streaming (enum)
+
+ #
+ The allowed values are buffered and
+ immediate. The default is buffered.
+ This parameter is intended to be used to test logical decoding and
+ replication of large transactions. The effect of
+ debug_logical_replication_streaming is different for the
+ publisher and subscriber:
+
+ On the publisher side, debug_logical_replication_streaming
+ allows streaming or serializing changes immediately in logical decoding.
+ When set to immediate, stream each change if the
+ streaming
+ option of
+ CREATE SUBSCRIPTION
+ is enabled, otherwise, serialize each change. When set to
+ buffered, the decoding will stream or serialize
+ changes when logical_decoding_work_mem is reached.
+
+ On the subscriber side, if the streaming option is set to
+ parallel, debug_logical_replication_streaming
+ can be used to direct the leader apply worker to send changes to the
+ shared memory queue or to serialize all changes to the file. When set to
+ buffered, the leader sends changes to parallel apply
+ workers via a shared memory queue. When set to
+ immediate, the leader serializes all changes to files
+ and notifies the parallel apply workers to read and apply them at the
+ end of the transaction.
+
exit_on_error (boolean)
+
+ #
+ If on, any error will terminate the current session. By default,
+ this is set to off, so that only FATAL errors will terminate the
+ session.
+
restart_after_crash (boolean)
+
+ #
+ When set to on, which is the default, PostgreSQL
+ will automatically reinitialize after a backend crash. Leaving this
+ value set to on is normally the best way to maximize the availability
+ of the database. However, in some circumstances, such as when
+ PostgreSQL is being invoked by clusterware, it may be
+ useful to disable the restart so that the clusterware can gain
+ control and take any actions it deems appropriate.
+
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
data_sync_retry (boolean)
+
+ #
+ When set to off, which is the default, PostgreSQL
+ will raise a PANIC-level error on failure to flush modified data files
+ to the file system. This causes the database server to crash. This
+ parameter can only be set at server start.
+
+ On some operating systems, the status of data in the kernel's page
+ cache is unknown after a write-back failure. In some cases it might
+ have been entirely forgotten, making it unsafe to retry; the second
+ attempt may be reported as successful, when in fact the data has been
+ lost. In these circumstances, the only way to avoid data loss is to
+ recover from the WAL after any failure is reported, preferably
+ after investigating the root cause of the failure and replacing any
+ faulty hardware.
+
+ If set to on, PostgreSQL will instead
+ report an error but continue to run so that the data flushing
+ operation can be retried in a later checkpoint. Only set it to on
+ after investigating the operating system's treatment of buffered data
+ in case of write-back failure.
+
recovery_init_sync_method (enum)
+
+ #
+ When set to fsync, which is the default,
+ PostgreSQL will recursively open and
+ synchronize all files in the data directory before crash recovery
+ begins. The search for files will follow symbolic links for the WAL
+ directory and each configured tablespace (but not any other symbolic
+ links). This is intended to make sure that all WAL and data files are
+ durably stored on disk before replaying changes. This applies whenever
+ starting a database cluster that did not shut down cleanly, including
+ copies created with pg_basebackup.
+
+ On Linux, syncfs may be used instead, to ask the
+ operating system to synchronize the whole file systems that contain the
+ data directory, the WAL files and each tablespace (but not any other
+ file systems that may be reachable through symbolic links). This may
+ be a lot faster than the fsync setting, because it
+ doesn't need to open each file one by one. On the other hand, it may
+ be slower if a file system is shared by other applications that
+ modify a lot of files, since those files will also be written to disk.
+ Furthermore, on versions of Linux before 5.8, I/O errors encountered
+ while writing data to disk may not be reported to
+ PostgreSQL, and relevant error messages may
+ appear only in kernel logs.
+
+ This parameter can only be set in the
+ postgresql.conf file or on the server command line.
+
+ In addition to the postgresql.conf file
+ already mentioned, PostgreSQL uses
+ two other manually-edited configuration files, which control
+ client authentication (their use is discussed in Chapter 21). By default, all three
+ configuration files are stored in the database cluster's data
+ directory. The parameters described in this section allow the
+ configuration files to be placed elsewhere. (Doing so can ease
+ administration. In particular it is often easier to ensure that
+ the configuration files are properly backed-up when they are
+ kept separate.)
+
data_directory (string)
+
+ #
+ Specifies the directory to use for data storage.
+ This parameter can only be set at server start.
+
config_file (string)
+
+ #
+ Specifies the main server configuration file
+ (customarily called postgresql.conf).
+ This parameter can only be set on the postgres command line.
+
hba_file (string)
+
+ #
+ Specifies the configuration file for host-based authentication
+ (customarily called pg_hba.conf).
+ This parameter can only be set at server start.
+
ident_file (string)
+
+ #
+ Specifies the configuration file for user name mapping
+ (customarily called pg_ident.conf).
+ This parameter can only be set at server start.
+ See also Section 21.2.
+
external_pid_file (string)
+
+ #
+ Specifies the name of an additional process-ID (PID) file that the
+ server should create for use by server administration programs.
+ This parameter can only be set at server start.
+
+ In a default installation, none of the above parameters are set
+ explicitly. Instead, the
+ data directory is specified by the -D command-line
+ option or the PGDATA environment variable, and the
+ configuration files are all found within the data directory.
+
+ If you wish to keep the configuration files elsewhere than the
+ data directory, the postgres -D
+ command-line option or PGDATA environment variable
+ must point to the directory containing the configuration files,
+ and the data_directory parameter must be set in
+ postgresql.conf (or on the command line) to show
+ where the data directory is actually located. Notice that
+ data_directory overrides -D and
+ PGDATA for the location
+ of the data directory, but not for the location of the configuration
+ files.
+
+ If you wish, you can specify the configuration file names and locations
+ individually using the parameters config_file,
+ hba_file and/or ident_file.
+ config_file can only be specified on the
+ postgres command line, but the others can be
+ set within the main configuration file. If all three parameters plus
+ data_directory are explicitly set, then it is not necessary
+ to specify -D or PGDATA.
+
+ When setting any of these parameters, a relative path will be interpreted
+ with respect to the directory in which postgres
+ is started.
+
deadlock_timeout (integer)
+
+
+
+ #
+ This is the amount of time to wait on a lock
+ before checking to see if there is a deadlock condition. The
+ check for deadlock is relatively expensive, so the server doesn't run
+ it every time it waits for a lock. We optimistically assume
+ that deadlocks are not common in production applications and
+ just wait on the lock for a while before checking for a
+ deadlock. Increasing this value reduces the amount of time
+ wasted in needless deadlock checks, but slows down reporting of
+ real deadlock errors.
+ If this value is specified without units, it is taken as milliseconds.
+ The default is one second (1s),
+ which is probably about the smallest value you would want in
+ practice. On a heavily loaded server you might want to raise it.
+ Ideally the setting should exceed your typical transaction time,
+ so as to improve the odds that a lock will be released before
+ the waiter decides to check for deadlock.
+ Only superusers and users with the appropriate SET
+ privilege can change this setting.
+
+ When log_lock_waits is set,
+ this parameter also determines the amount of time to wait before
+ a log message is issued about the lock wait. If you are trying
+ to investigate locking delays you might want to set a shorter than
+ normal deadlock_timeout.
+
max_locks_per_transaction (integer)
+
+ #
+ The shared lock table has space for
+ max_locks_per_transaction objects
+ (e.g., tables) per server process or prepared transaction;
+ hence, no more than this many distinct objects can be locked at
+ any one time. This parameter limits the average number of object
+ locks used by each transaction; individual transactions
+ can lock more objects as long as the locks of all transactions
+ fit in the lock table. This is not the number of
+ rows that can be locked; that value is unlimited. The default,
+ 64, has historically proven sufficient, but you might need to
+ raise this value if you have queries that touch many different
+ tables in a single transaction, e.g., query of a parent table with
+ many children. This parameter can only be set at server start.
+
+ When running a standby server, you must set this parameter to have the
+ same or higher value as on the primary server. Otherwise, queries
+ will not be allowed in the standby server.
+
max_pred_locks_per_transaction (integer)
+
+ #
+ The shared predicate lock table has space for
+ max_pred_locks_per_transaction objects
+ (e.g., tables) per server process or prepared transaction;
+ hence, no more than this many distinct objects can be locked at
+ any one time. This parameter limits the average number of object
+ locks used by each transaction; individual transactions
+ can lock more objects as long as the locks of all transactions
+ fit in the lock table. This is not the number of
+ rows that can be locked; that value is unlimited. The default,
+ 64, has historically proven sufficient, but you might need to
+ raise this value if you have clients that touch many different
+ tables in a single serializable transaction. This parameter can
+ only be set at server start.
+
max_pred_locks_per_relation (integer)
+
+ #
+ This controls how many pages or tuples of a single relation can be
+ predicate-locked before the lock is promoted to covering the whole
+ relation. Values greater than or equal to zero mean an absolute
+ limit, while negative values
+ mean max_pred_locks_per_transaction divided by
+ the absolute value of this setting. The default is -2, which keeps
+ the behavior from previous versions of PostgreSQL.
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
max_pred_locks_per_page (integer)
+
+ #
+ This controls how many rows on a single page can be predicate-locked
+ before the lock is promoted to covering the whole page. The default
+ is 2. This parameter can only be set in
+ the postgresql.conf file or on the server command line.
+
20.8. Error Reporting and Logging #
log_destination (string)
+
+ #
+ PostgreSQL supports several methods
+ for logging server messages, including
+ stderr, csvlog,
+ jsonlog, and
+ syslog. On Windows,
+ eventlog is also supported. Set this
+ parameter to a list of desired log destinations separated by
+ commas. The default is to log to stderr
+ only.
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
+ If csvlog is included in log_destination,
+ log entries are output in “comma separated
+ value” (CSV) format, which is convenient for
+ loading logs into programs.
+ See Section 20.8.4 for details.
+ logging_collector must be enabled to generate
+ CSV-format log output.
+
+ If jsonlog is included in
+ log_destination, log entries are output in
+ JSON format, which is convenient for loading logs
+ into programs.
+ See Section 20.8.5 for details.
+ logging_collector must be enabled to generate
+ JSON-format log output.
+
+ When either stderr,
+ csvlog or jsonlog are
+ included, the file current_logfiles is created to
+ record the location of the log file(s) currently in use by the logging
+ collector and the associated logging destination. This provides a
+ convenient way to find the logs currently in use by the instance. Here
+ is an example of this file's content:
+
+stderr log/postgresql.log
+csvlog log/postgresql.csv
+jsonlog log/postgresql.json
+
+
+ current_logfiles is recreated when a new log file
+ is created as an effect of rotation, and
+ when log_destination is reloaded. It is removed when
+ none of stderr,
+ csvlog or jsonlog are
+ included in log_destination, and when the logging
+ collector is disabled.
+
Note
+ On most Unix systems, you will need to alter the configuration of
+ your system's syslog daemon in order
+ to make use of the syslog option for
+ log_destination. PostgreSQL
+ can log to syslog facilities
+ LOCAL0 through LOCAL7 (see syslog_facility), but the default
+ syslog configuration on most platforms
+ will discard all such messages. You will need to add something like:
+
+local0.* /var/log/postgresql
+
+ to the syslog daemon's configuration file
+ to make it work.
+
+ On Windows, when you use the eventlog
+ option for log_destination, you should
+ register an event source and its library with the operating
+ system so that the Windows Event Viewer can display event
+ log messages cleanly.
+ See Section 19.12 for details.
+
logging_collector (boolean)
+
+ #
+ This parameter enables the logging collector, which
+ is a background process that captures log messages
+ sent to stderr and redirects them into log files.
+ This approach is often more useful than
+ logging to syslog, since some types of messages
+ might not appear in syslog output. (One common
+ example is dynamic-linker failure messages; another is error messages
+ produced by scripts such as archive_command.)
+ This parameter can only be set at server start.
+
Note
+ It is possible to log to stderr without using the
+ logging collector; the log messages will just go to wherever the
+ server's stderr is directed. However, that method is
+ only suitable for low log volumes, since it provides no convenient
+ way to rotate log files. Also, on some platforms not using the
+ logging collector can result in lost or garbled log output, because
+ multiple processes writing concurrently to the same log file can
+ overwrite each other's output.
+
Note
+ The logging collector is designed to never lose messages. This means
+ that in case of extremely high load, server processes could be
+ blocked while trying to send additional log messages when the
+ collector has fallen behind. In contrast, syslog
+ prefers to drop messages if it cannot write them, which means it
+ may fail to log some messages in such cases but it will not block
+ the rest of the system.
+
log_directory (string)
+
+ #
+ When logging_collector is enabled,
+ this parameter determines the directory in which log files will be created.
+ It can be specified as an absolute path, or relative to the
+ cluster data directory.
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+ The default is log.
+
log_filename (string)
+
+ #
+ When logging_collector is enabled,
+ this parameter sets the file names of the created log files. The value
+ is treated as a strftime pattern,
+ so %-escapes can be used to specify time-varying
+ file names. (Note that if there are
+ any time-zone-dependent %-escapes, the computation
+ is done in the zone specified
+ by log_timezone.)
+ The supported %-escapes are similar to those
+ listed in the Open Group's strftime
+ specification.
+ Note that the system's strftime is not used
+ directly, so platform-specific (nonstandard) extensions do not work.
+ The default is postgresql-%Y-%m-%d_%H%M%S.log.
+
+ If you specify a file name without escapes, you should plan to
+ use a log rotation utility to avoid eventually filling the
+ entire disk. In releases prior to 8.4, if
+ no % escapes were
+ present, PostgreSQL would append
+ the epoch of the new log file's creation time, but this is no
+ longer the case.
+
+ If CSV-format output is enabled in log_destination,
+ .csv will be appended to the timestamped
+ log file name to create the file name for CSV-format output.
+ (If log_filename ends in .log, the suffix is
+ replaced instead.)
+
+ If JSON-format output is enabled in log_destination,
+ .json will be appended to the timestamped
+ log file name to create the file name for JSON-format output.
+ (If log_filename ends in .log, the suffix is
+ replaced instead.)
+
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
log_file_mode (integer)
+
+ #
+ On Unix systems this parameter sets the permissions for log files
+ when logging_collector is enabled. (On Microsoft
+ Windows this parameter is ignored.)
+ The parameter value is expected to be a numeric mode
+ specified in the format accepted by the
+ chmod and umask
+ system calls. (To use the customary octal format the number
+ must start with a 0 (zero).)
+
+ The default permissions are 0600, meaning only the
+ server owner can read or write the log files. The other commonly
+ useful setting is 0640, allowing members of the owner's
+ group to read the files. Note however that to make use of such a
+ setting, you'll need to alter log_directory to
+ store the files somewhere outside the cluster data directory. In
+ any case, it's unwise to make the log files world-readable, since
+ they might contain sensitive data.
+
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
log_rotation_age (integer)
+
+ #
+ When logging_collector is enabled,
+ this parameter determines the maximum amount of time to use an
+ individual log file, after which a new log file will be created.
+ If this value is specified without units, it is taken as minutes.
+ The default is 24 hours.
+ Set to zero to disable time-based creation of new log files.
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
log_rotation_size (integer)
+
+ #
+ When logging_collector is enabled,
+ this parameter determines the maximum size of an individual log file.
+ After this amount of data has been emitted into a log file,
+ a new log file will be created.
+ If this value is specified without units, it is taken as kilobytes.
+ The default is 10 megabytes.
+ Set to zero to disable size-based creation of new log files.
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
log_truncate_on_rotation (boolean)
+
+ #
+ When logging_collector is enabled,
+ this parameter will cause PostgreSQL to truncate (overwrite),
+ rather than append to, any existing log file of the same name.
+ However, truncation will occur only when a new file is being opened
+ due to time-based rotation, not during server startup or size-based
+ rotation. When off, pre-existing files will be appended to in
+ all cases. For example, using this setting in combination with
+ a log_filename like postgresql-%H.log
+ would result in generating twenty-four hourly log files and then
+ cyclically overwriting them.
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
+ Example: To keep 7 days of logs, one log file per day named
+ server_log.Mon, server_log.Tue,
+ etc., and automatically overwrite last week's log with this week's log,
+ set log_filename to server_log.%a,
+ log_truncate_on_rotation to on, and
+ log_rotation_age to 1440.
+
+ Example: To keep 24 hours of logs, one log file per hour, but
+ also rotate sooner if the log file size exceeds 1GB, set
+ log_filename to server_log.%H%M,
+ log_truncate_on_rotation to on,
+ log_rotation_age to 60, and
+ log_rotation_size to 1000000.
+ Including %M in log_filename allows
+ any size-driven rotations that might occur to select a file name
+ different from the hour's initial file name.
+
syslog_facility (enum)
+
+ #
+ When logging to syslog is enabled, this parameter
+ determines the syslog
+ “facility” to be used. You can choose
+ from LOCAL0, LOCAL1,
+ LOCAL2, LOCAL3, LOCAL4,
+ LOCAL5, LOCAL6, LOCAL7;
+ the default is LOCAL0. See also the
+ documentation of your system's
+ syslog daemon.
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
syslog_ident (string)
+
+ #
+ When logging to syslog is enabled, this parameter
+ determines the program name used to identify
+ PostgreSQL messages in
+ syslog logs. The default is
+ postgres.
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
syslog_sequence_numbers (boolean)
+
+ #
+ When logging to syslog and this is on (the
+ default), then each message will be prefixed by an increasing
+ sequence number (such as [2]). This circumvents
+ the “--- last message repeated N times ---” suppression
+ that many syslog implementations perform by default. In more modern
+ syslog implementations, repeated message suppression can be configured
+ (for example, $RepeatedMsgReduction
+ in rsyslog), so this might not be
+ necessary. Also, you could turn this off if you actually want to
+ suppress repeated messages.
+
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
syslog_split_messages (boolean)
+
+ #
+ When logging to syslog is enabled, this parameter
+ determines how messages are delivered to syslog. When on (the
+ default), messages are split by lines, and long lines are split so
+ that they will fit into 1024 bytes, which is a typical size limit for
+ traditional syslog implementations. When off, PostgreSQL server log
+ messages are delivered to the syslog service as is, and it is up to
+ the syslog service to cope with the potentially bulky messages.
+
+ If syslog is ultimately logging to a text file, then the effect will
+ be the same either way, and it is best to leave the setting on, since
+ most syslog implementations either cannot handle large messages or
+ would need to be specially configured to handle them. But if syslog
+ is ultimately writing into some other medium, it might be necessary or
+ more useful to keep messages logically together.
+
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
event_source (string)
+
+ #
+ When logging to event log is enabled, this parameter
+ determines the program name used to identify
+ PostgreSQL messages in
+ the log. The default is PostgreSQL.
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
log_min_messages (enum)
+
+ #
+ Controls which message
+ levels are written to the server log.
+ Valid values are DEBUG5, DEBUG4,
+ DEBUG3, DEBUG2, DEBUG1,
+ INFO, NOTICE, WARNING,
+ ERROR, LOG, FATAL, and
+ PANIC. Each level includes all the levels that
+ follow it. The later the level, the fewer messages are sent
+ to the log. The default is WARNING. Note that
+ LOG has a different rank here than in
+ client_min_messages.
+ Only superusers and users with the appropriate SET
+ privilege can change this setting.
+
log_min_error_statement (enum)
+
+ #
+ Controls which SQL statements that cause an error
+ condition are recorded in the server log. The current
+ SQL statement is included in the log entry for any message of
+ the specified
+ severity
+ or higher.
+ Valid values are DEBUG5,
+ DEBUG4, DEBUG3,
+ DEBUG2, DEBUG1,
+ INFO, NOTICE,
+ WARNING, ERROR,
+ LOG,
+ FATAL, and PANIC.
+ The default is ERROR, which means statements
+ causing errors, log messages, fatal errors, or panics will be logged.
+ To effectively turn off logging of failing statements,
+ set this parameter to PANIC.
+ Only superusers and users with the appropriate SET
+ privilege can change this setting.
+
log_min_duration_statement (integer)
+
+ #
+ Causes the duration of each completed statement to be logged
+ if the statement ran for at least the specified amount of time.
+ For example, if you set it to 250ms
+ then all SQL statements that run 250ms or longer will be
+ logged. Enabling this parameter can be helpful in tracking down
+ unoptimized queries in your applications.
+ If this value is specified without units, it is taken as milliseconds.
+ Setting this to zero prints all statement durations.
+ -1 (the default) disables logging statement
+ durations.
+ Only superusers and users with the appropriate SET
+ privilege can change this setting.
+
+ This overrides log_min_duration_sample,
+ meaning that queries with duration exceeding this setting are not
+ subject to sampling and are always logged.
+
+ For clients using extended query protocol, durations of the Parse,
+ Bind, and Execute steps are logged independently.
+
Note
+ When using this option together with
+ log_statement,
+ the text of statements that are logged because of
+ log_statement will not be repeated in the
+ duration log message.
+ If you are not using syslog, it is recommended
+ that you log the PID or session ID using
+ log_line_prefix
+ so that you can link the statement message to the later
+ duration message using the process ID or session ID.
+
log_min_duration_sample (integer)
+
+ #
+ Allows sampling the duration of completed statements that ran for
+ at least the specified amount of time. This produces the same
+ kind of log entries as
+ log_min_duration_statement, but only for a
+ subset of the executed statements, with sample rate controlled by
+ log_statement_sample_rate.
+ For example, if you set it to 100ms then all
+ SQL statements that run 100ms or longer will be considered for
+ sampling. Enabling this parameter can be helpful when the
+ traffic is too high to log all queries.
+ If this value is specified without units, it is taken as milliseconds.
+ Setting this to zero samples all statement durations.
+ -1 (the default) disables sampling statement
+ durations.
+ Only superusers and users with the appropriate SET
+ privilege can change this setting.
+
+ This setting has lower priority
+ than log_min_duration_statement, meaning that
+ statements with durations
+ exceeding log_min_duration_statement are not
+ subject to sampling and are always logged.
+
+ Other notes for log_min_duration_statement
+ apply also to this setting.
+
log_statement_sample_rate (floating point)
+
+ #
+ Determines the fraction of statements with duration exceeding
+ log_min_duration_sample that will be logged.
+ Sampling is stochastic, for example 0.5 means
+ there is statistically one chance in two that any given statement
+ will be logged.
+ The default is 1.0, meaning to log all sampled
+ statements.
+ Setting this to zero disables sampled statement-duration logging,
+ the same as setting
+ log_min_duration_sample to
+ -1.
+ Only superusers and users with the appropriate SET
+ privilege can change this setting.
+
log_transaction_sample_rate (floating point)
+
+ #
+ Sets the fraction of transactions whose statements are all logged,
+ in addition to statements logged for other reasons. It applies to
+ each new transaction regardless of its statements' durations.
+ Sampling is stochastic, for example 0.1 means
+ there is statistically one chance in ten that any given transaction
+ will be logged.
+ log_transaction_sample_rate can be helpful to
+ construct a sample of transactions.
+ The default is 0, meaning not to log
+ statements from any additional transactions. Setting this
+ to 1 logs all statements of all transactions.
+ Only superusers and users with the appropriate SET
+ privilege can change this setting.
+
Note
+ Like all statement-logging options, this option can add significant
+ overhead.
+
log_startup_progress_interval (integer)
+
+ #
+ Sets the amount of time after which the startup process will log
+ a message about a long-running operation that is still in progress,
+ as well as the interval between further progress messages for that
+ operation. The default is 10 seconds. A setting of 0
+ disables the feature. If this value is specified without units,
+ it is taken as milliseconds. This setting is applied separately to
+ each operation.
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
+ For example, if syncing the data directory takes 25 seconds and
+ thereafter resetting unlogged relations takes 8 seconds, and if this
+ setting has the default value of 10 seconds, then a messages will be
+ logged for syncing the data directory after it has been in progress
+ for 10 seconds and again after it has been in progress for 20 seconds,
+ but nothing will be logged for resetting unlogged relations.
+
+ Table 20.2 explains the message
+ severity levels used by PostgreSQL. If logging output
+ is sent to syslog or Windows'
+ eventlog, the severity levels are translated
+ as shown in the table.
+
Table 20.2. Message Severity Levels
| Severity | Usage | syslog | eventlog |
|---|
DEBUG1 .. DEBUG5 | Provides successively-more-detailed information for use by
+ developers. | DEBUG | INFORMATION |
INFO | Provides information implicitly requested by the user,
+ e.g., output from VACUUM VERBOSE. | INFO | INFORMATION |
NOTICE | Provides information that might be helpful to users, e.g.,
+ notice of truncation of long identifiers. | NOTICE | INFORMATION |
WARNING | Provides warnings of likely problems, e.g., COMMIT
+ outside a transaction block. | NOTICE | WARNING |
ERROR | Reports an error that caused the current command to
+ abort. | WARNING | ERROR |
LOG | Reports information of interest to administrators, e.g.,
+ checkpoint activity. | INFO | INFORMATION |
FATAL | Reports an error that caused the current session to
+ abort. | ERR | ERROR |
PANIC | Reports an error that caused all database sessions to abort. | CRIT | ERROR |
Note
+ What you choose to log can have security implications; see
+ Section 25.3.
+
application_name (string)
+
+ #
+ The application_name can be any string of less than
+ NAMEDATALEN characters (64 characters in a standard build).
+ It is typically set by an application upon connection to the server.
+ The name will be displayed in the pg_stat_activity view
+ and included in CSV log entries. It can also be included in regular
+ log entries via the log_line_prefix parameter.
+ Only printable ASCII characters may be used in the
+ application_name value.
+ Other characters are replaced with C-style hexadecimal escapes.
+
debug_print_parse (boolean)
+
+
debug_print_rewritten (boolean)
+
+
debug_print_plan (boolean)
+
+ #
+ These parameters enable various debugging output to be emitted.
+ When set, they print the resulting parse tree, the query rewriter
+ output, or the execution plan for each executed query.
+ These messages are emitted at LOG message level, so by
+ default they will appear in the server log but will not be sent to the
+ client. You can change that by adjusting
+ client_min_messages and/or
+ log_min_messages.
+ These parameters are off by default.
+
debug_pretty_print (boolean)
+
+ #
+ When set, debug_pretty_print indents the messages
+ produced by debug_print_parse,
+ debug_print_rewritten, or
+ debug_print_plan. This results in more readable
+ but much longer output than the “compact” format used when
+ it is off. It is on by default.
+
log_autovacuum_min_duration (integer)
+
+ #
+ Causes each action executed by autovacuum to be logged if it ran for at
+ least the specified amount of time. Setting this to zero logs
+ all autovacuum actions. -1 disables logging autovacuum
+ actions. If this value is specified without units, it is taken as milliseconds.
+ For example, if you set this to
+ 250ms then all automatic vacuums and analyzes that run
+ 250ms or longer will be logged. In addition, when this parameter is
+ set to any value other than -1, a message will be
+ logged if an autovacuum action is skipped due to a conflicting lock or a
+ concurrently dropped relation. The default is 10min.
+ Enabling this parameter can be helpful in tracking autovacuum activity.
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line; but the setting can be overridden for
+ individual tables by changing table storage parameters.
+
log_checkpoints (boolean)
+
+ #
+ Causes checkpoints and restartpoints to be logged in the server log.
+ Some statistics are included in the log messages, including the number
+ of buffers written and the time spent writing them.
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line. The default is on.
+
log_connections (boolean)
+
+ #
+ Causes each attempted connection to the server to be logged,
+ as well as successful completion of both client authentication (if
+ necessary) and authorization.
+ Only superusers and users with the appropriate SET
+ privilege can change this parameter at session start,
+ and it cannot be changed at all within a session.
+ The default is off.
+
Note
+ Some client programs, like psql, attempt
+ to connect twice while determining if a password is required, so
+ duplicate “connection received” messages do not
+ necessarily indicate a problem.
+
log_disconnections (boolean)
+
+ #
+ Causes session terminations to be logged. The log output
+ provides information similar to log_connections,
+ plus the duration of the session.
+ Only superusers and users with the appropriate SET
+ privilege can change this parameter at session start,
+ and it cannot be changed at all within a session.
+ The default is off.
+
log_duration (boolean)
+
+ #
+ Causes the duration of every completed statement to be logged.
+ The default is off.
+ Only superusers and users with the appropriate SET
+ privilege can change this setting.
+
+ For clients using extended query protocol, durations of the Parse,
+ Bind, and Execute steps are logged independently.
+
Note
+ The difference between enabling log_duration and setting
+ log_min_duration_statement to zero is that
+ exceeding log_min_duration_statement forces the text of
+ the query to be logged, but this option doesn't. Thus, if
+ log_duration is on and
+ log_min_duration_statement has a positive value, all
+ durations are logged but the query text is included only for
+ statements exceeding the threshold. This behavior can be useful for
+ gathering statistics in high-load installations.
+
log_error_verbosity (enum)
+
+ #
+ Controls the amount of detail written in the server log for each
+ message that is logged. Valid values are TERSE,
+ DEFAULT, and VERBOSE, each adding more
+ fields to displayed messages. TERSE excludes
+ the logging of DETAIL, HINT,
+ QUERY, and CONTEXT error information.
+ VERBOSE output includes the SQLSTATE error
+ code (see also Appendix A) and the source code file name, function name,
+ and line number that generated the error.
+ Only superusers and users with the appropriate SET
+ privilege can change this setting.
+
log_hostname (boolean)
+
+ #
+ By default, connection log messages only show the IP address of the
+ connecting host. Turning this parameter on causes logging of the
+ host name as well. Note that depending on your host name resolution
+ setup this might impose a non-negligible performance penalty.
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
log_line_prefix (string)
+
+ #
+ This is a printf-style string that is output at the
+ beginning of each log line.
+ % characters begin “escape sequences”
+ that are replaced with status information as outlined below.
+ Unrecognized escapes are ignored. Other
+ characters are copied straight to the log line. Some escapes are
+ only recognized by session processes, and will be treated as empty by
+ background processes such as the main server process. Status
+ information may be aligned either left or right by specifying a
+ numeric literal after the % and before the option. A negative
+ value will cause the status information to be padded on the
+ right with spaces to give it a minimum width, whereas a positive
+ value will pad on the left. Padding can be useful to aid human
+ readability in log files.
+
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line. The default is
+ '%m [%p] ' which logs a time stamp and the process ID.
+
+ The backend type corresponds to the column
+ backend_type in the view
+
+ pg_stat_activity,
+ but additional types can appear
+ in the log that don't show in that view.
+
+ The %c escape prints a quasi-unique session identifier,
+ consisting of two 4-byte hexadecimal numbers (without leading zeros)
+ separated by a dot. The numbers are the process start time and the
+ process ID, so %c can also be used as a space saving way
+ of printing those items. For example, to generate the session
+ identifier from pg_stat_activity, use this query:
+
+SELECT to_hex(trunc(EXTRACT(EPOCH FROM backend_start))::integer) || '.' ||
+ to_hex(pid)
+FROM pg_stat_activity;
+
+
+
Tip
+ If you set a nonempty value for log_line_prefix,
+ you should usually make its last character be a space, to provide
+ visual separation from the rest of the log line. A punctuation
+ character can be used too.
+
Tip
+ Syslog produces its own
+ time stamp and process ID information, so you probably do not want to
+ include those escapes if you are logging to syslog.
+
Tip
+ The %q escape is useful when including information that is
+ only available in session (backend) context like user or database
+ name. For example:
+
+log_line_prefix = '%m [%p] %q%u@%d/%a '
+
+
Note
+ The %Q escape always reports a zero identifier
+ for lines output by log_statement because
+ log_statement generates output before an
+ identifier can be calculated, including invalid statements for
+ which an identifier cannot be calculated.
+
log_lock_waits (boolean)
+
+ #
+ Controls whether a log message is produced when a session waits
+ longer than deadlock_timeout to acquire a
+ lock. This is useful in determining if lock waits are causing
+ poor performance. The default is off.
+ Only superusers and users with the appropriate SET
+ privilege can change this setting.
+
log_recovery_conflict_waits (boolean)
+
+ #
+ Controls whether a log message is produced when the startup process
+ waits longer than deadlock_timeout
+ for recovery conflicts. This is useful in determining if recovery
+ conflicts prevent the recovery from applying WAL.
+
+ The default is off. This parameter can only be set
+ in the postgresql.conf file or on the server
+ command line.
+
log_parameter_max_length (integer)
+
+ #
+ If greater than zero, each bind parameter value logged with a
+ non-error statement-logging message is trimmed to this many bytes.
+ Zero disables logging of bind parameters for non-error statement logs.
+ -1 (the default) allows bind parameters to be
+ logged in full.
+ If this value is specified without units, it is taken as bytes.
+ Only superusers and users with the appropriate SET
+ privilege can change this setting.
+
+ This setting only affects log messages printed as a result of
+ log_statement,
+ log_duration, and related settings. Non-zero
+ values of this setting add some overhead, particularly if parameters
+ are sent in binary form, since then conversion to text is required.
+
log_parameter_max_length_on_error (integer)
+
+ #
+ If greater than zero, each bind parameter value reported in error
+ messages is trimmed to this many bytes.
+ Zero (the default) disables including bind parameters in error
+ messages.
+ -1 allows bind parameters to be printed in full.
+ If this value is specified without units, it is taken as bytes.
+
+ Non-zero values of this setting add overhead, as
+ PostgreSQL will need to store textual
+ representations of parameter values in memory at the start of each
+ statement, whether or not an error eventually occurs. The overhead
+ is greater when bind parameters are sent in binary form than when
+ they are sent as text, since the former case requires data
+ conversion while the latter only requires copying the string.
+
log_statement (enum)
+
+ #
+ Controls which SQL statements are logged. Valid values are
+ none (off), ddl, mod, and
+ all (all statements). ddl logs all data definition
+ statements, such as CREATE, ALTER, and
+ DROP statements. mod logs all
+ ddl statements, plus data-modifying statements
+ such as INSERT,
+ UPDATE, DELETE, TRUNCATE,
+ and COPY FROM.
+ PREPARE, EXECUTE, and
+ EXPLAIN ANALYZE statements are also logged if their
+ contained command is of an appropriate type. For clients using
+ extended query protocol, logging occurs when an Execute message
+ is received, and values of the Bind parameters are included
+ (with any embedded single-quote marks doubled).
+
+ The default is none.
+ Only superusers and users with the appropriate SET
+ privilege can change this setting.
+
Note
+ Statements that contain simple syntax errors are not logged
+ even by the log_statement = all setting,
+ because the log message is emitted only after basic parsing has
+ been done to determine the statement type. In the case of extended
+ query protocol, this setting likewise does not log statements that
+ fail before the Execute phase (i.e., during parse analysis or
+ planning). Set log_min_error_statement to
+ ERROR (or lower) to log such statements.
+
+ Logged statements might reveal sensitive data and even contain
+ plaintext passwords.
+
log_replication_commands (boolean)
+
+ #
+ Causes each replication command to be logged in the server log.
+ See Section 55.4 for more information about
+ replication command. The default value is off.
+ Only superusers and users with the appropriate SET
+ privilege can change this setting.
+
log_temp_files (integer)
+
+ #
+ Controls logging of temporary file names and sizes.
+ Temporary files can be
+ created for sorts, hashes, and temporary query results.
+ If enabled by this setting, a log entry is emitted for each
+ temporary file, with the file size specified in bytes, when it is deleted.
+ A value of zero logs all temporary file information, while positive
+ values log only files whose size is greater than or equal to
+ the specified amount of data.
+ If this value is specified without units, it is taken as kilobytes.
+ The default setting is -1, which disables such logging.
+ Only superusers and users with the appropriate SET
+ privilege can change this setting.
+
log_timezone (string)
+
+ #
+ Sets the time zone used for timestamps written in the server log.
+ Unlike TimeZone, this value is cluster-wide,
+ so that all sessions will report timestamps consistently.
+ The built-in default is GMT, but that is typically
+ overridden in postgresql.conf; initdb
+ will install a setting there corresponding to its system environment.
+ See Section 8.5.3 for more information.
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
20.8.4. Using CSV-Format Log Output #
+ Including csvlog in the log_destination list
+ provides a convenient way to import log files into a database table.
+ This option emits log lines in comma-separated-values
+ (CSV) format,
+ with these columns:
+ time stamp with milliseconds,
+ user name,
+ database name,
+ process ID,
+ client host:port number,
+ session ID,
+ per-session line number,
+ command tag,
+ session start time,
+ virtual transaction ID,
+ regular transaction ID,
+ error severity,
+ SQLSTATE code,
+ error message,
+ error message detail,
+ hint,
+ internal query that led to the error (if any),
+ character count of the error position therein,
+ error context,
+ user query that led to the error (if any and enabled by
+ log_min_error_statement),
+ character count of the error position therein,
+ location of the error in the PostgreSQL source code
+ (if log_error_verbosity is set to verbose),
+ application name, backend type, process ID of parallel group leader,
+ and query id.
+ Here is a sample table definition for storing CSV-format log output:
+
+
+CREATE TABLE postgres_log
+(
+ log_time timestamp(3) with time zone,
+ user_name text,
+ database_name text,
+ process_id integer,
+ connection_from text,
+ session_id text,
+ session_line_num bigint,
+ command_tag text,
+ session_start_time timestamp with time zone,
+ virtual_transaction_id text,
+ transaction_id bigint,
+ error_severity text,
+ sql_state_code text,
+ message text,
+ detail text,
+ hint text,
+ internal_query text,
+ internal_query_pos integer,
+ context text,
+ query text,
+ query_pos integer,
+ location text,
+ application_name text,
+ backend_type text,
+ leader_pid integer,
+ query_id bigint,
+ PRIMARY KEY (session_id, session_line_num)
+);
+
+
+ To import a log file into this table, use the COPY FROM
+ command:
+
+
+COPY postgres_log FROM '/full/path/to/logfile.csv' WITH csv;
+
+ It is also possible to access the file as a foreign table, using
+ the supplied file_fdw module.
+
+ There are a few things you need to do to simplify importing CSV log
+ files:
+
+
+ Set log_filename and
+ log_rotation_age to provide a consistent,
+ predictable naming scheme for your log files. This lets you
+ predict what the file name will be and know when an individual log
+ file is complete and therefore ready to be imported.
+
+ Set log_rotation_size to 0 to disable
+ size-based log rotation, as it makes the log file name difficult
+ to predict.
+
+ Set log_truncate_on_rotation to on so
+ that old log data isn't mixed with the new in the same file.
+
+ The table definition above includes a primary key specification.
+ This is useful to protect against accidentally importing the same
+ information twice. The COPY command commits all of the
+ data it imports at one time, so any error will cause the entire
+ import to fail. If you import a partial log file and later import
+ the file again when it is complete, the primary key violation will
+ cause the import to fail. Wait until the log is complete and
+ closed before importing. This procedure will also protect against
+ accidentally importing a partial line that hasn't been completely
+ written, which would also cause COPY to fail.
+
+
20.8.5. Using JSON-Format Log Output #
+ Including jsonlog in the
+ log_destination list provides a convenient way to
+ import log files into many different programs. This option emits log
+ lines in JSON format.
+
+ String fields with null values are excluded from output.
+ Additional fields may be added in the future. User applications that
+ process jsonlog output should ignore unknown fields.
+
+ Each log line is serialized as a JSON object with the set of keys and
+ their associated values shown in Table 20.3.
+
Table 20.3. Keys and Values of JSON Log Entries
| Key name | Type | Description |
|---|
timestamp | string | Time stamp with milliseconds |
user | string | User name |
dbname | string | Database name |
pid | number | Process ID |
remote_host | string | Client host |
remote_port | number | Client port |
session_id | string | Session ID |
line_num | number | Per-session line number |
ps | string | Current ps display |
session_start | string | Session start time |
vxid | string | Virtual transaction ID |
txid | string | Regular transaction ID |
error_severity | string | Error severity |
state_code | string | SQLSTATE code |
message | string | Error message |
detail | string | Error message detail |
hint | string | Error message hint |
internal_query | string | Internal query that led to the error |
internal_position | number | Cursor index into internal query |
context | string | Error context |
statement | string | Client-supplied query string |
cursor_position | number | Cursor index into query string |
func_name | string | Error location function name |
file_name | string | File name of error location |
file_line_num | number | File line number of the error location |
application_name | string | Client application name |
backend_type | string | Type of backend |
leader_pid | number | Process ID of leader for active parallel workers |
query_id | number | Query ID |
+ These settings control how process titles of server processes are
+ modified. Process titles are typically viewed using programs like
+ ps or, on Windows, Process Explorer.
+ See Section 28.1 for details.
+
cluster_name (string)
+
+ #
+ Sets a name that identifies this database cluster (instance) for
+ various purposes. The cluster name appears in the process title for
+ all server processes in this cluster. Moreover, it is the default
+ application name for a standby connection (see synchronous_standby_names.)
+
+ The name can be any string of less
+ than NAMEDATALEN characters (64 characters in a standard
+ build). Only printable ASCII characters may be used in the
+ cluster_name value.
+ Other characters are replaced with C-style hexadecimal escapes.
+ No name is shown if this parameter is set to the empty string
+ '' (which is the default).
+ This parameter can only be set at server start.
+
update_process_title (boolean)
+
+ #
+ Enables updating of the process title every time a new SQL command
+ is received by the server.
+ This setting defaults to on on most platforms, but it
+ defaults to off on Windows due to that platform's larger
+ overhead for updating the process title.
+ Only superusers and users with the appropriate SET
+ privilege can change this setting.
+
+ The following “parameters” are read-only.
+ As such, they have been excluded from the sample
+ postgresql.conf file. These options report
+ various aspects of PostgreSQL behavior
+ that might be of interest to certain applications, particularly
+ administrative front-ends.
+ Most of them are determined when PostgreSQL
+ is compiled or when it is installed.
+
block_size (integer)
+
+ #
+ Reports the size of a disk block. It is determined by the value
+ of BLCKSZ when building the server. The default
+ value is 8192 bytes. The meaning of some configuration
+ variables (such as shared_buffers) is
+ influenced by block_size. See Section 20.4 for information.
+
data_checksums (boolean)
+
+ #
+ Reports whether data checksums are enabled for this cluster.
+ See data checksums for more information.
+
data_directory_mode (integer)
+
+ #
+ On Unix systems this parameter reports the permissions the data
+ directory (defined by data_directory)
+ had at server startup.
+ (On Microsoft Windows this parameter will always display
+ 0700.) See
+ group access for more information.
+
debug_assertions (boolean)
+
+ #
+ Reports whether PostgreSQL has been built
+ with assertions enabled. That is the case if the
+ macro USE_ASSERT_CHECKING is defined
+ when PostgreSQL is built (accomplished
+ e.g., by the configure option
+ --enable-cassert). By
+ default PostgreSQL is built without
+ assertions.
+
integer_datetimes (boolean)
+
+ #
+ Reports whether PostgreSQL was built with support for
+ 64-bit-integer dates and times. As of PostgreSQL 10,
+ this is always on.
+
in_hot_standby (boolean)
+
+ #
+ Reports whether the server is currently in hot standby mode. When
+ this is on, all transactions are forced to be
+ read-only. Within a session, this can change only if the server is
+ promoted to be primary. See Section 27.4 for more
+ information.
+
max_function_args (integer)
+
+ #
+ Reports the maximum number of function arguments. It is determined by
+ the value of FUNC_MAX_ARGS when building the server. The
+ default value is 100 arguments.
+
max_identifier_length (integer)
+
+ #
+ Reports the maximum identifier length. It is determined as one
+ less than the value of NAMEDATALEN when building
+ the server. The default value of NAMEDATALEN is
+ 64; therefore the default
+ max_identifier_length is 63 bytes, which
+ can be less than 63 characters when using multibyte encodings.
+
max_index_keys (integer)
+
+ #
+ Reports the maximum number of index keys. It is determined by
+ the value of INDEX_MAX_KEYS when building the server. The
+ default value is 32 keys.
+
segment_size (integer)
+
+ #
+ Reports the number of blocks (pages) that can be stored within a file
+ segment. It is determined by the value of RELSEG_SIZE
+ when building the server. The maximum size of a segment file in bytes
+ is equal to segment_size multiplied by
+ block_size; by default this is 1GB.
+
server_encoding (string)
+
+
+ #
+ Reports the database encoding (character set).
+ It is determined when the database is created. Ordinarily,
+ clients need only be concerned with the value of client_encoding.
+
server_version (string)
+
+ #
+ Reports the version number of the server. It is determined by the
+ value of PG_VERSION when building the server.
+
server_version_num (integer)
+
+ #
+ Reports the version number of the server as an integer. It is determined
+ by the value of PG_VERSION_NUM when building the server.
+
shared_memory_size (integer)
+
+ #
+ Reports the size of the main shared memory area, rounded up to the
+ nearest megabyte.
+
shared_memory_size_in_huge_pages (integer)
+
+ #
+ Reports the number of huge pages that are needed for the main shared
+ memory area based on the specified huge_page_size.
+ If huge pages are not supported, this will be -1.
+
+ This setting is supported only on Linux. It
+ is always set to -1 on other platforms. For more
+ details about using huge pages on Linux, see
+ Section 19.4.5.
+
ssl_library (string)
+
+ #
+ Reports the name of the SSL library that this
+ PostgreSQL server was built with (even if
+ SSL is not currently configured or in use on this instance), for
+ example OpenSSL, or an empty string if none.
+
wal_block_size (integer)
+
+ #
+ Reports the size of a WAL disk block. It is determined by the value
+ of XLOG_BLCKSZ when building the server. The default value
+ is 8192 bytes.
+
wal_segment_size (integer)
+
+ #
+ Reports the size of write ahead log segments. The default value is
+ 16MB. See Section 30.5 for more information.
+
20.7.1. Planner Method Configuration #
+ These configuration parameters provide a crude method of
+ influencing the query plans chosen by the query optimizer. If
+ the default plan chosen by the optimizer for a particular query
+ is not optimal, a temporary solution is to use one
+ of these configuration parameters to force the optimizer to
+ choose a different plan.
+ Better ways to improve the quality of the
+ plans chosen by the optimizer include adjusting the planner cost
+ constants (see Section 20.7.2),
+ running ANALYZE manually, increasing
+ the value of the default_statistics_target configuration parameter,
+ and increasing the amount of statistics collected for
+ specific columns using ALTER TABLE SET
+ STATISTICS.
+
enable_async_append (boolean)
+
+ #
+ Enables or disables the query planner's use of async-aware
+ append plan types. The default is on.
+
enable_bitmapscan (boolean)
+
+
+ #
+ Enables or disables the query planner's use of bitmap-scan plan
+ types. The default is on.
+
enable_gathermerge (boolean)
+
+ #
+ Enables or disables the query planner's use of gather
+ merge plan types. The default is on.
+
enable_hashagg (boolean)
+
+ #
+ Enables or disables the query planner's use of hashed
+ aggregation plan types. The default is on.
+
enable_hashjoin (boolean)
+
+ #
+ Enables or disables the query planner's use of hash-join plan
+ types. The default is on.
+
enable_incremental_sort (boolean)
+
+ #
+ Enables or disables the query planner's use of incremental sort steps.
+ The default is on.
+
enable_indexscan (boolean)
+
+
+ #
+ Enables or disables the query planner's use of index-scan plan
+ types. The default is on.
+
enable_indexonlyscan (boolean)
+
+ #
+ Enables or disables the query planner's use of index-only-scan plan
+ types (see Section 11.9).
+ The default is on.
+
enable_material (boolean)
+
+ #
+ Enables or disables the query planner's use of materialization.
+ It is impossible to suppress materialization entirely,
+ but turning this variable off prevents the planner from inserting
+ materialize nodes except in cases where it is required for correctness.
+ The default is on.
+
enable_memoize (boolean)
+
+ #
+ Enables or disables the query planner's use of memoize plans for
+ caching results from parameterized scans inside nested-loop joins.
+ This plan type allows scans to the underlying plans to be skipped when
+ the results for the current parameters are already in the cache. Less
+ commonly looked up results may be evicted from the cache when more
+ space is required for new entries. The default is
+ on.
+
enable_mergejoin (boolean)
+
+ #
+ Enables or disables the query planner's use of merge-join plan
+ types. The default is on.
+
enable_nestloop (boolean)
+
+ #
+ Enables or disables the query planner's use of nested-loop join
+ plans. It is impossible to suppress nested-loop joins entirely,
+ but turning this variable off discourages the planner from using
+ one if there are other methods available. The default is
+ on.
+
enable_parallel_append (boolean)
+
+ #
+ Enables or disables the query planner's use of parallel-aware
+ append plan types. The default is on.
+
enable_parallel_hash (boolean)
+
+ #
+ Enables or disables the query planner's use of hash-join plan
+ types with parallel hash. Has no effect if hash-join plans are not
+ also enabled. The default is on.
+
enable_partition_pruning (boolean)
+
+ #
+ Enables or disables the query planner's ability to eliminate a
+ partitioned table's partitions from query plans. This also controls
+ the planner's ability to generate query plans which allow the query
+ executor to remove (ignore) partitions during query execution. The
+ default is on.
+ See Section 5.11.4 for details.
+
enable_partitionwise_join (boolean)
+
+ #
+ Enables or disables the query planner's use of partitionwise join,
+ which allows a join between partitioned tables to be performed by
+ joining the matching partitions. Partitionwise join currently applies
+ only when the join conditions include all the partition keys, which
+ must be of the same data type and have one-to-one matching sets of
+ child partitions. Because partitionwise join planning can use
+ significantly more CPU time and memory during planning, the default is
+ off.
+
enable_partitionwise_aggregate (boolean)
+
+ #
+ Enables or disables the query planner's use of partitionwise grouping
+ or aggregation, which allows grouping or aggregation on partitioned
+ tables to be performed separately for each partition. If the
+ GROUP BY clause does not include the partition
+ keys, only partial aggregation can be performed on a per-partition
+ basis, and finalization must be performed later. Because
+ partitionwise grouping or aggregation can use significantly more CPU
+ time and memory during planning, the default is
+ off.
+
enable_presorted_aggregate (boolean)
+
+ #
+ Controls if the query planner will produce a plan which will provide
+ rows which are presorted in the order required for the query's
+ ORDER BY / DISTINCT aggregate
+ functions. When disabled, the query planner will produce a plan which
+ will always require the executor to perform a sort before performing
+ aggregation of each aggregate function containing an
+ ORDER BY or DISTINCT clause.
+ When enabled, the planner will try to produce a more efficient plan
+ which provides input to the aggregate functions which is presorted in
+ the order they require for aggregation. The default value is
+ on.
+
enable_seqscan (boolean)
+
+
+ #
+ Enables or disables the query planner's use of sequential scan
+ plan types. It is impossible to suppress sequential scans
+ entirely, but turning this variable off discourages the planner
+ from using one if there are other methods available. The
+ default is on.
+
enable_sort (boolean)
+
+ #
+ Enables or disables the query planner's use of explicit sort
+ steps. It is impossible to suppress explicit sorts entirely,
+ but turning this variable off discourages the planner from
+ using one if there are other methods available. The default
+ is on.
+
enable_tidscan (boolean)
+
+ #
+ Enables or disables the query planner's use of TID
+ scan plan types. The default is on.
+
20.7.2. Planner Cost Constants #
+ The cost variables described in this section are measured
+ on an arbitrary scale. Only their relative values matter, hence
+ scaling them all up or down by the same factor will result in no change
+ in the planner's choices. By default, these cost variables are based on
+ the cost of sequential page fetches; that is,
+ seq_page_cost is conventionally set to 1.0
+ and the other cost variables are set with reference to that. But
+ you can use a different scale if you prefer, such as actual execution
+ times in milliseconds on a particular machine.
+
Note
+ Unfortunately, there is no well-defined method for determining ideal
+ values for the cost variables. They are best treated as averages over
+ the entire mix of queries that a particular installation will receive. This
+ means that changing them on the basis of just a few experiments is very
+ risky.
+
seq_page_cost (floating point)
+
+ #
+ Sets the planner's estimate of the cost of a disk page fetch
+ that is part of a series of sequential fetches. The default is 1.0.
+ This value can be overridden for tables and indexes in a particular
+ tablespace by setting the tablespace parameter of the same name
+ (see ALTER TABLESPACE).
+
random_page_cost (floating point)
+
+ #
+ Sets the planner's estimate of the cost of a
+ non-sequentially-fetched disk page. The default is 4.0.
+ This value can be overridden for tables and indexes in a particular
+ tablespace by setting the tablespace parameter of the same name
+ (see ALTER TABLESPACE).
+
+ Reducing this value relative to seq_page_cost
+ will cause the system to prefer index scans; raising it will
+ make index scans look relatively more expensive. You can raise
+ or lower both values together to change the importance of disk I/O
+ costs relative to CPU costs, which are described by the following
+ parameters.
+
+ Random access to mechanical disk storage is normally much more expensive
+ than four times sequential access. However, a lower default is used
+ (4.0) because the majority of random accesses to disk, such as indexed
+ reads, are assumed to be in cache. The default value can be thought of
+ as modeling random access as 40 times slower than sequential, while
+ expecting 90% of random reads to be cached.
+
+ If you believe a 90% cache rate is an incorrect assumption
+ for your workload, you can increase random_page_cost to better
+ reflect the true cost of random storage reads. Correspondingly,
+ if your data is likely to be completely in cache, such as when
+ the database is smaller than the total server memory, decreasing
+ random_page_cost can be appropriate. Storage that has a low random
+ read cost relative to sequential, e.g., solid-state drives, might
+ also be better modeled with a lower value for random_page_cost,
+ e.g., 1.1.
+
Tip
+ Although the system will let you set random_page_cost to
+ less than seq_page_cost, it is not physically sensible
+ to do so. However, setting them equal makes sense if the database
+ is entirely cached in RAM, since in that case there is no penalty
+ for touching pages out of sequence. Also, in a heavily-cached
+ database you should lower both values relative to the CPU parameters,
+ since the cost of fetching a page already in RAM is much smaller
+ than it would normally be.
+
cpu_tuple_cost (floating point)
+
+ #
+ Sets the planner's estimate of the cost of processing
+ each row during a query.
+ The default is 0.01.
+
cpu_index_tuple_cost (floating point)
+
+ #
+ Sets the planner's estimate of the cost of processing
+ each index entry during an index scan.
+ The default is 0.005.
+
cpu_operator_cost (floating point)
+
+ #
+ Sets the planner's estimate of the cost of processing each
+ operator or function executed during a query.
+ The default is 0.0025.
+
parallel_setup_cost (floating point)
+
+ #
+ Sets the planner's estimate of the cost of launching parallel worker
+ processes.
+ The default is 1000.
+
parallel_tuple_cost (floating point)
+
+ #
+ Sets the planner's estimate of the cost of transferring one tuple
+ from a parallel worker process to another process.
+ The default is 0.1.
+
min_parallel_table_scan_size (integer)
+
+ #
+ Sets the minimum amount of table data that must be scanned in order
+ for a parallel scan to be considered. For a parallel sequential scan,
+ the amount of table data scanned is always equal to the size of the
+ table, but when indexes are used the amount of table data
+ scanned will normally be less.
+ If this value is specified without units, it is taken as blocks,
+ that is BLCKSZ bytes, typically 8kB.
+ The default is 8 megabytes (8MB).
+
min_parallel_index_scan_size (integer)
+
+ #
+ Sets the minimum amount of index data that must be scanned in order
+ for a parallel scan to be considered. Note that a parallel index scan
+ typically won't touch the entire index; it is the number of pages
+ which the planner believes will actually be touched by the scan which
+ is relevant. This parameter is also used to decide whether a
+ particular index can participate in a parallel vacuum. See
+ VACUUM.
+ If this value is specified without units, it is taken as blocks,
+ that is BLCKSZ bytes, typically 8kB.
+ The default is 512 kilobytes (512kB).
+
effective_cache_size (integer)
+
+ #
+ Sets the planner's assumption about the effective size of the
+ disk cache that is available to a single query. This is
+ factored into estimates of the cost of using an index; a
+ higher value makes it more likely index scans will be used, a
+ lower value makes it more likely sequential scans will be
+ used. When setting this parameter you should consider both
+ PostgreSQL's shared buffers and the
+ portion of the kernel's disk cache that will be used for
+ PostgreSQL data files, though some
+ data might exist in both places. Also, take
+ into account the expected number of concurrent queries on different
+ tables, since they will have to share the available
+ space. This parameter has no effect on the size of shared
+ memory allocated by PostgreSQL, nor
+ does it reserve kernel disk cache; it is used only for estimation
+ purposes. The system also does not assume data remains in
+ the disk cache between queries.
+ If this value is specified without units, it is taken as blocks,
+ that is BLCKSZ bytes, typically 8kB.
+ The default is 4 gigabytes (4GB).
+ (If BLCKSZ is not 8kB, the default value scales
+ proportionally to it.)
+
jit_above_cost (floating point)
+
+ #
+ Sets the query cost above which JIT compilation is activated, if
+ enabled (see Chapter 32).
+ Performing JIT costs planning time but can
+ accelerate query execution.
+ Setting this to -1 disables JIT compilation.
+ The default is 100000.
+
jit_inline_above_cost (floating point)
+
+ #
+ Sets the query cost above which JIT compilation attempts to inline
+ functions and operators. Inlining adds planning time, but can
+ improve execution speed. It is not meaningful to set this to less
+ than jit_above_cost.
+ Setting this to -1 disables inlining.
+ The default is 500000.
+
jit_optimize_above_cost (floating point)
+
+ #
+ Sets the query cost above which JIT compilation applies expensive
+ optimizations. Such optimization adds planning time, but can improve
+ execution speed. It is not meaningful to set this to less
+ than jit_above_cost, and it is unlikely to be
+ beneficial to set it to more
+ than jit_inline_above_cost.
+ Setting this to -1 disables expensive optimizations.
+ The default is 500000.
+
20.7.3. Genetic Query Optimizer #
+ The genetic query optimizer (GEQO) is an algorithm that does query
+ planning using heuristic searching. This reduces planning time for
+ complex queries (those joining many relations), at the cost of producing
+ plans that are sometimes inferior to those found by the normal
+ exhaustive-search algorithm.
+ For more information see Chapter 62.
+
geqo (boolean)
+
+
+
+ #
+ Enables or disables genetic query optimization.
+ This is on by default. It is usually best not to turn it off in
+ production; the geqo_threshold variable provides
+ more granular control of GEQO.
+
geqo_threshold (integer)
+
+ #
+ Use genetic query optimization to plan queries with at least
+ this many FROM items involved. (Note that a
+ FULL OUTER JOIN construct counts as only one FROM
+ item.) The default is 12. For simpler queries it is usually best
+ to use the regular, exhaustive-search planner, but for queries with
+ many tables the exhaustive search takes too long, often
+ longer than the penalty of executing a suboptimal plan. Thus,
+ a threshold on the size of the query is a convenient way to manage
+ use of GEQO.
+
geqo_effort (integer)
+
+ #
+ Controls the trade-off between planning time and query plan
+ quality in GEQO. This variable must be an integer in the
+ range from 1 to 10. The default value is five. Larger values
+ increase the time spent doing query planning, but also
+ increase the likelihood that an efficient query plan will be
+ chosen.
+
+ geqo_effort doesn't actually do anything
+ directly; it is only used to compute the default values for
+ the other variables that influence GEQO behavior (described
+ below). If you prefer, you can set the other parameters by
+ hand instead.
+
geqo_pool_size (integer)
+
+ #
+ Controls the pool size used by GEQO, that is the
+ number of individuals in the genetic population. It must be
+ at least two, and useful values are typically 100 to 1000. If
+ it is set to zero (the default setting) then a suitable
+ value is chosen based on geqo_effort and
+ the number of tables in the query.
+
geqo_generations (integer)
+
+ #
+ Controls the number of generations used by GEQO, that is
+ the number of iterations of the algorithm. It must
+ be at least one, and useful values are in the same range as
+ the pool size. If it is set to zero (the default setting)
+ then a suitable value is chosen based on
+ geqo_pool_size.
+
geqo_selection_bias (floating point)
+
+ #
+ Controls the selection bias used by GEQO. The selection bias
+ is the selective pressure within the population. Values can be
+ from 1.50 to 2.00; the latter is the default.
+
geqo_seed (floating point)
+
+ #
+ Controls the initial value of the random number generator used
+ by GEQO to select random paths through the join order search space.
+ The value can range from zero (the default) to one. Varying the
+ value changes the set of join paths explored, and may result in a
+ better or worse best path being found.
+
20.7.4. Other Planner Options #
default_statistics_target (integer)
+
+ #
+ Sets the default statistics target for table columns without
+ a column-specific target set via ALTER TABLE
+ SET STATISTICS. Larger values increase the time needed to
+ do ANALYZE, but might improve the quality of the
+ planner's estimates. The default is 100. For more information
+ on the use of statistics by the PostgreSQL
+ query planner, refer to Section 14.2.
+
constraint_exclusion (enum)
+
+
+ #
+ Controls the query planner's use of table constraints to
+ optimize queries.
+ The allowed values of constraint_exclusion are
+ on (examine constraints for all tables),
+ off (never examine constraints), and
+ partition (examine constraints only for inheritance
+ child tables and UNION ALL subqueries).
+ partition is the default setting.
+ It is often used with traditional inheritance trees to improve
+ performance.
+
+ When this parameter allows it for a particular table, the planner
+ compares query conditions with the table's CHECK
+ constraints, and omits scanning tables for which the conditions
+ contradict the constraints. For example:
+
+
+CREATE TABLE parent(key integer, ...);
+CREATE TABLE child1000(check (key between 1000 and 1999)) INHERITS(parent);
+CREATE TABLE child2000(check (key between 2000 and 2999)) INHERITS(parent);
+...
+SELECT * FROM parent WHERE key = 2400;
+
+
+ With constraint exclusion enabled, this SELECT
+ will not scan child1000 at all, improving performance.
+
+ Currently, constraint exclusion is enabled by default
+ only for cases that are often used to implement table partitioning via
+ inheritance trees. Turning it on for all tables imposes extra
+ planning overhead that is quite noticeable on simple queries, and most
+ often will yield no benefit for simple queries. If you have no
+ tables that are partitioned using traditional inheritance, you might
+ prefer to turn it off entirely. (Note that the equivalent feature for
+ partitioned tables is controlled by a separate parameter,
+ enable_partition_pruning.)
+
+ Refer to Section 5.11.5 for
+ more information on using constraint exclusion to implement
+ partitioning.
+
cursor_tuple_fraction (floating point)
+
+ #
+ Sets the planner's estimate of the fraction of a cursor's rows that
+ will be retrieved. The default is 0.1. Smaller values of this
+ setting bias the planner towards using “fast start” plans
+ for cursors, which will retrieve the first few rows quickly while
+ perhaps taking a long time to fetch all rows. Larger values
+ put more emphasis on the total estimated time. At the maximum
+ setting of 1.0, cursors are planned exactly like regular queries,
+ considering only the total estimated time and not how soon the
+ first rows might be delivered.
+
from_collapse_limit (integer)
+
+ #
+ The planner will merge sub-queries into upper queries if the
+ resulting FROM list would have no more than
+ this many items. Smaller values reduce planning time but might
+ yield inferior query plans. The default is eight.
+ For more information see Section 14.3.
+
+ Setting this value to geqo_threshold or more
+ may trigger use of the GEQO planner, resulting in non-optimal
+ plans. See Section 20.7.3.
+
jit (boolean)
+
+ #
+ Determines whether JIT compilation may be used by
+ PostgreSQL, if available (see Chapter 32).
+ The default is on.
+
join_collapse_limit (integer)
+
+ #
+ The planner will rewrite explicit JOIN
+ constructs (except FULL JOINs) into lists of
+ FROM items whenever a list of no more than this many items
+ would result. Smaller values reduce planning time but might
+ yield inferior query plans.
+
+ By default, this variable is set the same as
+ from_collapse_limit, which is appropriate
+ for most uses. Setting it to 1 prevents any reordering of
+ explicit JOINs. Thus, the explicit join order
+ specified in the query will be the actual order in which the
+ relations are joined. Because the query planner does not always choose
+ the optimal join order, advanced users can elect to
+ temporarily set this variable to 1, and then specify the join
+ order they desire explicitly.
+ For more information see Section 14.3.
+
+ Setting this value to geqo_threshold or more
+ may trigger use of the GEQO planner, resulting in non-optimal
+ plans. See Section 20.7.3.
+
plan_cache_mode (enum)
+
+ #
+ Prepared statements (either explicitly prepared or implicitly
+ generated, for example by PL/pgSQL) can be executed using custom or
+ generic plans. Custom plans are made afresh for each execution
+ using its specific set of parameter values, while generic plans do
+ not rely on the parameter values and can be re-used across
+ executions. Thus, use of a generic plan saves planning time, but if
+ the ideal plan depends strongly on the parameter values then a
+ generic plan may be inefficient. The choice between these options
+ is normally made automatically, but it can be overridden
+ with plan_cache_mode.
+ The allowed values are auto (the default),
+ force_custom_plan and
+ force_generic_plan.
+ This setting is considered when a cached plan is to be executed,
+ not when it is prepared.
+ For more information see PREPARE.
+
recursive_worktable_factor (floating point)
+
+ #
+ Sets the planner's estimate of the average size of the working
+ table of a recursive
+ query, as a multiple of the estimated size of the initial
+ non-recursive term of the query. This helps the planner choose
+ the most appropriate method for joining the working table to the
+ query's other tables.
+ The default value is 10.0. A smaller value
+ such as 1.0 can be helpful when the recursion
+ has low “fan-out” from one step to the next, as for
+ example in shortest-path queries. Graph analytics queries may
+ benefit from larger-than-default values.
+
+ These settings control the behavior of the built-in
+ streaming replication feature (see
+ Section 27.2.5), and the built-in
+ logical replication feature (see
+ Chapter 31).
+
+ For streaming replication, servers will be either a
+ primary or a standby server. Primaries can send data, while standbys
+ are always receivers of replicated data. When cascading replication
+ (see Section 27.2.7) is used, standby servers
+ can also be senders, as well as receivers.
+ Parameters are mainly for sending and standby servers, though some
+ parameters have meaning only on the primary server. Settings may vary
+ across the cluster without problems if that is required.
+
+ For logical replication, publishers
+ (servers that do CREATE PUBLICATION)
+ replicate data to subscribers
+ (servers that do CREATE SUBSCRIPTION).
+ Servers can also be publishers and subscribers at the same time. Note,
+ the following sections refer to publishers as "senders". For more details
+ about logical replication configuration settings refer to
+ Section 31.10.
+
20.6.1. Sending Servers #
+ These parameters can be set on any server that is
+ to send replication data to one or more standby servers.
+ The primary is always a sending server, so these parameters must
+ always be set on the primary.
+ The role and meaning of these parameters does not change after a
+ standby becomes the primary.
+
max_wal_senders (integer)
+
+ #
+ Specifies the maximum number of concurrent connections from standby
+ servers or streaming base backup clients (i.e., the maximum number of
+ simultaneously running WAL sender processes). The default is
+ 10. The value 0 means
+ replication is disabled. Abrupt disconnection of a streaming client might
+ leave an orphaned connection slot behind until a timeout is reached,
+ so this parameter should be set slightly higher than the maximum
+ number of expected clients so disconnected clients can immediately
+ reconnect. This parameter can only be set at server start. Also,
+ wal_level must be set to
+ replica or higher to allow connections from standby
+ servers.
+
+ When running a standby server, you must set this parameter to the
+ same or higher value than on the primary server. Otherwise, queries
+ will not be allowed in the standby server.
+
max_replication_slots (integer)
+
+ #
+ Specifies the maximum number of replication slots
+ (see Section 27.2.6) that the server
+ can support. The default is 10. This parameter can only be set at
+ server start.
+ Setting it to a lower value than the number of currently
+ existing replication slots will prevent the server from starting.
+ Also, wal_level must be set
+ to replica or higher to allow replication slots to
+ be used.
+
+ Note that this parameter also applies on the subscriber side, but with
+ a different meaning.
+
wal_keep_size (integer)
+
+ #
+ Specifies the minimum size of past WAL files kept in the
+ pg_wal
+ directory, in case a standby server needs to fetch them for streaming
+ replication. If a standby
+ server connected to the sending server falls behind by more than
+ wal_keep_size megabytes, the sending server might
+ remove a WAL segment still needed by the standby, in which case the
+ replication connection will be terminated. Downstream connections
+ will also eventually fail as a result. (However, the standby
+ server can recover by fetching the segment from archive, if WAL
+ archiving is in use.)
+
+ This sets only the minimum size of segments retained in
+ pg_wal; the system might need to retain more segments
+ for WAL archival or to recover from a checkpoint. If
+ wal_keep_size is zero (the default), the system
+ doesn't keep any extra segments for standby purposes, so the number
+ of old WAL segments available to standby servers is a function of
+ the location of the previous checkpoint and status of WAL
+ archiving.
+ If this value is specified without units, it is taken as megabytes.
+ This parameter can only be set in the
+ postgresql.conf file or on the server command line.
+
max_slot_wal_keep_size (integer)
+
+ #
+ Specify the maximum size of WAL files
+ that replication
+ slots are allowed to retain in the pg_wal
+ directory at checkpoint time.
+ If max_slot_wal_keep_size is -1 (the default),
+ replication slots may retain an unlimited amount of WAL files. Otherwise, if
+ restart_lsn of a replication slot falls behind the current LSN by more
+ than the given size, the standby using the slot may no longer be able
+ to continue replication due to removal of required WAL files. You
+ can see the WAL availability of replication slots
+ in pg_replication_slots.
+ If this value is specified without units, it is taken as megabytes.
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
wal_sender_timeout (integer)
+
+ #
+ Terminate replication connections that are inactive for longer
+ than this amount of time. This is useful for
+ the sending server to detect a standby crash or network outage.
+ If this value is specified without units, it is taken as milliseconds.
+ The default value is 60 seconds.
+ A value of zero disables the timeout mechanism.
+
+ With a cluster distributed across multiple geographic
+ locations, using different values per location brings more flexibility
+ in the cluster management. A smaller value is useful for faster
+ failure detection with a standby having a low-latency network
+ connection, and a larger value helps in judging better the health
+ of a standby if located on a remote location, with a high-latency
+ network connection.
+
track_commit_timestamp (boolean)
+
+ #
+ Record commit time of transactions. This parameter
+ can only be set in postgresql.conf file or on the server
+ command line. The default value is off.
+
+ These parameters can be set on the primary server that is
+ to send replication data to one or more standby servers.
+ Note that in addition to these parameters,
+ wal_level must be set appropriately on the primary
+ server, and optionally WAL archiving can be enabled as
+ well (see Section 20.5.3).
+ The values of these parameters on standby servers are irrelevant,
+ although you may wish to set them there in preparation for the
+ possibility of a standby becoming the primary.
+
synchronous_standby_names (string)
+
+ #
+ Specifies a list of standby servers that can support
+ synchronous replication, as described in
+ Section 27.2.8.
+ There will be one or more active synchronous standbys;
+ transactions waiting for commit will be allowed to proceed after
+ these standby servers confirm receipt of their data.
+ The synchronous standbys will be those whose names appear
+ in this list, and
+ that are both currently connected and streaming data in real-time
+ (as shown by a state of streaming in the
+
+ pg_stat_replication view).
+ Specifying more than one synchronous standby can allow for very high
+ availability and protection against data loss.
+
+ The name of a standby server for this purpose is the
+ application_name setting of the standby, as set in the
+ standby's connection information. In case of a physical replication
+ standby, this should be set in the primary_conninfo
+ setting; the default is the setting of cluster_name
+ if set, else walreceiver.
+ For logical replication, this can be set in the connection
+ information of the subscription, and it defaults to the
+ subscription name. For other replication stream consumers,
+ consult their documentation.
+
+ This parameter specifies a list of standby servers using
+ either of the following syntaxes:
+
+[FIRST] num_sync ( standby_name [, ...] )
+ANY num_sync ( standby_name [, ...] )
+standby_name [, ...]
+
+ where num_sync is
+ the number of synchronous standbys that transactions need to
+ wait for replies from,
+ and standby_name
+ is the name of a standby server.
+ FIRST and ANY specify the method to choose
+ synchronous standbys from the listed servers.
+
+ The keyword FIRST, coupled with
+ num_sync, specifies a
+ priority-based synchronous replication and makes transaction commits
+ wait until their WAL records are replicated to
+ num_sync synchronous
+ standbys chosen based on their priorities. For example, a setting of
+ FIRST 3 (s1, s2, s3, s4) will cause each commit to wait for
+ replies from three higher-priority standbys chosen from standby servers
+ s1, s2, s3 and s4.
+ The standbys whose names appear earlier in the list are given higher
+ priority and will be considered as synchronous. Other standby servers
+ appearing later in this list represent potential synchronous standbys.
+ If any of the current synchronous standbys disconnects for whatever
+ reason, it will be replaced immediately with the next-highest-priority
+ standby. The keyword FIRST is optional.
+
+ The keyword ANY, coupled with
+ num_sync, specifies a
+ quorum-based synchronous replication and makes transaction commits
+ wait until their WAL records are replicated to at least
+ num_sync listed standbys.
+ For example, a setting of ANY 3 (s1, s2, s3, s4) will cause
+ each commit to proceed as soon as at least any three standbys of
+ s1, s2, s3 and s4
+ reply.
+
+ FIRST and ANY are case-insensitive. If these
+ keywords are used as the name of a standby server,
+ its standby_name must
+ be double-quoted.
+
+ The third syntax was used before PostgreSQL
+ version 9.6 and is still supported. It's the same as the first syntax
+ with FIRST and
+ num_sync equal to 1.
+ For example, FIRST 1 (s1, s2) and s1, s2 have
+ the same meaning: either s1 or s2 is chosen
+ as a synchronous standby.
+
+ The special entry * matches any standby name.
+
+ There is no mechanism to enforce uniqueness of standby names. In case
+ of duplicates one of the matching standbys will be considered as
+ higher priority, though exactly which one is indeterminate.
+
Note
+ Each standby_name
+ should have the form of a valid SQL identifier, unless it
+ is *. You can use double-quoting if necessary. But note
+ that standby_names are
+ compared to standby application names case-insensitively, whether
+ double-quoted or not.
+
+ If no synchronous standby names are specified here, then synchronous
+ replication is not enabled and transaction commits will not wait for
+ replication. This is the default configuration. Even when
+ synchronous replication is enabled, individual transactions can be
+ configured not to wait for replication by setting the
+ synchronous_commit parameter to
+ local or off.
+
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
20.6.3. Standby Servers #
+ These settings control the behavior of a
+ standby server
+ that is
+ to receive replication data. Their values on the primary server
+ are irrelevant.
+
primary_conninfo (string)
+
+ #
+ Specifies a connection string to be used for the standby server
+ to connect with a sending server. This string is in the format
+ described in Section 34.1.1. If any option is
+ unspecified in this string, then the corresponding environment
+ variable (see Section 34.15) is checked. If the
+ environment variable is not set either, then
+ defaults are used.
+
+ The connection string should specify the host name (or address)
+ of the sending server, as well as the port number if it is not
+ the same as the standby server's default.
+ Also specify a user name corresponding to a suitably-privileged role
+ on the sending server (see
+ Section 27.2.5.1).
+ A password needs to be provided too, if the sender demands password
+ authentication. It can be provided in the
+ primary_conninfo string, or in a separate
+ ~/.pgpass file on the standby server (use
+ replication as the database name).
+ Do not specify a database name in the
+ primary_conninfo string.
+
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+ If this parameter is changed while the WAL receiver process is
+ running, that process is signaled to shut down and expected to
+ restart with the new setting (except if primary_conninfo
+ is an empty string).
+ This setting has no effect if the server is not in standby mode.
+
primary_slot_name (string)
+
+ #
+ Optionally specifies an existing replication slot to be used when
+ connecting to the sending server via streaming replication to control
+ resource removal on the upstream node
+ (see Section 27.2.6).
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+ If this parameter is changed while the WAL receiver process is running,
+ that process is signaled to shut down and expected to restart with the
+ new setting.
+ This setting has no effect if primary_conninfo is not
+ set or the server is not in standby mode.
+
hot_standby (boolean)
+
+ #
+ Specifies whether or not you can connect and run queries during
+ recovery, as described in Section 27.4.
+ The default value is on.
+ This parameter can only be set at server start. It only has effect
+ during archive recovery or in standby mode.
+
max_standby_archive_delay (integer)
+
+ #
+ When hot standby is active, this parameter determines how long the
+ standby server should wait before canceling standby queries that
+ conflict with about-to-be-applied WAL entries, as described in
+ Section 27.4.2.
+ max_standby_archive_delay applies when WAL data is
+ being read from WAL archive (and is therefore not current).
+ If this value is specified without units, it is taken as milliseconds.
+ The default is 30 seconds.
+ A value of -1 allows the standby to wait forever for conflicting
+ queries to complete.
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
+ Note that max_standby_archive_delay is not the same as the
+ maximum length of time a query can run before cancellation; rather it
+ is the maximum total time allowed to apply any one WAL segment's data.
+ Thus, if one query has resulted in significant delay earlier in the
+ WAL segment, subsequent conflicting queries will have much less grace
+ time.
+
max_standby_streaming_delay (integer)
+
+ #
+ When hot standby is active, this parameter determines how long the
+ standby server should wait before canceling standby queries that
+ conflict with about-to-be-applied WAL entries, as described in
+ Section 27.4.2.
+ max_standby_streaming_delay applies when WAL data is
+ being received via streaming replication.
+ If this value is specified without units, it is taken as milliseconds.
+ The default is 30 seconds.
+ A value of -1 allows the standby to wait forever for conflicting
+ queries to complete.
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
+ Note that max_standby_streaming_delay is not the same as
+ the maximum length of time a query can run before cancellation; rather
+ it is the maximum total time allowed to apply WAL data once it has
+ been received from the primary server. Thus, if one query has
+ resulted in significant delay, subsequent conflicting queries will
+ have much less grace time until the standby server has caught up
+ again.
+
wal_receiver_create_temp_slot (boolean)
+
+ #
+ Specifies whether the WAL receiver process should create a temporary replication
+ slot on the remote instance when no permanent replication slot to use
+ has been configured (using primary_slot_name).
+ The default is off. This parameter can only be set in the
+ postgresql.conf file or on the server command line.
+ If this parameter is changed while the WAL receiver process is running,
+ that process is signaled to shut down and expected to restart with
+ the new setting.
+
wal_receiver_status_interval (integer)
+
+ #
+ Specifies the minimum frequency for the WAL receiver
+ process on the standby to send information about replication progress
+ to the primary or upstream standby, where it can be seen using the
+
+ pg_stat_replication
+ view. The standby will report
+ the last write-ahead log location it has written, the last position it
+ has flushed to disk, and the last position it has applied.
+ This parameter's value is the maximum amount of time between reports.
+ Updates are sent each time the write or flush positions change, or as
+ often as specified by this parameter if set to a non-zero value.
+ There are additional cases where updates are sent while ignoring this
+ parameter; for example, when processing of the existing WAL completes
+ or when synchronous_commit is set to
+ remote_apply.
+ Thus, the apply position may lag slightly behind the true position.
+ If this value is specified without units, it is taken as seconds.
+ The default value is 10 seconds. This parameter can only be set in
+ the postgresql.conf file or on the server
+ command line.
+
hot_standby_feedback (boolean)
+
+ #
+ Specifies whether or not a hot standby will send feedback to the primary
+ or upstream standby
+ about queries currently executing on the standby. This parameter can
+ be used to eliminate query cancels caused by cleanup records, but
+ can cause database bloat on the primary for some workloads.
+ Feedback messages will not be sent more frequently than once per
+ wal_receiver_status_interval. The default value is
+ off. This parameter can only be set in the
+ postgresql.conf file or on the server command line.
+
+ If cascaded replication is in use the feedback is passed upstream
+ until it eventually reaches the primary. Standbys make no other use
+ of feedback they receive other than to pass upstream.
+
+ This setting does not override the behavior of
+ old_snapshot_threshold on the primary; a snapshot on the
+ standby which exceeds the primary's age threshold can become invalid,
+ resulting in cancellation of transactions on the standby. This is
+ because old_snapshot_threshold is intended to provide an
+ absolute limit on the time which dead rows can contribute to bloat,
+ which would otherwise be violated because of the configuration of a
+ standby.
+
wal_receiver_timeout (integer)
+
+ #
+ Terminate replication connections that are inactive for longer
+ than this amount of time. This is useful for
+ the receiving standby server to detect a primary node crash or network
+ outage.
+ If this value is specified without units, it is taken as milliseconds.
+ The default value is 60 seconds.
+ A value of zero disables the timeout mechanism.
+ This parameter can only be set in
+ the postgresql.conf file or on the server
+ command line.
+
wal_retrieve_retry_interval (integer)
+
+ #
+ Specifies how long the standby server should wait when WAL data is not
+ available from any sources (streaming replication,
+ local pg_wal or WAL archive) before trying
+ again to retrieve WAL data.
+ If this value is specified without units, it is taken as milliseconds.
+ The default value is 5 seconds.
+ This parameter can only be set in
+ the postgresql.conf file or on the server
+ command line.
+
+ This parameter is useful in configurations where a node in recovery
+ needs to control the amount of time to wait for new WAL data to be
+ available. For example, in archive recovery, it is possible to
+ make the recovery more responsive in the detection of a new WAL
+ file by reducing the value of this parameter. On a system with
+ low WAL activity, increasing it reduces the amount of requests necessary
+ to access WAL archives, something useful for example in cloud
+ environments where the number of times an infrastructure is accessed
+ is taken into account.
+
+ In logical replication, this parameter also limits how often a failing
+ replication apply worker will be respawned.
+
recovery_min_apply_delay (integer)
+
+ #
+ By default, a standby server restores WAL records from the
+ sending server as soon as possible. It may be useful to have a time-delayed
+ copy of the data, offering opportunities to correct data loss errors.
+ This parameter allows you to delay recovery by a specified amount
+ of time. For example, if
+ you set this parameter to 5min, the standby will
+ replay each transaction commit only when the system time on the standby
+ is at least five minutes past the commit time reported by the primary.
+ If this value is specified without units, it is taken as milliseconds.
+ The default is zero, adding no delay.
+
+ It is possible that the replication delay between servers exceeds the
+ value of this parameter, in which case no delay is added.
+ Note that the delay is calculated between the WAL time stamp as written
+ on primary and the current time on the standby. Delays in transfer
+ because of network lag or cascading replication configurations
+ may reduce the actual wait time significantly. If the system
+ clocks on primary and standby are not synchronized, this may lead to
+ recovery applying records earlier than expected; but that is not a
+ major issue because useful settings of this parameter are much larger
+ than typical time deviations between servers.
+
+ The delay occurs only on WAL records for transaction commits.
+ Other records are replayed as quickly as possible, which
+ is not a problem because MVCC visibility rules ensure their effects
+ are not visible until the corresponding commit record is applied.
+
+ The delay occurs once the database in recovery has reached a consistent
+ state, until the standby is promoted or triggered. After that the standby
+ will end recovery without further waiting.
+
+ WAL records must be kept on the standby until they are ready to be
+ applied. Therefore, longer delays will result in a greater accumulation
+ of WAL files, increasing disk space requirements for the standby's
+ pg_wal directory.
+
+ This parameter is intended for use with streaming replication deployments;
+ however, if the parameter is specified it will be honored in all cases
+ except crash recovery.
+
+ hot_standby_feedback will be delayed by use of this feature
+ which could lead to bloat on the primary; use both together with care.
+
+
Warning
+ Synchronous replication is affected by this setting when synchronous_commit
+ is set to remote_apply; every COMMIT
+ will need to wait to be applied.
+
+
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
+ These settings control the behavior of a logical replication subscriber.
+ Their values on the publisher are irrelevant.
+ See Section 31.10 for more details.
+
max_replication_slots (integer)
+
+ #
+ Specifies how many replication origins (see
+ Chapter 50) can be tracked simultaneously,
+ effectively limiting how many logical replication subscriptions can
+ be created on the server. Setting it to a lower value than the current
+ number of tracked replication origins (reflected in
+ pg_replication_origin_status)
+ will prevent the server from starting.
+ max_replication_slots must be set to at least the
+ number of subscriptions that will be added to the subscriber, plus some
+ reserve for table synchronization.
+
+ Note that this parameter also applies on a sending server, but with
+ a different meaning.
+
max_logical_replication_workers (integer)
+
+ #
+ Specifies maximum number of logical replication workers. This includes
+ leader apply workers, parallel apply workers, and table synchronization
+ workers.
+
+ Logical replication workers are taken from the pool defined by
+ max_worker_processes.
+
+ The default value is 4. This parameter can only be set at server
+ start.
+
max_sync_workers_per_subscription (integer)
+
+ #
+ Maximum number of synchronization workers per subscription. This
+ parameter controls the amount of parallelism of the initial data copy
+ during the subscription initialization or when new tables are added.
+
+ Currently, there can be only one synchronization worker per table.
+
+ The synchronization workers are taken from the pool defined by
+ max_logical_replication_workers.
+
+ The default value is 2. This parameter can only be set in the
+ postgresql.conf file or on the server command
+ line.
+
max_parallel_apply_workers_per_subscription (integer)
+
+ #
+ Maximum number of parallel apply workers per subscription. This
+ parameter controls the amount of parallelism for streaming of
+ in-progress transactions with subscription parameter
+ streaming = parallel.
+
+ The parallel apply workers are taken from the pool defined by
+ max_logical_replication_workers.
+
+ The default value is 2. This parameter can only be set in the
+ postgresql.conf file or on the server command
+ line.
+
20.4. Resource Consumption #
shared_buffers (integer)
+
+ #
+ Sets the amount of memory the database server uses for shared
+ memory buffers. The default is typically 128 megabytes
+ (128MB), but might be less if your kernel settings will
+ not support it (as determined during initdb).
+ This setting must be at least 128 kilobytes. However,
+ settings significantly higher than the minimum are usually needed
+ for good performance.
+ If this value is specified without units, it is taken as blocks,
+ that is BLCKSZ bytes, typically 8kB.
+ (Non-default values of BLCKSZ change the minimum
+ value.)
+ This parameter can only be set at server start.
+
+ If you have a dedicated database server with 1GB or more of RAM, a
+ reasonable starting value for shared_buffers is 25%
+ of the memory in your system. There are some workloads where even
+ larger settings for shared_buffers are effective, but
+ because PostgreSQL also relies on the
+ operating system cache, it is unlikely that an allocation of more than
+ 40% of RAM to shared_buffers will work better than a
+ smaller amount. Larger settings for shared_buffers
+ usually require a corresponding increase in
+ max_wal_size, in order to spread out the
+ process of writing large quantities of new or changed data over a
+ longer period of time.
+
+ On systems with less than 1GB of RAM, a smaller percentage of RAM is
+ appropriate, so as to leave adequate space for the operating system.
+
huge_pages (enum)
+
+ #
+ Controls whether huge pages are requested for the main shared memory
+ area. Valid values are try (the default),
+ on, and off. With
+ huge_pages set to try, the
+ server will try to request huge pages, but fall back to the default if
+ that fails. With on, failure to request huge pages
+ will prevent the server from starting up. With off,
+ huge pages will not be requested.
+
+ At present, this setting is supported only on Linux and Windows. The
+ setting is ignored on other systems when set to
+ try. On Linux, it is only supported when
+ shared_memory_type is set to mmap
+ (the default).
+
+ The use of huge pages results in smaller page tables and less CPU time
+ spent on memory management, increasing performance. For more details about
+ using huge pages on Linux, see Section 19.4.5.
+
+ Huge pages are known as large pages on Windows. To use them, you need to
+ assign the user right “Lock pages in memory” to the Windows user account
+ that runs PostgreSQL.
+ You can use Windows Group Policy tool (gpedit.msc) to assign the user right
+ “Lock pages in memory”.
+ To start the database server on the command prompt as a standalone process,
+ not as a Windows service, the command prompt must be run as an administrator or
+ User Access Control (UAC) must be disabled. When the UAC is enabled, the normal
+ command prompt revokes the user right “Lock pages in memory” when started.
+
+ Note that this setting only affects the main shared memory area.
+ Operating systems such as Linux, FreeBSD, and Illumos can also use
+ huge pages (also known as “super” pages or
+ “large” pages) automatically for normal memory
+ allocation, without an explicit request from
+ PostgreSQL. On Linux, this is called
+ “transparent huge pages” (THP). That feature has been known to
+ cause performance degradation with
+ PostgreSQL for some users on some Linux
+ versions, so its use is currently discouraged (unlike explicit use of
+ huge_pages).
+
huge_page_size (integer)
+
+ #
+ Controls the size of huge pages, when they are enabled with
+ huge_pages.
+ The default is zero (0).
+ When set to 0, the default huge page size on the
+ system will be used. This parameter can only be set at server start.
+
+ Some commonly available page sizes on modern 64 bit server architectures include:
+ 2MB and 1GB (Intel and AMD), 16MB and
+ 16GB (IBM POWER), and 64kB, 2MB,
+ 32MB and 1GB (ARM). For more information
+ about usage and support, see Section 19.4.5.
+
+ Non-default settings are currently supported only on Linux.
+
temp_buffers (integer)
+
+ #
+ Sets the maximum amount of memory used for temporary buffers within
+ each database session. These are session-local buffers used only
+ for access to temporary tables.
+ If this value is specified without units, it is taken as blocks,
+ that is BLCKSZ bytes, typically 8kB.
+ The default is eight megabytes (8MB).
+ (If BLCKSZ is not 8kB, the default value scales
+ proportionally to it.)
+ This setting can be changed within individual
+ sessions, but only before the first use of temporary tables
+ within the session; subsequent attempts to change the value will
+ have no effect on that session.
+
+ A session will allocate temporary buffers as needed up to the limit
+ given by temp_buffers. The cost of setting a large
+ value in sessions that do not actually need many temporary
+ buffers is only a buffer descriptor, or about 64 bytes, per
+ increment in temp_buffers. However if a buffer is
+ actually used an additional 8192 bytes will be consumed for it
+ (or in general, BLCKSZ bytes).
+
max_prepared_transactions (integer)
+
+ #
+ Sets the maximum number of transactions that can be in the
+ “prepared” state simultaneously (see PREPARE TRANSACTION).
+ Setting this parameter to zero (which is the default)
+ disables the prepared-transaction feature.
+ This parameter can only be set at server start.
+
+ If you are not planning to use prepared transactions, this parameter
+ should be set to zero to prevent accidental creation of prepared
+ transactions. If you are using prepared transactions, you will
+ probably want max_prepared_transactions to be at
+ least as large as max_connections, so that every
+ session can have a prepared transaction pending.
+
+ When running a standby server, you must set this parameter to the
+ same or higher value than on the primary server. Otherwise, queries
+ will not be allowed in the standby server.
+
work_mem (integer)
+
+ #
+ Sets the base maximum amount of memory to be used by a query operation
+ (such as a sort or hash table) before writing to temporary disk files.
+ If this value is specified without units, it is taken as kilobytes.
+ The default value is four megabytes (4MB).
+ Note that a complex query might perform several sort and hash
+ operations at the same time, with each operation generally being
+ allowed to use as much memory as this value specifies before
+ it starts
+ to write data into temporary files. Also, several running
+ sessions could be doing such operations concurrently.
+ Therefore, the total memory used could be many times the value
+ of work_mem; it is necessary to keep this
+ fact in mind when choosing the value. Sort operations are used
+ for ORDER BY, DISTINCT,
+ and merge joins.
+ Hash tables are used in hash joins, hash-based aggregation, memoize
+ nodes and hash-based processing of IN subqueries.
+
+ Hash-based operations are generally more sensitive to memory
+ availability than equivalent sort-based operations. The
+ memory limit for a hash table is computed by multiplying
+ work_mem by
+ hash_mem_multiplier. This makes it
+ possible for hash-based operations to use an amount of memory
+ that exceeds the usual work_mem base
+ amount.
+
hash_mem_multiplier (floating point)
+
+ #
+ Used to compute the maximum amount of memory that hash-based
+ operations can use. The final limit is determined by
+ multiplying work_mem by
+ hash_mem_multiplier. The default value is
+ 2.0, which makes hash-based operations use twice the usual
+ work_mem base amount.
+
+ Consider increasing hash_mem_multiplier in
+ environments where spilling by query operations is a regular
+ occurrence, especially when simply increasing
+ work_mem results in memory pressure (memory
+ pressure typically takes the form of intermittent out of
+ memory errors). The default setting of 2.0 is often effective with
+ mixed workloads. Higher settings in the range of 2.0 - 8.0 or
+ more may be effective in environments where
+ work_mem has already been increased to 40MB
+ or more.
+
maintenance_work_mem (integer)
+
+ #
+ Specifies the maximum amount of memory to be used by maintenance
+ operations, such as VACUUM, CREATE
+ INDEX, and ALTER TABLE ADD FOREIGN KEY.
+ If this value is specified without units, it is taken as kilobytes.
+ It defaults
+ to 64 megabytes (64MB). Since only one of these
+ operations can be executed at a time by a database session, and
+ an installation normally doesn't have many of them running
+ concurrently, it's safe to set this value significantly larger
+ than work_mem. Larger settings might improve
+ performance for vacuuming and for restoring database dumps.
+
+ Note that when autovacuum runs, up to
+ autovacuum_max_workers times this memory
+ may be allocated, so be careful not to set the default value
+ too high. It may be useful to control for this by separately
+ setting autovacuum_work_mem.
+
+ Note that for the collection of dead tuple identifiers,
+ VACUUM is only able to utilize up to a maximum of
+ 1GB of memory.
+
autovacuum_work_mem (integer)
+
+ #
+ Specifies the maximum amount of memory to be used by each
+ autovacuum worker process.
+ If this value is specified without units, it is taken as kilobytes.
+ It defaults to -1, indicating that
+ the value of maintenance_work_mem should
+ be used instead. The setting has no effect on the behavior of
+ VACUUM when run in other contexts.
+ This parameter can only be set in the
+ postgresql.conf file or on the server command
+ line.
+
+ For the collection of dead tuple identifiers, autovacuum is only able
+ to utilize up to a maximum of 1GB of memory, so
+ setting autovacuum_work_mem to a value higher than
+ that has no effect on the number of dead tuples that autovacuum can
+ collect while scanning a table.
+
-
+
vacuum_buffer_usage_limit (integer)
+
+ #
+ Specifies the size of the
+ Buffer Access Strategy
+ used by the VACUUM and ANALYZE
+ commands. A setting of 0 will allow the operation
+ to use any number of shared_buffers. Otherwise
+ valid sizes range from 128 kB to
+ 16 GB. If the specified size would exceed 1/8 the
+ size of shared_buffers, the size is silently capped
+ to that value. The default value is 256 kB. If
+ this value is specified without units, it is taken as kilobytes. This
+ parameter can be set at any time. It can be overridden for
+ VACUUM and ANALYZE
+ when passing the BUFFER_USAGE_LIMIT option. Higher
+ settings can allow VACUUM and
+ ANALYZE to run more quickly, but having too large a
+ setting may cause too many other useful pages to be evicted from
+ shared buffers.
+
logical_decoding_work_mem (integer)
+
+ #
+ Specifies the maximum amount of memory to be used by logical decoding,
+ before some of the decoded changes are written to local disk. This
+ limits the amount of memory used by logical streaming replication
+ connections. It defaults to 64 megabytes (64MB).
+ Since each replication connection only uses a single buffer of this size,
+ and an installation normally doesn't have many such connections
+ concurrently (as limited by max_wal_senders), it's
+ safe to set this value significantly higher than work_mem,
+ reducing the amount of decoded changes written to disk.
+
max_stack_depth (integer)
+
+ #
+ Specifies the maximum safe depth of the server's execution stack.
+ The ideal setting for this parameter is the actual stack size limit
+ enforced by the kernel (as set by ulimit -s or local
+ equivalent), less a safety margin of a megabyte or so. The safety
+ margin is needed because the stack depth is not checked in every
+ routine in the server, but only in key potentially-recursive routines.
+ If this value is specified without units, it is taken as kilobytes.
+ The default setting is two megabytes (2MB), which
+ is conservatively small and unlikely to risk crashes. However,
+ it might be too small to allow execution of complex functions.
+ Only superusers and users with the appropriate SET
+ privilege can change this setting.
+
+ Setting max_stack_depth higher than
+ the actual kernel limit will mean that a runaway recursive function
+ can crash an individual backend process. On platforms where
+ PostgreSQL can determine the kernel limit,
+ the server will not allow this variable to be set to an unsafe
+ value. However, not all platforms provide the information,
+ so caution is recommended in selecting a value.
+
shared_memory_type (enum)
+
+ #
+ Specifies the shared memory implementation that the server
+ should use for the main shared memory region that holds
+ PostgreSQL's shared buffers and other
+ shared data. Possible values are mmap (for
+ anonymous shared memory allocated using mmap),
+ sysv (for System V shared memory allocated via
+ shmget) and windows (for Windows
+ shared memory). Not all values are supported on all platforms; the
+ first supported option is the default for that platform. The use of
+ the sysv option, which is not the default on any
+ platform, is generally discouraged because it typically requires
+ non-default kernel settings to allow for large allocations (see Section 19.4.1).
+
dynamic_shared_memory_type (enum)
+
+ #
+ Specifies the dynamic shared memory implementation that the server
+ should use. Possible values are posix (for POSIX shared
+ memory allocated using shm_open), sysv
+ (for System V shared memory allocated via shmget),
+ windows (for Windows shared memory),
+ and mmap (to simulate shared memory using
+ memory-mapped files stored in the data directory).
+ Not all values are supported on all platforms; the first supported
+ option is usually the default for that platform. The use of the
+ mmap option, which is not the default on any platform,
+ is generally discouraged because the operating system may write
+ modified pages back to disk repeatedly, increasing system I/O load;
+ however, it may be useful for debugging, when the
+ pg_dynshmem directory is stored on a RAM disk, or when
+ other shared memory facilities are not available.
+
min_dynamic_shared_memory (integer)
+
+ #
+ Specifies the amount of memory that should be allocated at server
+ startup for use by parallel queries. When this memory region is
+ insufficient or exhausted by concurrent queries, new parallel queries
+ try to allocate extra shared memory temporarily from the operating
+ system using the method configured with
+ dynamic_shared_memory_type, which may be slower due
+ to memory management overheads. Memory that is allocated at startup
+ with min_dynamic_shared_memory is affected by
+ the huge_pages setting on operating systems where
+ that is supported, and may be more likely to benefit from larger pages
+ on operating systems where that is managed automatically.
+ The default value is 0 (none). This parameter can
+ only be set at server start.
+
temp_file_limit (integer)
+
+ #
+ Specifies the maximum amount of disk space that a process can use
+ for temporary files, such as sort and hash temporary files, or the
+ storage file for a held cursor. A transaction attempting to exceed
+ this limit will be canceled.
+ If this value is specified without units, it is taken as kilobytes.
+ -1 (the default) means no limit.
+ Only superusers and users with the appropriate SET
+ privilege can change this setting.
+
+ This setting constrains the total space used at any instant by all
+ temporary files used by a given PostgreSQL process.
+ It should be noted that disk space used for explicit temporary
+ tables, as opposed to temporary files used behind-the-scenes in query
+ execution, does not count against this limit.
+
20.4.3. Kernel Resource Usage #
max_files_per_process (integer)
+
+ #
+ Sets the maximum number of simultaneously open files allowed to each
+ server subprocess. The default is one thousand files. If the kernel is enforcing
+ a safe per-process limit, you don't need to worry about this setting.
+ But on some platforms (notably, most BSD systems), the kernel will
+ allow individual processes to open many more files than the system
+ can actually support if many processes all try to open
+ that many files. If you find yourself seeing “Too many open
+ files” failures, try reducing this setting.
+ This parameter can only be set at server start.
+
20.4.4. Cost-based Vacuum Delay #
+ During the execution of VACUUM
+ and ANALYZE
+ commands, the system maintains an
+ internal counter that keeps track of the estimated cost of the
+ various I/O operations that are performed. When the accumulated
+ cost reaches a limit (specified by
+ vacuum_cost_limit), the process performing
+ the operation will sleep for a short period of time, as specified by
+ vacuum_cost_delay. Then it will reset the
+ counter and continue execution.
+
+ The intent of this feature is to allow administrators to reduce
+ the I/O impact of these commands on concurrent database
+ activity. There are many situations where it is not
+ important that maintenance commands like
+ VACUUM and ANALYZE finish
+ quickly; however, it is usually very important that these
+ commands do not significantly interfere with the ability of the
+ system to perform other database operations. Cost-based vacuum
+ delay provides a way for administrators to achieve this.
+
+ This feature is disabled by default for manually issued
+ VACUUM commands. To enable it, set the
+ vacuum_cost_delay variable to a nonzero
+ value.
+
vacuum_cost_delay (floating point)
+
+ #
+ The amount of time that the process will sleep
+ when the cost limit has been exceeded.
+ If this value is specified without units, it is taken as milliseconds.
+ The default value is zero, which disables the cost-based vacuum
+ delay feature. Positive values enable cost-based vacuuming.
+
+ When using cost-based vacuuming, appropriate values for
+ vacuum_cost_delay are usually quite small, perhaps
+ less than 1 millisecond. While vacuum_cost_delay
+ can be set to fractional-millisecond values, such delays may not be
+ measured accurately on older platforms. On such platforms,
+ increasing VACUUM's throttled resource consumption
+ above what you get at 1ms will require changing the other vacuum cost
+ parameters. You should, nonetheless,
+ keep vacuum_cost_delay as small as your platform
+ will consistently measure; large delays are not helpful.
+
vacuum_cost_page_hit (integer)
+
+ #
+ The estimated cost for vacuuming a buffer found in the shared buffer
+ cache. It represents the cost to lock the buffer pool, lookup
+ the shared hash table and scan the content of the page. The
+ default value is one.
+
vacuum_cost_page_miss (integer)
+
+ #
+ The estimated cost for vacuuming a buffer that has to be read from
+ disk. This represents the effort to lock the buffer pool,
+ lookup the shared hash table, read the desired block in from
+ the disk and scan its content. The default value is 2.
+
vacuum_cost_page_dirty (integer)
+
+ #
+ The estimated cost charged when vacuum modifies a block that was
+ previously clean. It represents the extra I/O required to
+ flush the dirty block out to disk again. The default value is
+ 20.
+
vacuum_cost_limit (integer)
+
+ #
+ The accumulated cost that will cause the vacuuming process to sleep.
+ The default value is 200.
+
Note
+ There are certain operations that hold critical locks and should
+ therefore complete as quickly as possible. Cost-based vacuum
+ delays do not occur during such operations. Therefore it is
+ possible that the cost accumulates far higher than the specified
+ limit. To avoid uselessly long delays in such cases, the actual
+ delay is calculated as vacuum_cost_delay *
+ accumulated_balance /
+ vacuum_cost_limit with a maximum of
+ vacuum_cost_delay * 4.
+
20.4.5. Background Writer #
+ There is a separate server
+ process called the background writer, whose function
+ is to issue writes of “dirty” (new or modified) shared
+ buffers. When the number of clean shared buffers appears to be
+ insufficient, the background writer writes some dirty buffers to the
+ file system and marks them as clean. This reduces the likelihood
+ that server processes handling user queries will be unable to find
+ clean buffers and have to write dirty buffers themselves.
+ However, the background writer does cause a net overall
+ increase in I/O load, because while a repeatedly-dirtied page might
+ otherwise be written only once per checkpoint interval, the
+ background writer might write it several times as it is dirtied
+ in the same interval. The parameters discussed in this subsection
+ can be used to tune the behavior for local needs.
+
bgwriter_delay (integer)
+
+ #
+ Specifies the delay between activity rounds for the
+ background writer. In each round the writer issues writes
+ for some number of dirty buffers (controllable by the
+ following parameters). It then sleeps for
+ the length of bgwriter_delay, and repeats.
+ When there are no dirty buffers in the
+ buffer pool, though, it goes into a longer sleep regardless of
+ bgwriter_delay.
+ If this value is specified without units, it is taken as milliseconds.
+ The default value is 200
+ milliseconds (200ms). Note that on many systems, the
+ effective resolution of sleep delays is 10 milliseconds; setting
+ bgwriter_delay to a value that is not a multiple of 10
+ might have the same results as setting it to the next higher multiple
+ of 10. This parameter can only be set in the
+ postgresql.conf file or on the server command line.
+
bgwriter_lru_maxpages (integer)
+
+ #
+ In each round, no more than this many buffers will be written
+ by the background writer. Setting this to zero disables
+ background writing. (Note that checkpoints, which are managed by
+ a separate, dedicated auxiliary process, are unaffected.)
+ The default value is 100 buffers.
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
bgwriter_lru_multiplier (floating point)
+
+ #
+ The number of dirty buffers written in each round is based on the
+ number of new buffers that have been needed by server processes
+ during recent rounds. The average recent need is multiplied by
+ bgwriter_lru_multiplier to arrive at an estimate of the
+ number of buffers that will be needed during the next round. Dirty
+ buffers are written until there are that many clean, reusable buffers
+ available. (However, no more than bgwriter_lru_maxpages
+ buffers will be written per round.)
+ Thus, a setting of 1.0 represents a “just in time” policy
+ of writing exactly the number of buffers predicted to be needed.
+ Larger values provide some cushion against spikes in demand,
+ while smaller values intentionally leave writes to be done by
+ server processes.
+ The default is 2.0.
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
bgwriter_flush_after (integer)
+
+ #
+ Whenever more than this amount of data has
+ been written by the background writer, attempt to force the OS to issue these
+ writes to the underlying storage. Doing so will limit the amount of
+ dirty data in the kernel's page cache, reducing the likelihood of
+ stalls when an fsync is issued at the end of a checkpoint, or when
+ the OS writes data back in larger batches in the background. Often
+ that will result in greatly reduced transaction latency, but there
+ also are some cases, especially with workloads that are bigger than
+ shared_buffers, but smaller than the OS's page
+ cache, where performance might degrade. This setting may have no
+ effect on some platforms.
+ If this value is specified without units, it is taken as blocks,
+ that is BLCKSZ bytes, typically 8kB.
+ The valid range is between
+ 0, which disables forced writeback, and
+ 2MB. The default is 512kB on Linux,
+ 0 elsewhere. (If BLCKSZ is not 8kB,
+ the default and maximum values scale proportionally to it.)
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
+ Smaller values of bgwriter_lru_maxpages and
+ bgwriter_lru_multiplier reduce the extra I/O load
+ caused by the background writer, but make it more likely that server
+ processes will have to issue writes for themselves, delaying interactive
+ queries.
+
20.4.6. Asynchronous Behavior #
backend_flush_after (integer)
+
+ #
+ Whenever more than this amount of data has
+ been written by a single backend, attempt to force the OS to issue
+ these writes to the underlying storage. Doing so will limit the
+ amount of dirty data in the kernel's page cache, reducing the
+ likelihood of stalls when an fsync is issued at the end of a
+ checkpoint, or when the OS writes data back in larger batches in the
+ background. Often that will result in greatly reduced transaction
+ latency, but there also are some cases, especially with workloads
+ that are bigger than shared_buffers, but smaller
+ than the OS's page cache, where performance might degrade. This
+ setting may have no effect on some platforms.
+ If this value is specified without units, it is taken as blocks,
+ that is BLCKSZ bytes, typically 8kB.
+ The valid range is
+ between 0, which disables forced writeback,
+ and 2MB. The default is 0, i.e., no
+ forced writeback. (If BLCKSZ is not 8kB,
+ the maximum value scales proportionally to it.)
+
effective_io_concurrency (integer)
+
+ #
+ Sets the number of concurrent disk I/O operations that
+ PostgreSQL expects can be executed
+ simultaneously. Raising this value will increase the number of I/O
+ operations that any individual PostgreSQL session
+ attempts to initiate in parallel. The allowed range is 1 to 1000,
+ or zero to disable issuance of asynchronous I/O requests. Currently,
+ this setting only affects bitmap heap scans.
+
+ For magnetic drives, a good starting point for this setting is the
+ number of separate
+ drives comprising a RAID 0 stripe or RAID 1 mirror being used for the
+ database. (For RAID 5 the parity drive should not be counted.)
+ However, if the database is often busy with multiple queries issued in
+ concurrent sessions, lower values may be sufficient to keep the disk
+ array busy. A value higher than needed to keep the disks busy will
+ only result in extra CPU overhead.
+ SSDs and other memory-based storage can often process many
+ concurrent requests, so the best value might be in the hundreds.
+
+ Asynchronous I/O depends on an effective posix_fadvise
+ function, which some operating systems lack. If the function is not
+ present then setting this parameter to anything but zero will result
+ in an error. On some operating systems (e.g., Solaris), the function
+ is present but does not actually do anything.
+
+ The default is 1 on supported systems, otherwise 0. This value can
+ be overridden for tables in a particular tablespace by setting the
+ tablespace parameter of the same name (see
+ ALTER TABLESPACE).
+
maintenance_io_concurrency (integer)
+
+ #
+ Similar to effective_io_concurrency, but used
+ for maintenance work that is done on behalf of many client sessions.
+
+ The default is 10 on supported systems, otherwise 0. This value can
+ be overridden for tables in a particular tablespace by setting the
+ tablespace parameter of the same name (see
+ ALTER TABLESPACE).
+
max_worker_processes (integer)
+
+ #
+ Sets the maximum number of background processes that the system
+ can support. This parameter can only be set at server start. The
+ default is 8.
+
+ When running a standby server, you must set this parameter to the
+ same or higher value than on the primary server. Otherwise, queries
+ will not be allowed in the standby server.
+
+ When changing this value, consider also adjusting
+ max_parallel_workers,
+ max_parallel_maintenance_workers, and
+ max_parallel_workers_per_gather.
+
max_parallel_workers_per_gather (integer)
+
+ #
+ Sets the maximum number of workers that can be started by a single
+ Gather or Gather Merge node.
+ Parallel workers are taken from the pool of processes established by
+ max_worker_processes, limited by
+ max_parallel_workers. Note that the requested
+ number of workers may not actually be available at run time. If this
+ occurs, the plan will run with fewer workers than expected, which may
+ be inefficient. The default value is 2. Setting this value to 0
+ disables parallel query execution.
+
+ Note that parallel queries may consume very substantially more
+ resources than non-parallel queries, because each worker process is
+ a completely separate process which has roughly the same impact on the
+ system as an additional user session. This should be taken into
+ account when choosing a value for this setting, as well as when
+ configuring other settings that control resource utilization, such
+ as work_mem. Resource limits such as
+ work_mem are applied individually to each worker,
+ which means the total utilization may be much higher across all
+ processes than it would normally be for any single process.
+ For example, a parallel query using 4 workers may use up to 5 times
+ as much CPU time, memory, I/O bandwidth, and so forth as a query which
+ uses no workers at all.
+
+ For more information on parallel query, see
+ Chapter 15.
+
max_parallel_maintenance_workers (integer)
+
+ #
+ Sets the maximum number of parallel workers that can be
+ started by a single utility command. Currently, the parallel
+ utility commands that support the use of parallel workers are
+ CREATE INDEX only when building a B-tree index,
+ and VACUUM without FULL
+ option. Parallel workers are taken from the pool of processes
+ established by max_worker_processes, limited
+ by max_parallel_workers. Note that the requested
+ number of workers may not actually be available at run time.
+ If this occurs, the utility operation will run with fewer
+ workers than expected. The default value is 2. Setting this
+ value to 0 disables the use of parallel workers by utility
+ commands.
+
+ Note that parallel utility commands should not consume
+ substantially more memory than equivalent non-parallel
+ operations. This strategy differs from that of parallel
+ query, where resource limits generally apply per worker
+ process. Parallel utility commands treat the resource limit
+ maintenance_work_mem as a limit to be applied to
+ the entire utility command, regardless of the number of
+ parallel worker processes. However, parallel utility
+ commands may still consume substantially more CPU resources
+ and I/O bandwidth.
+
max_parallel_workers (integer)
+
+ #
+ Sets the maximum number of workers that the system can support for
+ parallel operations. The default value is 8. When increasing or
+ decreasing this value, consider also adjusting
+ max_parallel_maintenance_workers and
+ max_parallel_workers_per_gather.
+ Also, note that a setting for this value which is higher than
+ max_worker_processes will have no effect,
+ since parallel workers are taken from the pool of worker processes
+ established by that setting.
+
-
+
parallel_leader_participation (boolean)
+
+ #
+ Allows the leader process to execute the query plan under
+ Gather and Gather Merge nodes
+ instead of waiting for worker processes. The default is
+ on. Setting this value to off
+ reduces the likelihood that workers will become blocked because the
+ leader is not reading tuples fast enough, but requires the leader
+ process to wait for worker processes to start up before the first
+ tuples can be produced. The degree to which the leader can help or
+ hinder performance depends on the plan type, number of workers and
+ query duration.
+
old_snapshot_threshold (integer)
+
+ #
+ Sets the minimum amount of time that a query snapshot can be used
+ without risk of a “snapshot too old” error occurring
+ when using the snapshot. Data that has been dead for longer than
+ this threshold is allowed to be vacuumed away. This can help
+ prevent bloat in the face of snapshots which remain in use for a
+ long time. To prevent incorrect results due to cleanup of data which
+ would otherwise be visible to the snapshot, an error is generated
+ when the snapshot is older than this threshold and the snapshot is
+ used to read a page which has been modified since the snapshot was
+ built.
+
+ If this value is specified without units, it is taken as minutes.
+ A value of -1 (the default) disables this feature,
+ effectively setting the snapshot age limit to infinity.
+ This parameter can only be set at server start.
+
+ Useful values for production work probably range from a small number
+ of hours to a few days. Small values (such as 0 or
+ 1min) are only allowed because they may sometimes be
+ useful for testing. While a setting as high as 60d is
+ allowed, please note that in many workloads extreme bloat or
+ transaction ID wraparound may occur in much shorter time frames.
+
+ When this feature is enabled, freed space at the end of a relation
+ cannot be released to the operating system, since that could remove
+ information needed to detect the “snapshot too old”
+ condition. All space allocated to a relation remains associated with
+ that relation for reuse only within that relation unless explicitly
+ freed (for example, with VACUUM FULL).
+
+ This setting does not attempt to guarantee that an error will be
+ generated under any particular circumstances. In fact, if the
+ correct results can be generated from (for example) a cursor which
+ has materialized a result set, no error will be generated even if the
+ underlying rows in the referenced table have been vacuumed away.
+ Some tables cannot safely be vacuumed early, and so will not be
+ affected by this setting, such as system catalogs. For such tables
+ this setting will neither reduce bloat nor create a possibility
+ of a “snapshot too old” error on scanning.
+
+ For convenience there are also single letter command-line option
+ switches available for some parameters. They are described in
+ Table 20.4. Some of these
+ options exist for historical reasons, and their presence as a
+ single-letter option does not necessarily indicate an endorsement
+ to use the option heavily.
+
Table 20.4. Short Option Key
| Short Option | Equivalent |
|---|
-B x | shared_buffers = x |
-d x | log_min_messages = DEBUGx |
-e | datestyle = euro |
+ -fb, -fh, -fi,
+ -fm, -fn, -fo,
+ -fs, -ft
+ |
+ enable_bitmapscan = off,
+ enable_hashjoin = off,
+ enable_indexscan = off,
+ enable_mergejoin = off,
+ enable_nestloop = off,
+ enable_indexonlyscan = off,
+ enable_seqscan = off,
+ enable_tidscan = off
+ |
-F | fsync = off |
-h x | listen_addresses = x |
-i | listen_addresses = '*' |
-k x | unix_socket_directories = x |
-l | ssl = on |
-N x | max_connections = x |
-O | allow_system_table_mods = on |
-p x | port = x |
-P | ignore_system_indexes = on |
-s | log_statement_stats = on |
-S x | work_mem = x |
-tpa, -tpl, -te | log_parser_stats = on,
+ log_planner_stats = on,
+ log_executor_stats = on |
-W x | post_auth_delay = x |
20.9. Run-time Statistics #
20.9.1. Cumulative Query and Index Statistics #
+ These parameters control the server-wide cumulative statistics system.
+ When enabled, the data that is collected can be accessed via the
+ pg_stat and pg_statio
+ family of system views. Refer to Chapter 28 for more
+ information.
+
track_activities (boolean)
+
+ #
+ Enables the collection of information on the currently
+ executing command of each session, along with its identifier and the
+ time when that command began execution. This parameter is on by
+ default. Note that even when enabled, this information is only
+ visible to superusers, roles with privileges of the
+ pg_read_all_stats role and the user owning the
+ sessions being reported on (including sessions belonging to a role they
+ have the privileges of), so it should not represent a security risk.
+ Only superusers and users with the appropriate SET
+ privilege can change this setting.
+
track_activity_query_size (integer)
+
+ #
+ Specifies the amount of memory reserved to store the text of the
+ currently executing command for each active session, for the
+ pg_stat_activity.query field.
+ If this value is specified without units, it is taken as bytes.
+ The default value is 1024 bytes.
+ This parameter can only be set at server start.
+
track_counts (boolean)
+
+ #
+ Enables collection of statistics on database activity.
+ This parameter is on by default, because the autovacuum
+ daemon needs the collected information.
+ Only superusers and users with the appropriate SET
+ privilege can change this setting.
+
track_io_timing (boolean)
+
+ #
+ Enables timing of database I/O calls. This parameter is off by
+ default, as it will repeatedly query the operating system for
+ the current time, which may cause significant overhead on some
+ platforms. You can use the pg_test_timing tool to
+ measure the overhead of timing on your system.
+ I/O timing information is
+ displayed in
+ pg_stat_database, in the output of
+ EXPLAIN when the BUFFERS option
+ is used, in the output of VACUUM when
+ the VERBOSE option is used, by autovacuum
+ for auto-vacuums and auto-analyzes, when log_autovacuum_min_duration is set and by
+ pg_stat_statements.
+ Only superusers and users with the appropriate SET
+ privilege can change this setting.
+
track_wal_io_timing (boolean)
+
+ #
+ Enables timing of WAL I/O calls. This parameter is off by default,
+ as it will repeatedly query the operating system for the current time,
+ which may cause significant overhead on some platforms.
+ You can use the pg_test_timing tool to
+ measure the overhead of timing on your system.
+ I/O timing information is
+ displayed in
+ pg_stat_wal.
+ Only superusers and users with the appropriate SET
+ privilege can change this setting.
+
track_functions (enum)
+
+ #
+ Enables tracking of function call counts and time used. Specify
+ pl to track only procedural-language functions,
+ all to also track SQL and C language functions.
+ The default is none, which disables function
+ statistics tracking.
+ Only superusers and users with the appropriate SET
+ privilege can change this setting.
+
Note
+ SQL-language functions that are simple enough to be “inlined”
+ into the calling query will not be tracked, regardless of this
+ setting.
+
stats_fetch_consistency (enum)
+
+ #
+ Determines the behavior when cumulative statistics are accessed
+ multiple times within a transaction. When set to
+ none, each access re-fetches counters from shared
+ memory. When set to cache, the first access to
+ statistics for an object caches those statistics until the end of the
+ transaction unless pg_stat_clear_snapshot() is
+ called. When set to snapshot, the first statistics
+ access caches all statistics accessible in the current database, until
+ the end of the transaction unless
+ pg_stat_clear_snapshot() is called. Changing this
+ parameter in a transaction discards the statistics snapshot.
+ The default is cache.
+
Note
+ none is most suitable for monitoring systems. If
+ values are only accessed once, it is the most
+ efficient. cache ensures repeat accesses yield the
+ same values, which is important for queries involving
+ e.g. self-joins. snapshot can be useful when
+ interactively inspecting statistics, but has higher overhead,
+ particularly if many database objects exist.
+
20.9.2. Statistics Monitoring #
compute_query_id (enum)
+
+ #
+ Enables in-core computation of a query identifier.
+ Query identifiers can be displayed in the pg_stat_activity
+ view, using EXPLAIN, or emitted in the log if
+ configured via the log_line_prefix parameter.
+ The pg_stat_statements extension also requires a query
+ identifier to be computed. Note that an external module can
+ alternatively be used if the in-core query identifier computation
+ method is not acceptable. In this case, in-core computation
+ must be always disabled.
+ Valid values are off (always disabled),
+ on (always enabled), auto,
+ which lets modules such as pg_stat_statements
+ automatically enable it, and regress which
+ has the same effect as auto, except that the
+ query identifier is not shown in the EXPLAIN output
+ in order to facilitate automated regression testing.
+ The default is auto.
+
Note
+ To ensure that only one query identifier is calculated and
+ displayed, extensions that calculate query identifiers should
+ throw an error if a query identifier has already been computed.
+
log_statement_stats (boolean)
+
+
log_parser_stats (boolean)
+
+
log_planner_stats (boolean)
+
+
log_executor_stats (boolean)
+
+ #
+ For each query, output performance statistics of the respective
+ module to the server log. This is a crude profiling
+ instrument, similar to the Unix getrusage() operating
+ system facility. log_statement_stats reports total
+ statement statistics, while the others report per-module statistics.
+ log_statement_stats cannot be enabled together with
+ any of the per-module options. All of these options are disabled by
+ default.
+ Only superusers and users with the appropriate SET
+ privilege can change these settings.
+
+ For additional information on tuning these settings,
+ see Section 30.5.
+
wal_level (enum)
+
+ #
+ wal_level determines how much information is written to
+ the WAL. The default value is replica, which writes enough
+ data to support WAL archiving and replication, including running
+ read-only queries on a standby server. minimal removes all
+ logging except the information required to recover from a crash or
+ immediate shutdown. Finally,
+ logical adds information necessary to support logical
+ decoding. Each level includes the information logged at all lower
+ levels. This parameter can only be set at server start.
+
+ The minimal level generates the least WAL
+ volume. It logs no row information for permanent relations
+ in transactions that create or
+ rewrite them. This can make operations much faster (see
+ Section 14.4.7). Operations that initiate this
+ optimization include:
+
ALTER ... SET TABLESPACE |
CLUSTER |
CREATE TABLE |
REFRESH MATERIALIZED VIEW
+ (without CONCURRENTLY) |
REINDEX |
TRUNCATE |
+ However, minimal WAL does not contain sufficient information for
+ point-in-time recovery, so replica or
+ higher must be used to enable continuous archiving
+ (archive_mode) and streaming binary replication.
+ In fact, the server will not even start in this mode if
+ max_wal_senders is non-zero.
+ Note that changing wal_level to
+ minimal makes previous base backups unusable
+ for point-in-time recovery and standby servers.
+
+ In logical level, the same information is logged as
+ with replica, plus information needed to
+ extract logical change sets from the WAL. Using a level of
+ logical will increase the WAL volume, particularly if many
+ tables are configured for REPLICA IDENTITY FULL and
+ many UPDATE and DELETE statements are
+ executed.
+
+ In releases prior to 9.6, this parameter also allowed the
+ values archive and hot_standby.
+ These are still accepted but mapped to replica.
+
fsync (boolean)
+
+ #
+ If this parameter is on, the PostgreSQL server
+ will try to make sure that updates are physically written to
+ disk, by issuing fsync() system calls or various
+ equivalent methods (see wal_sync_method).
+ This ensures that the database cluster can recover to a
+ consistent state after an operating system or hardware crash.
+
+ While turning off fsync is often a performance
+ benefit, this can result in unrecoverable data corruption in
+ the event of a power failure or system crash. Thus it
+ is only advisable to turn off fsync if
+ you can easily recreate your entire database from external
+ data.
+
+ Examples of safe circumstances for turning off
+ fsync include the initial loading of a new
+ database cluster from a backup file, using a database cluster
+ for processing a batch of data after which the database
+ will be thrown away and recreated,
+ or for a read-only database clone which
+ gets recreated frequently and is not used for failover. High
+ quality hardware alone is not a sufficient justification for
+ turning off fsync.
+
+ For reliable recovery when changing fsync
+ off to on, it is necessary to force all modified buffers in the
+ kernel to durable storage. This can be done while the cluster
+ is shutdown or while fsync is on by running initdb
+ --sync-only, running sync, unmounting the
+ file system, or rebooting the server.
+
+ In many situations, turning off synchronous_commit
+ for noncritical transactions can provide much of the potential
+ performance benefit of turning off fsync, without
+ the attendant risks of data corruption.
+
+ fsync can only be set in the postgresql.conf
+ file or on the server command line.
+ If you turn this parameter off, also consider turning off
+ full_page_writes.
+
synchronous_commit (enum)
+
+ #
+ Specifies how much WAL processing must complete before
+ the database server returns a “success”
+ indication to the client. Valid values are
+ remote_apply, on
+ (the default), remote_write,
+ local, and off.
+
+ If synchronous_standby_names is empty,
+ the only meaningful settings are on and
+ off; remote_apply,
+ remote_write and local
+ all provide the same local synchronization level
+ as on. The local behavior of all
+ non-off modes is to wait for local flush of WAL
+ to disk. In off mode, there is no waiting,
+ so there can be a delay between when success is reported to the
+ client and when the transaction is later guaranteed to be safe
+ against a server crash. (The maximum
+ delay is three times wal_writer_delay.) Unlike
+ fsync, setting this parameter to off
+ does not create any risk of database inconsistency: an operating
+ system or database crash might
+ result in some recent allegedly-committed transactions being lost, but
+ the database state will be just the same as if those transactions had
+ been aborted cleanly. So, turning synchronous_commit off
+ can be a useful alternative when performance is more important than
+ exact certainty about the durability of a transaction. For more
+ discussion see Section 30.4.
+
+ If synchronous_standby_names is non-empty,
+ synchronous_commit also controls whether
+ transaction commits will wait for their WAL records to be
+ processed on the standby server(s).
+
+ When set to remote_apply, commits will wait
+ until replies from the current synchronous standby(s) indicate they
+ have received the commit record of the transaction and applied
+ it, so that it has become visible to queries on the standby(s),
+ and also written to durable storage on the standbys. This will
+ cause much larger commit delays than previous settings since
+ it waits for WAL replay. When set to on,
+ commits wait until replies
+ from the current synchronous standby(s) indicate they have received
+ the commit record of the transaction and flushed it to durable storage. This
+ ensures the transaction will not be lost unless both the primary and
+ all synchronous standbys suffer corruption of their database storage.
+ When set to remote_write, commits will wait until replies
+ from the current synchronous standby(s) indicate they have
+ received the commit record of the transaction and written it to
+ their file systems. This setting ensures data preservation if a standby instance of
+ PostgreSQL crashes, but not if the standby
+ suffers an operating-system-level crash because the data has not
+ necessarily reached durable storage on the standby.
+ The setting local causes commits to wait for
+ local flush to disk, but not for replication. This is usually not
+ desirable when synchronous replication is in use, but is provided for
+ completeness.
+
+ This parameter can be changed at any time; the behavior for any
+ one transaction is determined by the setting in effect when it
+ commits. It is therefore possible, and useful, to have some
+ transactions commit synchronously and others asynchronously.
+ For example, to make a single multistatement transaction commit
+ asynchronously when the default is the opposite, issue SET
+ LOCAL synchronous_commit TO OFF within the transaction.
+
+ Table 20.1 summarizes the
+ capabilities of the synchronous_commit settings.
+
Table 20.1. synchronous_commit Modes
| synchronous_commit setting | local durable commit | standby durable commit after PG crash | standby durable commit after OS crash | standby query consistency |
|---|
| remote_apply | • | • | • | • |
| on | • | • | • | |
| remote_write | • | • | | |
| local | • | | | |
| off | | | | |
wal_sync_method (enum)
+
+ #
+ Method used for forcing WAL updates out to disk.
+ If fsync is off then this setting is irrelevant,
+ since WAL file updates will not be forced out at all.
+ Possible values are:
+
+ open_datasync (write WAL files with open() option O_DSYNC)
+
+ fdatasync (call fdatasync() at each commit)
+
+ fsync (call fsync() at each commit)
+
+ fsync_writethrough (call fsync() at each commit, forcing write-through of any disk write cache)
+
+ open_sync (write WAL files with open() option O_SYNC)
+
+ Not all of these choices are available on all platforms.
+ The default is the first method in the above list that is supported
+ by the platform, except that fdatasync is the default on
+ Linux and FreeBSD. The default is not necessarily ideal; it might be
+ necessary to change this setting or other aspects of your system
+ configuration in order to create a crash-safe configuration or
+ achieve optimal performance.
+ These aspects are discussed in Section 30.1.
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
full_page_writes (boolean)
+
+ #
+ When this parameter is on, the PostgreSQL server
+ writes the entire content of each disk page to WAL during the
+ first modification of that page after a checkpoint.
+ This is needed because
+ a page write that is in process during an operating system crash might
+ be only partially completed, leading to an on-disk page
+ that contains a mix of old and new data. The row-level change data
+ normally stored in WAL will not be enough to completely restore
+ such a page during post-crash recovery. Storing the full page image
+ guarantees that the page can be correctly restored, but at the price
+ of increasing the amount of data that must be written to WAL.
+ (Because WAL replay always starts from a checkpoint, it is sufficient
+ to do this during the first change of each page after a checkpoint.
+ Therefore, one way to reduce the cost of full-page writes is to
+ increase the checkpoint interval parameters.)
+
+ Turning this parameter off speeds normal operation, but
+ might lead to either unrecoverable data corruption, or silent
+ data corruption, after a system failure. The risks are similar to turning off
+ fsync, though smaller, and it should be turned off
+ only based on the same circumstances recommended for that parameter.
+
+ Turning off this parameter does not affect use of
+ WAL archiving for point-in-time recovery (PITR)
+ (see Section 26.3).
+
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+ The default is on.
+
wal_log_hints (boolean)
+
+ #
+ When this parameter is on, the PostgreSQL
+ server writes the entire content of each disk page to WAL during the
+ first modification of that page after a checkpoint, even for
+ non-critical modifications of so-called hint bits.
+
+ If data checksums are enabled, hint bit updates are always WAL-logged
+ and this setting is ignored. You can use this setting to test how much
+ extra WAL-logging would occur if your database had data checksums
+ enabled.
+
+ This parameter can only be set at server start. The default value is off.
+
wal_compression (enum)
+
+ #
+ This parameter enables compression of WAL using the specified
+ compression method.
+ When enabled, the PostgreSQL
+ server compresses full page images written to WAL when
+ full_page_writes is on or during a base backup.
+ A compressed page image will be decompressed during WAL replay.
+ The supported methods are pglz,
+ lz4 (if PostgreSQL
+ was compiled with --with-lz4) and
+ zstd (if PostgreSQL
+ was compiled with --with-zstd).
+ The default value is off.
+ Only superusers and users with the appropriate SET
+ privilege can change this setting.
+
+ Enabling compression can reduce the WAL volume without
+ increasing the risk of unrecoverable data corruption,
+ but at the cost of some extra CPU spent on the compression during
+ WAL logging and on the decompression during WAL replay.
+
wal_init_zero (boolean)
+
+ #
+ If set to on (the default), this option causes new
+ WAL files to be filled with zeroes. On some file systems, this ensures
+ that space is allocated before we need to write WAL records. However,
+ Copy-On-Write (COW) file systems may not benefit
+ from this technique, so the option is given to skip the unnecessary
+ work. If set to off, only the final byte is written
+ when the file is created so that it has the expected size.
+
wal_recycle (boolean)
+
+ #
+ If set to on (the default), this option causes WAL
+ files to be recycled by renaming them, avoiding the need to create new
+ ones. On COW file systems, it may be faster to create new ones, so the
+ option is given to disable this behavior.
+
wal_buffers (integer)
+
+ #
+ The amount of shared memory used for WAL data that has not yet been
+ written to disk. The default setting of -1 selects a size equal to
+ 1/32nd (about 3%) of shared_buffers, but not less
+ than 64kB nor more than the size of one WAL
+ segment, typically 16MB. This value can be set
+ manually if the automatic choice is too large or too small,
+ but any positive value less than 32kB will be
+ treated as 32kB.
+ If this value is specified without units, it is taken as WAL blocks,
+ that is XLOG_BLCKSZ bytes, typically 8kB.
+ This parameter can only be set at server start.
+
+ The contents of the WAL buffers are written out to disk at every
+ transaction commit, so extremely large values are unlikely to
+ provide a significant benefit. However, setting this value to at
+ least a few megabytes can improve write performance on a busy
+ server where many clients are committing at once. The auto-tuning
+ selected by the default setting of -1 should give reasonable
+ results in most cases.
+
wal_writer_delay (integer)
+
+ #
+ Specifies how often the WAL writer flushes WAL, in time terms.
+ After flushing WAL the writer sleeps for the length of time given
+ by wal_writer_delay, unless woken up sooner
+ by an asynchronously committing transaction. If the last flush
+ happened less than wal_writer_delay ago and less
+ than wal_writer_flush_after worth of WAL has been
+ produced since, then WAL is only written to the operating system, not
+ flushed to disk.
+ If this value is specified without units, it is taken as milliseconds.
+ The default value is 200 milliseconds (200ms). Note that
+ on many systems, the effective resolution of sleep delays is 10
+ milliseconds; setting wal_writer_delay to a value that is
+ not a multiple of 10 might have the same results as setting it to the
+ next higher multiple of 10. This parameter can only be set in the
+ postgresql.conf file or on the server command line.
+
wal_writer_flush_after (integer)
+
+ #
+ Specifies how often the WAL writer flushes WAL, in volume terms.
+ If the last flush happened less
+ than wal_writer_delay ago and less
+ than wal_writer_flush_after worth of WAL has been
+ produced since, then WAL is only written to the operating system, not
+ flushed to disk. If wal_writer_flush_after is set
+ to 0 then WAL data is always flushed immediately.
+ If this value is specified without units, it is taken as WAL blocks,
+ that is XLOG_BLCKSZ bytes, typically 8kB.
+ The default is 1MB.
+ This parameter can only be set in the
+ postgresql.conf file or on the server command line.
+
wal_skip_threshold (integer)
+
+ #
+ When wal_level is minimal and a
+ transaction commits after creating or rewriting a permanent relation,
+ this setting determines how to persist the new data. If the data is
+ smaller than this setting, write it to the WAL log; otherwise, use an
+ fsync of affected files. Depending on the properties of your storage,
+ raising or lowering this value might help if such commits are slowing
+ concurrent transactions. If this value is specified without units, it
+ is taken as kilobytes. The default is two megabytes
+ (2MB).
+
commit_delay (integer)
+
+ #
+ Setting commit_delay adds a time delay
+ before a WAL flush is initiated. This can improve
+ group commit throughput by allowing a larger number of transactions
+ to commit via a single WAL flush, if system load is high enough
+ that additional transactions become ready to commit within the
+ given interval. However, it also increases latency by up to the
+ commit_delay for each WAL
+ flush. Because the delay is just wasted if no other transactions
+ become ready to commit, a delay is only performed if at least
+ commit_siblings other transactions are active
+ when a flush is about to be initiated. Also, no delays are
+ performed if fsync is disabled.
+ If this value is specified without units, it is taken as microseconds.
+ The default commit_delay is zero (no delay).
+ Only superusers and users with the appropriate SET
+ privilege can change this setting.
+
+ In PostgreSQL releases prior to 9.3,
+ commit_delay behaved differently and was much
+ less effective: it affected only commits, rather than all WAL flushes,
+ and waited for the entire configured delay even if the WAL flush
+ was completed sooner. Beginning in PostgreSQL 9.3,
+ the first process that becomes ready to flush waits for the configured
+ interval, while subsequent processes wait only until the leader
+ completes the flush operation.
+
commit_siblings (integer)
+
+ #
+ Minimum number of concurrent open transactions to require
+ before performing the commit_delay delay. A larger
+ value makes it more probable that at least one other
+ transaction will become ready to commit during the delay
+ interval. The default is five transactions.
+
checkpoint_timeout (integer)
+
+ #
+ Maximum time between automatic WAL checkpoints.
+ If this value is specified without units, it is taken as seconds.
+ The valid range is between 30 seconds and one day.
+ The default is five minutes (5min).
+ Increasing this parameter can increase the amount of time needed
+ for crash recovery.
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
checkpoint_completion_target (floating point)
+
+ #
+ Specifies the target of checkpoint completion, as a fraction of
+ total time between checkpoints. The default is 0.9, which spreads the
+ checkpoint across almost all of the available interval, providing fairly
+ consistent I/O load while also leaving some time for checkpoint
+ completion overhead. Reducing this parameter is not recommended because
+ it causes the checkpoint to complete faster. This results in a higher
+ rate of I/O during the checkpoint followed by a period of less I/O between
+ the checkpoint completion and the next scheduled checkpoint. This
+ parameter can only be set in the postgresql.conf file
+ or on the server command line.
+
checkpoint_flush_after (integer)
+
+ #
+ Whenever more than this amount of data has been
+ written while performing a checkpoint, attempt to force the
+ OS to issue these writes to the underlying storage. Doing so will
+ limit the amount of dirty data in the kernel's page cache, reducing
+ the likelihood of stalls when an fsync is issued at the end of the
+ checkpoint, or when the OS writes data back in larger batches in the
+ background. Often that will result in greatly reduced transaction
+ latency, but there also are some cases, especially with workloads
+ that are bigger than shared_buffers, but smaller
+ than the OS's page cache, where performance might degrade. This
+ setting may have no effect on some platforms.
+ If this value is specified without units, it is taken as blocks,
+ that is BLCKSZ bytes, typically 8kB.
+ The valid range is
+ between 0, which disables forced writeback,
+ and 2MB. The default is 256kB on
+ Linux, 0 elsewhere. (If BLCKSZ is not
+ 8kB, the default and maximum values scale proportionally to it.)
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
checkpoint_warning (integer)
+
+ #
+ Write a message to the server log if checkpoints caused by
+ the filling of WAL segment files happen closer together
+ than this amount of time (which suggests that
+ max_wal_size ought to be raised).
+ If this value is specified without units, it is taken as seconds.
+ The default is 30 seconds (30s).
+ Zero disables the warning.
+ No warnings will be generated if checkpoint_timeout
+ is less than checkpoint_warning.
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
max_wal_size (integer)
+
+ #
+ Maximum size to let the WAL grow during automatic
+ checkpoints. This is a soft limit; WAL size can exceed
+ max_wal_size under special circumstances, such as
+ heavy load, a failing archive_command or archive_library, or a high
+ wal_keep_size setting.
+ If this value is specified without units, it is taken as megabytes.
+ The default is 1 GB.
+ Increasing this parameter can increase the amount of time needed for
+ crash recovery.
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
min_wal_size (integer)
+
+ #
+ As long as WAL disk usage stays below this setting, old WAL files are
+ always recycled for future use at a checkpoint, rather than removed.
+ This can be used to ensure that enough WAL space is reserved to
+ handle spikes in WAL usage, for example when running large batch
+ jobs.
+ If this value is specified without units, it is taken as megabytes.
+ The default is 80 MB.
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
archive_mode (enum)
+
+ #
+ When archive_mode is enabled, completed WAL segments
+ are sent to archive storage by setting
+ archive_command or
+ archive_library. In addition to off,
+ to disable, there are two modes: on, and
+ always. During normal operation, there is no
+ difference between the two modes, but when set to always
+ the WAL archiver is enabled also during archive recovery or standby
+ mode. In always mode, all files restored from the archive
+ or streamed with streaming replication will be archived (again). See
+ Section 27.2.9 for details.
+
+ archive_mode is a separate setting from
+ archive_command and
+ archive_library so that
+ archive_command and
+ archive_library can be changed without leaving
+ archiving mode.
+ This parameter can only be set at server start.
+ archive_mode cannot be enabled when
+ wal_level is set to minimal.
+
archive_command (string)
+
+ #
+ The local shell command to execute to archive a completed WAL file
+ segment. Any %p in the string is
+ replaced by the path name of the file to archive, and any
+ %f is replaced by only the file name.
+ (The path name is relative to the working directory of the server,
+ i.e., the cluster's data directory.)
+ Use %% to embed an actual % character in the
+ command. It is important for the command to return a zero
+ exit status only if it succeeds. For more information see
+ Section 26.3.1.
+
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line. It is only used if
+ archive_mode was enabled at server start and
+ archive_library is set to an empty string. If both
+ archive_command and archive_library
+ are set, an error will be raised.
+ If archive_command is an empty string (the default) while
+ archive_mode is enabled (and archive_library
+ is set to an empty string), WAL archiving is temporarily
+ disabled, but the server continues to accumulate WAL segment files in
+ the expectation that a command will soon be provided. Setting
+ archive_command to a command that does nothing but
+ return true, e.g., /bin/true (REM on
+ Windows), effectively disables
+ archiving, but also breaks the chain of WAL files needed for
+ archive recovery, so it should only be used in unusual circumstances.
+
archive_library (string)
+
+ #
+ The library to use for archiving completed WAL file segments. If set to
+ an empty string (the default), archiving via shell is enabled, and
+ archive_command is used. If both
+ archive_command and archive_library
+ are set, an error will be raised. Otherwise, the specified
+ shared library is used for archiving. The WAL archiver process is
+ restarted by the postmaster when this parameter changes. For more
+ information, see Section 26.3.1 and
+ Chapter 51.
+
+ This parameter can only be set in the
+ postgresql.conf file or on the server command line.
+
archive_timeout (integer)
+
+ #
+ The archive_command or archive_library is only invoked for
+ completed WAL segments. Hence, if your server generates little WAL
+ traffic (or has slack periods where it does so), there could be a
+ long delay between the completion of a transaction and its safe
+ recording in archive storage. To limit how old unarchived
+ data can be, you can set archive_timeout to force the
+ server to switch to a new WAL segment file periodically. When this
+ parameter is greater than zero, the server will switch to a new
+ segment file whenever this amount of time has elapsed since the last
+ segment file switch, and there has been any database activity,
+ including a single checkpoint (checkpoints are skipped if there is
+ no database activity). Note that archived files that are closed
+ early due to a forced switch are still the same length as completely
+ full files. Therefore, it is unwise to use a very short
+ archive_timeout — it will bloat your archive
+ storage. archive_timeout settings of a minute or so are
+ usually reasonable. You should consider using streaming replication,
+ instead of archiving, if you want data to be copied off the primary
+ server more quickly than that.
+ If this value is specified without units, it is taken as seconds.
+ This parameter can only be set in the
+ postgresql.conf file or on the server command line.
+
+ This section describes the settings that apply to recovery in general,
+ affecting crash recovery, streaming replication and archive-based
+ replication.
+
recovery_prefetch (enum)
+
+ #
+ Whether to try to prefetch blocks that are referenced in the WAL that
+ are not yet in the buffer pool, during recovery. Valid values are
+ off, on and
+ try (the default). The setting
+ try enables
+ prefetching only if the operating system provides the
+ posix_fadvise function, which is currently used
+ to implement prefetching. Note that some operating systems provide the
+ function, but it doesn't do anything.
+
+ Prefetching blocks that will soon be needed can reduce I/O wait times
+ during recovery with some workloads.
+ See also the wal_decode_buffer_size and
+ maintenance_io_concurrency settings, which limit
+ prefetching activity.
+
wal_decode_buffer_size (integer)
+
+ #
+ A limit on how far ahead the server can look in the WAL, to find
+ blocks to prefetch. If this value is specified without units, it is
+ taken as bytes.
+ The default is 512kB.
+
20.5.5. Archive Recovery #
+ This section describes the settings that apply only for the duration of
+ the recovery. They must be reset for any subsequent recovery you wish to
+ perform.
+
+ “Recovery” covers using the server as a standby or for
+ executing a targeted recovery. Typically, standby mode would be used to
+ provide high availability and/or read scalability, whereas a targeted
+ recovery is used to recover from data loss.
+
+ To start the server in standby mode, create a file called
+ standby.signal
+ in the data directory. The server will enter recovery and will not stop
+ recovery when the end of archived WAL is reached, but will keep trying to
+ continue recovery by connecting to the sending server as specified by the
+ primary_conninfo setting and/or by fetching new WAL
+ segments using restore_command. For this mode, the
+ parameters from this section and Section 20.6.3 are of interest.
+ Parameters from Section 20.5.6 will
+ also be applied but are typically not useful in this mode.
+
+ To start the server in targeted recovery mode, create a file called
+ recovery.signal
+ in the data directory. If both standby.signal and
+ recovery.signal files are created, standby mode
+ takes precedence. Targeted recovery mode ends when the archived WAL is
+ fully replayed, or when recovery_target is reached.
+ In this mode, the parameters from both this section and Section 20.5.6 will be used.
+
restore_command (string)
+
+ #
+ The local shell command to execute to retrieve an archived segment of
+ the WAL file series. This parameter is required for archive recovery,
+ but optional for streaming replication.
+ Any %f in the string is
+ replaced by the name of the file to retrieve from the archive,
+ and any %p is replaced by the copy destination path name
+ on the server.
+ (The path name is relative to the current working directory,
+ i.e., the cluster's data directory.)
+ Any %r is replaced by the name of the file containing the
+ last valid restart point. That is the earliest file that must be kept
+ to allow a restore to be restartable, so this information can be used
+ to truncate the archive to just the minimum required to support
+ restarting from the current restore. %r is typically only
+ used by warm-standby configurations
+ (see Section 27.2).
+ Write %% to embed an actual % character.
+
+ It is important for the command to return a zero exit status
+ only if it succeeds. The command will be asked for file
+ names that are not present in the archive; it must return nonzero
+ when so asked. Examples:
+
+restore_command = 'cp /mnt/server/archivedir/%f "%p"'
+restore_command = 'copy "C:\\server\\archivedir\\%f" "%p"' # Windows
+
+ An exception is that if the command was terminated by a signal (other
+ than SIGTERM, which is used as part of a
+ database server shutdown) or an error by the shell (such as command
+ not found), then recovery will abort and the server will not start up.
+
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
archive_cleanup_command (string)
+
+ #
+ This optional parameter specifies a shell command that will be executed
+ at every restartpoint. The purpose of
+ archive_cleanup_command is to provide a mechanism for
+ cleaning up old archived WAL files that are no longer needed by the
+ standby server.
+ Any %r is replaced by the name of the file containing the
+ last valid restart point.
+ That is the earliest file that must be kept to allow a
+ restore to be restartable, and so all files earlier than %r
+ may be safely removed.
+ This information can be used to truncate the archive to just the
+ minimum required to support restart from the current restore.
+ The pg_archivecleanup module
+ is often used in archive_cleanup_command for
+ single-standby configurations, for example:
+
archive_cleanup_command = 'pg_archivecleanup /mnt/server/archivedir %r'
+ Note however that if multiple standby servers are restoring from the
+ same archive directory, you will need to ensure that you do not delete
+ WAL files until they are no longer needed by any of the servers.
+ archive_cleanup_command would typically be used in a
+ warm-standby configuration (see Section 27.2).
+ Write %% to embed an actual % character in the
+ command.
+
+ If the command returns a nonzero exit status then a warning log
+ message will be written. An exception is that if the command was
+ terminated by a signal or an error by the shell (such as command not
+ found), a fatal error will be raised.
+
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
recovery_end_command (string)
+
+ #
+ This parameter specifies a shell command that will be executed once only
+ at the end of recovery. This parameter is optional. The purpose of the
+ recovery_end_command is to provide a mechanism for cleanup
+ following replication or recovery.
+ Any %r is replaced by the name of the file containing the
+ last valid restart point, like in archive_cleanup_command.
+
+ If the command returns a nonzero exit status then a warning log
+ message will be written and the database will proceed to start up
+ anyway. An exception is that if the command was terminated by a
+ signal or an error by the shell (such as command not found), the
+ database will not proceed with startup.
+
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
20.5.6. Recovery Target #
+ By default, recovery will recover to the end of the WAL log. The
+ following parameters can be used to specify an earlier stopping point.
+ At most one of recovery_target,
+ recovery_target_lsn, recovery_target_name,
+ recovery_target_time, or recovery_target_xid
+ can be used; if more than one of these is specified in the configuration
+ file, an error will be raised.
+ These parameters can only be set at server start.
+
recovery_target = 'immediate'
+
+ #
+ This parameter specifies that recovery should end as soon as a
+ consistent state is reached, i.e., as early as possible. When restoring
+ from an online backup, this means the point where taking the backup
+ ended.
+
+ Technically, this is a string parameter, but 'immediate'
+ is currently the only allowed value.
+
recovery_target_name (string)
+
+ #
+ This parameter specifies the named restore point (created with
+ pg_create_restore_point()) to which recovery will proceed.
+
recovery_target_time (timestamp)
+
+ #
+ This parameter specifies the time stamp up to which recovery
+ will proceed.
+ The precise stopping point is also influenced by
+ recovery_target_inclusive.
+
+ The value of this parameter is a time stamp in the same format
+ accepted by the timestamp with time zone data type,
+ except that you cannot use a time zone abbreviation (unless the
+ timezone_abbreviations variable has been set
+ earlier in the configuration file). Preferred style is to use a
+ numeric offset from UTC, or you can write a full time zone name,
+ e.g., Europe/Helsinki not EEST.
+
recovery_target_xid (string)
+
+ #
+ This parameter specifies the transaction ID up to which recovery
+ will proceed. Keep in mind
+ that while transaction IDs are assigned sequentially at transaction
+ start, transactions can complete in a different numeric order.
+ The transactions that will be recovered are those that committed
+ before (and optionally including) the specified one.
+ The precise stopping point is also influenced by
+ recovery_target_inclusive.
+
recovery_target_lsn (pg_lsn)
+
+ #
+ This parameter specifies the LSN of the write-ahead log location up
+ to which recovery will proceed. The precise stopping point is also
+ influenced by recovery_target_inclusive. This
+ parameter is parsed using the system data type
+ pg_lsn.
+
+ The following options further specify the recovery target, and affect
+ what happens when the target is reached:
+
recovery_target_inclusive (boolean)
+
+ #
+ Specifies whether to stop just after the specified recovery target
+ (on), or just before the recovery target
+ (off).
+ Applies when recovery_target_lsn,
+ recovery_target_time, or
+ recovery_target_xid is specified.
+ This setting controls whether transactions
+ having exactly the target WAL location (LSN), commit time, or transaction ID, respectively, will
+ be included in the recovery. Default is on.
+
recovery_target_timeline (string)
+
+ #
+ Specifies recovering into a particular timeline. The value can be a
+ numeric timeline ID or a special value. The value
+ current recovers along the same timeline that was
+ current when the base backup was taken. The
+ value latest recovers
+ to the latest timeline found in the archive, which is useful in
+ a standby server. latest is the default.
+
+ To specify a timeline ID in hexadecimal (for example, if extracted
+ from a WAL file name or history file), prefix it with a
+ 0x. For instance, if the WAL file name is
+ 00000011000000A10000004F, then the timeline ID is
+ 0x11 (or 17 decimal).
+
+ You usually only need to set this parameter
+ in complex re-recovery situations, where you need to return to
+ a state that itself was reached after a point-in-time recovery.
+ See Section 26.3.5 for discussion.
+
recovery_target_action (enum)
+
+ #
+ Specifies what action the server should take once the recovery target is
+ reached. The default is pause, which means recovery will
+ be paused. promote means the recovery process will finish
+ and the server will start to accept connections.
+ Finally shutdown will stop the server after reaching the
+ recovery target.
+
+ The intended use of the pause setting is to allow queries
+ to be executed against the database to check if this recovery target
+ is the most desirable point for recovery.
+ The paused state can be resumed by
+ using pg_wal_replay_resume() (see
+ Table 9.93), which then
+ causes recovery to end. If this recovery target is not the
+ desired stopping point, then shut down the server, change the
+ recovery target settings to a later target and restart to
+ continue recovery.
+
+ The shutdown setting is useful to have the instance ready
+ at the exact replay point desired. The instance will still be able to
+ replay more WAL records (and in fact will have to replay WAL records
+ since the last checkpoint next time it is started).
+
+ Note that because recovery.signal will not be
+ removed when recovery_target_action is set to shutdown,
+ any subsequent start will end with immediate shutdown unless the
+ configuration is changed or the recovery.signal
+ file is removed manually.
+
+ This setting has no effect if no recovery target is set.
+ If hot_standby is not enabled, a setting of
+ pause will act the same as shutdown.
+ If the recovery target is reached while a promotion is ongoing,
+ a setting of pause will act the same as
+ promote.
+
+ In any case, if a recovery target is configured but the archive
+ recovery ends before the target is reached, the server will shut down
+ with a fatal error.
+
Chapter 20. Server Configuration
+ There are many configuration parameters that affect the behavior of
+ the database system. In the first section of this chapter we
+ describe how to interact with configuration parameters. The subsequent sections
+ discuss each parameter in detail.
+
Chapter 19. Server Setup and Operation
+ This chapter discusses how to set up and run the database server,
+ and its interactions with the operating system.
+
+ The directions in this chapter assume that you are working with
+ plain PostgreSQL without any additional
+ infrastructure, for example a copy that you built from source
+ according to the directions in the preceding chapters.
+ If you are working with a pre-packaged or vendor-supplied
+ version of PostgreSQL, it is likely that
+ the packager has made special provisions for installing and starting
+ the database server according to your system's conventions.
+ Consult the package-level documentation for details.
+
55.3. SASL Authentication #
+ SASL is a framework for authentication in connection-oriented
+ protocols. At the moment, PostgreSQL implements two SASL
+ authentication mechanisms, SCRAM-SHA-256 and SCRAM-SHA-256-PLUS. More
+ might be added in the future. The below steps illustrate how SASL
+ authentication is performed in general, while the next subsection gives
+ more details on SCRAM-SHA-256 and SCRAM-SHA-256-PLUS.
+
SASL Authentication Message Flow
+ To begin a SASL authentication exchange, the server sends an
+ AuthenticationSASL message. It includes a list of SASL authentication
+ mechanisms that the server can accept, in the server's preferred order.
+
+ The client selects one of the supported mechanisms from the list, and sends
+ a SASLInitialResponse message to the server. The message includes the name
+ of the selected mechanism, and an optional Initial Client Response, if the
+ selected mechanism uses that.
+
+ One or more server-challenge and client-response message will follow. Each
+ server-challenge is sent in an AuthenticationSASLContinue message, followed
+ by a response from client in a SASLResponse message. The particulars of
+ the messages are mechanism specific.
+
+ Finally, when the authentication exchange is completed successfully, the
+ server sends an AuthenticationSASLFinal message, followed
+ immediately by an AuthenticationOk message. The AuthenticationSASLFinal
+ contains additional server-to-client data, whose content is particular to the
+ selected authentication mechanism. If the authentication mechanism doesn't
+ use additional data that's sent at completion, the AuthenticationSASLFinal
+ message is not sent.
+
+ On error, the server can abort the authentication at any stage, and send an
+ ErrorMessage.
+
55.3.1. SCRAM-SHA-256 Authentication #
+ The implemented SASL mechanisms at the moment
+ are SCRAM-SHA-256 and its variant with channel
+ binding SCRAM-SHA-256-PLUS. They are described in
+ detail in RFC 7677
+ and RFC 5802.
+
+ When SCRAM-SHA-256 is used in PostgreSQL, the server will ignore the user name
+ that the client sends in the client-first-message. The user name
+ that was already sent in the startup message is used instead.
+ PostgreSQL supports multiple character encodings, while SCRAM
+ dictates UTF-8 to be used for the user name, so it might be impossible to
+ represent the PostgreSQL user name in UTF-8.
+
+ The SCRAM specification dictates that the password is also in UTF-8, and is
+ processed with the SASLprep algorithm.
+ PostgreSQL, however, does not require UTF-8 to be used for
+ the password. When a user's password is set, it is processed with SASLprep
+ as if it was in UTF-8, regardless of the actual encoding used. However, if
+ it is not a legal UTF-8 byte sequence, or it contains UTF-8 byte sequences
+ that are prohibited by the SASLprep algorithm, the raw password will be used
+ without SASLprep processing, instead of throwing an error. This allows the
+ password to be normalized when it is in UTF-8, but still allows a non-UTF-8
+ password to be used, and doesn't require the system to know which encoding
+ the password is in.
+
+ Channel binding is supported in PostgreSQL builds with
+ SSL support. The SASL mechanism name for SCRAM with channel binding is
+ SCRAM-SHA-256-PLUS. The channel binding type used by
+ PostgreSQL is tls-server-end-point.
+
+ In SCRAM without channel binding, the server chooses
+ a random number that is transmitted to the client to be mixed with the
+ user-supplied password in the transmitted password hash. While this
+ prevents the password hash from being successfully retransmitted in
+ a later session, it does not prevent a fake server between the real
+ server and client from passing through the server's random value
+ and successfully authenticating.
+
+ SCRAM with channel binding prevents such
+ man-in-the-middle attacks by mixing the signature of the server's
+ certificate into the transmitted password hash. While a fake server can
+ retransmit the real server's certificate, it doesn't have access to the
+ private key matching that certificate, and therefore cannot prove it is
+ the owner, causing SSL connection failure.
+
Example
+ The server sends an AuthenticationSASL message. It includes a list of
+ SASL authentication mechanisms that the server can accept.
+ This will be SCRAM-SHA-256-PLUS
+ and SCRAM-SHA-256 if the server is built with SSL
+ support, or else just the latter.
+
+ The client responds by sending a SASLInitialResponse message, which
+ indicates the chosen mechanism, SCRAM-SHA-256 or
+ SCRAM-SHA-256-PLUS. (A client is free to choose either
+ mechanism, but for better security it should choose the channel-binding
+ variant if it can support it.) In the Initial Client response field, the
+ message contains the SCRAM client-first-message.
+ The client-first-message also contains the channel
+ binding type chosen by the client.
+
+ Server sends an AuthenticationSASLContinue message, with a SCRAM
+ server-first-message as the content.
+
+ Client sends a SASLResponse message, with SCRAM
+ client-final-message as the content.
+
+ Server sends an AuthenticationSASLFinal message, with the SCRAM
+ server-final-message, followed immediately by
+ an AuthenticationOk message.
+
F.39. seg — a datatype for line segments or floating point intervals #
+ This module implements a data type seg for
+ representing line segments, or floating point intervals.
+ seg can represent uncertainty in the interval endpoints,
+ making it especially useful for representing laboratory measurements.
+
+ This module is considered “trusted”, that is, it can be
+ installed by non-superusers who have CREATE privilege
+ on the current database.
+
+ The geometry of measurements is usually more complex than that of a
+ point in a numeric continuum. A measurement is usually a segment of
+ that continuum with somewhat fuzzy limits. The measurements come out
+ as intervals because of uncertainty and randomness, as well as because
+ the value being measured may naturally be an interval indicating some
+ condition, such as the temperature range of stability of a protein.
+
+ Using just common sense, it appears more convenient to store such data
+ as intervals, rather than pairs of numbers. In practice, it even turns
+ out more efficient in most applications.
+
+ Further along the line of common sense, the fuzziness of the limits
+ suggests that the use of traditional numeric data types leads to a
+ certain loss of information. Consider this: your instrument reads
+ 6.50, and you input this reading into the database. What do you get
+ when you fetch it? Watch:
+
+
+test=> select 6.50 :: float8 as "pH";
+ pH
+---
+6.5
+(1 row)
+
+
+ In the world of measurements, 6.50 is not the same as 6.5. It may
+ sometimes be critically different. The experimenters usually write
+ down (and publish) the digits they trust. 6.50 is actually a fuzzy
+ interval contained within a bigger and even fuzzier interval, 6.5,
+ with their center points being (probably) the only common feature they
+ share. We definitely do not want such different data items to appear the
+ same.
+
+ Conclusion? It is nice to have a special data type that can record the
+ limits of an interval with arbitrarily variable precision. Variable in
+ the sense that each data element records its own precision.
+
+ Check this out:
+
+
+test=> select '6.25 .. 6.50'::seg as "pH";
+ pH
+------------
+6.25 .. 6.50
+(1 row)
+
+
+ The external representation of an interval is formed using one or two
+ floating-point numbers joined by the range operator (..
+ or ...). Alternatively, it can be specified as a
+ center point plus or minus a deviation.
+ Optional certainty indicators (<,
+ > or ~) can be stored as well.
+ (Certainty indicators are ignored by all the built-in operators, however.)
+ Table F.28 gives an overview of allowed
+ representations; Table F.29 shows some
+ examples.
+
+ In Table F.28, x, y, and
+ delta denote
+ floating-point numbers. x and y, but
+ not delta, can be preceded by a certainty indicator.
+
Table F.28. seg External Representations
x | Single value (zero-length interval)
+ |
x .. y | Interval from x to y
+ |
x (+-) delta | Interval from x - delta to
+ x + delta
+ |
x .. | Open interval with lower bound x
+ |
.. x | Open interval with upper bound x
+ |
+ Because the ... operator is widely used in data sources, it is allowed
+ as an alternative spelling of the .. operator. Unfortunately, this
+ creates a parsing ambiguity: it is not clear whether the upper bound
+ in 0...23 is meant to be 23 or 0.23.
+ This is resolved by requiring at least one digit before the decimal
+ point in all numbers in seg input.
+
+ As a sanity check, seg rejects intervals with the lower bound
+ greater than the upper, for example 5 .. 2.
+
+ seg values are stored internally as pairs of 32-bit floating point
+ numbers. This means that numbers with more than 7 significant digits
+ will be truncated.
+
+ Numbers with 7 or fewer significant digits retain their
+ original precision. That is, if your query returns 0.00, you will be
+ sure that the trailing zeroes are not the artifacts of formatting: they
+ reflect the precision of the original data. The number of leading
+ zeroes does not affect precision: the value 0.0067 is considered to
+ have just 2 significant digits.
+
+ The seg module includes a GiST index operator class for
+ seg values.
+ The operators supported by the GiST operator class are shown in Table F.30.
+
Table F.30. Seg GiST Operators
+ Operator
+
+
+ Description
+ |
|---|
+ seg << seg
+ → boolean
+
+
+ Is the first seg entirely to the left of the second?
+ [a, b] << [c, d] is true if b < c.
+ |
+ seg >> seg
+ → boolean
+
+
+ Is the first seg entirely to the right of the second?
+ [a, b] >> [c, d] is true if a > d.
+ |
+ seg &< seg
+ → boolean
+
+
+ Does the first seg not extend to the right of the
+ second?
+ [a, b] &< [c, d] is true if b <= d.
+ |
+ seg &> seg
+ → boolean
+
+
+ Does the first seg not extend to the left of the
+ second?
+ [a, b] &> [c, d] is true if a >= c.
+ |
+ seg = seg
+ → boolean
+
+
+ Are the two segs equal?
+ |
+ seg && seg
+ → boolean
+
+
+ Do the two segs overlap?
+ |
+ seg @> seg
+ → boolean
+
+
+ Does the first seg contain the second?
+ |
+ seg <@ seg
+ → boolean
+
+
+ Is the first seg contained in the second?
+ |
+ In addition to the above operators, the usual comparison
+ operators shown in Table 9.1 are
+ available for type seg. These operators
+ first compare (a) to (c),
+ and if these are equal, compare (b) to (d). That results in
+ reasonably good sorting in most cases, which is useful if
+ you want to use ORDER BY with this type.
+
+ For examples of usage, see the regression test sql/seg.sql.
+
+ The mechanism that converts (+-) to regular ranges
+ isn't completely accurate in determining the number of significant digits
+ for the boundaries. For example, it adds an extra digit to the lower
+ boundary if the resulting interval includes a power of ten:
+
+
+postgres=> select '10(+-)1'::seg as seg;
+ seg
+---------
+9.0 .. 11 -- should be: 9 .. 11
+
+
+ The performance of an R-tree index can largely depend on the initial
+ order of input values. It may be very helpful to sort the input table
+ on the seg column; see the script sort-segments.pl
+ for an example.
+
+ Original author: Gene Selkov, Jr. <selkovjr@mcs.anl.gov>,
+ Mathematics and Computer Science Division, Argonne National Laboratory.
+
+ My thanks are primarily to Prof. Joe Hellerstein
+ (https://dsf.berkeley.edu/jmh/) for elucidating the
+ gist of the GiST (http://gist.cs.berkeley.edu/). I am
+ also grateful to all Postgres developers, present and past, for enabling
+ myself to create my own world and live undisturbed in it. And I would like
+ to acknowledge my gratitude to Argonne Lab and to the U.S. Department of
+ Energy for the years of faithful support of my database research.
+
F.40. sepgsql —
+ SELinux-, label-based mandatory access control (MAC) security module #
+ sepgsql is a loadable module that supports label-based
+ mandatory access control (MAC) based on SELinux security
+ policy.
+
Warning
+ The current implementation has significant limitations, and does not
+ enforce mandatory access control for all actions. See
+ Section F.40.7.
+
+ This module integrates with SELinux to provide an
+ additional layer of security checking above and beyond what is normally
+ provided by PostgreSQL. From the perspective of
+ SELinux, this module allows
+ PostgreSQL to function as a user-space object
+ manager. Each table or function access initiated by a DML query will be
+ checked against the system security policy. This check is in addition to
+ the usual SQL permissions checking performed by
+ PostgreSQL.
+
+ SELinux access control decisions are made using
+ security labels, which are represented by strings such as
+ system_u:object_r:sepgsql_table_t:s0. Each access control
+ decision involves two labels: the label of the subject attempting to
+ perform the action, and the label of the object on which the operation is
+ to be performed. Since these labels can be applied to any sort of object,
+ access control decisions for objects stored within the database can be
+ (and, with this module, are) subjected to the same general criteria used
+ for objects of any other type, such as files. This design is intended to
+ allow a centralized security policy to protect information assets
+ independent of the particulars of how those assets are stored.
+
+ The SECURITY LABEL statement allows assignment of
+ a security label to a database object.
+
+ sepgsql can only be used on Linux
+ 2.6.28 or higher with SELinux enabled.
+ It is not available on any other platform. You will also need
+ libselinux 2.1.10 or higher and
+ selinux-policy 3.9.13 or higher (although some
+ distributions may backport the necessary rules into older policy
+ versions).
+
+ The sestatus command allows you to check the status of
+ SELinux. A typical display is:
+
+$ sestatus
+SELinux status: enabled
+SELinuxfs mount: /selinux
+Current mode: enforcing
+Mode from config file: enforcing
+Policy version: 24
+Policy from config file: targeted
+
+ If SELinux is disabled or not installed, you must set
+ that product up first before installing this module.
+
+ To build this module, include the option --with-selinux in
+ your PostgreSQL configure command. Be sure that the
+ libselinux-devel RPM is installed at build time.
+
+ To use this module, you must include sepgsql
+ in the shared_preload_libraries parameter in
+ postgresql.conf. The module will not function correctly
+ if loaded in any other manner. Once the module is loaded, you
+ should execute sepgsql.sql in each database.
+ This will install functions needed for security label management, and
+ assign initial security labels.
+
+ Here is an example showing how to initialize a fresh database cluster
+ with sepgsql functions and security labels installed.
+ Adjust the paths shown as appropriate for your installation:
+
+$ export PGDATA=/path/to/data/directory
+$ initdb
+$ vi $PGDATA/postgresql.conf
+ change
+ #shared_preload_libraries = '' # (change requires restart)
+ to
+ shared_preload_libraries = 'sepgsql' # (change requires restart)
+$ for DBNAME in template0 template1 postgres; do
+ postgres --single -F -c exit_on_error=true $DBNAME \
+ </usr/local/pgsql/share/contrib/sepgsql.sql >/dev/null
+ done
+
+ Please note that you may see some or all of the following notifications
+ depending on the particular versions you have of
+ libselinux and selinux-policy:
+
+/etc/selinux/targeted/contexts/sepgsql_contexts: line 33 has invalid object type db_blobs
+/etc/selinux/targeted/contexts/sepgsql_contexts: line 36 has invalid object type db_language
+/etc/selinux/targeted/contexts/sepgsql_contexts: line 37 has invalid object type db_language
+/etc/selinux/targeted/contexts/sepgsql_contexts: line 38 has invalid object type db_language
+/etc/selinux/targeted/contexts/sepgsql_contexts: line 39 has invalid object type db_language
+/etc/selinux/targeted/contexts/sepgsql_contexts: line 40 has invalid object type db_language
+
+ These messages are harmless and should be ignored.
+
+ If the installation process completes without error, you can now start the
+ server normally.
+
F.40.3. Regression Tests #
+ Due to the nature of SELinux, running the
+ regression tests for sepgsql requires several extra
+ configuration steps, some of which must be done as root.
+ The regression tests will not be run by an ordinary
+ make check or make installcheck command; you must
+ set up the configuration and then invoke the test script manually.
+ The tests must be run in the contrib/sepgsql directory
+ of a configured PostgreSQL build tree. Although they require a build tree,
+ the tests are designed to be executed against an installed server,
+ that is they are comparable to make installcheck not
+ make check.
+
+ First, set up sepgsql in a working database
+ according to the instructions in Section F.40.2.
+ Note that the current operating system user must be able to connect to the
+ database as superuser without password authentication.
+
+ Second, build and install the policy package for the regression test.
+ The sepgsql-regtest policy is a special purpose policy package
+ which provides a set of rules to be allowed during the regression tests.
+ It should be built from the policy source file
+ sepgsql-regtest.te, which is done using
+ make with a Makefile supplied by SELinux.
+ You will need to locate the appropriate
+ Makefile on your system; the path shown below is only an example.
+ (This Makefile is usually supplied by the
+ selinux-policy-devel or
+ selinux-policy RPM.)
+ Once built, install this policy package using the
+ semodule command, which loads supplied policy packages
+ into the kernel. If the package is correctly installed,
+ semodule -lsepgsql-regtest as an
+ available policy package:
+
+$ cd .../contrib/sepgsql
+$ make -f /usr/share/selinux/devel/Makefile
+$ sudo semodule -u sepgsql-regtest.pp
+$ sudo semodule -l | grep sepgsql
+sepgsql-regtest 1.07
+
+ Third, turn on sepgsql_regression_test_mode.
+ For security reasons, the rules in sepgsql-regtest
+ are not enabled by default;
+ the sepgsql_regression_test_mode parameter enables
+ the rules needed to launch the regression tests.
+ It can be turned on using the setsebool command:
+
+$ sudo setsebool sepgsql_regression_test_mode on
+$ getsebool sepgsql_regression_test_mode
+sepgsql_regression_test_mode --> on
+
+ Fourth, verify your shell is operating in the unconfined_t
+ domain:
+
+$ id -Z
+unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023
+
+ See Section F.40.8 for details on adjusting your
+ working domain, if necessary.
+
+ Finally, run the regression test script:
+
+$ ./test_sepgsql
+
+ This script will attempt to verify that you have done all the configuration
+ steps correctly, and then it will run the regression tests for the
+ sepgsql module.
+
+ After completing the tests, it's recommended you disable
+ the sepgsql_regression_test_mode parameter:
+
+$ sudo setsebool sepgsql_regression_test_mode off
+
+ You might prefer to remove the sepgsql-regtest policy
+ entirely:
+
+$ sudo semodule -r sepgsql-regtest
+
-
+
sepgsql.permissive (boolean)
+
+ #
+ This parameter enables sepgsql to function
+ in permissive mode, regardless of the system setting.
+ The default is off.
+ This parameter can only be set in the postgresql.conf
+ file or on the server command line.
+
+ When this parameter is on, sepgsql functions
+ in permissive mode, even if SELinux in general is working in enforcing
+ mode. This parameter is primarily useful for testing purposes.
+
-
+
sepgsql.debug_audit (boolean)
+
+ #
+ This parameter enables the printing of audit messages regardless of
+ the system policy settings.
+ The default is off, which means that messages will be printed according
+ to the system settings.
+
+ The security policy of SELinux also has rules to
+ control whether or not particular accesses are logged.
+ By default, access violations are logged, but allowed
+ accesses are not.
+
+ This parameter forces all possible logging to be turned on, regardless
+ of the system policy.
+
F.40.5.1. Controlled Object Classes #
+ The security model of SELinux describes all the access
+ control rules as relationships between a subject entity (typically,
+ a client of the database) and an object entity (such as a database
+ object), each of which is
+ identified by a security label. If access to an unlabeled object is
+ attempted, the object is treated as if it were assigned the label
+ unlabeled_t.
+
+ Currently, sepgsql allows security labels to be
+ assigned to schemas, tables, columns, sequences, views, and functions.
+ When sepgsql is in use, security labels are
+ automatically assigned to supported database objects at creation time.
+ This label is called a default security label, and is decided according
+ to the system security policy, which takes as input the creator's label,
+ the label assigned to the new object's parent object and optionally name
+ of the constructed object.
+
+ A new database object basically inherits the security label of the parent
+ object, except when the security policy has special rules known as
+ type-transition rules, in which case a different label may be applied.
+ For schemas, the parent object is the current database; for tables,
+ sequences, views, and functions, it is the containing schema; for columns,
+ it is the containing table.
+
F.40.5.2. DML Permissions #
+ For tables, db_table:select, db_table:insert,
+ db_table:update or db_table:delete are
+ checked for all the referenced target tables depending on the kind of
+ statement; in addition, db_table:select is also checked for
+ all the tables that contain columns referenced in the
+ WHERE or RETURNING clause, as a data source
+ for UPDATE, and so on.
+
+ Column-level permissions will also be checked for each referenced column.
+ db_column:select is checked on not only the columns being
+ read using SELECT, but those being referenced in other DML
+ statements; db_column:update or db_column:insert
+ will also be checked for columns being modified by UPDATE or
+ INSERT.
+
+ For example, consider:
+
+UPDATE t1 SET x = 2, y = func1(y) WHERE z = 100;
+
+
+ Here, db_column:update will be checked for
+ t1.x, since it is being updated,
+ db_column:{select update} will be checked for
+ t1.y, since it is both updated and referenced, and
+ db_column:select will be checked for t1.z, since
+ it is only referenced.
+ db_table:{select update} will also be checked
+ at the table level.
+
+ For sequences, db_sequence:get_value is checked when we
+ reference a sequence object using SELECT; however, note that we
+ do not currently check permissions on execution of corresponding functions
+ such as lastval().
+
+ For views, db_view:expand will be checked, then any other
+ required permissions will be checked on the objects being
+ expanded from the view, individually.
+
+ For functions, db_procedure:{execute} will be checked when
+ user tries to execute a function as a part of query, or using fast-path
+ invocation. If this function is a trusted procedure, it also checks
+ db_procedure:{entrypoint} permission to check whether it
+ can perform as entry point of trusted procedure.
+
+ In order to access any schema object, db_schema:search
+ permission is required on the containing schema. When an object is
+ referenced without schema qualification, schemas on which this
+ permission is not present will not be searched (just as if the user did
+ not have USAGE privilege on the schema). If an explicit schema
+ qualification is present, an error will occur if the user does not have
+ the requisite permission on the named schema.
+
+ The client must be allowed to access all referenced tables and
+ columns, even if they originated from views which were then expanded,
+ so that we apply consistent access control rules independent of the manner
+ in which the table contents are referenced.
+
+ The default database privilege system allows database superusers to
+ modify system catalogs using DML commands, and reference or modify
+ toast tables. These operations are prohibited when
+ sepgsql is enabled.
+
F.40.5.3. DDL Permissions #
+ SELinux defines several permissions to control common
+ operations for each object type; such as creation, alter, drop and
+ relabel of security label. In addition, several object types have
+ special permissions to control their characteristic operations; such as
+ addition or deletion of name entries within a particular schema.
+
+ Creating a new database object requires create permission.
+ SELinux will grant or deny this permission based on the
+ client's security label and the proposed security label for the new
+ object. In some cases, additional privileges are required:
+
+ CREATE DATABASE additionally requires
+ getattr permission for the source or template database.
+
+ Creating a schema object additionally requires add_name
+ permission on the parent schema.
+
+ Creating a table additionally requires permission to create each
+ individual table column, just as if each table column were a
+ separate top-level object.
+
+ Creating a function marked as LEAKPROOF additionally
+ requires install permission. (This permission is also
+ checked when LEAKPROOF is set for an existing function.)
+
+ When DROP command is executed, drop will be
+ checked on the object being removed. Permissions will be also checked for
+ objects dropped indirectly via CASCADE. Deletion of objects
+ contained within a particular schema (tables, views, sequences and
+ procedures) additionally requires remove_name on the schema.
+
+ When ALTER command is executed, setattr will be
+ checked on the object being modified for each object types, except for
+ subsidiary objects such as the indexes or triggers of a table, where
+ permissions are instead checked on the parent object. In some cases,
+ additional permissions are required:
+
+ Moving an object to a new schema additionally requires
+ remove_name permission on the old schema and
+ add_name permission on the new one.
+
+ Setting the LEAKPROOF attribute on a function requires
+ install permission.
+
+ Using SECURITY LABEL on an object additionally
+ requires relabelfrom permission for the object in
+ conjunction with its old security label and relabelto
+ permission for the object in conjunction with its new security label.
+ (In cases where multiple label providers are installed and the user
+ tries to set a security label, but it is not managed by
+ SELinux, only setattr should be checked here.
+ This is currently not done due to implementation restrictions.)
+
F.40.5.4. Trusted Procedures #
+ Trusted procedures are similar to security definer functions or setuid
+ commands. SELinux provides a feature to allow trusted
+ code to run using a security label different from that of the client,
+ generally for the purpose of providing highly controlled access to
+ sensitive data (e.g., rows might be omitted, or the precision of stored
+ values might be reduced). Whether or not a function acts as a trusted
+ procedure is controlled by its security label and the operating system
+ security policy. For example:
+
+postgres=# CREATE TABLE customer (
+ cid int primary key,
+ cname text,
+ credit text
+ );
+CREATE TABLE
+postgres=# SECURITY LABEL ON COLUMN customer.credit
+ IS 'system_u:object_r:sepgsql_secret_table_t:s0';
+SECURITY LABEL
+postgres=# CREATE FUNCTION show_credit(int) RETURNS text
+ AS 'SELECT regexp_replace(credit, ''-[0-9]+$'', ''-xxxx'', ''g'')
+ FROM customer WHERE cid = $1'
+ LANGUAGE sql;
+CREATE FUNCTION
+postgres=# SECURITY LABEL ON FUNCTION show_credit(int)
+ IS 'system_u:object_r:sepgsql_trusted_proc_exec_t:s0';
+SECURITY LABEL
+
+ The above operations should be performed by an administrative user.
+
+postgres=# SELECT * FROM customer;
+ERROR: SELinux: security policy violation
+postgres=# SELECT cid, cname, show_credit(cid) FROM customer;
+ cid | cname | show_credit
+-----+--------+---------------------
+ 1 | taro | 1111-2222-3333-xxxx
+ 2 | hanako | 5555-6666-7777-xxxx
+(2 rows)
+
+ In this case, a regular user cannot reference customer.credit
+ directly, but a trusted procedure show_credit allows the user
+ to print the credit card numbers of customers with some of the digits
+ masked out.
+
F.40.5.5. Dynamic Domain Transitions #
+ It is possible to use SELinux's dynamic domain transition feature
+ to switch the security label of the client process, the client domain,
+ to a new context, if that is allowed by the security policy.
+ The client domain needs the setcurrent permission and also
+ dyntransition from the old to the new domain.
+
+ Dynamic domain transitions should be considered carefully, because they
+ allow users to switch their label, and therefore their privileges,
+ at their option, rather than (as in the case of a trusted procedure)
+ as mandated by the system.
+ Thus, the dyntransition permission is only considered
+ safe when used to switch to a domain with a smaller set of privileges than
+ the original one. For example:
+
+regression=# select sepgsql_getcon();
+ sepgsql_getcon
+-------------------------------------------------------
+ unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023
+(1 row)
+
+regression=# SELECT sepgsql_setcon('unconfined_u:unconfined_r:unconfined_t:s0-s0:c1.c4');
+ sepgsql_setcon
+----------------
+ t
+(1 row)
+
+regression=# SELECT sepgsql_setcon('unconfined_u:unconfined_r:unconfined_t:s0-s0:c1.c1023');
+ERROR: SELinux: security policy violation
+
+ In this example above we were allowed to switch from the larger MCS
+ range c1.c1023 to the smaller range c1.c4, but
+ switching back was denied.
+
+ A combination of dynamic domain transition and trusted procedure
+ enables an interesting use case that fits the typical process life-cycle
+ of connection pooling software.
+ Even if your connection pooling software is not allowed to run most
+ of SQL commands, you can allow it to switch the security label
+ of the client using the sepgsql_setcon() function
+ from within a trusted procedure; that should take some
+ credential to authorize the request to switch the client label.
+ After that, this session will have the privileges of the target user,
+ rather than the connection pooler.
+ The connection pooler can later revert the security label change by
+ again using sepgsql_setcon() with
+ NULL argument, again invoked from within a trusted
+ procedure with appropriate permissions checks.
+ The point here is that only the trusted procedure actually has permission
+ to change the effective security label, and only does so when given proper
+ credentials. Of course, for secure operation, the credential store
+ (table, procedure definition, or whatever) must be protected from
+ unauthorized access.
+
F.40.5.6. Miscellaneous #
+ We reject the LOAD command across the board, because
+ any module loaded could easily circumvent security policy enforcement.
+
F.40.6. Sepgsql Functions #
+ Table F.31 shows the available functions.
+
Table F.31. Sepgsql Functions
+ Function
+
+
+ Description
+ |
|---|
+ sepgsql_getcon ()
+ → text
+
+
+ Returns the client domain, the current security label of the client.
+ |
+ sepgsql_setcon ( text )
+ → boolean
+
+
+ Switches the client domain of the current session to the new domain,
+ if allowed by the security policy.
+ It also accepts NULL input as a request to transition
+ to the client's original domain.
+ |
+ sepgsql_mcstrans_in ( text )
+ → text
+
+
+ Translates the given qualified MLS/MCS range into raw format if
+ the mcstrans daemon is running.
+ |
+ sepgsql_mcstrans_out ( text )
+ → text
+
+
+ Translates the given raw MLS/MCS range into qualified format if
+ the mcstrans daemon is running.
+ |
+ sepgsql_restorecon ( text )
+ → boolean
+
+
+ Sets up initial security labels for all objects within the
+ current database. The argument may be NULL, or the
+ name of a specfile to be used as alternative of the system default.
+ |
- Data Definition Language (DDL) Permissions
+ Due to implementation restrictions, some DDL operations do not
+ check permissions.
+
- Data Control Language (DCL) Permissions
+ Due to implementation restrictions, DCL operations do not check
+ permissions.
+
- Row-level access control
+ PostgreSQL supports row-level access, but
+ sepgsql does not.
+
- Covert channels
+ sepgsql does not try to hide the existence of
+ a certain object, even if the user is not allowed to reference it.
+ For example, we can infer the existence of an invisible object as
+ a result of primary key conflicts, foreign key violations, and so on,
+ even if we cannot obtain the contents of the object. The existence
+ of a top secret table cannot be hidden; we only hope to conceal its
+ contents.
+
F.40.8. External Resources #
- SE-PostgreSQL Introduction
+ This wiki page provides a brief overview, security design, architecture,
+ administration and upcoming features.
+
- SELinux User's and Administrator's Guide
+ This document provides a wide spectrum of knowledge to administer
+ SELinux on your systems.
+ It focuses primarily on Red Hat operating systems, but is not limited to them.
+
- Fedora SELinux FAQ
+ This document answers frequently asked questions about
+ SELinux.
+ It focuses primarily on Fedora, but is not limited to Fedora.
+
Part V. Server Programming
+ This part is about extending the server functionality with
+ user-defined functions, data types, triggers, etc. These are
+ advanced topics which should probably be approached only after all
+ the other user documentation about PostgreSQL has
+ been understood. Later chapters in this part describe the server-side
+ programming languages available in the
+ PostgreSQL distribution as well as
+ general issues concerning server-side programming languages. It
+ is essential to read at least the earlier sections of Chapter 38 (covering functions) before diving into the
+ material about server-side programming languages.
+
19.5. Shutting Down the Server #
+ There are several ways to shut down the database server.
+ Under the hood, they all reduce to sending a signal to the supervisor
+ postgres process.
+
+ If you are using a pre-packaged version
+ of PostgreSQL, and you used its provisions
+ for starting the server, then you should also use its provisions for
+ stopping the server. Consult the package-level documentation for
+ details.
+
+ When managing the server directly, you can control the type of shutdown
+ by sending different signals to the postgres
+ process:
+
+
- SIGTERM
+ This is the Smart Shutdown mode.
+ After receiving SIGTERM, the server
+ disallows new connections, but lets existing sessions end their
+ work normally. It shuts down only after all of the sessions terminate.
+ If the server is in recovery when a smart
+ shutdown is requested, recovery and streaming replication will be
+ stopped only after all regular sessions have terminated.
+
- SIGINT
+ This is the Fast Shutdown mode.
+ The server disallows new connections and sends all existing
+ server processes SIGTERM, which will cause them
+ to abort their current transactions and exit promptly. It then
+ waits for all server processes to exit and finally shuts down.
+
- SIGQUIT
+ This is the Immediate Shutdown mode.
+ The server will send SIGQUIT to all child
+ processes and wait for them to terminate. If any do not terminate
+ within 5 seconds, they will be sent SIGKILL.
+ The supervisor server process exits as soon as all child processes have
+ exited, without doing normal database shutdown processing.
+ This will lead to recovery (by
+ replaying the WAL log) upon next start-up. This is recommended
+ only in emergencies.
+
+
+ The pg_ctl program provides a convenient
+ interface for sending these signals to shut down the server.
+ Alternatively, you can send the signal directly using kill
+ on non-Windows systems.
+ The PID of the postgres process can be
+ found using the ps program, or from the file
+ postmaster.pid in the data directory. For
+ example, to do a fast shutdown:
+
+$ kill -INT `head -1 /usr/local/pgsql/data/postmaster.pid`
+
+
Important
+ It is best not to use SIGKILL to shut down the
+ server. Doing so will prevent the server from releasing shared memory and
+ semaphores. Furthermore, SIGKILL kills
+ the postgres process without letting it relay the
+ signal to its subprocesses, so it might be necessary to kill the
+ individual subprocesses by hand as well.
+
+ To terminate an individual session while allowing other sessions to
+ continue, use pg_terminate_backend() (see Table 9.90) or send a
+ SIGTERM signal to the child process associated with
+ the session.
+
19.3. Starting the Database Server #
+ Before anyone can access the database, you must start the database
+ server. The database server program is called
+ postgres.
+
+ If you are using a pre-packaged version
+ of PostgreSQL, it almost certainly includes
+ provisions for running the server as a background task according to the
+ conventions of your operating system. Using the package's
+ infrastructure to start the server will be much less work than figuring
+ out how to do this yourself. Consult the package-level documentation
+ for details.
+
+ The bare-bones way to start the server manually is just to invoke
+ postgres directly, specifying the location of the
+ data directory with the -D option, for example:
+
+$ postgres -D /usr/local/pgsql/data
+
+ which will leave the server running in the foreground. This must be
+ done while logged into the PostgreSQL user
+ account. Without -D, the server will try to use
+ the data directory named by the environment variable PGDATA.
+ If that variable is not provided either, it will fail.
+
+ Normally it is better to start postgres in the
+ background. For this, use the usual Unix shell syntax:
+
+$ postgres -D /usr/local/pgsql/data >logfile 2>&1 &
+
+ It is important to store the server's stdout and
+ stderr output somewhere, as shown above. It will help
+ for auditing purposes and to diagnose problems. (See Section 25.3 for a more thorough discussion of log
+ file handling.)
+
+ The postgres program also takes a number of other
+ command-line options. For more information, see the
+ postgres reference page
+ and Chapter 20 below.
+
+ This shell syntax can get tedious quickly. Therefore the wrapper
+ program
+ pg_ctl
+ is provided to simplify some tasks. For example:
+
+pg_ctl start -l logfile
+
+ will start the server in the background and put the output into the
+ named log file. The -D option has the same meaning
+ here as for postgres. pg_ctl
+ is also capable of stopping the server.
+
+ Normally, you will want to start the database server when the
+ computer boots.
+ Autostart scripts are operating-system-specific.
+ There are a few example scripts distributed with
+ PostgreSQL in the
+ contrib/start-scripts directory. Installing one will require
+ root privileges.
+
+ Different systems have different conventions for starting up daemons
+ at boot time. Many systems have a file
+ /etc/rc.local or
+ /etc/rc.d/rc.local. Others use init.d or
+ rc.d directories. Whatever you do, the server must be
+ run by the PostgreSQL user account
+ and not by root or any other user. Therefore you
+ probably should form your commands using
+ su postgres -c '...'. For example:
+
+su postgres -c 'pg_ctl start -D /usr/local/pgsql/data -l serverlog'
+
+
+ Here are a few more operating-system-specific suggestions. (In each
+ case be sure to use the proper installation directory and user
+ name where we show generic values.)
+
+
+ For FreeBSD, look at the file
+ contrib/start-scripts/freebsd in the
+ PostgreSQL source distribution.
+
+
+ On OpenBSD, add the following lines
+ to the file /etc/rc.local:
+
+
+if [ -x /usr/local/pgsql/bin/pg_ctl -a -x /usr/local/pgsql/bin/postgres ]; then
+ su -l postgres -c '/usr/local/pgsql/bin/pg_ctl start -s -l /var/postgresql/log -D /usr/local/pgsql/data'
+ echo -n ' postgresql'
+fi
+
+
+ On Linux systems either add
+
+
+/usr/local/pgsql/bin/pg_ctl start -l logfile -D /usr/local/pgsql/data
+
+ to /etc/rc.d/rc.local
+ or /etc/rc.local or look at the file
+ contrib/start-scripts/linux in the
+ PostgreSQL source distribution.
+
+ When using systemd, you can use the following
+ service unit file (e.g.,
+ at /etc/systemd/system/postgresql.service):
+
+[Unit]
+Description=PostgreSQL database server
+Documentation=man:postgres(1)
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=notify
+User=postgres
+ExecStart=/usr/local/pgsql/bin/postgres -D /usr/local/pgsql/data
+ExecReload=/bin/kill -HUP $MAINPID
+KillMode=mixed
+KillSignal=SIGINT
+TimeoutSec=infinity
+
+[Install]
+WantedBy=multi-user.target
+
+ Using Type=notify requires that the server binary was
+ built with configure --with-systemd.
+
+ Consider carefully the timeout
+ setting. systemd has a default timeout of 90
+ seconds as of this writing and will kill a process that does not report
+ readiness within that time. But a PostgreSQL
+ server that might have to perform crash recovery at startup could take
+ much longer to become ready. The suggested value
+ of infinity disables the timeout logic.
+
+ On NetBSD, use either the
+ FreeBSD or
+ Linux start scripts, depending on
+ preference.
+
+
+ On Solaris, create a file called
+ /etc/init.d/postgresql that contains
+ the following line:
+
+
+su - postgres -c "/usr/local/pgsql/bin/pg_ctl start -l logfile -D /usr/local/pgsql/data"
+
+ Then, create a symbolic link to it in /etc/rc3.d as
+ S99postgresql.
+
+
+
+ While the server is running, its
+ PID is stored in the file
+ postmaster.pid in the data directory. This is
+ used to prevent multiple server instances from
+ running in the same data directory and can also be used for
+ shutting down the server.
+
19.3.1. Server Start-up Failures #
+ There are several common reasons the server might fail to
+ start. Check the server's log file, or start it by hand (without
+ redirecting standard output or standard error) and see what error
+ messages appear. Below we explain some of the most common error
+ messages in more detail.
+
+
+LOG: could not bind IPv4 address "127.0.0.1": Address already in use
+HINT: Is another postmaster already running on port 5432? If not, wait a few seconds and retry.
+FATAL: could not create any TCP/IP sockets
+
+ This usually means just what it suggests: you tried to start
+ another server on the same port where one is already running.
+ However, if the kernel error message is not Address
+ already in use or some variant of that, there might
+ be a different problem. For example, trying to start a server
+ on a reserved port number might draw something like:
+
+$ postgres -p 666
+LOG: could not bind IPv4 address "127.0.0.1": Permission denied
+HINT: Is another postmaster already running on port 666? If not, wait a few seconds and retry.
+FATAL: could not create any TCP/IP sockets
+
+
+ A message like:
+
+FATAL: could not create shared memory segment: Invalid argument
+DETAIL: Failed system call was shmget(key=5440001, size=4011376640, 03600).
+
+ probably means your kernel's limit on the size of shared memory is
+ smaller than the work area PostgreSQL
+ is trying to create (4011376640 bytes in this example).
+ This is only likely to happen if you have set shared_memory_type
+ to sysv. In that case, you
+ can try starting the server with a smaller-than-normal number of
+ buffers (shared_buffers), or
+ reconfigure your kernel to increase the allowed shared memory
+ size. You might also see this message when trying to start multiple
+ servers on the same machine, if their total space requested
+ exceeds the kernel limit.
+
+ An error like:
+
+FATAL: could not create semaphores: No space left on device
+DETAIL: Failed system call was semget(5440126, 17, 03600).
+
+ does not mean you've run out of disk
+ space. It means your kernel's limit on the number of System V semaphores is smaller than the number
+ PostgreSQL wants to create. As above,
+ you might be able to work around the problem by starting the
+ server with a reduced number of allowed connections
+ (max_connections), but you'll eventually want to
+ increase the kernel limit.
+
+ Details about configuring System V
+ IPC facilities are given in Section 19.4.1.
+
19.3.2. Client Connection Problems #
+ Although the error conditions possible on the client side are quite
+ varied and application-dependent, a few of them might be directly
+ related to how the server was started. Conditions other than
+ those shown below should be documented with the respective client
+ application.
+
+
+psql: error: connection to server at "server.joe.com" (123.123.123.123), port 5432 failed: Connection refused
+ Is the server running on that host and accepting TCP/IP connections?
+
+ This is the generic “I couldn't find a server to talk
+ to” failure. It looks like the above when TCP/IP
+ communication is attempted. A common mistake is to forget to
+ configure the server to allow TCP/IP connections.
+
+ Alternatively, you might get this when attempting Unix-domain socket
+ communication to a local server:
+
+psql: error: connection to server on socket "/tmp/.s.PGSQL.5432" failed: No such file or directory
+ Is the server running locally and accepting connections on that socket?
+
+ If the server is indeed running, check that the client's idea of the
+ socket path (here /tmp) agrees with the server's
+ unix_socket_directories setting.
+
+ A connection failure message always shows the server address or socket
+ path name, which is useful in verifying that the client is trying to
+ connect to the right place. If there is in fact no server
+ listening there, the kernel error message will typically be either
+ Connection refused or
+ No such file or directory, as
+ illustrated. (It is important to realize that
+ Connection refused in this context
+ does not mean that the server got your
+ connection request and rejected it. That case will produce a
+ different message, as shown in Section 21.15.) Other error messages
+ such as Connection timed out might
+ indicate more fundamental problems, like lack of network
+ connectivity, or a firewall blocking the connection.
+
56.4. Miscellaneous Coding Conventions #
+ Code in PostgreSQL should only rely on language
+ features available in the C99 standard. That means a conforming
+ C99 compiler has to be able to compile postgres, at least aside
+ from a few platform dependent pieces.
+
+ A few features included in the C99 standard are, at this time, not
+ permitted to be used in core PostgreSQL
+ code. This currently includes variable length arrays, intermingled
+ declarations and code, // comments, universal
+ character names. Reasons for that include portability and historical
+ practices.
+
+ Features from later revisions of the C standard or compiler specific
+ features can be used, if a fallback is provided.
+
+ For example _Static_assert() and
+ __builtin_constant_p are currently used, even though
+ they are from newer revisions of the C standard and a
+ GCC extension respectively. If not available
+ we respectively fall back to using a C99 compatible replacement that
+ performs the same checks, but emits rather cryptic messages and do not
+ use __builtin_constant_p.
+
Function-Like Macros and Inline Functions #
+ Both macros with arguments and static inline
+ functions may be used. The latter are preferable if there are
+ multiple-evaluation hazards when written as a macro, as e.g., the
+ case with
+
+#define Max(x, y) ((x) > (y) ? (x) : (y))
+
+ or when the macro would be very long. In other cases it's only
+ possible to use macros, or at least easier. For example because
+ expressions of various types need to be passed to the macro.
+
+ When the definition of an inline function references symbols
+ (i.e., variables, functions) that are only available as part of the
+ backend, the function may not be visible when included from frontend
+ code.
+
+#ifndef FRONTEND
+static inline MemoryContext
+MemoryContextSwitchTo(MemoryContext context)
+{
+ MemoryContext old = CurrentMemoryContext;
+
+ CurrentMemoryContext = context;
+ return old;
+}
+#endif /* FRONTEND */
+
+ In this example CurrentMemoryContext, which is only
+ available in the backend, is referenced and the function thus
+ hidden with a #ifndef FRONTEND. This rule
+ exists because some compilers emit references to symbols
+ contained in inline functions even if the function is not used.
+
Writing Signal Handlers #
+ To be suitable to run inside a signal handler code has to be
+ written very carefully. The fundamental problem is that, unless
+ blocked, a signal handler can interrupt code at any time. If code
+ inside the signal handler uses the same state as code outside
+ chaos may ensue. As an example consider what happens if a signal
+ handler tries to acquire a lock that's already held in the
+ interrupted code.
+
+ Barring special arrangements code in signal handlers may only
+ call async-signal safe functions (as defined in POSIX) and access
+ variables of type volatile sig_atomic_t. A few
+ functions in postgres are also deemed signal safe, importantly
+ SetLatch().
+
+ In most cases signal handlers should do nothing more than note
+ that a signal has arrived, and wake up code running outside of
+ the handler using a latch. An example of such a handler is the
+ following:
+
+static void
+handle_sighup(SIGNAL_ARGS)
+{
+ int save_errno = errno;
+
+ got_SIGHUP = true;
+ SetLatch(MyLatch);
+
+ errno = save_errno;
+}
+
+ errno is saved and restored because
+ SetLatch() might change it. If that were not done
+ interrupted code that's currently inspecting errno might see the wrong
+ value.
+
Calling Function Pointers #
+ For clarity, it is preferred to explicitly dereference a function pointer
+ when calling the pointed-to function if the pointer is a simple variable,
+ for example:
+
+(*emit_log_hook) (edata);
+
+ (even though emit_log_hook(edata) would also work).
+ When the function pointer is part of a structure, then the extra
+ punctuation can and usually should be omitted, for example:
+
+paramInfo->paramFetch(paramInfo, paramId);
+
+
+ Source code formatting uses 4 column tab spacing, with
+ tabs preserved (i.e., tabs are not expanded to spaces).
+ Each logical indentation level is one additional tab stop.
+
+ Layout rules (brace positioning, etc.) follow BSD conventions. In
+ particular, curly braces for the controlled blocks of if,
+ while, switch, etc. go on their own lines.
+
+ Limit line lengths so that the code is readable in an 80-column window.
+ (This doesn't mean that you must never go past 80 columns. For instance,
+ breaking a long error message string in arbitrary places just to keep the
+ code within 80 columns is probably not a net gain in readability.)
+
+ To maintain a consistent coding style, do not use C++ style comments
+ (// comments). pgindent
+ will replace them with /* ... */.
+
+ The preferred style for multi-line comment blocks is
+
+/*
+ * comment text begins here
+ * and continues here
+ */
+
+ Note that comment blocks that begin in column 1 will be preserved as-is
+ by pgindent, but it will re-flow indented comment blocks
+ as though they were plain text. If you want to preserve the line breaks
+ in an indented block, add dashes like this:
+
+ /*----------
+ * comment text begins here
+ * and continues here
+ *----------
+ */
+
+
+ While submitted patches do not absolutely have to follow these formatting
+ rules, it's a good idea to do so. Your code will get run through
+ pgindent before the next release, so there's no point in
+ making it look nice under some other set of formatting conventions.
+ A good rule of thumb for patches is “make the new code look like
+ the existing code around it”.
+
+ The src/tools/editors directory contains sample settings
+ files that can be used with the Emacs,
+ xemacs or vim
+ editors to help ensure that they format code according to these
+ conventions.
+
+ If you'd like to run pgindent locally
+ to help make your code match project style, see
+ the src/tools/pgindent directory.
+
+ The text browsing tools more and
+ less can be invoked as:
+
+more -x4
+less -x4
+
+ to make them show tabs appropriately.
+
Chapter 56. PostgreSQL Coding Conventions
Appendix I. The Source Code Repository
+ The PostgreSQL source code is stored and managed
+ using the Git version control system. A public
+ mirror of the master repository is available; it is updated within a minute
+ of any change to the master repository.
+
+ Our wiki, https://wiki.postgresql.org/wiki/Working_with_Git,
+ has some discussion on working with Git.
+
+ Note that building PostgreSQL from the source
+ repository requires reasonably up-to-date versions of bison,
+ flex, and Perl.
+ These tools are not needed to build from a distribution tarball, because
+ the files generated with these tools are included in the tarball.
+ Other tool requirements
+ are the same as shown in Section 17.1.
+
69.2. Built-in Operator Classes #
+ The core PostgreSQL distribution
+ includes the SP-GiST operator classes shown in
+ Table 69.1.
+
Table 69.1. Built-in SP-GiST Operator Classes
| Name | Indexable Operators | Ordering Operators |
|---|
box_ops | << (box,box) | <-> (box,point) |
&< (box,box) |
&> (box,box) |
>> (box,box) |
<@ (box,box) |
@> (box,box) |
~= (box,box) |
&& (box,box) |
<<| (box,box) |
&<| (box,box) |
|&> (box,box) |
|>> (box,box) |
inet_ops | << (inet,inet) | |
<<= (inet,inet) |
>> (inet,inet) |
>>= (inet,inet) |
= (inet,inet) |
<> (inet,inet) |
< (inet,inet) |
<= (inet,inet) |
> (inet,inet) |
>= (inet,inet) |
&& (inet,inet) |
kd_point_ops | |>> (point,point) | <-> (point,point) |
<< (point,point) |
>> (point,point) |
<<| (point,point) |
~= (point,point) |
<@ (point,box) |
poly_ops | << (polygon,polygon) | <-> (polygon,point) |
&< (polygon,polygon) |
&> (polygon,polygon) |
>> (polygon,polygon) |
<@ (polygon,polygon) |
@> (polygon,polygon) |
~= (polygon,polygon) |
&& (polygon,polygon) |
<<| (polygon,polygon) |
&<| (polygon,polygon) |
|>> (polygon,polygon) |
|&> (polygon,polygon) |
quad_point_ops | |>> (point,point) | <-> (point,point) |
<< (point,point) |
>> (point,point) |
<<| (point,point) |
~= (point,point) |
<@ (point,box) |
range_ops | = (anyrange,anyrange) | |
&& (anyrange,anyrange) |
@> (anyrange,anyelement) |
@> (anyrange,anyrange) |
<@ (anyrange,anyrange) |
<< (anyrange,anyrange) |
>> (anyrange,anyrange) |
&< (anyrange,anyrange) |
&> (anyrange,anyrange) |
-|- (anyrange,anyrange) |
text_ops | = (text,text) | |
< (text,text) |
<= (text,text) |
> (text,text) |
>= (text,text) |
~<~ (text,text) |
~<=~ (text,text) |
~>=~ (text,text) |
~>~ (text,text) |
^@ (text,text) |
+ Of the two operator classes for type point,
+ quad_point_ops is the default. kd_point_ops
+ supports the same operators but uses a different index data structure that
+ may offer better performance in some applications.
+
+ The quad_point_ops, kd_point_ops and
+ poly_ops operator classes support the <->
+ ordering operator, which enables the k-nearest neighbor (k-NN)
+ search over indexed point or polygon data sets.
+
+ The PostgreSQL source distribution includes
+ several examples of index operator classes for SP-GiST,
+ as described in Table 69.1. Look
+ into src/backend/access/spgist/
+ and src/backend/utils/adt/ to see the code.
+
+ SP-GiST offers an interface with a high level of
+ abstraction, requiring the access method developer to implement only
+ methods specific to a given data type. The SP-GiST core
+ is responsible for efficient disk mapping and searching the tree structure.
+ It also takes care of concurrency and logging considerations.
+
+ Leaf tuples of an SP-GiST tree usually contain values
+ of the same data type as the indexed column, although it is also possible
+ for them to contain lossy representations of the indexed column.
+ Leaf tuples stored at the root level will directly represent
+ the original indexed data value, but leaf tuples at lower
+ levels might contain only a partial value, such as a suffix.
+ In that case the operator class support functions must be able to
+ reconstruct the original value using information accumulated from the
+ inner tuples that are passed through to reach the leaf level.
+
+ When an SP-GiST index is created with
+ INCLUDE columns, the values of those columns are also
+ stored in leaf tuples. The INCLUDE columns are of no
+ concern to the SP-GiST operator class, so they are
+ not discussed further here.
+
+ Inner tuples are more complex, since they are branching points in the
+ search tree. Each inner tuple contains a set of one or more
+ nodes, which represent groups of similar leaf values.
+ A node contains a downlink that leads either to another, lower-level inner
+ tuple, or to a short list of leaf tuples that all lie on the same index page.
+ Each node normally has a label that describes it; for example,
+ in a radix tree the node label could be the next character of the string
+ value. (Alternatively, an operator class can omit the node labels, if it
+ works with a fixed set of nodes for all inner tuples;
+ see Section 69.4.2.)
+ Optionally, an inner tuple can have a prefix value
+ that describes all its members. In a radix tree this could be the common
+ prefix of the represented strings. The prefix value is not necessarily
+ really a prefix, but can be any data needed by the operator class;
+ for example, in a quad-tree it can store the central point that the four
+ quadrants are measured with respect to. A quad-tree inner tuple would
+ then also contain four nodes corresponding to the quadrants around this
+ central point.
+
+ Some tree algorithms require knowledge of level (or depth) of the current
+ tuple, so the SP-GiST core provides the possibility for
+ operator classes to manage level counting while descending the tree.
+ There is also support for incrementally reconstructing the represented
+ value when that is needed, and for passing down additional data (called
+ traverse values) during a tree descent.
+
Note
+ The SP-GiST core code takes care of null entries.
+ Although SP-GiST indexes do store entries for nulls
+ in indexed columns, this is hidden from the index operator class code:
+ no null index entries or search conditions will ever be passed to the
+ operator class methods. (It is assumed that SP-GiST
+ operators are strict and so cannot succeed for null values.) Null values
+ are therefore not discussed further here.
+
+ There are five user-defined methods that an index operator class for
+ SP-GiST must provide, and two are optional. All five
+ mandatory methods follow the convention of accepting two internal
+ arguments, the first of which is a pointer to a C struct containing input
+ values for the support method, while the second argument is a pointer to a
+ C struct where output values must be placed. Four of the mandatory methods just
+ return void, since all their results appear in the output struct; but
+ leaf_consistent returns a boolean result.
+ The methods must not modify any fields of their input structs. In all
+ cases, the output struct is initialized to zeroes before calling the
+ user-defined method. The optional sixth method compress
+ accepts a datum to be indexed as the only argument and returns a value suitable
+ for physical storage in a leaf tuple. The optional seventh method
+ options accepts an internal pointer to a C struct, where
+ opclass-specific parameters should be placed, and returns void.
+
+ The five mandatory user-defined methods are:
+
config
+ Returns static information about the index implementation, including
+ the data type OIDs of the prefix and node label data types.
+
+ The SQL declaration of the function must look like this:
+
+CREATE FUNCTION my_config(internal, internal) RETURNS void ...
+
+ The first argument is a pointer to a spgConfigIn
+ C struct, containing input data for the function.
+ The second argument is a pointer to a spgConfigOut
+ C struct, which the function must fill with result data.
+
+typedef struct spgConfigIn
+{
+ Oid attType; /* Data type to be indexed */
+} spgConfigIn;
+
+typedef struct spgConfigOut
+{
+ Oid prefixType; /* Data type of inner-tuple prefixes */
+ Oid labelType; /* Data type of inner-tuple node labels */
+ Oid leafType; /* Data type of leaf-tuple values */
+ bool canReturnData; /* Opclass can reconstruct original data */
+ bool longValuesOK; /* Opclass can cope with values > 1 page */
+} spgConfigOut;
+
+
+ attType is passed in order to support polymorphic
+ index operator classes; for ordinary fixed-data-type operator classes, it
+ will always have the same value and so can be ignored.
+
+ For operator classes that do not use prefixes,
+ prefixType can be set to VOIDOID.
+ Likewise, for operator classes that do not use node labels,
+ labelType can be set to VOIDOID.
+ canReturnData should be set true if the operator class
+ is capable of reconstructing the originally-supplied index value.
+ longValuesOK should be set true only when the
+ attType is of variable length and the operator
+ class is capable of segmenting long values by repeated suffixing
+ (see Section 69.4.1).
+
+ leafType should match the index storage type
+ defined by the operator class's opckeytype
+ catalog entry.
+ (Note that opckeytype can be zero,
+ implying the storage type is the same as the operator class's input
+ type, which is the most common situation.)
+ For reasons of backward compatibility, the config
+ method can set leafType to some other value,
+ and that value will be used; but this is deprecated since the index
+ contents are then incorrectly identified in the catalogs.
+ Also, it's permissible to
+ leave leafType uninitialized (zero);
+ that is interpreted as meaning the index storage type derived from
+ opckeytype.
+
+ When attType
+ and leafType are different, the optional
+ method compress must be provided.
+ Method compress is responsible
+ for transformation of datums to be indexed from attType
+ to leafType.
+
choose
+ Chooses a method for inserting a new value into an inner tuple.
+
+ The SQL declaration of the function must look like this:
+
+CREATE FUNCTION my_choose(internal, internal) RETURNS void ...
+
+ The first argument is a pointer to a spgChooseIn
+ C struct, containing input data for the function.
+ The second argument is a pointer to a spgChooseOut
+ C struct, which the function must fill with result data.
+
+typedef struct spgChooseIn
+{
+ Datum datum; /* original datum to be indexed */
+ Datum leafDatum; /* current datum to be stored at leaf */
+ int level; /* current level (counting from zero) */
+
+ /* Data from current inner tuple */
+ bool allTheSame; /* tuple is marked all-the-same? */
+ bool hasPrefix; /* tuple has a prefix? */
+ Datum prefixDatum; /* if so, the prefix value */
+ int nNodes; /* number of nodes in the inner tuple */
+ Datum *nodeLabels; /* node label values (NULL if none) */
+} spgChooseIn;
+
+typedef enum spgChooseResultType
+{
+ spgMatchNode = 1, /* descend into existing node */
+ spgAddNode, /* add a node to the inner tuple */
+ spgSplitTuple /* split inner tuple (change its prefix) */
+} spgChooseResultType;
+
+typedef struct spgChooseOut
+{
+ spgChooseResultType resultType; /* action code, see above */
+ union
+ {
+ struct /* results for spgMatchNode */
+ {
+ int nodeN; /* descend to this node (index from 0) */
+ int levelAdd; /* increment level by this much */
+ Datum restDatum; /* new leaf datum */
+ } matchNode;
+ struct /* results for spgAddNode */
+ {
+ Datum nodeLabel; /* new node's label */
+ int nodeN; /* where to insert it (index from 0) */
+ } addNode;
+ struct /* results for spgSplitTuple */
+ {
+ /* Info to form new upper-level inner tuple with one child tuple */
+ bool prefixHasPrefix; /* tuple should have a prefix? */
+ Datum prefixPrefixDatum; /* if so, its value */
+ int prefixNNodes; /* number of nodes */
+ Datum *prefixNodeLabels; /* their labels (or NULL for
+ * no labels) */
+ int childNodeN; /* which node gets child tuple */
+
+ /* Info to form new lower-level inner tuple with all old nodes */
+ bool postfixHasPrefix; /* tuple should have a prefix? */
+ Datum postfixPrefixDatum; /* if so, its value */
+ } splitTuple;
+ } result;
+} spgChooseOut;
+
+
+ datum is the original datum of
+ spgConfigIn.attType
+ type that was to be inserted into the index.
+ leafDatum is a value of
+ spgConfigOut.leafType
+ type, which is initially a result of method
+ compress applied to datum
+ when method compress is provided, or the same value as
+ datum otherwise.
+ leafDatum can change at lower levels of the tree
+ if the choose or picksplit
+ methods change it. When the insertion search reaches a leaf page,
+ the current value of leafDatum is what will be stored
+ in the newly created leaf tuple.
+ level is the current inner tuple's level, starting at
+ zero for the root level.
+ allTheSame is true if the current inner tuple is
+ marked as containing multiple equivalent nodes
+ (see Section 69.4.3).
+ hasPrefix is true if the current inner tuple contains
+ a prefix; if so,
+ prefixDatum is its value.
+ nNodes is the number of child nodes contained in the
+ inner tuple, and
+ nodeLabels is an array of their label values, or
+ NULL if there are no labels.
+
+ The choose function can determine either that
+ the new value matches one of the existing child nodes, or that a new
+ child node must be added, or that the new value is inconsistent with
+ the tuple prefix and so the inner tuple must be split to create a
+ less restrictive prefix.
+
+ If the new value matches one of the existing child nodes,
+ set resultType to spgMatchNode.
+ Set nodeN to the index (from zero) of that node in
+ the node array.
+ Set levelAdd to the increment in
+ level caused by descending through that node,
+ or leave it as zero if the operator class does not use levels.
+ Set restDatum to equal leafDatum
+ if the operator class does not modify datums from one level to the
+ next, or otherwise set it to the modified value to be used as
+ leafDatum at the next level.
+
+ If a new child node must be added,
+ set resultType to spgAddNode.
+ Set nodeLabel to the label to be used for the new
+ node, and set nodeN to the index (from zero) at which
+ to insert the node in the node array.
+ After the node has been added, the choose
+ function will be called again with the modified inner tuple;
+ that call should result in an spgMatchNode result.
+
+ If the new value is inconsistent with the tuple prefix,
+ set resultType to spgSplitTuple.
+ This action moves all the existing nodes into a new lower-level
+ inner tuple, and replaces the existing inner tuple with a tuple
+ having a single downlink pointing to the new lower-level inner tuple.
+ Set prefixHasPrefix to indicate whether the new
+ upper tuple should have a prefix, and if so set
+ prefixPrefixDatum to the prefix value. This new
+ prefix value must be sufficiently less restrictive than the original
+ to accept the new value to be indexed.
+ Set prefixNNodes to the number of nodes needed in the
+ new tuple, and set prefixNodeLabels to a palloc'd array
+ holding their labels, or to NULL if node labels are not required.
+ Note that the total size of the new upper tuple must be no more
+ than the total size of the tuple it is replacing; this constrains
+ the lengths of the new prefix and new labels.
+ Set childNodeN to the index (from zero) of the node
+ that will downlink to the new lower-level inner tuple.
+ Set postfixHasPrefix to indicate whether the new
+ lower-level inner tuple should have a prefix, and if so set
+ postfixPrefixDatum to the prefix value. The
+ combination of these two prefixes and the downlink node's label
+ (if any) must have the same meaning as the original prefix, because
+ there is no opportunity to alter the node labels that are moved to
+ the new lower-level tuple, nor to change any child index entries.
+ After the node has been split, the choose
+ function will be called again with the replacement inner tuple.
+ That call may return an spgAddNode result, if no suitable
+ node was created by the spgSplitTuple action. Eventually
+ choose must return spgMatchNode to
+ allow the insertion to descend to the next level.
+
picksplit
+ Decides how to create a new inner tuple over a set of leaf tuples.
+
+ The SQL declaration of the function must look like this:
+
+CREATE FUNCTION my_picksplit(internal, internal) RETURNS void ...
+
+ The first argument is a pointer to a spgPickSplitIn
+ C struct, containing input data for the function.
+ The second argument is a pointer to a spgPickSplitOut
+ C struct, which the function must fill with result data.
+
+typedef struct spgPickSplitIn
+{
+ int nTuples; /* number of leaf tuples */
+ Datum *datums; /* their datums (array of length nTuples) */
+ int level; /* current level (counting from zero) */
+} spgPickSplitIn;
+
+typedef struct spgPickSplitOut
+{
+ bool hasPrefix; /* new inner tuple should have a prefix? */
+ Datum prefixDatum; /* if so, its value */
+
+ int nNodes; /* number of nodes for new inner tuple */
+ Datum *nodeLabels; /* their labels (or NULL for no labels) */
+
+ int *mapTuplesToNodes; /* node index for each leaf tuple */
+ Datum *leafTupleDatums; /* datum to store in each new leaf tuple */
+} spgPickSplitOut;
+
+
+ nTuples is the number of leaf tuples provided.
+ datums is an array of their datum values of
+ spgConfigOut.leafType
+ type.
+ level is the current level that all the leaf tuples
+ share, which will become the level of the new inner tuple.
+
+ Set hasPrefix to indicate whether the new inner
+ tuple should have a prefix, and if so set
+ prefixDatum to the prefix value.
+ Set nNodes to indicate the number of nodes that
+ the new inner tuple will contain, and
+ set nodeLabels to an array of their label values,
+ or to NULL if node labels are not required.
+ Set mapTuplesToNodes to an array that gives the index
+ (from zero) of the node that each leaf tuple should be assigned to.
+ Set leafTupleDatums to an array of the values to
+ be stored in the new leaf tuples (these will be the same as the
+ input datums if the operator class does not modify
+ datums from one level to the next).
+ Note that the picksplit function is
+ responsible for palloc'ing the
+ nodeLabels, mapTuplesToNodes and
+ leafTupleDatums arrays.
+
+ If more than one leaf tuple is supplied, it is expected that the
+ picksplit function will classify them into more than
+ one node; otherwise it is not possible to split the leaf tuples
+ across multiple pages, which is the ultimate purpose of this
+ operation. Therefore, if the picksplit function
+ ends up placing all the leaf tuples in the same node, the core
+ SP-GiST code will override that decision and generate an inner
+ tuple in which the leaf tuples are assigned at random to several
+ identically-labeled nodes. Such a tuple is marked
+ allTheSame to signify that this has happened. The
+ choose and inner_consistent functions
+ must take suitable care with such inner tuples.
+ See Section 69.4.3 for more information.
+
+ picksplit can be applied to a single leaf tuple only
+ in the case that the config function set
+ longValuesOK to true and a larger-than-a-page input
+ value has been supplied. In this case the point of the operation is
+ to strip off a prefix and produce a new, shorter leaf datum value.
+ The call will be repeated until a leaf datum short enough to fit on
+ a page has been produced. See Section 69.4.1 for
+ more information.
+
inner_consistent
+ Returns set of nodes (branches) to follow during tree search.
+
+ The SQL declaration of the function must look like this:
+
+CREATE FUNCTION my_inner_consistent(internal, internal) RETURNS void ...
+
+ The first argument is a pointer to a spgInnerConsistentIn
+ C struct, containing input data for the function.
+ The second argument is a pointer to a spgInnerConsistentOut
+ C struct, which the function must fill with result data.
+
+
+typedef struct spgInnerConsistentIn
+{
+ ScanKey scankeys; /* array of operators and comparison values */
+ ScanKey orderbys; /* array of ordering operators and comparison
+ * values */
+ int nkeys; /* length of scankeys array */
+ int norderbys; /* length of orderbys array */
+
+ Datum reconstructedValue; /* value reconstructed at parent */
+ void *traversalValue; /* opclass-specific traverse value */
+ MemoryContext traversalMemoryContext; /* put new traverse values here */
+ int level; /* current level (counting from zero) */
+ bool returnData; /* original data must be returned? */
+
+ /* Data from current inner tuple */
+ bool allTheSame; /* tuple is marked all-the-same? */
+ bool hasPrefix; /* tuple has a prefix? */
+ Datum prefixDatum; /* if so, the prefix value */
+ int nNodes; /* number of nodes in the inner tuple */
+ Datum *nodeLabels; /* node label values (NULL if none) */
+} spgInnerConsistentIn;
+
+typedef struct spgInnerConsistentOut
+{
+ int nNodes; /* number of child nodes to be visited */
+ int *nodeNumbers; /* their indexes in the node array */
+ int *levelAdds; /* increment level by this much for each */
+ Datum *reconstructedValues; /* associated reconstructed values */
+ void **traversalValues; /* opclass-specific traverse values */
+ double **distances; /* associated distances */
+} spgInnerConsistentOut;
+
+
+ The array scankeys, of length nkeys,
+ describes the index search condition(s). These conditions are
+ combined with AND — only index entries that satisfy all of
+ them are interesting. (Note that nkeys = 0 implies
+ that all index entries satisfy the query.) Usually the consistent
+ function only cares about the sk_strategy and
+ sk_argument fields of each array entry, which
+ respectively give the indexable operator and comparison value.
+ In particular it is not necessary to check sk_flags to
+ see if the comparison value is NULL, because the SP-GiST core code
+ will filter out such conditions.
+ The array orderbys, of length norderbys,
+ describes ordering operators (if any) in the same manner.
+ reconstructedValue is the value reconstructed for the
+ parent tuple; it is (Datum) 0 at the root level or if the
+ inner_consistent function did not provide a value at the
+ parent level.
+ traversalValue is a pointer to any traverse data
+ passed down from the previous call of inner_consistent
+ on the parent index tuple, or NULL at the root level.
+ traversalMemoryContext is the memory context in which
+ to store output traverse values (see below).
+ level is the current inner tuple's level, starting at
+ zero for the root level.
+ returnData is true if reconstructed data is
+ required for this query; this will only be so if the
+ config function asserted canReturnData.
+ allTheSame is true if the current inner tuple is
+ marked “all-the-same”; in this case all the nodes have the
+ same label (if any) and so either all or none of them match the query
+ (see Section 69.4.3).
+ hasPrefix is true if the current inner tuple contains
+ a prefix; if so,
+ prefixDatum is its value.
+ nNodes is the number of child nodes contained in the
+ inner tuple, and
+ nodeLabels is an array of their label values, or
+ NULL if the nodes do not have labels.
+
+ nNodes must be set to the number of child nodes that
+ need to be visited by the search, and
+ nodeNumbers must be set to an array of their indexes.
+ If the operator class keeps track of levels, set
+ levelAdds to an array of the level increments
+ required when descending to each node to be visited. (Often these
+ increments will be the same for all the nodes, but that's not
+ necessarily so, so an array is used.)
+ If value reconstruction is needed, set
+ reconstructedValues to an array of the values
+ reconstructed for each child node to be visited; otherwise, leave
+ reconstructedValues as NULL.
+ The reconstructed values are assumed to be of type
+ spgConfigOut.leafType.
+ (However, since the core system will do nothing with them except
+ possibly copy them, it is sufficient for them to have the
+ same typlen and typbyval
+ properties as leafType.)
+ If ordered search is performed, set distances
+ to an array of distance values according to orderbys
+ array (nodes with lowest distances will be processed first). Leave it
+ NULL otherwise.
+ If it is desired to pass down additional out-of-band information
+ (“traverse values”) to lower levels of the tree search,
+ set traversalValues to an array of the appropriate
+ traverse values, one for each child node to be visited; otherwise,
+ leave traversalValues as NULL.
+ Note that the inner_consistent function is
+ responsible for palloc'ing the
+ nodeNumbers, levelAdds,
+ distances,
+ reconstructedValues, and
+ traversalValues arrays in the current memory context.
+ However, any output traverse values pointed to by
+ the traversalValues array should be allocated
+ in traversalMemoryContext.
+ Each traverse value must be a single palloc'd chunk.
+
leaf_consistent
+ Returns true if a leaf tuple satisfies a query.
+
+ The SQL declaration of the function must look like this:
+
+CREATE FUNCTION my_leaf_consistent(internal, internal) RETURNS bool ...
+
+ The first argument is a pointer to a spgLeafConsistentIn
+ C struct, containing input data for the function.
+ The second argument is a pointer to a spgLeafConsistentOut
+ C struct, which the function must fill with result data.
+
+typedef struct spgLeafConsistentIn
+{
+ ScanKey scankeys; /* array of operators and comparison values */
+ ScanKey orderbys; /* array of ordering operators and comparison
+ * values */
+ int nkeys; /* length of scankeys array */
+ int norderbys; /* length of orderbys array */
+
+ Datum reconstructedValue; /* value reconstructed at parent */
+ void *traversalValue; /* opclass-specific traverse value */
+ int level; /* current level (counting from zero) */
+ bool returnData; /* original data must be returned? */
+
+ Datum leafDatum; /* datum in leaf tuple */
+} spgLeafConsistentIn;
+
+typedef struct spgLeafConsistentOut
+{
+ Datum leafValue; /* reconstructed original data, if any */
+ bool recheck; /* set true if operator must be rechecked */
+ bool recheckDistances; /* set true if distances must be rechecked */
+ double *distances; /* associated distances */
+} spgLeafConsistentOut;
+
+
+ The array scankeys, of length nkeys,
+ describes the index search condition(s). These conditions are
+ combined with AND — only index entries that satisfy all of
+ them satisfy the query. (Note that nkeys = 0 implies
+ that all index entries satisfy the query.) Usually the consistent
+ function only cares about the sk_strategy and
+ sk_argument fields of each array entry, which
+ respectively give the indexable operator and comparison value.
+ In particular it is not necessary to check sk_flags to
+ see if the comparison value is NULL, because the SP-GiST core code
+ will filter out such conditions.
+ The array orderbys, of length norderbys,
+ describes the ordering operators in the same manner.
+ reconstructedValue is the value reconstructed for the
+ parent tuple; it is (Datum) 0 at the root level or if the
+ inner_consistent function did not provide a value at the
+ parent level.
+ traversalValue is a pointer to any traverse data
+ passed down from the previous call of inner_consistent
+ on the parent index tuple, or NULL at the root level.
+ level is the current leaf tuple's level, starting at
+ zero for the root level.
+ returnData is true if reconstructed data is
+ required for this query; this will only be so if the
+ config function asserted canReturnData.
+ leafDatum is the key value of
+ spgConfigOut.leafType
+ stored in the current leaf tuple.
+
+ The function must return true if the leaf tuple matches the
+ query, or false if not. In the true case,
+ if returnData is true then
+ leafValue must be set to the value (of type
+ spgConfigIn.attType)
+ originally supplied to be indexed for this leaf tuple. Also,
+ recheck may be set to true if the match
+ is uncertain and so the operator(s) must be re-applied to the actual
+ heap tuple to verify the match.
+ If ordered search is performed, set distances
+ to an array of distance values according to orderbys
+ array. Leave it NULL otherwise. If at least one of returned distances
+ is not exact, set recheckDistances to true.
+ In this case, the executor will calculate the exact distances after
+ fetching the tuple from the heap, and will reorder the tuples if needed.
+
+ The optional user-defined methods are:
+
Datum compress(Datum in)
+ Converts a data item into a format suitable for physical storage in
+ a leaf tuple of the index. It accepts a value of type
+ spgConfigIn.attType
+ and returns a value of type
+ spgConfigOut.leafType.
+ The output value must not contain an out-of-line TOAST pointer.
+
+ Note: the compress method is only applied to
+ values to be stored. The consistent methods receive query
+ scankeys unchanged, without transformation
+ using compress.
+
options
+ Defines a set of user-visible parameters that control operator class
+ behavior.
+
+ The SQL declaration of the function must look like this:
+
+
+CREATE OR REPLACE FUNCTION my_options(internal)
+RETURNS void
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT;
+
+
+ The function is passed a pointer to a local_relopts
+ struct, which needs to be filled with a set of operator class
+ specific options. The options can be accessed from other support
+ functions using the PG_HAS_OPCLASS_OPTIONS() and
+ PG_GET_OPCLASS_OPTIONS() macros.
+
+ Since the representation of the key in SP-GiST is
+ flexible, it may depend on user-specified parameters.
+
+ All the SP-GiST support methods are normally called in a short-lived
+ memory context; that is, CurrentMemoryContext will be reset
+ after processing of each tuple. It is therefore not very important to
+ worry about pfree'ing everything you palloc. (The config
+ method is an exception: it should try to avoid leaking memory. But
+ usually the config method need do nothing but assign
+ constants into the passed parameter struct.)
+
+ If the indexed column is of a collatable data type, the index collation
+ will be passed to all the support methods, using the standard
+ PG_GET_COLLATION() mechanism.
+
+ This section covers implementation details and other tricks that are
+ useful for implementers of SP-GiST operator classes to
+ know.
+
+ Individual leaf tuples and inner tuples must fit on a single index page
+ (8kB by default). Therefore, when indexing values of variable-length
+ data types, long values can only be supported by methods such as radix
+ trees, in which each level of the tree includes a prefix that is short
+ enough to fit on a page, and the final leaf level includes a suffix also
+ short enough to fit on a page. The operator class should set
+ longValuesOK to true only if it is prepared to arrange for
+ this to happen. Otherwise, the SP-GiST core will
+ reject any request to index a value that is too large to fit
+ on an index page.
+
+ Likewise, it is the operator class's responsibility that inner tuples
+ do not grow too large to fit on an index page; this limits the number
+ of child nodes that can be used in one inner tuple, as well as the
+ maximum size of a prefix value.
+
+ Another limitation is that when an inner tuple's node points to a set
+ of leaf tuples, those tuples must all be in the same index page.
+ (This is a design decision to reduce seeking and save space in the
+ links that chain such tuples together.) If the set of leaf tuples
+ grows too large for a page, a split is performed and an intermediate
+ inner tuple is inserted. For this to fix the problem, the new inner
+ tuple must divide the set of leaf values into more than one
+ node group. If the operator class's picksplit function
+ fails to do that, the SP-GiST core resorts to
+ extraordinary measures described in Section 69.4.3.
+
+ When longValuesOK is true, it is expected
+ that successive levels of the SP-GiST tree will
+ absorb more and more information into the prefixes and node labels of
+ the inner tuples, making the required leaf datum smaller and smaller,
+ so that eventually it will fit on a page.
+ To prevent bugs in operator classes from causing infinite insertion
+ loops, the SP-GiST core will raise an error if the
+ leaf datum does not become any smaller within ten cycles
+ of choose method calls.
+
69.4.2. SP-GiST Without Node Labels #
+ Some tree algorithms use a fixed set of nodes for each inner tuple;
+ for example, in a quad-tree there are always exactly four nodes
+ corresponding to the four quadrants around the inner tuple's centroid
+ point. In such a case the code typically works with the nodes by
+ number, and there is no need for explicit node labels. To suppress
+ node labels (and thereby save some space), the picksplit
+ function can return NULL for the nodeLabels array,
+ and likewise the choose function can return NULL for
+ the prefixNodeLabels array during
+ a spgSplitTuple action.
+ This will in turn result in nodeLabels being NULL during
+ subsequent calls to choose and inner_consistent.
+ In principle, node labels could be used for some inner tuples and omitted
+ for others in the same index.
+
+ When working with an inner tuple having unlabeled nodes, it is an error
+ for choose to return spgAddNode, since the set
+ of nodes is supposed to be fixed in such cases.
+
69.4.3. “All-the-Same” Inner Tuples #
+ The SP-GiST core can override the results of the
+ operator class's picksplit function when
+ picksplit fails to divide the supplied leaf values into
+ at least two node categories. When this happens, the new inner tuple
+ is created with multiple nodes that each have the same label (if any)
+ that picksplit gave to the one node it did use, and the
+ leaf values are divided at random among these equivalent nodes.
+ The allTheSame flag is set on the inner tuple to warn the
+ choose and inner_consistent functions that the
+ tuple does not have the node set that they might otherwise expect.
+
+ When dealing with an allTheSame tuple, a choose
+ result of spgMatchNode is interpreted to mean that the new
+ value can be assigned to any of the equivalent nodes; the core code will
+ ignore the supplied nodeN value and descend into one
+ of the nodes at random (so as to keep the tree balanced). It is an
+ error for choose to return spgAddNode, since
+ that would make the nodes not all equivalent; the
+ spgSplitTuple action must be used if the value to be inserted
+ doesn't match the existing nodes.
+
+ When dealing with an allTheSame tuple, the
+ inner_consistent function should return either all or none
+ of the nodes as targets for continuing the index search, since they are
+ all equivalent. This may or may not require any special-case code,
+ depending on how much the inner_consistent function normally
+ assumes about the meaning of the nodes.
+
+ SP-GiST is an abbreviation for space-partitioned
+ GiST. SP-GiST supports partitioned
+ search trees, which facilitate development of a wide range of different
+ non-balanced data structures, such as quad-trees, k-d trees, and radix
+ trees (tries). The common feature of these structures is that they
+ repeatedly divide the search space into partitions that need not be
+ of equal size. Searches that are well matched to the partitioning rule
+ can be very fast.
+
+ These popular data structures were originally developed for in-memory
+ usage. In main memory, they are usually designed as a set of dynamically
+ allocated nodes linked by pointers. This is not suitable for direct
+ storing on disk, since these chains of pointers can be rather long which
+ would require too many disk accesses. In contrast, disk-based data
+ structures should have a high fanout to minimize I/O. The challenge
+ addressed by SP-GiST is to map search tree nodes to
+ disk pages in such a way that a search need access only a few disk pages,
+ even if it traverses many nodes.
+
+ Like GiST, SP-GiST is meant to allow
+ the development of custom data types with the appropriate access methods,
+ by an expert in the domain of the data type, rather than a database expert.
+
+ Some of the information here is derived from Purdue University's
+ SP-GiST Indexing Project
+ web site.
+ The SP-GiST implementation in
+ PostgreSQL is primarily maintained by Teodor
+ Sigaev and Oleg Bartunov, and there is more information on their
+
+ web site.
+
Chapter 69. SP-GiST Indexes
+ This section contains a very simple example of SPI usage. The
+ C function execq takes an SQL command as its
+ first argument and a row count as its second, executes the command
+ using SPI_exec and returns the number of rows
+ that were processed by the command. You can find more complex
+ examples for SPI in the source tree in
+ src/test/regress/regress.c and in the
+ spi module.
+
+#include "postgres.h"
+
+#include "executor/spi.h"
+#include "utils/builtins.h"
+
+PG_MODULE_MAGIC;
+
+PG_FUNCTION_INFO_V1(execq);
+
+Datum
+execq(PG_FUNCTION_ARGS)
+{
+ char *command;
+ int cnt;
+ int ret;
+ uint64 proc;
+
+ /* Convert given text object to a C string */
+ command = text_to_cstring(PG_GETARG_TEXT_PP(0));
+ cnt = PG_GETARG_INT32(1);
+
+ SPI_connect();
+
+ ret = SPI_exec(command, cnt);
+
+ proc = SPI_processed;
+
+ /*
+ * If some rows were fetched, print them via elog(INFO).
+ */
+ if (ret > 0 && SPI_tuptable != NULL)
+ {
+ SPITupleTable *tuptable = SPI_tuptable;
+ TupleDesc tupdesc = tuptable->tupdesc;
+ char buf[8192];
+ uint64 j;
+
+ for (j = 0; j < tuptable->numvals; j++)
+ {
+ HeapTuple tuple = tuptable->vals[j];
+ int i;
+
+ for (i = 1, buf[0] = 0; i <= tupdesc->natts; i++)
+ snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " %s%s",
+ SPI_getvalue(tuple, tupdesc, i),
+ (i == tupdesc->natts) ? " " : " |");
+ elog(INFO, "EXECQ: %s", buf);
+ }
+ }
+
+ SPI_finish();
+ pfree(command);
+
+ PG_RETURN_INT64(proc);
+}
+
+ This is how you declare the function after having compiled it into
+ a shared library (details are in Section 38.10.5.):
+
+
+CREATE FUNCTION execq(text, integer) RETURNS int8
+ AS 'filename'
+ LANGUAGE C STRICT;
+
+
+ Here is a sample session:
+
+
+=> SELECT execq('CREATE TABLE a (x integer)', 0);
+ execq
+-------
+ 0
+(1 row)
+
+=> INSERT INTO a VALUES (execq('INSERT INTO a VALUES (0)', 0));
+INSERT 0 1
+=> SELECT execq('SELECT * FROM a', 0);
+INFO: EXECQ: 0 -- inserted by execq
+INFO: EXECQ: 1 -- returned by execq and inserted by upper INSERT
+
+ execq
+-------
+ 2
+(1 row)
+
+=> SELECT execq('INSERT INTO a SELECT x + 2 FROM a RETURNING *', 1);
+INFO: EXECQ: 2 -- 0 + 2, then execution was stopped by count
+ execq
+-------
+ 1
+(1 row)
+
+=> SELECT execq('SELECT * FROM a', 10);
+INFO: EXECQ: 0
+INFO: EXECQ: 1
+INFO: EXECQ: 2
+
+ execq
+-------
+ 3 -- 10 is the max value only, 3 is the real number of rows
+(1 row)
+
+=> SELECT execq('INSERT INTO a SELECT x + 10 FROM a', 1);
+ execq
+-------
+ 3 -- all rows processed; count does not stop it, because nothing is returned
+(1 row)
+
+=> SELECT * FROM a;
+ x
+----
+ 0
+ 1
+ 2
+ 10
+ 11
+ 12
+(6 rows)
+
+=> DELETE FROM a;
+DELETE 6
+=> INSERT INTO a VALUES (execq('SELECT * FROM a', 0) + 1);
+INSERT 0 1
+=> SELECT * FROM a;
+ x
+---
+ 1 -- 0 (no rows in a) + 1
+(1 row)
+
+=> INSERT INTO a VALUES (execq('SELECT * FROM a', 0) + 1);
+INFO: EXECQ: 1
+INSERT 0 1
+=> SELECT * FROM a;
+ x
+---
+ 1
+ 2 -- 1 (there was one row in a) + 1
+(2 rows)
+
+-- This demonstrates the data changes visibility rule.
+-- execq is called twice and sees different numbers of rows each time:
+
+=> INSERT INTO a SELECT execq('SELECT * FROM a', 0) * x FROM a;
+INFO: EXECQ: 1 -- results from first execq
+INFO: EXECQ: 2
+INFO: EXECQ: 1 -- results from second execq
+INFO: EXECQ: 2
+INFO: EXECQ: 2
+INSERT 0 2
+=> SELECT * FROM a;
+ x
+---
+ 1
+ 2
+ 2 -- 2 rows * 1 (x in first row)
+ 6 -- 3 rows (2 + 1 just inserted) * 2 (x in second row)
+(4 rows)
+
+
47.2. Interface Support Functions #
+ The functions described here provide an interface for extracting
+ information from result sets returned by SPI_execute and
+ other SPI functions.
+
+ All functions described in this section can be used by both
+ connected and unconnected C functions.
+
47.1. Interface Functions #
47.3. Memory Management #
+
+ PostgreSQL allocates memory within
+ memory contexts, which provide a convenient method of
+ managing allocations made in many different places that need to
+ live for differing amounts of time. Destroying a context releases
+ all the memory that was allocated in it. Thus, it is not necessary
+ to keep track of individual objects to avoid memory leaks; instead
+ only a relatively small number of contexts have to be managed.
+ palloc and related functions allocate memory
+ from the “current” context.
+
+ SPI_connect creates a new memory context and
+ makes it current. SPI_finish restores the
+ previous current memory context and destroys the context created by
+ SPI_connect. These actions ensure that
+ transient memory allocations made inside your C function are
+ reclaimed at C function exit, avoiding memory leakage.
+
+ However, if your C function needs to return an object in allocated
+ memory (such as a value of a pass-by-reference data type), you
+ cannot allocate that memory using palloc, at
+ least not while you are connected to SPI. If you try, the object
+ will be deallocated by SPI_finish, and your
+ C function will not work reliably. To solve this problem, use
+ SPI_palloc to allocate memory for your return
+ object. SPI_palloc allocates memory in the
+ “upper executor context”, that is, the memory context
+ that was current when SPI_connect was called,
+ which is precisely the right context for a value returned from your
+ C function. Several of the other utility functions described in
+ this section also return objects created in the upper executor context.
+
+ When SPI_connect is called, the private
+ context of the C function, which is created by
+ SPI_connect, is made the current context. All
+ allocations made by palloc,
+ repalloc, or SPI utility functions (except as
+ described in this section) are made in this context. When a
+ C function disconnects from the SPI manager (via
+ SPI_finish) the current context is restored to
+ the upper executor context, and all allocations made in the
+ C function memory context are freed and cannot be used any more.
+
SPI_repalloc
SPI_repalloc — reallocate memory in the upper executor context
Synopsis
+void * SPI_repalloc(void * pointer, Size size)
+
Description
+ SPI_repalloc changes the size of a memory
+ segment previously allocated using SPI_palloc.
+
+ This function is no longer different from plain
+ repalloc. It's kept just for backward
+ compatibility of existing code.
+
Arguments
void * pointer
+ pointer to existing storage to change
+
Size size
+ size in bytes of storage to allocate
+
Return Value
+ pointer to new storage space of specified size with the contents
+ copied from the existing area
+
SPI_commit
SPI_commit, SPI_commit_and_chain — commit the current transaction
Synopsis
+void SPI_commit(void)
+
+void SPI_commit_and_chain(void)
+
Description
+ SPI_commit commits the current transaction. It is
+ approximately equivalent to running the SQL
+ command COMMIT. After the transaction is committed, a
+ new transaction is automatically started using default transaction
+ characteristics, so that the caller can continue using SPI facilities.
+ If there is a failure during commit, the current transaction is instead
+ rolled back and a new transaction is started, after which the error is
+ thrown in the usual way.
+
+ SPI_commit_and_chain is the same, but the new
+ transaction is started with the same transaction
+ characteristics as the just finished one, like with the SQL command
+ COMMIT AND CHAIN.
+
+ These functions can only be executed if the SPI connection has been set as
+ nonatomic in the call to SPI_connect_ext.
+
SPI_connect
SPI_connect, SPI_connect_ext — connect a C function to the SPI manager
Synopsis
+int SPI_connect(void)
+
+int SPI_connect_ext(int options)
+
Description
+ SPI_connect opens a connection from a
+ C function invocation to the SPI manager. You must call this
+ function if you want to execute commands through SPI. Some utility
+ SPI functions can be called from unconnected C functions.
+
+ SPI_connect_ext does the same but has an argument that
+ allows passing option flags. Currently, the following option values are
+ available:
+
SPI_OPT_NONATOMIC
+ Sets the SPI connection to be nonatomic, which
+ means that transaction control calls (SPI_commit,
+ SPI_rollback) are allowed. Otherwise,
+ calling those functions will result in an immediate error.
+
+
+ SPI_connect() is equivalent to
+ SPI_connect_ext(0).
+
Return Value
SPI_OK_CONNECT
+ on success
+
SPI_ERROR_CONNECT
+ on error
+
SPI_copytuple
SPI_copytuple — make a copy of a row in the upper executor context
Synopsis
+HeapTuple SPI_copytuple(HeapTuple row)
+
Description
+ SPI_copytuple makes a copy of a row in the
+ upper executor context. This is normally used to return a modified
+ row from a trigger. In a function declared to return a composite
+ type, use SPI_returntuple instead.
+
+ This function can only be used while connected to SPI.
+ Otherwise, it returns NULL and sets SPI_result to
+ SPI_ERROR_UNCONNECTED.
+
Arguments
HeapTuple row
+ row to be copied
+
Return Value
+ the copied row, or NULL on error
+ (see SPI_result for an error indication)
+
SPI_cursor_close
SPI_cursor_close — close a cursor
Synopsis
+void SPI_cursor_close(Portal portal)
+
Description
+ SPI_cursor_close closes a previously created
+ cursor and releases its portal storage.
+
+ All open cursors are closed automatically at the end of a
+ transaction. SPI_cursor_close need only be
+ invoked if it is desirable to release resources sooner.
+
Arguments
Portal portal
+ portal containing the cursor
+
SPI_cursor_fetch
SPI_cursor_fetch — fetch some rows from a cursor
Synopsis
+void SPI_cursor_fetch(Portal portal, bool forward, long count)
+
Description
+ SPI_cursor_fetch fetches some rows from a
+ cursor. This is equivalent to a subset of the SQL command
+ FETCH (see SPI_scroll_cursor_fetch
+ for more functionality).
+
Arguments
Portal portal
+ portal containing the cursor
+
bool forward
+ true for fetch forward, false for fetch backward
+
long count
+ maximum number of rows to fetch
+
Return Value
+ SPI_processed and
+ SPI_tuptable are set as in
+ SPI_execute if successful.
+
Notes
+ Fetching backward may fail if the cursor's plan was not created
+ with the CURSOR_OPT_SCROLL option.
+
SPI_cursor_find
SPI_cursor_find — find an existing cursor by name
Synopsis
+Portal SPI_cursor_find(const char * name)
+
Description
+ SPI_cursor_find finds an existing portal by
+ name. This is primarily useful to resolve a cursor name returned
+ as text by some other function.
+
Arguments
const char * name
+ name of the portal
+
Return Value
+ pointer to the portal with the specified name, or
+ NULL if none was found
+
Notes
+ Beware that this function can return a Portal object
+ that does not have cursor-like properties; for example it might not
+ return tuples. If you simply pass the Portal pointer
+ to other SPI functions, they can defend themselves against such
+ cases, but caution is appropriate when directly inspecting
+ the Portal.
+
SPI_cursor_move
SPI_cursor_move — move a cursor
Synopsis
+void SPI_cursor_move(Portal portal, bool forward, long count)
+
Description
+ SPI_cursor_move skips over some number of rows
+ in a cursor. This is equivalent to a subset of the SQL command
+ MOVE (see SPI_scroll_cursor_move
+ for more functionality).
+
Arguments
Portal portal
+ portal containing the cursor
+
bool forward
+ true for move forward, false for move backward
+
long count
+ maximum number of rows to move
+
Notes
+ Moving backward may fail if the cursor's plan was not created
+ with the CURSOR_OPT_SCROLL option.
+
SPI_cursor_open_with_args
SPI_cursor_open_with_args — set up a cursor using a query and parameters
Synopsis
+Portal SPI_cursor_open_with_args(const char *name,
+ const char *command,
+ int nargs, Oid *argtypes,
+ Datum *values, const char *nulls,
+ bool read_only, int cursorOptions)
+
Description
+ SPI_cursor_open_with_args sets up a cursor
+ (internally, a portal) that will execute the specified query.
+ Most of the parameters have the same meanings as the corresponding
+ parameters to SPI_prepare_cursor
+ and SPI_cursor_open.
+
+ For one-time query execution, this function should be preferred
+ over SPI_prepare_cursor followed by
+ SPI_cursor_open.
+ If the same command is to be executed with many different parameters,
+ either method might be faster, depending on the cost of re-planning
+ versus the benefit of custom plans.
+
+ The passed-in parameter data will be copied into the cursor's portal, so it
+ can be freed while the cursor still exists.
+
+ This function is now deprecated in favor
+ of SPI_cursor_parse_open, which provides equivalent
+ functionality using a more modern API for handling query parameters.
+
Arguments
const char * name
+ name for portal, or NULL to let the system
+ select a name
+
const char * command
+ command string
+
int nargs
+ number of input parameters ($1, $2, etc.)
+
Oid * argtypes
+ an array of length nargs, containing the
+ OIDs of the data types of the parameters
+
Datum * values
+ an array of length nargs, containing the actual
+ parameter values
+
const char * nulls
+ an array of length nargs, describing which
+ parameters are null
+
+ If nulls is NULL then
+ SPI_cursor_open_with_args assumes that no parameters
+ are null. Otherwise, each entry of the nulls
+ array should be ' ' if the corresponding parameter
+ value is non-null, or 'n' if the corresponding parameter
+ value is null. (In the latter case, the actual value in the
+ corresponding values entry doesn't matter.) Note
+ that nulls is not a text string, just an array:
+ it does not need a '\0' terminator.
+
bool read_onlytrue for read-only execution
int cursorOptions
+ integer bit mask of cursor options; zero produces default behavior
+
Return Value
+ Pointer to portal containing the cursor. Note there is no error
+ return convention; any error will be reported via elog.
+
SPI_cursor_open_with_paramlist
SPI_cursor_open_with_paramlist — set up a cursor using parameters
Synopsis
+Portal SPI_cursor_open_with_paramlist(const char *name,
+ SPIPlanPtr plan,
+ ParamListInfo params,
+ bool read_only)
+
Description
+ SPI_cursor_open_with_paramlist sets up a cursor
+ (internally, a portal) that will execute a statement prepared by
+ SPI_prepare.
+ This function is equivalent to SPI_cursor_open
+ except that information about the parameter values to be passed to the
+ query is presented differently. The ParamListInfo
+ representation can be convenient for passing down values that are
+ already available in that format. It also supports use of dynamic
+ parameter sets via hook functions specified in ParamListInfo.
+
+ The passed-in parameter data will be copied into the cursor's portal, so it
+ can be freed while the cursor still exists.
+
Arguments
const char * name
+ name for portal, or NULL to let the system
+ select a name
+
SPIPlanPtr plan
+ prepared statement (returned by SPI_prepare)
+
ParamListInfo params
+ data structure containing parameter types and values; NULL if none
+
bool read_onlytrue for read-only execution
Return Value
+ Pointer to portal containing the cursor. Note there is no error
+ return convention; any error will be reported via elog.
+
SPI_cursor_open
SPI_cursor_open — set up a cursor using a statement created with SPI_prepare
Synopsis
+Portal SPI_cursor_open(const char * name, SPIPlanPtr plan,
+ Datum * values, const char * nulls,
+ bool read_only)
+
Description
+ SPI_cursor_open sets up a cursor (internally,
+ a portal) that will execute a statement prepared by
+ SPI_prepare. The parameters have the same
+ meanings as the corresponding parameters to
+ SPI_execute_plan.
+
+ Using a cursor instead of executing the statement directly has two
+ benefits. First, the result rows can be retrieved a few at a time,
+ avoiding memory overrun for queries that return many rows. Second,
+ a portal can outlive the current C function (it can, in fact, live
+ to the end of the current transaction). Returning the portal name
+ to the C function's caller provides a way of returning a row set as
+ result.
+
+ The passed-in parameter data will be copied into the cursor's portal, so it
+ can be freed while the cursor still exists.
+
Arguments
const char * name
+ name for portal, or NULL to let the system
+ select a name
+
SPIPlanPtr plan
+ prepared statement (returned by SPI_prepare)
+
Datum * values
+ An array of actual parameter values. Must have same length as the
+ statement's number of arguments.
+
const char * nulls
+ An array describing which parameters are null. Must have same length as
+ the statement's number of arguments.
+
+ If nulls is NULL then
+ SPI_cursor_open assumes that no parameters
+ are null. Otherwise, each entry of the nulls
+ array should be ' ' if the corresponding parameter
+ value is non-null, or 'n' if the corresponding parameter
+ value is null. (In the latter case, the actual value in the
+ corresponding values entry doesn't matter.) Note
+ that nulls is not a text string, just an array:
+ it does not need a '\0' terminator.
+
bool read_onlytrue for read-only execution
Return Value
+ Pointer to portal containing the cursor. Note there is no error
+ return convention; any error will be reported via elog.
+
SPI_cursor_parse_open
SPI_cursor_parse_open — set up a cursor using a query string and parameters
Synopsis
+Portal SPI_cursor_parse_open(const char *name,
+ const char *command,
+ const SPIParseOpenOptions * options)
+
Description
+ SPI_cursor_parse_open sets up a cursor
+ (internally, a portal) that will execute the specified query string.
+ This is comparable to SPI_prepare_cursor followed
+ by SPI_cursor_open_with_paramlist, except that
+ parameter references within the query string are handled entirely by
+ supplying a ParamListInfo object.
+
+ For one-time query execution, this function should be preferred
+ over SPI_prepare_cursor followed by
+ SPI_cursor_open_with_paramlist.
+ If the same command is to be executed with many different parameters,
+ either method might be faster, depending on the cost of re-planning
+ versus the benefit of custom plans.
+
+ The options->params object should normally
+ mark each parameter with the PARAM_FLAG_CONST flag,
+ since a one-shot plan is always used for the query.
+
+ The passed-in parameter data will be copied into the cursor's portal, so it
+ can be freed while the cursor still exists.
+
Arguments
const char * name
+ name for portal, or NULL to let the system
+ select a name
+
const char * command
+ command string
+
const SPIParseOpenOptions * options
+ struct containing optional arguments
+
+ Callers should always zero out the entire options
+ struct, then fill whichever fields they want to set. This ensures forward
+ compatibility of code, since any fields that are added to the struct in
+ future will be defined to behave backwards-compatibly if they are zero.
+ The currently available options fields are:
+
ParamListInfo params
+ data structure containing query parameter types and values; NULL if none
+
int cursorOptions
+ integer bit mask of cursor options; zero produces default behavior
+
bool read_onlytrue for read-only execution
Return Value
+ Pointer to portal containing the cursor. Note there is no error
+ return convention; any error will be reported via elog.
+
SPI_exec
SPI_exec — execute a read/write command
Synopsis
+int SPI_exec(const char * command, long count)
+
Description
+ SPI_exec is the same as
+ SPI_execute, with the latter's
+ read_only parameter always taken as
+ false.
+
Arguments
const char * command
+ string containing command to execute
+
long count
+ maximum number of rows to return,
+ or 0 for no limit
+
Return Value
+ See SPI_execute.
+
SPI_execp
SPI_execp — execute a statement in read/write mode
Synopsis
+int SPI_execp(SPIPlanPtr plan, Datum * values, const char * nulls, long count)
+
Description
+ SPI_execp is the same as
+ SPI_execute_plan, with the latter's
+ read_only parameter always taken as
+ false.
+
Arguments
SPIPlanPtr plan
+ prepared statement (returned by SPI_prepare)
+
Datum * values
+ An array of actual parameter values. Must have same length as the
+ statement's number of arguments.
+
const char * nulls
+ An array describing which parameters are null. Must have same length as
+ the statement's number of arguments.
+
+ If nulls is NULL then
+ SPI_execp assumes that no parameters
+ are null. Otherwise, each entry of the nulls
+ array should be ' ' if the corresponding parameter
+ value is non-null, or 'n' if the corresponding parameter
+ value is null. (In the latter case, the actual value in the
+ corresponding values entry doesn't matter.) Note
+ that nulls is not a text string, just an array:
+ it does not need a '\0' terminator.
+
long count
+ maximum number of rows to return,
+ or 0 for no limit
+
Return Value
+ See SPI_execute_plan.
+
+ SPI_processed and
+ SPI_tuptable are set as in
+ SPI_execute if successful.
+
SPI_execute_extended
SPI_execute_extended — execute a command with out-of-line parameters
Synopsis
+int SPI_execute_extended(const char *command,
+ const SPIExecuteOptions * options)
+
Description
+ SPI_execute_extended executes a command that might
+ include references to externally supplied parameters. The command text
+ refers to a parameter as $n,
+ and the options->params object (if supplied)
+ provides values and type information for each such symbol.
+ Various execution options can be specified
+ in the options struct, too.
+
+ The options->params object should normally
+ mark each parameter with the PARAM_FLAG_CONST flag,
+ since a one-shot plan is always used for the query.
+
+ If options->dest is not NULL, then result
+ tuples are passed to that object as they are generated by the executor,
+ instead of being accumulated in SPI_tuptable. Using
+ a caller-supplied DestReceiver object is particularly
+ helpful for queries that might generate many tuples, since the data can
+ be processed on-the-fly instead of being accumulated in memory.
+
Arguments
const char * command
+ command string
+
const SPIExecuteOptions * options
+ struct containing optional arguments
+
+ Callers should always zero out the entire options
+ struct, then fill whichever fields they want to set. This ensures forward
+ compatibility of code, since any fields that are added to the struct in
+ future will be defined to behave backwards-compatibly if they are zero.
+ The currently available options fields are:
+
ParamListInfo params
+ data structure containing query parameter types and values; NULL if none
+
bool read_onlytrue for read-only execution
bool allow_nonatomic
+ true allows non-atomic execution of CALL and DO
+ statements
+
bool must_return_tuples
+ if true, raise error if the query is not of a kind
+ that returns tuples (this does not forbid the case where it happens to
+ return zero tuples)
+
uint64 tcount
+ maximum number of rows to return,
+ or 0 for no limit
+
DestReceiver * dest
+ DestReceiver object that will receive any tuples
+ emitted by the query; if NULL, result tuples are accumulated into
+ a SPI_tuptable structure, as
+ in SPI_execute
+
ResourceOwner owner
+ This field is present for consistency
+ with SPI_execute_plan_extended, but it is
+ ignored, since the plan used
+ by SPI_execute_extended is never saved.
+
Return Value
+ The return value is the same as for SPI_execute.
+
+ When options->dest is NULL,
+ SPI_processed and
+ SPI_tuptable are set as in
+ SPI_execute.
+ When options->dest is not NULL,
+ SPI_processed is set to zero and
+ SPI_tuptable is set to NULL. If a tuple count
+ is required, the caller's DestReceiver object must
+ calculate it.
+
SPI_execute_plan_extended
SPI_execute_plan_extended — execute a statement prepared by SPI_prepare
Synopsis
+int SPI_execute_plan_extended(SPIPlanPtr plan,
+ const SPIExecuteOptions * options)
+
Description
+ SPI_execute_plan_extended executes a statement
+ prepared by SPI_prepare or one of its siblings.
+ This function is equivalent to SPI_execute_plan,
+ except that information about the parameter values to be passed to the
+ query is presented differently, and additional execution-controlling
+ options can be passed.
+
+ Query parameter values are represented by
+ a ParamListInfo struct, which is convenient for passing
+ down values that are already available in that format. Dynamic parameter
+ sets can also be used, via hook functions specified
+ in ParamListInfo.
+
+ Also, instead of always accumulating the result tuples into a
+ SPI_tuptable structure, tuples can be passed to a
+ caller-supplied DestReceiver object as they are
+ generated by the executor. This is particularly helpful for queries
+ that might generate many tuples, since the data can be processed
+ on-the-fly instead of being accumulated in memory.
+
Arguments
SPIPlanPtr plan
+ prepared statement (returned by SPI_prepare)
+
const SPIExecuteOptions * options
+ struct containing optional arguments
+
+ Callers should always zero out the entire options
+ struct, then fill whichever fields they want to set. This ensures forward
+ compatibility of code, since any fields that are added to the struct in
+ future will be defined to behave backwards-compatibly if they are zero.
+ The currently available options fields are:
+
ParamListInfo params
+ data structure containing query parameter types and values; NULL if none
+
bool read_onlytrue for read-only execution
bool allow_nonatomic
+ true allows non-atomic execution of CALL and DO
+ statements
+
bool must_return_tuples
+ if true, raise error if the query is not of a kind
+ that returns tuples (this does not forbid the case where it happens to
+ return zero tuples)
+
uint64 tcount
+ maximum number of rows to return,
+ or 0 for no limit
+
DestReceiver * dest
+ DestReceiver object that will receive any tuples
+ emitted by the query; if NULL, result tuples are accumulated into
+ a SPI_tuptable structure, as
+ in SPI_execute_plan
+
ResourceOwner owner
+ The resource owner that will hold a reference count on the plan while
+ it is executed. If NULL, CurrentResourceOwner is used. Ignored for
+ non-saved plans, as SPI does not acquire reference counts on those.
+
Return Value
+ The return value is the same as for SPI_execute_plan.
+
+ When options->dest is NULL,
+ SPI_processed and
+ SPI_tuptable are set as in
+ SPI_execute_plan.
+ When options->dest is not NULL,
+ SPI_processed is set to zero and
+ SPI_tuptable is set to NULL. If a tuple count
+ is required, the caller's DestReceiver object must
+ calculate it.
+
SPI_execute_plan_with_paramlist
SPI_execute_plan_with_paramlist — execute a statement prepared by SPI_prepare
Synopsis
+int SPI_execute_plan_with_paramlist(SPIPlanPtr plan,
+ ParamListInfo params,
+ bool read_only,
+ long count)
+
Description
+ SPI_execute_plan_with_paramlist executes a statement
+ prepared by SPI_prepare.
+ This function is equivalent to SPI_execute_plan
+ except that information about the parameter values to be passed to the
+ query is presented differently. The ParamListInfo
+ representation can be convenient for passing down values that are
+ already available in that format. It also supports use of dynamic
+ parameter sets via hook functions specified in ParamListInfo.
+
+ This function is now deprecated in favor
+ of SPI_execute_plan_extended.
+
Arguments
SPIPlanPtr plan
+ prepared statement (returned by SPI_prepare)
+
ParamListInfo params
+ data structure containing parameter types and values; NULL if none
+
bool read_onlytrue for read-only execution
long count
+ maximum number of rows to return,
+ or 0 for no limit
+
Return Value
+ The return value is the same as for SPI_execute_plan.
+
+ SPI_processed and
+ SPI_tuptable are set as in
+ SPI_execute_plan if successful.
+
SPI_execute_plan
SPI_execute_plan — execute a statement prepared by SPI_prepare
Synopsis
+int SPI_execute_plan(SPIPlanPtr plan, Datum * values, const char * nulls,
+ bool read_only, long count)
+
Description
+ SPI_execute_plan executes a statement prepared by
+ SPI_prepare or one of its siblings.
+ read_only and
+ count have the same interpretation as in
+ SPI_execute.
+
Arguments
SPIPlanPtr plan
+ prepared statement (returned by SPI_prepare)
+
Datum * values
+ An array of actual parameter values. Must have same length as the
+ statement's number of arguments.
+
const char * nulls
+ An array describing which parameters are null. Must have same length as
+ the statement's number of arguments.
+
+ If nulls is NULL then
+ SPI_execute_plan assumes that no parameters
+ are null. Otherwise, each entry of the nulls
+ array should be ' ' if the corresponding parameter
+ value is non-null, or 'n' if the corresponding parameter
+ value is null. (In the latter case, the actual value in the
+ corresponding values entry doesn't matter.) Note
+ that nulls is not a text string, just an array:
+ it does not need a '\0' terminator.
+
bool read_onlytrue for read-only execution
long count
+ maximum number of rows to return,
+ or 0 for no limit
+
Return Value
+ The return value is the same as for SPI_execute,
+ with the following additional possible error (negative) results:
+
+
SPI_ERROR_ARGUMENT
+ if plan is NULL or invalid,
+ or count is less than 0
+
SPI_ERROR_PARAM
+ if values is NULL and
+ plan was prepared with some parameters
+
+
+ SPI_processed and
+ SPI_tuptable are set as in
+ SPI_execute if successful.
+
SPI_execute_with_args
SPI_execute_with_args — execute a command with out-of-line parameters
Synopsis
+int SPI_execute_with_args(const char *command,
+ int nargs, Oid *argtypes,
+ Datum *values, const char *nulls,
+ bool read_only, long count)
+
Description
+ SPI_execute_with_args executes a command that might
+ include references to externally supplied parameters. The command text
+ refers to a parameter as $n, and
+ the call specifies data types and values for each such symbol.
+ read_only and count have
+ the same interpretation as in SPI_execute.
+
+ The main advantage of this routine compared to
+ SPI_execute is that data values can be inserted
+ into the command without tedious quoting/escaping, and thus with much
+ less risk of SQL-injection attacks.
+
+ Similar results can be achieved with SPI_prepare followed by
+ SPI_execute_plan; however, when using this function
+ the query plan is always customized to the specific parameter values
+ provided.
+ For one-time query execution, this function should be preferred.
+ If the same command is to be executed with many different parameters,
+ either method might be faster, depending on the cost of re-planning
+ versus the benefit of custom plans.
+
Arguments
const char * command
+ command string
+
int nargs
+ number of input parameters ($1, $2, etc.)
+
Oid * argtypes
+ an array of length nargs, containing the
+ OIDs of the data types of the parameters
+
Datum * values
+ an array of length nargs, containing the actual
+ parameter values
+
const char * nulls
+ an array of length nargs, describing which
+ parameters are null
+
+ If nulls is NULL then
+ SPI_execute_with_args assumes that no parameters
+ are null. Otherwise, each entry of the nulls
+ array should be ' ' if the corresponding parameter
+ value is non-null, or 'n' if the corresponding parameter
+ value is null. (In the latter case, the actual value in the
+ corresponding values entry doesn't matter.) Note
+ that nulls is not a text string, just an array:
+ it does not need a '\0' terminator.
+
bool read_onlytrue for read-only execution
long count
+ maximum number of rows to return,
+ or 0 for no limit
+
Return Value
+ The return value is the same as for SPI_execute.
+
+ SPI_processed and
+ SPI_tuptable are set as in
+ SPI_execute if successful.
+
SPI_execute
SPI_execute — execute a command
Synopsis
+int SPI_execute(const char * command, bool read_only, long count)
+
Description
+ SPI_execute executes the specified SQL command
+ for count rows. If read_only
+ is true, the command must be read-only, and execution overhead
+ is somewhat reduced.
+
+ This function can only be called from a connected C function.
+
+ If count is zero then the command is executed
+ for all rows that it applies to. If count
+ is greater than zero, then no more than count rows
+ will be retrieved; execution stops when the count is reached, much like
+ adding a LIMIT clause to the query. For example,
+
+SPI_execute("SELECT * FROM foo", true, 5);
+
+ will retrieve at most 5 rows from the table. Note that such a limit
+ is only effective when the command actually returns rows. For example,
+
+SPI_execute("INSERT INTO foo SELECT * FROM bar", false, 5);
+
+ inserts all rows from bar, ignoring the
+ count parameter. However, with
+
+SPI_execute("INSERT INTO foo SELECT * FROM bar RETURNING *", false, 5);
+
+ at most 5 rows would be inserted, since execution would stop after the
+ fifth RETURNING result row is retrieved.
+
+ You can pass multiple commands in one string;
+ SPI_execute returns the
+ result for the command executed last. The count
+ limit applies to each command separately (even though only the last
+ result will actually be returned). The limit is not applied to any
+ hidden commands generated by rules.
+
+ When read_only is false,
+ SPI_execute increments the command
+ counter and computes a new snapshot before executing each
+ command in the string. The snapshot does not actually change if the
+ current transaction isolation level is SERIALIZABLE or REPEATABLE READ, but in
+ READ COMMITTED mode the snapshot update allows each command to
+ see the results of newly committed transactions from other sessions.
+ This is essential for consistent behavior when the commands are modifying
+ the database.
+
+ When read_only is true,
+ SPI_execute does not update either the snapshot
+ or the command counter, and it allows only plain SELECT
+ commands to appear in the command string. The commands are executed
+ using the snapshot previously established for the surrounding query.
+ This execution mode is somewhat faster than the read/write mode due
+ to eliminating per-command overhead. It also allows genuinely
+ stable functions to be built: since successive executions
+ will all use the same snapshot, there will be no change in the results.
+
+ It is generally unwise to mix read-only and read-write commands within
+ a single function using SPI; that could result in very confusing behavior,
+ since the read-only queries would not see the results of any database
+ updates done by the read-write queries.
+
+ The actual number of rows for which the (last) command was executed
+ is returned in the global variable SPI_processed.
+ If the return value of the function is SPI_OK_SELECT,
+ SPI_OK_INSERT_RETURNING,
+ SPI_OK_DELETE_RETURNING, or
+ SPI_OK_UPDATE_RETURNING,
+ then you can use the
+ global pointer SPITupleTable *SPI_tuptable to
+ access the result rows. Some utility commands (such as
+ EXPLAIN) also return row sets, and SPI_tuptable
+ will contain the result in these cases too. Some utility commands
+ (COPY, CREATE TABLE AS) don't return a row set, so
+ SPI_tuptable is NULL, but they still return the number of
+ rows processed in SPI_processed.
+
+ The structure SPITupleTable is defined
+ thus:
+
+typedef struct SPITupleTable
+{
+ /* Public members */
+ TupleDesc tupdesc; /* tuple descriptor */
+ HeapTuple *vals; /* array of tuples */
+ uint64 numvals; /* number of valid tuples */
+
+ /* Private members, not intended for external callers */
+ uint64 alloced; /* allocated length of vals array */
+ MemoryContext tuptabcxt; /* memory context of result table */
+ slist_node next; /* link for internal bookkeeping */
+ SubTransactionId subid; /* subxact in which tuptable was created */
+} SPITupleTable;
+
+ The fields tupdesc,
+ vals, and
+ numvals
+ can be used by SPI callers; the remaining fields are internal.
+ vals is an array of pointers to rows.
+ The number of rows is given by numvals
+ (for somewhat historical reasons, this count is also returned
+ in SPI_processed).
+ tupdesc is a row descriptor which you can pass to
+ SPI functions dealing with rows.
+
+ SPI_finish frees all
+ SPITupleTables allocated during the current
+ C function. You can free a particular result table earlier, if you
+ are done with it, by calling SPI_freetuptable.
+
Arguments
const char * command
+ string containing command to execute
+
bool read_onlytrue for read-only execution
long count
+ maximum number of rows to return,
+ or 0 for no limit
+
Return Value
+ If the execution of the command was successful then one of the
+ following (nonnegative) values will be returned:
+
+
SPI_OK_SELECT
+ if a SELECT (but not SELECT
+ INTO) was executed
+
SPI_OK_SELINTO
+ if a SELECT INTO was executed
+
SPI_OK_INSERT
+ if an INSERT was executed
+
SPI_OK_DELETE
+ if a DELETE was executed
+
SPI_OK_UPDATE
+ if an UPDATE was executed
+
SPI_OK_MERGE
+ if a MERGE was executed
+
SPI_OK_INSERT_RETURNING
+ if an INSERT RETURNING was executed
+
SPI_OK_DELETE_RETURNING
+ if a DELETE RETURNING was executed
+
SPI_OK_UPDATE_RETURNING
+ if an UPDATE RETURNING was executed
+
SPI_OK_UTILITY
+ if a utility command (e.g., CREATE TABLE)
+ was executed
+
SPI_OK_REWRITTEN
+ if the command was rewritten into another kind of command (e.g.,
+ UPDATE became an INSERT) by a rule.
+
+
+ On error, one of the following negative values is returned:
+
+
SPI_ERROR_ARGUMENT
+ if command is NULL or
+ count is less than 0
+
SPI_ERROR_COPY
+ if COPY TO stdout or COPY FROM stdin
+ was attempted
+
SPI_ERROR_TRANSACTION
+ if a transaction manipulation command was attempted
+ (BEGIN,
+ COMMIT,
+ ROLLBACK,
+ SAVEPOINT,
+ PREPARE TRANSACTION,
+ COMMIT PREPARED,
+ ROLLBACK PREPARED,
+ or any variant thereof)
+
SPI_ERROR_OPUNKNOWN
+ if the command type is unknown (shouldn't happen)
+
SPI_ERROR_UNCONNECTED
+ if called from an unconnected C function
+
+
Notes
+ All SPI query-execution functions set both
+ SPI_processed and
+ SPI_tuptable (just the pointer, not the contents
+ of the structure). Save these two global variables into local
+ C function variables if you need to access the result table of
+ SPI_execute or another query-execution function
+ across later calls.
+
SPI_finish
SPI_finish — disconnect a C function from the SPI manager
Synopsis
+int SPI_finish(void)
+
Description
+ SPI_finish closes an existing connection to
+ the SPI manager. You must call this function after completing the
+ SPI operations needed during your C function's current invocation.
+ You do not need to worry about making this happen, however, if you
+ abort the transaction via elog(ERROR). In that
+ case SPI will clean itself up automatically.
+
Return Value
SPI_OK_FINISH
+ if properly disconnected
+
SPI_ERROR_UNCONNECTED
+ if called from an unconnected C function
+
SPI_fname
SPI_fname — determine the column name for the specified column number
Synopsis
+char * SPI_fname(TupleDesc rowdesc, int colnumber)
+
Description
+ SPI_fname returns a copy of the column name of the
+ specified column. (You can use pfree to
+ release the copy of the name when you don't need it anymore.)
+
Arguments
TupleDesc rowdesc
+ input row description
+
int colnumber
+ column number (count starts at 1)
+
Return Value
+ The column name; NULL if
+ colnumber is out of range.
+ SPI_result set to
+ SPI_ERROR_NOATTRIBUTE on error.
+
SPI_fnumber
SPI_fnumber — determine the column number for the specified column name
Synopsis
+int SPI_fnumber(TupleDesc rowdesc, const char * colname)
+
Description
+ SPI_fnumber returns the column number for the
+ column with the specified name.
+
+ If colname refers to a system column (e.g.,
+ ctid) then the appropriate negative column number will
+ be returned. The caller should be careful to test the return value
+ for exact equality to SPI_ERROR_NOATTRIBUTE to
+ detect an error; testing the result for less than or equal to 0 is
+ not correct unless system columns should be rejected.
+
Arguments
TupleDesc rowdesc
+ input row description
+
const char * colname
+ column name
+
Return Value
+ Column number (count starts at 1 for user-defined columns), or
+ SPI_ERROR_NOATTRIBUTE if the named column was not
+ found.
+
SPI_freeplan
SPI_freeplan — free a previously saved prepared statement
Synopsis
+int SPI_freeplan(SPIPlanPtr plan)
+
Description
+ SPI_freeplan releases a prepared statement
+ previously returned by SPI_prepare or saved by
+ SPI_keepplan or SPI_saveplan.
+
Arguments
SPIPlanPtr plan
+ pointer to statement to free
+
Return Value
+ 0 on success;
+ SPI_ERROR_ARGUMENT if plan
+ is NULL or invalid
+
SPI_freetuple
SPI_freetuple — free a row allocated in the upper executor context
Synopsis
+void SPI_freetuple(HeapTuple row)
+
Description
+ SPI_freetuple frees a row previously allocated
+ in the upper executor context.
+
+ This function is no longer different from plain
+ heap_freetuple. It's kept just for backward
+ compatibility of existing code.
+
Arguments
HeapTuple row
+ row to free
+
SPI_freetuptable
SPI_freetuptable — free a row set created by SPI_execute or a similar
+ function
Synopsis
+void SPI_freetuptable(SPITupleTable * tuptable)
+
Description
+ SPI_freetuptable frees a row set created by a
+ prior SPI command execution function, such as
+ SPI_execute. Therefore, this function is often called
+ with the global variable SPI_tuptable as
+ argument.
+
+ This function is useful if an SPI-using C function needs to execute
+ multiple commands and does not want to keep the results of earlier
+ commands around until it ends. Note that any unfreed row sets will
+ be freed anyway at SPI_finish.
+ Also, if a subtransaction is started and then aborted within execution
+ of an SPI-using C function, SPI automatically frees any row sets created while
+ the subtransaction was running.
+
+ Beginning in PostgreSQL 9.3,
+ SPI_freetuptable contains guard logic to protect
+ against duplicate deletion requests for the same row set. In previous
+ releases, duplicate deletions would lead to crashes.
+
Arguments
SPITupleTable * tuptable
+ pointer to row set to free, or NULL to do nothing
+
SPI_getargcount
SPI_getargcount — return the number of arguments needed by a statement
+ prepared by SPI_prepare
Synopsis
+int SPI_getargcount(SPIPlanPtr plan)
+
Description
+ SPI_getargcount returns the number of arguments needed
+ to execute a statement prepared by SPI_prepare.
+
Arguments
SPIPlanPtr plan
+ prepared statement (returned by SPI_prepare)
+
Return Value
+ The count of expected arguments for the plan.
+ If the plan is NULL or invalid,
+ SPI_result is set to SPI_ERROR_ARGUMENT
+ and -1 is returned.
+
SPI_getargtypeid
SPI_getargtypeid — return the data type OID for an argument of
+ a statement prepared by SPI_prepare
Synopsis
+Oid SPI_getargtypeid(SPIPlanPtr plan, int argIndex)
+
Description
+ SPI_getargtypeid returns the OID representing the type
+ for the argIndex'th argument of a statement prepared by
+ SPI_prepare. First argument is at index zero.
+
Arguments
SPIPlanPtr plan
+ prepared statement (returned by SPI_prepare)
+
int argIndex
+ zero based index of the argument
+
Return Value
+ The type OID of the argument at the given index.
+ If the plan is NULL or invalid,
+ or argIndex is less than 0 or
+ not less than the number of arguments declared for the
+ plan,
+ SPI_result is set to SPI_ERROR_ARGUMENT
+ and InvalidOid is returned.
+
SPI_getbinval
SPI_getbinval — return the binary value of the specified column
Synopsis
+Datum SPI_getbinval(HeapTuple row, TupleDesc rowdesc, int colnumber,
+ bool * isnull)
+
Description
+ SPI_getbinval returns the value of the
+ specified column in the internal form (as type Datum).
+
+ This function does not allocate new space for the datum. In the
+ case of a pass-by-reference data type, the return value will be a
+ pointer into the passed row.
+
Arguments
HeapTuple row
+ input row to be examined
+
TupleDesc rowdesc
+ input row description
+
int colnumber
+ column number (count starts at 1)
+
bool * isnull
+ flag for a null value in the column
+
Return Value
+ The binary value of the column is returned. The variable pointed
+ to by isnull is set to true if the column is
+ null, else to false.
+
+ SPI_result is set to
+ SPI_ERROR_NOATTRIBUTE on error.
+
SPI_getnspname
SPI_getnspname — return the namespace of the specified relation
Synopsis
+char * SPI_getnspname(Relation rel)
+
Description
+ SPI_getnspname returns a copy of the name of
+ the namespace that the specified Relation
+ belongs to. This is equivalent to the relation's schema. You should
+ pfree the return value of this function when
+ you are finished with it.
+
Arguments
Relation rel
+ input relation
+
Return Value
+ The name of the specified relation's namespace.
+
SPI_getrelname
SPI_getrelname — return the name of the specified relation
Synopsis
+char * SPI_getrelname(Relation rel)
+
Description
+ SPI_getrelname returns a copy of the name of the
+ specified relation. (You can use pfree to
+ release the copy of the name when you don't need it anymore.)
+
Arguments
Relation rel
+ input relation
+
Return Value
+ The name of the specified relation.
+
SPI_gettype
SPI_gettype — return the data type name of the specified column
Synopsis
+char * SPI_gettype(TupleDesc rowdesc, int colnumber)
+
Description
+ SPI_gettype returns a copy of the data type name of the
+ specified column. (You can use pfree to
+ release the copy of the name when you don't need it anymore.)
+
Arguments
TupleDesc rowdesc
+ input row description
+
int colnumber
+ column number (count starts at 1)
+
Return Value
+ The data type name of the specified column, or
+ NULL on error. SPI_result is
+ set to SPI_ERROR_NOATTRIBUTE on error.
+
SPI_gettypeid
SPI_gettypeid — return the data type OID of the specified column
Synopsis
+Oid SPI_gettypeid(TupleDesc rowdesc, int colnumber)
+
Description
+ SPI_gettypeid returns the
+ OID of the data type of the specified column.
+
Arguments
TupleDesc rowdesc
+ input row description
+
int colnumber
+ column number (count starts at 1)
+
Return Value
+ The OID of the data type of the specified column
+ or InvalidOid on error. On error,
+ SPI_result is set to
+ SPI_ERROR_NOATTRIBUTE.
+
SPI_getvalue
SPI_getvalue — return the string value of the specified column
Synopsis
+char * SPI_getvalue(HeapTuple row, TupleDesc rowdesc, int colnumber)
+
Description
+ SPI_getvalue returns the string representation
+ of the value of the specified column.
+
+ The result is returned in memory allocated using
+ palloc. (You can use
+ pfree to release the memory when you don't
+ need it anymore.)
+
Arguments
HeapTuple row
+ input row to be examined
+
TupleDesc rowdesc
+ input row description
+
int colnumber
+ column number (count starts at 1)
+
Return Value
+ Column value, or NULL if the column is null,
+ colnumber is out of range
+ (SPI_result is set to
+ SPI_ERROR_NOATTRIBUTE), or no output function is
+ available (SPI_result is set to
+ SPI_ERROR_NOOUTFUNC).
+
SPI_is_cursor_plan
SPI_is_cursor_plan — return true if a statement
+ prepared by SPI_prepare can be used with
+ SPI_cursor_open
Synopsis
+bool SPI_is_cursor_plan(SPIPlanPtr plan)
+
Description
+ SPI_is_cursor_plan returns true
+ if a statement prepared by SPI_prepare can be passed
+ as an argument to SPI_cursor_open, or
+ false if that is not the case. The criteria are that the
+ plan represents one single command and that this
+ command returns tuples to the caller; for example, SELECT
+ is allowed unless it contains an INTO clause, and
+ UPDATE is allowed only if it contains a RETURNING
+ clause.
+
Arguments
SPIPlanPtr plan
+ prepared statement (returned by SPI_prepare)
+
Return Value
+ true or false to indicate if the
+ plan can produce a cursor or not, with
+ SPI_result set to zero.
+ If it is not possible to determine the answer (for example,
+ if the plan is NULL or invalid,
+ or if called when not connected to SPI), then
+ SPI_result is set to a suitable error code
+ and false is returned.
+
SPI_keepplan
SPI_keepplan — save a prepared statement
Synopsis
+int SPI_keepplan(SPIPlanPtr plan)
+
Description
+ SPI_keepplan saves a passed statement (prepared by
+ SPI_prepare) so that it will not be freed
+ by SPI_finish nor by the transaction manager.
+ This gives you the ability to reuse prepared statements in the subsequent
+ invocations of your C function in the current session.
+
Arguments
SPIPlanPtr plan
+ the prepared statement to be saved
+
Return Value
+ 0 on success;
+ SPI_ERROR_ARGUMENT if plan
+ is NULL or invalid
+
Notes
+ The passed-in statement is relocated to permanent storage by means
+ of pointer adjustment (no data copying is required). If you later
+ wish to delete it, use SPI_freeplan on it.
+
SPI_modifytuple
SPI_modifytuple — create a row by replacing selected fields of a given row
Synopsis
+HeapTuple SPI_modifytuple(Relation rel, HeapTuple row, int ncols,
+ int * colnum, Datum * values, const char * nulls)
+
Description
+ SPI_modifytuple creates a new row by
+ substituting new values for selected columns, copying the original
+ row's columns at other positions. The input row is not modified.
+ The new row is returned in the upper executor context.
+
+ This function can only be used while connected to SPI.
+ Otherwise, it returns NULL and sets SPI_result to
+ SPI_ERROR_UNCONNECTED.
+
Arguments
Relation rel
+ Used only as the source of the row descriptor for the row.
+ (Passing a relation rather than a row descriptor is a
+ misfeature.)
+
HeapTuple row
+ row to be modified
+
int ncols
+ number of columns to be changed
+
int * colnum
+ an array of length ncols, containing the numbers
+ of the columns that are to be changed (column numbers start at 1)
+
Datum * values
+ an array of length ncols, containing the
+ new values for the specified columns
+
const char * nulls
+ an array of length ncols, describing which
+ new values are null
+
+ If nulls is NULL then
+ SPI_modifytuple assumes that no new values
+ are null. Otherwise, each entry of the nulls
+ array should be ' ' if the corresponding new value is
+ non-null, or 'n' if the corresponding new value is
+ null. (In the latter case, the actual value in the corresponding
+ values entry doesn't matter.) Note that
+ nulls is not a text string, just an array: it
+ does not need a '\0' terminator.
+
Return Value
+ new row with modifications, allocated in the upper executor
+ context, or NULL on error
+ (see SPI_result for an error indication)
+
+ On error, SPI_result is set as follows:
+
SPI_ERROR_ARGUMENT
+ if rel is NULL, or if
+ row is NULL, or if ncols
+ is less than or equal to 0, or if colnum is
+ NULL, or if values is NULL.
+
SPI_ERROR_NOATTRIBUTE
+ if colnum contains an invalid column number (less
+ than or equal to 0 or greater than the number of columns in
+ row)
+
SPI_ERROR_UNCONNECTED
+ if SPI is not active
+
+
SPI_palloc
SPI_palloc — allocate memory in the upper executor context
Synopsis
+void * SPI_palloc(Size size)
+
Description
+ SPI_palloc allocates memory in the upper
+ executor context.
+
+ This function can only be used while connected to SPI.
+ Otherwise, it throws an error.
+
Arguments
Size size
+ size in bytes of storage to allocate
+
Return Value
+ pointer to new storage space of the specified size
+
SPI_pfree
SPI_pfree — free memory in the upper executor context
Synopsis
+void SPI_pfree(void * pointer)
+
Description
+ SPI_pfree frees memory previously allocated
+ using SPI_palloc or
+ SPI_repalloc.
+
+ This function is no longer different from plain
+ pfree. It's kept just for backward
+ compatibility of existing code.
+
Arguments
void * pointer
+ pointer to existing storage to free
+
SPI_prepare_cursor
SPI_prepare_cursor — prepare a statement, without executing it yet
Synopsis
+SPIPlanPtr SPI_prepare_cursor(const char * command, int nargs,
+ Oid * argtypes, int cursorOptions)
+
Description
+ SPI_prepare_cursor is identical to
+ SPI_prepare, except that it also allows specification
+ of the planner's “cursor options” parameter. This is a bit mask
+ having the values shown in nodes/parsenodes.h
+ for the options field of DeclareCursorStmt.
+ SPI_prepare always takes the cursor options as zero.
+
+ This function is now deprecated in favor
+ of SPI_prepare_extended.
+
Arguments
const char * command
+ command string
+
int nargs
+ number of input parameters ($1, $2, etc.)
+
Oid * argtypes
+ pointer to an array containing the OIDs of
+ the data types of the parameters
+
int cursorOptions
+ integer bit mask of cursor options; zero produces default behavior
+
Return Value
+ SPI_prepare_cursor has the same return conventions as
+ SPI_prepare.
+
Notes
+ Useful bits to set in cursorOptions include
+ CURSOR_OPT_SCROLL,
+ CURSOR_OPT_NO_SCROLL,
+ CURSOR_OPT_FAST_PLAN,
+ CURSOR_OPT_GENERIC_PLAN, and
+ CURSOR_OPT_CUSTOM_PLAN. Note in particular that
+ CURSOR_OPT_HOLD is ignored.
+
SPI_prepare_extended
SPI_prepare_extended — prepare a statement, without executing it yet
Synopsis
+SPIPlanPtr SPI_prepare_extended(const char * command,
+ const SPIPrepareOptions * options)
+
Description
+ SPI_prepare_extended creates and returns a prepared
+ statement for the specified command, but doesn't execute the command.
+ This function is equivalent to SPI_prepare,
+ with the addition that the caller can specify options to control
+ the parsing of external parameter references, as well as other facets
+ of query parsing and planning.
+
Arguments
const char * command
+ command string
+
const SPIPrepareOptions * options
+ struct containing optional arguments
+
+ Callers should always zero out the entire options
+ struct, then fill whichever fields they want to set. This ensures forward
+ compatibility of code, since any fields that are added to the struct in
+ future will be defined to behave backwards-compatibly if they are zero.
+ The currently available options fields are:
+
ParserSetupHook parserSetup
+ Parser hook setup function
+
void * parserSetupArg
+ pass-through argument for parserSetup
+
RawParseMode parseMode
+ mode for raw parsing; RAW_PARSE_DEFAULT (zero)
+ produces default behavior
+
int cursorOptions
+ integer bit mask of cursor options; zero produces default behavior
+
Return Value
+ SPI_prepare_extended has the same return conventions as
+ SPI_prepare.
+
SPI_prepare_params
SPI_prepare_params — prepare a statement, without executing it yet
Synopsis
+SPIPlanPtr SPI_prepare_params(const char * command,
+ ParserSetupHook parserSetup,
+ void * parserSetupArg,
+ int cursorOptions)
+
Description
+ SPI_prepare_params creates and returns a prepared
+ statement for the specified command, but doesn't execute the command.
+ This function is equivalent to SPI_prepare_cursor,
+ with the addition that the caller can specify parser hook functions
+ to control the parsing of external parameter references.
+
+ This function is now deprecated in favor
+ of SPI_prepare_extended.
+
Arguments
const char * command
+ command string
+
ParserSetupHook parserSetup
+ Parser hook setup function
+
void * parserSetupArg
+ pass-through argument for parserSetup
+
int cursorOptions
+ integer bit mask of cursor options; zero produces default behavior
+
Return Value
+ SPI_prepare_params has the same return conventions as
+ SPI_prepare.
+
SPI_prepare
SPI_prepare — prepare a statement, without executing it yet
Synopsis
+SPIPlanPtr SPI_prepare(const char * command, int nargs, Oid * argtypes)
+
Description
+ SPI_prepare creates and returns a prepared
+ statement for the specified command, but doesn't execute the command.
+ The prepared statement can later be executed repeatedly using
+ SPI_execute_plan.
+
+ When the same or a similar command is to be executed repeatedly, it
+ is generally advantageous to perform parse analysis only once, and
+ might furthermore be advantageous to re-use an execution plan for the
+ command.
+ SPI_prepare converts a command string into a
+ prepared statement that encapsulates the results of parse analysis.
+ The prepared statement also provides a place for caching an execution plan
+ if it is found that generating a custom plan for each execution is not
+ helpful.
+
+ A prepared command can be generalized by writing parameters
+ ($1, $2, etc.) in place of what would be
+ constants in a normal command. The actual values of the parameters
+ are then specified when SPI_execute_plan is called.
+ This allows the prepared command to be used over a wider range of
+ situations than would be possible without parameters.
+
+ The statement returned by SPI_prepare can be used
+ only in the current invocation of the C function, since
+ SPI_finish frees memory allocated for such a
+ statement. But the statement can be saved for longer using the functions
+ SPI_keepplan or SPI_saveplan.
+
Arguments
const char * command
+ command string
+
int nargs
+ number of input parameters ($1, $2, etc.)
+
Oid * argtypes
+ pointer to an array containing the OIDs of
+ the data types of the parameters
+
Return Value
+ SPI_prepare returns a non-null pointer to an
+ SPIPlan, which is an opaque struct representing a prepared
+ statement. On error, NULL will be returned,
+ and SPI_result will be set to one of the same
+ error codes used by SPI_execute, except that
+ it is set to SPI_ERROR_ARGUMENT if
+ command is NULL, or if
+ nargs is less than 0, or if nargs is
+ greater than 0 and argtypes is NULL.
+
Notes
+ If no parameters are defined, a generic plan will be created at the
+ first use of SPI_execute_plan, and used for all
+ subsequent executions as well. If there are parameters, the first few uses
+ of SPI_execute_plan will generate custom plans
+ that are specific to the supplied parameter values. After enough uses
+ of the same prepared statement, SPI_execute_plan will
+ build a generic plan, and if that is not too much more expensive than the
+ custom plans, it will start using the generic plan instead of re-planning
+ each time. If this default behavior is unsuitable, you can alter it by
+ passing the CURSOR_OPT_GENERIC_PLAN or
+ CURSOR_OPT_CUSTOM_PLAN flag to
+ SPI_prepare_cursor, to force use of generic or custom
+ plans respectively.
+
+ Although the main point of a prepared statement is to avoid repeated parse
+ analysis and planning of the statement, PostgreSQL will
+ force re-analysis and re-planning of the statement before using it
+ whenever database objects used in the statement have undergone
+ definitional (DDL) changes since the previous use of the prepared
+ statement. Also, if the value of search_path changes
+ from one use to the next, the statement will be re-parsed using the new
+ search_path. (This latter behavior is new as of
+ PostgreSQL 9.3.) See PREPARE for more information about the behavior of prepared
+ statements.
+
+ This function should only be called from a connected C function.
+
+ SPIPlanPtr is declared as a pointer to an opaque struct type in
+ spi.h. It is unwise to try to access its contents
+ directly, as that makes your code much more likely to break in
+ future revisions of PostgreSQL.
+
+ The name SPIPlanPtr is somewhat historical, since the data
+ structure no longer necessarily contains an execution plan.
+
SPI_register_relation
SPI_register_relation — make an ephemeral named relation available by name in SPI queries
Synopsis
+int SPI_register_relation(EphemeralNamedRelation enr)
+
Description
+ SPI_register_relation makes an ephemeral named
+ relation, with associated information, available to queries planned and
+ executed through the current SPI connection.
+
Arguments
EphemeralNamedRelation enr
+ the ephemeral named relation registry entry
+
Return Value
+ If the execution of the command was successful then the following
+ (nonnegative) value will be returned:
+
+
SPI_OK_REL_REGISTER
+ if the relation has been successfully registered by name
+
+
+ On error, one of the following negative values is returned:
+
+
SPI_ERROR_ARGUMENT
+ if enr is NULL or its
+ name field is NULL
+
SPI_ERROR_UNCONNECTED
+ if called from an unconnected C function
+
SPI_ERROR_REL_DUPLICATE
+ if the name specified in the name field of
+ enr is already registered for this connection
+
+
SPI_register_trigger_data
SPI_register_trigger_data — make ephemeral trigger data available in SPI queries
Synopsis
+int SPI_register_trigger_data(TriggerData *tdata)
+
Description
+ SPI_register_trigger_data makes any ephemeral
+ relations captured by a trigger available to queries planned and executed
+ through the current SPI connection. Currently, this means the transition
+ tables captured by an AFTER trigger defined with a
+ REFERENCING OLD/NEW TABLE AS ... clause. This function
+ should be called by a PL trigger handler function after connecting.
+
Arguments
TriggerData *tdata
+ the TriggerData object passed to a trigger
+ handler function as fcinfo->context
+
Return Value
+ If the execution of the command was successful then the following
+ (nonnegative) value will be returned:
+
+
SPI_OK_TD_REGISTER
+ if the captured trigger data (if any) has been successfully registered
+
+
+ On error, one of the following negative values is returned:
+
+
SPI_ERROR_ARGUMENT
+ if tdata is NULL
+
SPI_ERROR_UNCONNECTED
+ if called from an unconnected C function
+
SPI_ERROR_REL_DUPLICATE
+ if the name of any trigger data transient relation is already
+ registered for this connection
+
+
SPI_result_code_string
SPI_result_code_string — return error code as string
Synopsis
+const char * SPI_result_code_string(int code);
+
Description
+ SPI_result_code_string returns a string representation
+ of the result code returned by various SPI functions or stored
+ in SPI_result.
+
Return Value
+ A string representation of the result code.
+
SPI_returntuple
SPI_returntuple — prepare to return a tuple as a Datum
Synopsis
+HeapTupleHeader SPI_returntuple(HeapTuple row, TupleDesc rowdesc)
+
Description
+ SPI_returntuple makes a copy of a row in
+ the upper executor context, returning it in the form of a row type Datum.
+ The returned pointer need only be converted to Datum via PointerGetDatum
+ before returning.
+
+ This function can only be used while connected to SPI.
+ Otherwise, it returns NULL and sets SPI_result to
+ SPI_ERROR_UNCONNECTED.
+
+ Note that this should be used for functions that are declared to return
+ composite types. It is not used for triggers; use
+ SPI_copytuple for returning a modified row in a trigger.
+
Arguments
HeapTuple row
+ row to be copied
+
TupleDesc rowdesc
+ descriptor for row (pass the same descriptor each time for most
+ effective caching)
+
Return Value
+ HeapTupleHeader pointing to copied row,
+ or NULL on error
+ (see SPI_result for an error indication)
+
SPI_rollback
SPI_rollback, SPI_rollback_and_chain — abort the current transaction
Synopsis
+void SPI_rollback(void)
+
+void SPI_rollback_and_chain(void)
+
Description
+ SPI_rollback rolls back the current transaction. It
+ is approximately equivalent to running the SQL
+ command ROLLBACK. After the transaction is rolled back,
+ a new transaction is automatically started using default transaction
+ characteristics, so that the caller can continue using SPI facilities.
+
+ SPI_rollback_and_chain is the same, but the new
+ transaction is started with the same transaction
+ characteristics as the just finished one, like with the SQL command
+ ROLLBACK AND CHAIN.
+
+ These functions can only be executed if the SPI connection has been set as
+ nonatomic in the call to SPI_connect_ext.
+
SPI_saveplan
SPI_saveplan — save a prepared statement
Synopsis
+SPIPlanPtr SPI_saveplan(SPIPlanPtr plan)
+
Description
+ SPI_saveplan copies a passed statement (prepared by
+ SPI_prepare) into memory that will not be freed
+ by SPI_finish nor by the transaction manager,
+ and returns a pointer to the copied statement. This gives you the
+ ability to reuse prepared statements in the subsequent invocations of
+ your C function in the current session.
+
Arguments
SPIPlanPtr plan
+ the prepared statement to be saved
+
Return Value
+ Pointer to the copied statement; or NULL if unsuccessful.
+ On error, SPI_result is set thus:
+
+
SPI_ERROR_ARGUMENT
+ if plan is NULL or invalid
+
SPI_ERROR_UNCONNECTED
+ if called from an unconnected C function
+
+
Notes
+ The originally passed-in statement is not freed, so you might wish to do
+ SPI_freeplan on it to avoid leaking memory
+ until SPI_finish.
+
+ In most cases, SPI_keepplan is preferred to this
+ function, since it accomplishes largely the same result without needing
+ to physically copy the prepared statement's data structures.
+
SPI_scroll_cursor_fetch
SPI_scroll_cursor_fetch — fetch some rows from a cursor
Synopsis
+void SPI_scroll_cursor_fetch(Portal portal, FetchDirection direction,
+ long count)
+
Description
+ SPI_scroll_cursor_fetch fetches some rows from a
+ cursor. This is equivalent to the SQL command FETCH.
+
Arguments
Portal portal
+ portal containing the cursor
+
FetchDirection direction
+ one of FETCH_FORWARD,
+ FETCH_BACKWARD,
+ FETCH_ABSOLUTE or
+ FETCH_RELATIVE
+
long count
+ number of rows to fetch for
+ FETCH_FORWARD or
+ FETCH_BACKWARD; absolute row number to fetch for
+ FETCH_ABSOLUTE; or relative row number to fetch for
+ FETCH_RELATIVE
+
Return Value
+ SPI_processed and
+ SPI_tuptable are set as in
+ SPI_execute if successful.
+
Notes
+ See the SQL FETCH command
+ for details of the interpretation of the
+ direction and
+ count parameters.
+
+ Direction values other than FETCH_FORWARD
+ may fail if the cursor's plan was not created
+ with the CURSOR_OPT_SCROLL option.
+
SPI_scroll_cursor_move
SPI_scroll_cursor_move — move a cursor
Synopsis
+void SPI_scroll_cursor_move(Portal portal, FetchDirection direction,
+ long count)
+
Description
+ SPI_scroll_cursor_move skips over some number of rows
+ in a cursor. This is equivalent to the SQL command
+ MOVE.
+
Arguments
Portal portal
+ portal containing the cursor
+
FetchDirection direction
+ one of FETCH_FORWARD,
+ FETCH_BACKWARD,
+ FETCH_ABSOLUTE or
+ FETCH_RELATIVE
+
long count
+ number of rows to move for
+ FETCH_FORWARD or
+ FETCH_BACKWARD; absolute row number to move to for
+ FETCH_ABSOLUTE; or relative row number to move to for
+ FETCH_RELATIVE
+
Return Value
+ SPI_processed is set as in
+ SPI_execute if successful.
+ SPI_tuptable is set to NULL, since
+ no rows are returned by this function.
+
Notes
+ See the SQL FETCH command
+ for details of the interpretation of the
+ direction and
+ count parameters.
+
+ Direction values other than FETCH_FORWARD
+ may fail if the cursor's plan was not created
+ with the CURSOR_OPT_SCROLL option.
+
SPI_start_transaction
SPI_start_transaction — obsolete function
Synopsis
+void SPI_start_transaction(void)
+
Description
+ SPI_start_transaction does nothing, and exists
+ only for code compatibility with
+ earlier PostgreSQL releases. It used to
+ be required after calling SPI_commit
+ or SPI_rollback, but now those functions start
+ a new transaction automatically.
+
SPI_unregister_relation
SPI_unregister_relation — remove an ephemeral named relation from the registry
Synopsis
+int SPI_unregister_relation(const char * name)
+
Description
+ SPI_unregister_relation removes an ephemeral named
+ relation from the registry for the current connection.
+
Arguments
const char * name
+ the relation registry entry name
+
Return Value
+ If the execution of the command was successful then the following
+ (nonnegative) value will be returned:
+
+
SPI_OK_REL_UNREGISTER
+ if the tuplestore has been successfully removed from the registry
+
+
+ On error, one of the following negative values is returned:
+
+
SPI_ERROR_ARGUMENT
+ if name is NULL
+
SPI_ERROR_UNCONNECTED
+ if called from an unconnected C function
+
SPI_ERROR_REL_NOT_FOUND
+ if name is not found in the registry for the
+ current connection
+
+
47.4. Transaction Management #
+ It is not possible to run transaction control commands such
+ as COMMIT and ROLLBACK through SPI
+ functions such as SPI_execute. There are, however,
+ separate interface functions that allow transaction control through SPI.
+
+ It is not generally safe and sensible to start and end transactions in
+ arbitrary user-defined SQL-callable functions without taking into account
+ the context in which they are called. For example, a transaction boundary
+ in the middle of a function that is part of a complex SQL expression that
+ is part of some SQL command will probably result in obscure internal errors
+ or crashes. The interface functions presented here are primarily intended
+ to be used by procedural language implementations to support transaction
+ management in SQL-level procedures that are invoked by the CALL
+ command, taking the context of the CALL invocation into
+ account. SPI-using procedures implemented in C can implement the same logic, but
+ the details of that are beyond the scope of this documentation.
+
47.5. Visibility of Data Changes #
+ The following rules govern the visibility of data changes in
+ functions that use SPI (or any other C function):
+
+
+ During the execution of an SQL command, any data changes made by
+ the command are invisible to the command itself. For
+ example, in:
+
+INSERT INTO a SELECT * FROM a;
+
+ the inserted rows are invisible to the SELECT
+ part.
+
+ Changes made by a command C are visible to all commands that are
+ started after C, no matter whether they are started inside C
+ (during the execution of C) or after C is done.
+
+ Commands executed via SPI inside a function called by an SQL command
+ (either an ordinary function or a trigger) follow one or the
+ other of the above rules depending on the read/write flag passed
+ to SPI. Commands executed in read-only mode follow the first
+ rule: they cannot see changes of the calling command. Commands executed
+ in read-write mode follow the second rule: they can see all changes made
+ so far.
+
+ All standard procedural languages set the SPI read-write mode
+ depending on the volatility attribute of the function. Commands of
+ STABLE and IMMUTABLE functions are done in
+ read-only mode, while commands of VOLATILE functions are
+ done in read-write mode. While authors of C functions are able to
+ violate this convention, it's unlikely to be a good idea to do so.
+
+
+ The next section contains an example that illustrates the
+ application of these rules.
+
Chapter 47. Server Programming Interface
+ The Server Programming Interface
+ (SPI) gives writers of user-defined
+ C functions the ability to run
+ SQL commands inside their functions or procedures.
+ SPI is a set of
+ interface functions to simplify access to the parser, planner,
+ and executor. SPI also does some
+ memory management.
+
Note
+ The available procedural languages provide various means to
+ execute SQL commands from functions. Most of these facilities are
+ based on SPI, so this documentation might be of use for users
+ of those languages as well.
+
+ Note that if a command invoked via SPI fails, then control will not be
+ returned to your C function. Rather, the
+ transaction or subtransaction in which your C function executes will be
+ rolled back. (This might seem surprising given that the SPI functions mostly
+ have documented error-return conventions. Those conventions only apply
+ for errors detected within the SPI functions themselves, however.)
+ It is possible to recover control after an error by establishing your own
+ subtransaction surrounding SPI calls that might fail.
+
+ SPI functions return a nonnegative result on
+ success (either via a returned integer value or in the global
+ variable SPI_result, as described below). On
+ error, a negative result or NULL will be returned.
+
+ Source code files that use SPI must include the header file
+ executor/spi.h.
+
ABORT
ABORT — abort the current transaction
Synopsis
+ABORT [ WORK | TRANSACTION ] [ AND [ NO ] CHAIN ]
+
Description
+ ABORT rolls back the current transaction and causes
+ all the updates made by the transaction to be discarded.
+ This command is identical
+ in behavior to the standard SQL command
+ ROLLBACK,
+ and is present only for historical reasons.
+
Parameters
WORK
TRANSACTION
+ Optional key words. They have no effect.
+
AND CHAIN
+ If AND CHAIN is specified, a new transaction is
+ immediately started with the same transaction characteristics (see SET TRANSACTION) as the just finished one. Otherwise,
+ no new transaction is started.
+
Notes
+ Use COMMIT to
+ successfully terminate a transaction.
+
+ Issuing ABORT outside of a transaction block
+ emits a warning and otherwise has no effect.
+
Examples
+ To abort all changes:
+
+ABORT;
+
Compatibility
+ This command is a PostgreSQL extension
+ present for historical reasons. ROLLBACK is the
+ equivalent standard SQL command.
+
ALTER AGGREGATE
ALTER AGGREGATE — change the definition of an aggregate function
Synopsis
+ALTER AGGREGATE name ( aggregate_signature ) RENAME TO new_name
+ALTER AGGREGATE name ( aggregate_signature )
+ OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+ALTER AGGREGATE name ( aggregate_signature ) SET SCHEMA new_schema
+
+where aggregate_signature is:
+
+* |
+[ argmode ] [ argname ] argtype [ , ... ] |
+[ [ argmode ] [ argname ] argtype [ , ... ] ] ORDER BY [ argmode ] [ argname ] argtype [ , ... ]
+
Description
+ ALTER AGGREGATE changes the definition of an
+ aggregate function.
+
+ You must own the aggregate function to use ALTER AGGREGATE.
+ To change the schema of an aggregate function, you must also have
+ CREATE privilege on the new schema.
+ To alter the owner, you must be able to SET ROLE to the
+ new owning role, and that role must have CREATE
+ privilege on the aggregate function's schema.
+ (These restrictions enforce that altering
+ the owner doesn't do anything you couldn't do by dropping and recreating
+ the aggregate function. However, a superuser can alter ownership of any
+ aggregate function anyway.)
+
Parameters
name
+ The name (optionally schema-qualified) of an existing aggregate function.
+
argmode
+ The mode of an argument: IN or VARIADIC.
+ If omitted, the default is IN.
+
argname
+ The name of an argument.
+ Note that ALTER AGGREGATE does not actually pay
+ any attention to argument names, since only the argument data
+ types are needed to determine the aggregate function's identity.
+
argtype
+ An input data type on which the aggregate function operates.
+ To reference a zero-argument aggregate function, write *
+ in place of the list of argument specifications.
+ To reference an ordered-set aggregate function, write
+ ORDER BY between the direct and aggregated argument
+ specifications.
+
new_name
+ The new name of the aggregate function.
+
new_owner
+ The new owner of the aggregate function.
+
new_schema
+ The new schema for the aggregate function.
+
Notes
+ The recommended syntax for referencing an ordered-set aggregate
+ is to write ORDER BY between the direct and aggregated
+ argument specifications, in the same style as in
+ CREATE AGGREGATE. However, it will also work to
+ omit ORDER BY and just run the direct and aggregated
+ argument specifications into a single list. In this abbreviated form,
+ if VARIADIC "any" was used in both the direct and
+ aggregated argument lists, write VARIADIC "any" only once.
+
Examples
+ To rename the aggregate function myavg for type
+ integer to my_average:
+
+ALTER AGGREGATE myavg(integer) RENAME TO my_average;
+
+
+ To change the owner of the aggregate function myavg for type
+ integer to joe:
+
+ALTER AGGREGATE myavg(integer) OWNER TO joe;
+
+
+ To move the ordered-set aggregate mypercentile with
+ direct argument of type float8 and aggregated argument
+ of type integer into schema myschema:
+
+ALTER AGGREGATE mypercentile(float8 ORDER BY integer) SET SCHEMA myschema;
+
+ This will work too:
+
+ALTER AGGREGATE mypercentile(float8, integer) SET SCHEMA myschema;
+
Compatibility
+ There is no ALTER AGGREGATE statement in the SQL
+ standard.
+
ALTER COLLATION
ALTER COLLATION — change the definition of a collation
Synopsis
+ALTER COLLATION name REFRESH VERSION
+
+ALTER COLLATION name RENAME TO new_name
+ALTER COLLATION name OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+ALTER COLLATION name SET SCHEMA new_schema
+
Description
+ ALTER COLLATION changes the definition of a
+ collation.
+
+ You must own the collation to use ALTER COLLATION.
+ To alter the owner, you must be able to SET ROLE to the
+ new owning role, and that role must have CREATE
+ privilege on the collation's schema.
+ (These restrictions enforce that altering the
+ owner doesn't do anything you couldn't do by dropping and recreating the
+ collation. However, a superuser can alter ownership of any collation
+ anyway.)
+
Parameters
name
+ The name (optionally schema-qualified) of an existing collation.
+
new_name
+ The new name of the collation.
+
new_owner
+ The new owner of the collation.
+
new_schema
+ The new schema for the collation.
+
REFRESH VERSION
+ Update the collation's version.
+ See Notes below.
+
Notes
+ When a collation object is created, the provider-specific version of the
+ collation is recorded in the system catalog. When the collation is used,
+ the current version is
+ checked against the recorded version, and a warning is issued when there is
+ a mismatch, for example:
+
+WARNING: collation "xx-x-icu" has version mismatch
+DETAIL: The collation in the database was created using version 1.2.3.4, but the operating system provides version 2.3.4.5.
+HINT: Rebuild all objects affected by this collation and run ALTER COLLATION pg_catalog."xx-x-icu" REFRESH VERSION, or build PostgreSQL with the right library version.
+
+ A change in collation definitions can lead to corrupt indexes and other
+ problems because the database system relies on stored objects having a
+ certain sort order. Generally, this should be avoided, but it can happen
+ in legitimate circumstances, such as when upgrading the operating system
+ to a new major version or when
+ using pg_upgrade to upgrade to server binaries linked
+ with a newer version of ICU. When this happens, all objects depending on
+ the collation should be rebuilt, for example,
+ using REINDEX. When that is done, the collation version
+ can be refreshed using the command ALTER COLLATION ... REFRESH
+ VERSION. This will update the system catalog to record the
+ current collation version and will make the warning go away. Note that this
+ does not actually check whether all affected objects have been rebuilt
+ correctly.
+
+ When using collations provided by libc, version
+ information is recorded on systems using the GNU C library (most Linux
+ systems), FreeBSD and Windows. When using collations provided by ICU, the
+ version information is provided by the ICU library and is available on all
+ platforms.
+
Note
+ When using the GNU C library for collations, the C library's version
+ is used as a proxy for the collation version. Many Linux distributions
+ change collation definitions only when upgrading the C library, but this
+ approach is imperfect as maintainers are free to back-port newer
+ collation definitions to older C library releases.
+
+ When using Windows for collations, version information is only available
+ for collations defined with BCP 47 language tags such as
+ en-US.
+
+ For the database default collation, there is an analogous command
+ ALTER DATABASE ... REFRESH COLLATION VERSION.
+
+ The following query can be used to identify all collations in the current
+ database that need to be refreshed and the objects that depend on them:
+
+SELECT pg_describe_object(refclassid, refobjid, refobjsubid) AS "Collation",
+ pg_describe_object(classid, objid, objsubid) AS "Object"
+ FROM pg_depend d JOIN pg_collation c
+ ON refclassid = 'pg_collation'::regclass AND refobjid = c.oid
+ WHERE c.collversion <> pg_collation_actual_version(c.oid)
+ ORDER BY 1, 2;
+
Examples
+ To rename the collation de_DE to
+ german:
+
+ALTER COLLATION "de_DE" RENAME TO german;
+
+
+ To change the owner of the collation en_US to
+ joe:
+
+ALTER COLLATION "en_US" OWNER TO joe;
+
Compatibility
+ There is no ALTER COLLATION statement in the SQL
+ standard.
+
ALTER CONVERSION
ALTER CONVERSION — change the definition of a conversion
Synopsis
+ALTER CONVERSION name RENAME TO new_name
+ALTER CONVERSION name OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+ALTER CONVERSION name SET SCHEMA new_schema
+
Description
+ ALTER CONVERSION changes the definition of a
+ conversion.
+
+ You must own the conversion to use ALTER CONVERSION.
+ To alter the owner, you must be able to SET ROLE to the
+ new owning role, and that role must have CREATE
+ privilege on the conversion's schema.
+ (These restrictions enforce that altering the
+ owner doesn't do anything you couldn't do by dropping and recreating the
+ conversion. However, a superuser can alter ownership of any conversion
+ anyway.)
+
Parameters
name
+ The name (optionally schema-qualified) of an existing conversion.
+
new_name
+ The new name of the conversion.
+
new_owner
+ The new owner of the conversion.
+
new_schema
+ The new schema for the conversion.
+
Examples
+ To rename the conversion iso_8859_1_to_utf8 to
+ latin1_to_unicode:
+
+ALTER CONVERSION iso_8859_1_to_utf8 RENAME TO latin1_to_unicode;
+
+
+ To change the owner of the conversion iso_8859_1_to_utf8 to
+ joe:
+
+ALTER CONVERSION iso_8859_1_to_utf8 OWNER TO joe;
+
Compatibility
+ There is no ALTER CONVERSION statement in the SQL
+ standard.
+
ALTER DATABASE
ALTER DATABASE — change a database
Synopsis
+ALTER DATABASE name [ [ WITH ] option [ ... ] ]
+
+where option can be:
+
+ ALLOW_CONNECTIONS allowconn
+ CONNECTION LIMIT connlimit
+ IS_TEMPLATE istemplate
+
+ALTER DATABASE name RENAME TO new_name
+
+ALTER DATABASE name OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+
+ALTER DATABASE name SET TABLESPACE new_tablespace
+
+ALTER DATABASE name REFRESH COLLATION VERSION
+
+ALTER DATABASE name SET configuration_parameter { TO | = } { value | DEFAULT }
+ALTER DATABASE name SET configuration_parameter FROM CURRENT
+ALTER DATABASE name RESET configuration_parameter
+ALTER DATABASE name RESET ALL
+
Description
+ ALTER DATABASE changes the attributes
+ of a database.
+
+ The first form changes certain per-database settings. (See below for
+ details.) Only the database owner or a superuser can change these settings.
+
+ The second form changes the name of the database. Only the database
+ owner or a superuser can rename a database; non-superuser owners must
+ also have the
+ CREATEDB privilege. The current database cannot
+ be renamed. (Connect to a different database if you need to do
+ that.)
+
+ The third form changes the owner of the database.
+ To alter the owner, you must be able to SET ROLE to the
+ new owning role, and you must have the
+ CREATEDB privilege.
+ (Note that superusers have all these privileges automatically.)
+
+ The fourth form changes the default tablespace of the database.
+ Only the database owner or a superuser can do this; you must also have
+ create privilege for the new tablespace.
+ This command physically moves any tables or indexes in the database's old
+ default tablespace to the new tablespace. The new default tablespace
+ must be empty for this database, and no one can be connected to
+ the database. Tables and indexes in non-default tablespaces are
+ unaffected.
+
+ The remaining forms change the session default for a run-time
+ configuration variable for a PostgreSQL
+ database. Whenever a new session is subsequently started in that
+ database, the specified value becomes the session default value.
+ The database-specific default overrides whatever setting is present
+ in postgresql.conf or has been received from the
+ postgres command line. Only the database
+ owner or a superuser can change the session defaults for a
+ database. Certain variables cannot be set this way, or can only be
+ set by a superuser.
+
Parameters
name
+ The name of the database whose attributes are to be altered.
+
allowconn
+ If false then no one can connect to this database.
+
connlimit
+ How many concurrent connections can be made
+ to this database. -1 means no limit.
+
istemplate
+ If true, then this database can be cloned by any user with CREATEDB
+ privileges; if false, then only superusers or the owner of the
+ database can clone it.
+
new_name
+ The new name of the database.
+
new_owner
+ The new owner of the database.
+
new_tablespace
+ The new default tablespace of the database.
+
+ This form of the command cannot be executed inside a transaction block.
+
REFRESH COLLATION VERSION
+ Update the database collation version. See Notes for background.
+
configuration_parameter
value
+ Set this database's session default for the specified configuration
+ parameter to the given value. If
+ value is DEFAULT
+ or, equivalently, RESET is used, the
+ database-specific setting is removed, so the system-wide default
+ setting will be inherited in new sessions. Use RESET
+ ALL to clear all database-specific settings.
+ SET FROM CURRENT saves the session's current value of
+ the parameter as the database-specific value.
+
+ See SET and Chapter 20
+ for more information about allowed parameter names
+ and values.
+
Notes
+ It is also possible to tie a session default to a specific role
+ rather than to a database; see
+ ALTER ROLE.
+ Role-specific settings override database-specific
+ ones if there is a conflict.
+
Examples
+ To disable index scans by default in the database
+ test:
+
+
+ALTER DATABASE test SET enable_indexscan TO off;
+
Compatibility
+ The ALTER DATABASE statement is a
+ PostgreSQL extension.
+
ALTER DEFAULT PRIVILEGES
ALTER DEFAULT PRIVILEGES — define default access privileges
Synopsis
+ALTER DEFAULT PRIVILEGES
+ [ FOR { ROLE | USER } target_role [, ...] ]
+ [ IN SCHEMA schema_name [, ...] ]
+ abbreviated_grant_or_revoke
+
+where abbreviated_grant_or_revoke is one of:
+
+GRANT { { SELECT | INSERT | UPDATE | DELETE | TRUNCATE | REFERENCES | TRIGGER }
+ [, ...] | ALL [ PRIVILEGES ] }
+ ON TABLES
+ TO { [ GROUP ] role_name | PUBLIC } [, ...] [ WITH GRANT OPTION ]
+
+GRANT { { USAGE | SELECT | UPDATE }
+ [, ...] | ALL [ PRIVILEGES ] }
+ ON SEQUENCES
+ TO { [ GROUP ] role_name | PUBLIC } [, ...] [ WITH GRANT OPTION ]
+
+GRANT { EXECUTE | ALL [ PRIVILEGES ] }
+ ON { FUNCTIONS | ROUTINES }
+ TO { [ GROUP ] role_name | PUBLIC } [, ...] [ WITH GRANT OPTION ]
+
+GRANT { USAGE | ALL [ PRIVILEGES ] }
+ ON TYPES
+ TO { [ GROUP ] role_name | PUBLIC } [, ...] [ WITH GRANT OPTION ]
+
+GRANT { { USAGE | CREATE }
+ [, ...] | ALL [ PRIVILEGES ] }
+ ON SCHEMAS
+ TO { [ GROUP ] role_name | PUBLIC } [, ...] [ WITH GRANT OPTION ]
+
+REVOKE [ GRANT OPTION FOR ]
+ { { SELECT | INSERT | UPDATE | DELETE | TRUNCATE | REFERENCES | TRIGGER }
+ [, ...] | ALL [ PRIVILEGES ] }
+ ON TABLES
+ FROM { [ GROUP ] role_name | PUBLIC } [, ...]
+ [ CASCADE | RESTRICT ]
+
+REVOKE [ GRANT OPTION FOR ]
+ { { USAGE | SELECT | UPDATE }
+ [, ...] | ALL [ PRIVILEGES ] }
+ ON SEQUENCES
+ FROM { [ GROUP ] role_name | PUBLIC } [, ...]
+ [ CASCADE | RESTRICT ]
+
+REVOKE [ GRANT OPTION FOR ]
+ { EXECUTE | ALL [ PRIVILEGES ] }
+ ON { FUNCTIONS | ROUTINES }
+ FROM { [ GROUP ] role_name | PUBLIC } [, ...]
+ [ CASCADE | RESTRICT ]
+
+REVOKE [ GRANT OPTION FOR ]
+ { USAGE | ALL [ PRIVILEGES ] }
+ ON TYPES
+ FROM { [ GROUP ] role_name | PUBLIC } [, ...]
+ [ CASCADE | RESTRICT ]
+
+REVOKE [ GRANT OPTION FOR ]
+ { { USAGE | CREATE }
+ [, ...] | ALL [ PRIVILEGES ] }
+ ON SCHEMAS
+ FROM { [ GROUP ] role_name | PUBLIC } [, ...]
+ [ CASCADE | RESTRICT ]
+Description
+ ALTER DEFAULT PRIVILEGES allows you to set the
+ privileges that will be applied to objects created in the future.
+ (It does not affect privileges assigned to already-existing objects.)
+ Privileges can be set globally (i.e., for all objects created in the
+ current database), or just for objects created in specified schemas.
+
+ While you can change your own default privileges and the defaults of
+ roles that you are a member of, at object creation time, new object
+ permissions are only affected by the default privileges of the current
+ role, and are not inherited from any roles in which the current role
+ is a member.
+
+ As explained in Section 5.7,
+ the default privileges for any object type normally grant all grantable
+ permissions to the object owner, and may grant some privileges to
+ PUBLIC as well. However, this behavior can be changed by
+ altering the global default privileges with
+ ALTER DEFAULT PRIVILEGES.
+
+ Currently,
+ only the privileges for schemas, tables (including views and foreign
+ tables), sequences, functions, and types (including domains) can be
+ altered. For this command, functions include aggregates and procedures.
+ The words FUNCTIONS and ROUTINES are
+ equivalent in this command. (ROUTINES is preferred
+ going forward as the standard term for functions and procedures taken
+ together. In earlier PostgreSQL releases, only the
+ word FUNCTIONS was allowed. It is not possible to set
+ default privileges for functions and procedures separately.)
+
+ Default privileges that are specified per-schema are added to whatever
+ the global default privileges are for the particular object type.
+ This means you cannot revoke privileges per-schema if they are granted
+ globally (either by default, or according to a previous ALTER
+ DEFAULT PRIVILEGES command that did not specify a schema).
+ Per-schema REVOKE is only useful to reverse the
+ effects of a previous per-schema GRANT.
+
Parameters
target_role
+ Change default privileges for objects created by the
+ target_role, or the current
+ role if unspecified.
+
schema_name
+ The name of an existing schema. If specified, the default privileges
+ are altered for objects later created in that schema.
+ If IN SCHEMA is omitted, the global default privileges
+ are altered.
+ IN SCHEMA is not allowed when setting privileges
+ for schemas, since schemas can't be nested.
+
role_name
+ The name of an existing role to grant or revoke privileges for.
+ This parameter, and all the other parameters in
+ abbreviated_grant_or_revoke,
+ act as described under
+ GRANT or
+ REVOKE,
+ except that one is setting permissions for a whole class of objects
+ rather than specific named objects.
+
Notes
+ Use psql's \ddp command
+ to obtain information about existing assignments of default privileges.
+ The meaning of the privilege display is the same as explained for
+ \dp in Section 5.7.
+
+ If you wish to drop a role for which the default privileges have been
+ altered, it is necessary to reverse the changes in its default privileges
+ or use DROP OWNED BY to get rid of the default privileges entry
+ for the role.
+
Examples
+ Grant SELECT privilege to everyone for all tables (and views) you
+ subsequently create in schema myschema, and allow
+ role webuser to INSERT into them too:
+
+
+ALTER DEFAULT PRIVILEGES IN SCHEMA myschema GRANT SELECT ON TABLES TO PUBLIC;
+ALTER DEFAULT PRIVILEGES IN SCHEMA myschema GRANT INSERT ON TABLES TO webuser;
+
+
+ Undo the above, so that subsequently-created tables won't have any
+ more permissions than normal:
+
+
+ALTER DEFAULT PRIVILEGES IN SCHEMA myschema REVOKE SELECT ON TABLES FROM PUBLIC;
+ALTER DEFAULT PRIVILEGES IN SCHEMA myschema REVOKE INSERT ON TABLES FROM webuser;
+
+
+ Remove the public EXECUTE permission that is normally granted on functions,
+ for all functions subsequently created by role admin:
+
+ALTER DEFAULT PRIVILEGES FOR ROLE admin REVOKE EXECUTE ON FUNCTIONS FROM PUBLIC;
+
+ Note however that you cannot accomplish that effect
+ with a command limited to a single schema. This command has no effect,
+ unless it is undoing a matching GRANT:
+
+ALTER DEFAULT PRIVILEGES IN SCHEMA public REVOKE EXECUTE ON FUNCTIONS FROM PUBLIC;
+
+ That's because per-schema default privileges can only add privileges to
+ the global setting, not remove privileges granted by it.
+
Compatibility
+ There is no ALTER DEFAULT PRIVILEGES statement in the SQL
+ standard.
+
ALTER DOMAIN
ALTER DOMAIN —
+ change the definition of a domain
+
Synopsis
+ALTER DOMAIN name
+ { SET DEFAULT expression | DROP DEFAULT }
+ALTER DOMAIN name
+ { SET | DROP } NOT NULL
+ALTER DOMAIN name
+ ADD domain_constraint [ NOT VALID ]
+ALTER DOMAIN name
+ DROP CONSTRAINT [ IF EXISTS ] constraint_name [ RESTRICT | CASCADE ]
+ALTER DOMAIN name
+ RENAME CONSTRAINT constraint_name TO new_constraint_name
+ALTER DOMAIN name
+ VALIDATE CONSTRAINT constraint_name
+ALTER DOMAIN name
+ OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+ALTER DOMAIN name
+ RENAME TO new_name
+ALTER DOMAIN name
+ SET SCHEMA new_schema
+
Description
+ ALTER DOMAIN changes the definition of an existing domain.
+ There are several sub-forms:
+
SET/DROP DEFAULT
+ These forms set or remove the default value for a domain. Note
+ that defaults only apply to subsequent INSERT
+ commands; they do not affect rows already in a table using the domain.
+
SET/DROP NOT NULL
+ These forms change whether a domain is marked to allow NULL
+ values or to reject NULL values. You can only SET NOT NULL
+ when the columns using the domain contain no null values.
+
ADD domain_constraint [ NOT VALID ]
+ This form adds a new constraint to a domain using the same syntax as
+ CREATE DOMAIN.
+ When a new constraint is added to a domain, all columns using that
+ domain will be checked against the newly added constraint. These
+ checks can be suppressed by adding the new constraint using the
+ NOT VALID option; the constraint can later be made
+ valid using ALTER DOMAIN ... VALIDATE CONSTRAINT.
+ Newly inserted or updated rows are always checked against all
+ constraints, even those marked NOT VALID.
+ NOT VALID is only accepted for CHECK constraints.
+
DROP CONSTRAINT [ IF EXISTS ]
+ This form drops constraints on a domain.
+ If IF EXISTS is specified and the constraint
+ does not exist, no error is thrown. In this case a notice is issued instead.
+
RENAME CONSTRAINT
+ This form changes the name of a constraint on a domain.
+
VALIDATE CONSTRAINT
+ This form validates a constraint previously added as
+ NOT VALID, that is, it verifies that all values in
+ table columns of the domain type satisfy the specified constraint.
+
OWNER
+ This form changes the owner of the domain to the specified user.
+
RENAME
+ This form changes the name of the domain.
+
SET SCHEMA
+ This form changes the schema of the domain. Any constraints
+ associated with the domain are moved into the new schema as well.
+
+ You must own the domain to use ALTER DOMAIN.
+ To change the schema of a domain, you must also have
+ CREATE privilege on the new schema.
+ To alter the owner, you must be able to SET ROLE to the
+ new owning role, and that role must have CREATE privilege
+ on the domain's schema. (These restrictions enforce that altering the owner
+ doesn't do anything you couldn't do by dropping and recreating the domain.
+ However, a superuser can alter ownership of any domain anyway.)
+
Parameters
+
name
+ The name (possibly schema-qualified) of an existing domain to
+ alter.
+
domain_constraint
+ New domain constraint for the domain.
+
constraint_name
+ Name of an existing constraint to drop or rename.
+
NOT VALID
+ Do not verify existing stored data for constraint validity.
+
CASCADE
+ Automatically drop objects that depend on the constraint,
+ and in turn all objects that depend on those objects
+ (see Section 5.14).
+
RESTRICT
+ Refuse to drop the constraint if there are any dependent
+ objects. This is the default behavior.
+
new_name
+ The new name for the domain.
+
new_constraint_name
+ The new name for the constraint.
+
new_owner
+ The user name of the new owner of the domain.
+
new_schema
+ The new schema for the domain.
+
+
Notes
+ Although ALTER DOMAIN ADD CONSTRAINT attempts to verify
+ that existing stored data satisfies the new constraint, this check is not
+ bulletproof, because the command cannot “see” table rows that
+ are newly inserted or updated and not yet committed. If there is a hazard
+ that concurrent operations might insert bad data, the way to proceed is to
+ add the constraint using the NOT VALID option, commit
+ that command, wait until all transactions started before that commit have
+ finished, and then issue ALTER DOMAIN VALIDATE
+ CONSTRAINT to search for data violating the constraint. This
+ method is reliable because once the constraint is committed, all new
+ transactions are guaranteed to enforce it against new values of the domain
+ type.
+
+ Currently, ALTER DOMAIN ADD CONSTRAINT, ALTER
+ DOMAIN VALIDATE CONSTRAINT, and ALTER DOMAIN SET NOT
+ NULL will fail if the named domain or any derived domain is used
+ within a container-type column (a composite, array, or range column) in
+ any table in the database. They should eventually be improved to be able
+ to verify the new constraint for such nested values.
+
Examples
+ To add a NOT NULL constraint to a domain:
+
+ALTER DOMAIN zipcode SET NOT NULL;
+
+ To remove a NOT NULL constraint from a domain:
+
+ALTER DOMAIN zipcode DROP NOT NULL;
+
+
+ To add a check constraint to a domain:
+
+ALTER DOMAIN zipcode ADD CONSTRAINT zipchk CHECK (char_length(VALUE) = 5);
+
+
+ To remove a check constraint from a domain:
+
+ALTER DOMAIN zipcode DROP CONSTRAINT zipchk;
+
+
+ To rename a check constraint on a domain:
+
+ALTER DOMAIN zipcode RENAME CONSTRAINT zipchk TO zip_check;
+
+
+ To move the domain into a different schema:
+
+ALTER DOMAIN zipcode SET SCHEMA customers;
+
Compatibility
+ ALTER DOMAIN conforms to the SQL
+ standard, except for the OWNER, RENAME, SET SCHEMA, and
+ VALIDATE CONSTRAINT variants, which are
+ PostgreSQL extensions. The NOT VALID
+ clause of the ADD CONSTRAINT variant is also a
+ PostgreSQL extension.
+
ALTER EVENT TRIGGER
ALTER EVENT TRIGGER — change the definition of an event trigger
Synopsis
+ALTER EVENT TRIGGER name DISABLE
+ALTER EVENT TRIGGER name ENABLE [ REPLICA | ALWAYS ]
+ALTER EVENT TRIGGER name OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+ALTER EVENT TRIGGER name RENAME TO new_name
+
Description
+ ALTER EVENT TRIGGER changes properties of an
+ existing event trigger.
+
+ You must be superuser to alter an event trigger.
+
Parameters
name
+ The name of an existing trigger to alter.
+
new_owner
+ The user name of the new owner of the event trigger.
+
new_name
+ The new name of the event trigger.
+
DISABLE/ENABLE [ REPLICA | ALWAYS ]
+ These forms configure the firing of event triggers. A disabled trigger
+ is still known to the system, but is not executed when its triggering
+ event occurs. See also session_replication_role.
+
Compatibility
+ There is no ALTER EVENT TRIGGER statement in the
+ SQL standard.
+
ALTER EXTENSION
ALTER EXTENSION —
+ change the definition of an extension
+
Synopsis
+ALTER EXTENSION name UPDATE [ TO new_version ]
+ALTER EXTENSION name SET SCHEMA new_schema
+ALTER EXTENSION name ADD member_object
+ALTER EXTENSION name DROP member_object
+
+where member_object is:
+
+ ACCESS METHOD object_name |
+ AGGREGATE aggregate_name ( aggregate_signature ) |
+ CAST (source_type AS target_type) |
+ COLLATION object_name |
+ CONVERSION object_name |
+ DOMAIN object_name |
+ EVENT TRIGGER object_name |
+ FOREIGN DATA WRAPPER object_name |
+ FOREIGN TABLE object_name |
+ FUNCTION function_name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ] |
+ MATERIALIZED VIEW object_name |
+ OPERATOR operator_name (left_type, right_type) |
+ OPERATOR CLASS object_name USING index_method |
+ OPERATOR FAMILY object_name USING index_method |
+ [ PROCEDURAL ] LANGUAGE object_name |
+ PROCEDURE procedure_name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ] |
+ ROUTINE routine_name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ] |
+ SCHEMA object_name |
+ SEQUENCE object_name |
+ SERVER object_name |
+ TABLE object_name |
+ TEXT SEARCH CONFIGURATION object_name |
+ TEXT SEARCH DICTIONARY object_name |
+ TEXT SEARCH PARSER object_name |
+ TEXT SEARCH TEMPLATE object_name |
+ TRANSFORM FOR type_name LANGUAGE lang_name |
+ TYPE object_name |
+ VIEW object_name
+
+and aggregate_signature is:
+
+* |
+[ argmode ] [ argname ] argtype [ , ... ] |
+[ [ argmode ] [ argname ] argtype [ , ... ] ] ORDER BY [ argmode ] [ argname ] argtype [ , ... ]
+
Description
+ ALTER EXTENSION changes the definition of an installed
+ extension. There are several subforms:
+
+
UPDATE
+ This form updates the extension to a newer version. The extension
+ must supply a suitable update script (or series of scripts) that can
+ modify the currently-installed version into the requested version.
+
SET SCHEMA
+ This form moves the extension's objects into another schema. The
+ extension has to be relocatable for this command to
+ succeed.
+
ADD member_object
+ This form adds an existing object to the extension. This is mainly
+ useful in extension update scripts. The object will subsequently
+ be treated as a member of the extension; notably, it can only be
+ dropped by dropping the extension.
+
DROP member_object
+ This form removes a member object from the extension. This is mainly
+ useful in extension update scripts. The object is not dropped, only
+ disassociated from the extension.
+
+
+ See Section 38.17 for more information about these
+ operations.
+
+ You must own the extension to use ALTER EXTENSION.
+ The ADD/DROP forms require ownership of the
+ added/dropped object as well.
+
Parameters
+
name
+ The name of an installed extension.
+
new_version
+ The desired new version of the extension. This can be written as
+ either an identifier or a string literal. If not specified,
+ ALTER EXTENSION UPDATE attempts to update to whatever is
+ shown as the default version in the extension's control file.
+
new_schema
+ The new schema for the extension.
+
object_name
aggregate_name
function_name
operator_name
procedure_name
routine_name
+ The name of an object to be added to or removed from the extension.
+ Names of tables,
+ aggregates, domains, foreign tables, functions, operators,
+ operator classes, operator families, procedures, routines, sequences, text search objects,
+ types, and views can be schema-qualified.
+
source_type
+ The name of the source data type of the cast.
+
target_type
+ The name of the target data type of the cast.
+
argmode
+ The mode of a function, procedure, or aggregate
+ argument: IN, OUT,
+ INOUT, or VARIADIC.
+ If omitted, the default is IN.
+ Note that ALTER EXTENSION does not actually pay
+ any attention to OUT arguments, since only the input
+ arguments are needed to determine the function's identity.
+ So it is sufficient to list the IN, INOUT,
+ and VARIADIC arguments.
+
argname
+ The name of a function, procedure, or aggregate argument.
+ Note that ALTER EXTENSION does not actually pay
+ any attention to argument names, since only the argument data
+ types are needed to determine the function's identity.
+
argtype
+ The data type of a function, procedure, or aggregate argument.
+
left_type
right_type
+ The data type(s) of the operator's arguments (optionally
+ schema-qualified). Write NONE for the missing argument
+ of a prefix operator.
+
PROCEDURAL
+ This is a noise word.
+
type_name
+ The name of the data type of the transform.
+
lang_name
+ The name of the language of the transform.
+
+
Examples
+ To update the hstore extension to version 2.0:
+
+ALTER EXTENSION hstore UPDATE TO '2.0';
+
+
+ To change the schema of the hstore extension
+ to utils:
+
+ALTER EXTENSION hstore SET SCHEMA utils;
+
+
+ To add an existing function to the hstore extension:
+
+ALTER EXTENSION hstore ADD FUNCTION populate_record(anyelement, hstore);
+
Compatibility
+ ALTER EXTENSION is a PostgreSQL
+ extension.
+
ALTER FOREIGN DATA WRAPPER
ALTER FOREIGN DATA WRAPPER — change the definition of a foreign-data wrapper
Synopsis
+ALTER FOREIGN DATA WRAPPER name
+ [ HANDLER handler_function | NO HANDLER ]
+ [ VALIDATOR validator_function | NO VALIDATOR ]
+ [ OPTIONS ( [ ADD | SET | DROP ] option ['value'] [, ... ]) ]
+ALTER FOREIGN DATA WRAPPER name OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+ALTER FOREIGN DATA WRAPPER name RENAME TO new_name
+
Description
+ ALTER FOREIGN DATA WRAPPER changes the
+ definition of a foreign-data wrapper. The first form of the
+ command changes the support functions or the generic options of the
+ foreign-data wrapper (at least one clause is required). The second
+ form changes the owner of the foreign-data wrapper.
+
+ Only superusers can alter foreign-data wrappers. Additionally,
+ only superusers can own foreign-data wrappers.
+
Parameters
name
+ The name of an existing foreign-data wrapper.
+
HANDLER handler_function
+ Specifies a new handler function for the foreign-data wrapper.
+
NO HANDLER
+ This is used to specify that the foreign-data wrapper should no
+ longer have a handler function.
+
+ Note that foreign tables that use a foreign-data wrapper with no
+ handler cannot be accessed.
+
VALIDATOR validator_function
+ Specifies a new validator function for the foreign-data wrapper.
+
+ Note that it is possible that pre-existing options of the foreign-data
+ wrapper, or of dependent servers, user mappings, or foreign tables, are
+ invalid according to the new validator. PostgreSQL does
+ not check for this. It is up to the user to make sure that these
+ options are correct before using the modified foreign-data wrapper.
+ However, any options specified in this ALTER FOREIGN DATA
+ WRAPPER command will be checked using the new validator.
+
NO VALIDATOR
+ This is used to specify that the foreign-data wrapper should no
+ longer have a validator function.
+
OPTIONS ( [ ADD | SET | DROP ] option ['value'] [, ... ] )
+ Change options for the foreign-data
+ wrapper. ADD, SET, and DROP
+ specify the action to be performed. ADD is assumed
+ if no operation is explicitly specified. Option names must be
+ unique; names and values are also validated using the foreign
+ data wrapper's validator function, if any.
+
new_owner
+ The user name of the new owner of the foreign-data wrapper.
+
new_name
+ The new name for the foreign-data wrapper.
+
Examples
+ Change a foreign-data wrapper dbi, add
+ option foo, drop bar:
+
+ALTER FOREIGN DATA WRAPPER dbi OPTIONS (ADD foo '1', DROP bar);
+
+
+ Change the foreign-data wrapper dbi validator
+ to bob.myvalidator:
+
+ALTER FOREIGN DATA WRAPPER dbi VALIDATOR bob.myvalidator;
+
Compatibility
+ ALTER FOREIGN DATA WRAPPER conforms to ISO/IEC
+ 9075-9 (SQL/MED), except that the HANDLER,
+ VALIDATOR, OWNER TO, and RENAME
+ clauses are extensions.
+
ALTER FOREIGN TABLE
ALTER FOREIGN TABLE — change the definition of a foreign table
Synopsis
+ALTER FOREIGN TABLE [ IF EXISTS ] [ ONLY ] name [ * ]
+ action [, ... ]
+ALTER FOREIGN TABLE [ IF EXISTS ] [ ONLY ] name [ * ]
+ RENAME [ COLUMN ] column_name TO new_column_name
+ALTER FOREIGN TABLE [ IF EXISTS ] name
+ RENAME TO new_name
+ALTER FOREIGN TABLE [ IF EXISTS ] name
+ SET SCHEMA new_schema
+
+where action is one of:
+
+ ADD [ COLUMN ] column_name data_type [ COLLATE collation ] [ column_constraint [ ... ] ]
+ DROP [ COLUMN ] [ IF EXISTS ] column_name [ RESTRICT | CASCADE ]
+ ALTER [ COLUMN ] column_name [ SET DATA ] TYPE data_type [ COLLATE collation ]
+ ALTER [ COLUMN ] column_name SET DEFAULT expression
+ ALTER [ COLUMN ] column_name DROP DEFAULT
+ ALTER [ COLUMN ] column_name { SET | DROP } NOT NULL
+ ALTER [ COLUMN ] column_name SET STATISTICS integer
+ ALTER [ COLUMN ] column_name SET ( attribute_option = value [, ... ] )
+ ALTER [ COLUMN ] column_name RESET ( attribute_option [, ... ] )
+ ALTER [ COLUMN ] column_name SET STORAGE { PLAIN | EXTERNAL | EXTENDED | MAIN | DEFAULT }
+ ALTER [ COLUMN ] column_name OPTIONS ( [ ADD | SET | DROP ] option ['value'] [, ... ])
+ ADD table_constraint [ NOT VALID ]
+ VALIDATE CONSTRAINT constraint_name
+ DROP CONSTRAINT [ IF EXISTS ] constraint_name [ RESTRICT | CASCADE ]
+ DISABLE TRIGGER [ trigger_name | ALL | USER ]
+ ENABLE TRIGGER [ trigger_name | ALL | USER ]
+ ENABLE REPLICA TRIGGER trigger_name
+ ENABLE ALWAYS TRIGGER trigger_name
+ SET WITHOUT OIDS
+ INHERIT parent_table
+ NO INHERIT parent_table
+ OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+ OPTIONS ( [ ADD | SET | DROP ] option ['value'] [, ... ])
+
Description
+ ALTER FOREIGN TABLE changes the definition of an
+ existing foreign table. There are several subforms:
+
+
ADD COLUMN
+ This form adds a new column to the foreign table, using the same syntax as
+ CREATE FOREIGN TABLE.
+ Unlike the case when adding a column to a regular table, nothing happens
+ to the underlying storage: this action simply declares that
+ some new column is now accessible through the foreign table.
+
DROP COLUMN [ IF EXISTS ]
+ This form drops a column from a foreign table.
+ You will need to say CASCADE if
+ anything outside the table depends on the column; for example,
+ views.
+ If IF EXISTS is specified and the column
+ does not exist, no error is thrown. In this case a notice
+ is issued instead.
+
SET DATA TYPE
+ This form changes the type of a column of a foreign table.
+ Again, this has no effect on any underlying storage: this action simply
+ changes the type that PostgreSQL believes the column to
+ have.
+
SET/DROP DEFAULT
+ These forms set or remove the default value for a column.
+ Default values only apply in subsequent INSERT
+ or UPDATE commands; they do not cause rows already in the
+ table to change.
+
SET/DROP NOT NULL
+ Mark a column as allowing, or not allowing, null values.
+
SET STATISTICS
+ This form
+ sets the per-column statistics-gathering target for subsequent
+ ANALYZE operations.
+ See the similar form of ALTER TABLE
+ for more details.
+
SET ( attribute_option = value [, ... ] )
RESET ( attribute_option [, ... ] )
+ This form sets or resets per-attribute options.
+ See the similar form of ALTER TABLE
+ for more details.
+
-
+
SET STORAGE
+
+ This form sets the storage mode for a column.
+ See the similar form of ALTER TABLE
+ for more details.
+ Note that the storage mode has no effect unless the table's
+ foreign-data wrapper chooses to pay attention to it.
+
ADD table_constraint [ NOT VALID ]
+ This form adds a new constraint to a foreign table, using the same
+ syntax as CREATE FOREIGN TABLE.
+ Currently only CHECK constraints are supported.
+
+ Unlike the case when adding a constraint to a regular table, nothing is
+ done to verify the constraint is correct; rather, this action simply
+ declares that some new condition should be assumed to hold for all rows
+ in the foreign table. (See the discussion
+ in CREATE FOREIGN TABLE.)
+ If the constraint is marked NOT VALID, then it isn't
+ assumed to hold, but is only recorded for possible future use.
+
VALIDATE CONSTRAINT
+ This form marks as valid a constraint that was previously marked
+ as NOT VALID. No action is taken to verify the
+ constraint, but future queries will assume that it holds.
+
DROP CONSTRAINT [ IF EXISTS ]
+ This form drops the specified constraint on a foreign table.
+ If IF EXISTS is specified and the constraint
+ does not exist, no error is thrown.
+ In this case a notice is issued instead.
+
DISABLE/ENABLE [ REPLICA | ALWAYS ] TRIGGER
+ These forms configure the firing of trigger(s) belonging to the foreign
+ table. See the similar form of ALTER TABLE for more
+ details.
+
SET WITHOUT OIDS
+ Backward compatibility syntax for removing the oid
+ system column. As oid system columns cannot be added
+ anymore, this never has an effect.
+
INHERIT parent_table
+ This form adds the target foreign table as a new child of the specified
+ parent table.
+ See the similar form of ALTER TABLE
+ for more details.
+
NO INHERIT parent_table
+ This form removes the target foreign table from the list of children of
+ the specified parent table.
+
OWNER
+ This form changes the owner of the foreign table to the
+ specified user.
+
OPTIONS ( [ ADD | SET | DROP ] option ['value'] [, ... ] )
+ Change options for the foreign table or one of its columns.
+ ADD, SET, and DROP
+ specify the action to be performed. ADD is assumed
+ if no operation is explicitly specified. Duplicate option names are not
+ allowed (although it's OK for a table option and a column option to have
+ the same name). Option names and values are also validated using the
+ foreign data wrapper library.
+
RENAME
+ The RENAME forms change the name of a foreign table
+ or the name of an individual column in a foreign table.
+
SET SCHEMA
+ This form moves the foreign table into another schema.
+
+
+ All the actions except RENAME and SET SCHEMA
+ can be combined into
+ a list of multiple alterations to apply in parallel. For example, it
+ is possible to add several columns and/or alter the type of several
+ columns in a single command.
+
+ If the command is written as ALTER FOREIGN TABLE IF EXISTS ...
+ and the foreign table does not exist, no error is thrown. A notice is
+ issued in this case.
+
+ You must own the table to use ALTER FOREIGN TABLE.
+ To change the schema of a foreign table, you must also have
+ CREATE privilege on the new schema.
+ To alter the owner, you must be able to SET ROLE to the
+ new owning role, and that role must have CREATE privilege
+ on the table's schema. (These restrictions enforce that altering the owner
+ doesn't do anything you couldn't do by dropping and recreating the table.
+ However, a superuser can alter ownership of any table anyway.)
+ To add a column or alter a column type, you must also
+ have USAGE privilege on the data type.
+
Parameters
name
+ The name (possibly schema-qualified) of an existing foreign table to
+ alter. If ONLY is specified before the table name, only
+ that table is altered. If ONLY is not specified, the table
+ and all its descendant tables (if any) are altered. Optionally,
+ * can be specified after the table name to explicitly
+ indicate that descendant tables are included.
+
column_name
+ Name of a new or existing column.
+
new_column_name
+ New name for an existing column.
+
new_name
+ New name for the table.
+
data_type
+ Data type of the new column, or new data type for an existing
+ column.
+
table_constraint
+ New table constraint for the foreign table.
+
constraint_name
+ Name of an existing constraint to drop.
+
CASCADE
+ Automatically drop objects that depend on the dropped column
+ or constraint (for example, views referencing the column),
+ and in turn all objects that depend on those objects
+ (see Section 5.14).
+
RESTRICT
+ Refuse to drop the column or constraint if there are any dependent
+ objects. This is the default behavior.
+
trigger_name
+ Name of a single trigger to disable or enable.
+
ALL
+ Disable or enable all triggers belonging to the foreign table. (This
+ requires superuser privilege if any of the triggers are internally
+ generated triggers. The core system does not add such triggers to
+ foreign tables, but add-on code could do so.)
+
USER
+ Disable or enable all triggers belonging to the foreign table except
+ for internally generated triggers.
+
parent_table
+ A parent table to associate or de-associate with this foreign table.
+
new_owner
+ The user name of the new owner of the table.
+
new_schema
+ The name of the schema to which the table will be moved.
+
Notes
+ The key word COLUMN is noise and can be omitted.
+
+ Consistency with the foreign server is not checked when a column is added
+ or removed with ADD COLUMN or
+ DROP COLUMN, a NOT NULL
+ or CHECK constraint is added, or a column type is changed
+ with SET DATA TYPE. It is the user's responsibility to ensure
+ that the table definition matches the remote side.
+
+ Refer to CREATE FOREIGN TABLE for a further description of valid
+ parameters.
+
Examples
+ To mark a column as not-null:
+
+ALTER FOREIGN TABLE distributors ALTER COLUMN street SET NOT NULL;
+
+
+ To change options of a foreign table:
+
+ALTER FOREIGN TABLE myschema.distributors OPTIONS (ADD opt1 'value', SET opt2 'value2', DROP opt3);
+
Compatibility
+ The forms ADD, DROP,
+ and SET DATA TYPE
+ conform with the SQL standard. The other forms are
+ PostgreSQL extensions of the SQL standard.
+ Also, the ability to specify more than one manipulation in a single
+ ALTER FOREIGN TABLE command is an extension.
+
+ ALTER FOREIGN TABLE DROP COLUMN can be used to drop the only
+ column of a foreign table, leaving a zero-column table. This is an
+ extension of SQL, which disallows zero-column foreign tables.
+
ALTER FUNCTION
ALTER FUNCTION — change the definition of a function
Synopsis
+ALTER FUNCTION name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ]
+ action [ ... ] [ RESTRICT ]
+ALTER FUNCTION name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ]
+ RENAME TO new_name
+ALTER FUNCTION name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ]
+ OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+ALTER FUNCTION name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ]
+ SET SCHEMA new_schema
+ALTER FUNCTION name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ]
+ [ NO ] DEPENDS ON EXTENSION extension_name
+
+where action is one of:
+
+ CALLED ON NULL INPUT | RETURNS NULL ON NULL INPUT | STRICT
+ IMMUTABLE | STABLE | VOLATILE
+ [ NOT ] LEAKPROOF
+ [ EXTERNAL ] SECURITY INVOKER | [ EXTERNAL ] SECURITY DEFINER
+ PARALLEL { UNSAFE | RESTRICTED | SAFE }
+ COST execution_cost
+ ROWS result_rows
+ SUPPORT support_function
+ SET configuration_parameter { TO | = } { value | DEFAULT }
+ SET configuration_parameter FROM CURRENT
+ RESET configuration_parameter
+ RESET ALL
+
Description
+ ALTER FUNCTION changes the definition of a
+ function.
+
+ You must own the function to use ALTER FUNCTION.
+ To change a function's schema, you must also have CREATE
+ privilege on the new schema. To alter the owner, you must be able to
+ SET ROLE to the new owning role, and that role must
+ have CREATE privilege on
+ the function's schema. (These restrictions enforce that altering the owner
+ doesn't do anything you couldn't do by dropping and recreating the function.
+ However, a superuser can alter ownership of any function anyway.)
+
Parameters
name
+ The name (optionally schema-qualified) of an existing function. If no
+ argument list is specified, the name must be unique in its schema.
+
argmode
+ The mode of an argument: IN, OUT,
+ INOUT, or VARIADIC.
+ If omitted, the default is IN.
+ Note that ALTER FUNCTION does not actually pay
+ any attention to OUT arguments, since only the input
+ arguments are needed to determine the function's identity.
+ So it is sufficient to list the IN, INOUT,
+ and VARIADIC arguments.
+
argname
+ The name of an argument.
+ Note that ALTER FUNCTION does not actually pay
+ any attention to argument names, since only the argument data
+ types are needed to determine the function's identity.
+
argtype
+ The data type(s) of the function's arguments (optionally
+ schema-qualified), if any.
+
new_name
+ The new name of the function.
+
new_owner
+ The new owner of the function. Note that if the function is
+ marked SECURITY DEFINER, it will subsequently
+ execute as the new owner.
+
new_schema
+ The new schema for the function.
+
DEPENDS ON EXTENSION extension_name
NO DEPENDS ON EXTENSION extension_name
+ This form marks the function as dependent on the extension, or no longer
+ dependent on that extension if NO is specified.
+ A function that's marked as dependent on an extension is dropped when the
+ extension is dropped, even if CASCADE is not specified.
+ A function can depend upon multiple extensions, and will be dropped when
+ any one of those extensions is dropped.
+
CALLED ON NULL INPUT
RETURNS NULL ON NULL INPUT
STRICTCALLED ON NULL INPUT changes the function so
+ that it will be invoked when some or all of its arguments are
+ null. RETURNS NULL ON NULL INPUT or
+ STRICT changes the function so that it is not
+ invoked if any of its arguments are null; instead, a null result
+ is assumed automatically. See CREATE FUNCTION
+ for more information.
+
IMMUTABLE
STABLE
VOLATILE
+ Change the volatility of the function to the specified setting.
+ See CREATE FUNCTION for details.
+
[ EXTERNAL ] SECURITY INVOKER
[ EXTERNAL ] SECURITY DEFINER
+ Change whether the function is a security definer or not. The
+ key word EXTERNAL is ignored for SQL
+ conformance. See CREATE FUNCTION for more information about
+ this capability.
+
PARALLEL
+ Change whether the function is deemed safe for parallelism.
+ See CREATE FUNCTION for details.
+
LEAKPROOF
+ Change whether the function is considered leakproof or not.
+ See CREATE FUNCTION for more information about
+ this capability.
+
COST execution_cost
+ Change the estimated execution cost of the function.
+ See CREATE FUNCTION for more information.
+
ROWS result_rows
+ Change the estimated number of rows returned by a set-returning
+ function. See CREATE FUNCTION for more information.
+
SUPPORT support_function
+ Set or change the planner support function to use for this function.
+ See Section 38.11 for details. You must be
+ superuser to use this option.
+
+ This option cannot be used to remove the support function altogether,
+ since it must name a new support function. Use CREATE OR
+ REPLACE FUNCTION if you need to do that.
+
configuration_parameter
value
+ Add or change the assignment to be made to a configuration parameter
+ when the function is called. If
+ value is DEFAULT
+ or, equivalently, RESET is used, the function-local
+ setting is removed, so that the function executes with the value
+ present in its environment. Use RESET
+ ALL to clear all function-local settings.
+ SET FROM CURRENT saves the value of the parameter that
+ is current when ALTER FUNCTION is executed as the value
+ to be applied when the function is entered.
+
+ See SET and
+ Chapter 20
+ for more information about allowed parameter names and values.
+
RESTRICT
+ Ignored for conformance with the SQL standard.
+
Examples
+ To rename the function sqrt for type
+ integer to square_root:
+
+ALTER FUNCTION sqrt(integer) RENAME TO square_root;
+
+
+ To change the owner of the function sqrt for type
+ integer to joe:
+
+ALTER FUNCTION sqrt(integer) OWNER TO joe;
+
+
+ To change the schema of the function sqrt for type
+ integer to maths:
+
+ALTER FUNCTION sqrt(integer) SET SCHEMA maths;
+
+
+ To mark the function sqrt for type
+ integer as being dependent on the extension
+ mathlib:
+
+ALTER FUNCTION sqrt(integer) DEPENDS ON EXTENSION mathlib;
+
+
+ To adjust the search path that is automatically set for a function:
+
+ALTER FUNCTION check_password(text) SET search_path = admin, pg_temp;
+
+
+ To disable automatic setting of search_path for a function:
+
+ALTER FUNCTION check_password(text) RESET search_path;
+
+ The function will now execute with whatever search path is used by its
+ caller.
+
Compatibility
+ This statement is partially compatible with the ALTER
+ FUNCTION statement in the SQL standard. The standard allows more
+ properties of a function to be modified, but does not provide the
+ ability to rename a function, make a function a security definer,
+ attach configuration parameter values to a function,
+ or change the owner, schema, or volatility of a function. The standard also
+ requires the RESTRICT key word, which is optional in
+ PostgreSQL.
+
ALTER GROUP
ALTER GROUP — change role name or membership
Synopsis
+ALTER GROUP role_specification ADD USER user_name [, ... ]
+ALTER GROUP role_specification DROP USER user_name [, ... ]
+
+where role_specification can be:
+
+ role_name
+ | CURRENT_ROLE
+ | CURRENT_USER
+ | SESSION_USER
+
+ALTER GROUP group_name RENAME TO new_name
+
Description
+ ALTER GROUP changes the attributes of a user group.
+ This is an obsolete command, though still accepted for backwards
+ compatibility, because groups (and users too) have been superseded by the
+ more general concept of roles.
+
+ The first two variants add users to a group or remove them from a group.
+ (Any role can play the part of either a “user” or a
+ “group” for this purpose.) These variants are effectively
+ equivalent to granting or revoking membership in the role named as the
+ “group”; so the preferred way to do this is to use
+ GRANT or
+ REVOKE. Note that
+ GRANT and REVOKE have additional
+ options which are not available with this command, such as the ability
+ to grant and revoke ADMIN OPTION, and the ability to
+ specify the grantor.
+
+ The third variant changes the name of the group. This is exactly
+ equivalent to renaming the role with
+ ALTER ROLE.
+
Parameters
group_name
+ The name of the group (role) to modify.
+
user_name
+ Users (roles) that are to be added to or removed from the group.
+ The users must already exist; ALTER GROUP does not
+ create or drop users.
+
new_name
+ The new name of the group.
+
Examples
+ Add users to a group:
+
+
+ALTER GROUP staff ADD USER karl, john;
+
+
+ Remove a user from a group:
+
+
+ALTER GROUP workers DROP USER beth;
+
Compatibility
+ There is no ALTER GROUP statement in the SQL
+ standard.
+
ALTER INDEX
ALTER INDEX — change the definition of an index
Synopsis
+ALTER INDEX [ IF EXISTS ] name RENAME TO new_name
+ALTER INDEX [ IF EXISTS ] name SET TABLESPACE tablespace_name
+ALTER INDEX name ATTACH PARTITION index_name
+ALTER INDEX name [ NO ] DEPENDS ON EXTENSION extension_name
+ALTER INDEX [ IF EXISTS ] name SET ( storage_parameter [= value] [, ... ] )
+ALTER INDEX [ IF EXISTS ] name RESET ( storage_parameter [, ... ] )
+ALTER INDEX [ IF EXISTS ] name ALTER [ COLUMN ] column_number
+ SET STATISTICS integer
+ALTER INDEX ALL IN TABLESPACE name [ OWNED BY role_name [, ... ] ]
+ SET TABLESPACE new_tablespace [ NOWAIT ]
+
Description
+ ALTER INDEX changes the definition of an existing index.
+ There are several subforms described below. Note that the lock level required
+ may differ for each subform. An ACCESS EXCLUSIVE lock is held
+ unless explicitly noted. When multiple subcommands are listed, the lock
+ held will be the strictest one required from any subcommand.
+
+
RENAME
+ The RENAME form changes the name of the index.
+ If the index is associated with a table constraint (either
+ UNIQUE, PRIMARY KEY,
+ or EXCLUDE), the constraint is renamed as well.
+ There is no effect on the stored data.
+
+ Renaming an index acquires a SHARE UPDATE EXCLUSIVE
+ lock.
+
SET TABLESPACE
+ This form changes the index's tablespace to the specified tablespace and
+ moves the data file(s) associated with the index to the new tablespace.
+ To change the tablespace of an index, you must own the index and have
+ CREATE privilege on the new tablespace.
+ All indexes in the current database in a tablespace can be moved by using
+ the ALL IN TABLESPACE form, which will lock all
+ indexes to be moved and then move each one. This form also supports
+ OWNED BY, which will only move indexes owned by the
+ roles specified. If the NOWAIT option is specified
+ then the command will fail if it is unable to acquire all of the locks
+ required immediately. Note that system catalogs will not be moved by
+ this command, use ALTER DATABASE or explicit
+ ALTER INDEX invocations instead if desired.
+ See also
+ CREATE TABLESPACE.
+
ATTACH PARTITION
+ Causes the named index to become attached to the altered index.
+ The named index must be on a partition of the table containing the
+ index being altered, and have an equivalent definition. An attached
+ index cannot be dropped by itself, and will automatically be dropped
+ if its parent index is dropped.
+
DEPENDS ON EXTENSION extension_name
NO DEPENDS ON EXTENSION extension_name
+ This form marks the index as dependent on the extension, or no longer
+ dependent on that extension if NO is specified.
+ An index that's marked as dependent on an extension is automatically
+ dropped when the extension is dropped.
+
SET ( storage_parameter [= value] [, ... ] )
+ This form changes one or more index-method-specific storage parameters
+ for the index. See
+ CREATE INDEX
+ for details on the available parameters. Note that the index contents
+ will not be modified immediately by this command; depending on the
+ parameter you might need to rebuild the index with
+ REINDEX
+ to get the desired effects.
+
RESET ( storage_parameter [, ... ] )
+ This form resets one or more index-method-specific storage parameters to
+ their defaults. As with SET, a REINDEX
+ might be needed to update the index entirely.
+
ALTER [ COLUMN ] column_number SET STATISTICS integer
+ This form sets the per-column statistics-gathering target for
+ subsequent ANALYZE operations, though can
+ be used only on index columns that are defined as an expression.
+ Since expressions lack a unique name, we refer to them using the
+ ordinal number of the index column.
+ The target can be set in the range 0 to 10000; alternatively, set it
+ to -1 to revert to using the system default statistics
+ target (default_statistics_target).
+ For more information on the use of statistics by the
+ PostgreSQL query planner, refer to
+ Section 14.2.
+
+
Parameters
IF EXISTS
+ Do not throw an error if the index does not exist. A notice is issued
+ in this case.
+
column_number
+ The ordinal number refers to the ordinal (left-to-right) position
+ of the index column.
+
name
+ The name (possibly schema-qualified) of an existing index to
+ alter.
+
new_name
+ The new name for the index.
+
tablespace_name
+ The tablespace to which the index will be moved.
+
extension_name
+ The name of the extension that the index is to depend on.
+
storage_parameter
+ The name of an index-method-specific storage parameter.
+
value
+ The new value for an index-method-specific storage parameter.
+ This might be a number or a word depending on the parameter.
+
Notes
+ These operations are also possible using
+ ALTER TABLE.
+ ALTER INDEX is in fact just an alias for the forms
+ of ALTER TABLE that apply to indexes.
+
+ There was formerly an ALTER INDEX OWNER variant, but
+ this is now ignored (with a warning). An index cannot have an owner
+ different from its table's owner. Changing the table's owner
+ automatically changes the index as well.
+
+ Changing any part of a system catalog index is not permitted.
+
Examples
+ To rename an existing index:
+
+ALTER INDEX distributors RENAME TO suppliers;
+
+
+ To move an index to a different tablespace:
+
+ALTER INDEX distributors SET TABLESPACE fasttablespace;
+
+
+ To change an index's fill factor (assuming that the index method
+ supports it):
+
+ALTER INDEX distributors SET (fillfactor = 75);
+REINDEX INDEX distributors;
+
+ Set the statistics-gathering target for an expression index:
+
+CREATE INDEX coord_idx ON measured (x, y, (z + t));
+ALTER INDEX coord_idx ALTER COLUMN 3 SET STATISTICS 1000;
+
Compatibility
+ ALTER INDEX is a PostgreSQL
+ extension.
+
ALTER LANGUAGE
ALTER LANGUAGE — change the definition of a procedural language
Synopsis
+ALTER [ PROCEDURAL ] LANGUAGE name RENAME TO new_name
+ALTER [ PROCEDURAL ] LANGUAGE name OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+
Description
+ ALTER LANGUAGE changes the definition of a
+ procedural language. The only functionality is to rename the language or
+ assign a new owner. You must be superuser or owner of the language to
+ use ALTER LANGUAGE.
+
Parameters
name
+ Name of a language
+
new_name
+ The new name of the language
+
new_owner
+ The new owner of the language
+
Compatibility
+ There is no ALTER LANGUAGE statement in the SQL
+ standard.
+
ALTER LARGE OBJECT
ALTER LARGE OBJECT — change the definition of a large object
Synopsis
+ALTER LARGE OBJECT large_object_oid OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+
Description
+ ALTER LARGE OBJECT changes the definition of a
+ large object.
+
+ You must own the large object to use ALTER LARGE OBJECT.
+ To alter the owner, you must also be able to SET ROLE to
+ the new owning role.
+ (However, a superuser can alter any large object anyway.)
+ Currently, the only functionality is to assign a new owner, so both
+ restrictions always apply.
+
Parameters
large_object_oid
+ OID of the large object to be altered
+
new_owner
+ The new owner of the large object
+
Compatibility
+ There is no ALTER LARGE OBJECT statement in the SQL
+ standard.
+
ALTER MATERIALIZED VIEW
ALTER MATERIALIZED VIEW — change the definition of a materialized view
Synopsis
+ALTER MATERIALIZED VIEW [ IF EXISTS ] name
+ action [, ... ]
+ALTER MATERIALIZED VIEW name
+ [ NO ] DEPENDS ON EXTENSION extension_name
+ALTER MATERIALIZED VIEW [ IF EXISTS ] name
+ RENAME [ COLUMN ] column_name TO new_column_name
+ALTER MATERIALIZED VIEW [ IF EXISTS ] name
+ RENAME TO new_name
+ALTER MATERIALIZED VIEW [ IF EXISTS ] name
+ SET SCHEMA new_schema
+ALTER MATERIALIZED VIEW ALL IN TABLESPACE name [ OWNED BY role_name [, ... ] ]
+ SET TABLESPACE new_tablespace [ NOWAIT ]
+
+where action is one of:
+
+ ALTER [ COLUMN ] column_name SET STATISTICS integer
+ ALTER [ COLUMN ] column_name SET ( attribute_option = value [, ... ] )
+ ALTER [ COLUMN ] column_name RESET ( attribute_option [, ... ] )
+ ALTER [ COLUMN ] column_name SET STORAGE { PLAIN | EXTERNAL | EXTENDED | MAIN | DEFAULT }
+ ALTER [ COLUMN ] column_name SET COMPRESSION compression_method
+ CLUSTER ON index_name
+ SET WITHOUT CLUSTER
+ SET ACCESS METHOD new_access_method
+ SET TABLESPACE new_tablespace
+ SET ( storage_parameter [= value] [, ... ] )
+ RESET ( storage_parameter [, ... ] )
+ OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+
Description
+ ALTER MATERIALIZED VIEW changes various auxiliary
+ properties of an existing materialized view.
+
+ You must own the materialized view to use ALTER MATERIALIZED
+ VIEW. To change a materialized view's schema, you must also have
+ CREATE privilege on the new schema.
+ To alter the owner, you must be able to SET ROLE to the
+ new owning role, and that role must have CREATE
+ privilege on the materialized view's schema.
+ (These restrictions enforce that altering
+ the owner doesn't do anything you couldn't do by dropping and recreating the
+ materialized view. However, a superuser can alter ownership of any view
+ anyway.)
+
+ The statement subforms and actions available for
+ ALTER MATERIALIZED VIEW are a subset of those available
+ for ALTER TABLE, and have the same meaning when used for
+ materialized views. See the descriptions for
+ ALTER TABLE
+ for details.
+
Parameters
name
+ The name (optionally schema-qualified) of an existing materialized view.
+
column_name
+ Name of a new or existing column.
+
extension_name
+ The name of the extension that the materialized view is to depend on (or no longer
+ dependent on, if NO is specified). A materialized view
+ that's marked as dependent on an extension is automatically dropped when
+ the extension is dropped.
+
new_column_name
+ New name for an existing column.
+
new_owner
+ The user name of the new owner of the materialized view.
+
new_name
+ The new name for the materialized view.
+
new_schema
+ The new schema for the materialized view.
+
Examples
+ To rename the materialized view foo to
+ bar:
+
+ALTER MATERIALIZED VIEW foo RENAME TO bar;
+
Compatibility
+ ALTER MATERIALIZED VIEW is a
+ PostgreSQL extension.
+
ALTER OPERATOR CLASS
ALTER OPERATOR CLASS — change the definition of an operator class
Synopsis
+ALTER OPERATOR CLASS name USING index_method
+ RENAME TO new_name
+
+ALTER OPERATOR CLASS name USING index_method
+ OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+
+ALTER OPERATOR CLASS name USING index_method
+ SET SCHEMA new_schema
+
Description
+ ALTER OPERATOR CLASS changes the definition of
+ an operator class.
+
+ You must own the operator class to use ALTER OPERATOR CLASS.
+ To alter the owner, you must be able to SET ROLE to the
+ new owning role, and that role must have CREATE
+ privilege on the operator class's schema.
+ (These restrictions enforce that altering the
+ owner doesn't do anything you couldn't do by dropping and recreating the
+ operator class. However, a superuser can alter ownership of any operator
+ class anyway.)
+
Parameters
name
+ The name (optionally schema-qualified) of an existing operator
+ class.
+
index_method
+ The name of the index method this operator class is for.
+
new_name
+ The new name of the operator class.
+
new_owner
+ The new owner of the operator class.
+
new_schema
+ The new schema for the operator class.
+
Compatibility
+ There is no ALTER OPERATOR CLASS statement in
+ the SQL standard.
+
ALTER OPERATOR
ALTER OPERATOR — change the definition of an operator
Synopsis
+ALTER OPERATOR name ( { left_type | NONE } , right_type )
+ OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+
+ALTER OPERATOR name ( { left_type | NONE } , right_type )
+ SET SCHEMA new_schema
+
+ALTER OPERATOR name ( { left_type | NONE } , right_type )
+ SET ( { RESTRICT = { res_proc | NONE }
+ | JOIN = { join_proc | NONE }
+ } [, ... ] )
+
Description
+ ALTER OPERATOR changes the definition of
+ an operator.
+
+ You must own the operator to use ALTER OPERATOR.
+ To alter the owner, you must be able to SET ROLE to the
+ new owning role, and that role must have CREATE
+ privilege on the operator's schema.
+ (These restrictions enforce that altering the owner
+ doesn't do anything you couldn't do by dropping and recreating the operator.
+ However, a superuser can alter ownership of any operator anyway.)
+
Parameters
name
+ The name (optionally schema-qualified) of an existing operator.
+
left_type
+ The data type of the operator's left operand; write
+ NONE if the operator has no left operand.
+
right_type
+ The data type of the operator's right operand.
+
new_owner
+ The new owner of the operator.
+
new_schema
+ The new schema for the operator.
+
res_proc
+ The restriction selectivity estimator function for this operator; write NONE to remove existing selectivity estimator.
+
join_proc
+ The join selectivity estimator function for this operator; write NONE to remove existing selectivity estimator.
+
Examples
+ Change the owner of a custom operator a @@ b for type text:
+
+ALTER OPERATOR @@ (text, text) OWNER TO joe;
+
+ Change the restriction and join selectivity estimator functions of a custom operator a && b for type int[]:
+
+ALTER OPERATOR && (_int4, _int4) SET (RESTRICT = _int_contsel, JOIN = _int_contjoinsel);
+
Compatibility
+ There is no ALTER OPERATOR statement in
+ the SQL standard.
+
ALTER OPERATOR FAMILY
ALTER OPERATOR FAMILY — change the definition of an operator family
Synopsis
+ALTER OPERATOR FAMILY name USING index_method ADD
+ { OPERATOR strategy_number operator_name ( op_type, op_type )
+ [ FOR SEARCH | FOR ORDER BY sort_family_name ]
+ | FUNCTION support_number [ ( op_type [ , op_type ] ) ]
+ function_name [ ( argument_type [, ...] ) ]
+ } [, ... ]
+
+ALTER OPERATOR FAMILY name USING index_method DROP
+ { OPERATOR strategy_number ( op_type [ , op_type ] )
+ | FUNCTION support_number ( op_type [ , op_type ] )
+ } [, ... ]
+
+ALTER OPERATOR FAMILY name USING index_method
+ RENAME TO new_name
+
+ALTER OPERATOR FAMILY name USING index_method
+ OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+
+ALTER OPERATOR FAMILY name USING index_method
+ SET SCHEMA new_schema
+
Description
+ ALTER OPERATOR FAMILY changes the definition of
+ an operator family. You can add operators and support functions
+ to the family, remove them from the family,
+ or change the family's name or owner.
+
+ When operators and support functions are added to a family with
+ ALTER OPERATOR FAMILY, they are not part of any
+ specific operator class within the family, but are just “loose”
+ within the family. This indicates that these operators and functions
+ are compatible with the family's semantics, but are not required for
+ correct functioning of any specific index. (Operators and functions
+ that are so required should be declared as part of an operator class,
+ instead; see CREATE OPERATOR CLASS.)
+ PostgreSQL will allow loose members of a
+ family to be dropped from the family at any time, but members of an
+ operator class cannot be dropped without dropping the whole class and
+ any indexes that depend on it.
+ Typically, single-data-type operators
+ and functions are part of operator classes because they are needed to
+ support an index on that specific data type, while cross-data-type
+ operators and functions are made loose members of the family.
+
+ You must be a superuser to use ALTER OPERATOR FAMILY.
+ (This restriction is made because an erroneous operator family definition
+ could confuse or even crash the server.)
+
+ ALTER OPERATOR FAMILY does not presently check
+ whether the operator family definition includes all the operators and
+ functions required by the index method, nor whether the operators and
+ functions form a self-consistent set. It is the user's
+ responsibility to define a valid operator family.
+
+ Refer to Section 38.16 for further information.
+
Parameters
name
+ The name (optionally schema-qualified) of an existing operator
+ family.
+
index_method
+ The name of the index method this operator family is for.
+
strategy_number
+ The index method's strategy number for an operator
+ associated with the operator family.
+
operator_name
+ The name (optionally schema-qualified) of an operator associated
+ with the operator family.
+
op_type
+ In an OPERATOR clause,
+ the operand data type(s) of the operator, or NONE to
+ signify a prefix operator. Unlike the comparable
+ syntax in CREATE OPERATOR CLASS, the operand data types
+ must always be specified.
+
+ In an ADD FUNCTION clause, the operand data type(s) the
+ function is intended to support, if different from
+ the input data type(s) of the function. For B-tree comparison functions
+ and hash functions it is not necessary to specify op_type since the function's input
+ data type(s) are always the correct ones to use. For B-tree sort
+ support functions, B-Tree equal image functions, and all
+ functions in GiST, SP-GiST and GIN operator classes, it is
+ necessary to specify the operand data type(s) the function is to
+ be used with.
+
+ In a DROP FUNCTION clause, the operand data type(s) the
+ function is intended to support must be specified.
+
sort_family_name
+ The name (optionally schema-qualified) of an existing btree operator
+ family that describes the sort ordering associated with an ordering
+ operator.
+
+ If neither FOR SEARCH nor FOR ORDER BY is
+ specified, FOR SEARCH is the default.
+
support_number
+ The index method's support function number for a
+ function associated with the operator family.
+
function_name
+ The name (optionally schema-qualified) of a function that is an index
+ method support function for the operator family. If no argument list
+ is specified, the name must be unique in its schema.
+
argument_type
+ The parameter data type(s) of the function.
+
new_name
+ The new name of the operator family.
+
new_owner
+ The new owner of the operator family.
+
new_schema
+ The new schema for the operator family.
+
+ The OPERATOR and FUNCTION
+ clauses can appear in any order.
+
Notes
+ Notice that the DROP syntax only specifies the “slot”
+ in the operator family, by strategy or support number and input data
+ type(s). The name of the operator or function occupying the slot is not
+ mentioned. Also, for DROP FUNCTION the type(s) to specify
+ are the input data type(s) the function is intended to support; for
+ GiST, SP-GiST and GIN indexes this might have nothing to do with the actual
+ input argument types of the function.
+
+ Because the index machinery does not check access permissions on functions
+ before using them, including a function or operator in an operator family
+ is tantamount to granting public execute permission on it. This is usually
+ not an issue for the sorts of functions that are useful in an operator
+ family.
+
+ The operators should not be defined by SQL functions. An SQL function
+ is likely to be inlined into the calling query, which will prevent
+ the optimizer from recognizing that the query matches an index.
+
+ Before PostgreSQL 8.4, the OPERATOR
+ clause could include a RECHECK option. This is no longer
+ supported because whether an index operator is “lossy” is now
+ determined on-the-fly at run time. This allows efficient handling of
+ cases where an operator might or might not be lossy.
+
Examples
+ The following example command adds cross-data-type operators and
+ support functions to an operator family that already contains B-tree
+ operator classes for data types int4 and int2.
+
+ALTER OPERATOR FAMILY integer_ops USING btree ADD
+
+ -- int4 vs int2
+ OPERATOR 1 < (int4, int2) ,
+ OPERATOR 2 <= (int4, int2) ,
+ OPERATOR 3 = (int4, int2) ,
+ OPERATOR 4 >= (int4, int2) ,
+ OPERATOR 5 > (int4, int2) ,
+ FUNCTION 1 btint42cmp(int4, int2) ,
+
+ -- int2 vs int4
+ OPERATOR 1 < (int2, int4) ,
+ OPERATOR 2 <= (int2, int4) ,
+ OPERATOR 3 = (int2, int4) ,
+ OPERATOR 4 >= (int2, int4) ,
+ OPERATOR 5 > (int2, int4) ,
+ FUNCTION 1 btint24cmp(int2, int4) ;
+
+ To remove these entries again:
+
+ALTER OPERATOR FAMILY integer_ops USING btree DROP
+
+ -- int4 vs int2
+ OPERATOR 1 (int4, int2) ,
+ OPERATOR 2 (int4, int2) ,
+ OPERATOR 3 (int4, int2) ,
+ OPERATOR 4 (int4, int2) ,
+ OPERATOR 5 (int4, int2) ,
+ FUNCTION 1 (int4, int2) ,
+
+ -- int2 vs int4
+ OPERATOR 1 (int2, int4) ,
+ OPERATOR 2 (int2, int4) ,
+ OPERATOR 3 (int2, int4) ,
+ OPERATOR 4 (int2, int4) ,
+ OPERATOR 5 (int2, int4) ,
+ FUNCTION 1 (int2, int4) ;
+
Compatibility
+ There is no ALTER OPERATOR FAMILY statement in
+ the SQL standard.
+
ALTER POLICY
ALTER POLICY — change the definition of a row-level security policy
Synopsis
+ALTER POLICY name ON table_name RENAME TO new_name
+
+ALTER POLICY name ON table_name
+ [ TO { role_name | PUBLIC | CURRENT_ROLE | CURRENT_USER | SESSION_USER } [, ...] ]
+ [ USING ( using_expression ) ]
+ [ WITH CHECK ( check_expression ) ]
+
Description
+ ALTER POLICY changes the definition of an existing
+ row-level security policy. Note that ALTER POLICY
+ only allows the set of roles to which the policy applies and the
+ USING and WITH CHECK expressions to
+ be modified. To change other properties of a policy, such as the command
+ to which it applies or whether it is permissive or restrictive, the policy
+ must be dropped and recreated.
+
+ To use ALTER POLICY, you must own the table that
+ the policy applies to.
+
+ In the second form of ALTER POLICY, the role list,
+ using_expression, and
+ check_expression are replaced
+ independently if specified. When one of those clauses is omitted, the
+ corresponding part of the policy is unchanged.
+
Parameters
name
+ The name of an existing policy to alter.
+
table_name
+ The name (optionally schema-qualified) of the table that the
+ policy is on.
+
new_name
+ The new name for the policy.
+
role_name
+ The role(s) to which the policy applies. Multiple roles can be
+ specified at one time. To apply the policy to all roles,
+ use PUBLIC.
+
using_expression
+ The USING expression for the policy.
+ See CREATE POLICY for details.
+
check_expression
+ The WITH CHECK expression for the policy.
+ See CREATE POLICY for details.
+
Compatibility
+ ALTER POLICY is a PostgreSQL extension.
+
ALTER PROCEDURE
ALTER PROCEDURE — change the definition of a procedure
Synopsis
+ALTER PROCEDURE name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ]
+ action [ ... ] [ RESTRICT ]
+ALTER PROCEDURE name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ]
+ RENAME TO new_name
+ALTER PROCEDURE name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ]
+ OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+ALTER PROCEDURE name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ]
+ SET SCHEMA new_schema
+ALTER PROCEDURE name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ]
+ [ NO ] DEPENDS ON EXTENSION extension_name
+
+where action is one of:
+
+ [ EXTERNAL ] SECURITY INVOKER | [ EXTERNAL ] SECURITY DEFINER
+ SET configuration_parameter { TO | = } { value | DEFAULT }
+ SET configuration_parameter FROM CURRENT
+ RESET configuration_parameter
+ RESET ALL
+
Description
+ ALTER PROCEDURE changes the definition of a
+ procedure.
+
+ You must own the procedure to use ALTER PROCEDURE.
+ To change a procedure's schema, you must also have CREATE
+ privilege on the new schema.
+ To alter the owner, you must be able to SET ROLE to the
+ new owning role, and that role must have CREATE
+ privilege on the procedure's schema.
+ (These restrictions enforce that altering the owner
+ doesn't do anything you couldn't do by dropping and recreating the procedure.
+ However, a superuser can alter ownership of any procedure anyway.)
+
Parameters
name
+ The name (optionally schema-qualified) of an existing procedure. If no
+ argument list is specified, the name must be unique in its schema.
+
argmode
+ The mode of an argument: IN, OUT,
+ INOUT, or VARIADIC. If omitted,
+ the default is IN.
+
argname
+ The name of an argument.
+ Note that ALTER PROCEDURE does not actually pay
+ any attention to argument names, since only the argument data
+ types are used to determine the procedure's identity.
+
argtype
+ The data type(s) of the procedure's arguments (optionally
+ schema-qualified), if any.
+ See DROP PROCEDURE for the details of how
+ the procedure is looked up using the argument data type(s).
+
new_name
+ The new name of the procedure.
+
new_owner
+ The new owner of the procedure. Note that if the procedure is
+ marked SECURITY DEFINER, it will subsequently
+ execute as the new owner.
+
new_schema
+ The new schema for the procedure.
+
extension_name
+ This form marks the procedure as dependent on the extension, or no longer
+ dependent on the extension if NO is specified.
+ A procedure that's marked as dependent on an extension is dropped when the
+ extension is dropped, even if cascade is not specified.
+ A procedure can depend upon multiple extensions, and will be dropped when
+ any one of those extensions is dropped.
+
[ EXTERNAL ] SECURITY INVOKER
[ EXTERNAL ] SECURITY DEFINER
+ Change whether the procedure is a security definer or not. The
+ key word EXTERNAL is ignored for SQL
+ conformance. See CREATE PROCEDURE for more information about
+ this capability.
+
configuration_parameter
value
+ Add or change the assignment to be made to a configuration parameter
+ when the procedure is called. If
+ value is DEFAULT
+ or, equivalently, RESET is used, the procedure-local
+ setting is removed, so that the procedure executes with the value
+ present in its environment. Use RESET
+ ALL to clear all procedure-local settings.
+ SET FROM CURRENT saves the value of the parameter that
+ is current when ALTER PROCEDURE is executed as the value
+ to be applied when the procedure is entered.
+
+ See SET and
+ Chapter 20
+ for more information about allowed parameter names and values.
+
RESTRICT
+ Ignored for conformance with the SQL standard.
+
Examples
+ To rename the procedure insert_data with two arguments
+ of type integer to insert_record:
+
+ALTER PROCEDURE insert_data(integer, integer) RENAME TO insert_record;
+
+
+ To change the owner of the procedure insert_data with
+ two arguments of type integer to joe:
+
+ALTER PROCEDURE insert_data(integer, integer) OWNER TO joe;
+
+
+ To change the schema of the procedure insert_data with
+ two arguments of type integer
+ to accounting:
+
+ALTER PROCEDURE insert_data(integer, integer) SET SCHEMA accounting;
+
+
+ To mark the procedure insert_data(integer, integer) as
+ being dependent on the extension myext:
+
+ALTER PROCEDURE insert_data(integer, integer) DEPENDS ON EXTENSION myext;
+
+
+ To adjust the search path that is automatically set for a procedure:
+
+ALTER PROCEDURE check_password(text) SET search_path = admin, pg_temp;
+
+
+ To disable automatic setting of search_path for a procedure:
+
+ALTER PROCEDURE check_password(text) RESET search_path;
+
+ The procedure will now execute with whatever search path is used by its
+ caller.
+
Compatibility
+ This statement is partially compatible with the ALTER
+ PROCEDURE statement in the SQL standard. The standard allows more
+ properties of a procedure to be modified, but does not provide the
+ ability to rename a procedure, make a procedure a security definer,
+ attach configuration parameter values to a procedure,
+ or change the owner, schema, or volatility of a procedure. The standard also
+ requires the RESTRICT key word, which is optional in
+ PostgreSQL.
+
ALTER PUBLICATION
ALTER PUBLICATION — change the definition of a publication
Synopsis
+ALTER PUBLICATION name ADD publication_object [, ...]
+ALTER PUBLICATION name SET publication_object [, ...]
+ALTER PUBLICATION name DROP publication_object [, ...]
+ALTER PUBLICATION name SET ( publication_parameter [= value] [, ... ] )
+ALTER PUBLICATION name OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+ALTER PUBLICATION name RENAME TO new_name
+
+where publication_object is one of:
+
+ TABLE [ ONLY ] table_name [ * ] [ ( column_name [, ... ] ) ] [ WHERE ( expression ) ] [, ... ]
+ TABLES IN SCHEMA { schema_name | CURRENT_SCHEMA } [, ... ]
+
Description
+ The command ALTER PUBLICATION can change the attributes
+ of a publication.
+
+ The first three variants change which tables/schemas are part of the
+ publication. The SET clause will replace the list of
+ tables/schemas in the publication with the specified list; the existing
+ tables/schemas that were present in the publication will be removed. The
+ ADD and DROP clauses will add and
+ remove one or more tables/schemas from the publication. Note that adding
+ tables/schemas to a publication that is already subscribed to will require an
+ ALTER SUBSCRIPTION ... REFRESH PUBLICATION action on the
+ subscribing side in order to become effective. Note also that
+ DROP TABLES IN SCHEMA will not drop any schema tables
+ that were specified using
+ FOR TABLE/
+ ADD TABLE, and the combination of DROP
+ with a WHERE clause is not allowed.
+
+ The fourth variant of this command listed in the synopsis can change
+ all of the publication properties specified in
+ CREATE PUBLICATION. Properties not mentioned in the
+ command retain their previous settings.
+
+ The remaining variants change the owner and the name of the publication.
+
+ You must own the publication to use ALTER PUBLICATION.
+ Adding a table to a publication additionally requires owning that table.
+ The ADD TABLES IN SCHEMA and
+ SET TABLES IN SCHEMA to a publication requires the
+ invoking user to be a superuser.
+ To alter the owner, you must be able to SET ROLE to the
+ new owning role, and that role must have CREATE
+ privilege on the database.
+ Also, the new owner of a
+ FOR ALL TABLES
+ or FOR TABLES IN SCHEMA
+ publication must be a superuser. However, a superuser can
+ change the ownership of a publication regardless of these restrictions.
+
+ Adding/Setting any schema when the publication also publishes a table with a
+ column list, and vice versa is not supported.
+
Parameters
name
+ The name of an existing publication whose definition is to be altered.
+
table_name
+ Name of an existing table. If ONLY is specified before the
+ table name, only that table is affected. If ONLY is not
+ specified, the table and all its descendant tables (if any) are
+ affected. Optionally, * can be specified after the table
+ name to explicitly indicate that descendant tables are included.
+
+ Optionally, a column list can be specified. See CREATE PUBLICATION for details. Note that a subscription
+ having several publications in which the same table has been published
+ with different column lists is not supported. See
+ Warning: Combining Column Lists from Multiple Publications for details of
+ potential problems when altering column lists.
+
+ If the optional WHERE clause is specified, rows for
+ which the expression
+ evaluates to false or null will not be published. Note that parentheses
+ are required around the expression. The
+ expression is evaluated with
+ the role used for the replication connection.
+
schema_name
+ Name of an existing schema.
+
SET ( publication_parameter [= value] [, ... ] )
+ This clause alters publication parameters originally set by
+ CREATE PUBLICATION. See there for more information.
+
new_owner
+ The user name of the new owner of the publication.
+
new_name
+ The new name for the publication.
+
Examples
+ Change the publication to publish only deletes and updates:
+
+ALTER PUBLICATION noinsert SET (publish = 'update, delete');
+
+
+ Add some tables to the publication:
+
+ALTER PUBLICATION mypublication ADD TABLE users (user_id, firstname), departments;
+
+ Change the set of columns published for a table:
+
+ALTER PUBLICATION mypublication SET TABLE users (user_id, firstname, lastname), TABLE departments;
+
+ Add schemas marketing and
+ sales to the publication
+ sales_publication:
+
+ALTER PUBLICATION sales_publication ADD TABLES IN SCHEMA marketing, sales;
+
+
+ Add tables users,
+ departments and schema
+ production to the publication
+ production_publication:
+
+ALTER PUBLICATION production_publication ADD TABLE users, departments, TABLES IN SCHEMA production;
+
Compatibility
+ ALTER PUBLICATION is a PostgreSQL
+ extension.
+
ALTER ROLE
ALTER ROLE — change a database role
Synopsis
+ALTER ROLE role_specification [ WITH ] option [ ... ]
+
+where option can be:
+
+ SUPERUSER | NOSUPERUSER
+ | CREATEDB | NOCREATEDB
+ | CREATEROLE | NOCREATEROLE
+ | INHERIT | NOINHERIT
+ | LOGIN | NOLOGIN
+ | REPLICATION | NOREPLICATION
+ | BYPASSRLS | NOBYPASSRLS
+ | CONNECTION LIMIT connlimit
+ | [ ENCRYPTED ] PASSWORD 'password' | PASSWORD NULL
+ | VALID UNTIL 'timestamp'
+
+ALTER ROLE name RENAME TO new_name
+
+ALTER ROLE { role_specification | ALL } [ IN DATABASE database_name ] SET configuration_parameter { TO | = } { value | DEFAULT }
+ALTER ROLE { role_specification | ALL } [ IN DATABASE database_name ] SET configuration_parameter FROM CURRENT
+ALTER ROLE { role_specification | ALL } [ IN DATABASE database_name ] RESET configuration_parameter
+ALTER ROLE { role_specification | ALL } [ IN DATABASE database_name ] RESET ALL
+
+where role_specification can be:
+
+ role_name
+ | CURRENT_ROLE
+ | CURRENT_USER
+ | SESSION_USER
+
Description
+ ALTER ROLE changes the attributes of a
+ PostgreSQL role.
+
+ The first variant of this command listed in the synopsis can change
+ many of the role attributes that can be specified in
+ CREATE ROLE.
+ (All the possible attributes are covered,
+ except that there are no options for adding or removing memberships; use
+ GRANT and
+ REVOKE for that.)
+ Attributes not mentioned in the command retain their previous settings.
+ Database superusers can change any of these settings for any role.
+ Non-superuser roles having CREATEROLE privilege can
+ change most of these properties, but only for non-superuser and
+ non-replication roles for which they have been granted
+ ADMIN OPTION. Non-superusers cannot change the
+ SUPERUSER property and can change the
+ CREATEDB, REPLICATION, and
+ BYPASSRLS properties only if they possess the
+ corresponding property themselves.
+ Ordinary roles can only change their own password.
+
+ The second variant changes the name of the role.
+ Database superusers can rename any role.
+ Roles having CREATEROLE privilege can rename non-superuser
+ roles for which they have been granted ADMIN OPTION.
+ The current session user cannot be renamed.
+ (Connect as a different user if you need to do that.)
+ Because MD5-encrypted passwords use the role name as
+ cryptographic salt, renaming a role clears its password if the
+ password is MD5-encrypted.
+
+ The remaining variants change a role's session default for a configuration
+ variable, either for all databases or, when the IN
+ DATABASE clause is specified, only for sessions in the named
+ database. If ALL is specified instead of a role name,
+ this changes the setting for all roles. Using ALL
+ with IN DATABASE is effectively the same as using the
+ command ALTER DATABASE ... SET ....
+
+ Whenever the role subsequently
+ starts a new session, the specified value becomes the session
+ default, overriding whatever setting is present in
+ postgresql.conf or has been received from the postgres
+ command line. This only happens at login time; executing
+ SET ROLE or
+ SET SESSION AUTHORIZATION does not cause new
+ configuration values to be set.
+ Settings set for all databases are overridden by database-specific settings
+ attached to a role. Settings for specific databases or specific roles override
+ settings for all roles.
+
+ Superusers can change anyone's session defaults. Roles having
+ CREATEROLE privilege can change defaults for non-superuser
+ roles for which they have been granted ADMIN OPTION.
+ Ordinary roles can only set defaults for themselves.
+ Certain configuration variables cannot be set this way, or can only be
+ set if a superuser issues the command. Only superusers can change a setting
+ for all roles in all databases.
+
Parameters
name #
+ The name of the role whose attributes are to be altered.
+
CURRENT_ROLE
CURRENT_USER #
+ Alter the current user instead of an explicitly identified role.
+
SESSION_USER #
+ Alter the current session user instead of an explicitly identified
+ role.
+
SUPERUSER
NOSUPERUSER
CREATEDB
NOCREATEDB
CREATEROLE
NOCREATEROLE
INHERIT
NOINHERIT
LOGIN
NOLOGIN
REPLICATION
NOREPLICATION
BYPASSRLS
NOBYPASSRLS
CONNECTION LIMIT connlimit
[ ENCRYPTED ] PASSWORD 'password'
PASSWORD NULL
VALID UNTIL 'timestamp' #
+ These clauses alter attributes originally set by
+ CREATE ROLE. For more information, see the
+ CREATE ROLE reference page.
+
new_name #
+ The new name of the role.
+
database_name #
+ The name of the database the configuration variable should be set in.
+
configuration_parameter
value #
+ Set this role's session default for the specified configuration
+ parameter to the given value. If
+ value is DEFAULT
+ or, equivalently, RESET is used, the
+ role-specific variable setting is removed, so the role will
+ inherit the system-wide default setting in new sessions. Use
+ RESET ALL to clear all role-specific settings.
+ SET FROM CURRENT saves the session's current value of
+ the parameter as the role-specific value.
+ If IN DATABASE is specified, the configuration
+ parameter is set or removed for the given role and database only.
+
+ Role-specific variable settings take effect only at login;
+ SET ROLE and
+ SET SESSION AUTHORIZATION
+ do not process role-specific variable settings.
+
+ See SET and Chapter 20 for more information about allowed
+ parameter names and values.
+
Notes
+ Use CREATE ROLE
+ to add new roles, and DROP ROLE to remove a role.
+
+ ALTER ROLE cannot change a role's memberships.
+ Use GRANT and
+ REVOKE
+ to do that.
+
+ Caution must be exercised when specifying an unencrypted password
+ with this command. The password will be transmitted to the server
+ in cleartext, and it might also be logged in the client's command
+ history or the server log. psql
+ contains a command
+ \password that can be used to change a
+ role's password without exposing the cleartext password.
+
+ It is also possible to tie a
+ session default to a specific database rather than to a role; see
+ ALTER DATABASE.
+ If there is a conflict, database-role-specific settings override role-specific
+ ones, which in turn override database-specific ones.
+
Examples
+ Change a role's password:
+
+
+ALTER ROLE davide WITH PASSWORD 'hu8jmn3';
+
+
+ Remove a role's password:
+
+
+ALTER ROLE davide WITH PASSWORD NULL;
+
+
+ Change a password expiration date, specifying that the password
+ should expire at midday on 4th May 2015 using
+ the time zone which is one hour ahead of UTC:
+
+ALTER ROLE chris VALID UNTIL 'May 4 12:00:00 2015 +1';
+
+
+ Make a password valid forever:
+
+ALTER ROLE fred VALID UNTIL 'infinity';
+
+
+ Give a role the ability to manage other roles and create new databases:
+
+
+ALTER ROLE miriam CREATEROLE CREATEDB;
+
+
+ Give a role a non-default setting of the
+ maintenance_work_mem parameter:
+
+
+ALTER ROLE worker_bee SET maintenance_work_mem = 100000;
+
+
+ Give a role a non-default, database-specific setting of the
+ client_min_messages parameter:
+
+
+ALTER ROLE fred IN DATABASE devel SET client_min_messages = DEBUG;
+
Compatibility
+ The ALTER ROLE statement is a
+ PostgreSQL extension.
+
ALTER ROUTINE
ALTER ROUTINE — change the definition of a routine
Synopsis
+ALTER ROUTINE name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ]
+ action [ ... ] [ RESTRICT ]
+ALTER ROUTINE name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ]
+ RENAME TO new_name
+ALTER ROUTINE name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ]
+ OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+ALTER ROUTINE name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ]
+ SET SCHEMA new_schema
+ALTER ROUTINE name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ]
+ [ NO ] DEPENDS ON EXTENSION extension_name
+
+where action is one of:
+
+ IMMUTABLE | STABLE | VOLATILE
+ [ NOT ] LEAKPROOF
+ [ EXTERNAL ] SECURITY INVOKER | [ EXTERNAL ] SECURITY DEFINER
+ PARALLEL { UNSAFE | RESTRICTED | SAFE }
+ COST execution_cost
+ ROWS result_rows
+ SET configuration_parameter { TO | = } { value | DEFAULT }
+ SET configuration_parameter FROM CURRENT
+ RESET configuration_parameter
+ RESET ALL
+
Description
+ ALTER ROUTINE changes the definition of a routine, which
+ can be an aggregate function, a normal function, or a procedure. See
+ under ALTER AGGREGATE, ALTER FUNCTION,
+ and ALTER PROCEDURE for the description of the
+ parameters, more examples, and further details.
+
Examples
+ To rename the routine foo for type
+ integer to foobar:
+
+ALTER ROUTINE foo(integer) RENAME TO foobar;
+
+ This command will work independent of whether foo is an
+ aggregate, function, or procedure.
+
Compatibility
+ This statement is partially compatible with the ALTER
+ ROUTINE statement in the SQL standard. See
+ under ALTER FUNCTION
+ and ALTER PROCEDURE for more details. Allowing
+ routine names to refer to aggregate functions is
+ a PostgreSQL extension.
+
ALTER RULE
ALTER RULE — change the definition of a rule
Synopsis
+ALTER RULE name ON table_name RENAME TO new_name
+
Description
+ ALTER RULE changes properties of an existing
+ rule. Currently, the only available action is to change the rule's name.
+
+ To use ALTER RULE, you must own the table or view that
+ the rule applies to.
+
Parameters
name
+ The name of an existing rule to alter.
+
table_name
+ The name (optionally schema-qualified) of the table or view that the
+ rule applies to.
+
new_name
+ The new name for the rule.
+
Examples
+ To rename an existing rule:
+
+ALTER RULE notify_all ON emp RENAME TO notify_me;
+
Compatibility
+ ALTER RULE is a
+ PostgreSQL language extension, as is the
+ entire query rewrite system.
+
ALTER SCHEMA
ALTER SCHEMA — change the definition of a schema
Synopsis
+ALTER SCHEMA name RENAME TO new_name
+ALTER SCHEMA name OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+
Description
+ ALTER SCHEMA changes the definition of a schema.
+
+ You must own the schema to use ALTER SCHEMA.
+ To rename a schema you must also have the
+ CREATE privilege for the database.
+ To alter the owner, you must be able to SET ROLE to the
+ new owning role, and that role must have the
+ CREATE privilege for the database.
+ (Note that superusers have all these privileges automatically.)
+
Parameters
name
+ The name of an existing schema.
+
new_name
+ The new name of the schema. The new name cannot
+ begin with pg_, as such names
+ are reserved for system schemas.
+
new_owner
+ The new owner of the schema.
+
Compatibility
+ There is no ALTER SCHEMA statement in the SQL
+ standard.
+
ALTER SEQUENCE
ALTER SEQUENCE —
+ change the definition of a sequence generator
+
Synopsis
+ALTER SEQUENCE [ IF EXISTS ] name
+ [ AS data_type ]
+ [ INCREMENT [ BY ] increment ]
+ [ MINVALUE minvalue | NO MINVALUE ] [ MAXVALUE maxvalue | NO MAXVALUE ]
+ [ START [ WITH ] start ]
+ [ RESTART [ [ WITH ] restart ] ]
+ [ CACHE cache ] [ [ NO ] CYCLE ]
+ [ OWNED BY { table_name.column_name | NONE } ]
+ALTER SEQUENCE [ IF EXISTS ] name SET { LOGGED | UNLOGGED }
+ALTER SEQUENCE [ IF EXISTS ] name OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+ALTER SEQUENCE [ IF EXISTS ] name RENAME TO new_name
+ALTER SEQUENCE [ IF EXISTS ] name SET SCHEMA new_schema
+
Description
+ ALTER SEQUENCE changes the parameters of an existing
+ sequence generator. Any parameters not specifically set in the
+ ALTER SEQUENCE command retain their prior settings.
+
+ You must own the sequence to use ALTER SEQUENCE.
+ To change a sequence's schema, you must also have CREATE
+ privilege on the new schema.
+ To alter the owner, you must be able to SET ROLE to the
+ new owning role, and that role must have CREATE
+ privilege on the sequence's schema.
+ (These restrictions enforce that altering the owner
+ doesn't do anything you couldn't do by dropping and recreating the sequence.
+ However, a superuser can alter ownership of any sequence anyway.)
+
Parameters
+
name
+ The name (optionally schema-qualified) of a sequence to be altered.
+
IF EXISTS
+ Do not throw an error if the sequence does not exist. A notice is issued
+ in this case.
+
data_type
+ The optional
+ clause AS data_type
+ changes the data type of the sequence. Valid types are
+ smallint, integer,
+ and bigint.
+
+ Changing the data type automatically changes the minimum and maximum
+ values of the sequence if and only if the previous minimum and maximum
+ values were the minimum or maximum value of the old data type (in
+ other words, if the sequence had been created using NO
+ MINVALUE or NO MAXVALUE, implicitly or
+ explicitly). Otherwise, the minimum and maximum values are preserved,
+ unless new values are given as part of the same command. If the
+ minimum and maximum values do not fit into the new data type, an error
+ will be generated.
+
increment
+ The clause INCREMENT BY increment is
+ optional. A positive value will make an ascending sequence, a
+ negative one a descending sequence. If unspecified, the old
+ increment value will be maintained.
+
minvalue
NO MINVALUE
+ The optional clause MINVALUE minvalue determines
+ the minimum value a sequence can generate. If NO
+ MINVALUE is specified, the defaults of 1 and
+ the minimum value of the data type for ascending and descending sequences,
+ respectively, will be used. If neither option is specified,
+ the current minimum value will be maintained.
+
maxvalue
NO MAXVALUE
+ The optional clause MAXVALUE maxvalue determines
+ the maximum value for the sequence. If NO
+ MAXVALUE is specified, the defaults of
+ the maximum value of the data type and -1 for ascending and descending
+ sequences, respectively, will be used. If neither option is
+ specified, the current maximum value will be maintained.
+
start
+ The optional clause START WITH start changes the
+ recorded start value of the sequence. This has no effect on the
+ current sequence value; it simply sets the value
+ that future ALTER SEQUENCE RESTART commands will use.
+
restart
+ The optional clause RESTART [ WITH restart ] changes the
+ current value of the sequence. This is similar to calling the
+ setval function with is_called =
+ false: the specified value will be returned by the
+ next call of nextval.
+ Writing RESTART with no restart value is equivalent to supplying
+ the start value that was recorded by CREATE SEQUENCE
+ or last set by ALTER SEQUENCE START WITH.
+
+ In contrast to a setval call,
+ a RESTART operation on a sequence is transactional
+ and blocks concurrent transactions from obtaining numbers from the
+ same sequence. If that's not the desired mode of
+ operation, setval should be used.
+
cache
+ The clause CACHE cache enables
+ sequence numbers to be preallocated and stored in memory for
+ faster access. The minimum value is 1 (only one value can be
+ generated at a time, i.e., no cache). If unspecified, the old
+ cache value will be maintained.
+
CYCLE
+ The optional CYCLE key word can be used to enable
+ the sequence to wrap around when the
+ maxvalue or
+ minvalue has been
+ reached by
+ an ascending or descending sequence respectively. If the limit is
+ reached, the next number generated will be the
+ minvalue or
+ maxvalue,
+ respectively.
+
NO CYCLE
+ If the optional NO CYCLE key word is
+ specified, any calls to nextval after the
+ sequence has reached its maximum value will return an error.
+ If neither CYCLE or NO
+ CYCLE are specified, the old cycle behavior will be
+ maintained.
+
SET { LOGGED | UNLOGGED }
+ This form changes the sequence from unlogged to logged or vice-versa
+ (see CREATE SEQUENCE). It cannot be applied to a
+ temporary sequence.
+
OWNED BY table_name.column_name
OWNED BY NONE
+ The OWNED BY option causes the sequence to be
+ associated with a specific table column, such that if that column
+ (or its whole table) is dropped, the sequence will be automatically
+ dropped as well. If specified, this association replaces any
+ previously specified association for the sequence. The specified
+ table must have the same owner and be in the same schema as the
+ sequence.
+ Specifying OWNED BY NONE removes any existing
+ association, making the sequence “free-standing”.
+
new_owner
+ The user name of the new owner of the sequence.
+
new_name
+ The new name for the sequence.
+
new_schema
+ The new schema for the sequence.
+
+
Notes
+ ALTER SEQUENCE will not immediately affect
+ nextval results in backends,
+ other than the current one, that have preallocated (cached) sequence
+ values. They will use up all cached values prior to noticing the changed
+ sequence generation parameters. The current backend will be affected
+ immediately.
+
+ ALTER SEQUENCE does not affect the currval
+ status for the sequence. (Before PostgreSQL
+ 8.3, it sometimes did.)
+
+ ALTER SEQUENCE blocks
+ concurrent nextval, currval,
+ lastval, and setval calls.
+
+ For historical reasons, ALTER TABLE can be used with
+ sequences too; but the only variants of ALTER TABLE
+ that are allowed with sequences are equivalent to the forms shown above.
+
Examples
+ Restart a sequence called serial, at 105:
+
+ALTER SEQUENCE serial RESTART WITH 105;
+
Compatibility
+ ALTER SEQUENCE conforms to the SQL
+ standard, except for the AS, START WITH,
+ OWNED BY, OWNER TO, RENAME TO, and
+ SET SCHEMA clauses, which are
+ PostgreSQL extensions.
+
ALTER SERVER
ALTER SERVER — change the definition of a foreign server
Synopsis
+ALTER SERVER name [ VERSION 'new_version' ]
+ [ OPTIONS ( [ ADD | SET | DROP ] option ['value'] [, ... ] ) ]
+ALTER SERVER name OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+ALTER SERVER name RENAME TO new_name
+
Description
+ ALTER SERVER changes the definition of a foreign
+ server. The first form changes the server version string or the
+ generic options of the server (at least one clause is required).
+ The second form changes the owner of the server.
+
+ To alter the server you must be the owner of the server.
+ Additionally to alter the owner, you must be able to
+ SET ROLE to the new owning role, and you must
+ have USAGE privilege on the server's foreign-data
+ wrapper. (Note that superusers satisfy all these criteria
+ automatically.)
+
Parameters
name
+ The name of an existing server.
+
new_version
+ New server version.
+
OPTIONS ( [ ADD | SET | DROP ] option ['value'] [, ... ] )
+ Change options for the
+ server. ADD, SET, and DROP
+ specify the action to be performed. ADD is assumed
+ if no operation is explicitly specified. Option names must be
+ unique; names and values are also validated using the server's
+ foreign-data wrapper library.
+
new_owner
+ The user name of the new owner of the foreign server.
+
new_name
+ The new name for the foreign server.
+
Examples
+ Alter server foo, add connection options:
+
+ALTER SERVER foo OPTIONS (host 'foo', dbname 'foodb');
+
+
+ Alter server foo, change version,
+ change host option:
+
+ALTER SERVER foo VERSION '8.4' OPTIONS (SET host 'baz');
+
Compatibility
+ ALTER SERVER conforms to ISO/IEC 9075-9 (SQL/MED).
+ The OWNER TO and RENAME forms are
+ PostgreSQL extensions.
+
ALTER STATISTICS
ALTER STATISTICS —
+ change the definition of an extended statistics object
+
Synopsis
+ALTER STATISTICS name OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+ALTER STATISTICS name RENAME TO new_name
+ALTER STATISTICS name SET SCHEMA new_schema
+ALTER STATISTICS name SET STATISTICS new_target
+
Description
+ ALTER STATISTICS changes the parameters of an existing
+ extended statistics object. Any parameters not specifically set in the
+ ALTER STATISTICS command retain their prior settings.
+
+ You must own the statistics object to use ALTER STATISTICS.
+ To change a statistics object's schema, you must also
+ have CREATE privilege on the new schema.
+ To alter the owner, you must be able to SET ROLE to the
+ new owning role, and that role must have CREATE
+ privilege on the statistics object's schema.
+ (These restrictions enforce that altering
+ the owner doesn't do anything you couldn't do by dropping and recreating
+ the statistics object. However, a superuser can alter ownership of any
+ statistics object anyway.)
+
Parameters
+
name
+ The name (optionally schema-qualified) of the statistics object to be
+ altered.
+
new_owner
+ The user name of the new owner of the statistics object.
+
new_name
+ The new name for the statistics object.
+
new_schema
+ The new schema for the statistics object.
+
new_target
+ The statistic-gathering target for this statistics object for subsequent
+ ANALYZE operations.
+ The target can be set in the range 0 to 10000; alternatively, set it
+ to -1 to revert to using the maximum of the statistics target of the
+ referenced columns, if set, or the system default statistics
+ target (default_statistics_target).
+ For more information on the use of statistics by the
+ PostgreSQL query planner, refer to
+ Section 14.2.
+
+
Compatibility
+ There is no ALTER STATISTICS command in the SQL standard.
+
ALTER SUBSCRIPTION
ALTER SUBSCRIPTION — change the definition of a subscription
Synopsis
+ALTER SUBSCRIPTION name CONNECTION 'conninfo'
+ALTER SUBSCRIPTION name SET PUBLICATION publication_name [, ...] [ WITH ( publication_option [= value] [, ... ] ) ]
+ALTER SUBSCRIPTION name ADD PUBLICATION publication_name [, ...] [ WITH ( publication_option [= value] [, ... ] ) ]
+ALTER SUBSCRIPTION name DROP PUBLICATION publication_name [, ...] [ WITH ( publication_option [= value] [, ... ] ) ]
+ALTER SUBSCRIPTION name REFRESH PUBLICATION [ WITH ( refresh_option [= value] [, ... ] ) ]
+ALTER SUBSCRIPTION name ENABLE
+ALTER SUBSCRIPTION name DISABLE
+ALTER SUBSCRIPTION name SET ( subscription_parameter [= value] [, ... ] )
+ALTER SUBSCRIPTION name SKIP ( skip_option = value )
+ALTER SUBSCRIPTION name OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+ALTER SUBSCRIPTION name RENAME TO new_name
+
Description
+ ALTER SUBSCRIPTION can change most of the subscription
+ properties that can be specified
+ in CREATE SUBSCRIPTION.
+
+ You must own the subscription to use ALTER SUBSCRIPTION.
+ To rename a subscription or alter the owner, you must have
+ CREATE permission on the database. In addition,
+ to alter the owner, you must be able to SET ROLE to the
+ new owning role. If the subscription has
+ password_required=false, only superusers can modify it.
+
+ When refreshing a publication we remove the relations that are no longer
+ part of the publication and we also remove the table synchronization slots
+ if there are any. It is necessary to remove these slots so that the resources
+ allocated for the subscription on the remote host are released. If due to
+ network breakdown or some other error, PostgreSQL
+ is unable to remove the slots, an error will be reported. To proceed in this
+ situation, the user either needs to retry the operation or disassociate the
+ slot from the subscription and drop the subscription as explained in
+ DROP SUBSCRIPTION.
+
+ Commands ALTER SUBSCRIPTION ... REFRESH PUBLICATION and
+ ALTER SUBSCRIPTION ... {SET|ADD|DROP} PUBLICATION ...
+ with refresh option as true cannot be
+ executed inside a transaction block.
+
+ These commands also cannot be executed when the subscription has
+ two_phase
+ commit enabled, unless
+ copy_data
+ is false. See column subtwophasestate
+ of pg_subscription
+ to know the actual two-phase state.
+
Parameters
name
+ The name of a subscription whose properties are to be altered.
+
CONNECTION 'conninfo'
+ This clause replaces the connection string originally set by
+ CREATE SUBSCRIPTION. See there for more
+ information.
+
SET PUBLICATION publication_name
ADD PUBLICATION publication_name
DROP PUBLICATION publication_name
+ These forms change the list of subscribed publications.
+ SET
+ replaces the entire list of publications with a new list,
+ ADD adds additional publications to the list of
+ publications, and DROP removes the publications from
+ the list of publications. We allow non-existent publications to be
+ specified in ADD and SET variants
+ so that users can add those later. See CREATE SUBSCRIPTION
+ for more information. By default, this command will also act like
+ REFRESH PUBLICATION.
+
+ publication_option specifies additional
+ options for this operation. The supported options are:
+
+
refresh (boolean)
+ When false, the command will not try to refresh table information.
+ REFRESH PUBLICATION should then be executed separately.
+ The default is true.
+
+
+ Additionally, the options described under
+ REFRESH PUBLICATION may be specified, to control the
+ implicit refresh operation.
+
REFRESH PUBLICATION
+ Fetch missing table information from publisher. This will start
+ replication of tables that were added to the subscribed-to publications
+ since CREATE SUBSCRIPTION or
+ the last invocation of REFRESH PUBLICATION.
+
+ refresh_option specifies additional options for the
+ refresh operation. The supported options are:
+
+
copy_data (boolean)
+ Specifies whether to copy pre-existing data in the publications
+ that are being subscribed to when the replication starts.
+ The default is true.
+
+ Previously subscribed tables are not copied, even if a table's row
+ filter WHERE clause has since been modified.
+
+ See Notes for details of
+ how copy_data = true can interact with the
+ origin
+ parameter.
+
+ See the
+ binary
+ parameter of CREATE SUBSCRIPTION for details about
+ copying pre-existing data in binary format.
+
ENABLE
+ Enables a previously disabled subscription, starting the logical
+ replication worker at the end of the transaction.
+
DISABLE
+ Disables a running subscription, stopping the logical replication
+ worker at the end of the transaction.
+
SET ( subscription_parameter [= value] [, ... ] )
+ This clause alters parameters originally set by
+ CREATE SUBSCRIPTION. See there for more
+ information. The parameters that can be altered are
+ slot_name,
+ synchronous_commit,
+ binary,
+ streaming,
+ disable_on_error,
+ password_required,
+ run_as_owner, and
+ origin.
+ Only a superuser can set password_required = false.
+
SKIP ( skip_option = value )
+ Skips applying all changes of the remote transaction. If incoming data
+ violates any constraints, logical replication will stop until it is
+ resolved. By using the ALTER SUBSCRIPTION ... SKIP command,
+ the logical replication worker skips all data modification changes within
+ the transaction. This option has no effect on the transactions that are
+ already prepared by enabling
+ two_phase
+ on the subscriber.
+ After the logical replication worker successfully skips the transaction or
+ finishes a transaction, the LSN (stored in
+ pg_subscription.subskiplsn)
+ is cleared. See Section 31.5 for
+ the details of logical replication conflicts.
+
+ skip_option specifies options for this operation.
+ The supported option is:
+
+
lsn (pg_lsn)
+ Specifies the finish LSN of the remote transaction whose changes
+ are to be skipped by the logical replication worker. The finish LSN
+ is the LSN at which the transaction is either committed or prepared.
+ Skipping individual subtransactions is not supported. Setting
+ NONE resets the LSN.
+
new_owner
+ The user name of the new owner of the subscription.
+
new_name
+ The new name for the subscription.
+
+ When specifying a parameter of type boolean, the
+ = value
+ part can be omitted, which is equivalent to
+ specifying TRUE.
+
Examples
+ Change the publication subscribed by a subscription to
+ insert_only:
+
+ALTER SUBSCRIPTION mysub SET PUBLICATION insert_only;
+
+
+ Disable (stop) the subscription:
+
+ALTER SUBSCRIPTION mysub DISABLE;
+
Compatibility
+ ALTER SUBSCRIPTION is a PostgreSQL
+ extension.
+
ALTER SYSTEM
ALTER SYSTEM — change a server configuration parameter
Synopsis
+ALTER SYSTEM SET configuration_parameter { TO | = } { value [, ...] | DEFAULT }
+
+ALTER SYSTEM RESET configuration_parameter
+ALTER SYSTEM RESET ALL
+
Description
+ ALTER SYSTEM is used for changing server configuration
+ parameters across the entire database cluster. It can be more convenient
+ than the traditional method of manually editing
+ the postgresql.conf file.
+ ALTER SYSTEM writes the given parameter setting to
+ the postgresql.auto.conf file, which is read in
+ addition to postgresql.conf.
+ Setting a parameter to DEFAULT, or using the
+ RESET variant, removes that configuration entry from the
+ postgresql.auto.conf file. Use RESET
+ ALL to remove all such configuration entries.
+
+ Values set with ALTER SYSTEM will be effective after
+ the next server configuration reload, or after the next server restart
+ in the case of parameters that can only be changed at server start.
+ A server configuration reload can be commanded by calling the SQL
+ function pg_reload_conf(), running pg_ctl reload,
+ or sending a SIGHUP signal to the main server process.
+
+ Only superusers and users granted ALTER SYSTEM privilege
+ on a parameter can change it using ALTER SYSTEM. Also, since
+ this command acts directly on the file system and cannot be rolled back,
+ it is not allowed inside a transaction block or function.
+
Parameters
configuration_parameter
+ Name of a settable configuration parameter. Available parameters are
+ documented in Chapter 20.
+
value
+ New value of the parameter. Values can be specified as string
+ constants, identifiers, numbers, or comma-separated lists of
+ these, as appropriate for the particular parameter.
+ Values that are neither numbers nor valid identifiers must be quoted.
+ DEFAULT can be written to specify removing the
+ parameter and its value from postgresql.auto.conf.
+
+ For some list-accepting parameters, quoted values will produce
+ double-quoted output to preserve whitespace and commas; for others,
+ double-quotes must be used inside single-quoted strings to get
+ this effect.
+
Notes
+ This command can't be used to set data_directory,
+ nor parameters that are not allowed in postgresql.conf
+ (e.g., preset options).
+
+ See Section 20.1 for other ways to set the parameters.
+
Examples
+ Set the wal_level:
+
+ALTER SYSTEM SET wal_level = replica;
+
+
+ Undo that, restoring whatever setting was effective
+ in postgresql.conf:
+
+ALTER SYSTEM RESET wal_level;
+
Compatibility
+ The ALTER SYSTEM statement is a
+ PostgreSQL extension.
+
ALTER TABLE
ALTER TABLE — change the definition of a table
Synopsis
+ALTER TABLE [ IF EXISTS ] [ ONLY ] name [ * ]
+ action [, ... ]
+ALTER TABLE [ IF EXISTS ] [ ONLY ] name [ * ]
+ RENAME [ COLUMN ] column_name TO new_column_name
+ALTER TABLE [ IF EXISTS ] [ ONLY ] name [ * ]
+ RENAME CONSTRAINT constraint_name TO new_constraint_name
+ALTER TABLE [ IF EXISTS ] name
+ RENAME TO new_name
+ALTER TABLE [ IF EXISTS ] name
+ SET SCHEMA new_schema
+ALTER TABLE ALL IN TABLESPACE name [ OWNED BY role_name [, ... ] ]
+ SET TABLESPACE new_tablespace [ NOWAIT ]
+ALTER TABLE [ IF EXISTS ] name
+ ATTACH PARTITION partition_name { FOR VALUES partition_bound_spec | DEFAULT }
+ALTER TABLE [ IF EXISTS ] name
+ DETACH PARTITION partition_name [ CONCURRENTLY | FINALIZE ]
+
+where action is one of:
+
+ ADD [ COLUMN ] [ IF NOT EXISTS ] column_name data_type [ COLLATE collation ] [ column_constraint [ ... ] ]
+ DROP [ COLUMN ] [ IF EXISTS ] column_name [ RESTRICT | CASCADE ]
+ ALTER [ COLUMN ] column_name [ SET DATA ] TYPE data_type [ COLLATE collation ] [ USING expression ]
+ ALTER [ COLUMN ] column_name SET DEFAULT expression
+ ALTER [ COLUMN ] column_name DROP DEFAULT
+ ALTER [ COLUMN ] column_name { SET | DROP } NOT NULL
+ ALTER [ COLUMN ] column_name DROP EXPRESSION [ IF EXISTS ]
+ ALTER [ COLUMN ] column_name ADD GENERATED { ALWAYS | BY DEFAULT } AS IDENTITY [ ( sequence_options ) ]
+ ALTER [ COLUMN ] column_name { SET GENERATED { ALWAYS | BY DEFAULT } | SET sequence_option | RESTART [ [ WITH ] restart ] } [...]
+ ALTER [ COLUMN ] column_name DROP IDENTITY [ IF EXISTS ]
+ ALTER [ COLUMN ] column_name SET STATISTICS integer
+ ALTER [ COLUMN ] column_name SET ( attribute_option = value [, ... ] )
+ ALTER [ COLUMN ] column_name RESET ( attribute_option [, ... ] )
+ ALTER [ COLUMN ] column_name SET STORAGE { PLAIN | EXTERNAL | EXTENDED | MAIN | DEFAULT }
+ ALTER [ COLUMN ] column_name SET COMPRESSION compression_method
+ ADD table_constraint [ NOT VALID ]
+ ADD table_constraint_using_index
+ ALTER CONSTRAINT constraint_name [ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]
+ VALIDATE CONSTRAINT constraint_name
+ DROP CONSTRAINT [ IF EXISTS ] constraint_name [ RESTRICT | CASCADE ]
+ DISABLE TRIGGER [ trigger_name | ALL | USER ]
+ ENABLE TRIGGER [ trigger_name | ALL | USER ]
+ ENABLE REPLICA TRIGGER trigger_name
+ ENABLE ALWAYS TRIGGER trigger_name
+ DISABLE RULE rewrite_rule_name
+ ENABLE RULE rewrite_rule_name
+ ENABLE REPLICA RULE rewrite_rule_name
+ ENABLE ALWAYS RULE rewrite_rule_name
+ DISABLE ROW LEVEL SECURITY
+ ENABLE ROW LEVEL SECURITY
+ FORCE ROW LEVEL SECURITY
+ NO FORCE ROW LEVEL SECURITY
+ CLUSTER ON index_name
+ SET WITHOUT CLUSTER
+ SET WITHOUT OIDS
+ SET ACCESS METHOD new_access_method
+ SET TABLESPACE new_tablespace
+ SET { LOGGED | UNLOGGED }
+ SET ( storage_parameter [= value] [, ... ] )
+ RESET ( storage_parameter [, ... ] )
+ INHERIT parent_table
+ NO INHERIT parent_table
+ OF type_name
+ NOT OF
+ OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+ REPLICA IDENTITY { DEFAULT | USING INDEX index_name | FULL | NOTHING }
+
+and partition_bound_spec is:
+
+IN ( partition_bound_expr [, ...] ) |
+FROM ( { partition_bound_expr | MINVALUE | MAXVALUE } [, ...] )
+ TO ( { partition_bound_expr | MINVALUE | MAXVALUE } [, ...] ) |
+WITH ( MODULUS numeric_literal, REMAINDER numeric_literal )
+
+and column_constraint is:
+
+[ CONSTRAINT constraint_name ]
+{ NOT NULL |
+ NULL |
+ CHECK ( expression ) [ NO INHERIT ] |
+ DEFAULT default_expr |
+ GENERATED ALWAYS AS ( generation_expr ) STORED |
+ GENERATED { ALWAYS | BY DEFAULT } AS IDENTITY [ ( sequence_options ) ] |
+ UNIQUE [ NULLS [ NOT ] DISTINCT ] index_parameters |
+ PRIMARY KEY index_parameters |
+ REFERENCES reftable [ ( refcolumn ) ] [ MATCH FULL | MATCH PARTIAL | MATCH SIMPLE ]
+ [ ON DELETE referential_action ] [ ON UPDATE referential_action ] }
+[ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]
+
+and table_constraint is:
+
+[ CONSTRAINT constraint_name ]
+{ CHECK ( expression ) [ NO INHERIT ] |
+ UNIQUE [ NULLS [ NOT ] DISTINCT ] ( column_name [, ... ] ) index_parameters |
+ PRIMARY KEY ( column_name [, ... ] ) index_parameters |
+ EXCLUDE [ USING index_method ] ( exclude_element WITH operator [, ... ] ) index_parameters [ WHERE ( predicate ) ] |
+ FOREIGN KEY ( column_name [, ... ] ) REFERENCES reftable [ ( refcolumn [, ... ] ) ]
+ [ MATCH FULL | MATCH PARTIAL | MATCH SIMPLE ] [ ON DELETE referential_action ] [ ON UPDATE referential_action ] }
+[ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]
+
+and table_constraint_using_index is:
+
+ [ CONSTRAINT constraint_name ]
+ { UNIQUE | PRIMARY KEY } USING INDEX index_name
+ [ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]
+
+index_parameters in UNIQUE, PRIMARY KEY, and EXCLUDE constraints are:
+
+[ INCLUDE ( column_name [, ... ] ) ]
+[ WITH ( storage_parameter [= value] [, ... ] ) ]
+[ USING INDEX TABLESPACE tablespace_name ]
+
+exclude_element in an EXCLUDE constraint is:
+
+{ column_name | ( expression ) } [ COLLATE collation ] [ opclass [ ( opclass_parameter = value [, ... ] ) ] ] [ ASC | DESC ] [ NULLS { FIRST | LAST } ]
+
+referential_action in a FOREIGN KEY/REFERENCES constraint is:
+
+{ NO ACTION | RESTRICT | CASCADE | SET NULL [ ( column_name [, ... ] ) ] | SET DEFAULT [ ( column_name [, ... ] ) ] }
+
Description
+ ALTER TABLE changes the definition of an existing table.
+ There are several subforms described below. Note that the lock level required
+ may differ for each subform. An ACCESS EXCLUSIVE lock is
+ acquired unless explicitly noted. When multiple subcommands are given, the
+ lock acquired will be the strictest one required by any subcommand.
+
+
ADD COLUMN [ IF NOT EXISTS ] #
+ This form adds a new column to the table, using the same syntax as
+ CREATE TABLE. If IF NOT EXISTS
+ is specified and a column already exists with this name,
+ no error is thrown.
+
DROP COLUMN [ IF EXISTS ] #
+ This form drops a column from a table. Indexes and
+ table constraints involving the column will be automatically
+ dropped as well.
+ Multivariate statistics referencing the dropped column will also be
+ removed if the removal of the column would cause the statistics to
+ contain data for only a single column.
+ You will need to say CASCADE if anything outside the table
+ depends on the column, for example, foreign key references or views.
+ If IF EXISTS is specified and the column
+ does not exist, no error is thrown. In this case a notice
+ is issued instead.
+
SET DATA TYPE #
+ This form changes the type of a column of a table. Indexes and
+ simple table constraints involving the column will be automatically
+ converted to use the new column type by reparsing the originally
+ supplied expression.
+ The optional COLLATE clause specifies a collation
+ for the new column; if omitted, the collation is the default for the
+ new column type.
+ The optional USING
+ clause specifies how to compute the new column value from the old;
+ if omitted, the default conversion is the same as an assignment
+ cast from old data type to new. A USING
+ clause must be provided if there is no implicit or assignment
+ cast from old to new type.
+
+ When this form is used, the column's statistics are removed,
+ so running ANALYZE
+ on the table afterwards is recommended.
+
SET/DROP DEFAULT #
+ These forms set or remove the default value for a column (where
+ removal is equivalent to setting the default value to NULL). The new
+ default value will only apply in subsequent INSERT
+ or UPDATE commands; it does not cause rows already
+ in the table to change.
+
SET/DROP NOT NULL #
+ These forms change whether a column is marked to allow null
+ values or to reject null values.
+
+ SET NOT NULL may only be applied to a column
+ provided none of the records in the table contain a
+ NULL value for the column. Ordinarily this is
+ checked during the ALTER TABLE by scanning the
+ entire table; however, if a valid CHECK constraint is
+ found which proves no NULL can exist, then the
+ table scan is skipped.
+
+ If this table is a partition, one cannot perform DROP NOT NULL
+ on a column if it is marked NOT NULL in the parent
+ table. To drop the NOT NULL constraint from all the
+ partitions, perform DROP NOT NULL on the parent
+ table. Even if there is no NOT NULL constraint on the
+ parent, such a constraint can still be added to individual partitions,
+ if desired; that is, the children can disallow nulls even if the parent
+ allows them, but not the other way around.
+
DROP EXPRESSION [ IF EXISTS ] #
+ This form turns a stored generated column into a normal base column.
+ Existing data in the columns is retained, but future changes will no
+ longer apply the generation expression.
+
+ If DROP EXPRESSION IF EXISTS is specified and the
+ column is not a stored generated column, no error is thrown. In this
+ case a notice is issued instead.
+
ADD GENERATED { ALWAYS | BY DEFAULT } AS IDENTITY
SET GENERATED { ALWAYS | BY DEFAULT }
DROP IDENTITY [ IF EXISTS ] #
+ These forms change whether a column is an identity column or change the
+ generation attribute of an existing identity column.
+ See CREATE TABLE for details.
+ Like SET DEFAULT, these forms only affect the
+ behavior of subsequent INSERT
+ and UPDATE commands; they do not cause rows
+ already in the table to change.
+
+ If DROP IDENTITY IF EXISTS is specified and the
+ column is not an identity column, no error is thrown. In this case a
+ notice is issued instead.
+
SET sequence_option
RESTART #
+ These forms alter the sequence that underlies an existing identity
+ column. sequence_option is an option
+ supported by ALTER SEQUENCE such
+ as INCREMENT BY.
+
SET STATISTICS #
+ This form
+ sets the per-column statistics-gathering target for subsequent
+ ANALYZE operations.
+ The target can be set in the range 0 to 10000; alternatively, set it
+ to -1 to revert to using the system default statistics
+ target (default_statistics_target).
+ For more information on the use of statistics by the
+ PostgreSQL query planner, refer to
+ Section 14.2.
+
+ SET STATISTICS acquires a
+ SHARE UPDATE EXCLUSIVE lock.
+
SET ( attribute_option = value [, ... ] )
RESET ( attribute_option [, ... ] ) #
+ This form sets or resets per-attribute options. Currently, the only
+ defined per-attribute options are n_distinct and
+ n_distinct_inherited, which override the
+ number-of-distinct-values estimates made by subsequent
+ ANALYZE
+ operations. n_distinct affects the statistics for the table
+ itself, while n_distinct_inherited affects the statistics
+ gathered for the table plus its inheritance children. When set to a
+ positive value, ANALYZE will assume that the column contains
+ exactly the specified number of distinct nonnull values. When set to a
+ negative value, which must be greater
+ than or equal to -1, ANALYZE will assume that the number of
+ distinct nonnull values in the column is linear in the size of the
+ table; the exact count is to be computed by multiplying the estimated
+ table size by the absolute value of the given number. For example,
+ a value of -1 implies that all values in the column are distinct, while
+ a value of -0.5 implies that each value appears twice on the average.
+ This can be useful when the size of the table changes over time, since
+ the multiplication by the number of rows in the table is not performed
+ until query planning time. Specify a value of 0 to revert to estimating
+ the number of distinct values normally. For more information on the use
+ of statistics by the PostgreSQL query
+ planner, refer to Section 14.2.
+
+ Changing per-attribute options acquires a
+ SHARE UPDATE EXCLUSIVE lock.
+
-
+
SET STORAGE { PLAIN | EXTERNAL | EXTENDED | MAIN | DEFAULT }
+
+ #
+ This form sets the storage mode for a column. This controls whether this
+ column is held inline or in a secondary TOAST table,
+ and whether the data
+ should be compressed or not. PLAIN must be used
+ for fixed-length values such as integer and is
+ inline, uncompressed. MAIN is for inline,
+ compressible data. EXTERNAL is for external,
+ uncompressed data, and EXTENDED is for external,
+ compressed data.
+ Writing DEFAULT sets the storage mode to the default
+ mode for the column's data type. EXTENDED is the
+ default for most data types that support non-PLAIN
+ storage.
+ Use of EXTERNAL will make substring operations on
+ very large text and bytea values run faster,
+ at the penalty of increased storage space.
+ Note that ALTER TABLE ... SET STORAGE doesn't itself
+ change anything in the table; it just sets the strategy to be pursued
+ during future table updates.
+ See Section 73.2 for more information.
+
-
+
SET COMPRESSION compression_method
+ #
+ This form sets the compression method for a column, determining how
+ values inserted in future will be compressed (if the storage mode
+ permits compression at all).
+ This does not cause the table to be rewritten, so existing data may still
+ be compressed with other compression methods. If the table is restored
+ with pg_restore, then all values are rewritten
+ with the configured compression method.
+ However, when data is inserted from another relation (for example,
+ by INSERT ... SELECT), values from the source table are
+ not necessarily detoasted, so any previously compressed data may retain
+ its existing compression method, rather than being recompressed with the
+ compression method of the target column.
+ The supported compression
+ methods are pglz and lz4.
+ (lz4 is available only if --with-lz4
+ was used when building PostgreSQL.) In
+ addition, compression_method
+ can be default, which selects the default behavior of
+ consulting the default_toast_compression setting
+ at the time of data insertion to determine the method to use.
+
ADD table_constraint [ NOT VALID ] #
+ This form adds a new constraint to a table using the same constraint
+ syntax as CREATE TABLE, plus the option NOT
+ VALID, which is currently only allowed for foreign key
+ and CHECK constraints.
+
+ Normally, this form will cause a scan of the table to verify that all
+ existing rows in the table satisfy the new constraint. But if
+ the NOT VALID option is used, this
+ potentially-lengthy scan is skipped. The constraint will still be
+ enforced against subsequent inserts or updates (that is, they'll fail
+ unless there is a matching row in the referenced table, in the case
+ of foreign keys, or they'll fail unless the new row matches the
+ specified check condition). But the
+ database will not assume that the constraint holds for all rows in
+ the table, until it is validated by using the VALIDATE
+ CONSTRAINT option.
+ See Notes below for more information
+ about using the NOT VALID option.
+
+ Although most forms of ADD
+ table_constraint
+ require an ACCESS EXCLUSIVE lock, ADD
+ FOREIGN KEY requires only a SHARE ROW
+ EXCLUSIVE lock. Note that ADD FOREIGN KEY
+ also acquires a SHARE ROW EXCLUSIVE lock on the
+ referenced table, in addition to the lock on the table on which the
+ constraint is declared.
+
+ Additional restrictions apply when unique or primary key constraints
+ are added to partitioned tables; see CREATE TABLE.
+ Also, foreign key constraints on partitioned
+ tables may not be declared NOT VALID at present.
+
ADD table_constraint_using_index #
+ This form adds a new PRIMARY KEY or UNIQUE
+ constraint to a table based on an existing unique index. All the
+ columns of the index will be included in the constraint.
+
+ The index cannot have expression columns nor be a partial index.
+ Also, it must be a b-tree index with default sort ordering. These
+ restrictions ensure that the index is equivalent to one that would be
+ built by a regular ADD PRIMARY KEY or ADD UNIQUE
+ command.
+
+ If PRIMARY KEY is specified, and the index's columns are not
+ already marked NOT NULL, then this command will attempt to
+ do ALTER COLUMN SET NOT NULL against each such column.
+ That requires a full table scan to verify the column(s) contain no
+ nulls. In all other cases, this is a fast operation.
+
+ If a constraint name is provided then the index will be renamed to match
+ the constraint name. Otherwise the constraint will be named the same as
+ the index.
+
+ After this command is executed, the index is “owned” by the
+ constraint, in the same way as if the index had been built by
+ a regular ADD PRIMARY KEY or ADD UNIQUE
+ command. In particular, dropping the constraint will make the index
+ disappear too.
+
+ This form is not currently supported on partitioned tables.
+
Note
+ Adding a constraint using an existing index can be helpful in
+ situations where a new constraint needs to be added without blocking
+ table updates for a long time. To do that, create the index using
+ CREATE INDEX CONCURRENTLY, and then install it as an
+ official constraint using this syntax. See the example below.
+
ALTER CONSTRAINT #
+ This form alters the attributes of a constraint that was previously
+ created. Currently only foreign key constraints may be altered.
+
VALIDATE CONSTRAINT #
+ This form validates a foreign key or check constraint that was
+ previously created as NOT VALID, by scanning the
+ table to ensure there are no rows for which the constraint is not
+ satisfied. Nothing happens if the constraint is already marked valid.
+ (See Notes below for an explanation
+ of the usefulness of this command.)
+
+ This command acquires a SHARE UPDATE EXCLUSIVE lock.
+
DROP CONSTRAINT [ IF EXISTS ] #
+ This form drops the specified constraint on a table, along with
+ any index underlying the constraint.
+ If IF EXISTS is specified and the constraint
+ does not exist, no error is thrown. In this case a notice is issued instead.
+
DISABLE/ENABLE [ REPLICA | ALWAYS ] TRIGGER #
+ These forms configure the firing of trigger(s) belonging to the table.
+ A disabled trigger is still known to the system, but is not executed
+ when its triggering event occurs. (For a deferred trigger, the enable
+ status is checked when the event occurs, not when the trigger function
+ is actually executed.) One can disable or enable a single
+ trigger specified by name, or all triggers on the table, or only
+ user triggers (this option excludes internally generated constraint
+ triggers, such as those that are used to implement foreign key
+ constraints or deferrable uniqueness and exclusion constraints).
+ Disabling or enabling internally generated constraint triggers
+ requires superuser privileges; it should be done with caution since
+ of course the integrity of the constraint cannot be guaranteed if the
+ triggers are not executed.
+
+ The trigger firing mechanism is also affected by the configuration
+ variable session_replication_role. Simply enabled
+ triggers (the default) will fire when the replication role is “origin”
+ (the default) or “local”. Triggers configured as ENABLE
+ REPLICA will only fire if the session is in “replica”
+ mode, and triggers configured as ENABLE ALWAYS will
+ fire regardless of the current replication role.
+
+ The effect of this mechanism is that in the default configuration,
+ triggers do not fire on replicas. This is useful because if a trigger
+ is used on the origin to propagate data between tables, then the
+ replication system will also replicate the propagated data; so the
+ trigger should not fire a second time on the replica, because that would
+ lead to duplication. However, if a trigger is used for another purpose
+ such as creating external alerts, then it might be appropriate to set it
+ to ENABLE ALWAYS so that it is also fired on
+ replicas.
+
+ When this command is applied to a partitioned table, the states of
+ corresponding clone triggers in the partitions are updated too,
+ unless ONLY is specified.
+
+ This command acquires a SHARE ROW EXCLUSIVE lock.
+
DISABLE/ENABLE [ REPLICA | ALWAYS ] RULE #
+ These forms configure the firing of rewrite rules belonging to the table.
+ A disabled rule is still known to the system, but is not applied
+ during query rewriting. The semantics are as for disabled/enabled
+ triggers. This configuration is ignored for ON SELECT rules, which
+ are always applied in order to keep views working even if the current
+ session is in a non-default replication role.
+
+ The rule firing mechanism is also affected by the configuration variable
+ session_replication_role, analogous to triggers as
+ described above.
+
DISABLE/ENABLE ROW LEVEL SECURITY #
+ These forms control the application of row security policies belonging
+ to the table. If enabled and no policies exist for the table, then a
+ default-deny policy is applied. Note that policies can exist for a table
+ even if row-level security is disabled. In this case, the policies will
+ not be applied and the policies will be ignored.
+ See also
+ CREATE POLICY.
+
NO FORCE/FORCE ROW LEVEL SECURITY #
+ These forms control the application of row security policies belonging
+ to the table when the user is the table owner. If enabled, row-level
+ security policies will be applied when the user is the table owner. If
+ disabled (the default) then row-level security will not be applied when
+ the user is the table owner.
+ See also
+ CREATE POLICY.
+
CLUSTER ON #
+ This form selects the default index for future
+ CLUSTER
+ operations. It does not actually re-cluster the table.
+
+ Changing cluster options acquires a SHARE UPDATE EXCLUSIVE lock.
+
SET WITHOUT CLUSTER #
+ This form removes the most recently used
+ CLUSTER
+ index specification from the table. This affects
+ future cluster operations that don't specify an index.
+
+ Changing cluster options acquires a SHARE UPDATE EXCLUSIVE lock.
+
SET WITHOUT OIDS #
+ Backward-compatible syntax for removing the oid
+ system column. As oid system columns cannot be
+ added anymore, this never has an effect.
+
SET ACCESS METHOD #
+ This form changes the access method of the table by rewriting it. See
+ Chapter 63 for more information.
+
SET TABLESPACE #
+ This form changes the table's tablespace to the specified tablespace and
+ moves the data file(s) associated with the table to the new tablespace.
+ Indexes on the table, if any, are not moved; but they can be moved
+ separately with additional SET TABLESPACE commands.
+ When applied to a partitioned table, nothing is moved, but any
+ partitions created afterwards with
+ CREATE TABLE PARTITION OF will use that tablespace,
+ unless overridden by a TABLESPACE clause.
+
+ All tables in the current database in a tablespace can be moved by using
+ the ALL IN TABLESPACE form, which will lock all tables
+ to be moved first and then move each one. This form also supports
+ OWNED BY, which will only move tables owned by the
+ roles specified. If the NOWAIT option is specified
+ then the command will fail if it is unable to acquire all of the locks
+ required immediately. Note that system catalogs are not moved by this
+ command; use ALTER DATABASE or explicit
+ ALTER TABLE invocations instead if desired. The
+ information_schema relations are not considered part
+ of the system catalogs and will be moved.
+ See also
+ CREATE TABLESPACE.
+
SET { LOGGED | UNLOGGED } #
+ This form changes the table from unlogged to logged or vice-versa
+ (see UNLOGGED). It cannot be applied
+ to a temporary table.
+
+ This also changes the persistence of any sequences linked to the table
+ (for identity or serial columns). However, it is also possible to
+ change the persistence of such sequences separately.
+
SET ( storage_parameter [= value] [, ... ] ) #
+ This form changes one or more storage parameters for the table. See
+ Storage Parameters in the
+ CREATE TABLE documentation
+ for details on the available parameters. Note that the table contents
+ will not be modified immediately by this command; depending on the
+ parameter you might need to rewrite the table to get the desired effects.
+ That can be done with VACUUM
+ FULL, CLUSTER or one of the forms
+ of ALTER TABLE that forces a table rewrite.
+ For planner related parameters, changes will take effect from the next
+ time the table is locked so currently executing queries will not be
+ affected.
+
+ SHARE UPDATE EXCLUSIVE lock will be taken for
+ fillfactor, toast and autovacuum storage parameters, as well as the
+ planner parameter parallel_workers.
+
RESET ( storage_parameter [, ... ] ) #
+ This form resets one or more storage parameters to their
+ defaults. As with SET, a table rewrite might be
+ needed to update the table entirely.
+
INHERIT parent_table #
+ This form adds the target table as a new child of the specified parent
+ table. Subsequently, queries against the parent will include records
+ of the target table. To be added as a child, the target table must
+ already contain all the same columns as the parent (it could have
+ additional columns, too). The columns must have matching data types,
+ and if they have NOT NULL constraints in the parent
+ then they must also have NOT NULL constraints in the
+ child.
+
+ There must also be matching child-table constraints for all
+ CHECK constraints of the parent, except those
+ marked non-inheritable (that is, created with ALTER TABLE ... ADD CONSTRAINT ... NO INHERIT)
+ in the parent, which are ignored; all child-table constraints matched
+ must not be marked non-inheritable.
+ Currently
+ UNIQUE, PRIMARY KEY, and
+ FOREIGN KEY constraints are not considered, but
+ this might change in the future.
+
NO INHERIT parent_table #
+ This form removes the target table from the list of children of the
+ specified parent table.
+ Queries against the parent table will no longer include records drawn
+ from the target table.
+
OF type_name #
+ This form links the table to a composite type as though CREATE
+ TABLE OF had formed it. The table's list of column names and types
+ must precisely match that of the composite type. The table must
+ not inherit from any other table. These restrictions ensure
+ that CREATE TABLE OF would permit an equivalent table
+ definition.
+
NOT OF #
+ This form dissociates a typed table from its type.
+
OWNER TO #
+ This form changes the owner of the table, sequence, view, materialized view,
+ or foreign table to the specified user.
+
REPLICA IDENTITY #
+ This form changes the information which is written to the write-ahead log
+ to identify rows which are updated or deleted.
+ In most cases, the old value of each column is only logged if it differs
+ from the new value; however, if the old value is stored externally, it is
+ always logged regardless of whether it changed.
+ This option has no effect except when logical replication is in use.
+
DEFAULT #
+ Records the old values of the columns of the primary key, if any.
+ This is the default for non-system tables.
+
USING INDEX index_name #
+ Records the old values of the columns covered by the named index,
+ that must be unique, not partial, not deferrable, and include only
+ columns marked NOT NULL. If this index is
+ dropped, the behavior is the same as NOTHING.
+
FULL #
+ Records the old values of all columns in the row.
+
NOTHING #
+ Records no information about the old row. This is the default for
+ system tables.
+
RENAME #
+ The RENAME forms change the name of a table
+ (or an index, sequence, view, materialized view, or foreign table), the
+ name of an individual column in a table, or the name of a constraint of
+ the table. When renaming a constraint that has an underlying index,
+ the index is renamed as well.
+ There is no effect on the stored data.
+
SET SCHEMA #
+ This form moves the table into another schema. Associated indexes,
+ constraints, and sequences owned by table columns are moved as well.
+
ATTACH PARTITION partition_name { FOR VALUES partition_bound_spec | DEFAULT } #
+ This form attaches an existing table (which might itself be partitioned)
+ as a partition of the target table. The table can be attached
+ as a partition for specific values using FOR VALUES
+ or as a default partition by using DEFAULT.
+ For each index in the target table, a corresponding
+ one will be created in the attached table; or, if an equivalent
+ index already exists, it will be attached to the target table's index,
+ as if ALTER INDEX ATTACH PARTITION had been executed.
+ Note that if the existing table is a foreign table, it is currently not
+ allowed to attach the table as a partition of the target table if there
+ are UNIQUE indexes on the target table. (See also
+ CREATE FOREIGN TABLE.) For each user-defined
+ row-level trigger that exists in the target table, a corresponding one
+ is created in the attached table.
+
+ A partition using FOR VALUES uses same syntax for
+ partition_bound_spec as
+ CREATE TABLE. The partition bound specification
+ must correspond to the partitioning strategy and partition key of the
+ target table. The table to be attached must have all the same columns
+ as the target table and no more; moreover, the column types must also
+ match. Also, it must have all the NOT NULL and
+ CHECK constraints of the target table. Currently
+ FOREIGN KEY constraints are not considered.
+ UNIQUE and PRIMARY KEY constraints
+ from the parent table will be created in the partition, if they don't
+ already exist.
+ If any of the CHECK constraints of the table being
+ attached are marked NO INHERIT, the command will fail;
+ such constraints must be recreated without the
+ NO INHERIT clause.
+
+ If the new partition is a regular table, a full table scan is performed
+ to check that existing rows in the table do not violate the partition
+ constraint. It is possible to avoid this scan by adding a valid
+ CHECK constraint to the table that allows only
+ rows satisfying the desired partition constraint before running this
+ command. The CHECK constraint will be used to
+ determine that the table need not be scanned to validate the partition
+ constraint. This does not work, however, if any of the partition keys
+ is an expression and the partition does not accept
+ NULL values. If attaching a list partition that will
+ not accept NULL values, also add a
+ NOT NULL constraint to the partition key column,
+ unless it's an expression.
+
+ If the new partition is a foreign table, nothing is done to verify
+ that all the rows in the foreign table obey the partition constraint.
+ (See the discussion in CREATE FOREIGN TABLE about
+ constraints on the foreign table.)
+
+ When a table has a default partition, defining a new partition changes
+ the partition constraint for the default partition. The default
+ partition can't contain any rows that would need to be moved to the new
+ partition, and will be scanned to verify that none are present. This
+ scan, like the scan of the new partition, can be avoided if an
+ appropriate CHECK constraint is present. Also like
+ the scan of the new partition, it is always skipped when the default
+ partition is a foreign table.
+
+ Attaching a partition acquires a
+ SHARE UPDATE EXCLUSIVE lock on the parent table,
+ in addition to the ACCESS EXCLUSIVE locks on the table
+ being attached and on the default partition (if any).
+
+ Further locks must also be held on all sub-partitions if the table being
+ attached is itself a partitioned table. Likewise if the default
+ partition is itself a partitioned table. The locking of the
+ sub-partitions can be avoided by adding a CHECK
+ constraint as described in
+ Section 5.11.2.2.
+
DETACH PARTITION partition_name [ CONCURRENTLY | FINALIZE ] #
+ This form detaches the specified partition of the target table. The detached
+ partition continues to exist as a standalone table, but no longer has any
+ ties to the table from which it was detached. Any indexes that were
+ attached to the target table's indexes are detached. Any triggers that
+ were created as clones of those in the target table are removed.
+ SHARE lock is obtained on any tables that reference
+ this partitioned table in foreign key constraints.
+
+ If CONCURRENTLY is specified, it runs using a reduced
+ lock level to avoid blocking other sessions that might be accessing the
+ partitioned table. In this mode, two transactions are used internally.
+ During the first transaction, a SHARE UPDATE EXCLUSIVE
+ lock is taken on both parent table and partition, and the partition is
+ marked as undergoing detach; at that point, the transaction is committed
+ and all other transactions using the partitioned table are waited for.
+ Once all those transactions have completed, the second transaction
+ acquires SHARE UPDATE EXCLUSIVE on the partitioned
+ table and ACCESS EXCLUSIVE on the partition,
+ and the detach process completes. A CHECK constraint
+ that duplicates the partition constraint is added to the partition.
+ CONCURRENTLY cannot be run in a transaction block and
+ is not allowed if the partitioned table contains a default partition.
+
+ If FINALIZE is specified, a previous
+ DETACH CONCURRENTLY invocation that was canceled or
+ interrupted is completed.
+ At most one partition in a partitioned table can be pending detach at
+ a time.
+
+
+ All the forms of ALTER TABLE that act on a single table, except
+ RENAME, SET SCHEMA,
+ ATTACH PARTITION, and
+ DETACH PARTITION can be combined into
+ a list of multiple alterations to be applied together. For example, it
+ is possible to add several columns and/or alter the type of several
+ columns in a single command. This is particularly useful with large
+ tables, since only one pass over the table need be made.
+
+ You must own the table to use ALTER TABLE.
+ To change the schema or tablespace of a table, you must also have
+ CREATE privilege on the new schema or tablespace.
+ To add the table as a new child of a parent table, you must own the parent
+ table as well. Also, to attach a table as a new partition of the table,
+ you must own the table being attached.
+ To alter the owner, you must be able to SET ROLE to the
+ new owning role, and that role must have CREATE
+ privilege on the table's schema.
+ (These restrictions enforce that altering the owner
+ doesn't do anything you couldn't do by dropping and recreating the table.
+ However, a superuser can alter ownership of any table anyway.)
+ To add a column or alter a column type or use the OF
+ clause, you must also have USAGE privilege on the data
+ type.
+
Parameters
IF EXISTS #
+ Do not throw an error if the table does not exist. A notice is issued
+ in this case.
+
name #
+ The name (optionally schema-qualified) of an existing table to
+ alter. If ONLY is specified before the table name, only
+ that table is altered. If ONLY is not specified, the table
+ and all its descendant tables (if any) are altered. Optionally,
+ * can be specified after the table name to explicitly
+ indicate that descendant tables are included.
+
column_name #
+ Name of a new or existing column.
+
new_column_name #
+ New name for an existing column.
+
new_name #
+ New name for the table.
+
data_type #
+ Data type of the new column, or new data type for an existing
+ column.
+
table_constraint #
+ New table constraint for the table.
+
constraint_name #
+ Name of a new or existing constraint.
+
CASCADE #
+ Automatically drop objects that depend on the dropped column
+ or constraint (for example, views referencing the column),
+ and in turn all objects that depend on those objects
+ (see Section 5.14).
+
RESTRICT #
+ Refuse to drop the column or constraint if there are any dependent
+ objects. This is the default behavior.
+
trigger_name #
+ Name of a single trigger to disable or enable.
+
ALL #
+ Disable or enable all triggers belonging to the table.
+ (This requires superuser privilege if any of the triggers are
+ internally generated constraint triggers, such as those that are used
+ to implement foreign key constraints or deferrable uniqueness and
+ exclusion constraints.)
+
USER #
+ Disable or enable all triggers belonging to the table except for
+ internally generated constraint triggers, such as those that are used
+ to implement foreign key constraints or deferrable uniqueness and
+ exclusion constraints.
+
index_name #
+ The name of an existing index.
+
storage_parameter #
+ The name of a table storage parameter.
+
value #
+ The new value for a table storage parameter.
+ This might be a number or a word depending on the parameter.
+
parent_table #
+ A parent table to associate or de-associate with this table.
+
new_owner #
+ The user name of the new owner of the table.
+
new_access_method #
+ The name of the access method to which the table will be converted.
+
new_tablespace #
+ The name of the tablespace to which the table will be moved.
+
new_schema #
+ The name of the schema to which the table will be moved.
+
partition_name #
+ The name of the table to attach as a new partition or to detach from this table.
+
partition_bound_spec #
+ The partition bound specification for a new partition. Refer to
+ CREATE TABLE for more details on the syntax of the same.
+
Notes
+ The key word COLUMN is noise and can be omitted.
+
+ When a column is added with ADD COLUMN and a
+ non-volatile DEFAULT is specified, the default is
+ evaluated at the time of the statement and the result stored in the
+ table's metadata. That value will be used for the column for all existing
+ rows. If no DEFAULT is specified, NULL is used. In
+ neither case is a rewrite of the table required.
+
+ Adding a column with a volatile DEFAULT or
+ changing the type of an existing column will require the entire table and
+ its indexes to be rewritten. As an exception, when changing the type of an
+ existing column, if the USING clause does not change
+ the column contents and the old type is either binary coercible to the new
+ type or an unconstrained domain over the new type, a table rewrite is not
+ needed. However, indexes must always be rebuilt unless the system can
+ verify that the new index would be logically equivalent to the existing
+ one. For example, if the collation for a column has been changed, an index
+ rebuild is always required because the new sort order might be different.
+ However, in the absence of a collation change, a column can be changed
+ from text to varchar (or vice versa) without
+ rebuilding the indexes because these data types sort identically.
+ Table and/or index rebuilds may take a
+ significant amount of time for a large table; and will temporarily require
+ as much as double the disk space.
+
+ Adding a CHECK or NOT NULL constraint requires
+ scanning the table to verify that existing rows meet the constraint,
+ but does not require a table rewrite.
+
+ Similarly, when attaching a new partition it may be scanned to verify that
+ existing rows meet the partition constraint.
+
+ The main reason for providing the option to specify multiple changes
+ in a single ALTER TABLE is that multiple table scans or
+ rewrites can thereby be combined into a single pass over the table.
+
+ Scanning a large table to verify a new foreign key or check constraint
+ can take a long time, and other updates to the table are locked out
+ until the ALTER TABLE ADD CONSTRAINT command is
+ committed. The main purpose of the NOT VALID
+ constraint option is to reduce the impact of adding a constraint on
+ concurrent updates. With NOT VALID,
+ the ADD CONSTRAINT command does not scan the table
+ and can be committed immediately. After that, a VALIDATE
+ CONSTRAINT command can be issued to verify that existing rows
+ satisfy the constraint. The validation step does not need to lock out
+ concurrent updates, since it knows that other transactions will be
+ enforcing the constraint for rows that they insert or update; only
+ pre-existing rows need to be checked. Hence, validation acquires only
+ a SHARE UPDATE EXCLUSIVE lock on the table being
+ altered. (If the constraint is a foreign key then a ROW
+ SHARE lock is also required on the table referenced by the
+ constraint.) In addition to improving concurrency, it can be useful to
+ use NOT VALID and VALIDATE
+ CONSTRAINT in cases where the table is known to contain
+ pre-existing violations. Once the constraint is in place, no new
+ violations can be inserted, and the existing problems can be corrected
+ at leisure until VALIDATE CONSTRAINT finally
+ succeeds.
+
+ The DROP COLUMN form does not physically remove
+ the column, but simply makes it invisible to SQL operations. Subsequent
+ insert and update operations in the table will store a null value for the
+ column. Thus, dropping a column is quick but it will not immediately
+ reduce the on-disk size of your table, as the space occupied
+ by the dropped column is not reclaimed. The space will be
+ reclaimed over time as existing rows are updated.
+
+ To force immediate reclamation of space occupied by a dropped column,
+ you can execute one of the forms of ALTER TABLE that
+ performs a rewrite of the whole table. This results in reconstructing
+ each row with the dropped column replaced by a null value.
+
+ The rewriting forms of ALTER TABLE are not MVCC-safe.
+ After a table rewrite, the table will appear empty to concurrent
+ transactions, if they are using a snapshot taken before the rewrite
+ occurred. See Section 13.6 for more details.
+
+ The USING option of SET DATA TYPE can actually
+ specify any expression involving the old values of the row; that is, it
+ can refer to other columns as well as the one being converted. This allows
+ very general conversions to be done with the SET DATA TYPE
+ syntax. Because of this flexibility, the USING
+ expression is not applied to the column's default value (if any); the
+ result might not be a constant expression as required for a default.
+ This means that when there is no implicit or assignment cast from old to
+ new type, SET DATA TYPE might fail to convert the default even
+ though a USING clause is supplied. In such cases,
+ drop the default with DROP DEFAULT, perform the ALTER
+ TYPE, and then use SET DEFAULT to add a suitable new
+ default. Similar considerations apply to indexes and constraints involving
+ the column.
+
+ If a table has any descendant tables, it is not permitted to add,
+ rename, or change the type of a column in the parent table without doing
+ the same to the descendants. This ensures that the descendants always
+ have columns matching the parent. Similarly, a CHECK
+ constraint cannot be renamed in the parent without also renaming it in
+ all descendants, so that CHECK constraints also match
+ between the parent and its descendants. (That restriction does not apply
+ to index-based constraints, however.)
+ Also, because selecting from the parent also selects from its descendants,
+ a constraint on the parent cannot be marked valid unless it is also marked
+ valid for those descendants. In all of these cases, ALTER TABLE
+ ONLY will be rejected.
+
+ A recursive DROP COLUMN operation will remove a
+ descendant table's column only if the descendant does not inherit
+ that column from any other parents and never had an independent
+ definition of the column. A nonrecursive DROP
+ COLUMN (i.e., ALTER TABLE ONLY ... DROP
+ COLUMN) never removes any descendant columns, but
+ instead marks them as independently defined rather than inherited.
+ A nonrecursive DROP COLUMN command will fail for a
+ partitioned table, because all partitions of a table must have the same
+ columns as the partitioning root.
+
+ The actions for identity columns (ADD
+ GENERATED, SET etc., DROP
+ IDENTITY), as well as the actions
+ CLUSTER, OWNER,
+ and TABLESPACE never recurse to descendant tables;
+ that is, they always act as though ONLY were specified.
+ Actions affecting trigger states recurse to partitions of partitioned
+ tables (unless ONLY is specified), but never to
+ traditional-inheritance descendants.
+ Adding a constraint recurses only for CHECK constraints
+ that are not marked NO INHERIT.
+
+ Changing any part of a system catalog table is not permitted.
+
+ Refer to CREATE TABLE for a further description of valid
+ parameters. Chapter 5 has further information on
+ inheritance.
+
Examples
+ To add a column of type varchar to a table:
+
+ALTER TABLE distributors ADD COLUMN address varchar(30);
+
+ That will cause all existing rows in the table to be filled with null
+ values for the new column.
+
+ To add a column with a non-null default:
+
+ALTER TABLE measurements
+ ADD COLUMN mtime timestamp with time zone DEFAULT now();
+
+ Existing rows will be filled with the current time as the value of the
+ new column, and then new rows will receive the time of their insertion.
+
+ To add a column and fill it with a value different from the default to
+ be used later:
+
+ALTER TABLE transactions
+ ADD COLUMN status varchar(30) DEFAULT 'old',
+ ALTER COLUMN status SET default 'current';
+
+ Existing rows will be filled with old, but then
+ the default for subsequent commands will be current.
+ The effects are the same as if the two sub-commands had been issued
+ in separate ALTER TABLE commands.
+
+ To drop a column from a table:
+
+ALTER TABLE distributors DROP COLUMN address RESTRICT;
+
+
+ To change the types of two existing columns in one operation:
+
+ALTER TABLE distributors
+ ALTER COLUMN address TYPE varchar(80),
+ ALTER COLUMN name TYPE varchar(100);
+
+
+ To change an integer column containing Unix timestamps to timestamp
+ with time zone via a USING clause:
+
+ALTER TABLE foo
+ ALTER COLUMN foo_timestamp SET DATA TYPE timestamp with time zone
+ USING
+ timestamp with time zone 'epoch' + foo_timestamp * interval '1 second';
+
+
+ The same, when the column has a default expression that won't automatically
+ cast to the new data type:
+
+ALTER TABLE foo
+ ALTER COLUMN foo_timestamp DROP DEFAULT,
+ ALTER COLUMN foo_timestamp TYPE timestamp with time zone
+ USING
+ timestamp with time zone 'epoch' + foo_timestamp * interval '1 second',
+ ALTER COLUMN foo_timestamp SET DEFAULT now();
+
+
+ To rename an existing column:
+
+ALTER TABLE distributors RENAME COLUMN address TO city;
+
+
+ To rename an existing table:
+
+ALTER TABLE distributors RENAME TO suppliers;
+
+
+ To rename an existing constraint:
+
+ALTER TABLE distributors RENAME CONSTRAINT zipchk TO zip_check;
+
+
+ To add a not-null constraint to a column:
+
+ALTER TABLE distributors ALTER COLUMN street SET NOT NULL;
+
+ To remove a not-null constraint from a column:
+
+ALTER TABLE distributors ALTER COLUMN street DROP NOT NULL;
+
+
+ To add a check constraint to a table and all its children:
+
+ALTER TABLE distributors ADD CONSTRAINT zipchk CHECK (char_length(zipcode) = 5);
+
+
+ To add a check constraint only to a table and not to its children:
+
+ALTER TABLE distributors ADD CONSTRAINT zipchk CHECK (char_length(zipcode) = 5) NO INHERIT;
+
+ (The check constraint will not be inherited by future children, either.)
+
+ To remove a check constraint from a table and all its children:
+
+ALTER TABLE distributors DROP CONSTRAINT zipchk;
+
+
+ To remove a check constraint from one table only:
+
+ALTER TABLE ONLY distributors DROP CONSTRAINT zipchk;
+
+ (The check constraint remains in place for any child tables.)
+
+ To add a foreign key constraint to a table:
+
+ALTER TABLE distributors ADD CONSTRAINT distfk FOREIGN KEY (address) REFERENCES addresses (address);
+
+
+ To add a foreign key constraint to a table with the least impact on other work:
+
+ALTER TABLE distributors ADD CONSTRAINT distfk FOREIGN KEY (address) REFERENCES addresses (address) NOT VALID;
+ALTER TABLE distributors VALIDATE CONSTRAINT distfk;
+
+
+ To add a (multicolumn) unique constraint to a table:
+
+ALTER TABLE distributors ADD CONSTRAINT dist_id_zipcode_key UNIQUE (dist_id, zipcode);
+
+
+ To add an automatically named primary key constraint to a table, noting
+ that a table can only ever have one primary key:
+
+ALTER TABLE distributors ADD PRIMARY KEY (dist_id);
+
+
+ To move a table to a different tablespace:
+
+ALTER TABLE distributors SET TABLESPACE fasttablespace;
+
+
+ To move a table to a different schema:
+
+ALTER TABLE myschema.distributors SET SCHEMA yourschema;
+
+
+ To recreate a primary key constraint, without blocking updates while the
+ index is rebuilt:
+
+CREATE UNIQUE INDEX CONCURRENTLY dist_id_temp_idx ON distributors (dist_id);
+ALTER TABLE distributors DROP CONSTRAINT distributors_pkey,
+ ADD CONSTRAINT distributors_pkey PRIMARY KEY USING INDEX dist_id_temp_idx;
+
+ To attach a partition to a range-partitioned table:
+
+ALTER TABLE measurement
+ ATTACH PARTITION measurement_y2016m07 FOR VALUES FROM ('2016-07-01') TO ('2016-08-01');
+
+ To attach a partition to a list-partitioned table:
+
+ALTER TABLE cities
+ ATTACH PARTITION cities_ab FOR VALUES IN ('a', 'b');
+
+ To attach a partition to a hash-partitioned table:
+
+ALTER TABLE orders
+ ATTACH PARTITION orders_p4 FOR VALUES WITH (MODULUS 4, REMAINDER 3);
+
+ To attach a default partition to a partitioned table:
+
+ALTER TABLE cities
+ ATTACH PARTITION cities_partdef DEFAULT;
+
+ To detach a partition from a partitioned table:
+
+ALTER TABLE measurement
+ DETACH PARTITION measurement_y2015m12;
+
Compatibility
+ The forms ADD (without USING INDEX),
+ DROP [COLUMN], DROP IDENTITY, RESTART,
+ SET DEFAULT, SET DATA TYPE (without USING),
+ SET GENERATED, and SET sequence_option
+ conform with the SQL standard. The other forms are
+ PostgreSQL extensions of the SQL standard.
+ Also, the ability to specify more than one manipulation in a single
+ ALTER TABLE command is an extension.
+
+ ALTER TABLE DROP COLUMN can be used to drop the only
+ column of a table, leaving a zero-column table. This is an
+ extension of SQL, which disallows zero-column tables.
+
ALTER TABLESPACE
ALTER TABLESPACE — change the definition of a tablespace
Synopsis
+ALTER TABLESPACE name RENAME TO new_name
+ALTER TABLESPACE name OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+ALTER TABLESPACE name SET ( tablespace_option = value [, ... ] )
+ALTER TABLESPACE name RESET ( tablespace_option [, ... ] )
+
Description
+ ALTER TABLESPACE can be used to change the definition of
+ a tablespace.
+
+ You must own the tablespace to change the definition of a tablespace.
+ To alter the owner, you must also be able to SET ROLE
+ to the new owning role.
+ (Note that superusers have these privileges automatically.)
+
Parameters
name
+ The name of an existing tablespace.
+
new_name
+ The new name of the tablespace. The new name cannot
+ begin with pg_, as such names
+ are reserved for system tablespaces.
+
new_owner
+ The new owner of the tablespace.
+
tablespace_option
+ A tablespace parameter to be set or reset. Currently, the only
+ available parameters are seq_page_cost,
+ random_page_cost, effective_io_concurrency
+ and maintenance_io_concurrency.
+ Setting these values for a particular tablespace will override the
+ planner's usual estimate of the cost of reading pages from tables in
+ that tablespace, and the executor's prefetching behavior, as established
+ by the configuration parameters of the
+ same name (see seq_page_cost,
+ random_page_cost,
+ effective_io_concurrency,
+ maintenance_io_concurrency). This may be useful if
+ one tablespace is located on a disk which is faster or slower than the
+ remainder of the I/O subsystem.
+
Examples
+ Rename tablespace index_space to fast_raid:
+
+ALTER TABLESPACE index_space RENAME TO fast_raid;
+
+
+ Change the owner of tablespace index_space:
+
+ALTER TABLESPACE index_space OWNER TO mary;
+
Compatibility
+ There is no ALTER TABLESPACE statement in
+ the SQL standard.
+
ALTER TRIGGER
ALTER TRIGGER — change the definition of a trigger
Synopsis
+ALTER TRIGGER name ON table_name RENAME TO new_name
+ALTER TRIGGER name ON table_name [ NO ] DEPENDS ON EXTENSION extension_name
+
Description
+ ALTER TRIGGER changes properties of an existing
+ trigger.
+
+ The RENAME clause changes the name of
+ the given trigger without otherwise changing the trigger
+ definition.
+ If the table that the trigger is on is a partitioned table,
+ then corresponding clone triggers in the partitions are
+ renamed too.
+
+ The DEPENDS ON EXTENSION clause marks
+ the trigger as dependent on an extension, such that if the extension is
+ dropped, the trigger will automatically be dropped as well.
+
+ You must own the table on which the trigger acts to be allowed to change its properties.
+
Parameters
name
+ The name of an existing trigger to alter.
+
table_name
+ The name of the table on which this trigger acts.
+
new_name
+ The new name for the trigger.
+
extension_name
+ The name of the extension that the trigger is to depend on (or no longer
+ dependent on, if NO is specified). A trigger
+ that's marked as dependent on an extension is automatically dropped when
+ the extension is dropped.
+
Notes
+ The ability to temporarily enable or disable a trigger is provided by
+ ALTER TABLE, not by
+ ALTER TRIGGER, because ALTER TRIGGER has no
+ convenient way to express the option of enabling or disabling all of
+ a table's triggers at once.
+
Examples
+ To rename an existing trigger:
+
+ALTER TRIGGER emp_stamp ON emp RENAME TO emp_track_chgs;
+
+ To mark a trigger as being dependent on an extension:
+
+ALTER TRIGGER emp_stamp ON emp DEPENDS ON EXTENSION emplib;
+
Compatibility
+ ALTER TRIGGER is a PostgreSQL
+ extension of the SQL standard.
+
ALTER TEXT SEARCH CONFIGURATION
ALTER TEXT SEARCH CONFIGURATION — change the definition of a text search configuration
Synopsis
+ALTER TEXT SEARCH CONFIGURATION name
+ ADD MAPPING FOR token_type [, ... ] WITH dictionary_name [, ... ]
+ALTER TEXT SEARCH CONFIGURATION name
+ ALTER MAPPING FOR token_type [, ... ] WITH dictionary_name [, ... ]
+ALTER TEXT SEARCH CONFIGURATION name
+ ALTER MAPPING REPLACE old_dictionary WITH new_dictionary
+ALTER TEXT SEARCH CONFIGURATION name
+ ALTER MAPPING FOR token_type [, ... ] REPLACE old_dictionary WITH new_dictionary
+ALTER TEXT SEARCH CONFIGURATION name
+ DROP MAPPING [ IF EXISTS ] FOR token_type [, ... ]
+ALTER TEXT SEARCH CONFIGURATION name RENAME TO new_name
+ALTER TEXT SEARCH CONFIGURATION name OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+ALTER TEXT SEARCH CONFIGURATION name SET SCHEMA new_schema
+
Description
+ ALTER TEXT SEARCH CONFIGURATION changes the definition of
+ a text search configuration. You can modify
+ its mappings from token types to dictionaries,
+ or change the configuration's name or owner.
+
+ You must be the owner of the configuration to use
+ ALTER TEXT SEARCH CONFIGURATION.
+
Parameters
name
+ The name (optionally schema-qualified) of an existing text search
+ configuration.
+
token_type
+ The name of a token type that is emitted by the configuration's
+ parser.
+
dictionary_name
+ The name of a text search dictionary to be consulted for the
+ specified token type(s). If multiple dictionaries are listed,
+ they are consulted in the specified order.
+
old_dictionary
+ The name of a text search dictionary to be replaced in the mapping.
+
new_dictionary
+ The name of a text search dictionary to be substituted for
+ old_dictionary.
+
new_name
+ The new name of the text search configuration.
+
new_owner
+ The new owner of the text search configuration.
+
new_schema
+ The new schema for the text search configuration.
+
+ The ADD MAPPING FOR form installs a list of dictionaries to be
+ consulted for the specified token type(s); it is an error if there is
+ already a mapping for any of the token types.
+ The ALTER MAPPING FOR form does the same, but first removing
+ any existing mapping for those token types.
+ The ALTER MAPPING REPLACE forms substitute new_dictionary for old_dictionary anywhere the latter appears.
+ This is done for only the specified token types when FOR
+ appears, or for all mappings of the configuration when it doesn't.
+ The DROP MAPPING form removes all dictionaries for the
+ specified token type(s), causing tokens of those types to be ignored
+ by the text search configuration. It is an error if there is no mapping
+ for the token types, unless IF EXISTS appears.
+
Examples
+ The following example replaces the english dictionary
+ with the swedish dictionary anywhere that english
+ is used within my_config.
+
+ALTER TEXT SEARCH CONFIGURATION my_config
+ ALTER MAPPING REPLACE english WITH swedish;
+
Compatibility
+ There is no ALTER TEXT SEARCH CONFIGURATION statement in
+ the SQL standard.
+
ALTER TEXT SEARCH DICTIONARY
ALTER TEXT SEARCH DICTIONARY — change the definition of a text search dictionary
Synopsis
+ALTER TEXT SEARCH DICTIONARY name (
+ option [ = value ] [, ... ]
+)
+ALTER TEXT SEARCH DICTIONARY name RENAME TO new_name
+ALTER TEXT SEARCH DICTIONARY name OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+ALTER TEXT SEARCH DICTIONARY name SET SCHEMA new_schema
+
Description
+ ALTER TEXT SEARCH DICTIONARY changes the definition of
+ a text search dictionary. You can change the dictionary's
+ template-specific options, or change the dictionary's name or owner.
+
+ You must be the owner of the dictionary to use
+ ALTER TEXT SEARCH DICTIONARY.
+
Parameters
name
+ The name (optionally schema-qualified) of an existing text search
+ dictionary.
+
option
+ The name of a template-specific option to be set for this dictionary.
+
value
+ The new value to use for a template-specific option.
+ If the equal sign and value are omitted, then any previous
+ setting for the option is removed from the dictionary,
+ allowing the default to be used.
+
new_name
+ The new name of the text search dictionary.
+
new_owner
+ The new owner of the text search dictionary.
+
new_schema
+ The new schema for the text search dictionary.
+
+ Template-specific options can appear in any order.
+
Examples
+ The following example command changes the stopword list
+ for a Snowball-based dictionary. Other parameters remain unchanged.
+
+ALTER TEXT SEARCH DICTIONARY my_dict ( StopWords = newrussian );
+
+ The following example command changes the language option to dutch,
+ and removes the stopword option entirely.
+
+ALTER TEXT SEARCH DICTIONARY my_dict ( language = dutch, StopWords );
+
+ The following example command “updates” the dictionary's
+ definition without actually changing anything.
+
+
+ALTER TEXT SEARCH DICTIONARY my_dict ( dummy );
+
+
+ (The reason this works is that the option removal code doesn't complain
+ if there is no such option.) This trick is useful when changing
+ configuration files for the dictionary: the ALTER will
+ force existing database sessions to re-read the configuration files,
+ which otherwise they would never do if they had read them earlier.
+
Compatibility
+ There is no ALTER TEXT SEARCH DICTIONARY statement in
+ the SQL standard.
+
ALTER TEXT SEARCH PARSER
ALTER TEXT SEARCH PARSER — change the definition of a text search parser
Synopsis
+ALTER TEXT SEARCH PARSER name RENAME TO new_name
+ALTER TEXT SEARCH PARSER name SET SCHEMA new_schema
+
Description
+ ALTER TEXT SEARCH PARSER changes the definition of
+ a text search parser. Currently, the only supported functionality
+ is to change the parser's name.
+
+ You must be a superuser to use ALTER TEXT SEARCH PARSER.
+
Parameters
name
+ The name (optionally schema-qualified) of an existing text search parser.
+
new_name
+ The new name of the text search parser.
+
new_schema
+ The new schema for the text search parser.
+
Compatibility
+ There is no ALTER TEXT SEARCH PARSER statement in
+ the SQL standard.
+
ALTER TEXT SEARCH TEMPLATE
ALTER TEXT SEARCH TEMPLATE — change the definition of a text search template
Synopsis
+ALTER TEXT SEARCH TEMPLATE name RENAME TO new_name
+ALTER TEXT SEARCH TEMPLATE name SET SCHEMA new_schema
+
Description
+ ALTER TEXT SEARCH TEMPLATE changes the definition of
+ a text search template. Currently, the only supported functionality
+ is to change the template's name.
+
+ You must be a superuser to use ALTER TEXT SEARCH TEMPLATE.
+
Parameters
name
+ The name (optionally schema-qualified) of an existing text search template.
+
new_name
+ The new name of the text search template.
+
new_schema
+ The new schema for the text search template.
+
Compatibility
+ There is no ALTER TEXT SEARCH TEMPLATE statement in
+ the SQL standard.
+
ALTER TYPE
ALTER TYPE —
+ change the definition of a type
+
Synopsis
+ALTER TYPE name OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+ALTER TYPE name RENAME TO new_name
+ALTER TYPE name SET SCHEMA new_schema
+ALTER TYPE name RENAME ATTRIBUTE attribute_name TO new_attribute_name [ CASCADE | RESTRICT ]
+ALTER TYPE name action [, ... ]
+ALTER TYPE name ADD VALUE [ IF NOT EXISTS ] new_enum_value [ { BEFORE | AFTER } neighbor_enum_value ]
+ALTER TYPE name RENAME VALUE existing_enum_value TO new_enum_value
+ALTER TYPE name SET ( property = value [, ... ] )
+
+where action is one of:
+
+ ADD ATTRIBUTE attribute_name data_type [ COLLATE collation ] [ CASCADE | RESTRICT ]
+ DROP ATTRIBUTE [ IF EXISTS ] attribute_name [ CASCADE | RESTRICT ]
+ ALTER ATTRIBUTE attribute_name [ SET DATA ] TYPE data_type [ COLLATE collation ] [ CASCADE | RESTRICT ]
+
Description
+ ALTER TYPE changes the definition of an existing type.
+ There are several subforms:
+
+
OWNER
+ This form changes the owner of the type.
+
RENAME
+ This form changes the name of the type.
+
SET SCHEMA
+ This form moves the type into another schema.
+
RENAME ATTRIBUTE
+ This form is only usable with composite types.
+ It changes the name of an individual attribute of the type.
+
ADD ATTRIBUTE
+ This form adds a new attribute to a composite type, using the same syntax as
+ CREATE TYPE.
+
DROP ATTRIBUTE [ IF EXISTS ]
+ This form drops an attribute from a composite type.
+ If IF EXISTS is specified and the attribute
+ does not exist, no error is thrown. In this case a notice
+ is issued instead.
+
ALTER ATTRIBUTE ... SET DATA TYPE
+ This form changes the type of an attribute of a composite type.
+
ADD VALUE [ IF NOT EXISTS ] [ BEFORE | AFTER ]
+ This form adds a new value to an enum type. The new value's place in
+ the enum's ordering can be specified as being BEFORE
+ or AFTER one of the existing values. Otherwise,
+ the new item is added at the end of the list of values.
+
+ If IF NOT EXISTS is specified, it is not an error if
+ the type already contains the new value: a notice is issued but no other
+ action is taken. Otherwise, an error will occur if the new value is
+ already present.
+
RENAME VALUE
+ This form renames a value of an enum type.
+ The value's place in the enum's ordering is not affected.
+ An error will occur if the specified value is not present or the new
+ name is already present.
+
-
+
SET ( property = value [, ... ] )
+
+ This form is only applicable to base types. It allows adjustment of a
+ subset of the base-type properties that can be set in CREATE
+ TYPE. Specifically, these properties can be changed:
+
+ RECEIVE can be set to the name of a binary input
+ function, or NONE to remove the type's binary
+ input function. Using this option requires superuser privilege.
+
+ SEND can be set to the name of a binary output
+ function, or NONE to remove the type's binary
+ output function. Using this option requires superuser privilege.
+
+ TYPMOD_IN can be set to the name of a type
+ modifier input function, or NONE to remove the
+ type's type modifier input function. Using this option requires
+ superuser privilege.
+
+ TYPMOD_OUT can be set to the name of a type
+ modifier output function, or NONE to remove the
+ type's type modifier output function. Using this option requires
+ superuser privilege.
+
+ ANALYZE can be set to the name of a type-specific
+ statistics collection function, or NONE to remove
+ the type's statistics collection function. Using this option
+ requires superuser privilege.
+
+ SUBSCRIPT can be set to the name of a type-specific
+ subscripting handler function, or NONE to remove
+ the type's subscripting handler function. Using this option
+ requires superuser privilege.
+
+ STORAGE
+ can be set to plain,
+ extended, external,
+ or main (see Section 73.2 for
+ more information about what these mean). However, changing
+ from plain to another setting requires superuser
+ privilege (because it requires that the type's C functions all be
+ TOAST-ready), and changing to plain from another
+ setting is not allowed at all (since the type may already have
+ TOASTed values present in the database). Note that changing this
+ option doesn't by itself change any stored data, it just sets the
+ default TOAST strategy to be used for table columns created in the
+ future. See ALTER TABLE to change the TOAST
+ strategy for existing table columns.
+
+ See CREATE TYPE for more details about these
+ type properties. Note that where appropriate, a change in these
+ properties for a base type will be propagated automatically to domains
+ based on that type.
+
+
+ The ADD ATTRIBUTE, DROP
+ ATTRIBUTE, and ALTER ATTRIBUTE actions
+ can be combined into a list of multiple alterations to apply in
+ parallel. For example, it is possible to add several attributes
+ and/or alter the type of several attributes in a single command.
+
+ You must own the type to use ALTER TYPE.
+ To change the schema of a type, you must also have
+ CREATE privilege on the new schema.
+ To alter the owner, you must be able to SET ROLE to the
+ new owning role, and that role must have CREATE
+ privilege on the type's schema.
+ (These restrictions enforce that altering the owner
+ doesn't do anything you couldn't do by dropping and recreating the type.
+ However, a superuser can alter ownership of any type anyway.)
+ To add an attribute or alter an attribute type, you must also
+ have USAGE privilege on the attribute's data type.
+
Parameters
+
name
+ The name (possibly schema-qualified) of an existing type to
+ alter.
+
new_name
+ The new name for the type.
+
new_owner
+ The user name of the new owner of the type.
+
new_schema
+ The new schema for the type.
+
attribute_name
+ The name of the attribute to add, alter, or drop.
+
new_attribute_name
+ The new name of the attribute to be renamed.
+
data_type
+ The data type of the attribute to add, or the new type of the
+ attribute to alter.
+
new_enum_value
+ The new value to be added to an enum type's list of values,
+ or the new name to be given to an existing value.
+ Like all enum literals, it needs to be quoted.
+
neighbor_enum_value
+ The existing enum value that the new value should be added immediately
+ before or after in the enum type's sort ordering.
+ Like all enum literals, it needs to be quoted.
+
existing_enum_value
+ The existing enum value that should be renamed.
+ Like all enum literals, it needs to be quoted.
+
property
+ The name of a base-type property to be modified; see above for
+ possible values.
+
CASCADE
+ Automatically propagate the operation to typed tables of the
+ type being altered, and their descendants.
+
RESTRICT
+ Refuse the operation if the type being altered is the type of a
+ typed table. This is the default.
+
+
Notes
+ If ALTER TYPE ... ADD VALUE (the form that adds a new
+ value to an enum type) is executed inside a transaction block, the new
+ value cannot be used until after the transaction has been committed.
+
+ Comparisons involving an added enum value will sometimes be slower than
+ comparisons involving only original members of the enum type. This will
+ usually only occur if BEFORE or AFTER
+ is used to set the new value's sort position somewhere other than at the
+ end of the list. However, sometimes it will happen even though the new
+ value is added at the end (this occurs if the OID counter “wrapped
+ around” since the original creation of the enum type). The slowdown is
+ usually insignificant; but if it matters, optimal performance can be
+ regained by dropping and recreating the enum type, or by dumping and
+ restoring the database.
+
Examples
+ To rename a data type:
+
+ALTER TYPE electronic_mail RENAME TO email;
+
+
+ To change the owner of the type email
+ to joe:
+
+ALTER TYPE email OWNER TO joe;
+
+
+ To change the schema of the type email
+ to customers:
+
+ALTER TYPE email SET SCHEMA customers;
+
+
+ To add a new attribute to a composite type:
+
+ALTER TYPE compfoo ADD ATTRIBUTE f3 int;
+
+
+ To add a new value to an enum type in a particular sort position:
+
+ALTER TYPE colors ADD VALUE 'orange' AFTER 'red';
+
+
+ To rename an enum value:
+
+ALTER TYPE colors RENAME VALUE 'purple' TO 'mauve';
+
+
+ To create binary I/O functions for an existing base type:
+
+CREATE FUNCTION mytypesend(mytype) RETURNS bytea ...;
+CREATE FUNCTION mytyperecv(internal, oid, integer) RETURNS mytype ...;
+ALTER TYPE mytype SET (
+ SEND = mytypesend,
+ RECEIVE = mytyperecv
+);
+
Compatibility
+ The variants to add and drop attributes are part of the SQL
+ standard; the other variants are PostgreSQL extensions.
+
ALTER USER
ALTER USER — change a database role
Synopsis
+ALTER USER role_specification [ WITH ] option [ ... ]
+
+where option can be:
+
+ SUPERUSER | NOSUPERUSER
+ | CREATEDB | NOCREATEDB
+ | CREATEROLE | NOCREATEROLE
+ | INHERIT | NOINHERIT
+ | LOGIN | NOLOGIN
+ | REPLICATION | NOREPLICATION
+ | BYPASSRLS | NOBYPASSRLS
+ | CONNECTION LIMIT connlimit
+ | [ ENCRYPTED ] PASSWORD 'password' | PASSWORD NULL
+ | VALID UNTIL 'timestamp'
+
+ALTER USER name RENAME TO new_name
+
+ALTER USER { role_specification | ALL } [ IN DATABASE database_name ] SET configuration_parameter { TO | = } { value | DEFAULT }
+ALTER USER { role_specification | ALL } [ IN DATABASE database_name ] SET configuration_parameter FROM CURRENT
+ALTER USER { role_specification | ALL } [ IN DATABASE database_name ] RESET configuration_parameter
+ALTER USER { role_specification | ALL } [ IN DATABASE database_name ] RESET ALL
+
+where role_specification can be:
+
+ role_name
+ | CURRENT_ROLE
+ | CURRENT_USER
+ | SESSION_USER
+
Description
+ ALTER USER is now an alias for
+ ALTER ROLE.
+
Compatibility
+ The ALTER USER statement is a
+ PostgreSQL extension. The SQL standard
+ leaves the definition of users to the implementation.
+
ALTER USER MAPPING
ALTER USER MAPPING — change the definition of a user mapping
Synopsis
+ALTER USER MAPPING FOR { user_name | USER | CURRENT_ROLE | CURRENT_USER | SESSION_USER | PUBLIC }
+ SERVER server_name
+ OPTIONS ( [ ADD | SET | DROP ] option ['value'] [, ... ] )
+Description
+ ALTER USER MAPPING changes the definition of a
+ user mapping.
+
+ The owner of a foreign server can alter user mappings for that
+ server for any user. Also, a user can alter a user mapping for
+ their own user name if USAGE privilege on the server has
+ been granted to the user.
+
Parameters
user_name
+ User name of the mapping. CURRENT_ROLE, CURRENT_USER,
+ and USER match the name of the current
+ user. PUBLIC is used to match all present and future
+ user names in the system.
+
server_name
+ Server name of the user mapping.
+
OPTIONS ( [ ADD | SET | DROP ] option ['value'] [, ... ] )
+ Change options for the user mapping. The new options override
+ any previously specified
+ options. ADD, SET, and DROP
+ specify the action to be performed. ADD is assumed
+ if no operation is explicitly specified. Option names must be
+ unique; options are also validated by the server's foreign-data
+ wrapper.
+
Examples
+ Change the password for user mapping bob, server foo:
+
+ALTER USER MAPPING FOR bob SERVER foo OPTIONS (SET password 'public');
+
Compatibility
+ ALTER USER MAPPING conforms to ISO/IEC 9075-9
+ (SQL/MED). There is a subtle syntax issue: The standard omits
+ the FOR key word. Since both CREATE
+ USER MAPPING and DROP USER MAPPING use
+ FOR in analogous positions, and IBM DB2 (being
+ the other major SQL/MED implementation) also requires it
+ for ALTER USER MAPPING, PostgreSQL diverges from
+ the standard here in the interest of consistency and
+ interoperability.
+
ALTER VIEW
ALTER VIEW — change the definition of a view
Synopsis
+ALTER VIEW [ IF EXISTS ] name ALTER [ COLUMN ] column_name SET DEFAULT expression
+ALTER VIEW [ IF EXISTS ] name ALTER [ COLUMN ] column_name DROP DEFAULT
+ALTER VIEW [ IF EXISTS ] name OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+ALTER VIEW [ IF EXISTS ] name RENAME [ COLUMN ] column_name TO new_column_name
+ALTER VIEW [ IF EXISTS ] name RENAME TO new_name
+ALTER VIEW [ IF EXISTS ] name SET SCHEMA new_schema
+ALTER VIEW [ IF EXISTS ] name SET ( view_option_name [= view_option_value] [, ... ] )
+ALTER VIEW [ IF EXISTS ] name RESET ( view_option_name [, ... ] )
+
Description
+ ALTER VIEW changes various auxiliary properties
+ of a view. (If you want to modify the view's defining query,
+ use CREATE OR REPLACE VIEW.)
+
+ You must own the view to use ALTER VIEW.
+ To change a view's schema, you must also have CREATE
+ privilege on the new schema.
+ To alter the owner, you must be able to SET ROLE to the
+ new owning role, and that role must have CREATE
+ privilege on the view's schema.
+ (These restrictions enforce that altering the owner
+ doesn't do anything you couldn't do by dropping and recreating the view.
+ However, a superuser can alter ownership of any view anyway.)
+
Parameters
name
+ The name (optionally schema-qualified) of an existing view.
+
column_name
+ Name of an existing column.
+
new_column_name
+ New name for an existing column.
+
IF EXISTS
+ Do not throw an error if the view does not exist. A notice is issued
+ in this case.
+
SET/DROP DEFAULT
+ These forms set or remove the default value for a column.
+ A view column's default value is substituted into any
+ INSERT or UPDATE command whose target is the
+ view, before applying any rules or triggers for the view. The view's
+ default will therefore take precedence over any default values from
+ underlying relations.
+
new_owner
+ The user name of the new owner of the view.
+
new_name
+ The new name for the view.
+
new_schema
+ The new schema for the view.
+
SET ( view_option_name [= view_option_value] [, ... ] )
RESET ( view_option_name [, ... ] )
+ Sets or resets a view option. Currently supported options are:
+
check_option (enum)
+ Changes the check option of the view. The value must
+ be local or cascaded.
+
security_barrier (boolean)
+ Changes the security-barrier property of the view. The value must
+ be a Boolean value, such as true
+ or false.
+
security_invoker (boolean)
+ Changes the security-invoker property of the view. The value must
+ be a Boolean value, such as true
+ or false.
+
Notes
+ For historical reasons, ALTER TABLE can be used with
+ views too; but the only variants of ALTER TABLE
+ that are allowed with views are equivalent to the ones shown above.
+
Examples
+ To rename the view foo to
+ bar:
+
+ALTER VIEW foo RENAME TO bar;
+
+
+ To attach a default column value to an updatable view:
+
+CREATE TABLE base_table (id int, ts timestamptz);
+CREATE VIEW a_view AS SELECT * FROM base_table;
+ALTER VIEW a_view ALTER COLUMN ts SET DEFAULT now();
+INSERT INTO base_table(id) VALUES(1); -- ts will receive a NULL
+INSERT INTO a_view(id) VALUES(2); -- ts will receive the current time
+
Compatibility
+ ALTER VIEW is a PostgreSQL
+ extension of the SQL standard.
+
ANALYZE
ANALYZE — collect statistics about a database
Synopsis
+ANALYZE [ ( option [, ...] ) ] [ table_and_columns [, ...] ]
+ANALYZE [ VERBOSE ] [ table_and_columns [, ...] ]
+
+where option can be one of:
+
+ VERBOSE [ boolean ]
+ SKIP_LOCKED [ boolean ]
+ BUFFER_USAGE_LIMIT size
+
+and table_and_columns is:
+
+ table_name [ ( column_name [, ...] ) ]
+
Description
+ ANALYZE collects statistics about the contents
+ of tables in the database, and stores the results in the pg_statistic
+ system catalog. Subsequently, the query planner uses these
+ statistics to help determine the most efficient execution plans for
+ queries.
+
+ Without a table_and_columns
+ list, ANALYZE processes every table and materialized view
+ in the current database that the current user has permission to analyze.
+ With a list, ANALYZE processes only those table(s).
+ It is further possible to give a list of column names for a table,
+ in which case only the statistics for those columns are collected.
+
+ When the option list is surrounded by parentheses, the options can be
+ written in any order. The parenthesized syntax was added in
+ PostgreSQL 11; the unparenthesized syntax
+ is deprecated.
+
Parameters
VERBOSE
+ Enables display of progress messages.
+
SKIP_LOCKED
+ Specifies that ANALYZE should not wait for any
+ conflicting locks to be released when beginning work on a relation:
+ if a relation cannot be locked immediately without waiting, the relation
+ is skipped. Note that even with this option, ANALYZE
+ may still block when opening the relation's indexes or when acquiring
+ sample rows from partitions, table inheritance children, and some
+ types of foreign tables. Also, while ANALYZE
+ ordinarily processes all partitions of specified partitioned tables,
+ this option will cause ANALYZE to skip all
+ partitions if there is a conflicting lock on the partitioned table.
+
BUFFER_USAGE_LIMIT
+ Specifies the
+ Buffer Access Strategy
+ ring buffer size for ANALYZE. This size is used to
+ calculate the number of shared buffers which will be reused as part of
+ this strategy. 0 disables use of a
+ Buffer Access Strategy. When this option is not
+ specified, ANALYZE uses the value from
+ vacuum_buffer_usage_limit. Higher settings can
+ allow ANALYZE to run more quickly, but having too
+ large a setting may cause too many other useful pages to be evicted from
+ shared buffers. The minimum value is 128 kB and the
+ maximum value is 16 GB.
+
boolean
+ Specifies whether the selected option should be turned on or off.
+ You can write TRUE, ON, or
+ 1 to enable the option, and FALSE,
+ OFF, or 0 to disable it. The
+ boolean value can also
+ be omitted, in which case TRUE is assumed.
+
size
+ Specifies an amount of memory in kilobytes. Sizes may also be specified
+ as a string containing the numerical size followed by any one of the
+ following memory units: B (bytes),
+ kB (kilobytes), MB (megabytes),
+ GB (gigabytes), or TB (terabytes).
+
table_name
+ The name (possibly schema-qualified) of a specific table to
+ analyze. If omitted, all regular tables, partitioned tables, and
+ materialized views in the current database are analyzed (but not
+ foreign tables). If the specified table is a partitioned table, both the
+ inheritance statistics of the partitioned table as a whole and
+ statistics of the individual partitions are updated.
+
column_name
+ The name of a specific column to analyze. Defaults to all columns.
+
Outputs
+ When VERBOSE is specified, ANALYZE emits
+ progress messages to indicate which table is currently being
+ processed. Various statistics about the tables are printed as well.
+
Notes
+ To analyze a table, one must ordinarily be the table's owner or a
+ superuser. However, database owners are allowed to
+ analyze all tables in their databases, except shared catalogs.
+ (The restriction for shared catalogs means that a true database-wide
+ ANALYZE can only be performed by a superuser.)
+ ANALYZE will skip over any tables that the calling user
+ does not have permission to analyze.
+
+ Foreign tables are analyzed only when explicitly selected. Not all
+ foreign data wrappers support ANALYZE. If the table's
+ wrapper does not support ANALYZE, the command prints a
+ warning and does nothing.
+
+ In the default PostgreSQL configuration,
+ the autovacuum daemon (see Section 25.1.6)
+ takes care of automatic analyzing of tables when they are first loaded
+ with data, and as they change throughout regular operation.
+ When autovacuum is disabled,
+ it is a good idea to run ANALYZE periodically, or
+ just after making major changes in the contents of a table. Accurate
+ statistics will help the planner to choose the most appropriate query
+ plan, and thereby improve the speed of query processing. A common
+ strategy for read-mostly databases is to run VACUUM
+ and ANALYZE once a day during a low-usage time of day.
+ (This will not be sufficient if there is heavy update activity.)
+
+ ANALYZE
+ requires only a read lock on the target table, so it can run in
+ parallel with other activity on the table.
+
+ The statistics collected by ANALYZE usually
+ include a list of some of the most common values in each column and
+ a histogram showing the approximate data distribution in each
+ column. One or both of these can be omitted if
+ ANALYZE deems them uninteresting (for example,
+ in a unique-key column, there are no common values) or if the
+ column data type does not support the appropriate operators. There
+ is more information about the statistics in Chapter 25.
+
+ For large tables, ANALYZE takes a random sample
+ of the table contents, rather than examining every row. This
+ allows even very large tables to be analyzed in a small amount of
+ time. Note, however, that the statistics are only approximate, and
+ will change slightly each time ANALYZE is run,
+ even if the actual table contents did not change. This might result
+ in small changes in the planner's estimated costs shown by
+ EXPLAIN.
+ In rare situations, this non-determinism will cause the planner's
+ choices of query plans to change after ANALYZE is run.
+ To avoid this, raise the amount of statistics collected by
+ ANALYZE, as described below.
+
+ The extent of analysis can be controlled by adjusting the
+ default_statistics_target configuration variable, or
+ on a column-by-column basis by setting the per-column statistics
+ target with ALTER TABLE ... ALTER COLUMN ... SET
+ STATISTICS.
+ The target value sets the
+ maximum number of entries in the most-common-value list and the
+ maximum number of bins in the histogram. The default target value
+ is 100, but this can be adjusted up or down to trade off accuracy of
+ planner estimates against the time taken for
+ ANALYZE and the amount of space occupied in
+ pg_statistic. In particular, setting the
+ statistics target to zero disables collection of statistics for
+ that column. It might be useful to do that for columns that are
+ never used as part of the WHERE, GROUP BY,
+ or ORDER BY clauses of queries, since the planner will
+ have no use for statistics on such columns.
+
+ The largest statistics target among the columns being analyzed determines
+ the number of table rows sampled to prepare the statistics. Increasing
+ the target causes a proportional increase in the time and space needed
+ to do ANALYZE.
+
+ One of the values estimated by ANALYZE is the number of
+ distinct values that appear in each column. Because only a subset of the
+ rows are examined, this estimate can sometimes be quite inaccurate, even
+ with the largest possible statistics target. If this inaccuracy leads to
+ bad query plans, a more accurate value can be determined manually and then
+ installed with
+ ALTER TABLE ... ALTER COLUMN ... SET (n_distinct = ...).
+
+ If the table being analyzed has inheritance children,
+ ANALYZE gathers two sets of statistics: one on the rows
+ of the parent table only, and a second including rows of both the parent
+ table and all of its children. This second set of statistics is needed when
+ planning queries that process the inheritance tree as a whole. The child
+ tables themselves are not individually analyzed in this case.
+ The autovacuum daemon, however, will only consider inserts or
+ updates on the parent table itself when deciding whether to trigger an
+ automatic analyze for that table. If that table is rarely inserted into
+ or updated, the inheritance statistics will not be up to date unless you
+ run ANALYZE manually.
+
+ For partitioned tables, ANALYZE gathers statistics by
+ sampling rows from all partitions; in addition, it will recurse into each
+ partition and update its statistics. Each leaf partition is analyzed only
+ once, even with multi-level partitioning. No statistics are collected for
+ only the parent table (without data from its partitions), because with
+ partitioning it's guaranteed to be empty.
+
+ The autovacuum daemon does not process partitioned tables, nor does it
+ process inheritance parents if only the children are ever modified.
+ It is usually necessary to periodically run a manual
+ ANALYZE to keep the statistics of the table hierarchy
+ up to date.
+
+ If any child tables or partitions are foreign tables whose foreign
+ data wrappers do not support ANALYZE, those tables are
+ ignored while gathering inheritance statistics.
+
+ If the table being analyzed is completely empty, ANALYZE
+ will not record new statistics for that table. Any existing statistics
+ will be retained.
+
+ Each backend running ANALYZE will report its progress
+ in the pg_stat_progress_analyze view. See
+ Section 28.4.1 for details.
+
Compatibility
+ There is no ANALYZE statement in the SQL standard.
+
BEGIN
BEGIN — start a transaction block
Synopsis
+BEGIN [ WORK | TRANSACTION ] [ transaction_mode [, ...] ]
+
+where transaction_mode is one of:
+
+ ISOLATION LEVEL { SERIALIZABLE | REPEATABLE READ | READ COMMITTED | READ UNCOMMITTED }
+ READ WRITE | READ ONLY
+ [ NOT ] DEFERRABLE
+
Description
+ BEGIN initiates a transaction block, that is,
+ all statements after a BEGIN command will be
+ executed in a single transaction until an explicit COMMIT or ROLLBACK is given.
+ By default (without BEGIN),
+ PostgreSQL executes
+ transactions in “autocommit” mode, that is, each
+ statement is executed in its own transaction and a commit is
+ implicitly performed at the end of the statement (if execution was
+ successful, otherwise a rollback is done).
+
+ Statements are executed more quickly in a transaction block, because
+ transaction start/commit requires significant CPU and disk
+ activity. Execution of multiple statements inside a transaction is
+ also useful to ensure consistency when making several related changes:
+ other sessions will be unable to see the intermediate states
+ wherein not all the related updates have been done.
+
+ If the isolation level, read/write mode, or deferrable mode is specified, the new
+ transaction has those characteristics, as if
+ SET TRANSACTION
+ was executed.
+
Parameters
WORK
TRANSACTION
+ Optional key words. They have no effect.
+
+ Refer to SET TRANSACTION for information on the meaning
+ of the other parameters to this statement.
+
Notes
+ START TRANSACTION has the same functionality
+ as BEGIN.
+
+ Use COMMIT or
+ ROLLBACK
+ to terminate a transaction block.
+
+ Issuing BEGIN when already inside a transaction block will
+ provoke a warning message. The state of the transaction is not affected.
+ To nest transactions within a transaction block, use savepoints
+ (see SAVEPOINT).
+
+ For reasons of backwards compatibility, the commas between successive
+ transaction_modes can be
+ omitted.
+
Examples
+ To begin a transaction block:
+
+
+BEGIN;
+
Compatibility
+ BEGIN is a PostgreSQL
+ language extension. It is equivalent to the SQL-standard command
+ START TRANSACTION, whose reference page
+ contains additional compatibility information.
+
+ The DEFERRABLE
+ transaction_mode
+ is a PostgreSQL language extension.
+
+ Incidentally, the BEGIN key word is used for a
+ different purpose in embedded SQL. You are advised to be careful
+ about the transaction semantics when porting database applications.
+
CALL
CALL — invoke a procedure
Synopsis
+CALL name ( [ argument ] [, ...] )
+
Description
+ CALL executes a procedure.
+
+ If the procedure has any output parameters, then a result row will be
+ returned, containing the values of those parameters.
+
Parameters
name
+ The name (optionally schema-qualified) of the procedure.
+
argument
+ An argument expression for the procedure call.
+
+ Arguments can include parameter names, using the syntax
+ name => value
+ Arguments must be supplied for all procedure parameters that lack
+ defaults, including OUT parameters. However,
+ arguments matching OUT parameters are not evaluated,
+ so it's customary to just write NULL for them.
+ (Writing something else for an OUT parameter
+ might cause compatibility problems with
+ future PostgreSQL versions.)
+
Notes
+ The user must have EXECUTE privilege on the procedure in
+ order to be allowed to invoke it.
+
+ To call a function (not a procedure), use SELECT instead.
+
+ If CALL is executed in a transaction block, then the
+ called procedure cannot execute transaction control statements.
+ Transaction control statements are only allowed if CALL
+ is executed in its own transaction.
+
+ PL/pgSQL handles output parameters
+ in CALL commands differently;
+ see Section 43.6.3.
+
Examples
+CALL do_db_maintenance();
+
Compatibility
+ CALL conforms to the SQL standard,
+ except for the handling of output parameters. The standard
+ says that users should write variables to receive the values
+ of output parameters.
+
CHECKPOINT
CHECKPOINT — force a write-ahead log checkpoint
Description
+ A checkpoint is a point in the write-ahead log sequence at which
+ all data files have been updated to reflect the information in the
+ log. All data files will be flushed to disk. Refer to
+ Section 30.5 for more details about what happens
+ during a checkpoint.
+
+ The CHECKPOINT command forces an immediate
+ checkpoint when the command is issued, without waiting for a
+ regular checkpoint scheduled by the system (controlled by the settings in
+ Section 20.5.2).
+ CHECKPOINT is not intended for use during normal
+ operation.
+
+ If executed during recovery, the CHECKPOINT command
+ will force a restartpoint (see Section 30.5)
+ rather than writing a new checkpoint.
+
+ Only superusers or users with the privileges of
+ the pg_checkpoint
+ role can call CHECKPOINT.
+
Compatibility
+ The CHECKPOINT command is a
+ PostgreSQL language extension.
+
CLOSE
CLOSE — close a cursor
Synopsis
+CLOSE { name | ALL }
+Description
+ CLOSE frees the resources associated with an open cursor.
+ After the cursor is closed, no subsequent operations
+ are allowed on it. A cursor should be closed when it is
+ no longer needed.
+
+ Every non-holdable open cursor is implicitly closed when a
+ transaction is terminated by COMMIT or
+ ROLLBACK. A holdable cursor is implicitly
+ closed if the transaction that created it aborts via
+ ROLLBACK. If the creating transaction
+ successfully commits, the holdable cursor remains open until an
+ explicit CLOSE is executed, or the client
+ disconnects.
+
Parameters
name
+ The name of an open cursor to close.
+
ALL
+ Close all open cursors.
+
Notes
+ PostgreSQL does not have an explicit
+ OPEN cursor statement; a cursor is considered
+ open when it is declared. Use the
+ DECLARE
+ statement to declare a cursor.
+
+ You can see all available cursors by querying the pg_cursors system view.
+
+ If a cursor is closed after a savepoint which is later rolled back,
+ the CLOSE is not rolled back; that is, the cursor
+ remains closed.
+
Examples
+ Close the cursor liahona:
+
+CLOSE liahona;
+
Compatibility
+ CLOSE is fully conforming with the SQL
+ standard. CLOSE ALL is a PostgreSQL
+ extension.
+
CLUSTER
CLUSTER — cluster a table according to an index
Synopsis
+CLUSTER [VERBOSE] table_name [ USING index_name ]
+CLUSTER ( option [, ...] ) table_name [ USING index_name ]
+CLUSTER [VERBOSE]
+
+where option can be one of:
+
+ VERBOSE [ boolean ]
+
Description
+ CLUSTER instructs PostgreSQL
+ to cluster the table specified
+ by table_name
+ based on the index specified by
+ index_name. The index must
+ already have been defined on
+ table_name.
+
+ When a table is clustered, it is physically reordered
+ based on the index information. Clustering is a one-time operation:
+ when the table is subsequently updated, the changes are
+ not clustered. That is, no attempt is made to store new or
+ updated rows according to their index order. (If one wishes, one can
+ periodically recluster by issuing the command again. Also, setting
+ the table's fillfactor storage parameter to less than
+ 100% can aid in preserving cluster ordering during updates, since updated
+ rows are kept on the same page if enough space is available there.)
+
+ When a table is clustered, PostgreSQL
+ remembers which index it was clustered by. The form
+ CLUSTER table_name
+ reclusters the table using the same index as before. You can also
+ use the CLUSTER or SET WITHOUT CLUSTER
+ forms of ALTER TABLE to set the index to be used for
+ future cluster operations, or to clear any previous setting.
+
+ CLUSTER without a
+ table_name reclusters all the
+ previously-clustered tables in the current database that the calling user
+ owns, or all such tables if called by a superuser. This
+ form of CLUSTER cannot be executed inside a transaction
+ block.
+
+ When a table is being clustered, an ACCESS
+ EXCLUSIVE lock is acquired on it. This prevents any other
+ database operations (both reads and writes) from operating on the
+ table until the CLUSTER is finished.
+
Parameters
table_name
+ The name (possibly schema-qualified) of a table.
+
index_name
+ The name of an index.
+
VERBOSE
+ Prints a progress report as each table is clustered.
+
boolean
+ Specifies whether the selected option should be turned on or off.
+ You can write TRUE, ON, or
+ 1 to enable the option, and FALSE,
+ OFF, or 0 to disable it. The
+ boolean value can also
+ be omitted, in which case TRUE is assumed.
+
Notes
+ In cases where you are accessing single rows randomly
+ within a table, the actual order of the data in the
+ table is unimportant. However, if you tend to access some
+ data more than others, and there is an index that groups
+ them together, you will benefit from using CLUSTER.
+ If you are requesting a range of indexed values from a table, or a
+ single indexed value that has multiple rows that match,
+ CLUSTER will help because once the index identifies the
+ table page for the first row that matches, all other rows
+ that match are probably already on the same table page,
+ and so you save disk accesses and speed up the query.
+
+ CLUSTER can re-sort the table using either an index scan
+ on the specified index, or (if the index is a b-tree) a sequential
+ scan followed by sorting. It will attempt to choose the method that
+ will be faster, based on planner cost parameters and available statistical
+ information.
+
+ When an index scan is used, a temporary copy of the table is created that
+ contains the table data in the index order. Temporary copies of each
+ index on the table are created as well. Therefore, you need free space on
+ disk at least equal to the sum of the table size and the index sizes.
+
+ When a sequential scan and sort is used, a temporary sort file is
+ also created, so that the peak temporary space requirement is as much
+ as double the table size, plus the index sizes. This method is often
+ faster than the index scan method, but if the disk space requirement is
+ intolerable, you can disable this choice by temporarily setting enable_sort to off.
+
+ It is advisable to set maintenance_work_mem to
+ a reasonably large value (but not more than the amount of RAM you can
+ dedicate to the CLUSTER operation) before clustering.
+
+ Because the planner records statistics about the ordering of
+ tables, it is advisable to run ANALYZE
+ on the newly clustered table.
+ Otherwise, the planner might make poor choices of query plans.
+
+ Because CLUSTER remembers which indexes are clustered,
+ one can cluster the tables one wants clustered manually the first time,
+ then set up a periodic maintenance script that executes
+ CLUSTER without any parameters, so that the desired tables
+ are periodically reclustered.
+
+ Each backend running CLUSTER will report its progress
+ in the pg_stat_progress_cluster view. See
+ Section 28.4.2 for details.
+
+ Clustering a partitioned table clusters each of its partitions using the
+ partition of the specified partitioned index. When clustering a partitioned
+ table, the index may not be omitted. CLUSTER on a
+ partitioned table cannot be executed inside a transaction block.
+
Examples
+ Cluster the table employees on the basis of
+ its index employees_ind:
+
+CLUSTER employees USING employees_ind;
+
+
+ Cluster the employees table using the same
+ index that was used before:
+
+CLUSTER employees;
+
+
+ Cluster all tables in the database that have previously been clustered:
+
+CLUSTER;
+
Compatibility
+ There is no CLUSTER statement in the SQL standard.
+
+ The syntax
+
+CLUSTER index_name ON table_name
+
+ is also supported for compatibility with pre-8.3 PostgreSQL
+ versions.
+
+ This part contains reference information for the
+ SQL commands supported by
+ PostgreSQL. By “SQL” the
+ language in general is meant; information about the standards
+ conformance and compatibility of each command can be found on the
+ respective reference page.
+
COMMIT PREPARED
COMMIT PREPARED — commit a transaction that was earlier prepared for two-phase commit
Synopsis
+COMMIT PREPARED transaction_id
+
Description
+ COMMIT PREPARED commits a transaction that is in
+ prepared state.
+
Parameters
transaction_id
+ The transaction identifier of the transaction that is to be
+ committed.
+
Notes
+ To commit a prepared transaction, you must be either the same user that
+ executed the transaction originally, or a superuser. But you do not
+ have to be in the same session that executed the transaction.
+
+ This command cannot be executed inside a transaction block. The prepared
+ transaction is committed immediately.
+
+ All currently available prepared transactions are listed in the
+ pg_prepared_xacts
+ system view.
+
Examples
+ Commit the transaction identified by the transaction
+ identifier foobar:
+
+
+COMMIT PREPARED 'foobar';
+
Compatibility
+ COMMIT PREPARED is a
+ PostgreSQL extension. It is intended for use by
+ external transaction management systems, some of which are covered by
+ standards (such as X/Open XA), but the SQL side of those systems is not
+ standardized.
+
COMMIT
COMMIT — commit the current transaction
Synopsis
+COMMIT [ WORK | TRANSACTION ] [ AND [ NO ] CHAIN ]
+
Description
+ COMMIT commits the current transaction. All
+ changes made by the transaction become visible to others
+ and are guaranteed to be durable if a crash occurs.
+
Parameters
WORK
TRANSACTION #
+ Optional key words. They have no effect.
+
AND CHAIN #
+ If AND CHAIN is specified, a new transaction is
+ immediately started with the same transaction characteristics (see SET TRANSACTION) as the just finished one. Otherwise,
+ no new transaction is started.
+
Notes
+ Use ROLLBACK to
+ abort a transaction.
+
+ Issuing COMMIT when not inside a transaction does
+ no harm, but it will provoke a warning message. COMMIT AND
+ CHAIN when not inside a transaction is an error.
+
Examples
+ To commit the current transaction and make all changes permanent:
+
+COMMIT;
+
Compatibility
+ The command COMMIT conforms to the SQL standard. The
+ form COMMIT TRANSACTION is a PostgreSQL extension.
+
COPY
COPY — copy data between a file and a table
Synopsis
+COPY table_name [ ( column_name [, ...] ) ]
+ FROM { 'filename' | PROGRAM 'command' | STDIN }
+ [ [ WITH ] ( option [, ...] ) ]
+ [ WHERE condition ]
+
+COPY { table_name [ ( column_name [, ...] ) ] | ( query ) }
+ TO { 'filename' | PROGRAM 'command' | STDOUT }
+ [ [ WITH ] ( option [, ...] ) ]
+
+where option can be one of:
+
+ FORMAT format_name
+ FREEZE [ boolean ]
+ DELIMITER 'delimiter_character'
+ NULL 'null_string'
+ DEFAULT 'default_string'
+ HEADER [ boolean | MATCH ]
+ QUOTE 'quote_character'
+ ESCAPE 'escape_character'
+ FORCE_QUOTE { ( column_name [, ...] ) | * }
+ FORCE_NOT_NULL ( column_name [, ...] )
+ FORCE_NULL ( column_name [, ...] )
+ ENCODING 'encoding_name'
+
Description
+ COPY moves data between
+ PostgreSQL tables and standard file-system
+ files. COPY TO copies the contents of a table
+ to a file, while COPY FROM copies
+ data from a file to a table (appending the data to
+ whatever is in the table already). COPY TO
+ can also copy the results of a SELECT query.
+
+ If a column list is specified, COPY TO copies only
+ the data in the specified columns to the file. For COPY
+ FROM, each field in the file is inserted, in order, into the
+ specified column. Table columns not specified in the COPY
+ FROM column list will receive their default values.
+
+ COPY with a file name instructs the
+ PostgreSQL server to directly read from
+ or write to a file. The file must be accessible by the
+ PostgreSQL user (the user ID the server
+ runs as) and the name must be specified from the viewpoint of the
+ server. When PROGRAM is specified, the server
+ executes the given command and reads from the standard output of the
+ program, or writes to the standard input of the program. The command
+ must be specified from the viewpoint of the server, and be executable
+ by the PostgreSQL user. When
+ STDIN or STDOUT is
+ specified, data is transmitted via the connection between the
+ client and the server.
+
+ Each backend running COPY will report its progress
+ in the pg_stat_progress_copy view. See
+ Section 28.4.3 for details.
+
Parameters
table_name
+ The name (optionally schema-qualified) of an existing table.
+
column_name
+ An optional list of columns to be copied. If no column list is
+ specified, all columns of the table except generated columns will be
+ copied.
+
query
+ A SELECT,
+ VALUES,
+ INSERT,
+ UPDATE, or
+ DELETE command whose results are to be
+ copied. Note that parentheses are required around the query.
+
+ For INSERT, UPDATE and
+ DELETE queries a RETURNING clause
+ must be provided, and the target relation must not have a conditional
+ rule, nor an ALSO rule, nor an
+ INSTEAD rule that expands to multiple statements.
+
filename
+ The path name of the input or output file. An input file name can be
+ an absolute or relative path, but an output file name must be an absolute
+ path. Windows users might need to use an E'' string and
+ double any backslashes used in the path name.
+
PROGRAM
+ A command to execute. In COPY FROM, the input is
+ read from standard output of the command, and in COPY TO,
+ the output is written to the standard input of the command.
+
+ Note that the command is invoked by the shell, so if you need to pass
+ any arguments that come from an untrusted source, you
+ must be careful to strip or escape any special characters that might
+ have a special meaning for the shell. For security reasons, it is best
+ to use a fixed command string, or at least avoid including any user input
+ in it.
+
STDIN
+ Specifies that input comes from the client application.
+
STDOUT
+ Specifies that output goes to the client application.
+
boolean
+ Specifies whether the selected option should be turned on or off.
+ You can write TRUE, ON, or
+ 1 to enable the option, and FALSE,
+ OFF, or 0 to disable it. The
+ boolean value can also
+ be omitted, in which case TRUE is assumed.
+
FORMAT
+ Selects the data format to be read or written:
+ text,
+ csv (Comma Separated Values),
+ or binary.
+ The default is text.
+
FREEZE
+ Requests copying the data with rows already frozen, just as they
+ would be after running the VACUUM FREEZE command.
+ This is intended as a performance option for initial data loading.
+ Rows will be frozen only if the table being loaded has been created
+ or truncated in the current subtransaction, there are no cursors
+ open and there are no older snapshots held by this transaction. It is
+ currently not possible to perform a COPY FREEZE on
+ a partitioned table.
+
+ Note that all other sessions will immediately be able to see the data
+ once it has been successfully loaded. This violates the normal rules
+ of MVCC visibility and users should be aware of the
+ potential problems this might cause.
+
DELIMITER
+ Specifies the character that separates columns within each row
+ (line) of the file. The default is a tab character in text format,
+ a comma in CSV format.
+ This must be a single one-byte character.
+ This option is not allowed when using binary format.
+
NULL
+ Specifies the string that represents a null value. The default is
+ \N (backslash-N) in text format, and an unquoted empty
+ string in CSV format. You might prefer an
+ empty string even in text format for cases where you don't want to
+ distinguish nulls from empty strings.
+ This option is not allowed when using binary format.
+
Note
+ When using COPY FROM, any data item that matches
+ this string will be stored as a null value, so you should make
+ sure that you use the same string as you used with
+ COPY TO.
+
DEFAULT
+ Specifies the string that represents a default value. Each time the string
+ is found in the input file, the default value of the corresponding column
+ will be used.
+ This option is allowed only in COPY FROM, and only when
+ not using binary format.
+
HEADER
+ Specifies that the file contains a header line with the names of each
+ column in the file. On output, the first line contains the column
+ names from the table. On input, the first line is discarded when this
+ option is set to true (or equivalent Boolean value).
+ If this option is set to MATCH, the number and names
+ of the columns in the header line must match the actual column names of
+ the table, in order; otherwise an error is raised.
+ This option is not allowed when using binary format.
+ The MATCH option is only valid for COPY
+ FROM commands.
+
QUOTE
+ Specifies the quoting character to be used when a data value is quoted.
+ The default is double-quote.
+ This must be a single one-byte character.
+ This option is allowed only when using CSV format.
+
ESCAPE
+ Specifies the character that should appear before a
+ data character that matches the QUOTE value.
+ The default is the same as the QUOTE value (so that
+ the quoting character is doubled if it appears in the data).
+ This must be a single one-byte character.
+ This option is allowed only when using CSV format.
+
FORCE_QUOTE
+ Forces quoting to be
+ used for all non-NULL values in each specified column.
+ NULL output is never quoted. If * is specified,
+ non-NULL values will be quoted in all columns.
+ This option is allowed only in COPY TO, and only when
+ using CSV format.
+
FORCE_NOT_NULL
+ Do not match the specified columns' values against the null string.
+ In the default case where the null string is empty, this means that
+ empty values will be read as zero-length strings rather than nulls,
+ even when they are not quoted.
+ This option is allowed only in COPY FROM, and only when
+ using CSV format.
+
FORCE_NULL
+ Match the specified columns' values against the null string, even
+ if it has been quoted, and if a match is found set the value to
+ NULL. In the default case where the null string is empty,
+ this converts a quoted empty string into NULL.
+ This option is allowed only in COPY FROM, and only when
+ using CSV format.
+
ENCODING
+ Specifies that the file is encoded in the encoding_name. If this option is
+ omitted, the current client encoding is used. See the Notes below
+ for more details.
+
WHERE
+ The optional WHERE clause has the general form
+
+WHERE condition
+
+ where condition is
+ any expression that evaluates to a result of type
+ boolean. Any row that does not satisfy this
+ condition will not be inserted to the table. A row satisfies the
+ condition if it returns true when the actual row values are
+ substituted for any variable references.
+
+ Currently, subqueries are not allowed in WHERE
+ expressions, and the evaluation does not see any changes made by the
+ COPY itself (this matters when the expression
+ contains calls to VOLATILE functions).
+
Outputs
+ On successful completion, a COPY command returns a command
+ tag of the form
+
+COPY count
+
+ The count is the number
+ of rows copied.
+
Note
+ psql will print this command tag only if the command
+ was not COPY ... TO STDOUT, or the
+ equivalent psql meta-command
+ \copy ... to stdout. This is to prevent confusing the
+ command tag with the data that was just printed.
+
Notes
+ COPY TO can be used only with plain
+ tables, not views, and does not copy rows from child tables
+ or child partitions. For example, COPY table TO copies
+ the same rows as SELECT * FROM ONLY table.
+ The syntax COPY (SELECT * FROM table) TO ... can be used to
+ dump all of the rows in an inheritance hierarchy, partitioned table,
+ or view.
+
+ COPY FROM can be used with plain, foreign, or
+ partitioned tables or with views that have
+ INSTEAD OF INSERT triggers.
+
+ You must have select privilege on the table
+ whose values are read by COPY TO, and
+ insert privilege on the table into which values
+ are inserted by COPY FROM. It is sufficient
+ to have column privileges on the column(s) listed in the command.
+
+ If row-level security is enabled for the table, the relevant
+ SELECT policies will apply to COPY
+ table TO statements.
+ Currently, COPY FROM is not supported for tables
+ with row-level security. Use equivalent INSERT
+ statements instead.
+
+ Files named in a COPY command are read or written
+ directly by the server, not by the client application. Therefore,
+ they must reside on or be accessible to the database server machine,
+ not the client. They must be accessible to and readable or writable
+ by the PostgreSQL user (the user ID the
+ server runs as), not the client. Similarly,
+ the command specified with PROGRAM is executed directly
+ by the server, not by the client application, must be executable by the
+ PostgreSQL user.
+ COPY naming a file or command is only allowed to
+ database superusers or users who are granted one of the roles
+ pg_read_server_files,
+ pg_write_server_files,
+ or pg_execute_server_program, since it allows reading
+ or writing any file or running a program that the server has privileges to
+ access.
+
+ Do not confuse COPY with the
+ psql instruction
+ \copy. \copy invokes
+ COPY FROM STDIN or COPY TO
+ STDOUT, and then fetches/stores the data in a file
+ accessible to the psql client. Thus,
+ file accessibility and access rights depend on the client rather
+ than the server when \copy is used.
+
+ It is recommended that the file name used in COPY
+ always be specified as an absolute path. This is enforced by the
+ server in the case of COPY TO, but for
+ COPY FROM you do have the option of reading from
+ a file specified by a relative path. The path will be interpreted
+ relative to the working directory of the server process (normally
+ the cluster's data directory), not the client's working directory.
+
+ Executing a command with PROGRAM might be restricted
+ by the operating system's access control mechanisms, such as SELinux.
+
+ COPY FROM will invoke any triggers and check
+ constraints on the destination table. However, it will not invoke rules.
+
+ For identity columns, the COPY FROM command will always
+ write the column values provided in the input data, like
+ the INSERT option OVERRIDING SYSTEM
+ VALUE.
+
+ COPY input and output is affected by
+ DateStyle. To ensure portability to other
+ PostgreSQL installations that might use
+ non-default DateStyle settings,
+ DateStyle should be set to ISO before
+ using COPY TO. It is also a good idea to avoid dumping
+ data with IntervalStyle set to
+ sql_standard, because negative interval values might be
+ misinterpreted by a server that has a different setting for
+ IntervalStyle.
+
+ Input data is interpreted according to ENCODING
+ option or the current client encoding, and output data is encoded
+ in ENCODING or the current client encoding, even
+ if the data does not pass through the client but is read from or
+ written to a file directly by the server.
+
+ COPY stops operation at the first error. This
+ should not lead to problems in the event of a COPY
+ TO, but the target table will already have received
+ earlier rows in a COPY FROM. These rows will not
+ be visible or accessible, but they still occupy disk space. This might
+ amount to a considerable amount of wasted disk space if the failure
+ happened well into a large copy operation. You might wish to invoke
+ VACUUM to recover the wasted space.
+
+ FORCE_NULL and FORCE_NOT_NULL can be used
+ simultaneously on the same column. This results in converting quoted
+ null strings to null values and unquoted null strings to empty strings.
+
File Formats
Text Format
+ When the text format is used,
+ the data read or written is a text file with one line per table row.
+ Columns in a row are separated by the delimiter character.
+ The column values themselves are strings generated by the
+ output function, or acceptable to the input function, of each
+ attribute's data type. The specified null string is used in
+ place of columns that are null.
+ COPY FROM will raise an error if any line of the
+ input file contains more or fewer columns than are expected.
+
+ End of data can be represented by a single line containing just
+ backslash-period (\.). An end-of-data marker is
+ not necessary when reading from a file, since the end of file
+ serves perfectly well; it is needed only when copying data to or from
+ client applications using pre-3.0 client protocol.
+
+ Backslash characters (\) can be used in the
+ COPY data to quote data characters that might
+ otherwise be taken as row or column delimiters. In particular, the
+ following characters must be preceded by a backslash if
+ they appear as part of a column value: backslash itself,
+ newline, carriage return, and the current delimiter character.
+
+ The specified null string is sent by COPY TO without
+ adding any backslashes; conversely, COPY FROM matches
+ the input against the null string before removing backslashes. Therefore,
+ a null string such as \N cannot be confused with
+ the actual data value \N (which would be represented
+ as \\N).
+
+ The following special backslash sequences are recognized by
+ COPY FROM:
+
+
+
+ Presently, COPY TO will never emit an octal or
+ hex-digits backslash sequence, but it does use the other sequences
+ listed above for those control characters.
+
+ Any other backslashed character that is not mentioned in the above table
+ will be taken to represent itself. However, beware of adding backslashes
+ unnecessarily, since that might accidentally produce a string matching the
+ end-of-data marker (\.) or the null string (\N by
+ default). These strings will be recognized before any other backslash
+ processing is done.
+
+ It is strongly recommended that applications generating COPY data convert
+ data newlines and carriage returns to the \n and
+ \r sequences respectively. At present it is
+ possible to represent a data carriage return by a backslash and carriage
+ return, and to represent a data newline by a backslash and newline.
+ However, these representations might not be accepted in future releases.
+ They are also highly vulnerable to corruption if the COPY file is
+ transferred across different machines (for example, from Unix to Windows
+ or vice versa).
+
+ All backslash sequences are interpreted after encoding conversion.
+ The bytes specified with the octal and hex-digit backslash sequences must
+ form valid characters in the database encoding.
+
+ COPY TO will terminate each row with a Unix-style
+ newline (“\n”). Servers running on Microsoft Windows instead
+ output carriage return/newline (“\r\n”), but only for
+ COPY to a server file; for consistency across platforms,
+ COPY TO STDOUT always sends “\n”
+ regardless of server platform.
+ COPY FROM can handle lines ending with newlines,
+ carriage returns, or carriage return/newlines. To reduce the risk of
+ error due to un-backslashed newlines or carriage returns that were
+ meant as data, COPY FROM will complain if the line
+ endings in the input are not all alike.
+
CSV Format
+ This format option is used for importing and exporting the Comma
+ Separated Value (CSV) file format used by many other
+ programs, such as spreadsheets. Instead of the escaping rules used by
+ PostgreSQL's standard text format, it
+ produces and recognizes the common CSV escaping mechanism.
+
+ The values in each record are separated by the DELIMITER
+ character. If the value contains the delimiter character, the
+ QUOTE character, the NULL string, a carriage
+ return, or line feed character, then the whole value is prefixed and
+ suffixed by the QUOTE character, and any occurrence
+ within the value of a QUOTE character or the
+ ESCAPE character is preceded by the escape character.
+ You can also use FORCE_QUOTE to force quotes when outputting
+ non-NULL values in specific columns.
+
+ The CSV format has no standard way to distinguish a
+ NULL value from an empty string.
+ PostgreSQL's COPY handles this by quoting.
+ A NULL is output as the NULL parameter string
+ and is not quoted, while a non-NULL value matching the
+ NULL parameter string is quoted. For example, with the
+ default settings, a NULL is written as an unquoted empty
+ string, while an empty string data value is written with double quotes
+ (""). Reading values follows similar rules. You can
+ use FORCE_NOT_NULL to prevent NULL input
+ comparisons for specific columns. You can also use
+ FORCE_NULL to convert quoted null string data values to
+ NULL.
+
+ Because backslash is not a special character in the CSV
+ format, \., the end-of-data marker, could also appear
+ as a data value. To avoid any misinterpretation, a \.
+ data value appearing as a lone entry on a line is automatically
+ quoted on output, and on input, if quoted, is not interpreted as the
+ end-of-data marker. If you are loading a file created by another
+ application that has a single unquoted column and might have a
+ value of \., you might need to quote that value in the
+ input file.
+
Note
+ In CSV format, all characters are significant. A quoted value
+ surrounded by white space, or any characters other than
+ DELIMITER, will include those characters. This can cause
+ errors if you import data from a system that pads CSV
+ lines with white space out to some fixed width. If such a situation
+ arises you might need to preprocess the CSV file to remove
+ the trailing white space, before importing the data into
+ PostgreSQL.
+
Note
+ CSV format will both recognize and produce CSV files with quoted
+ values containing embedded carriage returns and line feeds. Thus
+ the files are not strictly one line per table row like text-format
+ files.
+
Note
+ Many programs produce strange and occasionally perverse CSV files,
+ so the file format is more a convention than a standard. Thus you
+ might encounter some files that cannot be imported using this
+ mechanism, and COPY might produce files that other
+ programs cannot process.
+
Binary Format
+ The binary format option causes all data to be
+ stored/read as binary format rather than as text. It is
+ somewhat faster than the text and CSV formats,
+ but a binary-format file is less portable across machine architectures and
+ PostgreSQL versions.
+ Also, the binary format is very data type specific; for example
+ it will not work to output binary data from a smallint column
+ and read it into an integer column, even though that would work
+ fine in text format.
+
+ The binary file format consists
+ of a file header, zero or more tuples containing the row data, and
+ a file trailer. Headers and data are in network byte order.
+
Note
+ PostgreSQL releases before 7.4 used a
+ different binary file format.
+
File Header
+ The file header consists of 15 bytes of fixed fields, followed
+ by a variable-length header extension area. The fixed fields are:
+
+
- Signature
+11-byte sequence PGCOPY\n\377\r\n\0 — note that the zero byte
+is a required part of the signature. (The signature is designed to allow
+easy identification of files that have been munged by a non-8-bit-clean
+transfer. This signature will be changed by end-of-line-translation
+filters, dropped zero bytes, dropped high bits, or parity changes.)
+
- Flags field
+32-bit integer bit mask to denote important aspects of the file format. Bits
+are numbered from 0 (LSB) to 31 (MSB). Note that
+this field is stored in network byte order (most significant byte first),
+as are all the integer fields used in the file format. Bits
+16–31 are reserved to denote critical file format issues; a reader
+should abort if it finds an unexpected bit set in this range. Bits 0–15
+are reserved to signal backwards-compatible format issues; a reader
+should simply ignore any unexpected bits set in this range. Currently
+only one flag bit is defined, and the rest must be zero:
+
- Bit 16
+ If 1, OIDs are included in the data; if 0, not. Oid system columns
+ are not supported in PostgreSQL
+ anymore, but the format still contains the indicator.
+
- Header extension area length
+32-bit integer, length in bytes of remainder of header, not including self.
+Currently, this is zero, and the first tuple follows
+immediately. Future changes to the format might allow additional data
+to be present in the header. A reader should silently skip over any header
+extension data it does not know what to do with.
+
+
+The header extension area is envisioned to contain a sequence of
+self-identifying chunks. The flags field is not intended to tell readers
+what is in the extension area. Specific design of header extension contents
+is left for a later release.
+
+ This design allows for both backwards-compatible header additions (add
+ header extension chunks, or set low-order flag bits) and
+ non-backwards-compatible changes (set high-order flag bits to signal such
+ changes, and add supporting data to the extension area if needed).
+
Tuples
+Each tuple begins with a 16-bit integer count of the number of fields in the
+tuple. (Presently, all tuples in a table will have the same count, but that
+might not always be true.) Then, repeated for each field in the tuple, there
+is a 32-bit length word followed by that many bytes of field data. (The
+length word does not include itself, and can be zero.) As a special case,
+-1 indicates a NULL field value. No value bytes follow in the NULL case.
+
+There is no alignment padding or any other extra data between fields.
+
+Presently, all data values in a binary-format file are
+assumed to be in binary format (format code one). It is anticipated that a
+future extension might add a header field that allows per-column format codes
+to be specified.
+
+To determine the appropriate binary format for the actual tuple data you
+should consult the PostgreSQL source, in
+particular the *send and *recv functions for
+each column's data type (typically these functions are found in the
+src/backend/utils/adt/ directory of the source
+distribution).
+
+If OIDs are included in the file, the OID field immediately follows the
+field-count word. It is a normal field except that it's not included in the
+field-count. Note that oid system columns are not supported in current
+versions of PostgreSQL.
+
File Trailer
+ The file trailer consists of a 16-bit integer word containing -1. This
+ is easily distinguished from a tuple's field-count word.
+
+ A reader should report an error if a field-count word is neither -1
+ nor the expected number of columns. This provides an extra
+ check against somehow getting out of sync with the data.
+
Examples
+ The following example copies a table to the client
+ using the vertical bar (|) as the field delimiter:
+
+COPY country TO STDOUT (DELIMITER '|');
+
+
+ To copy data from a file into the country table:
+
+COPY country FROM '/usr1/proj/bray/sql/country_data';
+
+
+ To copy into a file just the countries whose names start with 'A':
+
+COPY (SELECT * FROM country WHERE country_name LIKE 'A%') TO '/usr1/proj/bray/sql/a_list_countries.copy';
+
+
+ To copy into a compressed file, you can pipe the output through an external
+ compression program:
+
+COPY country TO PROGRAM 'gzip > /usr1/proj/bray/sql/country_data.gz';
+
+
+ Here is a sample of data suitable for copying into a table from
+ STDIN:
+
+AF AFGHANISTAN
+AL ALBANIA
+DZ ALGERIA
+ZM ZAMBIA
+ZW ZIMBABWE
+
+ Note that the white space on each line is actually a tab character.
+
+ The following is the same data, output in binary format.
+ The data is shown after filtering through the
+ Unix utility od -c. The table has three columns;
+ the first has type char(2), the second has type text,
+ and the third has type integer. All the rows have a null value
+ in the third column.
+
+0000000 P G C O P Y \n 377 \r \n \0 \0 \0 \0 \0 \0
+0000020 \0 \0 \0 \0 003 \0 \0 \0 002 A F \0 \0 \0 013 A
+0000040 F G H A N I S T A N 377 377 377 377 \0 003
+0000060 \0 \0 \0 002 A L \0 \0 \0 007 A L B A N I
+0000100 A 377 377 377 377 \0 003 \0 \0 \0 002 D Z \0 \0 \0
+0000120 007 A L G E R I A 377 377 377 377 \0 003 \0 \0
+0000140 \0 002 Z M \0 \0 \0 006 Z A M B I A 377 377
+0000160 377 377 \0 003 \0 \0 \0 002 Z W \0 \0 \0 \b Z I
+0000200 M B A B W E 377 377 377 377 377 377
+
Compatibility
+ There is no COPY statement in the SQL standard.
+
+ The following syntax was used before PostgreSQL
+ version 9.0 and is still supported:
+
+
+COPY table_name [ ( column_name [, ...] ) ]
+ FROM { 'filename' | STDIN }
+ [ [ WITH ]
+ [ BINARY ]
+ [ DELIMITER [ AS ] 'delimiter_character' ]
+ [ NULL [ AS ] 'null_string' ]
+ [ CSV [ HEADER ]
+ [ QUOTE [ AS ] 'quote_character' ]
+ [ ESCAPE [ AS ] 'escape_character' ]
+ [ FORCE NOT NULL column_name [, ...] ] ] ]
+
+COPY { table_name [ ( column_name [, ...] ) ] | ( query ) }
+ TO { 'filename' | STDOUT }
+ [ [ WITH ]
+ [ BINARY ]
+ [ DELIMITER [ AS ] 'delimiter_character' ]
+ [ NULL [ AS ] 'null_string' ]
+ [ CSV [ HEADER ]
+ [ QUOTE [ AS ] 'quote_character' ]
+ [ ESCAPE [ AS ] 'escape_character' ]
+ [ FORCE QUOTE { column_name [, ...] | * } ] ] ]
+
+
+ Note that in this syntax, BINARY and CSV are
+ treated as independent keywords, not as arguments of a FORMAT
+ option.
+
+ The following syntax was used before PostgreSQL
+ version 7.3 and is still supported:
+
+
+COPY [ BINARY ] table_name
+ FROM { 'filename' | STDIN }
+ [ [USING] DELIMITERS 'delimiter_character' ]
+ [ WITH NULL AS 'null_string' ]
+
+COPY [ BINARY ] table_name
+ TO { 'filename' | STDOUT }
+ [ [USING] DELIMITERS 'delimiter_character' ]
+ [ WITH NULL AS 'null_string' ]
+
CREATE ACCESS METHOD
CREATE ACCESS METHOD — define a new access method
Synopsis
+CREATE ACCESS METHOD name
+ TYPE access_method_type
+ HANDLER handler_function
+
Description
+ CREATE ACCESS METHOD creates a new access method.
+
+ The access method name must be unique within the database.
+
+ Only superusers can define new access methods.
+
Parameters
name
+ The name of the access method to be created.
+
access_method_type
+ This clause specifies the type of access method to define.
+ Only TABLE and INDEX
+ are supported at present.
+
handler_function
+ handler_function is the
+ name (possibly schema-qualified) of a previously registered function
+ that represents the access method. The handler function must be
+ declared to take a single argument of type internal,
+ and its return type depends on the type of access method;
+ for TABLE access methods, it must
+ be table_am_handler and for INDEX
+ access methods, it must be index_am_handler.
+ The C-level API that the handler function must implement varies
+ depending on the type of access method. The table access method API
+ is described in Chapter 63 and the index access method
+ API is described in Chapter 64.
+
Examples
+ Create an index access method heptree with
+ handler function heptree_handler:
+
+CREATE ACCESS METHOD heptree TYPE INDEX HANDLER heptree_handler;
+
Compatibility
+ CREATE ACCESS METHOD is a
+ PostgreSQL extension.
+
CREATE AGGREGATE
CREATE AGGREGATE — define a new aggregate function
Synopsis
+CREATE [ OR REPLACE ] AGGREGATE name ( [ argmode ] [ argname ] arg_data_type [ , ... ] ) (
+ SFUNC = sfunc,
+ STYPE = state_data_type
+ [ , SSPACE = state_data_size ]
+ [ , FINALFUNC = ffunc ]
+ [ , FINALFUNC_EXTRA ]
+ [ , FINALFUNC_MODIFY = { READ_ONLY | SHAREABLE | READ_WRITE } ]
+ [ , COMBINEFUNC = combinefunc ]
+ [ , SERIALFUNC = serialfunc ]
+ [ , DESERIALFUNC = deserialfunc ]
+ [ , INITCOND = initial_condition ]
+ [ , MSFUNC = msfunc ]
+ [ , MINVFUNC = minvfunc ]
+ [ , MSTYPE = mstate_data_type ]
+ [ , MSSPACE = mstate_data_size ]
+ [ , MFINALFUNC = mffunc ]
+ [ , MFINALFUNC_EXTRA ]
+ [ , MFINALFUNC_MODIFY = { READ_ONLY | SHAREABLE | READ_WRITE } ]
+ [ , MINITCOND = minitial_condition ]
+ [ , SORTOP = sort_operator ]
+ [ , PARALLEL = { SAFE | RESTRICTED | UNSAFE } ]
+)
+
+CREATE [ OR REPLACE ] AGGREGATE name ( [ [ argmode ] [ argname ] arg_data_type [ , ... ] ]
+ ORDER BY [ argmode ] [ argname ] arg_data_type [ , ... ] ) (
+ SFUNC = sfunc,
+ STYPE = state_data_type
+ [ , SSPACE = state_data_size ]
+ [ , FINALFUNC = ffunc ]
+ [ , FINALFUNC_EXTRA ]
+ [ , FINALFUNC_MODIFY = { READ_ONLY | SHAREABLE | READ_WRITE } ]
+ [ , INITCOND = initial_condition ]
+ [ , PARALLEL = { SAFE | RESTRICTED | UNSAFE } ]
+ [ , HYPOTHETICAL ]
+)
+
+or the old syntax
+
+CREATE [ OR REPLACE ] AGGREGATE name (
+ BASETYPE = base_type,
+ SFUNC = sfunc,
+ STYPE = state_data_type
+ [ , SSPACE = state_data_size ]
+ [ , FINALFUNC = ffunc ]
+ [ , FINALFUNC_EXTRA ]
+ [ , FINALFUNC_MODIFY = { READ_ONLY | SHAREABLE | READ_WRITE } ]
+ [ , COMBINEFUNC = combinefunc ]
+ [ , SERIALFUNC = serialfunc ]
+ [ , DESERIALFUNC = deserialfunc ]
+ [ , INITCOND = initial_condition ]
+ [ , MSFUNC = msfunc ]
+ [ , MINVFUNC = minvfunc ]
+ [ , MSTYPE = mstate_data_type ]
+ [ , MSSPACE = mstate_data_size ]
+ [ , MFINALFUNC = mffunc ]
+ [ , MFINALFUNC_EXTRA ]
+ [ , MFINALFUNC_MODIFY = { READ_ONLY | SHAREABLE | READ_WRITE } ]
+ [ , MINITCOND = minitial_condition ]
+ [ , SORTOP = sort_operator ]
+)
+
Description
+ CREATE AGGREGATE defines a new aggregate function.
+ CREATE OR REPLACE AGGREGATE will either define a new
+ aggregate function or replace an existing definition. Some basic and
+ commonly-used aggregate functions are included with the distribution; they
+ are documented in Section 9.21. If one defines new
+ types or needs an aggregate function not already provided, then
+ CREATE AGGREGATE can be used to provide the desired
+ features.
+
+ When replacing an existing definition, the argument types, result type,
+ and number of direct arguments may not be changed. Also, the new definition
+ must be of the same kind (ordinary aggregate, ordered-set aggregate, or
+ hypothetical-set aggregate) as the old one.
+
+ If a schema name is given (for example, CREATE AGGREGATE
+ myschema.myagg ...) then the aggregate function is created in the
+ specified schema. Otherwise it is created in the current schema.
+
+ An aggregate function is identified by its name and input data type(s).
+ Two aggregates in the same schema can have the same name if they operate on
+ different input types. The
+ name and input data type(s) of an aggregate must also be distinct from
+ the name and input data type(s) of every ordinary function in the same
+ schema.
+ This behavior is identical to overloading of ordinary function names
+ (see CREATE FUNCTION).
+
+ A simple aggregate function is made from one or two ordinary
+ functions:
+ a state transition function
+ sfunc,
+ and an optional final calculation function
+ ffunc.
+ These are used as follows:
+
+sfunc( internal-state, next-data-values ) ---> next-internal-state
+ffunc( internal-state ) ---> aggregate-value
+
+
+ PostgreSQL creates a temporary variable
+ of data type stype
+ to hold the current internal state of the aggregate. At each input row,
+ the aggregate argument value(s) are calculated and
+ the state transition function is invoked with the current state value
+ and the new argument value(s) to calculate a new
+ internal state value. After all the rows have been processed,
+ the final function is invoked once to calculate the aggregate's return
+ value. If there is no final function then the ending state value
+ is returned as-is.
+
+ An aggregate function can provide an initial condition,
+ that is, an initial value for the internal state value.
+ This is specified and stored in the database as a value of type
+ text, but it must be a valid external representation
+ of a constant of the state value data type. If it is not supplied
+ then the state value starts out null.
+
+ If the state transition function is declared “strict”,
+ then it cannot be called with null inputs. With such a transition
+ function, aggregate execution behaves as follows. Rows with any null input
+ values are ignored (the function is not called and the previous state value
+ is retained). If the initial state value is null, then at the first row
+ with all-nonnull input values, the first argument value replaces the state
+ value, and the transition function is invoked at each subsequent row with
+ all-nonnull input values.
+ This is handy for implementing aggregates like max.
+ Note that this behavior is only available when
+ state_data_type
+ is the same as the first
+ arg_data_type.
+ When these types are different, you must supply a nonnull initial
+ condition or use a nonstrict transition function.
+
+ If the state transition function is not strict, then it will be called
+ unconditionally at each input row, and must deal with null inputs
+ and null state values for itself. This allows the aggregate
+ author to have full control over the aggregate's handling of null values.
+
+ If the final function is declared “strict”, then it will not
+ be called when the ending state value is null; instead a null result
+ will be returned automatically. (Of course this is just the normal
+ behavior of strict functions.) In any case the final function has
+ the option of returning a null value. For example, the final function for
+ avg returns null when it sees there were zero
+ input rows.
+
+ Sometimes it is useful to declare the final function as taking not just
+ the state value, but extra parameters corresponding to the aggregate's
+ input values. The main reason for doing this is if the final function
+ is polymorphic and the state value's data type would be inadequate to
+ pin down the result type. These extra parameters are always passed as
+ NULL (and so the final function must not be strict when
+ the FINALFUNC_EXTRA option is used), but nonetheless they
+ are valid parameters. The final function could for example make use
+ of get_fn_expr_argtype to identify the actual argument type
+ in the current call.
+
+ An aggregate can optionally support moving-aggregate mode,
+ as described in Section 38.12.1. This requires
+ specifying the MSFUNC, MINVFUNC,
+ and MSTYPE parameters, and optionally
+ the MSSPACE, MFINALFUNC,
+ MFINALFUNC_EXTRA, MFINALFUNC_MODIFY,
+ and MINITCOND parameters. Except for MINVFUNC,
+ these parameters work like the corresponding simple-aggregate parameters
+ without M; they define a separate implementation of the
+ aggregate that includes an inverse transition function.
+
+ The syntax with ORDER BY in the parameter list creates
+ a special type of aggregate called an ordered-set
+ aggregate; or if HYPOTHETICAL is specified, then
+ a hypothetical-set aggregate is created. These
+ aggregates operate over groups of sorted values in order-dependent ways,
+ so that specification of an input sort order is an essential part of a
+ call. Also, they can have direct arguments, which are
+ arguments that are evaluated only once per aggregation rather than once
+ per input row. Hypothetical-set aggregates are a subclass of ordered-set
+ aggregates in which some of the direct arguments are required to match,
+ in number and data types, the aggregated argument columns. This allows
+ the values of those direct arguments to be added to the collection of
+ aggregate-input rows as an additional “hypothetical” row.
+
+ An aggregate can optionally support partial aggregation,
+ as described in Section 38.12.4.
+ This requires specifying the COMBINEFUNC parameter.
+ If the state_data_type
+ is internal, it's usually also appropriate to provide the
+ SERIALFUNC and DESERIALFUNC parameters so that
+ parallel aggregation is possible. Note that the aggregate must also be
+ marked PARALLEL SAFE to enable parallel aggregation.
+
+ Aggregates that behave like MIN or MAX can
+ sometimes be optimized by looking into an index instead of scanning every
+ input row. If this aggregate can be so optimized, indicate it by
+ specifying a sort operator. The basic requirement is that
+ the aggregate must yield the first element in the sort ordering induced by
+ the operator; in other words:
+
+SELECT agg(col) FROM tab;
+
+ must be equivalent to:
+
+SELECT col FROM tab ORDER BY col USING sortop LIMIT 1;
+
+ Further assumptions are that the aggregate ignores null inputs, and that
+ it delivers a null result if and only if there were no non-null inputs.
+ Ordinarily, a data type's < operator is the proper sort
+ operator for MIN, and > is the proper sort
+ operator for MAX. Note that the optimization will never
+ actually take effect unless the specified operator is the “less
+ than” or “greater than” strategy member of a B-tree
+ index operator class.
+
+ To be able to create an aggregate function, you must
+ have USAGE privilege on the argument types, the state
+ type(s), and the return type, as well as EXECUTE
+ privilege on the supporting functions.
+
Parameters
name
+ The name (optionally schema-qualified) of the aggregate function
+ to create.
+
argmode
+ The mode of an argument: IN or VARIADIC.
+ (Aggregate functions do not support OUT arguments.)
+ If omitted, the default is IN. Only the last argument
+ can be marked VARIADIC.
+
argname
+ The name of an argument. This is currently only useful for
+ documentation purposes. If omitted, the argument has no name.
+
arg_data_type
+ An input data type on which this aggregate function operates.
+ To create a zero-argument aggregate function, write *
+ in place of the list of argument specifications. (An example of such an
+ aggregate is count(*).)
+
base_type
+ In the old syntax for CREATE AGGREGATE, the input data type
+ is specified by a basetype parameter rather than being
+ written next to the aggregate name. Note that this syntax allows
+ only one input parameter. To define a zero-argument aggregate function
+ with this syntax, specify the basetype as
+ "ANY" (not *).
+ Ordered-set aggregates cannot be defined with the old syntax.
+
sfunc
+ The name of the state transition function to be called for each
+ input row. For a normal N-argument
+ aggregate function, the sfunc
+ must take N+1 arguments,
+ the first being of type state_data_type and the rest
+ matching the declared input data type(s) of the aggregate.
+ The function must return a value of type state_data_type. This function
+ takes the current state value and the current input data value(s),
+ and returns the next state value.
+
+ For ordered-set (including hypothetical-set) aggregates, the state
+ transition function receives only the current state value and the
+ aggregated arguments, not the direct arguments. Otherwise it is the
+ same.
+
state_data_type
+ The data type for the aggregate's state value.
+
state_data_size
+ The approximate average size (in bytes) of the aggregate's state value.
+ If this parameter is omitted or is zero, a default estimate is used
+ based on the state_data_type.
+ The planner uses this value to estimate the memory required for a
+ grouped aggregate query.
+
ffunc
+ The name of the final function called to compute the aggregate's
+ result after all input rows have been traversed.
+ For a normal aggregate, this function
+ must take a single argument of type state_data_type. The return
+ data type of the aggregate is defined as the return type of this
+ function. If ffunc
+ is not specified, then the ending state value is used as the
+ aggregate's result, and the return type is state_data_type.
+
+ For ordered-set (including hypothetical-set) aggregates, the
+ final function receives not only the final state value,
+ but also the values of all the direct arguments.
+
+ If FINALFUNC_EXTRA is specified, then in addition to the
+ final state value and any direct arguments, the final function
+ receives extra NULL values corresponding to the aggregate's regular
+ (aggregated) arguments. This is mainly useful to allow correct
+ resolution of the aggregate result type when a polymorphic aggregate
+ is being defined.
+
FINALFUNC_MODIFY = { READ_ONLY | SHAREABLE | READ_WRITE }
+ This option specifies whether the final function is a pure function
+ that does not modify its arguments. READ_ONLY indicates
+ it does not; the other two values indicate that it may change the
+ transition state value. See Notes
+ below for more detail. The
+ default is READ_ONLY, except for ordered-set aggregates,
+ for which the default is READ_WRITE.
+
combinefunc
+ The combinefunc function
+ may optionally be specified to allow the aggregate function to support
+ partial aggregation. If provided,
+ the combinefunc must
+ combine two state_data_type
+ values, each containing the result of aggregation over some subset of
+ the input values, to produce a
+ new state_data_type that
+ represents the result of aggregating over both sets of inputs. This
+ function can be thought of as
+ an sfunc, where instead of
+ acting upon an individual input row and adding it to the running
+ aggregate state, it adds another aggregate state to the running state.
+
+ The combinefunc must be
+ declared as taking two arguments of
+ the state_data_type and
+ returning a value of
+ the state_data_type.
+ Optionally this function may be “strict”. In this case the
+ function will not be called when either of the input states are null;
+ the other state will be taken as the correct result.
+
+ For aggregate functions
+ whose state_data_type
+ is internal,
+ the combinefunc must not
+ be strict. In this case
+ the combinefunc must
+ ensure that null states are handled correctly and that the state being
+ returned is properly stored in the aggregate memory context.
+
serialfunc
+ An aggregate function
+ whose state_data_type
+ is internal can participate in parallel aggregation only if it
+ has a serialfunc function,
+ which must serialize the aggregate state into a bytea value for
+ transmission to another process. This function must take a single
+ argument of type internal and return type bytea. A
+ corresponding deserialfunc
+ is also required.
+
deserialfunc
+ Deserialize a previously serialized aggregate state back into
+ state_data_type. This
+ function must take two arguments of types bytea
+ and internal, and produce a result of type internal.
+ (Note: the second, internal argument is unused, but is required
+ for type safety reasons.)
+
initial_condition
+ The initial setting for the state value. This must be a string
+ constant in the form accepted for the data type state_data_type. If not
+ specified, the state value starts out null.
+
msfunc
+ The name of the forward state transition function to be called for each
+ input row in moving-aggregate mode. This is exactly like the regular
+ transition function, except that its first argument and result are of
+ type mstate_data_type, which might be different
+ from state_data_type.
+
minvfunc
+ The name of the inverse state transition function to be used in
+ moving-aggregate mode. This function has the same argument and
+ result types as msfunc, but it is used to remove
+ a value from the current aggregate state, rather than add a value to
+ it. The inverse transition function must have the same strictness
+ attribute as the forward state transition function.
+
mstate_data_type
+ The data type for the aggregate's state value, when using
+ moving-aggregate mode.
+
mstate_data_size
+ The approximate average size (in bytes) of the aggregate's state
+ value, when using moving-aggregate mode. This works the same as
+ state_data_size.
+
mffunc
+ The name of the final function called to compute the aggregate's
+ result after all input rows have been traversed, when using
+ moving-aggregate mode. This works the same as ffunc,
+ except that its first argument's type
+ is mstate_data_type and extra dummy arguments are
+ specified by writing MFINALFUNC_EXTRA.
+ The aggregate result type determined by mffunc
+ or mstate_data_type must match that determined by the
+ aggregate's regular implementation.
+
MFINALFUNC_MODIFY = { READ_ONLY | SHAREABLE | READ_WRITE }
+ This option is like FINALFUNC_MODIFY, but it describes
+ the behavior of the moving-aggregate final function.
+
minitial_condition
+ The initial setting for the state value, when using moving-aggregate
+ mode. This works the same as initial_condition.
+
sort_operator
+ The associated sort operator for a MIN- or
+ MAX-like aggregate.
+ This is just an operator name (possibly schema-qualified).
+ The operator is assumed to have the same input data types as
+ the aggregate (which must be a single-argument normal aggregate).
+
PARALLEL = { SAFE | RESTRICTED | UNSAFE }
+ The meanings of PARALLEL SAFE, PARALLEL
+ RESTRICTED, and PARALLEL UNSAFE are the same as
+ in CREATE FUNCTION. An aggregate will not be
+ considered for parallelization if it is marked PARALLEL
+ UNSAFE (which is the default!) or PARALLEL RESTRICTED.
+ Note that the parallel-safety markings of the aggregate's support
+ functions are not consulted by the planner, only the marking of the
+ aggregate itself.
+
HYPOTHETICAL
+ For ordered-set aggregates only, this flag specifies that the aggregate
+ arguments are to be processed according to the requirements for
+ hypothetical-set aggregates: that is, the last few direct arguments must
+ match the data types of the aggregated (WITHIN GROUP)
+ arguments. The HYPOTHETICAL flag has no effect on
+ run-time behavior, only on parse-time resolution of the data types and
+ collations of the aggregate's arguments.
+
+ The parameters of CREATE AGGREGATE can be
+ written in any order, not just the order illustrated above.
+
Notes
+ In parameters that specify support function names, you can write
+ a schema name if needed, for example SFUNC = public.sum.
+ Do not write argument types there, however — the argument types
+ of the support functions are determined from other parameters.
+
+ Ordinarily, PostgreSQL functions are expected to be true functions that
+ do not modify their input values. However, an aggregate transition
+ function, when used in the context of an aggregate,
+ is allowed to cheat and modify its transition-state argument in place.
+ This can provide substantial performance benefits compared to making
+ a fresh copy of the transition state each time.
+
+ Likewise, while an aggregate final function is normally expected not to
+ modify its input values, sometimes it is impractical to avoid modifying
+ the transition-state argument. Such behavior must be declared using
+ the FINALFUNC_MODIFY parameter.
+ The READ_WRITE
+ value indicates that the final function modifies the transition state in
+ unspecified ways. This value prevents use of the aggregate as a window
+ function, and it also prevents merging of transition states for aggregate
+ calls that share the same input values and transition functions.
+ The SHAREABLE value indicates that the transition function
+ cannot be applied after the final function, but multiple final-function
+ calls can be performed on the ending transition state value. This value
+ prevents use of the aggregate as a window function, but it allows merging
+ of transition states. (That is, the optimization of interest here is not
+ applying the same final function repeatedly, but applying different final
+ functions to the same ending transition state value. This is allowed as
+ long as none of the final functions are marked READ_WRITE.)
+
+ If an aggregate supports moving-aggregate mode, it will improve
+ calculation efficiency when the aggregate is used as a window function
+ for a window with moving frame start (that is, a frame start mode other
+ than UNBOUNDED PRECEDING). Conceptually, the forward
+ transition function adds input values to the aggregate's state when
+ they enter the window frame from the bottom, and the inverse transition
+ function removes them again when they leave the frame at the top. So,
+ when values are removed, they are always removed in the same order they
+ were added. Whenever the inverse transition function is invoked, it will
+ thus receive the earliest added but not yet removed argument value(s).
+ The inverse transition function can assume that at least one row will
+ remain in the current state after it removes the oldest row. (When this
+ would not be the case, the window function mechanism simply starts a
+ fresh aggregation, rather than using the inverse transition function.)
+
+ The forward transition function for moving-aggregate mode is not
+ allowed to return NULL as the new state value. If the inverse
+ transition function returns NULL, this is taken as an indication that
+ the inverse function cannot reverse the state calculation for this
+ particular input, and so the aggregate calculation will be redone from
+ scratch for the current frame starting position. This convention
+ allows moving-aggregate mode to be used in situations where there are
+ some infrequent cases that are impractical to reverse out of the
+ running state value.
+
+ If no moving-aggregate implementation is supplied,
+ the aggregate can still be used with moving frames,
+ but PostgreSQL will recompute the whole
+ aggregation whenever the start of the frame moves.
+ Note that whether or not the aggregate supports moving-aggregate
+ mode, PostgreSQL can handle a moving frame
+ end without recalculation; this is done by continuing to add new values
+ to the aggregate's state. This is why use of an aggregate as a window
+ function requires that the final function be read-only: it must
+ not damage the aggregate's state value, so that the aggregation can be
+ continued even after an aggregate result value has been obtained for
+ one set of frame boundaries.
+
+ The syntax for ordered-set aggregates allows VARIADIC
+ to be specified for both the last direct parameter and the last
+ aggregated (WITHIN GROUP) parameter. However, the
+ current implementation restricts use of VARIADIC
+ in two ways. First, ordered-set aggregates can only use
+ VARIADIC "any", not other variadic array types.
+ Second, if the last direct parameter is VARIADIC "any",
+ then there can be only one aggregated parameter and it must also
+ be VARIADIC "any". (In the representation used in the
+ system catalogs, these two parameters are merged into a single
+ VARIADIC "any" item, since pg_proc cannot
+ represent functions with more than one VARIADIC parameter.)
+ If the aggregate is a hypothetical-set aggregate, the direct arguments
+ that match the VARIADIC "any" parameter are the hypothetical
+ ones; any preceding parameters represent additional direct arguments
+ that are not constrained to match the aggregated arguments.
+
+ Currently, ordered-set aggregates do not need to support
+ moving-aggregate mode, since they cannot be used as window functions.
+
+ Partial (including parallel) aggregation is currently not supported for
+ ordered-set aggregates. Also, it will never be used for aggregate calls
+ that include DISTINCT or ORDER BY clauses, since
+ those semantics cannot be supported during partial aggregation.
+
Compatibility
+ CREATE AGGREGATE is a
+ PostgreSQL language extension. The SQL
+ standard does not provide for user-defined aggregate functions.
+
CREATE CAST
CREATE CAST — define a new cast
Synopsis
+CREATE CAST (source_type AS target_type)
+ WITH FUNCTION function_name [ (argument_type [, ...]) ]
+ [ AS ASSIGNMENT | AS IMPLICIT ]
+
+CREATE CAST (source_type AS target_type)
+ WITHOUT FUNCTION
+ [ AS ASSIGNMENT | AS IMPLICIT ]
+
+CREATE CAST (source_type AS target_type)
+ WITH INOUT
+ [ AS ASSIGNMENT | AS IMPLICIT ]
+
Description
+ CREATE CAST defines a new cast. A cast
+ specifies how to perform a conversion between
+ two data types. For example,
+
+SELECT CAST(42 AS float8);
+
+ converts the integer constant 42 to type float8 by
+ invoking a previously specified function, in this case
+ float8(int4). (If no suitable cast has been defined, the
+ conversion fails.)
+
+ Two types can be binary coercible, which
+ means that the conversion can be performed “for free”
+ without invoking any function. This requires that corresponding
+ values use the same internal representation. For instance, the
+ types text and varchar are binary
+ coercible both ways. Binary coercibility is not necessarily a
+ symmetric relationship. For example, the cast
+ from xml to text can be performed for
+ free in the present implementation, but the reverse direction
+ requires a function that performs at least a syntax check. (Two
+ types that are binary coercible both ways are also referred to as
+ binary compatible.)
+
+ You can define a cast as an I/O conversion cast by using
+ the WITH INOUT syntax. An I/O conversion cast is
+ performed by invoking the output function of the source data type, and
+ passing the resulting string to the input function of the target data type.
+ In many common cases, this feature avoids the need to write a separate
+ cast function for conversion. An I/O conversion cast acts the same as
+ a regular function-based cast; only the implementation is different.
+
+ By default, a cast can be invoked only by an explicit cast request,
+ that is an explicit CAST(x AS
+ typename) or
+ x::typename
+ construct.
+
+ If the cast is marked AS ASSIGNMENT then it can be invoked
+ implicitly when assigning a value to a column of the target data type.
+ For example, supposing that foo.f1 is a column of
+ type text, then:
+
+INSERT INTO foo (f1) VALUES (42);
+
+ will be allowed if the cast from type integer to type
+ text is marked AS ASSIGNMENT, otherwise not.
+ (We generally use the term assignment
+ cast to describe this kind of cast.)
+
+ If the cast is marked AS IMPLICIT then it can be invoked
+ implicitly in any context, whether assignment or internally in an
+ expression. (We generally use the term implicit
+ cast to describe this kind of cast.)
+ For example, consider this query:
+
+SELECT 2 + 4.0;
+
+ The parser initially marks the constants as being of type integer
+ and numeric respectively. There is no integer
+ + numeric operator in the system catalogs,
+ but there is a numeric + numeric operator.
+ The query will therefore succeed if a cast from integer to
+ numeric is available and is marked AS IMPLICIT —
+ which in fact it is. The parser will apply the implicit cast and resolve
+ the query as if it had been written
+
+SELECT CAST ( 2 AS numeric ) + 4.0;
+
+
+ Now, the catalogs also provide a cast from numeric to
+ integer. If that cast were marked AS IMPLICIT —
+ which it is not — then the parser would be faced with choosing
+ between the above interpretation and the alternative of casting the
+ numeric constant to integer and applying the
+ integer + integer operator. Lacking any
+ knowledge of which choice to prefer, it would give up and declare the
+ query ambiguous. The fact that only one of the two casts is
+ implicit is the way in which we teach the parser to prefer resolution
+ of a mixed numeric-and-integer expression as
+ numeric; there is no built-in knowledge about that.
+
+ It is wise to be conservative about marking casts as implicit. An
+ overabundance of implicit casting paths can cause
+ PostgreSQL to choose surprising
+ interpretations of commands, or to be unable to resolve commands at
+ all because there are multiple possible interpretations. A good
+ rule of thumb is to make a cast implicitly invokable only for
+ information-preserving transformations between types in the same
+ general type category. For example, the cast from int2 to
+ int4 can reasonably be implicit, but the cast from
+ float8 to int4 should probably be
+ assignment-only. Cross-type-category casts, such as text
+ to int4, are best made explicit-only.
+
Note
+ Sometimes it is necessary for usability or standards-compliance reasons
+ to provide multiple implicit casts among a set of types, resulting in
+ ambiguity that cannot be avoided as above. The parser has a fallback
+ heuristic based on type categories and preferred
+ types that can help to provide desired behavior in such cases. See
+ CREATE TYPE for
+ more information.
+
+ To be able to create a cast, you must own the source or the target data type
+ and have USAGE privilege on the other type. To create a
+ binary-coercible cast, you must be superuser. (This restriction is made
+ because an erroneous binary-coercible cast conversion can easily crash the
+ server.)
+
Parameters
source_type
+ The name of the source data type of the cast.
+
target_type
+ The name of the target data type of the cast.
+
function_name[(argument_type [, ...])]
+ The function used to perform the cast. The function name can
+ be schema-qualified. If it is not, the function will be looked
+ up in the schema search path. The function's result data type must
+ match the target type of the cast. Its arguments are discussed below.
+ If no argument list is specified, the function name must be unique in
+ its schema.
+
WITHOUT FUNCTION
+ Indicates that the source type is binary-coercible to the target type,
+ so no function is required to perform the cast.
+
WITH INOUT
+ Indicates that the cast is an I/O conversion cast, performed by
+ invoking the output function of the source data type, and passing the
+ resulting string to the input function of the target data type.
+
AS ASSIGNMENT
+ Indicates that the cast can be invoked implicitly in assignment
+ contexts.
+
AS IMPLICIT
+ Indicates that the cast can be invoked implicitly in any context.
+
+ Cast implementation functions can have one to three arguments.
+ The first argument type must be identical to or binary-coercible from
+ the cast's source type. The second argument,
+ if present, must be type integer; it receives the type
+ modifier associated with the destination type, or -1
+ if there is none. The third argument,
+ if present, must be type boolean; it receives true
+ if the cast is an explicit cast, false otherwise.
+ (Bizarrely, the SQL standard demands different behaviors for explicit and
+ implicit casts in some cases. This argument is supplied for functions
+ that must implement such casts. It is not recommended that you design
+ your own data types so that this matters.)
+
+ The return type of a cast function must be identical to or
+ binary-coercible to the cast's target type.
+
+ Ordinarily a cast must have different source and target data types.
+ However, it is allowed to declare a cast with identical source and
+ target types if it has a cast implementation function with more than one
+ argument. This is used to represent type-specific length coercion
+ functions in the system catalogs. The named function is used to
+ coerce a value of the type to the type modifier value given by its
+ second argument.
+
+ When a cast has different source and
+ target types and a function that takes more than one argument, it
+ supports converting from one type to another and applying a length
+ coercion in a single step. When no such entry is available, coercion
+ to a type that uses a type modifier involves two cast steps, one to
+ convert between data types and a second to apply the modifier.
+
+ A cast to or from a domain type currently has no effect. Casting
+ to or from a domain uses the casts associated with its underlying type.
+
Notes
+ Use DROP CAST to remove user-defined casts.
+
+ Remember that if you want to be able to convert types both ways you
+ need to declare casts both ways explicitly.
+
+ It is normally not necessary to create casts between user-defined types
+ and the standard string types (text, varchar, and
+ char(n), as well as user-defined types that
+ are defined to be in the string category). PostgreSQL
+ provides automatic I/O conversion casts for that. The automatic casts to
+ string types are treated as assignment casts, while the automatic casts
+ from string types are
+ explicit-only. You can override this behavior by declaring your own
+ cast to replace an automatic cast, but usually the only reason to
+ do so is if you want the conversion to be more easily invokable than the
+ standard assignment-only or explicit-only setting. Another possible
+ reason is that you want the conversion to behave differently from the
+ type's I/O function; but that is sufficiently surprising that you
+ should think twice about whether it's a good idea. (A small number of
+ the built-in types do indeed have different behaviors for conversions,
+ mostly because of requirements of the SQL standard.)
+
+ While not required, it is recommended that you continue to follow this old
+ convention of naming cast implementation functions after the target data
+ type. Many users are used to being able to cast data types using a
+ function-style notation, that is
+ typename(x). This notation is in fact
+ nothing more nor less than a call of the cast implementation function; it
+ is not specially treated as a cast. If your conversion functions are not
+ named to support this convention then you will have surprised users.
+ Since PostgreSQL allows overloading of the same function
+ name with different argument types, there is no difficulty in having
+ multiple conversion functions from different types that all use the
+ target type's name.
+
Note
+ Actually the preceding paragraph is an oversimplification: there are
+ two cases in which a function-call construct will be treated as a cast
+ request without having matched it to an actual function.
+ If a function call name(x) does not
+ exactly match any existing function, but name is the name
+ of a data type and pg_cast provides a binary-coercible cast
+ to this type from the type of x, then the call will be
+ construed as a binary-coercible cast. This exception is made so that
+ binary-coercible casts can be invoked using functional syntax, even
+ though they lack any function. Likewise, if there is no
+ pg_cast entry but the cast would be to or from a string
+ type, the call will be construed as an I/O conversion cast. This
+ exception allows I/O conversion casts to be invoked using functional
+ syntax.
+
Note
+ There is also an exception to the exception: I/O conversion casts from
+ composite types to string types cannot be invoked using functional
+ syntax, but must be written in explicit cast syntax (either
+ CAST or :: notation). This exception was added
+ because after the introduction of automatically-provided I/O conversion
+ casts, it was found too easy to accidentally invoke such a cast when
+ a function or column reference was intended.
+
Examples
+ To create an assignment cast from type bigint to type
+ int4 using the function int4(bigint):
+
+CREATE CAST (bigint AS int4) WITH FUNCTION int4(bigint) AS ASSIGNMENT;
+
+ (This cast is already predefined in the system.)
+
Compatibility
+ The CREATE CAST command conforms to the
+ SQL standard,
+ except that SQL does not make provisions for binary-coercible
+ types or extra arguments to implementation functions.
+ AS IMPLICIT is a PostgreSQL
+ extension, too.
+
CREATE COLLATION
CREATE COLLATION — define a new collation
Synopsis
+CREATE COLLATION [ IF NOT EXISTS ] name (
+ [ LOCALE = locale, ]
+ [ LC_COLLATE = lc_collate, ]
+ [ LC_CTYPE = lc_ctype, ]
+ [ PROVIDER = provider, ]
+ [ DETERMINISTIC = boolean, ]
+ [ RULES = rules, ]
+ [ VERSION = version ]
+)
+CREATE COLLATION [ IF NOT EXISTS ] name FROM existing_collation
+
Description
+ CREATE COLLATION defines a new collation using
+ the specified operating system locale settings,
+ or by copying an existing collation.
+
+ To be able to create a collation, you must
+ have CREATE privilege on the destination schema.
+
Parameters
IF NOT EXISTS
+ Do not throw an error if a collation with the same name already exists.
+ A notice is issued in this case. Note that there is no guarantee that
+ the existing collation is anything like the one that would have been created.
+
name
+ The name of the collation. The collation name can be
+ schema-qualified. If it is not, the collation is defined in the
+ current schema. The collation name must be unique within that
+ schema. (The system catalogs can contain collations with the
+ same name for other encodings, but these are ignored if the
+ database encoding does not match.)
+
locale
+ The locale name for this collation. See Section 24.2.2.3.1 and Section 24.2.2.3.2 for details.
+
+ If provider is libc, this
+ is a shortcut for setting LC_COLLATE and
+ LC_CTYPE at once. If you specify
+ locale, you cannot specify either of those
+ parameters.
+
lc_collate
+ If provider is libc, use
+ the specified operating system locale for the
+ LC_COLLATE locale category.
+
lc_ctype
+ If provider is libc, use
+ the specified operating system locale for the LC_CTYPE
+ locale category.
+
provider
+ Specifies the provider to use for locale services associated with this
+ collation. Possible values are
+ icu
+ (if the server was built with ICU support) or libc.
+ libc is the default. See Section 24.1.4 for details.
+
DETERMINISTIC
+ Specifies whether the collation should use deterministic comparisons.
+ The default is true. A deterministic comparison considers strings that
+ are not byte-wise equal to be unequal even if they are considered
+ logically equal by the comparison. PostgreSQL breaks ties using a
+ byte-wise comparison. Comparison that is not deterministic can make the
+ collation be, say, case- or accent-insensitive. For that, you need to
+ choose an appropriate LOCALE setting
+ and set the collation to not deterministic here.
+
+ Nondeterministic collations are only supported with the ICU provider.
+
rules
+ Specifies additional collation rules to customize the behavior of the
+ collation. This is supported for ICU only. See Section 24.2.3.4 for details.
+
version
+ Specifies the version string to store with the collation. Normally,
+ this should be omitted, which will cause the version to be computed
+ from the actual version of the collation as provided by the operating
+ system. This option is intended to be used
+ by pg_upgrade for copying the version from an
+ existing installation.
+
+ See also ALTER COLLATION for how to handle
+ collation version mismatches.
+
existing_collation
+ The name of an existing collation to copy. The new collation
+ will have the same properties as the existing one, but it
+ will be an independent object.
+
Notes
+ CREATE COLLATION takes a SHARE ROW
+ EXCLUSIVE lock, which is self-conflicting, on the
+ pg_collation system catalog, so only one
+ CREATE COLLATION command can run at a time.
+
+ Use DROP COLLATION to remove user-defined collations.
+
+ See Section 24.2.2.3 for more information on how to create collations.
+
+ When using the libc collation provider, the locale must
+ be applicable to the current database encoding.
+ See CREATE DATABASE for the precise rules.
+
Examples
+ To create a collation from the operating system locale
+ fr_FR.utf8
+ (assuming the current database encoding is UTF8):
+
+CREATE COLLATION french (locale = 'fr_FR.utf8');
+
+
+ To create a collation using the ICU provider using German phone book sort order:
+
+CREATE COLLATION german_phonebook (provider = icu, locale = 'de-u-co-phonebk');
+
+
+ To create a collation using the ICU provider, based on the root ICU locale,
+ with custom rules:
+
+CREATE COLLATION custom (provider = icu, locale = 'und', rules = '&V << w <<< W');
+
+ See Section 24.2.3.4 for further details and examples
+ on the rules syntax.
+
+ To create a collation from an existing collation:
+
+CREATE COLLATION german FROM "de_DE";
+
+ This can be convenient to be able to use operating-system-independent
+ collation names in applications.
+
Compatibility
+ There is a CREATE COLLATION statement in the SQL
+ standard, but it is limited to copying an existing collation. The
+ syntax to create a new collation is
+ a PostgreSQL extension.
+
CREATE CONVERSION
CREATE CONVERSION — define a new encoding conversion
Synopsis
+CREATE [ DEFAULT ] CONVERSION name
+ FOR source_encoding TO dest_encoding FROM function_name
+
Description
+ CREATE CONVERSION defines a new conversion between
+ two character set encodings.
+
+ Conversions that are marked DEFAULT can be used for
+ automatic encoding conversion between client and server. To support that
+ usage, two conversions, from encoding A to B and
+ from encoding B to A, must be defined.
+
+ To be able to create a conversion, you must have EXECUTE privilege
+ on the function and CREATE privilege on the destination schema.
+
Parameters
DEFAULT
+ The DEFAULT clause indicates that this conversion
+ is the default for this particular source to destination
+ encoding. There should be only one default encoding in a schema
+ for the encoding pair.
+
name
+ The name of the conversion. The conversion name can be
+ schema-qualified. If it is not, the conversion is defined in the
+ current schema. The conversion name must be unique within a
+ schema.
+
source_encoding
+ The source encoding name.
+
dest_encoding
+ The destination encoding name.
+
function_name
+ The function used to perform the conversion. The function name can
+ be schema-qualified. If it is not, the function will be looked
+ up in the path.
+
+ The function must have the following signature:
+
+
+conv_proc(
+ integer, -- source encoding ID
+ integer, -- destination encoding ID
+ cstring, -- source string (null terminated C string)
+ internal, -- destination (fill with a null terminated C string)
+ integer, -- source string length
+ boolean -- if true, don't throw an error if conversion fails
+) RETURNS integer;
+
+ The return value is the number of source bytes that were successfully
+ converted. If the last argument is false, the function must throw an
+ error on invalid input, and the return value is always equal to the
+ source string length.
+
Notes
+ Neither the source nor the destination encoding can
+ be SQL_ASCII, as the server's behavior for cases
+ involving the SQL_ASCII “encoding” is
+ hard-wired.
+
+ Use DROP CONVERSION to remove user-defined conversions.
+
+ The privileges required to create a conversion might be changed in a future
+ release.
+
Examples
+ To create a conversion from encoding UTF8 to
+ LATIN1 using myfunc:
+
+CREATE CONVERSION myconv FOR 'UTF8' TO 'LATIN1' FROM myfunc;
+
Compatibility
+ CREATE CONVERSION
+ is a PostgreSQL extension.
+ There is no CREATE CONVERSION
+ statement in the SQL standard, but a CREATE TRANSLATION
+ statement that is very similar in purpose and syntax.
+
CREATE DATABASE
CREATE DATABASE — create a new database
Synopsis
+CREATE DATABASE name
+ [ WITH ] [ OWNER [=] user_name ]
+ [ TEMPLATE [=] template ]
+ [ ENCODING [=] encoding ]
+ [ STRATEGY [=] strategy ]
+ [ LOCALE [=] locale ]
+ [ LC_COLLATE [=] lc_collate ]
+ [ LC_CTYPE [=] lc_ctype ]
+ [ ICU_LOCALE [=] icu_locale ]
+ [ ICU_RULES [=] icu_rules ]
+ [ LOCALE_PROVIDER [=] locale_provider ]
+ [ COLLATION_VERSION = collation_version ]
+ [ TABLESPACE [=] tablespace_name ]
+ [ ALLOW_CONNECTIONS [=] allowconn ]
+ [ CONNECTION LIMIT [=] connlimit ]
+ [ IS_TEMPLATE [=] istemplate ]
+ [ OID [=] oid ]
+
Description
+ CREATE DATABASE creates a new
+ PostgreSQL database.
+
+ To create a database, you must be a superuser or have the special
+ CREATEDB privilege.
+ See CREATE ROLE.
+
+ By default, the new database will be created by cloning the standard
+ system database template1. A different template can be
+ specified by writing TEMPLATE
+ name. In particular,
+ by writing TEMPLATE template0, you can create a pristine
+ database (one where no user-defined objects exist and where the system
+ objects have not been altered)
+ containing only the standard objects predefined by your
+ version of PostgreSQL. This is useful
+ if you wish to avoid copying
+ any installation-local objects that might have been added to
+ template1.
+
Parameters
name #
+ The name of a database to create.
+
user_name #
+ The role name of the user who will own the new database,
+ or DEFAULT to use the default (namely, the
+ user executing the command). To create a database owned by another
+ role, you must be able to SET ROLE to that
+ role.
+
template #
+ The name of the template from which to create the new database,
+ or DEFAULT to use the default template
+ (template1).
+
encoding #
+ Character set encoding to use in the new database. Specify
+ a string constant (e.g., 'SQL_ASCII'),
+ or an integer encoding number, or DEFAULT
+ to use the default encoding (namely, the encoding of the
+ template database). The character sets supported by the
+ PostgreSQL server are described in
+ Section 24.3.1. See below for
+ additional restrictions.
+
strategy #
+ Strategy to be used in creating the new database. If
+ the WAL_LOG strategy is used, the database will be
+ copied block by block and each block will be separately written
+ to the write-ahead log. This is the most efficient strategy in
+ cases where the template database is small, and therefore it is the
+ default. The older FILE_COPY strategy is also
+ available. This strategy writes a small record to the write-ahead log
+ for each tablespace used by the target database. Each such record
+ represents copying an entire directory to a new location at the
+ filesystem level. While this does reduce the write-ahead
+ log volume substantially, especially if the template database is large,
+ it also forces the system to perform a checkpoint both before and
+ after the creation of the new database. In some situations, this may
+ have a noticeable negative impact on overall system performance.
+
locale #
+ Sets the default collation order and character classification in the
+ new database. Collation affects the sort order applied to strings,
+ e.g., in queries with ORDER BY, as well as the order used in indexes
+ on text columns. Character classification affects the categorization
+ of characters, e.g., lower, upper, and digit. Also sets the
+ associated aspects of the operating system environment,
+ LC_COLLATE and LC_CTYPE. The
+ default is the same setting as the template database. See Section 24.2.2.3.1 and Section 24.2.2.3.2 for details.
+
+ Can be overridden by setting lc_collate, lc_ctype, or icu_locale individually.
+
Tip
+ The other locale settings lc_messages, lc_monetary, lc_numeric, and
+ lc_time are not fixed per database and are not
+ set by this command. If you want to make them the default for a
+ specific database, you can use ALTER DATABASE
+ ... SET.
+
lc_collate #
+ Sets LC_COLLATE in the database server's operating
+ system environment. The default is the setting of locale if specified, otherwise the same
+ setting as the template database. See below for additional
+ restrictions.
+
+ If locale_provider is
+ libc, also sets the default collation order to use
+ in the new database, overriding the setting locale.
+
lc_ctype #
+ Sets LC_CTYPE in the database server's operating
+ system environment. The default is the setting of locale if specified, otherwise the same
+ setting as the template database. See below for additional
+ restrictions.
+
+ If locale_provider is
+ libc, also sets the default character
+ classification to use in the new database, overriding the setting
+ locale.
+
icu_locale #
+ Specifies the ICU locale (see Section 24.2.2.3.2) for the database default
+ collation order and character classification, overriding the setting
+ locale. The locale provider must be ICU. The default
+ is the setting of locale if
+ specified; otherwise the same setting as the template database.
+
icu_rules #
+ Specifies additional collation rules to customize the behavior of the
+ default collation of this database. This is supported for ICU only.
+ See Section 24.2.3.4 for details.
+
locale_provider #
+ Specifies the provider to use for the default collation in this
+ database. Possible values are
+ icu
+ (if the server was built with ICU support) or libc.
+ By default, the provider is the same as that of the template. See Section 24.1.4 for details.
+
collation_version #
+ Specifies the collation version string to store with the database.
+ Normally, this should be omitted, which will cause the version to be
+ computed from the actual version of the database collation as provided
+ by the operating system. This option is intended to be used by
+ pg_upgrade for copying the version from an existing
+ installation.
+
+ See also ALTER DATABASE for how to handle
+ database collation version mismatches.
+
tablespace_name #
+ The name of the tablespace that will be associated with the
+ new database, or DEFAULT to use the
+ template database's tablespace. This
+ tablespace will be the default tablespace used for objects
+ created in this database. See
+ CREATE TABLESPACE
+ for more information.
+
allowconn #
+ If false then no one can connect to this database. The default is
+ true, allowing connections (except as restricted by other mechanisms,
+ such as GRANT/REVOKE CONNECT).
+
connlimit #
+ How many concurrent connections can be made
+ to this database. -1 (the default) means no limit.
+
istemplate #
+ If true, then this database can be cloned by any user with CREATEDB
+ privileges; if false (the default), then only superusers or the owner
+ of the database can clone it.
+
oid #
+ The object identifier to be used for the new database. If this
+ parameter is not specified, PostgreSQL
+ will choose a suitable OID automatically. This parameter is primarily
+ intended for internal use by pg_upgrade,
+ and only pg_upgrade can specify a value
+ less than 16384.
+
+ Optional parameters can be written in any order, not only the order
+ illustrated above.
+
Notes
+ CREATE DATABASE cannot be executed inside a transaction
+ block.
+
+ Errors along the line of “could not initialize database directory”
+ are most likely related to insufficient permissions on the data
+ directory, a full disk, or other file system problems.
+
+ Use DROP DATABASE to remove a database.
+
+ The program createdb is a
+ wrapper program around this command, provided for convenience.
+
+ Database-level configuration parameters (set via ALTER DATABASE) and database-level permissions (set via
+ GRANT) are not copied from the template database.
+
+ Although it is possible to copy a database other than template1
+ by specifying its name as the template, this is not (yet) intended as
+ a general-purpose “COPY DATABASE” facility.
+ The principal limitation is that no other sessions can be connected to
+ the template database while it is being copied. CREATE
+ DATABASE will fail if any other connection exists when it starts;
+ otherwise, new connections to the template database are locked out
+ until CREATE DATABASE completes.
+ See Section 23.3 for more information.
+
+ The character set encoding specified for the new database must be
+ compatible with the chosen locale settings (LC_COLLATE and
+ LC_CTYPE). If the locale is C (or equivalently
+ POSIX), then all encodings are allowed, but for other
+ locale settings there is only one encoding that will work properly.
+ (On Windows, however, UTF-8 encoding can be used with any locale.)
+ CREATE DATABASE will allow superusers to specify
+ SQL_ASCII encoding regardless of the locale settings,
+ but this choice is deprecated and may result in misbehavior of
+ character-string functions if data that is not encoding-compatible
+ with the locale is stored in the database.
+
+ The encoding and locale settings must match those of the template database,
+ except when template0 is used as template. This is because
+ other databases might contain data that does not match the specified
+ encoding, or might contain indexes whose sort ordering is affected by
+ LC_COLLATE and LC_CTYPE. Copying such data would
+ result in a database that is corrupt according to the new settings.
+ template0, however, is known to not contain any data or
+ indexes that would be affected.
+
+ There is currently no option to use a database locale with nondeterministic
+ comparisons (see CREATE
+ COLLATION for an explanation). If this is needed, then
+ per-column collations would need to be used.
+
+ The CONNECTION LIMIT option is only enforced approximately;
+ if two new sessions start at about the same time when just one
+ connection “slot” remains for the database, it is possible that
+ both will fail. Also, the limit is not enforced against superusers or
+ background worker processes.
+
Examples
+ To create a new database:
+
+
+CREATE DATABASE lusiadas;
+
+
+ To create a database sales owned by user salesapp
+ with a default tablespace of salesspace:
+
+
+CREATE DATABASE sales OWNER salesapp TABLESPACE salesspace;
+
+
+ To create a database music with a different locale:
+
+CREATE DATABASE music
+ LOCALE 'sv_SE.utf8'
+ TEMPLATE template0;
+
+ In this example, the TEMPLATE template0 clause is required if
+ the specified locale is different from the one in template1.
+ (If it is not, then specifying the locale explicitly is redundant.)
+
+ To create a database music2 with a different locale and a
+ different character set encoding:
+
+CREATE DATABASE music2
+ LOCALE 'sv_SE.iso885915'
+ ENCODING LATIN9
+ TEMPLATE template0;
+
+ The specified locale and encoding settings must match, or an error will be
+ reported.
+
+ Note that locale names are specific to the operating system, so that the
+ above commands might not work in the same way everywhere.
+
Compatibility
+ There is no CREATE DATABASE statement in the SQL
+ standard. Databases are equivalent to catalogs, whose creation is
+ implementation-defined.
+
CREATE DOMAIN
CREATE DOMAIN — define a new domain
Synopsis
+CREATE DOMAIN name [ AS ] data_type
+ [ COLLATE collation ]
+ [ DEFAULT expression ]
+ [ constraint [ ... ] ]
+
+where constraint is:
+
+[ CONSTRAINT constraint_name ]
+{ NOT NULL | NULL | CHECK (expression) }
+
Description
+ CREATE DOMAIN creates a new domain. A domain is
+ essentially a data type with optional constraints (restrictions on
+ the allowed set of values).
+ The user who defines a domain becomes its owner.
+
+ If a schema name is given (for example, CREATE DOMAIN
+ myschema.mydomain ...) then the domain is created in the
+ specified schema. Otherwise it is created in the current schema.
+ The domain name must be unique among the types and domains existing
+ in its schema.
+
+ Domains are useful for abstracting common constraints on fields into
+ a single location for maintenance. For example, several tables might
+ contain email address columns, all requiring the same CHECK constraint
+ to verify the address syntax.
+ Define a domain rather than setting up each table's constraint
+ individually.
+
+ To be able to create a domain, you must have USAGE
+ privilege on the underlying type.
+
Parameters
name
+ The name (optionally schema-qualified) of a domain to be created.
+
data_type
+ The underlying data type of the domain. This can include array
+ specifiers.
+
collation
+ An optional collation for the domain. If no collation is
+ specified, the domain has the same collation behavior as its
+ underlying data type.
+ The underlying type must be collatable if COLLATE
+ is specified.
+
DEFAULT expression
+ The DEFAULT clause specifies a default value for
+ columns of the domain data type. The value is any
+ variable-free expression (but subqueries are not allowed).
+ The data type of the default expression must match the data
+ type of the domain. If no default value is specified, then
+ the default value is the null value.
+
+ The default expression will be used in any insert operation
+ that does not specify a value for the column. If a default
+ value is defined for a particular column, it overrides any
+ default associated with the domain. In turn, the domain
+ default overrides any default value associated with the
+ underlying data type.
+
CONSTRAINT constraint_name
+ An optional name for a constraint. If not specified,
+ the system generates a name.
+
NOT NULL
+ Values of this domain are prevented from being null
+ (but see notes below).
+
NULL
+ Values of this domain are allowed to be null. This is the default.
+
+ This clause is only intended for compatibility with
+ nonstandard SQL databases. Its use is discouraged in new
+ applications.
+
CHECK (expression)CHECK clauses specify integrity constraints or tests
+ which values of the domain must satisfy.
+ Each constraint must be an expression
+ producing a Boolean result. It should use the key word VALUE
+ to refer to the value being tested. Expressions evaluating
+ to TRUE or UNKNOWN succeed. If the expression produces a FALSE result,
+ an error is reported and the value is not allowed to be converted
+ to the domain type.
+
+ Currently, CHECK expressions cannot contain
+ subqueries nor refer to variables other than VALUE.
+
+ When a domain has multiple CHECK constraints,
+ they will be tested in alphabetical order by name.
+ (PostgreSQL versions before 9.5 did not honor any
+ particular firing order for CHECK constraints.)
+
Notes
+ Domain constraints, particularly NOT NULL, are checked when
+ converting a value to the domain type. It is possible for a column that
+ is nominally of the domain type to read as null despite there being such
+ a constraint. For example, this can happen in an outer-join query, if
+ the domain column is on the nullable side of the outer join. A more
+ subtle example is
+
+INSERT INTO tab (domcol) VALUES ((SELECT domcol FROM tab WHERE false));
+
+ The empty scalar sub-SELECT will produce a null value that is considered
+ to be of the domain type, so no further constraint checking is applied
+ to it, and the insertion will succeed.
+
+ It is very difficult to avoid such problems, because of SQL's general
+ assumption that a null value is a valid value of every data type. Best practice
+ therefore is to design a domain's constraints so that a null value is allowed,
+ and then to apply column NOT NULL constraints to columns of
+ the domain type as needed, rather than directly to the domain type.
+
+ PostgreSQL assumes that
+ CHECK constraints' conditions are immutable, that is,
+ they will always give the same result for the same input value. This
+ assumption is what justifies examining CHECK
+ constraints only when a value is first converted to be of a domain type,
+ and not at other times. (This is essentially the same as the treatment
+ of table CHECK constraints, as described in
+ Section 5.4.1.)
+
+ An example of a common way to break this assumption is to reference a
+ user-defined function in a CHECK expression, and then
+ change the behavior of that
+ function. PostgreSQL does not disallow that,
+ but it will not notice if there are stored values of the domain type that
+ now violate the CHECK constraint. That would cause a
+ subsequent database dump and restore to fail. The recommended way to
+ handle such a change is to drop the constraint (using ALTER
+ DOMAIN), adjust the function definition, and re-add the
+ constraint, thereby rechecking it against stored data.
+
+ It's also good practice to ensure that domain CHECK
+ expressions will not throw errors.
+
Examples
+ This example creates the us_postal_code data type and
+ then uses the type in a table definition. A regular expression test
+ is used to verify that the value looks like a valid US postal code:
+
+
+CREATE DOMAIN us_postal_code AS TEXT
+CHECK(
+ VALUE ~ '^\d{5}$'
+OR VALUE ~ '^\d{5}-\d{4}$'
+);
+
+CREATE TABLE us_snail_addy (
+ address_id SERIAL PRIMARY KEY,
+ street1 TEXT NOT NULL,
+ street2 TEXT,
+ street3 TEXT,
+ city TEXT NOT NULL,
+ postal us_postal_code NOT NULL
+);
+Compatibility
+ The command CREATE DOMAIN conforms to the SQL
+ standard.
+
CREATE EVENT TRIGGER
CREATE EVENT TRIGGER — define a new event trigger
Synopsis
+CREATE EVENT TRIGGER name
+ ON event
+ [ WHEN filter_variable IN (filter_value [, ... ]) [ AND ... ] ]
+ EXECUTE { FUNCTION | PROCEDURE } function_name()
+
Description
+ CREATE EVENT TRIGGER creates a new event trigger.
+ Whenever the designated event occurs and the WHEN condition
+ associated with the trigger, if any, is satisfied, the trigger function
+ will be executed. For a general introduction to event triggers, see
+ Chapter 40. The user who creates an event trigger
+ becomes its owner.
+
Parameters
name
+ The name to give the new trigger. This name must be unique within
+ the database.
+
event
+ The name of the event that triggers a call to the given function.
+ See Section 40.1 for more information
+ on event names.
+
filter_variable
+ The name of a variable used to filter events. This makes it possible
+ to restrict the firing of the trigger to a subset of the cases in which
+ it is supported. Currently the only supported
+ filter_variable
+ is TAG.
+
filter_value
+ A list of values for the
+ associated filter_variable
+ for which the trigger should fire. For TAG, this means a
+ list of command tags (e.g., 'DROP FUNCTION').
+
function_name
+ A user-supplied function that is declared as taking no argument and
+ returning type event_trigger.
+
+ In the syntax of CREATE EVENT TRIGGER, the keywords
+ FUNCTION and PROCEDURE are
+ equivalent, but the referenced function must in any case be a function,
+ not a procedure. The use of the keyword PROCEDURE
+ here is historical and deprecated.
+
Notes
+ Only superusers can create event triggers.
+
+ Event triggers are disabled in single-user mode (see postgres). If an erroneous event trigger disables the
+ database so much that you can't even drop the trigger, restart in
+ single-user mode and you'll be able to do that.
+
Examples
+ Forbid the execution of any DDL command:
+
+
+CREATE OR REPLACE FUNCTION abort_any_command()
+ RETURNS event_trigger
+ LANGUAGE plpgsql
+ AS $$
+BEGIN
+ RAISE EXCEPTION 'command % is disabled', tg_tag;
+END;
+$$;
+
+CREATE EVENT TRIGGER abort_ddl ON ddl_command_start
+ EXECUTE FUNCTION abort_any_command();
+
Compatibility
+ There is no CREATE EVENT TRIGGER statement in the
+ SQL standard.
+
CREATE EXTENSION
CREATE EXTENSION — install an extension
Synopsis
+CREATE EXTENSION [ IF NOT EXISTS ] extension_name
+ [ WITH ] [ SCHEMA schema_name ]
+ [ VERSION version ]
+ [ CASCADE ]
+
Description
+ CREATE EXTENSION loads a new extension into the current
+ database. There must not be an extension of the same name already loaded.
+
+ Loading an extension essentially amounts to running the extension's script
+ file. The script will typically create new SQL objects such as
+ functions, data types, operators and index support methods.
+ CREATE EXTENSION additionally records the identities
+ of all the created objects, so that they can be dropped again if
+ DROP EXTENSION is issued.
+
+ The user who runs CREATE EXTENSION becomes the
+ owner of the extension for purposes of later privilege checks, and
+ normally also becomes the owner of any objects created by the
+ extension's script.
+
+ Loading an extension ordinarily requires the same privileges that would
+ be required to create its component objects. For many extensions this
+ means superuser privileges are needed.
+ However, if the extension is marked trusted in
+ its control file, then it can be installed by any user who has
+ CREATE privilege on the current database.
+ In this case the extension object itself will be owned by the calling
+ user, but the contained objects will be owned by the bootstrap superuser
+ (unless the extension's script explicitly assigns them to the calling
+ user). This configuration gives the calling user the right to drop the
+ extension, but not to modify individual objects within it.
+
Parameters
IF NOT EXISTS
+ Do not throw an error if an extension with the same name already
+ exists. A notice is issued in this case. Note that there is no
+ guarantee that the existing extension is anything like the one that
+ would have been created from the currently-available script file.
+
extension_name
+ The name of the extension to be
+ installed. PostgreSQL will create the
+ extension using details from the file
+ SHAREDIR/extension/extension_name.control.
+
schema_name
+ The name of the schema in which to install the extension's
+ objects, given that the extension allows its contents to be
+ relocated. The named schema must already exist.
+ If not specified, and the extension's control file does not specify a
+ schema either, the current default object creation schema is used.
+
+ If the extension specifies a schema parameter in its
+ control file, then that schema cannot be overridden with
+ a SCHEMA clause. Normally, an error will be raised if
+ a SCHEMA clause is given and it conflicts with the
+ extension's schema parameter. However, if
+ the CASCADE clause is also given,
+ then schema_name is
+ ignored when it conflicts. The
+ given schema_name will be
+ used for installation of any needed extensions that do not
+ specify schema in their control files.
+
+ Remember that the extension itself is not considered to be within any
+ schema: extensions have unqualified names that must be unique
+ database-wide. But objects belonging to the extension can be within
+ schemas.
+
version
+ The version of the extension to install. This can be written as
+ either an identifier or a string literal. The default version is
+ whatever is specified in the extension's control file.
+
CASCADE
+ Automatically install any extensions that this extension depends on
+ that are not already installed. Their dependencies are likewise
+ automatically installed, recursively. The SCHEMA clause,
+ if given, applies to all extensions that get installed this way.
+ Other options of the statement are not applied to
+ automatically-installed extensions; in particular, their default
+ versions are always selected.
+
Notes
+ Before you can use CREATE EXTENSION to load an extension
+ into a database, the extension's supporting files must be installed.
+ Information about installing the extensions supplied with
+ PostgreSQL can be found in
+ Additional Supplied Modules.
+
+ The extensions currently available for loading can be identified from the
+ pg_available_extensions
+ or
+ pg_available_extension_versions
+ system views.
+
Caution
+ Installing an extension as superuser requires trusting that the
+ extension's author wrote the extension installation script in a secure
+ fashion. It is not terribly difficult for a malicious user to create
+ trojan-horse objects that will compromise later execution of a
+ carelessly-written extension script, allowing that user to acquire
+ superuser privileges. However, trojan-horse objects are only hazardous
+ if they are in the search_path during script
+ execution, meaning that they are in the extension's installation target
+ schema or in the schema of some extension it depends on. Therefore, a
+ good rule of thumb when dealing with extensions whose scripts have not
+ been carefully vetted is to install them only into schemas for which
+ CREATE privilege has not been and will not be granted to any untrusted
+ users. Likewise for any extensions they depend on.
+
+ The extensions supplied with PostgreSQL are
+ believed to be secure against installation-time attacks of this sort,
+ except for a few that depend on other extensions. As stated in the
+ documentation for those extensions, they should be installed into secure
+ schemas, or installed into the same schemas as the extensions they
+ depend on, or both.
+
+ For information about writing new extensions, see
+ Section 38.17.
+
Examples
+ Install the hstore extension into the
+ current database, placing its objects in schema addons:
+
+CREATE EXTENSION hstore SCHEMA addons;
+
+ Another way to accomplish the same thing:
+
+SET search_path = addons;
+CREATE EXTENSION hstore;
+
Compatibility
+ CREATE EXTENSION is a PostgreSQL
+ extension.
+
CREATE FOREIGN DATA WRAPPER
CREATE FOREIGN DATA WRAPPER — define a new foreign-data wrapper
Synopsis
+CREATE FOREIGN DATA WRAPPER name
+ [ HANDLER handler_function | NO HANDLER ]
+ [ VALIDATOR validator_function | NO VALIDATOR ]
+ [ OPTIONS ( option 'value' [, ... ] ) ]
+
Description
+ CREATE FOREIGN DATA WRAPPER creates a new
+ foreign-data wrapper. The user who defines a foreign-data wrapper
+ becomes its owner.
+
+ The foreign-data wrapper name must be unique within the database.
+
+ Only superusers can create foreign-data wrappers.
+
Parameters
name
+ The name of the foreign-data wrapper to be created.
+
HANDLER handler_functionhandler_function is the
+ name of a previously registered function that will be called to
+ retrieve the execution functions for foreign tables.
+ The handler function must take no arguments, and
+ its return type must be fdw_handler.
+
+ It is possible to create a foreign-data wrapper with no handler
+ function, but foreign tables using such a wrapper can only be declared,
+ not accessed.
+
VALIDATOR validator_functionvalidator_function
+ is the name of a previously registered function that will be called to
+ check the generic options given to the foreign-data wrapper, as
+ well as options for foreign servers, user mappings and foreign tables
+ using the foreign-data wrapper. If no validator function or NO
+ VALIDATOR is specified, then options will not be
+ checked at creation time. (Foreign-data wrappers will possibly
+ ignore or reject invalid option specifications at run time,
+ depending on the implementation.) The validator function must
+ take two arguments: one of type text[], which will
+ contain the array of options as stored in the system catalogs,
+ and one of type oid, which will be the OID of the
+ system catalog containing the options. The return type is ignored;
+ the function should report invalid options using the
+ ereport(ERROR) function.
+
OPTIONS ( option 'value' [, ... ] )
+ This clause specifies options for the new foreign-data wrapper.
+ The allowed option names and values are specific to each foreign
+ data wrapper and are validated using the foreign-data wrapper's
+ validator function. Option names must be unique.
+
Notes
+ PostgreSQL's foreign-data functionality is still under
+ active development. Optimization of queries is primitive (and mostly left
+ to the wrapper, too). Thus, there is considerable room for future
+ performance improvements.
+
Examples
+ Create a useless foreign-data wrapper dummy:
+
+CREATE FOREIGN DATA WRAPPER dummy;
+
+
+ Create a foreign-data wrapper file with
+ handler function file_fdw_handler:
+
+CREATE FOREIGN DATA WRAPPER file HANDLER file_fdw_handler;
+
+
+ Create a foreign-data wrapper mywrapper with some
+ options:
+
+CREATE FOREIGN DATA WRAPPER mywrapper
+ OPTIONS (debug 'true');
+
Compatibility
+ CREATE FOREIGN DATA WRAPPER conforms to ISO/IEC
+ 9075-9 (SQL/MED), with the exception that the HANDLER
+ and VALIDATOR clauses are extensions and the standard
+ clauses LIBRARY and LANGUAGE
+ are not implemented in PostgreSQL.
+
+ Note, however, that the SQL/MED functionality as a whole is not yet
+ conforming.
+
CREATE FOREIGN TABLE
CREATE FOREIGN TABLE — define a new foreign table
Synopsis
+CREATE FOREIGN TABLE [ IF NOT EXISTS ] table_name ( [
+ { column_name data_type [ OPTIONS ( option 'value' [, ... ] ) ] [ COLLATE collation ] [ column_constraint [ ... ] ]
+ | table_constraint }
+ [, ... ]
+] )
+[ INHERITS ( parent_table [, ... ] ) ]
+ SERVER server_name
+[ OPTIONS ( option 'value' [, ... ] ) ]
+
+CREATE FOREIGN TABLE [ IF NOT EXISTS ] table_name
+ PARTITION OF parent_table [ (
+ { column_name [ WITH OPTIONS ] [ column_constraint [ ... ] ]
+ | table_constraint }
+ [, ... ]
+) ]
+{ FOR VALUES partition_bound_spec | DEFAULT }
+ SERVER server_name
+[ OPTIONS ( option 'value' [, ... ] ) ]
+
+where column_constraint is:
+
+[ CONSTRAINT constraint_name ]
+{ NOT NULL |
+ NULL |
+ CHECK ( expression ) [ NO INHERIT ] |
+ DEFAULT default_expr |
+ GENERATED ALWAYS AS ( generation_expr ) STORED }
+
+and table_constraint is:
+
+[ CONSTRAINT constraint_name ]
+CHECK ( expression ) [ NO INHERIT ]
+
+and partition_bound_spec is:
+
+IN ( partition_bound_expr [, ...] ) |
+FROM ( { partition_bound_expr | MINVALUE | MAXVALUE } [, ...] )
+ TO ( { partition_bound_expr | MINVALUE | MAXVALUE } [, ...] ) |
+WITH ( MODULUS numeric_literal, REMAINDER numeric_literal )
+
Description
+ CREATE FOREIGN TABLE creates a new foreign table
+ in the current database. The table will be owned by the user issuing the
+ command.
+
+ If a schema name is given (for example, CREATE FOREIGN TABLE
+ myschema.mytable ...) then the table is created in the specified
+ schema. Otherwise it is created in the current schema.
+ The name of the foreign table must be
+ distinct from the name of any other relation (table, sequence, index, view,
+ materialized view, or foreign table) in the same schema.
+
+ CREATE FOREIGN TABLE also automatically creates a data
+ type that represents the composite type corresponding to one row of
+ the foreign table. Therefore, foreign tables cannot have the same
+ name as any existing data type in the same schema.
+
+ If PARTITION OF clause is specified then the table is
+ created as a partition of parent_table with specified
+ bounds.
+
+ To be able to create a foreign table, you must have USAGE
+ privilege on the foreign server, as well as USAGE
+ privilege on all column types used in the table.
+
Parameters
IF NOT EXISTS
+ Do not throw an error if a relation with the same name already exists.
+ A notice is issued in this case. Note that there is no guarantee that
+ the existing relation is anything like the one that would have been
+ created.
+
table_name
+ The name (optionally schema-qualified) of the table to be created.
+
column_name
+ The name of a column to be created in the new table.
+
data_type
+ The data type of the column. This can include array
+ specifiers. For more information on the data types supported by
+ PostgreSQL, refer to Chapter 8.
+
COLLATE collation
+ The COLLATE clause assigns a collation to
+ the column (which must be of a collatable data type).
+ If not specified, the column data type's default collation is used.
+
INHERITS ( parent_table [, ... ] )
+ The optional INHERITS clause specifies a list of
+ tables from which the new foreign table automatically inherits
+ all columns. Parent tables can be plain tables or foreign tables.
+ See the similar form of
+ CREATE TABLE for more details.
+
PARTITION OF parent_table { FOR VALUES partition_bound_spec | DEFAULT }
+ This form can be used to create the foreign table as partition of
+ the given parent table with specified partition bound values.
+ See the similar form of
+ CREATE TABLE for more details.
+ Note that it is currently not allowed to create the foreign table as a
+ partition of the parent table if there are UNIQUE
+ indexes on the parent table. (See also
+ ALTER TABLE ATTACH PARTITION.)
+
CONSTRAINT constraint_name
+ An optional name for a column or table constraint. If the
+ constraint is violated, the constraint name is present in error messages,
+ so constraint names like col must be positive can be used
+ to communicate helpful constraint information to client applications.
+ (Double-quotes are needed to specify constraint names that contain spaces.)
+ If a constraint name is not specified, the system generates a name.
+
NOT NULL
+ The column is not allowed to contain null values.
+
NULL
+ The column is allowed to contain null values. This is the default.
+
+ This clause is only provided for compatibility with
+ non-standard SQL databases. Its use is discouraged in new
+ applications.
+
CHECK ( expression ) [ NO INHERIT ]
+ The CHECK clause specifies an expression producing a
+ Boolean result which each row in the foreign table is expected
+ to satisfy; that is, the expression should produce TRUE or UNKNOWN,
+ never FALSE, for all rows in the foreign table.
+ A check constraint specified as a column constraint should
+ reference that column's value only, while an expression
+ appearing in a table constraint can reference multiple columns.
+
+ Currently, CHECK expressions cannot contain
+ subqueries nor refer to variables other than columns of the
+ current row. The system column tableoid
+ may be referenced, but not any other system column.
+
+ A constraint marked with NO INHERIT will not propagate to
+ child tables.
+
DEFAULT
+ default_expr
+ The DEFAULT clause assigns a default data value for
+ the column whose column definition it appears within. The value
+ is any variable-free expression (subqueries and cross-references
+ to other columns in the current table are not allowed). The
+ data type of the default expression must match the data type of the
+ column.
+
+ The default expression will be used in any insert operation that
+ does not specify a value for the column. If there is no default
+ for a column, then the default is null.
+
GENERATED ALWAYS AS ( generation_expr ) STORED
+ This clause creates the column as a generated
+ column. The column cannot be written to, and when read the
+ result of the specified expression will be returned.
+
+ The keyword STORED is required to signify that the
+ column will be computed on write. (The computed value will be presented
+ to the foreign-data wrapper for storage and must be returned on
+ reading.)
+
+ The generation expression can refer to other columns in the table, but
+ not other generated columns. Any functions and operators used must be
+ immutable. References to other tables are not allowed.
+
server_name
+ The name of an existing foreign server to use for the foreign table.
+ For details on defining a server, see CREATE SERVER.
+
OPTIONS ( option 'value' [, ...] )
+ Options to be associated with the new foreign table or one of its
+ columns.
+ The allowed option names and values are specific to each foreign
+ data wrapper and are validated using the foreign-data wrapper's
+ validator function. Duplicate option names are not allowed (although
+ it's OK for a table option and a column option to have the same name).
+
Notes
+ Constraints on foreign tables (such as CHECK
+ or NOT NULL clauses) are not enforced by the
+ core PostgreSQL system, and most foreign data wrappers
+ do not attempt to enforce them either; that is, the constraint is
+ simply assumed to hold true. There would be little point in such
+ enforcement since it would only apply to rows inserted or updated via
+ the foreign table, and not to rows modified by other means, such as
+ directly on the remote server. Instead, a constraint attached to a
+ foreign table should represent a constraint that is being enforced by
+ the remote server.
+
+ Some special-purpose foreign data wrappers might be the only access
+ mechanism for the data they access, and in that case it might be
+ appropriate for the foreign data wrapper itself to perform constraint
+ enforcement. But you should not assume that a wrapper does that
+ unless its documentation says so.
+
+ Although PostgreSQL does not attempt to enforce
+ constraints on foreign tables, it does assume that they are correct
+ for purposes of query optimization. If there are rows visible in the
+ foreign table that do not satisfy a declared constraint, queries on
+ the table might produce errors or incorrect answers. It is the user's
+ responsibility to ensure that the constraint definition matches
+ reality.
+
Caution
+ When a foreign table is used as a partition of a partitioned table,
+ there is an implicit constraint that its contents must satisfy the
+ partitioning rule. Again, it is the user's responsibility to ensure
+ that that is true, which is best done by installing a matching
+ constraint on the remote server.
+
+ Within a partitioned table containing foreign-table partitions,
+ an UPDATE that changes the partition key value can
+ cause a row to be moved from a local partition to a foreign-table
+ partition, provided the foreign data wrapper supports tuple routing.
+ However, it is not currently possible to move a row from a
+ foreign-table partition to another partition.
+ An UPDATE that would require doing that will fail
+ due to the partitioning constraint, assuming that that is properly
+ enforced by the remote server.
+
+ Similar considerations apply to generated columns. Stored generated
+ columns are computed on insert or update on the local
+ PostgreSQL server and handed to the
+ foreign-data wrapper for writing out to the foreign data store, but it is
+ not enforced that a query of the foreign table returns values for stored
+ generated columns that are consistent with the generation expression.
+ Again, this might result in incorrect query results.
+
Examples
+ Create foreign table films, which will be accessed through
+ the server film_server:
+
+
+CREATE FOREIGN TABLE films (
+ code char(5) NOT NULL,
+ title varchar(40) NOT NULL,
+ did integer NOT NULL,
+ date_prod date,
+ kind varchar(10),
+ len interval hour to minute
+)
+SERVER film_server;
+
+ Create foreign table measurement_y2016m07, which will be
+ accessed through the server server_07, as a partition
+ of the range partitioned table measurement:
+
+
+CREATE FOREIGN TABLE measurement_y2016m07
+ PARTITION OF measurement FOR VALUES FROM ('2016-07-01') TO ('2016-08-01')
+ SERVER server_07;
+Compatibility
+ The CREATE FOREIGN TABLE command largely conforms to the
+ SQL standard; however, much as with
+ CREATE TABLE,
+ NULL constraints and zero-column foreign tables are permitted.
+ The ability to specify column default values is also
+ a PostgreSQL extension. Table inheritance, in the form
+ defined by PostgreSQL, is nonstandard.
+
CREATE FUNCTION
CREATE FUNCTION — define a new function
Synopsis
+CREATE [ OR REPLACE ] FUNCTION
+ name ( [ [ argmode ] [ argname ] argtype [ { DEFAULT | = } default_expr ] [, ...] ] )
+ [ RETURNS rettype
+ | RETURNS TABLE ( column_name column_type [, ...] ) ]
+ { LANGUAGE lang_name
+ | TRANSFORM { FOR TYPE type_name } [, ... ]
+ | WINDOW
+ | { IMMUTABLE | STABLE | VOLATILE }
+ | [ NOT ] LEAKPROOF
+ | { CALLED ON NULL INPUT | RETURNS NULL ON NULL INPUT | STRICT }
+ | { [ EXTERNAL ] SECURITY INVOKER | [ EXTERNAL ] SECURITY DEFINER }
+ | PARALLEL { UNSAFE | RESTRICTED | SAFE }
+ | COST execution_cost
+ | ROWS result_rows
+ | SUPPORT support_function
+ | SET configuration_parameter { TO value | = value | FROM CURRENT }
+ | AS 'definition'
+ | AS 'obj_file', 'link_symbol'
+ | sql_body
+ } ...
+
Description
+ CREATE FUNCTION defines a new function.
+ CREATE OR REPLACE FUNCTION will either create a
+ new function, or replace an existing definition.
+ To be able to define a function, the user must have the
+ USAGE privilege on the language.
+
+ If a schema name is included, then the function is created in the
+ specified schema. Otherwise it is created in the current schema.
+ The name of the new function must not match any existing function or procedure
+ with the same input argument types in the same schema. However,
+ functions and procedures of different argument types can share a name (this is
+ called overloading).
+
+ To replace the current definition of an existing function, use
+ CREATE OR REPLACE FUNCTION. It is not possible
+ to change the name or argument types of a function this way (if you
+ tried, you would actually be creating a new, distinct function).
+ Also, CREATE OR REPLACE FUNCTION will not let
+ you change the return type of an existing function. To do that,
+ you must drop and recreate the function. (When using OUT
+ parameters, that means you cannot change the types of any
+ OUT parameters except by dropping the function.)
+
+ When CREATE OR REPLACE FUNCTION is used to replace an
+ existing function, the ownership and permissions of the function
+ do not change. All other function properties are assigned the
+ values specified or implied in the command. You must own the function
+ to replace it (this includes being a member of the owning role).
+
+ If you drop and then recreate a function, the new function is not
+ the same entity as the old; you will have to drop existing rules, views,
+ triggers, etc. that refer to the old function. Use
+ CREATE OR REPLACE FUNCTION to change a function
+ definition without breaking objects that refer to the function.
+ Also, ALTER FUNCTION can be used to change most of the
+ auxiliary properties of an existing function.
+
+ The user that creates the function becomes the owner of the function.
+
+ To be able to create a function, you must have USAGE
+ privilege on the argument types and the return type.
+
+ Refer to Section 38.3 for further information on writing
+ functions.
+
Parameters
name
+ The name (optionally schema-qualified) of the function to create.
+
argmode
+ The mode of an argument: IN, OUT,
+ INOUT, or VARIADIC.
+ If omitted, the default is IN.
+ Only OUT arguments can follow a VARIADIC one.
+ Also, OUT and INOUT arguments cannot be used
+ together with the RETURNS TABLE notation.
+
argname
+ The name of an argument. Some languages (including SQL and PL/pgSQL)
+ let you use the name in the function body. For other languages the
+ name of an input argument is just extra documentation, so far as
+ the function itself is concerned; but you can use input argument names
+ when calling a function to improve readability (see Section 4.3). In any case, the name
+ of an output argument is significant, because it defines the column
+ name in the result row type. (If you omit the name for an output
+ argument, the system will choose a default column name.)
+
argtype
+ The data type(s) of the function's arguments (optionally
+ schema-qualified), if any. The argument types can be base, composite,
+ or domain types, or can reference the type of a table column.
+
+ Depending on the implementation language it might also be allowed
+ to specify “pseudo-types” such as cstring.
+ Pseudo-types indicate that the actual argument type is either
+ incompletely specified, or outside the set of ordinary SQL data types.
+
+ The type of a column is referenced by writing
+ table_name.column_name%TYPE
default_expr
+ An expression to be used as default value if the parameter is
+ not specified. The expression has to be coercible to the
+ argument type of the parameter.
+ Only input (including INOUT) parameters can have a default
+ value. All input parameters following a
+ parameter with a default value must have default values as well.
+
rettype
+ The return data type (optionally schema-qualified). The return type
+ can be a base, composite, or domain type,
+ or can reference the type of a table column.
+ Depending on the implementation language it might also be allowed
+ to specify “pseudo-types” such as cstring.
+ If the function is not supposed to return a value, specify
+ void as the return type.
+
+ When there are OUT or INOUT parameters,
+ the RETURNS clause can be omitted. If present, it
+ must agree with the result type implied by the output parameters:
+ RECORD if there are multiple output parameters, or
+ the same type as the single output parameter.
+
+ The SETOF
+ modifier indicates that the function will return a set of
+ items, rather than a single item.
+
+ The type of a column is referenced by writing
+ table_name.column_name%TYPE
column_name
+ The name of an output column in the RETURNS TABLE
+ syntax. This is effectively another way of declaring a named
+ OUT parameter, except that RETURNS TABLE
+ also implies RETURNS SETOF.
+
column_type
+ The data type of an output column in the RETURNS TABLE
+ syntax.
+
lang_name
+ The name of the language that the function is implemented in.
+ It can be sql, c,
+ internal, or the name of a user-defined
+ procedural language, e.g., plpgsql. The default is
+ sql if sql_body is specified. Enclosing the
+ name in single quotes is deprecated and requires matching case.
+
TRANSFORM { FOR TYPE type_name } [, ... ] }
+ Lists which transforms a call to the function should apply. Transforms
+ convert between SQL types and language-specific data types;
+ see CREATE TRANSFORM. Procedural language
+ implementations usually have hardcoded knowledge of the built-in types,
+ so those don't need to be listed here. If a procedural language
+ implementation does not know how to handle a type and no transform is
+ supplied, it will fall back to a default behavior for converting data
+ types, but this depends on the implementation.
+
WINDOWWINDOW indicates that the function is a
+ window function rather than a plain function.
+ This is currently only useful for functions written in C.
+ The WINDOW attribute cannot be changed when
+ replacing an existing function definition.
+
IMMUTABLE
STABLE
VOLATILE
+ These attributes inform the query optimizer about the behavior
+ of the function. At most one choice
+ can be specified. If none of these appear,
+ VOLATILE is the default assumption.
+
IMMUTABLE indicates that the function
+ cannot modify the database and always
+ returns the same result when given the same argument values; that
+ is, it does not do database lookups or otherwise use information not
+ directly present in its argument list. If this option is given,
+ any call of the function with all-constant arguments can be
+ immediately replaced with the function value.
+
STABLE indicates that the function
+ cannot modify the database,
+ and that within a single table scan it will consistently
+ return the same result for the same argument values, but that its
+ result could change across SQL statements. This is the appropriate
+ selection for functions whose results depend on database lookups,
+ parameter variables (such as the current time zone), etc. (It is
+ inappropriate for AFTER triggers that wish to
+ query rows modified by the current command.) Also note
+ that the current_timestamp family of functions qualify
+ as stable, since their values do not change within a transaction.
+
VOLATILE indicates that the function value can
+ change even within a single table scan, so no optimizations can be
+ made. Relatively few database functions are volatile in this sense;
+ some examples are random(), currval(),
+ timeofday(). But note that any function that has
+ side-effects must be classified volatile, even if its result is quite
+ predictable, to prevent calls from being optimized away; an example is
+ setval().
+
+ For additional details see Section 38.7.
+
LEAKPROOF
+ LEAKPROOF indicates that the function has no side
+ effects. It reveals no information about its arguments other than by
+ its return value. For example, a function which throws an error message
+ for some argument values but not others, or which includes the argument
+ values in any error message, is not leakproof. This affects how the
+ system executes queries against views created with the
+ security_barrier option or tables with row level
+ security enabled. The system will enforce conditions from security
+ policies and security barrier views before any user-supplied conditions
+ from the query itself that contain non-leakproof functions, in order to
+ prevent the inadvertent exposure of data. Functions and operators
+ marked as leakproof are assumed to be trustworthy, and may be executed
+ before conditions from security policies and security barrier views.
+ In addition, functions which do not take arguments or which are not
+ passed any arguments from the security barrier view or table do not have
+ to be marked as leakproof to be executed before security conditions. See
+ CREATE VIEW and Section 41.5.
+ This option can only be set by the superuser.
+
CALLED ON NULL INPUT
RETURNS NULL ON NULL INPUT
STRICTCALLED ON NULL INPUT (the default) indicates
+ that the function will be called normally when some of its
+ arguments are null. It is then the function author's
+ responsibility to check for null values if necessary and respond
+ appropriately.
+
RETURNS NULL ON NULL INPUT or
+ STRICT indicates that the function always
+ returns null whenever any of its arguments are null. If this
+ parameter is specified, the function is not executed when there
+ are null arguments; instead a null result is assumed
+ automatically.
+
[EXTERNAL] SECURITY INVOKER
[EXTERNAL] SECURITY DEFINERSECURITY INVOKER indicates that the function
+ is to be executed with the privileges of the user that calls it.
+ That is the default. SECURITY DEFINER
+ specifies that the function is to be executed with the
+ privileges of the user that owns it. For information on how to
+ write SECURITY DEFINER functions safely,
+ see below.
+
+ The key word EXTERNAL is allowed for SQL
+ conformance, but it is optional since, unlike in SQL, this feature
+ applies to all functions not only external ones.
+
PARALLELPARALLEL UNSAFE indicates that the function
+ can't be executed in parallel mode and the presence of such a
+ function in an SQL statement forces a serial execution plan. This is
+ the default. PARALLEL RESTRICTED indicates that
+ the function can be executed in parallel mode, but the execution is
+ restricted to parallel group leader. PARALLEL SAFE
+ indicates that the function is safe to run in parallel mode without
+ restriction.
+
+ Functions should be labeled parallel unsafe if they modify any database
+ state, or if they make changes to the transaction such as using
+ sub-transactions, or if they access sequences or attempt to make
+ persistent changes to settings (e.g., setval). They should
+ be labeled as parallel restricted if they access temporary tables,
+ client connection state, cursors, prepared statements, or miscellaneous
+ backend-local state which the system cannot synchronize in parallel mode
+ (e.g., setseed cannot be executed other than by the group
+ leader because a change made by another process would not be reflected
+ in the leader). In general, if a function is labeled as being safe when
+ it is restricted or unsafe, or if it is labeled as being restricted when
+ it is in fact unsafe, it may throw errors or produce wrong answers
+ when used in a parallel query. C-language functions could in theory
+ exhibit totally undefined behavior if mislabeled, since there is no way
+ for the system to protect itself against arbitrary C code, but in most
+ likely cases the result will be no worse than for any other function.
+ If in doubt, functions should be labeled as UNSAFE, which is
+ the default.
+
COST execution_cost
+ A positive number giving the estimated execution cost for the function,
+ in units of cpu_operator_cost. If the function
+ returns a set, this is the cost per returned row. If the cost is
+ not specified, 1 unit is assumed for C-language and internal functions,
+ and 100 units for functions in all other languages. Larger values
+ cause the planner to try to avoid evaluating the function more often
+ than necessary.
+
ROWS result_rows
+ A positive number giving the estimated number of rows that the planner
+ should expect the function to return. This is only allowed when the
+ function is declared to return a set. The default assumption is
+ 1000 rows.
+
SUPPORT support_function
+ The name (optionally schema-qualified) of a planner support
+ function to use for this function. See
+ Section 38.11 for details.
+ You must be superuser to use this option.
+
configuration_parameter
value
+ The SET clause causes the specified configuration
+ parameter to be set to the specified value when the function is
+ entered, and then restored to its prior value when the function exits.
+ SET FROM CURRENT saves the value of the parameter that
+ is current when CREATE FUNCTION is executed as the value
+ to be applied when the function is entered.
+
+ If a SET clause is attached to a function, then
+ the effects of a SET LOCAL command executed inside the
+ function for the same variable are restricted to the function: the
+ configuration parameter's prior value is still restored at function exit.
+ However, an ordinary
+ SET command (without LOCAL) overrides the
+ SET clause, much as it would do for a previous SET
+ LOCAL command: the effects of such a command will persist after
+ function exit, unless the current transaction is rolled back.
+
+ See SET and
+ Chapter 20
+ for more information about allowed parameter names and values.
+
definition
+ A string constant defining the function; the meaning depends on the
+ language. It can be an internal function name, the path to an
+ object file, an SQL command, or text in a procedural language.
+
+ It is often helpful to use dollar quoting (see Section 4.1.2.4) to write the function definition
+ string, rather than the normal single quote syntax. Without dollar
+ quoting, any single quotes or backslashes in the function definition must
+ be escaped by doubling them.
+
obj_file, link_symbol
+ This form of the AS clause is used for
+ dynamically loadable C language functions when the function name
+ in the C language source code is not the same as the name of
+ the SQL function. The string obj_file is the name of the shared
+ library file containing the compiled C function, and is interpreted
+ as for the LOAD command. The string
+ link_symbol is the
+ function's link symbol, that is, the name of the function in the C
+ language source code. If the link symbol is omitted, it is assumed to
+ be the same as the name of the SQL function being defined. The C names
+ of all functions must be different, so you must give overloaded C
+ functions different C names (for example, use the argument types as
+ part of the C names).
+
+ When repeated CREATE FUNCTION calls refer to
+ the same object file, the file is only loaded once per session.
+ To unload and
+ reload the file (perhaps during development), start a new session.
+
sql_body
+ The body of a LANGUAGE SQL function. This can
+ either be a single statement
+
+RETURN expression
+
+ or a block
+
+BEGIN ATOMIC
+ statement;
+ statement;
+ ...
+ statement;
+END
+
+
+ This is similar to writing the text of the function body as a string
+ constant (see definition above), but there
+ are some differences: This form only works for LANGUAGE
+ SQL, the string constant form works for all languages. This
+ form is parsed at function definition time, the string constant form is
+ parsed at execution time; therefore this form cannot support
+ polymorphic argument types and other constructs that are not resolvable
+ at function definition time. This form tracks dependencies between the
+ function and objects used in the function body, so DROP
+ ... CASCADE will work correctly, whereas the form using
+ string literals may leave dangling functions. Finally, this form is
+ more compatible with the SQL standard and other SQL implementations.
+
Overloading
+ PostgreSQL allows function
+ overloading; that is, the same name can be
+ used for several different functions so long as they have distinct
+ input argument types. Whether or not you use it, this capability entails
+ security precautions when calling functions in databases where some users
+ mistrust other users; see Section 10.3.
+
+ Two functions are considered the same if they have the same names and
+ input argument types, ignoring any OUT
+ parameters. Thus for example these declarations conflict:
+
+CREATE FUNCTION foo(int) ...
+CREATE FUNCTION foo(int, out text) ...
+
+
+ Functions that have different argument type lists will not be considered
+ to conflict at creation time, but if defaults are provided they might
+ conflict in use. For example, consider
+
+CREATE FUNCTION foo(int) ...
+CREATE FUNCTION foo(int, int default 42) ...
+
+ A call foo(10) will fail due to the ambiguity about which
+ function should be called.
+
Notes
+ The full SQL type syntax is allowed for
+ declaring a function's arguments and return value. However,
+ parenthesized type modifiers (e.g., the precision field for
+ type numeric) are discarded by CREATE FUNCTION.
+ Thus for example
+ CREATE FUNCTION foo (varchar(10)) ...
+ is exactly the same as
+ CREATE FUNCTION foo (varchar) ....
+
+ When replacing an existing function with CREATE OR REPLACE
+ FUNCTION, there are restrictions on changing parameter names.
+ You cannot change the name already assigned to any input parameter
+ (although you can add names to parameters that had none before).
+ If there is more than one output parameter, you cannot change the
+ names of the output parameters, because that would change the
+ column names of the anonymous composite type that describes the
+ function's result. These restrictions are made to ensure that
+ existing calls of the function do not stop working when it is replaced.
+
+ If a function is declared STRICT with a VARIADIC
+ argument, the strictness check tests that the variadic array as
+ a whole is non-null. The function will still be called if the
+ array has null elements.
+
Examples
+ Add two integers using an SQL function:
+
+CREATE FUNCTION add(integer, integer) RETURNS integer
+ AS 'select $1 + $2;'
+ LANGUAGE SQL
+ IMMUTABLE
+ RETURNS NULL ON NULL INPUT;
+
+ The same function written in a more SQL-conforming style, using argument
+ names and an unquoted body:
+
+CREATE FUNCTION add(a integer, b integer) RETURNS integer
+ LANGUAGE SQL
+ IMMUTABLE
+ RETURNS NULL ON NULL INPUT
+ RETURN a + b;
+
+
+ Increment an integer, making use of an argument name, in
+ PL/pgSQL:
+
+CREATE OR REPLACE FUNCTION increment(i integer) RETURNS integer AS $$
+ BEGIN
+ RETURN i + 1;
+ END;
+$$ LANGUAGE plpgsql;
+
+
+ Return a record containing multiple output parameters:
+
+CREATE FUNCTION dup(in int, out f1 int, out f2 text)
+ AS $$ SELECT $1, CAST($1 AS text) || ' is text' $$
+ LANGUAGE SQL;
+
+SELECT * FROM dup(42);
+
+ You can do the same thing more verbosely with an explicitly named
+ composite type:
+
+CREATE TYPE dup_result AS (f1 int, f2 text);
+
+CREATE FUNCTION dup(int) RETURNS dup_result
+ AS $$ SELECT $1, CAST($1 AS text) || ' is text' $$
+ LANGUAGE SQL;
+
+SELECT * FROM dup(42);
+
+ Another way to return multiple columns is to use a TABLE
+ function:
+
+CREATE FUNCTION dup(int) RETURNS TABLE(f1 int, f2 text)
+ AS $$ SELECT $1, CAST($1 AS text) || ' is text' $$
+ LANGUAGE SQL;
+
+SELECT * FROM dup(42);
+
+ However, a TABLE function is different from the
+ preceding examples, because it actually returns a set
+ of records, not just one record.
+
Writing SECURITY DEFINER Functions Safely
+ Because a SECURITY DEFINER function is executed
+ with the privileges of the user that owns it, care is needed to
+ ensure that the function cannot be misused. For security,
+ search_path should be set to exclude any schemas
+ writable by untrusted users. This prevents
+ malicious users from creating objects (e.g., tables, functions, and
+ operators) that mask objects intended to be used by the function.
+ Particularly important in this regard is the
+ temporary-table schema, which is searched first by default, and
+ is normally writable by anyone. A secure arrangement can be obtained
+ by forcing the temporary schema to be searched last. To do this,
+ write pg_temp as the last entry in search_path.
+ This function illustrates safe usage:
+
+
+CREATE FUNCTION check_password(uname TEXT, pass TEXT)
+RETURNS BOOLEAN AS $$
+DECLARE passed BOOLEAN;
+BEGIN
+ SELECT (pwd = $2) INTO passed
+ FROM pwds
+ WHERE username = $1;
+
+ RETURN passed;
+END;
+$$ LANGUAGE plpgsql
+ SECURITY DEFINER
+ -- Set a secure search_path: trusted schema(s), then 'pg_temp'.
+ SET search_path = admin, pg_temp;
+
+
+ This function's intention is to access a table admin.pwds.
+ But without the SET clause, or with a SET clause
+ mentioning only admin, the function could be subverted by
+ creating a temporary table named pwds.
+
+ If the security definer function intends to create roles, and if it
+ is running as a non-superuser, createrole_self_grant
+ should also be set to a known value using the SET
+ clause.
+
+ Another point to keep in mind is that by default, execute privilege
+ is granted to PUBLIC for newly created functions
+ (see Section 5.7 for more
+ information). Frequently you will wish to restrict use of a security
+ definer function to only some users. To do that, you must revoke
+ the default PUBLIC privileges and then grant execute
+ privilege selectively. To avoid having a window where the new function
+ is accessible to all, create it and set the privileges within a single
+ transaction. For example:
+
+BEGIN;
+CREATE FUNCTION check_password(uname TEXT, pass TEXT) ... SECURITY DEFINER;
+REVOKE ALL ON FUNCTION check_password(uname TEXT, pass TEXT) FROM PUBLIC;
+GRANT EXECUTE ON FUNCTION check_password(uname TEXT, pass TEXT) TO admins;
+COMMIT;
+
Compatibility
+ A CREATE FUNCTION command is defined in the SQL
+ standard. The PostgreSQL implementation can be
+ used in a compatible way but has many extensions. Conversely, the SQL
+ standard specifies a number of optional features that are not implemented
+ in PostgreSQL.
+
+ The following are important compatibility issues:
+
+
+ OR REPLACE is a PostgreSQL extension.
+
+ For compatibility with some other database systems, argmode can be written either before or
+ after argname. But only
+ the first way is standard-compliant.
+
+ For parameter defaults, the SQL standard specifies only the syntax with
+ the DEFAULT key word. The syntax with
+ = is used in T-SQL and Firebird.
+
+ The SETOF modifier is a PostgreSQL extension.
+
+ Only SQL is standardized as a language.
+
+ All other attributes except CALLED ON NULL INPUT and
+ RETURNS NULL ON NULL INPUT are not standardized.
+
+ For the body of LANGUAGE SQL functions, the SQL
+ standard only specifies the sql_body form.
+
+
+ Simple LANGUAGE SQL functions can be written in a way
+ that is both standard-conforming and portable to other implementations.
+ More complex functions using advanced features, optimization attributes, or
+ other languages will necessarily be specific to PostgreSQL in a significant
+ way.
+
CREATE GROUP
CREATE GROUP — define a new database role
Synopsis
+CREATE GROUP name [ [ WITH ] option [ ... ] ]
+
+where option can be:
+
+ SUPERUSER | NOSUPERUSER
+ | CREATEDB | NOCREATEDB
+ | CREATEROLE | NOCREATEROLE
+ | INHERIT | NOINHERIT
+ | LOGIN | NOLOGIN
+ | REPLICATION | NOREPLICATION
+ | BYPASSRLS | NOBYPASSRLS
+ | CONNECTION LIMIT connlimit
+ | [ ENCRYPTED ] PASSWORD 'password' | PASSWORD NULL
+ | VALID UNTIL 'timestamp'
+ | IN ROLE role_name [, ...]
+ | IN GROUP role_name [, ...]
+ | ROLE role_name [, ...]
+ | ADMIN role_name [, ...]
+ | USER role_name [, ...]
+ | SYSID uid
+
Description
+ CREATE GROUP is now an alias for
+ CREATE ROLE.
+
Compatibility
+ There is no CREATE GROUP statement in the SQL
+ standard.
+
CREATE INDEX
CREATE INDEX — define a new index
Synopsis
+CREATE [ UNIQUE ] INDEX [ CONCURRENTLY ] [ [ IF NOT EXISTS ] name ] ON [ ONLY ] table_name [ USING method ]
+ ( { column_name | ( expression ) } [ COLLATE collation ] [ opclass [ ( opclass_parameter = value [, ... ] ) ] ] [ ASC | DESC ] [ NULLS { FIRST | LAST } ] [, ...] )
+ [ INCLUDE ( column_name [, ...] ) ]
+ [ NULLS [ NOT ] DISTINCT ]
+ [ WITH ( storage_parameter [= value] [, ... ] ) ]
+ [ TABLESPACE tablespace_name ]
+ [ WHERE predicate ]
+
Description
+ CREATE INDEX constructs an index on the specified column(s)
+ of the specified relation, which can be a table or a materialized view.
+ Indexes are primarily used to enhance database performance (though
+ inappropriate use can result in slower performance).
+
+ The key field(s) for the index are specified as column names,
+ or alternatively as expressions written in parentheses.
+ Multiple fields can be specified if the index method supports
+ multicolumn indexes.
+
+ An index field can be an expression computed from the values of
+ one or more columns of the table row. This feature can be used
+ to obtain fast access to data based on some transformation of
+ the basic data. For example, an index computed on
+ upper(col) would allow the clause
+ WHERE upper(col) = 'JIM' to use an index.
+
+ PostgreSQL provides the index methods
+ B-tree, hash, GiST, SP-GiST, GIN, and BRIN. Users can also define their own
+ index methods, but that is fairly complicated.
+
+ When the WHERE clause is present, a
+ partial index is created.
+ A partial index is an index that contains entries for only a portion of
+ a table, usually a portion that is more useful for indexing than the
+ rest of the table. For example, if you have a table that contains both
+ billed and unbilled orders where the unbilled orders take up a small
+ fraction of the total table and yet that is an often used section, you
+ can improve performance by creating an index on just that portion.
+ Another possible application is to use WHERE with
+ UNIQUE to enforce uniqueness over a subset of a
+ table. See Section 11.8 for more discussion.
+
+ The expression used in the WHERE clause can refer
+ only to columns of the underlying table, but it can use all columns,
+ not just the ones being indexed. Presently, subqueries and
+ aggregate expressions are also forbidden in WHERE.
+ The same restrictions apply to index fields that are expressions.
+
+ All functions and operators used in an index definition must be
+ “immutable”, that is, their results must depend only on
+ their arguments and never on any outside influence (such as
+ the contents of another table or the current time). This restriction
+ ensures that the behavior of the index is well-defined. To use a
+ user-defined function in an index expression or WHERE
+ clause, remember to mark the function immutable when you create it.
+
Parameters
UNIQUE
+ Causes the system to check for
+ duplicate values in the table when the index is created (if data
+ already exist) and each time data is added. Attempts to
+ insert or update data which would result in duplicate entries
+ will generate an error.
+
+ Additional restrictions apply when unique indexes are applied to
+ partitioned tables; see CREATE TABLE.
+
CONCURRENTLY
+ When this option is used, PostgreSQL will build the
+ index without taking any locks that prevent concurrent inserts,
+ updates, or deletes on the table; whereas a standard index build
+ locks out writes (but not reads) on the table until it's done.
+ There are several caveats to be aware of when using this option
+ — see Building Indexes Concurrently below.
+
+ For temporary tables, CREATE INDEX is always
+ non-concurrent, as no other session can access them, and
+ non-concurrent index creation is cheaper.
+
IF NOT EXISTS
+ Do not throw an error if a relation with the same name already exists.
+ A notice is issued in this case. Note that there is no guarantee that
+ the existing index is anything like the one that would have been created.
+ Index name is required when IF NOT EXISTS is specified.
+
INCLUDE
+ The optional INCLUDE clause specifies a
+ list of columns which will be included in the index
+ as non-key columns. A non-key column cannot
+ be used in an index scan search qualification, and it is disregarded
+ for purposes of any uniqueness or exclusion constraint enforced by
+ the index. However, an index-only scan can return the contents of
+ non-key columns without having to visit the index's table, since
+ they are available directly from the index entry. Thus, addition of
+ non-key columns allows index-only scans to be used for queries that
+ otherwise could not use them.
+
+ It's wise to be conservative about adding non-key columns to an
+ index, especially wide columns. If an index tuple exceeds the
+ maximum size allowed for the index type, data insertion will fail.
+ In any case, non-key columns duplicate data from the index's table
+ and bloat the size of the index, thus potentially slowing searches.
+ Furthermore, B-tree deduplication is never used with indexes
+ that have a non-key column.
+
+ Columns listed in the INCLUDE clause don't need
+ appropriate operator classes; the clause can include
+ columns whose data types don't have operator classes defined for
+ a given access method.
+
+ Expressions are not supported as included columns since they cannot be
+ used in index-only scans.
+
+ Currently, the B-tree, GiST and SP-GiST index access methods support
+ this feature. In these indexes, the values of columns listed
+ in the INCLUDE clause are included in leaf tuples
+ which correspond to heap tuples, but are not included in upper-level
+ index entries used for tree navigation.
+
name
+ The name of the index to be created. No schema name can be included
+ here; the index is always created in the same schema as its parent
+ table. The name of the index must be distinct from the name of any
+ other relation (table, sequence, index, view, materialized view, or
+ foreign table) in that schema.
+ If the name is omitted, PostgreSQL chooses a
+ suitable name based on the parent table's name and the indexed column
+ name(s).
+
ONLY
+ Indicates not to recurse creating indexes on partitions, if the
+ table is partitioned. The default is to recurse.
+
table_name
+ The name (possibly schema-qualified) of the table to be indexed.
+
method
+ The name of the index method to be used. Choices are
+ btree, hash,
+ gist, spgist, gin,
+ brin, or user-installed access methods like
+ bloom.
+ The default method is btree.
+
column_name
+ The name of a column of the table.
+
expression
+ An expression based on one or more columns of the table. The
+ expression usually must be written with surrounding parentheses,
+ as shown in the syntax. However, the parentheses can be omitted
+ if the expression has the form of a function call.
+
collation
+ The name of the collation to use for the index. By default,
+ the index uses the collation declared for the column to be
+ indexed or the result collation of the expression to be
+ indexed. Indexes with non-default collations can be useful for
+ queries that involve expressions using non-default collations.
+
opclass
+ The name of an operator class. See below for details.
+
opclass_parameter
+ The name of an operator class parameter. See below for details.
+
ASC
+ Specifies ascending sort order (which is the default).
+
DESC
+ Specifies descending sort order.
+
NULLS FIRST
+ Specifies that nulls sort before non-nulls. This is the default
+ when DESC is specified.
+
NULLS LAST
+ Specifies that nulls sort after non-nulls. This is the default
+ when DESC is not specified.
+
NULLS DISTINCT
NULLS NOT DISTINCT
+ Specifies whether for a unique index, null values should be considered
+ distinct (not equal). The default is that they are distinct, so that
+ a unique index could contain multiple null values in a column.
+
storage_parameter
+ The name of an index-method-specific storage parameter. See
+ Index Storage Parameters below
+ for details.
+
tablespace_name
+ The tablespace in which to create the index. If not specified,
+ default_tablespace is consulted, or
+ temp_tablespaces for indexes on temporary
+ tables.
+
predicate
+ The constraint expression for a partial index.
+
Index Storage Parameters
+ The optional WITH clause specifies storage
+ parameters for the index. Each index method has its own set of allowed
+ storage parameters. The B-tree, hash, GiST and SP-GiST index methods all
+ accept this parameter:
+
fillfactor (integer)
+
+ #
+ The fillfactor for an index is a percentage that determines how full
+ the index method will try to pack index pages. For B-trees, leaf pages
+ are filled to this percentage during initial index builds, and also
+ when extending the index at the right (adding new largest key values).
+ If pages
+ subsequently become completely full, they will be split, leading to
+ fragmentation of the on-disk index structure. B-trees use a default
+ fillfactor of 90, but any integer value from 10 to 100 can be selected.
+
+ B-tree indexes on tables where many inserts and/or updates are
+ anticipated can benefit from lower fillfactor settings at
+ CREATE INDEX time (following bulk loading into the
+ table). Values in the range of 50 - 90 can usefully “smooth
+ out” the rate of page splits during the
+ early life of the B-tree index (lowering fillfactor like this may even
+ lower the absolute number of page splits, though this effect is highly
+ workload dependent). The B-tree bottom-up index deletion technique
+ described in Section 67.4.2 is dependent on having
+ some “extra” space on pages to store “extra”
+ tuple versions, and so can be affected by fillfactor (though the effect
+ is usually not significant).
+
+ In other specific cases it might be useful to increase fillfactor to
+ 100 at CREATE INDEX time as a way of maximizing
+ space utilization. You should only consider this when you are
+ completely sure that the table is static (i.e. that it will never be
+ affected by either inserts or updates). A fillfactor setting of 100
+ otherwise risks harming performance: even a few
+ updates or inserts will cause a sudden flood of page splits.
+
+ The other index methods use fillfactor in different but roughly
+ analogous ways; the default fillfactor varies between methods.
+
+ B-tree indexes additionally accept this parameter:
+
deduplicate_items (boolean)
+
+ #
+ Controls usage of the B-tree deduplication technique described
+ in Section 67.4.3. Set to
+ ON or OFF to enable or
+ disable the optimization. (Alternative spellings of
+ ON and OFF are allowed as
+ described in Section 20.1.) The default is
+ ON.
+
Note
+ Turning deduplicate_items off via
+ ALTER INDEX prevents future insertions from
+ triggering deduplication, but does not in itself make existing
+ posting list tuples use the standard tuple representation.
+
+ GiST indexes additionally accept this parameter:
+
buffering (enum)
+
+ #
+ Determines whether the buffered build technique described in
+ Section 68.4.1 is used to build the index. With
+ OFF buffering is disabled, with ON
+ it is enabled, and with AUTO it is initially disabled,
+ but is turned on on-the-fly once the index size reaches
+ effective_cache_size. The default
+ is AUTO.
+ Note that if sorted build is possible, it will be used instead of
+ buffered build unless buffering=ON is specified.
+
+ GIN indexes accept different parameters:
+
fastupdate (boolean)
+
+ #
+ This setting controls usage of the fast update technique described in
+ Section 70.4.1. It is a Boolean parameter:
+ ON enables fast update, OFF disables it.
+ The default is ON.
+
Note
+ Turning fastupdate off via ALTER INDEX prevents
+ future insertions from going into the list of pending index entries,
+ but does not in itself flush previous entries. You might want to
+ VACUUM the table or call gin_clean_pending_list
+ function afterward to ensure the pending list is emptied.
+
gin_pending_list_limit (integer)
+
+ #
+ Custom gin_pending_list_limit parameter.
+ This value is specified in kilobytes.
+
+ BRIN indexes accept different parameters:
+
pages_per_range (integer)
+
+ #
+ Defines the number of table blocks that make up one block range for
+ each entry of a BRIN index (see Section 71.1
+ for more details). The default is 128.
+
autosummarize (boolean)
+
+ #
+ Defines whether a summarization run is queued for the previous page
+ range whenever an insertion is detected on the next one.
+ See Section 71.1.1 for more details.
+ The default is off.
+
Building Indexes Concurrently
+ Creating an index can interfere with regular operation of a database.
+ Normally PostgreSQL locks the table to be indexed against
+ writes and performs the entire index build with a single scan of the
+ table. Other transactions can still read the table, but if they try to
+ insert, update, or delete rows in the table they will block until the
+ index build is finished. This could have a severe effect if the system is
+ a live production database. Very large tables can take many hours to be
+ indexed, and even for smaller tables, an index build can lock out writers
+ for periods that are unacceptably long for a production system.
+
+ PostgreSQL supports building indexes without locking
+ out writes. This method is invoked by specifying the
+ CONCURRENTLY option of CREATE INDEX.
+ When this option is used,
+ PostgreSQL must perform two scans of the table, and in
+ addition it must wait for all existing transactions that could potentially
+ modify or use the index to terminate. Thus
+ this method requires more total work than a standard index build and takes
+ significantly longer to complete. However, since it allows normal
+ operations to continue while the index is built, this method is useful for
+ adding new indexes in a production environment. Of course, the extra CPU
+ and I/O load imposed by the index creation might slow other operations.
+
+ In a concurrent index build, the index is actually entered as an
+ “invalid” index into
+ the system catalogs in one transaction, then two table scans occur in
+ two more transactions. Before each table scan, the index build must
+ wait for existing transactions that have modified the table to terminate.
+ After the second scan, the index build must wait for any transactions
+ that have a snapshot (see Chapter 13) predating the second
+ scan to terminate, including transactions used by any phase of concurrent
+ index builds on other tables, if the indexes involved are partial or have
+ columns that are not simple column references.
+ Then finally the index can be marked “valid” and ready for use,
+ and the CREATE INDEX command terminates.
+ Even then, however, the index may not be immediately usable for queries:
+ in the worst case, it cannot be used as long as transactions exist that
+ predate the start of the index build.
+
+ If a problem arises while scanning the table, such as a deadlock or a
+ uniqueness violation in a unique index, the CREATE INDEX
+ command will fail but leave behind an “invalid” index. This index
+ will be ignored for querying purposes because it might be incomplete;
+ however it will still consume update overhead. The psql
+ \d command will report such an index as INVALID:
+
+
+postgres=# \d tab
+ Table "public.tab"
+ Column | Type | Collation | Nullable | Default
+--------+---------+-----------+----------+---------
+ col | integer | | |
+Indexes:
+ "idx" btree (col) INVALID
+
+
+ The recommended recovery
+ method in such cases is to drop the index and try again to perform
+ CREATE INDEX CONCURRENTLY. (Another possibility is
+ to rebuild the index with REINDEX INDEX CONCURRENTLY).
+
+ Another caveat when building a unique index concurrently is that the
+ uniqueness constraint is already being enforced against other transactions
+ when the second table scan begins. This means that constraint violations
+ could be reported in other queries prior to the index becoming available
+ for use, or even in cases where the index build eventually fails. Also,
+ if a failure does occur in the second scan, the “invalid” index
+ continues to enforce its uniqueness constraint afterwards.
+
+ Concurrent builds of expression indexes and partial indexes are supported.
+ Errors occurring in the evaluation of these expressions could cause
+ behavior similar to that described above for unique constraint violations.
+
+ Regular index builds permit other regular index builds on the
+ same table to occur simultaneously, but only one concurrent index build
+ can occur on a table at a time. In either case, schema modification of the
+ table is not allowed while the index is being built. Another difference is
+ that a regular CREATE INDEX command can be performed
+ within a transaction block, but CREATE INDEX CONCURRENTLY
+ cannot.
+
+ Concurrent builds for indexes on partitioned tables are currently not
+ supported. However, you may concurrently build the index on each
+ partition individually and then finally create the partitioned index
+ non-concurrently in order to reduce the time where writes to the
+ partitioned table will be locked out. In this case, building the
+ partitioned index is a metadata only operation.
+
Notes
+ See Chapter 11 for information about when indexes can
+ be used, when they are not used, and in which particular situations
+ they can be useful.
+
+ Currently, only the B-tree, GiST, GIN, and BRIN index methods support
+ multiple-key-column indexes. Whether there can be multiple key
+ columns is independent of whether INCLUDE columns
+ can be added to the index. Indexes can have up to 32 columns,
+ including INCLUDE columns.
+ (This limit can be altered when building
+ PostgreSQL.) Only B-tree currently
+ supports unique indexes.
+
+ An operator class with optional parameters
+ can be specified for each column of an index.
+ The operator class identifies the operators to be
+ used by the index for that column. For example, a B-tree index on
+ four-byte integers would use the int4_ops class;
+ this operator class includes comparison functions for four-byte
+ integers. In practice the default operator class for the column's data
+ type is usually sufficient. The main point of having operator classes
+ is that for some data types, there could be more than one meaningful
+ ordering. For example, we might want to sort a complex-number data
+ type either by absolute value or by real part. We could do this by
+ defining two operator classes for the data type and then selecting
+ the proper class when creating an index. More information about
+ operator classes is in Section 11.10 and in Section 38.16.
+
+ When CREATE INDEX is invoked on a partitioned
+ table, the default behavior is to recurse to all partitions to ensure
+ they all have matching indexes.
+ Each partition is first checked to determine whether an equivalent
+ index already exists, and if so, that index will become attached as a
+ partition index to the index being created, which will become its
+ parent index.
+ If no matching index exists, a new index will be created and
+ automatically attached; the name of the new index in each partition
+ will be determined as if no index name had been specified in the
+ command.
+ If the ONLY option is specified, no recursion
+ is done, and the index is marked invalid.
+ (ALTER INDEX ... ATTACH PARTITION marks the index
+ valid, once all partitions acquire matching indexes.) Note, however,
+ that any partition that is created in the future using
+ CREATE TABLE ... PARTITION OF will automatically
+ have a matching index, regardless of whether ONLY is
+ specified.
+
+ For index methods that support ordered scans (currently, only B-tree),
+ the optional clauses ASC, DESC, NULLS
+ FIRST, and/or NULLS LAST can be specified to modify
+ the sort ordering of the index. Since an ordered index can be
+ scanned either forward or backward, it is not normally useful to create a
+ single-column DESC index — that sort ordering is already
+ available with a regular index. The value of these options is that
+ multicolumn indexes can be created that match the sort ordering requested
+ by a mixed-ordering query, such as SELECT ... ORDER BY x ASC, y
+ DESC. The NULLS options are useful if you need to support
+ “nulls sort low” behavior, rather than the default “nulls
+ sort high”, in queries that depend on indexes to avoid sorting steps.
+
+ The system regularly collects statistics on all of a table's
+ columns. Newly-created non-expression indexes can immediately
+ use these statistics to determine an index's usefulness.
+ For new expression indexes, it is necessary to run ANALYZE or wait for
+ the autovacuum daemon to analyze
+ the table to generate statistics for these indexes.
+
+ For most index methods, the speed of creating an index is
+ dependent on the setting of maintenance_work_mem.
+ Larger values will reduce the time needed for index creation, so long
+ as you don't make it larger than the amount of memory really available,
+ which would drive the machine into swapping.
+
+ PostgreSQL can build indexes while
+ leveraging multiple CPUs in order to process the table rows faster.
+ This feature is known as parallel index
+ build. For index methods that support building indexes
+ in parallel (currently, only B-tree),
+ maintenance_work_mem specifies the maximum
+ amount of memory that can be used by each index build operation as
+ a whole, regardless of how many worker processes were started.
+ Generally, a cost model automatically determines how many worker
+ processes should be requested, if any.
+
+ Parallel index builds may benefit from increasing
+ maintenance_work_mem where an equivalent serial
+ index build will see little or no benefit. Note that
+ maintenance_work_mem may influence the number of
+ worker processes requested, since parallel workers must have at
+ least a 32MB share of the total
+ maintenance_work_mem budget. There must also be
+ a remaining 32MB share for the leader process.
+ Increasing max_parallel_maintenance_workers
+ may allow more workers to be used, which will reduce the time
+ needed for index creation, so long as the index build is not
+ already I/O bound. Of course, there should also be sufficient
+ CPU capacity that would otherwise lie idle.
+
+ Setting a value for parallel_workers via ALTER TABLE directly controls how many parallel
+ worker processes will be requested by a CREATE
+ INDEX against the table. This bypasses the cost model
+ completely, and prevents maintenance_work_mem
+ from affecting how many parallel workers are requested. Setting
+ parallel_workers to 0 via ALTER
+ TABLE will disable parallel index builds on the table in
+ all cases.
+
Tip
+ You might want to reset parallel_workers after
+ setting it as part of tuning an index build. This avoids
+ inadvertent changes to query plans, since
+ parallel_workers affects
+ all parallel table scans.
+
+ While CREATE INDEX with the
+ CONCURRENTLY option supports parallel builds
+ without special restrictions, only the first table scan is actually
+ performed in parallel.
+
+ Use DROP INDEX
+ to remove an index.
+
+ Like any long-running transaction, CREATE INDEX on a
+ table can affect which tuples can be removed by concurrent
+ VACUUM on any other table.
+
+ Prior releases of PostgreSQL also had an
+ R-tree index method. This method has been removed because
+ it had no significant advantages over the GiST method.
+ If USING rtree is specified, CREATE INDEX
+ will interpret it as USING gist, to simplify conversion
+ of old databases to GiST.
+
+ Each backend running CREATE INDEX will report its
+ progress in the pg_stat_progress_create_index
+ view. See Section 28.4.4 for details.
+
Examples
+ To create a unique B-tree index on the column title in
+ the table films:
+
+CREATE UNIQUE INDEX title_idx ON films (title);
+
+
+ To create a unique B-tree index on the column title
+ with included columns director
+ and rating in the table films:
+
+CREATE UNIQUE INDEX title_idx ON films (title) INCLUDE (director, rating);
+
+
+ To create a B-Tree index with deduplication disabled:
+
+CREATE INDEX title_idx ON films (title) WITH (deduplicate_items = off);
+
+
+ To create an index on the expression lower(title),
+ allowing efficient case-insensitive searches:
+
+CREATE INDEX ON films ((lower(title)));
+
+ (In this example we have chosen to omit the index name, so the system
+ will choose a name, typically films_lower_idx.)
+
+ To create an index with non-default collation:
+
+CREATE INDEX title_idx_german ON films (title COLLATE "de_DE");
+
+
+ To create an index with non-default sort ordering of nulls:
+
+CREATE INDEX title_idx_nulls_low ON films (title NULLS FIRST);
+
+
+ To create an index with non-default fill factor:
+
+CREATE UNIQUE INDEX title_idx ON films (title) WITH (fillfactor = 70);
+
+
+ To create a GIN index with fast updates disabled:
+
+CREATE INDEX gin_idx ON documents_table USING GIN (locations) WITH (fastupdate = off);
+
+
+ To create an index on the column code in the table
+ films and have the index reside in the tablespace
+ indexspace:
+
+CREATE INDEX code_idx ON films (code) TABLESPACE indexspace;
+
+
+ To create a GiST index on a point attribute so that we
+ can efficiently use box operators on the result of the
+ conversion function:
+
+CREATE INDEX pointloc
+ ON points USING gist (box(location,location));
+SELECT * FROM points
+ WHERE box(location,location) && '(0,0),(1,1)'::box;
+
+
+ To create an index without locking out writes to the table:
+
+CREATE INDEX CONCURRENTLY sales_quantity_index ON sales_table (quantity);
+
Compatibility
+ CREATE INDEX is a
+ PostgreSQL language extension. There
+ are no provisions for indexes in the SQL standard.
+
CREATE LANGUAGE
CREATE LANGUAGE — define a new procedural language
Synopsis
+CREATE [ OR REPLACE ] [ TRUSTED ] [ PROCEDURAL ] LANGUAGE name
+ HANDLER call_handler [ INLINE inline_handler ] [ VALIDATOR valfunction ]
+CREATE [ OR REPLACE ] [ TRUSTED ] [ PROCEDURAL ] LANGUAGE name
+
Description
+ CREATE LANGUAGE registers a new
+ procedural language with a PostgreSQL
+ database. Subsequently, functions and procedures can be
+ defined in this new language.
+
+ CREATE LANGUAGE effectively associates the
+ language name with handler function(s) that are responsible for executing
+ functions written in the language. Refer to Chapter 58
+ for more information about language handlers.
+
+ CREATE OR REPLACE LANGUAGE will either create a
+ new language, or replace an existing definition. If the language
+ already exists, its parameters are updated according to the command,
+ but the language's ownership and permissions settings do not change,
+ and any existing functions written in the language are assumed to still
+ be valid.
+
+ One must have the
+ PostgreSQL superuser privilege to
+ register a new language or change an existing language's parameters.
+ However, once the language is created it is valid to assign ownership of
+ it to a non-superuser, who may then drop it, change its permissions,
+ rename it, or assign it to a new owner. (Do not, however, assign
+ ownership of the underlying C functions to a non-superuser; that would
+ create a privilege escalation path for that user.)
+
+ The form of CREATE LANGUAGE that does not supply
+ any handler function is obsolete. For backwards compatibility with
+ old dump files, it is interpreted as CREATE EXTENSION.
+ That will work if the language has been packaged into an extension of
+ the same name, which is the conventional way to set up procedural
+ languages.
+
Parameters
TRUSTEDTRUSTED specifies that the language does
+ not grant access to data that the user would not otherwise
+ have. If this key word is omitted
+ when registering the language, only users with the
+ PostgreSQL superuser privilege can
+ use this language to create new functions.
+
PROCEDURAL
+ This is a noise word.
+
name
+ The name of the new procedural language.
+ The name must be unique among the languages in the database.
+
HANDLER call_handlercall_handler is
+ the name of a previously registered function that will be
+ called to execute the procedural language's functions. The call
+ handler for a procedural language must be written in a compiled
+ language such as C with version 1 call convention and
+ registered with PostgreSQL as a
+ function taking no arguments and returning the
+ language_handler type, a placeholder type that is
+ simply used to identify the function as a call handler.
+
INLINE inline_handlerinline_handler is the
+ name of a previously registered function that will be called
+ to execute an anonymous code block
+ (DO command)
+ in this language.
+ If no inline_handler
+ function is specified, the language does not support anonymous code
+ blocks.
+ The handler function must take one argument of
+ type internal, which will be the DO command's
+ internal representation, and it will typically return
+ void. The return value of the handler is ignored.
+
VALIDATOR valfunctionvalfunction is the
+ name of a previously registered function that will be called
+ when a new function in the language is created, to validate the
+ new function.
+ If no
+ validator function is specified, then a new function will not
+ be checked when it is created.
+ The validator function must take one argument of
+ type oid, which will be the OID of the
+ to-be-created function, and will typically return void.
+
+ A validator function would typically inspect the function body
+ for syntactical correctness, but it can also look at other
+ properties of the function, for example if the language cannot
+ handle certain argument types. To signal an error, the
+ validator function should use the ereport()
+ function. The return value of the function is ignored.
+
Notes
+ Use DROP LANGUAGE to drop procedural languages.
+
+ The system catalog pg_language (see Section 53.29) records information about the
+ currently installed languages. Also, the psql
+ command \dL lists the installed languages.
+
+ To create functions in a procedural language, a user must have the
+ USAGE privilege for the language. By default,
+ USAGE is granted to PUBLIC (i.e., everyone)
+ for trusted languages. This can be revoked if desired.
+
+ Procedural languages are local to individual databases.
+ However, a language can be installed into the template1
+ database, which will cause it to be available automatically in
+ all subsequently-created databases.
+
Examples
+ A minimal sequence for creating a new procedural language is:
+
+CREATE FUNCTION plsample_call_handler() RETURNS language_handler
+ AS '$libdir/plsample'
+ LANGUAGE C;
+CREATE LANGUAGE plsample
+ HANDLER plsample_call_handler;
+
+ Typically that would be written in an extension's creation script,
+ and users would do this to install the extension:
+
+CREATE EXTENSION plsample;
+
Compatibility
+ CREATE LANGUAGE is a
+ PostgreSQL extension.
+
CREATE MATERIALIZED VIEW
CREATE MATERIALIZED VIEW — define a new materialized view
Synopsis
+CREATE MATERIALIZED VIEW [ IF NOT EXISTS ] table_name
+ [ (column_name [, ...] ) ]
+ [ USING method ]
+ [ WITH ( storage_parameter [= value] [, ... ] ) ]
+ [ TABLESPACE tablespace_name ]
+ AS query
+ [ WITH [ NO ] DATA ]
+
Description
+ CREATE MATERIALIZED VIEW defines a materialized view of
+ a query. The query is executed and used to populate the view at the time
+ the command is issued (unless WITH NO DATA is used) and may be
+ refreshed later using REFRESH MATERIALIZED VIEW.
+
+ CREATE MATERIALIZED VIEW is similar to
+ CREATE TABLE AS, except that it also remembers the query used
+ to initialize the view, so that it can be refreshed later upon demand.
+ A materialized view has many of the same properties as a table, but there
+ is no support for temporary materialized views.
+
+ CREATE MATERIALIZED VIEW requires
+ CREATE privilege on the schema used for the materialized
+ view.
+
Parameters
IF NOT EXISTS
+ Do not throw an error if a materialized view with the same name already
+ exists. A notice is issued in this case. Note that there is no guarantee
+ that the existing materialized view is anything like the one that would
+ have been created.
+
table_name
+ The name (optionally schema-qualified) of the materialized view to be
+ created. The name must be distinct from the name of any other relation
+ (table, sequence, index, view, materialized view, or foreign table) in
+ the same schema.
+
column_name
+ The name of a column in the new materialized view. If column names are
+ not provided, they are taken from the output column names of the query.
+
USING method
+ This optional clause specifies the table access method to use to store
+ the contents for the new materialized view; the method needs be an
+ access method of type TABLE. See Chapter 63 for more information. If this option is not
+ specified, the default table access method is chosen for the new
+ materialized view. See default_table_access_method
+ for more information.
+
WITH ( storage_parameter [= value] [, ... ] )
+ This clause specifies optional storage parameters for the new
+ materialized view; see
+ Storage Parameters in the
+ CREATE TABLE documentation for more
+ information. All parameters supported for CREATE
+ TABLE are also supported for CREATE MATERIALIZED
+ VIEW.
+ See CREATE TABLE for more information.
+
TABLESPACE tablespace_name
+ The tablespace_name is the name
+ of the tablespace in which the new materialized view is to be created.
+ If not specified, default_tablespace is consulted.
+
query
+ A SELECT, TABLE,
+ or VALUES command. This query will run within a
+ security-restricted operation; in particular, calls to functions that
+ themselves create temporary tables will fail.
+
WITH [ NO ] DATA
+ This clause specifies whether or not the materialized view should be
+ populated at creation time. If not, the materialized view will be
+ flagged as unscannable and cannot be queried until REFRESH
+ MATERIALIZED VIEW is used.
+
Compatibility
+ CREATE MATERIALIZED VIEW is a
+ PostgreSQL extension.
+
CREATE OPERATOR CLASS
CREATE OPERATOR CLASS — define a new operator class
Synopsis
+CREATE OPERATOR CLASS name [ DEFAULT ] FOR TYPE data_type
+ USING index_method [ FAMILY family_name ] AS
+ { OPERATOR strategy_number operator_name [ ( op_type, op_type ) ] [ FOR SEARCH | FOR ORDER BY sort_family_name ]
+ | FUNCTION support_number [ ( op_type [ , op_type ] ) ] function_name ( argument_type [, ...] )
+ | STORAGE storage_type
+ } [, ... ]
+
Description
+ CREATE OPERATOR CLASS creates a new operator class.
+ An operator class defines how a particular data type can be used with
+ an index. The operator class specifies that certain operators will fill
+ particular roles or “strategies” for this data type and this
+ index method. The operator class also specifies the support functions to
+ be used by
+ the index method when the operator class is selected for an
+ index column. All the operators and functions used by an operator
+ class must be defined before the operator class can be created.
+
+ If a schema name is given then the operator class is created in the
+ specified schema. Otherwise it is created in the current schema.
+ Two operator classes in the same schema can have the same name only if they
+ are for different index methods.
+
+ The user who defines an operator class becomes its owner. Presently,
+ the creating user must be a superuser. (This restriction is made because
+ an erroneous operator class definition could confuse or even crash the
+ server.)
+
+ CREATE OPERATOR CLASS does not presently check
+ whether the operator class definition includes all the operators and
+ functions required by the index method, nor whether the operators and
+ functions form a self-consistent set. It is the user's
+ responsibility to define a valid operator class.
+
+ Related operator classes can be grouped into operator
+ families. To add a new operator class to an existing family,
+ specify the FAMILY option in CREATE OPERATOR
+ CLASS. Without this option, the new class is placed into
+ a family named the same as the new class (creating that family if
+ it doesn't already exist).
+
+ Refer to Section 38.16 for further information.
+
Parameters
name
+ The name of the operator class to be created. The name can be
+ schema-qualified.
+
DEFAULT
+ If present, the operator class will become the default
+ operator class for its data type. At most one operator class
+ can be the default for a specific data type and index method.
+
data_type
+ The column data type that this operator class is for.
+
index_method
+ The name of the index method this operator class is for.
+
family_name
+ The name of the existing operator family to add this operator class to.
+ If not specified, a family named the same as the operator class is
+ used (creating it, if it doesn't already exist).
+
strategy_number
+ The index method's strategy number for an operator
+ associated with the operator class.
+
operator_name
+ The name (optionally schema-qualified) of an operator associated
+ with the operator class.
+
op_type
+ In an OPERATOR clause,
+ the operand data type(s) of the operator, or NONE to
+ signify a prefix operator. The operand data
+ types can be omitted in the normal case where they are the same
+ as the operator class's data type.
+
+ In a FUNCTION clause, the operand data type(s) the
+ function is intended to support, if different from
+ the input data type(s) of the function (for B-tree comparison functions
+ and hash functions)
+ or the class's data type (for B-tree sort support functions,
+ B-tree equal image functions, and all functions in GiST,
+ SP-GiST, GIN and BRIN operator classes). These defaults are
+ correct, and so op_type need not be specified
+ in FUNCTION clauses, except for the case of a
+ B-tree sort support function that is meant to support
+ cross-data-type comparisons.
+
sort_family_name
+ The name (optionally schema-qualified) of an existing btree operator
+ family that describes the sort ordering associated with an ordering
+ operator.
+
+ If neither FOR SEARCH nor FOR ORDER BY is
+ specified, FOR SEARCH is the default.
+
support_number
+ The index method's support function number for a
+ function associated with the operator class.
+
function_name
+ The name (optionally schema-qualified) of a function that is an
+ index method support function for the operator class.
+
argument_type
+ The parameter data type(s) of the function.
+
storage_type
+ The data type actually stored in the index. Normally this is
+ the same as the column data type, but some index methods
+ (currently GiST, GIN, SP-GiST and BRIN) allow it to be different. The
+ STORAGE clause must be omitted unless the index
+ method allows a different type to be used.
+ If the column data_type is specified
+ as anyarray, the storage_type
+ can be declared as anyelement to indicate that the index
+ entries are members of the element type belonging to the actual array
+ type that each particular index is created for.
+
+ The OPERATOR, FUNCTION, and STORAGE
+ clauses can appear in any order.
+
Notes
+ Because the index machinery does not check access permissions on functions
+ before using them, including a function or operator in an operator class
+ is tantamount to granting public execute permission on it. This is usually
+ not an issue for the sorts of functions that are useful in an operator
+ class.
+
+ The operators should not be defined by SQL functions. An SQL function
+ is likely to be inlined into the calling query, which will prevent
+ the optimizer from recognizing that the query matches an index.
+
+ Before PostgreSQL 8.4, the OPERATOR
+ clause could include a RECHECK option. This is no longer
+ supported because whether an index operator is “lossy” is now
+ determined on-the-fly at run time. This allows efficient handling of
+ cases where an operator might or might not be lossy.
+
Examples
+ The following example command defines a GiST index operator class
+ for the data type _int4 (array of int4). See the
+ intarray module for the complete example.
+
+CREATE OPERATOR CLASS gist__int_ops
+ DEFAULT FOR TYPE _int4 USING gist AS
+ OPERATOR 3 &&,
+ OPERATOR 6 = (anyarray, anyarray),
+ OPERATOR 7 @>,
+ OPERATOR 8 <@,
+ OPERATOR 20 @@ (_int4, query_int),
+ FUNCTION 1 g_int_consistent (internal, _int4, smallint, oid, internal),
+ FUNCTION 2 g_int_union (internal, internal),
+ FUNCTION 3 g_int_compress (internal),
+ FUNCTION 4 g_int_decompress (internal),
+ FUNCTION 5 g_int_penalty (internal, internal, internal),
+ FUNCTION 6 g_int_picksplit (internal, internal),
+ FUNCTION 7 g_int_same (_int4, _int4, internal);
+
Compatibility
+ CREATE OPERATOR CLASS is a
+ PostgreSQL extension. There is no
+ CREATE OPERATOR CLASS statement in the SQL
+ standard.
+
CREATE OPERATOR
CREATE OPERATOR — define a new operator
Synopsis
+CREATE OPERATOR name (
+ {FUNCTION|PROCEDURE} = function_name
+ [, LEFTARG = left_type ] [, RIGHTARG = right_type ]
+ [, COMMUTATOR = com_op ] [, NEGATOR = neg_op ]
+ [, RESTRICT = res_proc ] [, JOIN = join_proc ]
+ [, HASHES ] [, MERGES ]
+)
+
Description
+ CREATE OPERATOR defines a new operator,
+ name. The user who
+ defines an operator becomes its owner. If a schema name is given
+ then the operator is created in the specified schema. Otherwise it
+ is created in the current schema.
+
+ The operator name is a sequence of up to NAMEDATALEN-1
+ (63 by default) characters from the following list:
+
++ - * / < > = ~ ! @ # % ^ & | ` ?
+
+
+ There are a few restrictions on your choice of name:
+
+ -- and /* cannot appear anywhere in an operator name,
+ since they will be taken as the start of a comment.
+
+ A multicharacter operator name cannot end in + or
+ -,
+ unless the name also contains at least one of these characters:
+
+ For example, @- is an allowed operator name,
+ but *- is not.
+ This restriction allows PostgreSQL to
+ parse SQL-compliant commands without requiring spaces between tokens.
+
+ The symbol => is reserved by the SQL grammar,
+ so it cannot be used as an operator name.
+
+
+ The operator != is mapped to
+ <> on input, so these two names are always
+ equivalent.
+
+ For binary operators, both LEFTARG and
+ RIGHTARG must be defined. For prefix operators only
+ RIGHTARG should be defined.
+ The function_name
+ function must have been previously defined using CREATE
+ FUNCTION and must be defined to accept the correct number
+ of arguments (either one or two) of the indicated types.
+
+ In the syntax of CREATE OPERATOR, the keywords
+ FUNCTION and PROCEDURE are
+ equivalent, but the referenced function must in any case be a function, not
+ a procedure. The use of the keyword PROCEDURE here is
+ historical and deprecated.
+
+ The other clauses specify optional operator optimization clauses.
+ Their meaning is detailed in Section 38.15.
+
+ To be able to create an operator, you must have USAGE
+ privilege on the argument types and the return type, as well
+ as EXECUTE privilege on the underlying function. If a
+ commutator or negator operator is specified, you must own these operators.
+
Parameters
name
+ The name of the operator to be defined. See above for allowable
+ characters. The name can be schema-qualified, for example
+ CREATE OPERATOR myschema.+ (...). If not, then
+ the operator is created in the current schema. Two operators
+ in the same schema can have the same name if they operate on
+ different data types. This is called
+ overloading.
+
function_name
+ The function used to implement this operator.
+
left_type
+ The data type of the operator's left operand, if any.
+ This option would be omitted for a prefix operator.
+
right_type
+ The data type of the operator's right operand.
+
com_op
+ The commutator of this operator.
+
neg_op
+ The negator of this operator.
+
res_proc
+ The restriction selectivity estimator function for this operator.
+
join_proc
+ The join selectivity estimator function for this operator.
+
HASHES
+ Indicates this operator can support a hash join.
+
MERGES
+ Indicates this operator can support a merge join.
+
+ To give a schema-qualified operator name in com_op or the other optional
+ arguments, use the OPERATOR() syntax, for example:
+
+COMMUTATOR = OPERATOR(myschema.===) ,
+
Notes
+ Refer to Section 38.14 for further information.
+
+ It is not possible to specify an operator's lexical precedence in
+ CREATE OPERATOR, because the parser's precedence behavior
+ is hard-wired. See Section 4.1.6 for precedence details.
+
+ The obsolete options SORT1, SORT2,
+ LTCMP, and GTCMP were formerly used to
+ specify the names of sort operators associated with a merge-joinable
+ operator. This is no longer necessary, since information about
+ associated operators is found by looking at B-tree operator families
+ instead. If one of these options is given, it is ignored except
+ for implicitly setting MERGES true.
+
+ Use DROP OPERATOR to delete user-defined operators
+ from a database. Use ALTER OPERATOR to modify operators in a
+ database.
+
Examples
+ The following command defines a new operator, area-equality, for
+ the data type box:
+
+CREATE OPERATOR === (
+ LEFTARG = box,
+ RIGHTARG = box,
+ FUNCTION = area_equal_function,
+ COMMUTATOR = ===,
+ NEGATOR = !==,
+ RESTRICT = area_restriction_function,
+ JOIN = area_join_function,
+ HASHES, MERGES
+);
+
Compatibility
+ CREATE OPERATOR is a
+ PostgreSQL extension. There are no
+ provisions for user-defined operators in the SQL standard.
+
CREATE OPERATOR FAMILY
CREATE OPERATOR FAMILY — define a new operator family
Synopsis
+CREATE OPERATOR FAMILY name USING index_method
+
Description
+ CREATE OPERATOR FAMILY creates a new operator family.
+ An operator family defines a collection of related operator classes,
+ and perhaps some additional operators and support functions that are
+ compatible with these operator classes but not essential for the
+ functioning of any individual index. (Operators and functions that
+ are essential to indexes should be grouped within the relevant operator
+ class, rather than being “loose” in the operator family.
+ Typically, single-data-type operators are bound to operator classes,
+ while cross-data-type operators can be loose in an operator family
+ containing operator classes for both data types.)
+
+ The new operator family is initially empty. It should be populated
+ by issuing subsequent CREATE OPERATOR CLASS commands
+ to add contained operator classes, and optionally
+ ALTER OPERATOR FAMILY commands to add “loose”
+ operators and their corresponding support functions.
+
+ If a schema name is given then the operator family is created in the
+ specified schema. Otherwise it is created in the current schema.
+ Two operator families in the same schema can have the same name only if they
+ are for different index methods.
+
+ The user who defines an operator family becomes its owner. Presently,
+ the creating user must be a superuser. (This restriction is made because
+ an erroneous operator family definition could confuse or even crash the
+ server.)
+
+ Refer to Section 38.16 for further information.
+
Parameters
name
+ The name of the operator family to be created. The name can be
+ schema-qualified.
+
index_method
+ The name of the index method this operator family is for.
+
Compatibility
+ CREATE OPERATOR FAMILY is a
+ PostgreSQL extension. There is no
+ CREATE OPERATOR FAMILY statement in the SQL
+ standard.
+
CREATE POLICY
CREATE POLICY — define a new row-level security policy for a table
Synopsis
+CREATE POLICY name ON table_name
+ [ AS { PERMISSIVE | RESTRICTIVE } ]
+ [ FOR { ALL | SELECT | INSERT | UPDATE | DELETE } ]
+ [ TO { role_name | PUBLIC | CURRENT_ROLE | CURRENT_USER | SESSION_USER } [, ...] ]
+ [ USING ( using_expression ) ]
+ [ WITH CHECK ( check_expression ) ]
+
Description
+ The CREATE POLICY command defines a new row-level
+ security policy for a table. Note that row-level security must be
+ enabled on the table (using ALTER TABLE ... ENABLE ROW LEVEL
+ SECURITY) in order for created policies to be applied.
+
+ A policy grants the permission to select, insert, update, or delete rows
+ that match the relevant policy expression. Existing table rows are
+ checked against the expression specified in USING,
+ while new rows that would be created via INSERT
+ or UPDATE are checked against the expression specified
+ in WITH CHECK. When a USING
+ expression returns true for a given row then that row is visible to the
+ user, while if false or null is returned then the row is not visible.
+ When a WITH CHECK expression returns true for a row
+ then that row is inserted or updated, while if false or null is returned
+ then an error occurs.
+
+ For INSERT, UPDATE, and
+ MERGE statements,
+ WITH CHECK expressions are enforced after
+ BEFORE triggers are fired, and before any actual data
+ modifications are made. Thus a BEFORE ROW trigger may
+ modify the data to be inserted, affecting the result of the security
+ policy check. WITH CHECK expressions are enforced
+ before any other constraints.
+
+ Policy names are per-table. Therefore, one policy name can be used for many
+ different tables and have a definition for each table which is appropriate to
+ that table.
+
+ Policies can be applied for specific commands or for specific roles. The
+ default for newly created policies is that they apply for all commands and
+ roles, unless otherwise specified. Multiple policies may apply to a single
+ command; see below for more details.
+ Table 292 summarizes how the different types
+ of policy apply to specific commands.
+
+ For policies that can have both USING
+ and WITH CHECK expressions (ALL
+ and UPDATE), if no WITH CHECK
+ expression is defined, then the USING expression will be
+ used both to determine which rows are visible (normal
+ USING case) and which new rows will be allowed to be
+ added (WITH CHECK case).
+
+ If row-level security is enabled for a table, but no applicable policies
+ exist, a “default deny” policy is assumed, so that no rows will
+ be visible or updatable.
+
Parameters
name
+ The name of the policy to be created. This must be distinct from the
+ name of any other policy for the table.
+
table_name
+ The name (optionally schema-qualified) of the table the
+ policy applies to.
+
PERMISSIVE
+ Specify that the policy is to be created as a permissive policy.
+ All permissive policies which are applicable to a given query will
+ be combined together using the Boolean “OR” operator. By creating
+ permissive policies, administrators can add to the set of records
+ which can be accessed. Policies are permissive by default.
+
RESTRICTIVE
+ Specify that the policy is to be created as a restrictive policy.
+ All restrictive policies which are applicable to a given query will
+ be combined together using the Boolean “AND” operator. By creating
+ restrictive policies, administrators can reduce the set of records
+ which can be accessed as all restrictive policies must be passed for
+ each record.
+
+ Note that there needs to be at least one permissive policy to grant
+ access to records before restrictive policies can be usefully used to
+ reduce that access. If only restrictive policies exist, then no records
+ will be accessible. When a mix of permissive and restrictive policies
+ are present, a record is only accessible if at least one of the
+ permissive policies passes, in addition to all the restrictive
+ policies.
+
command
+ The command to which the policy applies. Valid options are
+ ALL, SELECT,
+ INSERT, UPDATE,
+ and DELETE.
+ ALL is the default.
+ See below for specifics regarding how these are applied.
+
role_name
+ The role(s) to which the policy is to be applied. The default is
+ PUBLIC, which will apply the policy to all roles.
+
using_expression
+ Any SQL conditional expression (returning
+ boolean). The conditional expression cannot contain
+ any aggregate or window functions. This expression will be added
+ to queries that refer to the table if row-level security is enabled.
+ Rows for which the expression returns true will be visible. Any
+ rows for which the expression returns false or null will not be
+ visible to the user (in a SELECT), and will not be
+ available for modification (in an UPDATE
+ or DELETE). Such rows are silently suppressed; no error
+ is reported.
+
check_expression
+ Any SQL conditional expression (returning
+ boolean). The conditional expression cannot contain
+ any aggregate or window functions. This expression will be used in
+ INSERT and UPDATE queries against
+ the table if row-level security is enabled. Only rows for which the
+ expression evaluates to true will be allowed. An error will be thrown
+ if the expression evaluates to false or null for any of the records
+ inserted or any of the records that result from the update. Note that
+ the check_expression is
+ evaluated against the proposed new contents of the row, not the
+ original contents.
+
Per-Command Policies
ALL #
+ Using ALL for a policy means that it will apply
+ to all commands, regardless of the type of command. If an
+ ALL policy exists and more specific policies
+ exist, then both the ALL policy and the more
+ specific policy (or policies) will be applied.
+ Additionally, ALL policies will be applied to
+ both the selection side of a query and the modification side, using
+ the USING expression for both cases if only
+ a USING expression has been defined.
+
+ As an example, if an UPDATE is issued, then the
+ ALL policy will be applicable both to what the
+ UPDATE will be able to select as rows to be
+ updated (applying the USING expression),
+ and to the resulting updated rows, to check if they are permitted
+ to be added to the table (applying the WITH CHECK
+ expression, if defined, and the USING expression
+ otherwise). If an INSERT
+ or UPDATE command attempts to add rows to the
+ table that do not pass the ALL
+ policy's WITH CHECK expression, the entire
+ command will be aborted.
+
SELECT #
+ Using SELECT for a policy means that it will apply
+ to SELECT queries and whenever
+ SELECT permissions are required on the relation the
+ policy is defined for. The result is that only those records from the
+ relation that pass the SELECT policy will be
+ returned during a SELECT query, and that queries
+ that require SELECT permissions, such as
+ UPDATE, will also only see those records
+ that are allowed by the SELECT policy.
+ A SELECT policy cannot have a WITH
+ CHECK expression, as it only applies in cases where
+ records are being retrieved from the relation.
+
INSERT #
+ Using INSERT for a policy means that it will apply
+ to INSERT commands and MERGE
+ commands that contain INSERT actions.
+ Rows being inserted that do
+ not pass this policy will result in a policy violation error, and the
+ entire INSERT command will be aborted.
+ An INSERT policy cannot have
+ a USING expression, as it only applies in cases
+ where records are being added to the relation.
+
+ Note that INSERT with ON CONFLICT DO
+ UPDATE checks INSERT policies'
+ WITH CHECK expressions only for rows appended
+ to the relation by the INSERT path.
+
UPDATE #
+ Using UPDATE for a policy means that it will apply
+ to UPDATE, SELECT FOR UPDATE
+ and SELECT FOR SHARE commands, as well as
+ auxiliary ON CONFLICT DO UPDATE clauses of
+ INSERT commands.
+ MERGE commands containing UPDATE
+ actions are affected as well. Since UPDATE
+ involves pulling an existing record and replacing it with a new
+ modified record, UPDATE
+ policies accept both a USING expression and
+ a WITH CHECK expression.
+ The USING expression determines which records
+ the UPDATE command will see to operate against,
+ while the WITH CHECK expression defines which
+ modified rows are allowed to be stored back into the relation.
+
+ Any rows whose updated values do not pass the
+ WITH CHECK expression will cause an error, and the
+ entire command will be aborted. If only a USING
+ clause is specified, then that clause will be used for both
+ USING and WITH CHECK cases.
+
+ Typically an UPDATE command also needs to read
+ data from columns in the relation being updated (e.g., in a
+ WHERE clause or a RETURNING
+ clause, or in an expression on the right hand side of the
+ SET clause). In this case,
+ SELECT rights are also required on the relation
+ being updated, and the appropriate SELECT or
+ ALL policies will be applied in addition to
+ the UPDATE policies. Thus the user must have
+ access to the row(s) being updated through a SELECT
+ or ALL policy in addition to being granted
+ permission to update the row(s) via an UPDATE
+ or ALL policy.
+
+ When an INSERT command has an auxiliary
+ ON CONFLICT DO UPDATE clause, if the
+ UPDATE path is taken, the row to be updated is
+ first checked against the USING expressions of
+ any UPDATE policies, and then the new updated row
+ is checked against the WITH CHECK expressions.
+ Note, however, that unlike a standalone UPDATE
+ command, if the existing row does not pass the
+ USING expressions, an error will be thrown (the
+ UPDATE path will never be silently
+ avoided).
+
DELETE #
+ Using DELETE for a policy means that it will apply
+ to DELETE commands. Only rows that pass this
+ policy will be seen by a DELETE command. There can
+ be rows that are visible through a SELECT that are
+ not available for deletion, if they do not pass the
+ USING expression for
+ the DELETE policy.
+
+ In most cases a DELETE command also needs to read
+ data from columns in the relation that it is deleting from (e.g.,
+ in a WHERE clause or a
+ RETURNING clause). In this case,
+ SELECT rights are also required on the relation,
+ and the appropriate SELECT or
+ ALL policies will be applied in addition to
+ the DELETE policies. Thus the user must have
+ access to the row(s) being deleted through a SELECT
+ or ALL policy in addition to being granted
+ permission to delete the row(s) via a DELETE or
+ ALL policy.
+
+ A DELETE policy cannot have a WITH
+ CHECK expression, as it only applies in cases where
+ records are being deleted from the relation, so that there is no
+ new row to check.
+
Table 292. Policies Applied by Command Type
| Command | SELECT/ALL policy | INSERT/ALL policy | UPDATE/ALL policy | DELETE/ALL policy |
|---|
USING expression | WITH CHECK expression | USING expression | WITH CHECK expression | USING expression |
|---|
SELECT | Existing row | — | — | — | — |
SELECT FOR UPDATE/SHARE | Existing row | — | Existing row | — | — |
INSERT / MERGE ... THEN INSERT | — | New row | — | — | — |
INSERT ... RETURNING |
+ New row
+ | New row | — | — | — |
UPDATE / MERGE ... THEN UPDATE |
+ Existing & new rows
+ | — | Existing row | New row | — |
DELETE |
+ Existing row
+ | — | — | — | Existing row |
ON CONFLICT DO UPDATE | Existing & new rows | — | Existing row | New row | — |
Application of Multiple Policies
+ When multiple policies of different command types apply to the same command
+ (for example, SELECT and UPDATE
+ policies applied to an UPDATE command), then the user
+ must have both types of permissions (for example, permission to select rows
+ from the relation as well as permission to update them). Thus the
+ expressions for one type of policy are combined with the expressions for
+ the other type of policy using the AND operator.
+
+ When multiple policies of the same command type apply to the same command,
+ then there must be at least one PERMISSIVE policy
+ granting access to the relation, and all of the
+ RESTRICTIVE policies must pass. Thus all the
+ PERMISSIVE policy expressions are combined using
+ OR, all the RESTRICTIVE policy
+ expressions are combined using AND, and the results are
+ combined using AND. If there are no
+ PERMISSIVE policies, then access is denied.
+
+ Note that, for the purposes of combining multiple policies,
+ ALL policies are treated as having the same type as
+ whichever other type of policy is being applied.
+
+ For example, in an UPDATE command requiring both
+ SELECT and UPDATE permissions, if
+ there are multiple applicable policies of each type, they will be combined
+ as follows:
+
+
+expression from RESTRICTIVE SELECT/ALL policy 1
+AND
+expression from RESTRICTIVE SELECT/ALL policy 2
+AND
+...
+AND
+(
+ expression from PERMISSIVE SELECT/ALL policy 1
+ OR
+ expression from PERMISSIVE SELECT/ALL policy 2
+ OR
+ ...
+)
+AND
+expression from RESTRICTIVE UPDATE/ALL policy 1
+AND
+expression from RESTRICTIVE UPDATE/ALL policy 2
+AND
+...
+AND
+(
+ expression from PERMISSIVE UPDATE/ALL policy 1
+ OR
+ expression from PERMISSIVE UPDATE/ALL policy 2
+ OR
+ ...
+)
+
Notes
+ You must be the owner of a table to create or change policies for it.
+
+ While policies will be applied for explicit queries against tables
+ in the database, they are not applied when the system is performing internal
+ referential integrity checks or validating constraints. This means there are
+ indirect ways to determine that a given value exists. An example of this is
+ attempting to insert a duplicate value into a column that is a primary key
+ or has a unique constraint. If the insert fails then the user can infer that
+ the value already exists. (This example assumes that the user is permitted by
+ policy to insert records which they are not allowed to see.) Another example
+ is where a user is allowed to insert into a table which references another,
+ otherwise hidden table. Existence can be determined by the user inserting
+ values into the referencing table, where success would indicate that the
+ value exists in the referenced table. These issues can be addressed by
+ carefully crafting policies to prevent users from being able to insert,
+ delete, or update records at all which might possibly indicate a value they
+ are not otherwise able to see, or by using generated values (e.g., surrogate
+ keys) instead of keys with external meanings.
+
+ Generally, the system will enforce filter conditions imposed using
+ security policies prior to qualifications that appear in user queries,
+ in order to prevent inadvertent exposure of the protected data to
+ user-defined functions which might not be trustworthy. However,
+ functions and operators marked by the system (or the system
+ administrator) as LEAKPROOF may be evaluated before
+ policy expressions, as they are assumed to be trustworthy.
+
+ Since policy expressions
+ are added to the user's query directly, they will be run with the rights of
+ the user running the overall query. Therefore, users who are using a given
+ policy must be able to access any tables or functions referenced in the
+ expression or they will simply receive a permission denied error when
+ attempting to query the table that has row-level security enabled.
+ This does not change how views
+ work, however. As with normal queries and views, permission checks and
+ policies for the tables which are referenced by a view will use the view
+ owner's rights and any policies which apply to the view owner, except if
+ the view is defined using the security_invoker option
+ (see CREATE VIEW).
+
+ No separate policy exists for MERGE. Instead, the policies
+ defined for SELECT, INSERT,
+ UPDATE, and DELETE are applied
+ while executing MERGE, depending on the actions that are
+ performed.
+
+ Additional discussion and practical examples can be found
+ in Section 5.8.
+
Compatibility
+ CREATE POLICY is a PostgreSQL
+ extension.
+
CREATE PROCEDURE
CREATE PROCEDURE — define a new procedure
Synopsis
+CREATE [ OR REPLACE ] PROCEDURE
+ name ( [ [ argmode ] [ argname ] argtype [ { DEFAULT | = } default_expr ] [, ...] ] )
+ { LANGUAGE lang_name
+ | TRANSFORM { FOR TYPE type_name } [, ... ]
+ | [ EXTERNAL ] SECURITY INVOKER | [ EXTERNAL ] SECURITY DEFINER
+ | SET configuration_parameter { TO value | = value | FROM CURRENT }
+ | AS 'definition'
+ | AS 'obj_file', 'link_symbol'
+ | sql_body
+ } ...
+
Description
+ CREATE PROCEDURE defines a new procedure.
+ CREATE OR REPLACE PROCEDURE will either create a
+ new procedure, or replace an existing definition.
+ To be able to define a procedure, the user must have the
+ USAGE privilege on the language.
+
+ If a schema name is included, then the procedure is created in the
+ specified schema. Otherwise it is created in the current schema.
+ The name of the new procedure must not match any existing procedure or function
+ with the same input argument types in the same schema. However,
+ procedures and functions of different argument types can share a name (this is
+ called overloading).
+
+ To replace the current definition of an existing procedure, use
+ CREATE OR REPLACE PROCEDURE. It is not possible
+ to change the name or argument types of a procedure this way (if you
+ tried, you would actually be creating a new, distinct procedure).
+
+ When CREATE OR REPLACE PROCEDURE is used to replace an
+ existing procedure, the ownership and permissions of the procedure
+ do not change. All other procedure properties are assigned the
+ values specified or implied in the command. You must own the procedure
+ to replace it (this includes being a member of the owning role).
+
+ The user that creates the procedure becomes the owner of the procedure.
+
+ To be able to create a procedure, you must have USAGE
+ privilege on the argument types.
+
+ Refer to Section 38.4 for further information on writing
+ procedures.
+
Parameters
name
+ The name (optionally schema-qualified) of the procedure to create.
+
argmode
+ The mode of an argument: IN, OUT,
+ INOUT, or VARIADIC. If omitted,
+ the default is IN.
+
argname
+ The name of an argument.
+
argtype
+ The data type(s) of the procedure's arguments (optionally
+ schema-qualified), if any. The argument types can be base, composite,
+ or domain types, or can reference the type of a table column.
+
+ Depending on the implementation language it might also be allowed
+ to specify “pseudo-types” such as cstring.
+ Pseudo-types indicate that the actual argument type is either
+ incompletely specified, or outside the set of ordinary SQL data types.
+
+ The type of a column is referenced by writing
+ table_name.column_name%TYPE
default_expr
+ An expression to be used as default value if the parameter is
+ not specified. The expression has to be coercible to the
+ argument type of the parameter.
+ All input parameters following a
+ parameter with a default value must have default values as well.
+
lang_name
+ The name of the language that the procedure is implemented in.
+ It can be sql, c,
+ internal, or the name of a user-defined
+ procedural language, e.g., plpgsql. The default is
+ sql if sql_body is specified. Enclosing the
+ name in single quotes is deprecated and requires matching case.
+
TRANSFORM { FOR TYPE type_name } [, ... ] }
+ Lists which transforms a call to the procedure should apply. Transforms
+ convert between SQL types and language-specific data types;
+ see CREATE TRANSFORM. Procedural language
+ implementations usually have hardcoded knowledge of the built-in types,
+ so those don't need to be listed here. If a procedural language
+ implementation does not know how to handle a type and no transform is
+ supplied, it will fall back to a default behavior for converting data
+ types, but this depends on the implementation.
+
[EXTERNAL] SECURITY INVOKER
[EXTERNAL] SECURITY DEFINERSECURITY INVOKER indicates that the procedure
+ is to be executed with the privileges of the user that calls it.
+ That is the default. SECURITY DEFINER
+ specifies that the procedure is to be executed with the
+ privileges of the user that owns it.
+
+ The key word EXTERNAL is allowed for SQL
+ conformance, but it is optional since, unlike in SQL, this feature
+ applies to all procedures not only external ones.
+
+ A SECURITY DEFINER procedure cannot execute
+ transaction control statements (for example, COMMIT
+ and ROLLBACK, depending on the language).
+
configuration_parameter
value
+ The SET clause causes the specified configuration
+ parameter to be set to the specified value when the procedure is
+ entered, and then restored to its prior value when the procedure exits.
+ SET FROM CURRENT saves the value of the parameter that
+ is current when CREATE PROCEDURE is executed as the value
+ to be applied when the procedure is entered.
+
+ If a SET clause is attached to a procedure, then
+ the effects of a SET LOCAL command executed inside the
+ procedure for the same variable are restricted to the procedure: the
+ configuration parameter's prior value is still restored at procedure exit.
+ However, an ordinary
+ SET command (without LOCAL) overrides the
+ SET clause, much as it would do for a previous SET
+ LOCAL command: the effects of such a command will persist after
+ procedure exit, unless the current transaction is rolled back.
+
+ If a SET clause is attached to a procedure, then
+ that procedure cannot execute transaction control statements (for
+ example, COMMIT and ROLLBACK,
+ depending on the language).
+
+ See SET and
+ Chapter 20
+ for more information about allowed parameter names and values.
+
definition
+ A string constant defining the procedure; the meaning depends on the
+ language. It can be an internal procedure name, the path to an
+ object file, an SQL command, or text in a procedural language.
+
+ It is often helpful to use dollar quoting (see Section 4.1.2.4) to write the procedure definition
+ string, rather than the normal single quote syntax. Without dollar
+ quoting, any single quotes or backslashes in the procedure definition must
+ be escaped by doubling them.
+
obj_file, link_symbol
+ This form of the AS clause is used for
+ dynamically loadable C language procedures when the procedure name
+ in the C language source code is not the same as the name of
+ the SQL procedure. The string obj_file is the name of the shared
+ library file containing the compiled C procedure, and is interpreted
+ as for the LOAD command. The string
+ link_symbol is the
+ procedure's link symbol, that is, the name of the procedure in the C
+ language source code. If the link symbol is omitted, it is assumed
+ to be the same as the name of the SQL procedure being defined.
+
+ When repeated CREATE PROCEDURE calls refer to
+ the same object file, the file is only loaded once per session.
+ To unload and
+ reload the file (perhaps during development), start a new session.
+
sql_body
+ The body of a LANGUAGE SQL procedure. This should
+ be a block
+
+BEGIN ATOMIC
+ statement;
+ statement;
+ ...
+ statement;
+END
+
+
+ This is similar to writing the text of the procedure body as a string
+ constant (see definition above), but there
+ are some differences: This form only works for LANGUAGE
+ SQL, the string constant form works for all languages. This
+ form is parsed at procedure definition time, the string constant form is
+ parsed at execution time; therefore this form cannot support
+ polymorphic argument types and other constructs that are not resolvable
+ at procedure definition time. This form tracks dependencies between the
+ procedure and objects used in the procedure body, so DROP
+ ... CASCADE will work correctly, whereas the form using
+ string literals may leave dangling procedures. Finally, this form is
+ more compatible with the SQL standard and other SQL implementations.
+
Notes
+ See CREATE FUNCTION for more details on function
+ creation that also apply to procedures.
+
+ Use CALL to execute a procedure.
+
Examples
+
+CREATE PROCEDURE insert_data(a integer, b integer)
+LANGUAGE SQL
+AS $$
+INSERT INTO tbl VALUES (a);
+INSERT INTO tbl VALUES (b);
+$$;
+
+ or
+
+CREATE PROCEDURE insert_data(a integer, b integer)
+LANGUAGE SQL
+BEGIN ATOMIC
+ INSERT INTO tbl VALUES (a);
+ INSERT INTO tbl VALUES (b);
+END;
+
+ and call like this:
+
+CALL insert_data(1, 2);
+
Compatibility
+ A CREATE PROCEDURE command is defined in the SQL
+ standard. The PostgreSQL implementation can be
+ used in a compatible way but has many extensions. For details see also
+ CREATE FUNCTION.
+
CREATE PUBLICATION
CREATE PUBLICATION — define a new publication
Synopsis
+CREATE PUBLICATION name
+ [ FOR ALL TABLES
+ | FOR publication_object [, ... ] ]
+ [ WITH ( publication_parameter [= value] [, ... ] ) ]
+
+where publication_object is one of:
+
+ TABLE [ ONLY ] table_name [ * ] [ ( column_name [, ... ] ) ] [ WHERE ( expression ) ] [, ... ]
+ TABLES IN SCHEMA { schema_name | CURRENT_SCHEMA } [, ... ]
+
Description
+ CREATE PUBLICATION adds a new publication
+ into the current database. The publication name must be distinct from
+ the name of any existing publication in the current database.
+
+ A publication is essentially a group of tables whose data changes are
+ intended to be replicated through logical replication. See
+ Section 31.1 for details about how
+ publications fit into the logical replication setup.
+
Parameters
name #
+ The name of the new publication.
+
FOR TABLE #
+ Specifies a list of tables to add to the publication. If
+ ONLY is specified before the table name, only
+ that table is added to the publication. If ONLY is not
+ specified, the table and all its descendant tables (if any) are added.
+ Optionally, * can be specified after the table name to
+ explicitly indicate that descendant tables are included.
+ This does not apply to a partitioned table, however. The partitions of
+ a partitioned table are always implicitly considered part of the
+ publication, so they are never explicitly added to the publication.
+
+ If the optional WHERE clause is specified, it defines a
+ row filter expression. Rows for
+ which the expression
+ evaluates to false or null will not be published. Note that parentheses
+ are required around the expression. It has no effect on
+ TRUNCATE commands.
+
+ When a column list is specified, only the named columns are replicated.
+ If no column list is specified, all columns of the table are replicated
+ through this publication, including any columns added later. It has no
+ effect on TRUNCATE commands. See
+ Section 31.4 for details about column
+ lists.
+
+ Only persistent base tables and partitioned tables can be part of a
+ publication. Temporary tables, unlogged tables, foreign tables,
+ materialized views, and regular views cannot be part of a publication.
+
+ Specifying a column list when the publication also publishes
+ FOR TABLES IN SCHEMA is not supported.
+
+ When a partitioned table is added to a publication, all of its existing
+ and future partitions are implicitly considered to be part of the
+ publication. So, even operations that are performed directly on a
+ partition are also published via publications that its ancestors are
+ part of.
+
FOR ALL TABLES #
+ Marks the publication as one that replicates changes for all tables in
+ the database, including tables created in the future.
+
FOR TABLES IN SCHEMA #
+ Marks the publication as one that replicates changes for all tables in
+ the specified list of schemas, including tables created in the future.
+
+ Specifying a schema when the publication also publishes a table with a
+ column list is not supported.
+
+ Only persistent base tables and partitioned tables present in the schema
+ will be included as part of the publication. Temporary tables, unlogged
+ tables, foreign tables, materialized views, and regular views from the
+ schema will not be part of the publication.
+
+ When a partitioned table is published via schema level publication, all
+ of its existing and future partitions are implicitly considered to be part of the
+ publication, regardless of whether they are from the publication schema or not.
+ So, even operations that are performed directly on a
+ partition are also published via publications that its ancestors are
+ part of.
+
WITH ( publication_parameter [= value] [, ... ] ) #
+ This clause specifies optional parameters for a publication. The
+ following parameters are supported:
+
+
publish (string) #
+ This parameter determines which DML operations will be published by
+ the new publication to the subscribers. The value is
+ comma-separated list of operations. The allowed operations are
+ insert, update,
+ delete, and truncate.
+ The default is to publish all actions,
+ and so the default value for this option is
+ 'insert, update, delete, truncate'.
+
+ This parameter only affects DML operations. In particular, the initial
+ data synchronization (see Section 31.7.1)
+ for logical replication does not take this parameter into account when
+ copying existing table data.
+
publish_via_partition_root (boolean) #
+ This parameter determines whether changes in a partitioned table (or
+ on its partitions) contained in the publication will be published
+ using the identity and schema of the partitioned table rather than
+ that of the individual partitions that are actually changed; the
+ latter is the default. Enabling this allows the changes to be
+ replicated into a non-partitioned table or a partitioned table
+ consisting of a different set of partitions.
+
+ There can be a case where a subscription combines multiple
+ publications. If a partitioned table is published by any
+ subscribed publications which set
+ publish_via_partition_root = true, changes on this
+ partitioned table (or on its partitions) will be published using
+ the identity and schema of this partitioned table rather than
+ that of the individual partitions.
+
+ This parameter also affects how row filters and column lists are
+ chosen for partitions; see below for details.
+
+ If this is enabled, TRUNCATE operations performed
+ directly on partitions are not replicated.
+
+ When specifying a parameter of type boolean, the
+ = value
+ part can be omitted, which is equivalent to
+ specifying TRUE.
+
Notes
+ If FOR TABLE, FOR ALL TABLES or
+ FOR TABLES IN SCHEMA are not specified, then the
+ publication starts out with an empty set of tables. That is useful if
+ tables or schemas are to be added later.
+
+ The creation of a publication does not start replication. It only defines
+ a grouping and filtering logic for future subscribers.
+
+ To create a publication, the invoking user must have the
+ CREATE privilege for the current database.
+ (Of course, superusers bypass this check.)
+
+ To add a table to a publication, the invoking user must have ownership
+ rights on the table. The FOR ALL TABLES and
+ FOR TABLES IN SCHEMA clauses require the invoking
+ user to be a superuser.
+
+ The tables added to a publication that publishes UPDATE
+ and/or DELETE operations must have
+ REPLICA IDENTITY defined. Otherwise those operations will be
+ disallowed on those tables.
+
+ Any column list must include the REPLICA IDENTITY columns
+ in order for UPDATE or DELETE
+ operations to be published. There are no column list restrictions if the
+ publication publishes only INSERT operations.
+
+ A row filter expression (i.e., the WHERE clause) must contain only
+ columns that are covered by the REPLICA IDENTITY, in
+ order for UPDATE and DELETE operations
+ to be published. For publication of INSERT operations,
+ any column may be used in the WHERE expression. The
+ row filter allows simple expressions that don't have
+ user-defined functions, user-defined operators, user-defined types,
+ user-defined collations, non-immutable built-in functions, or references to
+ system columns.
+
+ The row filter on a table becomes redundant if
+ FOR TABLES IN SCHEMA is specified and the table
+ belongs to the referred schema.
+
+ For published partitioned tables, the row filter for each
+ partition is taken from the published partitioned table if the
+ publication parameter publish_via_partition_root is true,
+ or from the partition itself if it is false (the default).
+ See Section 31.3 for details about row
+ filters.
+ Similarly, for published partitioned tables, the column list for each
+ partition is taken from the published partitioned table if the
+ publication parameter publish_via_partition_root is true,
+ or from the partition itself if it is false.
+
+ For an INSERT ... ON CONFLICT command, the publication will
+ publish the operation that results from the command. Depending
+ on the outcome, it may be published as either INSERT or
+ UPDATE, or it may not be published at all.
+
+ For a MERGE command, the publication will publish an
+ INSERT, UPDATE, or DELETE
+ for each row inserted, updated, or deleted.
+
+ ATTACHing a table into a partition tree whose root is
+ published using a publication with publish_via_partition_root
+ set to true does not result in the table's existing contents
+ being replicated.
+
+ COPY ... FROM commands are published
+ as INSERT operations.
+
+ DDL operations are not published.
+
+ The WHERE clause expression is executed with the role used
+ for the replication connection.
+
Examples
+ Create a publication that publishes all changes in two tables:
+
+CREATE PUBLICATION mypublication FOR TABLE users, departments;
+
+
+ Create a publication that publishes all changes from active departments:
+
+CREATE PUBLICATION active_departments FOR TABLE departments WHERE (active IS TRUE);
+
+
+ Create a publication that publishes all changes in all tables:
+
+CREATE PUBLICATION alltables FOR ALL TABLES;
+
+
+ Create a publication that only publishes INSERT
+ operations in one table:
+
+CREATE PUBLICATION insert_only FOR TABLE mydata
+ WITH (publish = 'insert');
+
+
+ Create a publication that publishes all changes for tables
+ users, departments and
+ all changes for all the tables present in the schema
+ production:
+
+CREATE PUBLICATION production_publication FOR TABLE users, departments, TABLES IN SCHEMA production;
+
+
+ Create a publication that publishes all changes for all the tables present in
+ the schemas marketing and
+ sales:
+
+CREATE PUBLICATION sales_publication FOR TABLES IN SCHEMA marketing, sales;
+
+ Create a publication that publishes all changes for table users,
+ but replicates only columns user_id and
+ firstname:
+
+CREATE PUBLICATION users_filtered FOR TABLE users (user_id, firstname);
+
Compatibility
+ CREATE PUBLICATION is a PostgreSQL
+ extension.
+
CREATE ROLE
CREATE ROLE — define a new database role
Synopsis
+CREATE ROLE name [ [ WITH ] option [ ... ] ]
+
+where option can be:
+
+ SUPERUSER | NOSUPERUSER
+ | CREATEDB | NOCREATEDB
+ | CREATEROLE | NOCREATEROLE
+ | INHERIT | NOINHERIT
+ | LOGIN | NOLOGIN
+ | REPLICATION | NOREPLICATION
+ | BYPASSRLS | NOBYPASSRLS
+ | CONNECTION LIMIT connlimit
+ | [ ENCRYPTED ] PASSWORD 'password' | PASSWORD NULL
+ | VALID UNTIL 'timestamp'
+ | IN ROLE role_name [, ...]
+ | IN GROUP role_name [, ...]
+ | ROLE role_name [, ...]
+ | ADMIN role_name [, ...]
+ | USER role_name [, ...]
+ | SYSID uid
+
Description
+ CREATE ROLE adds a new role to a
+ PostgreSQL database cluster. A role is
+ an entity that can own database objects and have database privileges;
+ a role can be considered a “user”, a “group”, or both
+ depending on how it is used. Refer to
+ Chapter 22 and Chapter 21 for information about managing
+ users and authentication. You must have CREATEROLE
+ privilege or be a database superuser to use this command.
+
+ Note that roles are defined at the database cluster
+ level, and so are valid in all databases in the cluster.
+
+ During role creation it is possible to immediately assign the newly created
+ role to be a member of an existing role, and also assign existing roles
+ to be members of the newly created role. The rules for which initial
+ role membership options are enabled described below in the
+ IN ROLE, ROLE, and
+ ADMIN clauses. The GRANT
+ command has fine-grained option control during membership creation,
+ and the ability to modify these options after the new role is created.
+
Parameters
name
+ The name of the new role.
+
SUPERUSER
NOSUPERUSER
+ These clauses determine whether the new role is a “superuser”,
+ who can override all access restrictions within the database.
+ Superuser status is dangerous and should be used only when really
+ needed. You must yourself be a superuser to create a new superuser.
+ If not specified,
+ NOSUPERUSER is the default.
+
CREATEDB
NOCREATEDB
+ These clauses define a role's ability to create databases. If
+ CREATEDB is specified, the role being
+ defined will be allowed to create new databases. Specifying
+ NOCREATEDB will deny a role the ability to
+ create databases. If not specified,
+ NOCREATEDB is the default.
+ Only superuser roles or roles with CREATEDB
+ can specify CREATEDB.
+
CREATEROLE
NOCREATEROLE
+ These clauses determine whether a role will be permitted to
+ create, alter, drop, comment on, and change the security label for
+ other roles.
+ See role creation for more details about what
+ capabilities are conferred by this privilege.
+ If not specified, NOCREATEROLE is the default.
+
INHERIT
NOINHERIT
+ This affects the membership inheritance status when this
+ role is added as a member of another role, both in this and
+ future commands. Specifically, it controls the inheritance
+ status of memberships added with this command using the
+ IN ROLE clause, and in later commands using
+ the ROLE clause. It is also used as the
+ default inheritance status when adding this role as a member
+ using the GRANT command. If not specified,
+ INHERIT is the default.
+
+ In PostgreSQL versions before 16,
+ inheritance was a role-level attribute that controlled all runtime
+ membership checks for that role.
+
LOGIN
NOLOGIN
+ These clauses determine whether a role is allowed to log in;
+ that is, whether the role can be given as the initial session
+ authorization name during client connection. A role having
+ the LOGIN attribute can be thought of as a user.
+ Roles without this attribute are useful for managing database
+ privileges, but are not users in the usual sense of the word.
+ If not specified,
+ NOLOGIN is the default, except when
+ CREATE ROLE is invoked through its alternative spelling
+ CREATE USER.
+
REPLICATION
NOREPLICATION
+ These clauses determine whether a role is a replication role. A role
+ must have this attribute (or be a superuser) in order to be able to
+ connect to the server in replication mode (physical or logical
+ replication) and in order to be able to create or drop replication
+ slots.
+ A role having the REPLICATION attribute is a very
+ highly privileged role, and should only be used on roles actually
+ used for replication. If not specified,
+ NOREPLICATION is the default.
+ Only superuser roles or roles with REPLICATION
+ can specify REPLICATION.
+
BYPASSRLS
NOBYPASSRLS
+ These clauses determine whether a role bypasses every row-level
+ security (RLS) policy. NOBYPASSRLS is the default.
+ Only superuser roles or roles with BYPASSRLS
+ can specify BYPASSRLS.
+
+ Note that pg_dump will set row_security to
+ OFF by default, to ensure all contents of a table are
+ dumped out. If the user running pg_dump does not have appropriate
+ permissions, an error will be returned. However, superusers and the
+ owner of the table being dumped always bypass RLS.
+
CONNECTION LIMIT connlimit
+ If role can log in, this specifies how many concurrent connections
+ the role can make. -1 (the default) means no limit. Note that only
+ normal connections are counted towards this limit. Neither prepared
+ transactions nor background worker connections are counted towards
+ this limit.
+
- [
ENCRYPTED ] PASSWORD 'password'
PASSWORD NULL
+ Sets the role's password. (A password is only of use for
+ roles having the LOGIN attribute, but you
+ can nonetheless define one for roles without it.) If you do
+ not plan to use password authentication you can omit this
+ option. If no password is specified, the password will be set
+ to null and password authentication will always fail for that
+ user. A null password can optionally be written explicitly as
+ PASSWORD NULL.
+
Note
+ Specifying an empty string will also set the password to null,
+ but that was not the case before PostgreSQL
+ version 10. In earlier versions, an empty string could be used,
+ or not, depending on the authentication method and the exact
+ version, and libpq would refuse to use it in any case.
+ To avoid the ambiguity, specifying an empty string should be
+ avoided.
+
+ The password is always stored encrypted in the system catalogs. The
+ ENCRYPTED keyword has no effect, but is accepted for
+ backwards compatibility. The method of encryption is determined
+ by the configuration parameter password_encryption.
+ If the presented password string is already in MD5-encrypted or
+ SCRAM-encrypted format, then it is stored as-is regardless of
+ password_encryption (since the system cannot decrypt
+ the specified encrypted password string, to encrypt it in a
+ different format). This allows reloading of encrypted passwords
+ during dump/restore.
+
VALID UNTIL 'timestamp'
+ The VALID UNTIL clause sets a date and
+ time after which the role's password is no longer valid. If
+ this clause is omitted the password will be valid for all time.
+
IN ROLE role_name
+ The IN ROLE clause causes the new role to
+ be automatically added as a member of the specified existing
+ roles. The new membership will have the SET
+ option enabled and the ADMIN option disabled.
+ The INHERIT option will be enabled unless the
+ NOINHERIT option is specified.
+
IN GROUP role_nameIN GROUP is an obsolete spelling of
+ IN ROLE.
+
ROLE role_name
+ The ROLE clause causes one or more specified
+ existing roles to be automatically added as members, with the
+ SET option enabled. This in effect makes the
+ new role a “group”. Roles named in this clause
+ with the role-level INHERIT attribute will have
+ the INHERIT option enabled in the new membership.
+ New memberships will have the ADMIN option disabled.
+
ADMIN role_name
+ The ADMIN clause has the same effect as
+ ROLE, but the named roles are added as members
+ of the new role with ADMIN enabled, giving
+ them the right to grant membership in the new role to others.
+
USER role_name
+ The USER clause is an obsolete spelling of
+ the ROLE clause.
+
SYSID uid
+ The SYSID clause is ignored, but is accepted
+ for backwards compatibility.
+
Notes
+ Use ALTER ROLE to
+ change the attributes of a role, and DROP ROLE
+ to remove a role. All the attributes
+ specified by CREATE ROLE can be modified by later
+ ALTER ROLE commands.
+
+ The preferred way to add and remove members of roles that are being
+ used as groups is to use
+ GRANT and
+ REVOKE.
+
+ The VALID UNTIL clause defines an expiration time for a
+ password only, not for the role per se. In
+ particular, the expiration time is not enforced when logging in using
+ a non-password-based authentication method.
+
+ The role attributes defined here are non-inheritable, i.e., being a
+ member of a role with, e.g., CREATEDB will not
+ allow the member to create new databases even if the membership grant
+ has the INHERIT option. Of course, if the membership
+ grant has the SET option the member role would be able to
+ SET ROLE to the
+ createdb role and then create a new database.
+
+ The membership grants created by the
+ IN ROLE, ROLE, and ADMIN
+ clauses have the role executing this command as the grantor.
+
+ The INHERIT attribute is the default for reasons of backwards
+ compatibility: in prior releases of PostgreSQL,
+ users always had access to all privileges of groups they were members of.
+ However, NOINHERIT provides a closer match to the semantics
+ specified in the SQL standard.
+
+ PostgreSQL includes a program createuser that has
+ the same functionality as CREATE ROLE (in fact,
+ it calls this command) but can be run from the command shell.
+
+ The CONNECTION LIMIT option is only enforced approximately;
+ if two new sessions start at about the same time when just one
+ connection “slot” remains for the role, it is possible that
+ both will fail. Also, the limit is never enforced for superusers.
+
+ Caution must be exercised when specifying an unencrypted password
+ with this command. The password will be transmitted to the server
+ in cleartext, and it might also be logged in the client's command
+ history or the server log. The command createuser, however, transmits
+ the password encrypted. Also, psql
+ contains a command
+ \password that can be used to safely change the
+ password later.
+
Examples
+ Create a role that can log in, but don't give it a password:
+
+CREATE ROLE jonathan LOGIN;
+
+
+ Create a role with a password:
+
+CREATE USER davide WITH PASSWORD 'jw8s0F4';
+
+ (CREATE USER is the same as CREATE ROLE except
+ that it implies LOGIN.)
+
+ Create a role with a password that is valid until the end of 2004.
+ After one second has ticked in 2005, the password is no longer
+ valid.
+
+
+CREATE ROLE miriam WITH LOGIN PASSWORD 'jw8s0F4' VALID UNTIL '2005-01-01';
+
+
+ Create a role that can create databases and manage roles:
+
+CREATE ROLE admin WITH CREATEDB CREATEROLE;
+
Compatibility
+ The CREATE ROLE statement is in the SQL standard,
+ but the standard only requires the syntax
+
+CREATE ROLE name [ WITH ADMIN role_name ]
+
+ Multiple initial administrators, and all the other options of
+ CREATE ROLE, are
+ PostgreSQL extensions.
+
+ The SQL standard defines the concepts of users and roles, but it
+ regards them as distinct concepts and leaves all commands defining
+ users to be specified by each database implementation. In
+ PostgreSQL we have chosen to unify
+ users and roles into a single kind of entity. Roles therefore
+ have many more optional attributes than they do in the standard.
+
+ The behavior specified by the SQL standard is most closely approximated
+ creating SQL-standard users as PostgreSQL
+ roles with the NOINHERIT option, and SQL-standard
+ roles as PostgreSQL roles with the
+ INHERIT option.
+
CREATE RULE
CREATE RULE — define a new rewrite rule
Synopsis
+CREATE [ OR REPLACE ] RULE name AS ON event
+ TO table_name [ WHERE condition ]
+ DO [ ALSO | INSTEAD ] { NOTHING | command | ( command ; command ... ) }
+
+where event can be one of:
+
+ SELECT | INSERT | UPDATE | DELETE
+
Description
+ CREATE RULE defines a new rule applying to a specified
+ table or view.
+ CREATE OR REPLACE RULE will either create a
+ new rule, or replace an existing rule of the same name for the same
+ table.
+
+ The PostgreSQL rule system allows one to
+ define an alternative action to be performed on insertions, updates,
+ or deletions in database tables. Roughly speaking, a rule causes
+ additional commands to be executed when a given command on a given
+ table is executed. Alternatively, an INSTEAD
+ rule can replace a given command by another, or cause a command
+ not to be executed at all. Rules are used to implement SQL
+ views as well. It is important to realize that a rule is really
+ a command transformation mechanism, or command macro. The
+ transformation happens before the execution of the command starts.
+ If you actually want an operation that fires independently for each
+ physical row, you probably want to use a trigger, not a rule.
+ More information about the rules system is in Chapter 41.
+
+ Presently, ON SELECT rules can only be attached
+ to views. Such a rule must be named "_RETURN",
+ must be an unconditional INSTEAD rule, and must have
+ an action that consists of a single SELECT command.
+ This command defines the visible contents of the view. (The view
+ itself is basically a dummy table with no storage.) It's best to
+ regard such a rule as an implementation detail. While a view can be
+ redefined via CREATE OR REPLACE RULE "_RETURN" AS
+ ..., it's better style to use CREATE OR REPLACE
+ VIEW.
+
+ You can create the illusion of an updatable view by defining
+ ON INSERT, ON UPDATE, and
+ ON DELETE rules (or any subset of those that's
+ sufficient for your purposes) to replace update actions on the view
+ with appropriate updates on other tables. If you want to support
+ INSERT RETURNING and so on, then be sure to put a suitable
+ RETURNING clause into each of these rules.
+
+ There is a catch if you try to use conditional rules for complex view
+ updates: there must be an unconditional
+ INSTEAD rule for each action you wish to allow
+ on the view. If the rule is conditional, or is not
+ INSTEAD, then the system will still reject
+ attempts to perform the update action, because it thinks it might
+ end up trying to perform the action on the dummy table of the view
+ in some cases. If you want to handle all the useful cases in
+ conditional rules, add an unconditional DO
+ INSTEAD NOTHING rule to ensure that the system
+ understands it will never be called on to update the dummy table.
+ Then make the conditional rules non-INSTEAD; in
+ the cases where they are applied, they add to the default
+ INSTEAD NOTHING action. (This method does not
+ currently work to support RETURNING queries, however.)
+
Note
+ A view that is simple enough to be automatically updatable (see CREATE VIEW) does not require a user-created rule in
+ order to be updatable. While you can create an explicit rule anyway,
+ the automatic update transformation will generally outperform an
+ explicit rule.
+
+ Another alternative worth considering is to use INSTEAD OF
+ triggers (see CREATE TRIGGER) in place of rules.
+
Parameters
name
+ The name of a rule to create. This must be distinct from the
+ name of any other rule for the same table. Multiple rules on
+ the same table and same event type are applied in alphabetical
+ name order.
+
event
+ The event is one of SELECT,
+ INSERT, UPDATE, or
+ DELETE. Note that an
+ INSERT containing an ON
+ CONFLICT clause cannot be used on tables that have
+ either INSERT or UPDATE
+ rules. Consider using an updatable view instead.
+
table_name
+ The name (optionally schema-qualified) of the table or view the
+ rule applies to.
+
condition
+ Any SQL conditional expression (returning
+ boolean). The condition expression cannot refer
+ to any tables except NEW and OLD, and
+ cannot contain aggregate functions.
+
INSTEADINSTEAD indicates that the commands should be
+ executed instead of the original command.
+
ALSOALSO indicates that the commands should be
+ executed in addition to the original
+ command.
+
+ If neither ALSO nor
+ INSTEAD is specified, ALSO
+ is the default.
+
command
+ The command or commands that make up the rule action. Valid
+ commands are SELECT,
+ INSERT, UPDATE,
+ DELETE, or NOTIFY.
+
+ Within condition and
+ command, the special
+ table names NEW and OLD can
+ be used to refer to values in the referenced table.
+ NEW is valid in ON INSERT and
+ ON UPDATE rules to refer to the new row being
+ inserted or updated. OLD is valid in
+ ON UPDATE and ON DELETE rules
+ to refer to the existing row being updated or deleted.
+
Notes
+ You must be the owner of a table to create or change rules for it.
+
+ In a rule for INSERT, UPDATE, or
+ DELETE on a view, you can add a RETURNING
+ clause that emits the view's columns. This clause will be used to compute
+ the outputs if the rule is triggered by an INSERT RETURNING,
+ UPDATE RETURNING, or DELETE RETURNING command
+ respectively. When the rule is triggered by a command without
+ RETURNING, the rule's RETURNING clause will be
+ ignored. The current implementation allows only unconditional
+ INSTEAD rules to contain RETURNING; furthermore
+ there can be at most one RETURNING clause among all the rules
+ for the same event. (This ensures that there is only one candidate
+ RETURNING clause to be used to compute the results.)
+ RETURNING queries on the view will be rejected if
+ there is no RETURNING clause in any available rule.
+
+ It is very important to take care to avoid circular rules. For
+ example, though each of the following two rule definitions are
+ accepted by PostgreSQL, the
+ SELECT command would cause
+ PostgreSQL to report an error because
+ of recursive expansion of a rule:
+
+
+CREATE RULE "_RETURN" AS
+ ON SELECT TO t1
+ DO INSTEAD
+ SELECT * FROM t2;
+
+CREATE RULE "_RETURN" AS
+ ON SELECT TO t2
+ DO INSTEAD
+ SELECT * FROM t1;
+
+SELECT * FROM t1;
+
+
+ Presently, if a rule action contains a NOTIFY
+ command, the NOTIFY command will be executed
+ unconditionally, that is, the NOTIFY will be
+ issued even if there are not any rows that the rule should apply
+ to. For example, in:
+
+CREATE RULE notify_me AS ON UPDATE TO mytable DO ALSO NOTIFY mytable;
+
+UPDATE mytable SET name = 'foo' WHERE id = 42;
+
+ one NOTIFY event will be sent during the
+ UPDATE, whether or not there are any rows that
+ match the condition id = 42. This is an
+ implementation restriction that might be fixed in future releases.
+
Compatibility
+ CREATE RULE is a
+ PostgreSQL language extension, as is the
+ entire query rewrite system.
+
CREATE SCHEMA
CREATE SCHEMA — define a new schema
Synopsis
+CREATE SCHEMA schema_name [ AUTHORIZATION role_specification ] [ schema_element [ ... ] ]
+CREATE SCHEMA AUTHORIZATION role_specification [ schema_element [ ... ] ]
+CREATE SCHEMA IF NOT EXISTS schema_name [ AUTHORIZATION role_specification ]
+CREATE SCHEMA IF NOT EXISTS AUTHORIZATION role_specification
+
+where role_specification can be:
+
+ user_name
+ | CURRENT_ROLE
+ | CURRENT_USER
+ | SESSION_USER
+
Description
+ CREATE SCHEMA enters a new schema
+ into the current database.
+ The schema name must be distinct from the name of any existing schema
+ in the current database.
+
+ A schema is essentially a namespace:
+ it contains named objects (tables, data types, functions, and operators)
+ whose names can duplicate those of other objects existing in other
+ schemas. Named objects are accessed either by “qualifying”
+ their names with the schema name as a prefix, or by setting a search
+ path that includes the desired schema(s). A CREATE command
+ specifying an unqualified object name creates the object
+ in the current schema (the one at the front of the search path,
+ which can be determined with the function current_schema).
+
+ Optionally, CREATE SCHEMA can include subcommands
+ to create objects within the new schema. The subcommands are treated
+ essentially the same as separate commands issued after creating the
+ schema, except that if the AUTHORIZATION clause is used,
+ all the created objects will be owned by that user.
+
Parameters
schema_name
+ The name of a schema to be created. If this is omitted, the
+ user_name
+ is used as the schema name. The name cannot
+ begin with pg_, as such names
+ are reserved for system schemas.
+
user_name
+ The role name of the user who will own the new schema. If omitted,
+ defaults to the user executing the command. To create a schema
+ owned by another role, you must be able to
+ SET ROLE to that role.
+
schema_element
+ An SQL statement defining an object to be created within the
+ schema. Currently, only CREATE
+ TABLE, CREATE VIEW, CREATE
+ INDEX, CREATE SEQUENCE, CREATE
+ TRIGGER and GRANT are accepted as clauses
+ within CREATE SCHEMA. Other kinds of objects may
+ be created in separate commands after the schema is created.
+
IF NOT EXISTS
+ Do nothing (except issuing a notice) if a schema with the same name
+ already exists. schema_element
+ subcommands cannot be included when this option is used.
+
Notes
+ To create a schema, the invoking user must have the
+ CREATE privilege for the current database.
+ (Of course, superusers bypass this check.)
+
Examples
+ Create a schema:
+
+CREATE SCHEMA myschema;
+
+
+ Create a schema for user joe; the schema will also be
+ named joe:
+
+CREATE SCHEMA AUTHORIZATION joe;
+
+
+ Create a schema named test that will be owned by user
+ joe, unless there already is a schema named test.
+ (It does not matter whether joe owns the pre-existing schema.)
+
+CREATE SCHEMA IF NOT EXISTS test AUTHORIZATION joe;
+
+
+ Create a schema and create a table and view within it:
+
+CREATE SCHEMA hollywood
+ CREATE TABLE films (title text, release date, awards text[])
+ CREATE VIEW winners AS
+ SELECT title, release FROM films WHERE awards IS NOT NULL;
+
+ Notice that the individual subcommands do not end with semicolons.
+
+ The following is an equivalent way of accomplishing the same result:
+
+CREATE SCHEMA hollywood;
+CREATE TABLE hollywood.films (title text, release date, awards text[]);
+CREATE VIEW hollywood.winners AS
+ SELECT title, release FROM hollywood.films WHERE awards IS NOT NULL;
+
Compatibility
+ The SQL standard allows a DEFAULT CHARACTER SET clause
+ in CREATE SCHEMA, as well as more subcommand
+ types than are presently accepted by
+ PostgreSQL.
+
+ The SQL standard specifies that the subcommands in CREATE
+ SCHEMA can appear in any order. The present
+ PostgreSQL implementation does not
+ handle all cases of forward references in subcommands; it might
+ sometimes be necessary to reorder the subcommands in order to avoid
+ forward references.
+
+ According to the SQL standard, the owner of a schema always owns
+ all objects within it. PostgreSQL
+ allows schemas to contain objects owned by users other than the
+ schema owner. This can happen only if the schema owner grants the
+ CREATE privilege on their schema to someone else, or a
+ superuser chooses to create objects in it.
+
+ The IF NOT EXISTS option is a
+ PostgreSQL extension.
+
CREATE SEQUENCE
CREATE SEQUENCE — define a new sequence generator
Synopsis
+CREATE [ { TEMPORARY | TEMP } | UNLOGGED ] SEQUENCE [ IF NOT EXISTS ] name
+ [ AS data_type ]
+ [ INCREMENT [ BY ] increment ]
+ [ MINVALUE minvalue | NO MINVALUE ] [ MAXVALUE maxvalue | NO MAXVALUE ]
+ [ START [ WITH ] start ] [ CACHE cache ] [ [ NO ] CYCLE ]
+ [ OWNED BY { table_name.column_name | NONE } ]
+Description
+ CREATE SEQUENCE creates a new sequence number
+ generator. This involves creating and initializing a new special
+ single-row table with the name name. The generator will be
+ owned by the user issuing the command.
+
+ If a schema name is given then the sequence is created in the
+ specified schema. Otherwise it is created in the current schema.
+ Temporary sequences exist in a special schema, so a schema name cannot be
+ given when creating a temporary sequence.
+ The sequence name must be distinct from the name of any other relation
+ (table, sequence, index, view, materialized view, or foreign table) in
+ the same schema.
+
+ After a sequence is created, you use the functions
+ nextval,
+ currval, and
+ setval
+ to operate on the sequence. These functions are documented in
+ Section 9.17.
+
+ Although you cannot update a sequence directly, you can use a query like:
+
+
+SELECT * FROM name;
+
+
+ to examine the parameters and current state of a sequence. In particular,
+ the last_value field of the sequence shows the last value
+ allocated by any session. (Of course, this value might be obsolete
+ by the time it's printed, if other sessions are actively doing
+ nextval calls.)
+
Parameters
TEMPORARY or TEMP
+ If specified, the sequence object is created only for this
+ session, and is automatically dropped on session exit. Existing
+ permanent sequences with the same name are not visible (in this
+ session) while the temporary sequence exists, unless they are
+ referenced with schema-qualified names.
+
UNLOGGED
+ If specified, the sequence is created as an unlogged sequence. Changes
+ to unlogged sequences are not written to the write-ahead log. They are
+ not crash-safe: an unlogged sequence is automatically reset to its
+ initial state after a crash or unclean shutdown. Unlogged sequences are
+ also not replicated to standby servers.
+
+ Unlike unlogged tables, unlogged sequences do not offer a significant
+ performance advantage. This option is mainly intended for sequences
+ associated with unlogged tables via identity columns or serial columns.
+ In those cases, it usually wouldn't make sense to have the sequence
+ WAL-logged and replicated but not its associated table.
+
IF NOT EXISTS
+ Do not throw an error if a relation with the same name already exists.
+ A notice is issued in this case. Note that there is no guarantee that
+ the existing relation is anything like the sequence that would have
+ been created — it might not even be a sequence.
+
name
+ The name (optionally schema-qualified) of the sequence to be created.
+
data_type
+ The optional
+ clause AS data_type
+ specifies the data type of the sequence. Valid types are
+ smallint, integer,
+ and bigint. bigint is the
+ default. The data type determines the default minimum and maximum
+ values of the sequence.
+
increment
+ The optional clause INCREMENT BY increment specifies
+ which value is added to the current sequence value to create a
+ new value. A positive value will make an ascending sequence, a
+ negative one a descending sequence. The default value is 1.
+
minvalue
NO MINVALUE
+ The optional clause MINVALUE minvalue determines
+ the minimum value a sequence can generate. If this clause is not
+ supplied or NO MINVALUE is specified, then
+ defaults will be used. The default for an ascending sequence is 1. The
+ default for a descending sequence is the minimum value of the data type.
+
maxvalue
NO MAXVALUE
+ The optional clause MAXVALUE maxvalue determines
+ the maximum value for the sequence. If this clause is not
+ supplied or NO MAXVALUE is specified, then
+ default values will be used. The default for an ascending sequence is
+ the maximum value of the data type. The default for a descending
+ sequence is -1.
+
start
+ The optional clause START WITH start allows the
+ sequence to begin anywhere. The default starting value is
+ minvalue for
+ ascending sequences and maxvalue for descending ones.
+
cache
+ The optional clause CACHE cache specifies how
+ many sequence numbers are to be preallocated and stored in
+ memory for faster access. The minimum value is 1 (only one value
+ can be generated at a time, i.e., no cache), and this is also the
+ default.
+
CYCLE
NO CYCLE
+ The CYCLE option allows the sequence to wrap
+ around when the maxvalue or minvalue has been reached by an
+ ascending or descending sequence respectively. If the limit is
+ reached, the next number generated will be the minvalue or maxvalue, respectively.
+
+ If NO CYCLE is specified, any calls to
+ nextval after the sequence has reached its
+ maximum value will return an error. If neither
+ CYCLE or NO CYCLE are
+ specified, NO CYCLE is the default.
+
OWNED BY table_name.column_name
OWNED BY NONE
+ The OWNED BY option causes the sequence to be
+ associated with a specific table column, such that if that column
+ (or its whole table) is dropped, the sequence will be automatically
+ dropped as well. The specified table must have the same owner and be in
+ the same schema as the sequence.
+ OWNED BY NONE, the default, specifies that there
+ is no such association.
+
Notes
+ Use DROP SEQUENCE to remove a sequence.
+
+ Sequences are based on bigint arithmetic, so the range
+ cannot exceed the range of an eight-byte integer
+ (-9223372036854775808 to 9223372036854775807).
+
+ Because nextval and setval calls are never
+ rolled back, sequence objects cannot be used if “gapless”
+ assignment of sequence numbers is needed. It is possible to build
+ gapless assignment by using exclusive locking of a table containing a
+ counter; but this solution is much more expensive than sequence
+ objects, especially if many transactions need sequence numbers
+ concurrently.
+
+ Unexpected results might be obtained if a cache setting greater than one is
+ used for a sequence object that will be used concurrently by
+ multiple sessions. Each session will allocate and cache successive
+ sequence values during one access to the sequence object and
+ increase the sequence object's last_value accordingly.
+ Then, the next cache-1
+ uses of nextval within that session simply return the
+ preallocated values without touching the sequence object. So, any
+ numbers allocated but not used within a session will be lost when
+ that session ends, resulting in “holes” in the
+ sequence.
+
+ Furthermore, although multiple sessions are guaranteed to allocate
+ distinct sequence values, the values might be generated out of
+ sequence when all the sessions are considered. For example, with
+ a cache setting of 10,
+ session A might reserve values 1..10 and return
+ nextval=1, then session B might reserve values
+ 11..20 and return nextval=11 before session A
+ has generated nextval=2. Thus, with a
+ cache setting of one
+ it is safe to assume that nextval values are generated
+ sequentially; with a cache setting greater than one you
+ should only assume that the nextval values are all
+ distinct, not that they are generated purely sequentially. Also,
+ last_value will reflect the latest value reserved by
+ any session, whether or not it has yet been returned by
+ nextval.
+
+ Another consideration is that a setval executed on
+ such a sequence will not be noticed by other sessions until they
+ have used up any preallocated values they have cached.
+
Examples
+ Create an ascending sequence called serial, starting at 101:
+
+CREATE SEQUENCE serial START 101;
+
+
+ Select the next number from this sequence:
+
+SELECT nextval('serial');
+
+ nextval
+---------
+ 101
+
+
+ Select the next number from this sequence:
+
+SELECT nextval('serial');
+
+ nextval
+---------
+ 102
+
+
+ Use this sequence in an INSERT command:
+
+INSERT INTO distributors VALUES (nextval('serial'), 'nothing');
+
+
+ Update the sequence value after a COPY FROM:
+
+BEGIN;
+COPY distributors FROM 'input_file';
+SELECT setval('serial', max(id)) FROM distributors;
+END;
+Compatibility
+ CREATE SEQUENCE conforms to the SQL
+ standard, with the following exceptions:
+
CREATE SERVER
CREATE SERVER — define a new foreign server
Synopsis
+CREATE SERVER [ IF NOT EXISTS ] server_name [ TYPE 'server_type' ] [ VERSION 'server_version' ]
+ FOREIGN DATA WRAPPER fdw_name
+ [ OPTIONS ( option 'value' [, ... ] ) ]
+
Description
+ CREATE SERVER defines a new foreign server. The
+ user who defines the server becomes its owner.
+
+ A foreign server typically encapsulates connection information that
+ a foreign-data wrapper uses to access an external data resource.
+ Additional user-specific connection information may be specified by
+ means of user mappings.
+
+ The server name must be unique within the database.
+
+ Creating a server requires USAGE privilege on the
+ foreign-data wrapper being used.
+
Parameters
IF NOT EXISTS
+ Do not throw an error if a server with the same name already exists.
+ A notice is issued in this case. Note that there is no guarantee that
+ the existing server is anything like the one that would have been
+ created.
+
server_name
+ The name of the foreign server to be created.
+
server_type
+ Optional server type, potentially useful to foreign-data wrappers.
+
server_version
+ Optional server version, potentially useful to foreign-data wrappers.
+
fdw_name
+ The name of the foreign-data wrapper that manages the server.
+
OPTIONS ( option 'value' [, ... ] )
+ This clause specifies the options for the server. The options
+ typically define the connection details of the server, but the
+ actual names and values are dependent on the server's
+ foreign-data wrapper.
+
Notes
+ When using the dblink module,
+ a foreign server's name can be used
+ as an argument of the dblink_connect
+ function to indicate the connection parameters. It is necessary to have
+ the USAGE privilege on the foreign server to be
+ able to use it in this way.
+
+ If the foreign server supports sort pushdown, it is necessary for it
+ to have the same sort ordering as the local server.
+
Examples
+ Create a server myserver that uses the
+ foreign-data wrapper postgres_fdw:
+
+CREATE SERVER myserver FOREIGN DATA WRAPPER postgres_fdw OPTIONS (host 'foo', dbname 'foodb', port '5432');
+
+ See postgres_fdw for more details.
+
Compatibility
+ CREATE SERVER conforms to ISO/IEC 9075-9 (SQL/MED).
+
CREATE STATISTICS
CREATE STATISTICS — define extended statistics
Synopsis
+CREATE STATISTICS [ [ IF NOT EXISTS ] statistics_name ]
+ ON ( expression )
+ FROM table_name
+
+CREATE STATISTICS [ [ IF NOT EXISTS ] statistics_name ]
+ [ ( statistics_kind [, ... ] ) ]
+ ON { column_name | ( expression ) }, { column_name | ( expression ) } [, ...]
+ FROM table_name
+
Description
+ CREATE STATISTICS will create a new extended statistics
+ object tracking data about the specified table, foreign table or
+ materialized view. The statistics object will be created in the current
+ database and will be owned by the user issuing the command.
+
+ The CREATE STATISTICS command has two basic forms. The
+ first form allows univariate statistics for a single expression to be
+ collected, providing benefits similar to an expression index without the
+ overhead of index maintenance. This form does not allow the statistics
+ kind to be specified, since the various statistics kinds refer only to
+ multivariate statistics. The second form of the command allows
+ multivariate statistics on multiple columns and/or expressions to be
+ collected, optionally specifying which statistics kinds to include. This
+ form will also automatically cause univariate statistics to be collected on
+ any expressions included in the list.
+
+ If a schema name is given (for example, CREATE STATISTICS
+ myschema.mystat ...) then the statistics object is created in the
+ specified schema. Otherwise it is created in the current schema.
+ If given, the name of the statistics object must be distinct from the name
+ of any other statistics object in the same schema.
+
Parameters
IF NOT EXISTS
+ Do not throw an error if a statistics object with the same name already
+ exists. A notice is issued in this case. Note that only the name of
+ the statistics object is considered here, not the details of its
+ definition.
+ Statistics name is required when IF NOT EXISTS is specified.
+
statistics_name
+ The name (optionally schema-qualified) of the statistics object to be
+ created.
+ If the name is omitted, PostgreSQL chooses a
+ suitable name based on the parent table's name and the defined column
+ name(s) and/or expression(s).
+
statistics_kind
+ A multivariate statistics kind to be computed in this statistics object.
+ Currently supported kinds are
+ ndistinct, which enables n-distinct statistics,
+ dependencies, which enables functional
+ dependency statistics, and mcv which enables
+ most-common values lists.
+ If this clause is omitted, all supported statistics kinds are
+ included in the statistics object. Univariate expression statistics are
+ built automatically if the statistics definition includes any complex
+ expressions rather than just simple column references.
+ For more information, see Section 14.2.2
+ and Section 76.2.
+
column_name
+ The name of a table column to be covered by the computed statistics.
+ This is only allowed when building multivariate statistics. At least
+ two column names or expressions must be specified, and their order is
+ not significant.
+
expression
+ An expression to be covered by the computed statistics. This may be
+ used to build univariate statistics on a single expression, or as part
+ of a list of multiple column names and/or expressions to build
+ multivariate statistics. In the latter case, separate univariate
+ statistics are built automatically for each expression in the list.
+
table_name
+ The name (optionally schema-qualified) of the table containing the
+ column(s) the statistics are computed on; see ANALYZE for an explanation of the handling of
+ inheritance and partitions.
+
Notes
+ You must be the owner of a table to create a statistics object
+ reading it. Once created, however, the ownership of the statistics
+ object is independent of the underlying table(s).
+
+ Expression statistics are per-expression and are similar to creating an
+ index on the expression, except that they avoid the overhead of index
+ maintenance. Expression statistics are built automatically for each
+ expression in the statistics object definition.
+
+ Extended statistics are not currently used by the planner for selectivity
+ estimations made for table joins. This limitation will likely be removed
+ in a future version of PostgreSQL.
+
Examples
+ Create table t1 with two functionally dependent columns, i.e.,
+ knowledge of a value in the first column is sufficient for determining the
+ value in the other column. Then functional dependency statistics are built
+ on those columns:
+
+
+CREATE TABLE t1 (
+ a int,
+ b int
+);
+
+INSERT INTO t1 SELECT i/100, i/500
+ FROM generate_series(1,1000000) s(i);
+
+ANALYZE t1;
+
+-- the number of matching rows will be drastically underestimated:
+EXPLAIN ANALYZE SELECT * FROM t1 WHERE (a = 1) AND (b = 0);
+
+CREATE STATISTICS s1 (dependencies) ON a, b FROM t1;
+
+ANALYZE t1;
+
+-- now the row count estimate is more accurate:
+EXPLAIN ANALYZE SELECT * FROM t1 WHERE (a = 1) AND (b = 0);
+
+
+ Without functional-dependency statistics, the planner would assume
+ that the two WHERE conditions are independent, and would
+ multiply their selectivities together to arrive at a much-too-small
+ row count estimate.
+ With such statistics, the planner recognizes that the WHERE
+ conditions are redundant and does not underestimate the row count.
+
+ Create table t2 with two perfectly correlated columns
+ (containing identical data), and an MCV list on those columns:
+
+
+CREATE TABLE t2 (
+ a int,
+ b int
+);
+
+INSERT INTO t2 SELECT mod(i,100), mod(i,100)
+ FROM generate_series(1,1000000) s(i);
+
+CREATE STATISTICS s2 (mcv) ON a, b FROM t2;
+
+ANALYZE t2;
+
+-- valid combination (found in MCV)
+EXPLAIN ANALYZE SELECT * FROM t2 WHERE (a = 1) AND (b = 1);
+
+-- invalid combination (not found in MCV)
+EXPLAIN ANALYZE SELECT * FROM t2 WHERE (a = 1) AND (b = 2);
+
+
+ The MCV list gives the planner more detailed information about the
+ specific values that commonly appear in the table, as well as an upper
+ bound on the selectivities of combinations of values that do not appear
+ in the table, allowing it to generate better estimates in both cases.
+
+ Create table t3 with a single timestamp column,
+ and run queries using expressions on that column. Without extended
+ statistics, the planner has no information about the data distribution for
+ the expressions, and uses default estimates. The planner also does not
+ realize that the value of the date truncated to the month is fully
+ determined by the value of the date truncated to the day. Then expression
+ and ndistinct statistics are built on those two expressions:
+
+
+CREATE TABLE t3 (
+ a timestamp
+);
+
+INSERT INTO t3 SELECT i FROM generate_series('2020-01-01'::timestamp,
+ '2020-12-31'::timestamp,
+ '1 minute'::interval) s(i);
+
+ANALYZE t3;
+
+-- the number of matching rows will be drastically underestimated:
+EXPLAIN ANALYZE SELECT * FROM t3
+ WHERE date_trunc('month', a) = '2020-01-01'::timestamp;
+
+EXPLAIN ANALYZE SELECT * FROM t3
+ WHERE date_trunc('day', a) BETWEEN '2020-01-01'::timestamp
+ AND '2020-06-30'::timestamp;
+
+EXPLAIN ANALYZE SELECT date_trunc('month', a), date_trunc('day', a)
+ FROM t3 GROUP BY 1, 2;
+
+-- build ndistinct statistics on the pair of expressions (per-expression
+-- statistics are built automatically)
+CREATE STATISTICS s3 (ndistinct) ON date_trunc('month', a), date_trunc('day', a) FROM t3;
+
+ANALYZE t3;
+
+-- now the row count estimates are more accurate:
+EXPLAIN ANALYZE SELECT * FROM t3
+ WHERE date_trunc('month', a) = '2020-01-01'::timestamp;
+
+EXPLAIN ANALYZE SELECT * FROM t3
+ WHERE date_trunc('day', a) BETWEEN '2020-01-01'::timestamp
+ AND '2020-06-30'::timestamp;
+
+EXPLAIN ANALYZE SELECT date_trunc('month', a), date_trunc('day', a)
+ FROM t3 GROUP BY 1, 2;
+
+
+ Without expression and ndistinct statistics, the planner has no information
+ about the number of distinct values for the expressions, and has to rely
+ on default estimates. The equality and range conditions are assumed to have
+ 0.5% selectivity, and the number of distinct values in the expression is
+ assumed to be the same as for the column (i.e. unique). This results in a
+ significant underestimate of the row count in the first two queries. Moreover,
+ the planner has no information about the relationship between the expressions,
+ so it assumes the two WHERE and GROUP BY
+ conditions are independent, and multiplies their selectivities together to
+ arrive at a severe overestimate of the group count in the aggregate query.
+ This is further exacerbated by the lack of accurate statistics for the
+ expressions, forcing the planner to use a default ndistinct estimate for the
+ expression derived from ndistinct for the column. With such statistics, the
+ planner recognizes that the conditions are correlated, and arrives at much
+ more accurate estimates.
+
Compatibility
+ There is no CREATE STATISTICS command in the SQL standard.
+
CREATE SUBSCRIPTION
CREATE SUBSCRIPTION — define a new subscription
Synopsis
+CREATE SUBSCRIPTION subscription_name
+ CONNECTION 'conninfo'
+ PUBLICATION publication_name [, ...]
+ [ WITH ( subscription_parameter [= value] [, ... ] ) ]
+
Description
+ CREATE SUBSCRIPTION adds a new logical-replication
+ subscription. The user that creates a subscription becomes the owner
+ of the subscription. The subscription name must be distinct from the name of
+ any existing subscription in the current database.
+
+ A subscription represents a replication connection to the publisher.
+ Hence, in addition to adding definitions in the local catalogs, this
+ command normally creates a replication slot on the publisher.
+
+ A logical replication worker will be started to replicate data for the new
+ subscription at the commit of the transaction where this command is run,
+ unless the subscription is initially disabled.
+
+ To be able to create a subscription, you must have the privileges of the
+ the pg_create_subscription role, as well as
+ CREATE privileges on the current database.
+
+ Additional information about subscriptions and logical replication as a
+ whole is available at Section 31.2 and
+ Chapter 31.
+
Parameters
subscription_name #
+ The name of the new subscription.
+
CONNECTION 'conninfo' #
+ The libpq connection string defining how
+ to connect to the publisher database. For details see
+ Section 34.1.1.
+
PUBLICATION publication_name [, ...] #
+ Names of the publications on the publisher to subscribe to.
+
WITH ( subscription_parameter [= value] [, ... ] ) #
+ This clause specifies optional parameters for a subscription.
+
+ The following parameters control what happens during subscription creation:
+
+
connect (boolean) #
+ Specifies whether the CREATE SUBSCRIPTION
+ command should connect to the publisher at all. The default
+ is true. Setting this to
+ false will force the values of
+ create_slot, enabled and
+ copy_data to false.
+ (You cannot combine setting connect
+ to false with
+ setting create_slot, enabled,
+ or copy_data to true.)
+
+ Since no connection is made when this option is
+ false, no tables are subscribed. To initiate
+ replication, you must manually create the replication slot, enable
+ the subscription, and refresh the subscription. See
+ Section 31.2.3
+ for examples.
+
create_slot (boolean) #
+ Specifies whether the command should create the replication slot on
+ the publisher. The default is true.
+
+ If set to false, you are responsible for
+ creating the publisher's slot in some other way. See
+ Section 31.2.3
+ for examples.
+
enabled (boolean) #
+ Specifies whether the subscription should be actively replicating
+ or whether it should just be set up but not started yet. The default
+ is true.
+
slot_name (string) #
+ Name of the publisher's replication slot to use. The default is
+ to use the name of the subscription for the slot name.
+
+ Setting slot_name to NONE
+ means there will be no replication slot associated with the
+ subscription. Such subscriptions must also have both
+ enabled and create_slot set to
+ false. Use this when you will be creating the
+ replication slot later manually. See
+ Section 31.2.3
+ for examples.
+
+
+ The following parameters control the subscription's replication
+ behavior after it has been created:
+
+
binary (boolean) #
+ Specifies whether the subscription will request the publisher to send
+ the data in binary format (as opposed to text). The default is
+ false. Any initial table synchronization copy
+ (see copy_data) also uses the same format. Binary
+ format can be faster than the text format, but it is less portable
+ across machine architectures and PostgreSQL
+ versions. Binary format is very data type specific; for example, it
+ will not allow copying from a smallint column to an
+ integer column, even though that would work fine in text
+ format. Even when this option is enabled, only data types having binary
+ send and receive functions will be transferred in binary. Note that
+ the initial synchronization requires all data types to have binary
+ send and receive functions, otherwise the synchronization will fail
+ (see CREATE TYPE for more about send/receive
+ functions).
+
+ When doing cross-version replication, it could be that the
+ publisher has a binary send function for some data type, but the
+ subscriber lacks a binary receive function for that type. In
+ such a case, data transfer will fail, and
+ the binary option cannot be used.
+
+ If the publisher is a PostgreSQL version
+ before 16, then any initial table synchronization will use text format
+ even if binary = true.
+
copy_data (boolean) #
+ Specifies whether to copy pre-existing data in the publications
+ that are being subscribed to when the replication starts.
+ The default is true.
+
+ If the publications contain WHERE clauses, it
+ will affect what data is copied. Refer to the
+ Notes for details.
+
+ See Notes for details of how
+ copy_data = true can interact with the
+ origin parameter.
+
streaming (enum) #
+ Specifies whether to enable streaming of in-progress transactions
+ for this subscription. The default value is off,
+ meaning all transactions are fully decoded on the publisher and only
+ then sent to the subscriber as a whole.
+
+ If set to on, the incoming changes are written to
+ temporary files and then applied only after the transaction is
+ committed on the publisher and received by the subscriber.
+
+ If set to parallel, incoming changes are directly
+ applied via one of the parallel apply workers, if available. If no
+ parallel apply worker is free to handle streaming transactions then
+ the changes are written to temporary files and applied after the
+ transaction is committed. Note that if an error happens in a
+ parallel apply worker, the finish LSN of the remote transaction
+ might not be reported in the server log.
+
synchronous_commit (enum) #
+ The value of this parameter overrides the
+ synchronous_commit setting within this
+ subscription's apply worker processes. The default value
+ is off.
+
+ It is safe to use off for logical replication:
+ If the subscriber loses transactions because of missing
+ synchronization, the data will be sent again from the publisher.
+
+ A different setting might be appropriate when doing synchronous
+ logical replication. The logical replication workers report the
+ positions of writes and flushes to the publisher, and when using
+ synchronous replication, the publisher will wait for the actual
+ flush. This means that setting
+ synchronous_commit for the subscriber to
+ off when the subscription is used for
+ synchronous replication might increase the latency for
+ COMMIT on the publisher. In this scenario, it
+ can be advantageous to set synchronous_commit
+ to local or higher.
+
two_phase (boolean) #
+ Specifies whether two-phase commit is enabled for this subscription.
+ The default is false.
+
+ When two-phase commit is enabled, prepared transactions are sent
+ to the subscriber at the time of PREPARE
+ TRANSACTION, and are processed as two-phase
+ transactions on the subscriber too. Otherwise, prepared
+ transactions are sent to the subscriber only when committed, and
+ are then processed immediately by the subscriber.
+
+ The implementation of two-phase commit requires that replication
+ has successfully finished the initial table synchronization
+ phase. So even when two_phase is enabled for a
+ subscription, the internal two-phase state remains
+ temporarily “pending” until the initialization phase
+ completes. See column subtwophasestate
+ of pg_subscription
+ to know the actual two-phase state.
+
disable_on_error (boolean) #
+ Specifies whether the subscription should be automatically disabled
+ if any errors are detected by subscription workers during data
+ replication from the publisher. The default is
+ false.
+
password_required (boolean) #
+ If set to true, connections to the publisher made
+ as a result of this subscription must use password authentication
+ and the password must be specified as a part of the connection
+ string. This setting is ignored when the subscription is owned by a
+ superuser. The default is true. Only superusers
+ can set this value to false.
+
run_as_owner (boolean) #
+ If true, all replication actions are performed as the subscription
+ owner. If false, replication workers will perform actions on each
+ table as the owner of that table. The latter configuration is
+ generally much more secure; for details, see
+ Section 31.9.
+ The default is false.
+
origin (string) #
+ Specifies whether the subscription will request the publisher to only
+ send changes that don't have an origin or send changes regardless of
+ origin. Setting origin to none
+ means that the subscription will request the publisher to only send
+ changes that don't have an origin. Setting origin
+ to any means that the publisher sends changes
+ regardless of their origin. The default is any.
+
+ See Notes for details of how
+ copy_data = true can interact with the
+ origin parameter.
+
+ When specifying a parameter of type boolean, the
+ = value
+ part can be omitted, which is equivalent to
+ specifying TRUE.
+
Notes
+ See Section 31.9 for details on
+ how to configure access control between the subscription and the
+ publication instance.
+
+ When creating a replication slot (the default behavior), CREATE
+ SUBSCRIPTION cannot be executed inside a transaction block.
+
+ Creating a subscription that connects to the same database cluster (for
+ example, to replicate between databases in the same cluster or to replicate
+ within the same database) will only succeed if the replication slot is not
+ created as part of the same command. Otherwise, the CREATE
+ SUBSCRIPTION call will hang. To make this work, create the
+ replication slot separately (using the
+ function pg_create_logical_replication_slot with the
+ plugin name pgoutput) and create the subscription using
+ the parameter create_slot = false. See
+ Section 31.2.3
+ for examples. This is an implementation restriction that might be lifted in a
+ future release.
+
+ If any table in the publication has a WHERE clause, rows
+ for which the expression
+ evaluates to false or null will not be published. If the subscription has
+ several publications in which the same table has been published with
+ different WHERE clauses, a row will be published if any
+ of the expressions (referring to that publish operation) are satisfied. In
+ the case of different WHERE clauses, if one of the
+ publications has no WHERE clause (referring to that
+ publish operation) or the publication is declared as
+ FOR ALL TABLES
+ or FOR TABLES IN SCHEMA,
+ rows are always published regardless of the definition of the other
+ expressions. If the subscriber is a PostgreSQL
+ version before 15, then any row filtering is ignored during the initial data
+ synchronization phase. For this case, the user might want to consider
+ deleting any initially copied data that would be incompatible with
+ subsequent filtering. Because initial data synchronization does not take
+ into account the publication
+ publish
+ parameter when copying existing table data, some rows may be copied that
+ would not be replicated using DML. See
+ Section 31.2.2 for examples.
+
+ Subscriptions having several publications in which the same table has been
+ published with different column lists are not supported.
+
+ We allow non-existent publications to be specified so that users can add
+ those later. This means
+ pg_subscription
+ can have non-existent publications.
+
+ When using a subscription parameter combination of
+ copy_data = true and origin = NONE,
+ the initial sync table data is copied directly from the publisher, meaning
+ that knowledge of the true origin of that data is not possible. If the
+ publisher also has subscriptions then the copied table data might have
+ originated from further upstream. This scenario is detected and a WARNING is
+ logged to the user, but the warning is only an indication of a potential
+ problem; it is the user's responsibility to make the necessary checks to
+ ensure the copied data origins are really as wanted or not.
+
+ To find which tables might potentially include non-local origins (due to
+ other subscriptions created on the publisher) try this SQL query:
+
+# substitute <pub-names> below with your publication name(s) to be queried
+SELECT DISTINCT PT.schemaname, PT.tablename
+FROM pg_publication_tables PT,
+ pg_subscription_rel PS
+ JOIN pg_class C ON (C.oid = PS.srrelid)
+ JOIN pg_namespace N ON (N.oid = C.relnamespace)
+WHERE N.nspname = PT.schemaname AND
+ C.relname = PT.tablename AND
+ PT.pubname IN (<pub-names>);
+
Examples
+ Create a subscription to a remote server that replicates tables in
+ the publications mypublication and
+ insert_only and starts replicating immediately on
+ commit:
+
+CREATE SUBSCRIPTION mysub
+ CONNECTION 'host=192.168.1.50 port=5432 user=foo dbname=foodb'
+ PUBLICATION mypublication, insert_only;
+
+
+ Create a subscription to a remote server that replicates tables in
+ the insert_only publication and does not start replicating
+ until enabled at a later time.
+
+CREATE SUBSCRIPTION mysub
+ CONNECTION 'host=192.168.1.50 port=5432 user=foo dbname=foodb'
+ PUBLICATION insert_only
+ WITH (enabled = false);
+
Compatibility
+ CREATE SUBSCRIPTION is a PostgreSQL
+ extension.
+
CREATE TABLE
CREATE TABLE — define a new table
Synopsis
+CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } | UNLOGGED ] TABLE [ IF NOT EXISTS ] table_name ( [
+ { column_name data_type [ STORAGE { PLAIN | EXTERNAL | EXTENDED | MAIN | DEFAULT } ] [ COMPRESSION compression_method ] [ COLLATE collation ] [ column_constraint [ ... ] ]
+ | table_constraint
+ | LIKE source_table [ like_option ... ] }
+ [, ... ]
+] )
+[ INHERITS ( parent_table [, ... ] ) ]
+[ PARTITION BY { RANGE | LIST | HASH } ( { column_name | ( expression ) } [ COLLATE collation ] [ opclass ] [, ... ] ) ]
+[ USING method ]
+[ WITH ( storage_parameter [= value] [, ... ] ) | WITHOUT OIDS ]
+[ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
+[ TABLESPACE tablespace_name ]
+
+CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } | UNLOGGED ] TABLE [ IF NOT EXISTS ] table_name
+ OF type_name [ (
+ { column_name [ WITH OPTIONS ] [ column_constraint [ ... ] ]
+ | table_constraint }
+ [, ... ]
+) ]
+[ PARTITION BY { RANGE | LIST | HASH } ( { column_name | ( expression ) } [ COLLATE collation ] [ opclass ] [, ... ] ) ]
+[ USING method ]
+[ WITH ( storage_parameter [= value] [, ... ] ) | WITHOUT OIDS ]
+[ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
+[ TABLESPACE tablespace_name ]
+
+CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } | UNLOGGED ] TABLE [ IF NOT EXISTS ] table_name
+ PARTITION OF parent_table [ (
+ { column_name [ WITH OPTIONS ] [ column_constraint [ ... ] ]
+ | table_constraint }
+ [, ... ]
+) ] { FOR VALUES partition_bound_spec | DEFAULT }
+[ PARTITION BY { RANGE | LIST | HASH } ( { column_name | ( expression ) } [ COLLATE collation ] [ opclass ] [, ... ] ) ]
+[ USING method ]
+[ WITH ( storage_parameter [= value] [, ... ] ) | WITHOUT OIDS ]
+[ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
+[ TABLESPACE tablespace_name ]
+
+where column_constraint is:
+
+[ CONSTRAINT constraint_name ]
+{ NOT NULL |
+ NULL |
+ CHECK ( expression ) [ NO INHERIT ] |
+ DEFAULT default_expr |
+ GENERATED ALWAYS AS ( generation_expr ) STORED |
+ GENERATED { ALWAYS | BY DEFAULT } AS IDENTITY [ ( sequence_options ) ] |
+ UNIQUE [ NULLS [ NOT ] DISTINCT ] index_parameters |
+ PRIMARY KEY index_parameters |
+ REFERENCES reftable [ ( refcolumn ) ] [ MATCH FULL | MATCH PARTIAL | MATCH SIMPLE ]
+ [ ON DELETE referential_action ] [ ON UPDATE referential_action ] }
+[ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]
+
+and table_constraint is:
+
+[ CONSTRAINT constraint_name ]
+{ CHECK ( expression ) [ NO INHERIT ] |
+ UNIQUE [ NULLS [ NOT ] DISTINCT ] ( column_name [, ... ] ) index_parameters |
+ PRIMARY KEY ( column_name [, ... ] ) index_parameters |
+ EXCLUDE [ USING index_method ] ( exclude_element WITH operator [, ... ] ) index_parameters [ WHERE ( predicate ) ] |
+ FOREIGN KEY ( column_name [, ... ] ) REFERENCES reftable [ ( refcolumn [, ... ] ) ]
+ [ MATCH FULL | MATCH PARTIAL | MATCH SIMPLE ] [ ON DELETE referential_action ] [ ON UPDATE referential_action ] }
+[ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]
+
+and like_option is:
+
+{ INCLUDING | EXCLUDING } { COMMENTS | COMPRESSION | CONSTRAINTS | DEFAULTS | GENERATED | IDENTITY | INDEXES | STATISTICS | STORAGE | ALL }
+
+and partition_bound_spec is:
+
+IN ( partition_bound_expr [, ...] ) |
+FROM ( { partition_bound_expr | MINVALUE | MAXVALUE } [, ...] )
+ TO ( { partition_bound_expr | MINVALUE | MAXVALUE } [, ...] ) |
+WITH ( MODULUS numeric_literal, REMAINDER numeric_literal )
+
+index_parameters in UNIQUE, PRIMARY KEY, and EXCLUDE constraints are:
+
+[ INCLUDE ( column_name [, ... ] ) ]
+[ WITH ( storage_parameter [= value] [, ... ] ) ]
+[ USING INDEX TABLESPACE tablespace_name ]
+
+exclude_element in an EXCLUDE constraint is:
+
+{ column_name | ( expression ) } [ COLLATE collation ] [ opclass [ ( opclass_parameter = value [, ... ] ) ] ] [ ASC | DESC ] [ NULLS { FIRST | LAST } ]
+
+referential_action in a FOREIGN KEY/REFERENCES constraint is:
+
+{ NO ACTION | RESTRICT | CASCADE | SET NULL [ ( column_name [, ... ] ) ] | SET DEFAULT [ ( column_name [, ... ] ) ] }
+Description
+ CREATE TABLE will create a new, initially empty table
+ in the current database. The table will be owned by the user issuing the
+ command.
+
+ If a schema name is given (for example, CREATE TABLE
+ myschema.mytable ...) then the table is created in the specified
+ schema. Otherwise it is created in the current schema. Temporary
+ tables exist in a special schema, so a schema name cannot be given
+ when creating a temporary table. The name of the table must be
+ distinct from the name of any other relation (table, sequence, index, view,
+ materialized view, or foreign table) in the same schema.
+
+ CREATE TABLE also automatically creates a data
+ type that represents the composite type corresponding
+ to one row of the table. Therefore, tables cannot have the same
+ name as any existing data type in the same schema.
+
+ The optional constraint clauses specify constraints (tests) that
+ new or updated rows must satisfy for an insert or update operation
+ to succeed. A constraint is an SQL object that helps define the
+ set of valid values in the table in various ways.
+
+ There are two ways to define constraints: table constraints and
+ column constraints. A column constraint is defined as part of a
+ column definition. A table constraint definition is not tied to a
+ particular column, and it can encompass more than one column.
+ Every column constraint can also be written as a table constraint;
+ a column constraint is only a notational convenience for use when the
+ constraint only affects one column.
+
+ To be able to create a table, you must have USAGE
+ privilege on all column types or the type in the OF
+ clause, respectively.
+
Parameters
TEMPORARY or TEMP #
+ If specified, the table is created as a temporary table.
+ Temporary tables are automatically dropped at the end of a
+ session, or optionally at the end of the current transaction
+ (see ON COMMIT below). The default
+ search_path includes the temporary schema first and so identically
+ named existing permanent tables are not chosen for new plans
+ while the temporary table exists, unless they are referenced
+ with schema-qualified names. Any indexes created on a temporary
+ table are automatically temporary as well.
+
+ The autovacuum daemon cannot
+ access and therefore cannot vacuum or analyze temporary tables.
+ For this reason, appropriate vacuum and analyze operations should be
+ performed via session SQL commands. For example, if a temporary
+ table is going to be used in complex queries, it is wise to run
+ ANALYZE on the temporary table after it is populated.
+
+ Optionally, GLOBAL or LOCAL
+ can be written before TEMPORARY or TEMP.
+ This presently makes no difference in PostgreSQL
+ and is deprecated; see
+ Compatibility below.
+
UNLOGGED #
+ If specified, the table is created as an unlogged table. Data written
+ to unlogged tables is not written to the write-ahead log (see Chapter 30), which makes them considerably faster than ordinary
+ tables. However, they are not crash-safe: an unlogged table is
+ automatically truncated after a crash or unclean shutdown. The contents
+ of an unlogged table are also not replicated to standby servers.
+ Any indexes created on an unlogged table are automatically unlogged as
+ well.
+
+ If this is specified, any sequences created together with the unlogged
+ table (for identity or serial columns) are also created as unlogged.
+
IF NOT EXISTS #
+ Do not throw an error if a relation with the same name already exists.
+ A notice is issued in this case. Note that there is no guarantee that
+ the existing relation is anything like the one that would have been
+ created.
+
table_name #
+ The name (optionally schema-qualified) of the table to be created.
+
OF type_name #
+ Creates a typed table, which takes its
+ structure from the specified composite type (name optionally
+ schema-qualified). A typed table is tied to its type; for
+ example the table will be dropped if the type is dropped
+ (with DROP TYPE ... CASCADE).
+
+ When a typed table is created, then the data types of the
+ columns are determined by the underlying composite type and are
+ not specified by the CREATE TABLE command.
+ But the CREATE TABLE command can add defaults
+ and constraints to the table and can specify storage parameters.
+
column_name #
+ The name of a column to be created in the new table.
+
data_type #
+ The data type of the column. This can include array
+ specifiers. For more information on the data types supported by
+ PostgreSQL, refer to Chapter 8.
+
COLLATE collation #
+ The COLLATE clause assigns a collation to
+ the column (which must be of a collatable data type).
+ If not specified, the column data type's default collation is used.
+
-
+
STORAGE { PLAIN | EXTERNAL | EXTENDED | MAIN | DEFAULT }
+
+ #
+ This form sets the storage mode for the column. This controls whether this
+ column is held inline or in a secondary TOAST table,
+ and whether the data should be compressed or not. PLAIN
+ must be used for fixed-length values such as integer and is
+ inline, uncompressed. MAIN is for inline, compressible
+ data. EXTERNAL is for external, uncompressed data, and
+ EXTENDED is for external, compressed data.
+ Writing DEFAULT sets the storage mode to the default
+ mode for the column's data type. EXTENDED is the
+ default for most data types that support non-PLAIN
+ storage.
+ Use of EXTERNAL will make substring operations on
+ very large text and bytea values run faster,
+ at the penalty of increased storage space.
+ See Section 73.2 for more information.
+
COMPRESSION compression_method #
+ The COMPRESSION clause sets the compression method
+ for the column. Compression is supported only for variable-width data
+ types, and is used only when the column's storage mode
+ is main or extended.
+ (See ALTER TABLE for information on
+ column storage modes.) Setting this property for a partitioned table
+ has no direct effect, because such tables have no storage of their own,
+ but the configured value will be inherited by newly-created partitions.
+ The supported compression methods are pglz and
+ lz4. (lz4 is available only if
+ --with-lz4 was used when building
+ PostgreSQL.) In addition,
+ compression_method
+ can be default to explicitly specify the default
+ behavior, which is to consult the
+ default_toast_compression setting at the time of
+ data insertion to determine the method to use.
+
INHERITS ( parent_table [, ... ] ) #
+ The optional INHERITS clause specifies a list of
+ tables from which the new table automatically inherits all
+ columns. Parent tables can be plain tables or foreign tables.
+
+ Use of INHERITS creates a persistent relationship
+ between the new child table and its parent table(s). Schema
+ modifications to the parent(s) normally propagate to children
+ as well, and by default the data of the child table is included in
+ scans of the parent(s).
+
+ If the same column name exists in more than one parent
+ table, an error is reported unless the data types of the columns
+ match in each of the parent tables. If there is no conflict,
+ then the duplicate columns are merged to form a single column in
+ the new table. If the column name list of the new table
+ contains a column name that is also inherited, the data type must
+ likewise match the inherited column(s), and the column
+ definitions are merged into one. If the
+ new table explicitly specifies a default value for the column,
+ this default overrides any defaults from inherited declarations
+ of the column. Otherwise, any parents that specify default
+ values for the column must all specify the same default, or an
+ error will be reported.
+
+ CHECK constraints are merged in essentially the same way as
+ columns: if multiple parent tables and/or the new table definition
+ contain identically-named CHECK constraints, these
+ constraints must all have the same check expression, or an error will be
+ reported. Constraints having the same name and expression will
+ be merged into one copy. A constraint marked NO INHERIT in a
+ parent will not be considered. Notice that an unnamed CHECK
+ constraint in the new table will never be merged, since a unique name
+ will always be chosen for it.
+
+ Column STORAGE settings are also copied from parent tables.
+
+ If a column in the parent table is an identity column, that property is
+ not inherited. A column in the child table can be declared identity
+ column if desired.
+
PARTITION BY { RANGE | LIST | HASH } ( { column_name | ( expression ) } [ opclass ] [, ...] ) #
+ The optional PARTITION BY clause specifies a strategy
+ of partitioning the table. The table thus created is called a
+ partitioned table. The parenthesized list of
+ columns or expressions forms the partition key
+ for the table. When using range or hash partitioning, the partition key
+ can include multiple columns or expressions (up to 32, but this limit can
+ be altered when building PostgreSQL), but for
+ list partitioning, the partition key must consist of a single column or
+ expression.
+
+ Range and list partitioning require a btree operator class, while hash
+ partitioning requires a hash operator class. If no operator class is
+ specified explicitly, the default operator class of the appropriate
+ type will be used; if no default operator class exists, an error will
+ be raised. When hash partitioning is used, the operator class used
+ must implement support function 2 (see Section 38.16.3
+ for details).
+
+ A partitioned table is divided into sub-tables (called partitions),
+ which are created using separate CREATE TABLE commands.
+ The partitioned table is itself empty. A data row inserted into the
+ table is routed to a partition based on the value of columns or
+ expressions in the partition key. If no existing partition matches
+ the values in the new row, an error will be reported.
+
+ Partitioned tables do not support EXCLUDE constraints;
+ however, you can define these constraints on individual partitions.
+
+ See Section 5.11 for more discussion on table
+ partitioning.
+
PARTITION OF parent_table { FOR VALUES partition_bound_spec | DEFAULT } #
+ Creates the table as a partition of the specified
+ parent table. The table can be created either as a partition for specific
+ values using FOR VALUES or as a default partition
+ using DEFAULT. Any indexes, constraints and
+ user-defined row-level triggers that exist in the parent table are cloned
+ on the new partition.
+
+ The partition_bound_spec
+ must correspond to the partitioning method and partition key of the
+ parent table, and must not overlap with any existing partition of that
+ parent. The form with IN is used for list partitioning,
+ the form with FROM and TO is used
+ for range partitioning, and the form with WITH is used
+ for hash partitioning.
+
+ partition_bound_expr is
+ any variable-free expression (subqueries, window functions, aggregate
+ functions, and set-returning functions are not allowed). Its data type
+ must match the data type of the corresponding partition key column.
+ The expression is evaluated once at table creation time, so it can
+ even contain volatile expressions such as
+ CURRENT_TIMESTAMP
+ When creating a list partition, NULL can be
+ specified to signify that the partition allows the partition key
+ column to be null. However, there cannot be more than one such
+ list partition for a given parent table. NULL
+ cannot be specified for range partitions.
+
+ When creating a range partition, the lower bound specified with
+ FROM is an inclusive bound, whereas the upper
+ bound specified with TO is an exclusive bound.
+ That is, the values specified in the FROM list
+ are valid values of the corresponding partition key columns for this
+ partition, whereas those in the TO list are
+ not. Note that this statement must be understood according to the
+ rules of row-wise comparison (Section 9.24.5).
+ For example, given PARTITION BY RANGE (x,y), a partition
+ bound FROM (1, 2) TO (3, 4)
+ allows x=1 with any y>=2,
+ x=2 with any non-null y,
+ and x=3 with any y<4.
+
+ The special values MINVALUE and MAXVALUE
+ may be used when creating a range partition to indicate that there
+ is no lower or upper bound on the column's value. For example, a
+ partition defined using FROM (MINVALUE) TO (10) allows
+ any values less than 10, and a partition defined using
+ FROM (10) TO (MAXVALUE) allows any values greater than
+ or equal to 10.
+
+ When creating a range partition involving more than one column, it
+ can also make sense to use MAXVALUE as part of the lower
+ bound, and MINVALUE as part of the upper bound. For
+ example, a partition defined using
+ FROM (0, MAXVALUE) TO (10, MAXVALUE) allows any rows
+ where the first partition key column is greater than 0 and less than
+ or equal to 10. Similarly, a partition defined using
+ FROM ('a', MINVALUE) TO ('b', MINVALUE) allows any rows
+ where the first partition key column starts with "a".
+
+ Note that if MINVALUE or MAXVALUE is used for
+ one column of a partitioning bound, the same value must be used for all
+ subsequent columns. For example, (10, MINVALUE, 0) is not
+ a valid bound; you should write (10, MINVALUE, MINVALUE).
+
+ Also note that some element types, such as timestamp,
+ have a notion of "infinity", which is just another value that can
+ be stored. This is different from MINVALUE and
+ MAXVALUE, which are not real values that can be stored,
+ but rather they are ways of saying that the value is unbounded.
+ MAXVALUE can be thought of as being greater than any
+ other value, including "infinity" and MINVALUE as being
+ less than any other value, including "minus infinity". Thus the range
+ FROM ('infinity') TO (MAXVALUE) is not an empty range; it
+ allows precisely one value to be stored — "infinity".
+
+ If DEFAULT is specified, the table will be
+ created as the default partition of the parent table. This option
+ is not available for hash-partitioned tables. A partition key value
+ not fitting into any other partition of the given parent will be
+ routed to the default partition.
+
+ When a table has an existing DEFAULT partition and
+ a new partition is added to it, the default partition must
+ be scanned to verify that it does not contain any rows which properly
+ belong in the new partition. If the default partition contains a
+ large number of rows, this may be slow. The scan will be skipped if
+ the default partition is a foreign table or if it has a constraint which
+ proves that it cannot contain rows which should be placed in the new
+ partition.
+
+ When creating a hash partition, a modulus and remainder must be specified.
+ The modulus must be a positive integer, and the remainder must be a
+ non-negative integer less than the modulus. Typically, when initially
+ setting up a hash-partitioned table, you should choose a modulus equal to
+ the number of partitions and assign every table the same modulus and a
+ different remainder (see examples, below). However, it is not required
+ that every partition have the same modulus, only that every modulus which
+ occurs among the partitions of a hash-partitioned table is a factor of the
+ next larger modulus. This allows the number of partitions to be increased
+ incrementally without needing to move all the data at once. For example,
+ suppose you have a hash-partitioned table with 8 partitions, each of which
+ has modulus 8, but find it necessary to increase the number of partitions
+ to 16. You can detach one of the modulus-8 partitions, create two new
+ modulus-16 partitions covering the same portion of the key space (one with
+ a remainder equal to the remainder of the detached partition, and the
+ other with a remainder equal to that value plus 8), and repopulate them
+ with data. You can then repeat this -- perhaps at a later time -- for
+ each modulus-8 partition until none remain. While this may still involve
+ a large amount of data movement at each step, it is still better than
+ having to create a whole new table and move all the data at once.
+
+ A partition must have the same column names and types as the partitioned
+ table to which it belongs. Modifications to the column names or types of
+ a partitioned table will automatically propagate to all partitions.
+ CHECK constraints will be inherited automatically by
+ every partition, but an individual partition may specify additional
+ CHECK constraints; additional constraints with the
+ same name and condition as in the parent will be merged with the parent
+ constraint. Defaults may be specified separately for each partition.
+ But note that a partition's default value is not applied when inserting
+ a tuple through a partitioned table.
+
+ Rows inserted into a partitioned table will be automatically routed to
+ the correct partition. If no suitable partition exists, an error will
+ occur.
+
+ Operations such as TRUNCATE
+ which normally affect a table and all of its
+ inheritance children will cascade to all partitions, but may also be
+ performed on an individual partition.
+
+ Note that creating a partition using PARTITION OF
+ requires taking an ACCESS EXCLUSIVE lock on the
+ parent partitioned table. Likewise, dropping a partition
+ with DROP TABLE requires taking
+ an ACCESS EXCLUSIVE lock on the parent table.
+ It is possible to use ALTER
+ TABLE ATTACH/DETACH PARTITION to perform these
+ operations with a weaker lock, thus reducing interference with
+ concurrent operations on the partitioned table.
+
LIKE source_table [ like_option ... ] #
+ The LIKE clause specifies a table from which
+ the new table automatically copies all column names, their data types,
+ and their not-null constraints.
+
+ Unlike INHERITS, the new table and original table
+ are completely decoupled after creation is complete. Changes to the
+ original table will not be applied to the new table, and it is not
+ possible to include data of the new table in scans of the original
+ table.
+
+ Also unlike INHERITS, columns and
+ constraints copied by LIKE are not merged with similarly
+ named columns and constraints.
+ If the same name is specified explicitly or in another
+ LIKE clause, an error is signaled.
+
+ The optional like_option clauses specify
+ which additional properties of the original table to copy. Specifying
+ INCLUDING copies the property, specifying
+ EXCLUDING omits the property.
+ EXCLUDING is the default. If multiple specifications
+ are made for the same kind of object, the last one is used. The
+ available options are:
+
+
+ Comments for the copied columns, constraints, and indexes will be
+ copied. The default behavior is to exclude comments, resulting in
+ the copied columns and constraints in the new table having no
+ comments.
+
INCLUDING COMPRESSION #
+ Compression method of the columns will be copied. The default
+ behavior is to exclude compression methods, resulting in columns
+ having the default compression method.
+
INCLUDING CONSTRAINTS #
+ CHECK constraints will be copied. No distinction
+ is made between column constraints and table constraints. Not-null
+ constraints are always copied to the new table.
+
INCLUDING DEFAULTS #
+ Default expressions for the copied column definitions will be
+ copied. Otherwise, default expressions are not copied, resulting in
+ the copied columns in the new table having null defaults. Note that
+ copying defaults that call database-modification functions, such as
+ nextval, may create a functional linkage
+ between the original and new tables.
+
INCLUDING GENERATED #
+ Any generation expressions of copied column definitions will be
+ copied. By default, new columns will be regular base columns.
+
INCLUDING IDENTITY #
+ Any identity specifications of copied column definitions will be
+ copied. A new sequence is created for each identity column of the
+ new table, separate from the sequences associated with the old
+ table.
+
INCLUDING INDEXES #
+ Indexes, PRIMARY KEY, UNIQUE,
+ and EXCLUDE constraints on the original table
+ will be created on the new table. Names for the new indexes and
+ constraints are chosen according to the default rules, regardless of
+ how the originals were named. (This behavior avoids possible
+ duplicate-name failures for the new indexes.)
+
INCLUDING STATISTICS #
+ Extended statistics are copied to the new table.
+
INCLUDING STORAGE #
+ STORAGE settings for the copied column
+ definitions will be copied. The default behavior is to exclude
+ STORAGE settings, resulting in the copied columns
+ in the new table having type-specific default settings. For more on
+ STORAGE settings, see Section 73.2.
+
INCLUDING ALL #
+ INCLUDING ALL is an abbreviated form selecting
+ all the available individual options. (It could be useful to write
+ individual EXCLUDING clauses after
+ INCLUDING ALL to select all but some specific
+ options.)
+
+
+ The LIKE clause can also be used to copy column
+ definitions from views, foreign tables, or composite types.
+ Inapplicable options (e.g., INCLUDING INDEXES from
+ a view) are ignored.
+
CONSTRAINT constraint_name #
+ An optional name for a column or table constraint. If the
+ constraint is violated, the constraint name is present in error messages,
+ so constraint names like col must be positive can be used
+ to communicate helpful constraint information to client applications.
+ (Double-quotes are needed to specify constraint names that contain spaces.)
+ If a constraint name is not specified, the system generates a name.
+
NOT NULL #
+ The column is not allowed to contain null values.
+
NULL #
+ The column is allowed to contain null values. This is the default.
+
+ This clause is only provided for compatibility with
+ non-standard SQL databases. Its use is discouraged in new
+ applications.
+
CHECK ( expression ) [ NO INHERIT ] #
+ The CHECK clause specifies an expression producing a
+ Boolean result which new or updated rows must satisfy for an
+ insert or update operation to succeed. Expressions evaluating
+ to TRUE or UNKNOWN succeed. Should any row of an insert or
+ update operation produce a FALSE result, an error exception is
+ raised and the insert or update does not alter the database. A
+ check constraint specified as a column constraint should
+ reference that column's value only, while an expression
+ appearing in a table constraint can reference multiple columns.
+
+ Currently, CHECK expressions cannot contain
+ subqueries nor refer to variables other than columns of the
+ current row (see Section 5.4.1).
+ The system column tableoid
+ may be referenced, but not any other system column.
+
+ A constraint marked with NO INHERIT will not propagate to
+ child tables.
+
+ When a table has multiple CHECK constraints,
+ they will be tested for each row in alphabetical order by name,
+ after checking NOT NULL constraints.
+ (PostgreSQL versions before 9.5 did not honor any
+ particular firing order for CHECK constraints.)
+
DEFAULT
+ default_expr #
+ The DEFAULT clause assigns a default data value for
+ the column whose column definition it appears within. The value
+ is any variable-free expression (in particular, cross-references
+ to other columns in the current table are not allowed). Subqueries
+ are not allowed either. The data type of the default expression must
+ match the data type of the column.
+
+ The default expression will be used in any insert operation that
+ does not specify a value for the column. If there is no default
+ for a column, then the default is null.
+
GENERATED ALWAYS AS ( generation_expr ) STORED #
+ This clause creates the column as a generated
+ column. The column cannot be written to, and when read the
+ result of the specified expression will be returned.
+
+ The keyword STORED is required to signify that the
+ column will be computed on write and will be stored on disk.
+
+ The generation expression can refer to other columns in the table, but
+ not other generated columns. Any functions and operators used must be
+ immutable. References to other tables are not allowed.
+
GENERATED { ALWAYS | BY DEFAULT } AS IDENTITY [ ( sequence_options ) ] #
+ This clause creates the column as an identity
+ column. It will have an implicit sequence attached to it
+ and the column in new rows will automatically have values from the
+ sequence assigned to it.
+ Such a column is implicitly NOT NULL.
+
+ The clauses ALWAYS and BY DEFAULT
+ determine how explicitly user-specified values are handled in
+ INSERT and UPDATE commands.
+
+ In an INSERT command, if ALWAYS is
+ selected, a user-specified value is only accepted if the
+ INSERT statement specifies OVERRIDING SYSTEM
+ VALUE. If BY DEFAULT is selected, then the
+ user-specified value takes precedence. See INSERT
+ for details. (In the COPY command, user-specified
+ values are always used regardless of this setting.)
+
+ In an UPDATE command, if ALWAYS is
+ selected, any update of the column to any value other than
+ DEFAULT will be rejected. If BY
+ DEFAULT is selected, the column can be updated normally.
+ (There is no OVERRIDING clause for the
+ UPDATE command.)
+
+ The optional sequence_options clause can be
+ used to override the options of the sequence.
+ See CREATE SEQUENCE for details.
+
UNIQUE [ NULLS [ NOT ] DISTINCT ] (column constraint)
UNIQUE [ NULLS [ NOT ] DISTINCT ] ( column_name [, ... ] )
+ [ INCLUDE ( column_name [, ...]) ] (table constraint) #
+ The UNIQUE constraint specifies that a
+ group of one or more columns of a table can contain
+ only unique values. The behavior of a unique table constraint
+ is the same as that of a unique column constraint, with the
+ additional capability to span multiple columns. The constraint
+ therefore enforces that any two rows must differ in at least one
+ of these columns.
+
+ For the purpose of a unique constraint, null values are not
+ considered equal, unless NULLS NOT DISTINCT is
+ specified.
+
+ Each unique constraint should name a set of columns that is
+ different from the set of columns named by any other unique or
+ primary key constraint defined for the table. (Otherwise, redundant
+ unique constraints will be discarded.)
+
+ When establishing a unique constraint for a multi-level partition
+ hierarchy, all the columns in the partition key of the target
+ partitioned table, as well as those of all its descendant partitioned
+ tables, must be included in the constraint definition.
+
+ Adding a unique constraint will automatically create a unique btree
+ index on the column or group of columns used in the constraint.
+
+ The optional INCLUDE clause adds to that index
+ one or more columns that are simply “payload”: uniqueness
+ is not enforced on them, and the index cannot be searched on the basis
+ of those columns. However they can be retrieved by an index-only scan.
+ Note that although the constraint is not enforced on included columns,
+ it still depends on them. Consequently, some operations on such columns
+ (e.g., DROP COLUMN) can cause cascaded constraint and
+ index deletion.
+
PRIMARY KEY (column constraint)
PRIMARY KEY ( column_name [, ... ] )
+ [ INCLUDE ( column_name [, ...]) ] (table constraint) #
+ The PRIMARY KEY constraint specifies that a column or
+ columns of a table can contain only unique (non-duplicate), nonnull
+ values. Only one primary key can be specified for a table, whether as a
+ column constraint or a table constraint.
+
+ The primary key constraint should name a set of columns that is
+ different from the set of columns named by any unique
+ constraint defined for the same table. (Otherwise, the unique
+ constraint is redundant and will be discarded.)
+
+ PRIMARY KEY enforces the same data constraints as
+ a combination of UNIQUE and NOT
+ NULL. However,
+ identifying a set of columns as the primary key also provides metadata
+ about the design of the schema, since a primary key implies that other
+ tables can rely on this set of columns as a unique identifier for rows.
+
+ When placed on a partitioned table, PRIMARY KEY
+ constraints share the restrictions previously described
+ for UNIQUE constraints.
+
+ Adding a PRIMARY KEY constraint will automatically
+ create a unique btree index on the column or group of columns used in the
+ constraint.
+
+ The optional INCLUDE clause adds to that index
+ one or more columns that are simply “payload”: uniqueness
+ is not enforced on them, and the index cannot be searched on the basis
+ of those columns. However they can be retrieved by an index-only scan.
+ Note that although the constraint is not enforced on included columns,
+ it still depends on them. Consequently, some operations on such columns
+ (e.g., DROP COLUMN) can cause cascaded constraint and
+ index deletion.
+
EXCLUDE [ USING index_method ] ( exclude_element WITH operator [, ... ] ) index_parameters [ WHERE ( predicate ) ] #
+ The EXCLUDE clause defines an exclusion
+ constraint, which guarantees that if
+ any two rows are compared on the specified column(s) or
+ expression(s) using the specified operator(s), not all of these
+ comparisons will return TRUE. If all of the
+ specified operators test for equality, this is equivalent to a
+ UNIQUE constraint, although an ordinary unique constraint
+ will be faster. However, exclusion constraints can specify
+ constraints that are more general than simple equality.
+ For example, you can specify a constraint that
+ no two rows in the table contain overlapping circles
+ (see Section 8.8) by using the
+ && operator.
+ The operator(s) are required to be commutative.
+
+ Exclusion constraints are implemented using
+ an index, so each specified operator must be associated with an
+ appropriate operator class
+ (see Section 11.10) for the index access
+ method index_method.
+ Each exclude_element
+ defines a column of the index, so it can optionally specify a collation,
+ an operator class, operator class parameters, and/or ordering options;
+ these are described fully under CREATE INDEX.
+
+ The access method must support amgettuple (see Chapter 64); at present this means GIN
+ cannot be used. Although it's allowed, there is little point in using
+ B-tree or hash indexes with an exclusion constraint, because this
+ does nothing that an ordinary unique constraint doesn't do better.
+ So in practice the access method will always be GiST or
+ SP-GiST.
+
+ The predicate allows you to specify an
+ exclusion constraint on a subset of the table; internally this creates a
+ partial index. Note that parentheses are required around the predicate.
+
REFERENCES reftable [ ( refcolumn ) ] [ MATCH matchtype ] [ ON DELETE referential_action ] [ ON UPDATE referential_action ] (column constraint)
FOREIGN KEY ( column_name [, ... ] )
+ REFERENCES reftable [ ( refcolumn [, ... ] ) ]
+ [ MATCH matchtype ]
+ [ ON DELETE referential_action ]
+ [ ON UPDATE referential_action ]
+ (table constraint) #
+ These clauses specify a foreign key constraint, which requires
+ that a group of one or more columns of the new table must only
+ contain values that match values in the referenced
+ column(s) of some row of the referenced table. If the refcolumn list is omitted, the
+ primary key of the reftable
+ is used. Otherwise, the refcolumn
+ list must refer to the columns of a non-deferrable unique or primary key
+ constraint or be the columns of a non-partial unique index. The user
+ must have REFERENCES permission on the referenced
+ table (either the whole table, or the specific referenced columns). The
+ addition of a foreign key constraint requires a
+ SHARE ROW EXCLUSIVE lock on the referenced table.
+ Note that foreign key constraints cannot be defined between temporary
+ tables and permanent tables.
+
+ A value inserted into the referencing column(s) is matched against the
+ values of the referenced table and referenced columns using the
+ given match type. There are three match types: MATCH
+ FULL, MATCH PARTIAL, and MATCH
+ SIMPLE (which is the default). MATCH
+ FULL will not allow one column of a multicolumn foreign key
+ to be null unless all foreign key columns are null; if they are all
+ null, the row is not required to have a match in the referenced table.
+ MATCH SIMPLE allows any of the foreign key columns
+ to be null; if any of them are null, the row is not required to have a
+ match in the referenced table.
+ MATCH PARTIAL is not yet implemented.
+ (Of course, NOT NULL constraints can be applied to the
+ referencing column(s) to prevent these cases from arising.)
+
+ In addition, when the data in the referenced columns is changed,
+ certain actions are performed on the data in this table's
+ columns. The ON DELETE clause specifies the
+ action to perform when a referenced row in the referenced table is
+ being deleted. Likewise, the ON UPDATE
+ clause specifies the action to perform when a referenced column
+ in the referenced table is being updated to a new value. If the
+ row is updated, but the referenced column is not actually
+ changed, no action is done. Referential actions other than the
+ NO ACTION check cannot be deferred, even if
+ the constraint is declared deferrable. There are the following possible
+ actions for each clause:
+
+
NO ACTION #
+ Produce an error indicating that the deletion or update
+ would create a foreign key constraint violation.
+ If the constraint is deferred, this
+ error will be produced at constraint check time if there still
+ exist any referencing rows. This is the default action.
+
RESTRICT #
+ Produce an error indicating that the deletion or update
+ would create a foreign key constraint violation.
+ This is the same as NO ACTION except that
+ the check is not deferrable.
+
CASCADE #
+ Delete any rows referencing the deleted row, or update the
+ values of the referencing column(s) to the new values of the
+ referenced columns, respectively.
+
SET NULL [ ( column_name [, ... ] ) ] #
+ Set all of the referencing columns, or a specified subset of the
+ referencing columns, to null. A subset of columns can only be
+ specified for ON DELETE actions.
+
SET DEFAULT [ ( column_name [, ... ] ) ] #
+ Set all of the referencing columns, or a specified subset of the
+ referencing columns, to their default values. A subset of columns
+ can only be specified for ON DELETE actions.
+ (There must be a row in the referenced table matching the default
+ values, if they are not null, or the operation will fail.)
+
+
+ If the referenced column(s) are changed frequently, it might be wise to
+ add an index to the referencing column(s) so that referential actions
+ associated with the foreign key constraint can be performed more
+ efficiently.
+
DEFERRABLE
NOT DEFERRABLE #
+ This controls whether the constraint can be deferred. A
+ constraint that is not deferrable will be checked immediately
+ after every command. Checking of constraints that are
+ deferrable can be postponed until the end of the transaction
+ (using the SET CONSTRAINTS command).
+ NOT DEFERRABLE is the default.
+ Currently, only UNIQUE, PRIMARY KEY,
+ EXCLUDE, and
+ REFERENCES (foreign key) constraints accept this
+ clause. NOT NULL and CHECK constraints are not
+ deferrable. Note that deferrable constraints cannot be used as
+ conflict arbitrators in an INSERT statement that
+ includes an ON CONFLICT DO UPDATE clause.
+
INITIALLY IMMEDIATE
INITIALLY DEFERRED #
+ If a constraint is deferrable, this clause specifies the default
+ time to check the constraint. If the constraint is
+ INITIALLY IMMEDIATE, it is checked after each
+ statement. This is the default. If the constraint is
+ INITIALLY DEFERRED, it is checked only at the
+ end of the transaction. The constraint check time can be
+ altered with the SET CONSTRAINTS command.
+
USING method #
+ This optional clause specifies the table access method to use to store
+ the contents for the new table; the method needs be an access method of
+ type TABLE. See Chapter 63 for more
+ information. If this option is not specified, the default table access
+ method is chosen for the new table. See default_table_access_method for more information.
+
WITH ( storage_parameter [= value] [, ... ] ) #
+ This clause specifies optional storage parameters for a table or index;
+ see Storage Parameters below for more
+ information. For backward-compatibility the WITH
+ clause for a table can also include OIDS=FALSE to
+ specify that rows of the new table should not contain OIDs (object
+ identifiers), OIDS=TRUE is not supported anymore.
+
WITHOUT OIDS #
+ This is backward-compatible syntax for declaring a table
+ WITHOUT OIDS, creating a table WITH
+ OIDS is not supported anymore.
+
ON COMMIT #
+ The behavior of temporary tables at the end of a transaction
+ block can be controlled using ON COMMIT.
+ The three options are:
+
+
PRESERVE ROWS #
+ No special action is taken at the ends of transactions.
+ This is the default behavior.
+
DELETE ROWS #
+ All rows in the temporary table will be deleted at the end
+ of each transaction block. Essentially, an automatic TRUNCATE is done
+ at each commit. When used on a partitioned table, this
+ is not cascaded to its partitions.
+
DROP #
+ The temporary table will be dropped at the end of the current
+ transaction block. When used on a partitioned table, this action
+ drops its partitions and when used on tables with inheritance
+ children, it drops the dependent children.
+
TABLESPACE tablespace_name #
+ The tablespace_name is the name
+ of the tablespace in which the new table is to be created.
+ If not specified,
+ default_tablespace is consulted, or
+ temp_tablespaces if the table is temporary. For
+ partitioned tables, since no storage is required for the table itself,
+ the tablespace specified overrides default_tablespace
+ as the default tablespace to use for any newly created partitions when no
+ other tablespace is explicitly specified.
+
USING INDEX TABLESPACE tablespace_name #
+ This clause allows selection of the tablespace in which the index
+ associated with a UNIQUE, PRIMARY
+ KEY, or EXCLUDE constraint will be created.
+ If not specified,
+ default_tablespace is consulted, or
+ temp_tablespaces if the table is temporary.
+
Storage Parameters
+ The WITH clause can specify storage parameters
+ for tables, and for indexes associated with a UNIQUE,
+ PRIMARY KEY, or EXCLUDE constraint.
+ Storage parameters for
+ indexes are documented in CREATE INDEX.
+ The storage parameters currently
+ available for tables are listed below. For many of these parameters, as
+ shown, there is an additional parameter with the same name prefixed with
+ toast., which controls the behavior of the
+ table's secondary TOAST table, if any
+ (see Section 73.2 for more information about TOAST).
+ If a table parameter value is set and the
+ equivalent toast. parameter is not, the TOAST table
+ will use the table's parameter value.
+ Specifying these parameters for partitioned tables is not supported,
+ but you may specify them for individual leaf partitions.
+
fillfactor (integer)
+
+ #
+ The fillfactor for a table is a percentage between 10 and 100.
+ 100 (complete packing) is the default. When a smaller fillfactor
+ is specified, INSERT operations pack table pages only
+ to the indicated percentage; the remaining space on each page is
+ reserved for updating rows on that page. This gives UPDATE
+ a chance to place the updated copy of a row on the same page as the
+ original, which is more efficient than placing it on a different
+ page, and makes heap-only tuple
+ updates more likely.
+ For a table whose entries are never updated, complete packing is the
+ best choice, but in heavily updated tables smaller fillfactors are
+ appropriate. This parameter cannot be set for TOAST tables.
+
toast_tuple_target (integer)
+
+ #
+ The toast_tuple_target specifies the minimum tuple length required before
+ we try to compress and/or move long column values into TOAST tables, and
+ is also the target length we try to reduce the length below once toasting
+ begins. This affects columns marked as External (for move),
+ Main (for compression), or Extended (for both) and applies only to new
+ tuples. There is no effect on existing rows.
+ By default this parameter is set to allow at least 4 tuples per block,
+ which with the default block size will be 2040 bytes. Valid values are
+ between 128 bytes and the (block size - header), by default 8160 bytes.
+ Changing this value may not be useful for very short or very long rows.
+ Note that the default setting is often close to optimal, and
+ it is possible that setting this parameter could have negative
+ effects in some cases.
+ This parameter cannot be set for TOAST tables.
+
parallel_workers (integer)
+
+ #
+ This sets the number of workers that should be used to assist a parallel
+ scan of this table. If not set, the system will determine a value based
+ on the relation size. The actual number of workers chosen by the planner
+ or by utility statements that use parallel scans may be less, for example
+ due to the setting of max_worker_processes.
+
autovacuum_enabled, toast.autovacuum_enabled (boolean)
+
+ #
+ Enables or disables the autovacuum daemon for a particular table.
+ If true, the autovacuum daemon will perform automatic VACUUM
+ and/or ANALYZE operations on this table following the rules
+ discussed in Section 25.1.6.
+ If false, this table will not be autovacuumed, except to prevent
+ transaction ID wraparound. See Section 25.1.5 for
+ more about wraparound prevention.
+ Note that the autovacuum daemon does not run at all (except to prevent
+ transaction ID wraparound) if the autovacuum
+ parameter is false; setting individual tables' storage parameters does
+ not override that. Therefore there is seldom much point in explicitly
+ setting this storage parameter to true, only
+ to false.
+
vacuum_index_cleanup, toast.vacuum_index_cleanup (enum)
+
+ #
+ Forces or disables index cleanup when VACUUM
+ is run on this table. The default value is
+ AUTO. With OFF, index
+ cleanup is disabled, with ON it is enabled,
+ and with AUTO a decision is made dynamically,
+ each time VACUUM runs. The dynamic behavior
+ allows VACUUM to avoid needlessly scanning
+ indexes to remove very few dead tuples. Forcibly disabling all
+ index cleanup can speed up VACUUM very
+ significantly, but may also lead to severely bloated indexes if
+ table modifications are frequent. The
+ INDEX_CLEANUP parameter of VACUUM, if
+ specified, overrides the value of this option.
+
vacuum_truncate, toast.vacuum_truncate (boolean)
+
+ #
+ Enables or disables vacuum to try to truncate off any empty pages
+ at the end of this table. The default value is true.
+ If true, VACUUM and
+ autovacuum do the truncation and the disk space for
+ the truncated pages is returned to the operating system.
+ Note that the truncation requires ACCESS EXCLUSIVE
+ lock on the table. The TRUNCATE parameter
+ of VACUUM, if specified, overrides the value
+ of this option.
+
autovacuum_vacuum_threshold, toast.autovacuum_vacuum_threshold (integer)
+
+ #
+ Per-table value for autovacuum_vacuum_threshold
+ parameter.
+
autovacuum_vacuum_scale_factor, toast.autovacuum_vacuum_scale_factor (floating point)
+
+ #
+ Per-table value for autovacuum_vacuum_scale_factor
+ parameter.
+
autovacuum_vacuum_insert_threshold, toast.autovacuum_vacuum_insert_threshold (integer)
+
+ #
+ Per-table value for autovacuum_vacuum_insert_threshold
+ parameter. The special value of -1 may be used to disable insert vacuums on the table.
+
autovacuum_vacuum_insert_scale_factor, toast.autovacuum_vacuum_insert_scale_factor (floating point)
+
+ #
+ Per-table value for autovacuum_vacuum_insert_scale_factor
+ parameter.
+
autovacuum_analyze_threshold (integer)
+
+ #
+ Per-table value for autovacuum_analyze_threshold
+ parameter.
+
autovacuum_analyze_scale_factor (floating point)
+
+ #
+ Per-table value for autovacuum_analyze_scale_factor
+ parameter.
+
autovacuum_vacuum_cost_delay, toast.autovacuum_vacuum_cost_delay (floating point)
+
+ #
+ Per-table value for autovacuum_vacuum_cost_delay
+ parameter.
+
autovacuum_vacuum_cost_limit, toast.autovacuum_vacuum_cost_limit (integer)
+
+ #
+ Per-table value for autovacuum_vacuum_cost_limit
+ parameter.
+
autovacuum_freeze_min_age, toast.autovacuum_freeze_min_age (integer)
+
+ #
+ Per-table value for vacuum_freeze_min_age
+ parameter. Note that autovacuum will ignore
+ per-table autovacuum_freeze_min_age parameters that are
+ larger than half the
+ system-wide autovacuum_freeze_max_age setting.
+
autovacuum_freeze_max_age, toast.autovacuum_freeze_max_age (integer)
+
+ #
+ Per-table value for autovacuum_freeze_max_age
+ parameter. Note that autovacuum will ignore
+ per-table autovacuum_freeze_max_age parameters that are
+ larger than the system-wide setting (it can only be set smaller).
+
autovacuum_freeze_table_age, toast.autovacuum_freeze_table_age (integer)
+
+ #
+ Per-table value for vacuum_freeze_table_age
+ parameter.
+
autovacuum_multixact_freeze_min_age, toast.autovacuum_multixact_freeze_min_age (integer)
+
+ #
+ Per-table value for vacuum_multixact_freeze_min_age
+ parameter. Note that autovacuum will ignore
+ per-table autovacuum_multixact_freeze_min_age parameters
+ that are larger than half the
+ system-wide autovacuum_multixact_freeze_max_age
+ setting.
+
autovacuum_multixact_freeze_max_age, toast.autovacuum_multixact_freeze_max_age (integer)
+
+ #
+ Per-table value
+ for autovacuum_multixact_freeze_max_age parameter.
+ Note that autovacuum will ignore
+ per-table autovacuum_multixact_freeze_max_age parameters
+ that are larger than the system-wide setting (it can only be set
+ smaller).
+
autovacuum_multixact_freeze_table_age, toast.autovacuum_multixact_freeze_table_age (integer)
+
+ #
+ Per-table value
+ for vacuum_multixact_freeze_table_age parameter.
+
log_autovacuum_min_duration, toast.log_autovacuum_min_duration (integer)
+
+ #
+ Per-table value for log_autovacuum_min_duration
+ parameter.
+
user_catalog_table (boolean)
+
+ #
+ Declare the table as an additional catalog table for purposes of
+ logical replication. See
+ Section 49.6.2 for details.
+ This parameter cannot be set for TOAST tables.
+
Notes
+ PostgreSQL automatically creates an
+ index for each unique constraint and primary key constraint to
+ enforce uniqueness. Thus, it is not necessary to create an
+ index explicitly for primary key columns. (See CREATE INDEX for more information.)
+
+ Unique constraints and primary keys are not inherited in the
+ current implementation. This makes the combination of
+ inheritance and unique constraints rather dysfunctional.
+
+ A table cannot have more than 1600 columns. (In practice, the
+ effective limit is usually lower because of tuple-length constraints.)
+
Examples
+ Create table films and table
+ distributors:
+
+
+CREATE TABLE films (
+ code char(5) CONSTRAINT firstkey PRIMARY KEY,
+ title varchar(40) NOT NULL,
+ did integer NOT NULL,
+ date_prod date,
+ kind varchar(10),
+ len interval hour to minute
+);
+
+CREATE TABLE distributors (
+ did integer PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY,
+ name varchar(40) NOT NULL CHECK (name <> '')
+);
+
+
+ Create a table with a 2-dimensional array:
+
+
+CREATE TABLE array_int (
+ vector int[][]
+);
+
+
+ Define a unique table constraint for the table
+ films. Unique table constraints can be defined
+ on one or more columns of the table:
+
+
+CREATE TABLE films (
+ code char(5),
+ title varchar(40),
+ did integer,
+ date_prod date,
+ kind varchar(10),
+ len interval hour to minute,
+ CONSTRAINT production UNIQUE(date_prod)
+);
+
+
+ Define a check column constraint:
+
+
+CREATE TABLE distributors (
+ did integer CHECK (did > 100),
+ name varchar(40)
+);
+
+
+ Define a check table constraint:
+
+
+CREATE TABLE distributors (
+ did integer,
+ name varchar(40),
+ CONSTRAINT con1 CHECK (did > 100 AND name <> '')
+);
+
+
+ Define a primary key table constraint for the table
+ films:
+
+
+CREATE TABLE films (
+ code char(5),
+ title varchar(40),
+ did integer,
+ date_prod date,
+ kind varchar(10),
+ len interval hour to minute,
+ CONSTRAINT code_title PRIMARY KEY(code,title)
+);
+
+
+ Define a primary key constraint for table
+ distributors. The following two examples are
+ equivalent, the first using the table constraint syntax, the second
+ the column constraint syntax:
+
+
+CREATE TABLE distributors (
+ did integer,
+ name varchar(40),
+ PRIMARY KEY(did)
+);
+
+CREATE TABLE distributors (
+ did integer PRIMARY KEY,
+ name varchar(40)
+);
+
+
+ Assign a literal constant default value for the column
+ name, arrange for the default value of column
+ did to be generated by selecting the next value
+ of a sequence object, and make the default value of
+ modtime be the time at which the row is
+ inserted:
+
+
+CREATE TABLE distributors (
+ name varchar(40) DEFAULT 'Luso Films',
+ did integer DEFAULT nextval('distributors_serial'),
+ modtime timestamp DEFAULT current_timestamp
+);
+
+
+ Define two NOT NULL column constraints on the table
+ distributors, one of which is explicitly
+ given a name:
+
+
+CREATE TABLE distributors (
+ did integer CONSTRAINT no_null NOT NULL,
+ name varchar(40) NOT NULL
+);
+
+
+ Define a unique constraint for the name column:
+
+
+CREATE TABLE distributors (
+ did integer,
+ name varchar(40) UNIQUE
+);
+
+
+ The same, specified as a table constraint:
+
+
+CREATE TABLE distributors (
+ did integer,
+ name varchar(40),
+ UNIQUE(name)
+);
+
+
+ Create the same table, specifying 70% fill factor for both the table
+ and its unique index:
+
+
+CREATE TABLE distributors (
+ did integer,
+ name varchar(40),
+ UNIQUE(name) WITH (fillfactor=70)
+)
+WITH (fillfactor=70);
+
+
+ Create table circles with an exclusion
+ constraint that prevents any two circles from overlapping:
+
+
+CREATE TABLE circles (
+ c circle,
+ EXCLUDE USING gist (c WITH &&)
+);
+
+
+ Create table cinemas in tablespace diskvol1:
+
+
+CREATE TABLE cinemas (
+ id serial,
+ name text,
+ location text
+) TABLESPACE diskvol1;
+
+
+ Create a composite type and a typed table:
+
+CREATE TYPE employee_type AS (name text, salary numeric);
+
+CREATE TABLE employees OF employee_type (
+ PRIMARY KEY (name),
+ salary WITH OPTIONS DEFAULT 1000
+);
+
+ Create a range partitioned table:
+
+CREATE TABLE measurement (
+ logdate date not null,
+ peaktemp int,
+ unitsales int
+) PARTITION BY RANGE (logdate);
+
+ Create a range partitioned table with multiple columns in the partition key:
+
+CREATE TABLE measurement_year_month (
+ logdate date not null,
+ peaktemp int,
+ unitsales int
+) PARTITION BY RANGE (EXTRACT(YEAR FROM logdate), EXTRACT(MONTH FROM logdate));
+
+ Create a list partitioned table:
+
+CREATE TABLE cities (
+ city_id bigserial not null,
+ name text not null,
+ population bigint
+) PARTITION BY LIST (left(lower(name), 1));
+
+ Create a hash partitioned table:
+
+CREATE TABLE orders (
+ order_id bigint not null,
+ cust_id bigint not null,
+ status text
+) PARTITION BY HASH (order_id);
+
+ Create partition of a range partitioned table:
+
+CREATE TABLE measurement_y2016m07
+ PARTITION OF measurement (
+ unitsales DEFAULT 0
+) FOR VALUES FROM ('2016-07-01') TO ('2016-08-01');
+
+ Create a few partitions of a range partitioned table with multiple
+ columns in the partition key:
+
+CREATE TABLE measurement_ym_older
+ PARTITION OF measurement_year_month
+ FOR VALUES FROM (MINVALUE, MINVALUE) TO (2016, 11);
+
+CREATE TABLE measurement_ym_y2016m11
+ PARTITION OF measurement_year_month
+ FOR VALUES FROM (2016, 11) TO (2016, 12);
+
+CREATE TABLE measurement_ym_y2016m12
+ PARTITION OF measurement_year_month
+ FOR VALUES FROM (2016, 12) TO (2017, 01);
+
+CREATE TABLE measurement_ym_y2017m01
+ PARTITION OF measurement_year_month
+ FOR VALUES FROM (2017, 01) TO (2017, 02);
+
+ Create partition of a list partitioned table:
+
+CREATE TABLE cities_ab
+ PARTITION OF cities (
+ CONSTRAINT city_id_nonzero CHECK (city_id != 0)
+) FOR VALUES IN ('a', 'b');
+
+ Create partition of a list partitioned table that is itself further
+ partitioned and then add a partition to it:
+
+CREATE TABLE cities_ab
+ PARTITION OF cities (
+ CONSTRAINT city_id_nonzero CHECK (city_id != 0)
+) FOR VALUES IN ('a', 'b') PARTITION BY RANGE (population);
+
+CREATE TABLE cities_ab_10000_to_100000
+ PARTITION OF cities_ab FOR VALUES FROM (10000) TO (100000);
+
+ Create partitions of a hash partitioned table:
+
+CREATE TABLE orders_p1 PARTITION OF orders
+ FOR VALUES WITH (MODULUS 4, REMAINDER 0);
+CREATE TABLE orders_p2 PARTITION OF orders
+ FOR VALUES WITH (MODULUS 4, REMAINDER 1);
+CREATE TABLE orders_p3 PARTITION OF orders
+ FOR VALUES WITH (MODULUS 4, REMAINDER 2);
+CREATE TABLE orders_p4 PARTITION OF orders
+ FOR VALUES WITH (MODULUS 4, REMAINDER 3);
+
+ Create a default partition:
+
+CREATE TABLE cities_partdef
+ PARTITION OF cities DEFAULT;
+
Compatibility
+ The CREATE TABLE command conforms to the
+ SQL standard, with exceptions listed below.
+
Temporary Tables
+ Although the syntax of CREATE TEMPORARY TABLE
+ resembles that of the SQL standard, the effect is not the same. In the
+ standard,
+ temporary tables are defined just once and automatically exist (starting
+ with empty contents) in every session that needs them.
+ PostgreSQL instead
+ requires each session to issue its own CREATE TEMPORARY
+ TABLE command for each temporary table to be used. This allows
+ different sessions to use the same temporary table name for different
+ purposes, whereas the standard's approach constrains all instances of a
+ given temporary table name to have the same table structure.
+
+ The standard's definition of the behavior of temporary tables is
+ widely ignored. PostgreSQL's behavior
+ on this point is similar to that of several other SQL databases.
+
+ The SQL standard also distinguishes between global and local temporary
+ tables, where a local temporary table has a separate set of contents for
+ each SQL module within each session, though its definition is still shared
+ across sessions. Since PostgreSQL does not
+ support SQL modules, this distinction is not relevant in
+ PostgreSQL.
+
+ For compatibility's sake, PostgreSQL will
+ accept the GLOBAL and LOCAL keywords
+ in a temporary table declaration, but they currently have no effect.
+ Use of these keywords is discouraged, since future versions of
+ PostgreSQL might adopt a more
+ standard-compliant interpretation of their meaning.
+
+ The ON COMMIT clause for temporary tables
+ also resembles the SQL standard, but has some differences.
+ If the ON COMMIT clause is omitted, SQL specifies that the
+ default behavior is ON COMMIT DELETE ROWS. However, the
+ default behavior in PostgreSQL is
+ ON COMMIT PRESERVE ROWS. The ON COMMIT
+ DROP option does not exist in SQL.
+
Non-Deferred Uniqueness Constraints
+ When a UNIQUE or PRIMARY KEY constraint is
+ not deferrable, PostgreSQL checks for
+ uniqueness immediately whenever a row is inserted or modified.
+ The SQL standard says that uniqueness should be enforced only at
+ the end of the statement; this makes a difference when, for example,
+ a single command updates multiple key values. To obtain
+ standard-compliant behavior, declare the constraint as
+ DEFERRABLE but not deferred (i.e., INITIALLY
+ IMMEDIATE). Be aware that this can be significantly slower than
+ immediate uniqueness checking.
+
Column Check Constraints
+ The SQL standard says that CHECK column constraints
+ can only refer to the column they apply to; only CHECK
+ table constraints can refer to multiple columns.
+ PostgreSQL does not enforce this
+ restriction; it treats column and table check constraints alike.
+
EXCLUDE Constraint
+ The EXCLUDE constraint type is a
+ PostgreSQL extension.
+
Foreign Key Constraints
+ The ability to specify column lists in the foreign key actions
+ SET DEFAULT and SET NULL is a
+ PostgreSQL extension.
+
+ It is a PostgreSQL extension that a
+ foreign key constraint may reference columns of a unique index instead of
+ columns of a primary key or unique constraint.
+
NULL “Constraint”
+ The NULL “constraint” (actually a
+ non-constraint) is a PostgreSQL
+ extension to the SQL standard that is included for compatibility with some
+ other database systems (and for symmetry with the NOT
+ NULL constraint). Since it is the default for any
+ column, its presence is simply noise.
+
Constraint Naming
+ The SQL standard says that table and domain constraints must have names
+ that are unique across the schema containing the table or domain.
+ PostgreSQL is laxer: it only requires
+ constraint names to be unique across the constraints attached to a
+ particular table or domain. However, this extra freedom does not exist
+ for index-based constraints (UNIQUE,
+ PRIMARY KEY, and EXCLUDE
+ constraints), because the associated index is named the same as the
+ constraint, and index names must be unique across all relations within
+ the same schema.
+
+ Currently, PostgreSQL does not record names
+ for NOT NULL constraints at all, so they are not
+ subject to the uniqueness restriction. This might change in a future
+ release.
+
Inheritance
+ Multiple inheritance via the INHERITS clause is
+ a PostgreSQL language extension.
+ SQL:1999 and later define single inheritance using a
+ different syntax and different semantics. SQL:1999-style
+ inheritance is not yet supported by
+ PostgreSQL.
+
Zero-Column Tables
+ PostgreSQL allows a table of no columns
+ to be created (for example, CREATE TABLE foo();). This
+ is an extension from the SQL standard, which does not allow zero-column
+ tables. Zero-column tables are not in themselves very useful, but
+ disallowing them creates odd special cases for ALTER TABLE
+ DROP COLUMN, so it seems cleaner to ignore this spec restriction.
+
Multiple Identity Columns
+ PostgreSQL allows a table to have more than one
+ identity column. The standard specifies that a table can have at most one
+ identity column. This is relaxed mainly to give more flexibility for
+ doing schema changes or migrations. Note that
+ the INSERT command supports only one override clause
+ that applies to the entire statement, so having multiple identity columns
+ with different behaviors is not well supported.
+
Generated Columns
+ The option STORED is not standard but is also used by
+ other SQL implementations. The SQL standard does not specify the storage
+ of generated columns.
+
LIKE Clause
+ While a LIKE clause exists in the SQL standard, many of the
+ options that PostgreSQL accepts for it are not
+ in the standard, and some of the standard's options are not implemented
+ by PostgreSQL.
+
WITH Clause
+ The WITH clause is a PostgreSQL
+ extension; storage parameters are not in the standard.
+
Tablespaces
+ The PostgreSQL concept of tablespaces is not
+ part of the standard. Hence, the clauses TABLESPACE
+ and USING INDEX TABLESPACE are extensions.
+
Typed Tables
+ Typed tables implement a subset of the SQL standard. According to
+ the standard, a typed table has columns corresponding to the
+ underlying composite type as well as one other column that is
+ the “self-referencing column”.
+ PostgreSQL does not support self-referencing
+ columns explicitly.
+
PARTITION BY Clause
+ The PARTITION BY clause is a
+ PostgreSQL extension.
+
PARTITION OF Clause
+ The PARTITION OF clause is a
+ PostgreSQL extension.
+
CREATE TABLE AS
CREATE TABLE AS — define a new table from the results of a query
Synopsis
+CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } | UNLOGGED ] TABLE [ IF NOT EXISTS ] table_name
+ [ (column_name [, ...] ) ]
+ [ USING method ]
+ [ WITH ( storage_parameter [= value] [, ... ] ) | WITHOUT OIDS ]
+ [ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
+ [ TABLESPACE tablespace_name ]
+ AS query
+ [ WITH [ NO ] DATA ]
+Description
+ CREATE TABLE AS creates a table and fills it
+ with data computed by a SELECT command.
+ The table columns have the
+ names and data types associated with the output columns of the
+ SELECT (except that you can override the column
+ names by giving an explicit list of new column names).
+
+ CREATE TABLE AS bears some resemblance to
+ creating a view, but it is really quite different: it creates a new
+ table and evaluates the query just once to fill the new table
+ initially. The new table will not track subsequent changes to the
+ source tables of the query. In contrast, a view re-evaluates its
+ defining SELECT statement whenever it is
+ queried.
+
+ CREATE TABLE AS requires CREATE
+ privilege on the schema used for the table.
+
Parameters
GLOBAL or LOCAL
+ Ignored for compatibility. Use of these keywords is deprecated;
+ refer to CREATE TABLE for details.
+
TEMPORARY or TEMP
+ If specified, the table is created as a temporary table.
+ Refer to CREATE TABLE for details.
+
UNLOGGED
+ If specified, the table is created as an unlogged table.
+ Refer to CREATE TABLE for details.
+
IF NOT EXISTS
+ Do not throw an error if a relation with the same name already
+ exists; simply issue a notice and leave the table unmodified.
+
table_name
+ The name (optionally schema-qualified) of the table to be created.
+
column_name
+ The name of a column in the new table. If column names are not
+ provided, they are taken from the output column names of the query.
+
USING method
+ This optional clause specifies the table access method to use to store
+ the contents for the new table; the method needs be an access method of
+ type TABLE. See Chapter 63 for more
+ information. If this option is not specified, the default table access
+ method is chosen for the new table. See default_table_access_method for more information.
+
WITH ( storage_parameter [= value] [, ... ] )
+ This clause specifies optional storage parameters for the new table;
+ see Storage Parameters in the
+ CREATE TABLE documentation for more
+ information. For backward-compatibility the WITH
+ clause for a table can also include OIDS=FALSE to
+ specify that rows of the new table should contain no OIDs (object
+ identifiers), OIDS=TRUE is not supported anymore.
+
WITHOUT OIDS
+ This is backward-compatible syntax for declaring a table
+ WITHOUT OIDS, creating a table WITH
+ OIDS is not supported anymore.
+
ON COMMIT
+ The behavior of temporary tables at the end of a transaction
+ block can be controlled using ON COMMIT.
+ The three options are:
+
+
PRESERVE ROWS
+ No special action is taken at the ends of transactions.
+ This is the default behavior.
+
DELETE ROWS
+ All rows in the temporary table will be deleted at the end
+ of each transaction block. Essentially, an automatic TRUNCATE is done
+ at each commit.
+
DROP
+ The temporary table will be dropped at the end of the current
+ transaction block.
+
TABLESPACE tablespace_name
+ The tablespace_name is the name
+ of the tablespace in which the new table is to be created.
+ If not specified,
+ default_tablespace is consulted, or
+ temp_tablespaces if the table is temporary.
+
query
+ A SELECT, TABLE, or VALUES
+ command, or an EXECUTE command that runs a
+ prepared SELECT, TABLE, or
+ VALUES query.
+
WITH [ NO ] DATA
+ This clause specifies whether or not the data produced by the query
+ should be copied into the new table. If not, only the table structure
+ is copied. The default is to copy the data.
+
Notes
+ This command is functionally similar to SELECT INTO, but it is
+ preferred since it is less likely to be confused with other uses of
+ the SELECT INTO syntax. Furthermore, CREATE
+ TABLE AS offers a superset of the functionality offered
+ by SELECT INTO.
+
Examples
+ Create a new table films_recent consisting of only
+ recent entries from the table films:
+
+
+CREATE TABLE films_recent AS
+ SELECT * FROM films WHERE date_prod >= '2002-01-01';
+
+
+ To copy a table completely, the short form using
+ the TABLE command can also be used:
+
+
+CREATE TABLE films2 AS
+ TABLE films;
+
+
+ Create a new temporary table films_recent, consisting of
+ only recent entries from the table films, using a
+ prepared statement. The new table will be dropped at commit:
+
+
+PREPARE recentfilms(date) AS
+ SELECT * FROM films WHERE date_prod > $1;
+CREATE TEMP TABLE films_recent ON COMMIT DROP AS
+ EXECUTE recentfilms('2002-01-01');
+Compatibility
+ CREATE TABLE AS conforms to the SQL
+ standard. The following are nonstandard extensions:
+
+
+ The standard requires parentheses around the subquery clause; in
+ PostgreSQL, these parentheses are
+ optional.
+
+ In the standard, the WITH [ NO ] DATA clause
+ is required; in PostgreSQL it is optional.
+
PostgreSQL handles temporary tables in a way
+ rather different from the standard; see
+ CREATE TABLE
+ for details.
+
+ The WITH clause is a PostgreSQL
+ extension; storage parameters are not in the standard.
+
+ The PostgreSQL concept of tablespaces is not
+ part of the standard. Hence, the clause TABLESPACE
+ is an extension.
+
CREATE TABLESPACE
CREATE TABLESPACE — define a new tablespace
Synopsis
+CREATE TABLESPACE tablespace_name
+ [ OWNER { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER } ]
+ LOCATION 'directory'
+ [ WITH ( tablespace_option = value [, ... ] ) ]
+
Description
+ CREATE TABLESPACE registers a new cluster-wide
+ tablespace. The tablespace name must be distinct from the name of any
+ existing tablespace in the database cluster.
+
+ A tablespace allows superusers to define an alternative location on
+ the file system where the data files containing database objects
+ (such as tables and indexes) can reside.
+
+ A user with appropriate privileges can pass
+ tablespace_name to
+ CREATE DATABASE, CREATE TABLE,
+ CREATE INDEX or ADD CONSTRAINT to have the data
+ files for these objects stored within the specified tablespace.
+
Warning
+ A tablespace cannot be used independently of the cluster in which it
+ is defined; see Section 23.6.
+
Parameters
tablespace_name
+ The name of a tablespace to be created. The name cannot
+ begin with pg_, as such names
+ are reserved for system tablespaces.
+
user_name
+ The name of the user who will own the tablespace. If omitted,
+ defaults to the user executing the command. Only superusers
+ can create tablespaces, but they can assign ownership of tablespaces
+ to non-superusers.
+
directory
+ The directory that will be used for the tablespace. The directory
+ must exist (CREATE TABLESPACE will not create it),
+ should be empty, and must be owned by the
+ PostgreSQL system user. The directory must be
+ specified by an absolute path name.
+
tablespace_option
+ A tablespace parameter to be set or reset. Currently, the only
+ available parameters are seq_page_cost,
+ random_page_cost, effective_io_concurrency
+ and maintenance_io_concurrency.
+ Setting these values for a particular tablespace will override the
+ planner's usual estimate of the cost of reading pages from tables in
+ that tablespace, and the executor's prefetching behavior, as established
+ by the configuration parameters of the
+ same name (see seq_page_cost,
+ random_page_cost,
+ effective_io_concurrency,
+ maintenance_io_concurrency). This may be useful if
+ one tablespace is located on a disk which is faster or slower than the
+ remainder of the I/O subsystem.
+
Notes
+ CREATE TABLESPACE cannot be executed inside a transaction
+ block.
+
Examples
+ To create a tablespace dbspace at file system location
+ /data/dbs, first create the directory using operating
+ system facilities and set the correct ownership:
+
+mkdir /data/dbs
+chown postgres:postgres /data/dbs
+
+ Then issue the tablespace creation command inside
+ PostgreSQL:
+
+CREATE TABLESPACE dbspace LOCATION '/data/dbs';
+
+
+ To create a tablespace owned by a different database user, use a command
+ like this:
+
+CREATE TABLESPACE indexspace OWNER genevieve LOCATION '/data/indexes';
+
Compatibility
+ CREATE TABLESPACE is a PostgreSQL
+ extension.
+
CREATE TRANSFORM
CREATE TRANSFORM — define a new transform
Synopsis
+CREATE [ OR REPLACE ] TRANSFORM FOR type_name LANGUAGE lang_name (
+ FROM SQL WITH FUNCTION from_sql_function_name [ (argument_type [, ...]) ],
+ TO SQL WITH FUNCTION to_sql_function_name [ (argument_type [, ...]) ]
+);
+
Parameters
type_name
+ The name of the data type of the transform.
+
lang_name
+ The name of the language of the transform.
+
from_sql_function_name[(argument_type [, ...])]
+ The name of the function for converting the type from the SQL
+ environment to the language. It must take one argument of
+ type internal and return type internal. The
+ actual argument will be of the type for the transform, and the function
+ should be coded as if it were. (But it is not allowed to declare an
+ SQL-level function returning internal without at
+ least one argument of type internal.) The actual return
+ value will be something specific to the language implementation.
+ If no argument list is specified, the function name must be unique in
+ its schema.
+
to_sql_function_name[(argument_type [, ...])]
+ The name of the function for converting the type from the language to
+ the SQL environment. It must take one argument of type
+ internal and return the type that is the type for the
+ transform. The actual argument value will be something specific to the
+ language implementation.
+ If no argument list is specified, the function name must be unique in
+ its schema.
+
CREATE TRIGGER
CREATE TRIGGER — define a new trigger
Synopsis
+CREATE [ OR REPLACE ] [ CONSTRAINT ] TRIGGER name { BEFORE | AFTER | INSTEAD OF } { event [ OR ... ] }
+ ON table_name
+ [ FROM referenced_table_name ]
+ [ NOT DEFERRABLE | [ DEFERRABLE ] [ INITIALLY IMMEDIATE | INITIALLY DEFERRED ] ]
+ [ REFERENCING { { OLD | NEW } TABLE [ AS ] transition_relation_name } [ ... ] ]
+ [ FOR [ EACH ] { ROW | STATEMENT } ]
+ [ WHEN ( condition ) ]
+ EXECUTE { FUNCTION | PROCEDURE } function_name ( arguments )
+
+where event can be one of:
+
+ INSERT
+ UPDATE [ OF column_name [, ... ] ]
+ DELETE
+ TRUNCATE
+
Description
+ CREATE TRIGGER creates a new trigger.
+ CREATE OR REPLACE TRIGGER will either create a
+ new trigger, or replace an existing trigger. The
+ trigger will be associated with the specified table, view, or foreign table
+ and will execute the specified
+ function function_name when
+ certain operations are performed on that table.
+
+ To replace the current definition of an existing trigger, use
+ CREATE OR REPLACE TRIGGER, specifying the existing
+ trigger's name and parent table. All other properties are replaced.
+
+ The trigger can be specified to fire before the
+ operation is attempted on a row (before constraints are checked and
+ the INSERT, UPDATE, or
+ DELETE is attempted); or after the operation has
+ completed (after constraints are checked and the
+ INSERT, UPDATE, or
+ DELETE has completed); or instead of the operation
+ (in the case of inserts, updates or deletes on a view).
+ If the trigger fires before or instead of the event, the trigger can skip
+ the operation for the current row, or change the row being inserted (for
+ INSERT and UPDATE operations
+ only). If the trigger fires after the event, all changes, including
+ the effects of other triggers, are “visible”
+ to the trigger.
+
+ A trigger that is marked FOR EACH ROW is called
+ once for every row that the operation modifies. For example, a
+ DELETE that affects 10 rows will cause any
+ ON DELETE triggers on the target relation to be
+ called 10 separate times, once for each deleted row. In contrast, a
+ trigger that is marked FOR EACH STATEMENT only
+ executes once for any given operation, regardless of how many rows
+ it modifies (in particular, an operation that modifies zero rows
+ will still result in the execution of any applicable FOR
+ EACH STATEMENT triggers).
+
+ Triggers that are specified to fire INSTEAD OF the trigger
+ event must be marked FOR EACH ROW, and can only be defined
+ on views. BEFORE and AFTER triggers on a view
+ must be marked as FOR EACH STATEMENT.
+
+ In addition, triggers may be defined to fire for
+ TRUNCATE, though only
+ FOR EACH STATEMENT.
+
+ The following table summarizes which types of triggers may be used on
+ tables, views, and foreign tables:
+
+ Also, a trigger definition can specify a Boolean WHEN
+ condition, which will be tested to see whether the trigger should
+ be fired. In row-level triggers the WHEN condition can
+ examine the old and/or new values of columns of the row. Statement-level
+ triggers can also have WHEN conditions, although the feature
+ is not so useful for them since the condition cannot refer to any values
+ in the table.
+
+ If multiple triggers of the same kind are defined for the same event,
+ they will be fired in alphabetical order by name.
+
+ When the CONSTRAINT option is specified, this command creates a
+ constraint trigger.
+ This is the same as a regular trigger
+ except that the timing of the trigger firing can be adjusted using
+ SET CONSTRAINTS.
+ Constraint triggers must be AFTER ROW triggers on plain
+ tables (not foreign tables). They
+ can be fired either at the end of the statement causing the triggering
+ event, or at the end of the containing transaction; in the latter case they
+ are said to be deferred. A pending deferred-trigger firing
+ can also be forced to happen immediately by using SET
+ CONSTRAINTS. Constraint triggers are expected to raise an exception
+ when the constraints they implement are violated.
+
+ The REFERENCING option enables collection
+ of transition relations, which are row sets that include all
+ of the rows inserted, deleted, or modified by the current SQL statement.
+ This feature lets the trigger see a global view of what the statement did,
+ not just one row at a time. This option is only allowed for
+ an AFTER trigger that is not a constraint trigger; also, if
+ the trigger is an UPDATE trigger, it must not specify
+ a column_name list.
+ OLD TABLE may only be specified once, and only for a trigger
+ that can fire on UPDATE or DELETE; it creates a
+ transition relation containing the before-images of all rows
+ updated or deleted by the statement.
+ Similarly, NEW TABLE may only be specified once, and only for
+ a trigger that can fire on UPDATE or INSERT;
+ it creates a transition relation containing the after-images
+ of all rows updated or inserted by the statement.
+
+ SELECT does not modify any rows so you cannot
+ create SELECT triggers. Rules and views may provide
+ workable solutions to problems that seem to need SELECT
+ triggers.
+
+ Refer to Chapter 39 for more information about triggers.
+
Parameters
name
+ The name to give the new trigger. This must be distinct from
+ the name of any other trigger for the same table.
+ The name cannot be schema-qualified — the trigger inherits the
+ schema of its table. For a constraint trigger, this is also the name to
+ use when modifying the trigger's behavior using
+ SET CONSTRAINTS.
+
BEFORE
AFTER
INSTEAD OF
+ Determines whether the function is called before, after, or instead of
+ the event. A constraint trigger can only be specified as
+ AFTER.
+
event
+ One of INSERT, UPDATE,
+ DELETE, or TRUNCATE;
+ this specifies the event that will fire the trigger. Multiple
+ events can be specified using OR, except when
+ transition relations are requested.
+
+ For UPDATE events, it is possible to
+ specify a list of columns using this syntax:
+
+UPDATE OF column_name1 [, column_name2 ... ]
+
+ The trigger will only fire if at least one of the listed columns
+ is mentioned as a target of the UPDATE command
+ or if one of the listed columns is a generated column that depends on a
+ column that is the target of the UPDATE.
+
+ INSTEAD OF UPDATE events do not allow a list of columns.
+ A column list cannot be specified when requesting transition relations,
+ either.
+
table_name
+ The name (optionally schema-qualified) of the table, view, or foreign
+ table the trigger is for.
+
referenced_table_name
+ The (possibly schema-qualified) name of another table referenced by the
+ constraint. This option is used for foreign-key constraints and is not
+ recommended for general use. This can only be specified for
+ constraint triggers.
+
DEFERRABLE
NOT DEFERRABLE
INITIALLY IMMEDIATE
INITIALLY DEFERRED
+ The default timing of the trigger.
+ See the CREATE TABLE documentation for details of
+ these constraint options. This can only be specified for constraint
+ triggers.
+
REFERENCING
+ This keyword immediately precedes the declaration of one or two
+ relation names that provide access to the transition relations of the
+ triggering statement.
+
OLD TABLE
NEW TABLE
+ This clause indicates whether the following relation name is for the
+ before-image transition relation or the after-image transition
+ relation.
+
transition_relation_name
+ The (unqualified) name to be used within the trigger for this
+ transition relation.
+
FOR EACH ROW
FOR EACH STATEMENT
+ This specifies whether the trigger function should be fired
+ once for every row affected by the trigger event, or just once
+ per SQL statement. If neither is specified, FOR EACH
+ STATEMENT is the default. Constraint triggers can only
+ be specified FOR EACH ROW.
+
condition
+ A Boolean expression that determines whether the trigger function
+ will actually be executed. If WHEN is specified, the
+ function will only be called if the condition returns true.
+ In FOR EACH ROW triggers, the WHEN
+ condition can refer to columns of the old and/or new row values
+ by writing OLD.column_name or
+ NEW.column_name respectively.
+ Of course, INSERT triggers cannot refer to OLD
+ and DELETE triggers cannot refer to NEW.
+
INSTEAD OF triggers do not support WHEN
+ conditions.
+
+ Currently, WHEN expressions cannot contain
+ subqueries.
+
+ Note that for constraint triggers, evaluation of the WHEN
+ condition is not deferred, but occurs immediately after the row update
+ operation is performed. If the condition does not evaluate to true then
+ the trigger is not queued for deferred execution.
+
function_name
+ A user-supplied function that is declared as taking no arguments
+ and returning type trigger, which is executed when
+ the trigger fires.
+
+ In the syntax of CREATE TRIGGER, the keywords
+ FUNCTION and PROCEDURE are
+ equivalent, but the referenced function must in any case be a function,
+ not a procedure. The use of the keyword PROCEDURE
+ here is historical and deprecated.
+
arguments
+ An optional comma-separated list of arguments to be provided to
+ the function when the trigger is executed. The arguments are
+ literal string constants. Simple names and numeric constants
+ can be written here, too, but they will all be converted to
+ strings. Please check the description of the implementation
+ language of the trigger function to find out how these arguments
+ can be accessed within the function; it might be different from
+ normal function arguments.
+
Notes
+ To create or replace a trigger on a table, the user must have the
+ TRIGGER privilege on the table. The user must
+ also have EXECUTE privilege on the trigger function.
+
+ Use DROP TRIGGER to remove a trigger.
+
+ Creating a row-level trigger on a partitioned table will cause an
+ identical “clone” trigger to be created on each of its
+ existing partitions; and any partitions created or attached later will have
+ an identical trigger, too. If there is a conflictingly-named trigger on a
+ child partition already, an error occurs unless CREATE OR REPLACE
+ TRIGGER is used, in which case that trigger is replaced with a
+ clone trigger. When a partition is detached from its parent, its clone
+ triggers are removed.
+
+ A column-specific trigger (one defined using the UPDATE OF
+ column_name syntax) will fire when any
+ of its columns are listed as targets in the UPDATE
+ command's SET list. It is possible for a column's value
+ to change even when the trigger is not fired, because changes made to the
+ row's contents by BEFORE UPDATE triggers are not considered.
+ Conversely, a command such as UPDATE ... SET x = x ...
+ will fire a trigger on column x, even though the column's
+ value did not change.
+
+ In a BEFORE trigger, the WHEN condition is
+ evaluated just before the function is or would be executed, so using
+ WHEN is not materially different from testing the same
+ condition at the beginning of the trigger function. Note in particular
+ that the NEW row seen by the condition is the current value,
+ as possibly modified by earlier triggers. Also, a BEFORE
+ trigger's WHEN condition is not allowed to examine the
+ system columns of the NEW row (such as ctid),
+ because those won't have been set yet.
+
+ In an AFTER trigger, the WHEN condition is
+ evaluated just after the row update occurs, and it determines whether an
+ event is queued to fire the trigger at the end of statement. So when an
+ AFTER trigger's WHEN condition does not return
+ true, it is not necessary to queue an event nor to re-fetch the row at end
+ of statement. This can result in significant speedups in statements that
+ modify many rows, if the trigger only needs to be fired for a few of the
+ rows.
+
+ In some cases it is possible for a single SQL command to fire more than
+ one kind of trigger. For instance an INSERT with
+ an ON CONFLICT DO UPDATE clause may cause both insert and
+ update operations, so it will fire both kinds of triggers as needed.
+ The transition relations supplied to triggers are
+ specific to their event type; thus an INSERT trigger
+ will see only the inserted rows, while an UPDATE
+ trigger will see only the updated rows.
+
+ Row updates or deletions caused by foreign-key enforcement actions, such
+ as ON UPDATE CASCADE or ON DELETE SET NULL, are
+ treated as part of the SQL command that caused them (note that such
+ actions are never deferred). Relevant triggers on the affected table will
+ be fired, so that this provides another way in which an SQL command might
+ fire triggers not directly matching its type. In simple cases, triggers
+ that request transition relations will see all changes caused in their
+ table by a single original SQL command as a single transition relation.
+ However, there are cases in which the presence of an AFTER ROW
+ trigger that requests transition relations will cause the foreign-key
+ enforcement actions triggered by a single SQL command to be split into
+ multiple steps, each with its own transition relation(s). In such cases,
+ any statement-level triggers that are present will be fired once per
+ creation of a transition relation set, ensuring that the triggers see
+ each affected row in a transition relation once and only once.
+
+ Statement-level triggers on a view are fired only if the action on the
+ view is handled by a row-level INSTEAD OF trigger.
+ If the action is handled by an INSTEAD rule, then
+ whatever statements are emitted by the rule are executed in place of the
+ original statement naming the view, so that the triggers that will be
+ fired are those on tables named in the replacement statements.
+ Similarly, if the view is automatically updatable, then the action is
+ handled by automatically rewriting the statement into an action on the
+ view's base table, so that the base table's statement-level triggers are
+ the ones that are fired.
+
+ Modifying a partitioned table or a table with inheritance children fires
+ statement-level triggers attached to the explicitly named table, but not
+ statement-level triggers for its partitions or child tables. In contrast,
+ row-level triggers are fired on the rows in affected partitions or
+ child tables, even if they are not explicitly named in the query.
+ If a statement-level trigger has been defined with transition relations
+ named by a REFERENCING clause, then before and after
+ images of rows are visible from all affected partitions or child tables.
+ In the case of inheritance children, the row images include only columns
+ that are present in the table that the trigger is attached to.
+
+ Currently, row-level triggers with transition relations cannot be defined
+ on partitions or inheritance child tables. Also, triggers on partitioned
+ tables may not be INSTEAD OF.
+
+ Currently, the OR REPLACE option is not supported for
+ constraint triggers.
+
+ Replacing an existing trigger within a transaction that has already
+ performed updating actions on the trigger's table is not recommended.
+ Trigger firing decisions, or portions of firing decisions, that have
+ already been made will not be reconsidered, so the effects could be
+ surprising.
+
+ There are a few built-in trigger functions that can be used to
+ solve common problems without having to write your own trigger code;
+ see Section 9.28.
+
Examples
+ Execute the function check_account_update whenever
+ a row of the table accounts is about to be updated:
+
+
+CREATE TRIGGER check_update
+ BEFORE UPDATE ON accounts
+ FOR EACH ROW
+ EXECUTE FUNCTION check_account_update();
+
+
+ Modify that trigger definition to only execute the function if
+ column balance is specified as a target in
+ the UPDATE command:
+
+
+CREATE OR REPLACE TRIGGER check_update
+ BEFORE UPDATE OF balance ON accounts
+ FOR EACH ROW
+ EXECUTE FUNCTION check_account_update();
+
+
+ This form only executes the function if column balance
+ has in fact changed value:
+
+
+CREATE TRIGGER check_update
+ BEFORE UPDATE ON accounts
+ FOR EACH ROW
+ WHEN (OLD.balance IS DISTINCT FROM NEW.balance)
+ EXECUTE FUNCTION check_account_update();
+
+
+ Call a function to log updates of accounts, but only if
+ something changed:
+
+
+CREATE TRIGGER log_update
+ AFTER UPDATE ON accounts
+ FOR EACH ROW
+ WHEN (OLD.* IS DISTINCT FROM NEW.*)
+ EXECUTE FUNCTION log_account_update();
+
+
+ Execute the function view_insert_row for each row to insert
+ rows into the tables underlying a view:
+
+
+CREATE TRIGGER view_insert
+ INSTEAD OF INSERT ON my_view
+ FOR EACH ROW
+ EXECUTE FUNCTION view_insert_row();
+
+
+ Execute the function check_transfer_balances_to_zero for each
+ statement to confirm that the transfer rows offset to a net of
+ zero:
+
+
+CREATE TRIGGER transfer_insert
+ AFTER INSERT ON transfer
+ REFERENCING NEW TABLE AS inserted
+ FOR EACH STATEMENT
+ EXECUTE FUNCTION check_transfer_balances_to_zero();
+
+
+ Execute the function check_matching_pairs for each row to
+ confirm that changes are made to matching pairs at the same time (by the
+ same statement):
+
+
+CREATE TRIGGER paired_items_update
+ AFTER UPDATE ON paired_items
+ REFERENCING NEW TABLE AS newtab OLD TABLE AS oldtab
+ FOR EACH ROW
+ EXECUTE FUNCTION check_matching_pairs();
+
+
+ Section 39.4 contains a complete example of a trigger
+ function written in C.
+
Compatibility
+ The CREATE TRIGGER statement in
+ PostgreSQL implements a subset of the
+ SQL standard. The following functionalities are currently
+ missing:
+
+
+ While transition table names for AFTER triggers are
+ specified using the REFERENCING clause in the standard way,
+ the row variables used in FOR EACH ROW triggers may not be
+ specified in a REFERENCING clause. They are available in a
+ manner that is dependent on the language in which the trigger function
+ is written, but is fixed for any one language. Some languages
+ effectively behave as though there is a REFERENCING clause
+ containing OLD ROW AS OLD NEW ROW AS NEW.
+
+ The standard allows transition tables to be used with
+ column-specific UPDATE triggers, but then the set of rows
+ that should be visible in the transition tables depends on the
+ trigger's column list. This is not currently implemented by
+ PostgreSQL.
+
+ PostgreSQL only allows the execution
+ of a user-defined function for the triggered action. The standard
+ allows the execution of a number of other SQL commands, such as
+ CREATE TABLE, as the triggered action. This
+ limitation is not hard to work around by creating a user-defined
+ function that executes the desired commands.
+
+
+ SQL specifies that multiple triggers should be fired in
+ time-of-creation order. PostgreSQL uses
+ name order, which was judged to be more convenient.
+
+ SQL specifies that BEFORE DELETE triggers on cascaded
+ deletes fire after the cascaded DELETE completes.
+ The PostgreSQL behavior is for BEFORE
+ DELETE to always fire before the delete action, even a cascading
+ one. This is considered more consistent. There is also nonstandard
+ behavior if BEFORE triggers modify rows or prevent
+ updates during an update that is caused by a referential action. This can
+ lead to constraint violations or stored data that does not honor the
+ referential constraint.
+
+ The ability to specify multiple actions for a single trigger using
+ OR is a PostgreSQL extension of
+ the SQL standard.
+
+ The ability to fire triggers for TRUNCATE is a
+ PostgreSQL extension of the SQL standard, as is the
+ ability to define statement-level triggers on views.
+
+ CREATE CONSTRAINT TRIGGER is a
+ PostgreSQL extension of the SQL
+ standard.
+ So is the OR REPLACE option.
+
CREATE TEXT SEARCH CONFIGURATION
CREATE TEXT SEARCH CONFIGURATION — define a new text search configuration
Synopsis
+CREATE TEXT SEARCH CONFIGURATION name (
+ PARSER = parser_name |
+ COPY = source_config
+)
+
Description
+ CREATE TEXT SEARCH CONFIGURATION creates a new text
+ search configuration. A text search configuration specifies a text
+ search parser that can divide a string into tokens, plus dictionaries
+ that can be used to determine which tokens are of interest for searching.
+
+ If only the parser is specified, then the new text search configuration
+ initially has no mappings from token types to dictionaries, and therefore
+ will ignore all words. Subsequent ALTER TEXT SEARCH
+ CONFIGURATION commands must be used to create mappings to
+ make the configuration useful. Alternatively, an existing text search
+ configuration can be copied.
+
+ If a schema name is given then the text search configuration is created in
+ the specified schema. Otherwise it is created in the current schema.
+
+ The user who defines a text search configuration becomes its owner.
+
+ Refer to Chapter 12 for further information.
+
Parameters
name
+ The name of the text search configuration to be created. The name can be
+ schema-qualified.
+
parser_name
+ The name of the text search parser to use for this configuration.
+
source_config
+ The name of an existing text search configuration to copy.
+
Notes
+ The PARSER and COPY options are mutually
+ exclusive, because when an existing configuration is copied, its
+ parser selection is copied too.
+
Compatibility
+ There is no CREATE TEXT SEARCH CONFIGURATION statement
+ in the SQL standard.
+
CREATE TEXT SEARCH DICTIONARY
CREATE TEXT SEARCH DICTIONARY — define a new text search dictionary
Synopsis
+CREATE TEXT SEARCH DICTIONARY name (
+ TEMPLATE = template
+ [, option = value [, ... ]]
+)
+
Description
+ CREATE TEXT SEARCH DICTIONARY creates a new text search
+ dictionary. A text search dictionary specifies a way of recognizing
+ interesting or uninteresting words for searching. A dictionary depends
+ on a text search template, which specifies the functions that actually
+ perform the work. Typically the dictionary provides some options that
+ control the detailed behavior of the template's functions.
+
+ If a schema name is given then the text search dictionary is created in the
+ specified schema. Otherwise it is created in the current schema.
+
+ The user who defines a text search dictionary becomes its owner.
+
+ Refer to Chapter 12 for further information.
+
Parameters
name
+ The name of the text search dictionary to be created. The name can be
+ schema-qualified.
+
template
+ The name of the text search template that will define the basic
+ behavior of this dictionary.
+
option
+ The name of a template-specific option to be set for this dictionary.
+
value
+ The value to use for a template-specific option. If the value
+ is not a simple identifier or number, it must be quoted (but you can
+ always quote it, if you wish).
+
+ The options can appear in any order.
+
Examples
+ The following example command creates a Snowball-based dictionary
+ with a nonstandard list of stop words.
+
+CREATE TEXT SEARCH DICTIONARY my_russian (
+ template = snowball,
+ language = russian,
+ stopwords = myrussian
+);
+
Compatibility
+ There is no CREATE TEXT SEARCH DICTIONARY statement in
+ the SQL standard.
+
CREATE TEXT SEARCH PARSER
CREATE TEXT SEARCH PARSER — define a new text search parser
Synopsis
+CREATE TEXT SEARCH PARSER name (
+ START = start_function ,
+ GETTOKEN = gettoken_function ,
+ END = end_function ,
+ LEXTYPES = lextypes_function
+ [, HEADLINE = headline_function ]
+)
+
Description
+ CREATE TEXT SEARCH PARSER creates a new text search
+ parser. A text search parser defines a method for splitting a text
+ string into tokens and assigning types (categories) to the tokens.
+ A parser is not particularly useful by itself, but must be bound into a
+ text search configuration along with some text search dictionaries
+ to be used for searching.
+
+ If a schema name is given then the text search parser is created in the
+ specified schema. Otherwise it is created in the current schema.
+
+ You must be a superuser to use CREATE TEXT SEARCH PARSER.
+ (This restriction is made because an erroneous text search parser
+ definition could confuse or even crash the server.)
+
+ Refer to Chapter 12 for further information.
+
Parameters
name
+ The name of the text search parser to be created. The name can be
+ schema-qualified.
+
start_function
+ The name of the start function for the parser.
+
gettoken_function
+ The name of the get-next-token function for the parser.
+
end_function
+ The name of the end function for the parser.
+
lextypes_function
+ The name of the lextypes function for the parser (a function that
+ returns information about the set of token types it produces).
+
headline_function
+ The name of the headline function for the parser (a function that
+ summarizes a set of tokens).
+
+ The function names can be schema-qualified if necessary. Argument types
+ are not given, since the argument list for each type of function is
+ predetermined. All except the headline function are required.
+
+ The arguments can appear in any order, not only the one shown above.
+
Compatibility
+ There is no
+ CREATE TEXT SEARCH PARSER statement in the SQL
+ standard.
+
CREATE TEXT SEARCH TEMPLATE
CREATE TEXT SEARCH TEMPLATE — define a new text search template
Synopsis
+CREATE TEXT SEARCH TEMPLATE name (
+ [ INIT = init_function , ]
+ LEXIZE = lexize_function
+)
+
Description
+ CREATE TEXT SEARCH TEMPLATE creates a new text search
+ template. Text search templates define the functions that implement
+ text search dictionaries. A template is not useful by itself, but must
+ be instantiated as a dictionary to be used. The dictionary typically
+ specifies parameters to be given to the template functions.
+
+ If a schema name is given then the text search template is created in the
+ specified schema. Otherwise it is created in the current schema.
+
+ You must be a superuser to use CREATE TEXT SEARCH
+ TEMPLATE. This restriction is made because an erroneous text
+ search template definition could confuse or even crash the server.
+ The reason for separating templates from dictionaries is that a template
+ encapsulates the “unsafe” aspects of defining a dictionary.
+ The parameters that can be set when defining a dictionary are safe for
+ unprivileged users to set, and so creating a dictionary need not be a
+ privileged operation.
+
+ Refer to Chapter 12 for further information.
+
Parameters
name
+ The name of the text search template to be created. The name can be
+ schema-qualified.
+
init_function
+ The name of the init function for the template.
+
lexize_function
+ The name of the lexize function for the template.
+
+ The function names can be schema-qualified if necessary. Argument types
+ are not given, since the argument list for each type of function is
+ predetermined. The lexize function is required, but the init function
+ is optional.
+
+ The arguments can appear in any order, not only the one shown above.
+
Compatibility
+ There is no
+ CREATE TEXT SEARCH TEMPLATE statement in the SQL
+ standard.
+
CREATE TYPE
CREATE TYPE — define a new data type
Synopsis
+CREATE TYPE name AS
+ ( [ attribute_name data_type [ COLLATE collation ] [, ... ] ] )
+
+CREATE TYPE name AS ENUM
+ ( [ 'label' [, ... ] ] )
+
+CREATE TYPE name AS RANGE (
+ SUBTYPE = subtype
+ [ , SUBTYPE_OPCLASS = subtype_operator_class ]
+ [ , COLLATION = collation ]
+ [ , CANONICAL = canonical_function ]
+ [ , SUBTYPE_DIFF = subtype_diff_function ]
+ [ , MULTIRANGE_TYPE_NAME = multirange_type_name ]
+)
+
+CREATE TYPE name (
+ INPUT = input_function,
+ OUTPUT = output_function
+ [ , RECEIVE = receive_function ]
+ [ , SEND = send_function ]
+ [ , TYPMOD_IN = type_modifier_input_function ]
+ [ , TYPMOD_OUT = type_modifier_output_function ]
+ [ , ANALYZE = analyze_function ]
+ [ , SUBSCRIPT = subscript_function ]
+ [ , INTERNALLENGTH = { internallength | VARIABLE } ]
+ [ , PASSEDBYVALUE ]
+ [ , ALIGNMENT = alignment ]
+ [ , STORAGE = storage ]
+ [ , LIKE = like_type ]
+ [ , CATEGORY = category ]
+ [ , PREFERRED = preferred ]
+ [ , DEFAULT = default ]
+ [ , ELEMENT = element ]
+ [ , DELIMITER = delimiter ]
+ [ , COLLATABLE = collatable ]
+)
+
+CREATE TYPE name
+
Description
+ CREATE TYPE registers a new data type for use in
+ the current database. The user who defines a type becomes its
+ owner.
+
+ If a schema name is given then the type is created in the specified
+ schema. Otherwise it is created in the current schema. The type
+ name must be distinct from the name of any existing type or domain
+ in the same schema. (Because tables have associated data types,
+ the type name must also be distinct from the name of any existing
+ table in the same schema.)
+
+ There are five forms of CREATE TYPE, as shown in the
+ syntax synopsis above. They respectively create a composite
+ type, an enum type, a range type, a
+ base type, or a shell type. The first four
+ of these are discussed in turn below. A shell type is simply a placeholder
+ for a type to be defined later; it is created by issuing CREATE
+ TYPE with no parameters except for the type name. Shell types
+ are needed as forward references when creating range types and base types,
+ as discussed in those sections.
+
Composite Types
+ The first form of CREATE TYPE
+ creates a composite type.
+ The composite type is specified by a list of attribute names and data types.
+ An attribute's collation can be specified too, if its data type is
+ collatable. A composite type is essentially the same as the row type
+ of a table, but using CREATE TYPE avoids the need to
+ create an actual table when all that is wanted is to define a type.
+ A stand-alone composite type is useful, for example, as the argument or
+ return type of a function.
+
+ To be able to create a composite type, you must
+ have USAGE privilege on all attribute types.
+
Enumerated Types
+ The second form of CREATE TYPE creates an enumerated
+ (enum) type, as described in Section 8.7.
+ Enum types take a list of quoted labels, each of which
+ must be less than NAMEDATALEN bytes long (64 bytes in a
+ standard PostgreSQL build). (It is possible to
+ create an enumerated type with zero labels, but such a type cannot be used
+ to hold values before at least one label is added using ALTER TYPE.)
+
Range Types
+ The third form of CREATE TYPE creates a new
+ range type, as described in Section 8.17.
+
+ The range type's subtype can
+ be any type with an associated b-tree operator class (to determine the
+ ordering of values for the range type). Normally the subtype's default
+ b-tree operator class is used to determine ordering; to use a non-default
+ operator class, specify its name with subtype_opclass. If the subtype is
+ collatable, and you want to use a non-default collation in the range's
+ ordering, specify the desired collation with the collation option.
+
+ The optional canonical
+ function must take one argument of the range type being defined, and
+ return a value of the same type. This is used to convert range values
+ to a canonical form, when applicable. See Section 8.17.8 for more information. Creating a
+ canonical function
+ is a bit tricky, since it must be defined before the range type can be
+ declared. To do this, you must first create a shell type, which is a
+ placeholder type that has no properties except a name and an
+ owner. This is done by issuing the command CREATE TYPE
+ name, with no additional parameters. Then
+ the function can be declared using the shell type as argument and result,
+ and finally the range type can be declared using the same name. This
+ automatically replaces the shell type entry with a valid range type.
+
+ The optional subtype_diff
+ function must take two values of the
+ subtype type as argument,
+ and return a double precision value representing the
+ difference between the two given values. While this is optional,
+ providing it allows much greater efficiency of GiST indexes on columns of
+ the range type. See Section 8.17.8 for more
+ information.
+
+ The optional multirange_type_name
+ parameter specifies the name of the corresponding multirange type. If not
+ specified, this name is chosen automatically as follows.
+ If the range type name contains the substring range, then
+ the multirange type name is formed by replacement of the range
+ substring with multirange in the range
+ type name. Otherwise, the multirange type name is formed by appending a
+ _multirange suffix to the range type name.
+
Base Types
+ The fourth form of CREATE TYPE creates a new base type
+ (scalar type). To create a new base type, you must be a superuser.
+ (This restriction is made because an erroneous type definition could
+ confuse or even crash the server.)
+
+ The parameters can appear in any order, not only that
+ illustrated above, and most are optional. You must register
+ two or more functions (using CREATE FUNCTION) before
+ defining the type. The support functions
+ input_function and
+ output_function
+ are required, while the functions
+ receive_function,
+ send_function,
+ type_modifier_input_function,
+ type_modifier_output_function,
+ analyze_function, and
+ subscript_function
+ are optional. Generally these functions have to be coded in C
+ or another low-level language.
+
+ The input_function
+ converts the type's external textual representation to the internal
+ representation used by the operators and functions defined for the type.
+ output_function
+ performs the reverse transformation. The input function can be
+ declared as taking one argument of type cstring,
+ or as taking three arguments of types
+ cstring, oid, integer.
+ The first argument is the input text as a C string, the second
+ argument is the type's own OID (except for array types, which instead
+ receive their element type's OID),
+ and the third is the typmod of the destination column, if known
+ (-1 will be passed if not).
+ The input function must return a value of the data type itself.
+ Usually, an input function should be declared STRICT; if it is not,
+ it will be called with a NULL first parameter when reading a NULL
+ input value. The function must still return NULL in this case, unless
+ it raises an error.
+ (This case is mainly meant to support domain input functions, which
+ might need to reject NULL inputs.)
+ The output function must be
+ declared as taking one argument of the new data type.
+ The output function must return type cstring.
+ Output functions are not invoked for NULL values.
+
+ The optional receive_function
+ converts the type's external binary representation to the internal
+ representation. If this function is not supplied, the type cannot
+ participate in binary input. The binary representation should be
+ chosen to be cheap to convert to internal form, while being reasonably
+ portable. (For example, the standard integer data types use network
+ byte order as the external binary representation, while the internal
+ representation is in the machine's native byte order.) The receive
+ function should perform adequate checking to ensure that the value is
+ valid.
+ The receive function can be declared as taking one argument of type
+ internal, or as taking three arguments of types
+ internal, oid, integer.
+ The first argument is a pointer to a StringInfo buffer
+ holding the received byte string; the optional arguments are the
+ same as for the text input function.
+ The receive function must return a value of the data type itself.
+ Usually, a receive function should be declared STRICT; if it is not,
+ it will be called with a NULL first parameter when reading a NULL
+ input value. The function must still return NULL in this case, unless
+ it raises an error.
+ (This case is mainly meant to support domain receive functions, which
+ might need to reject NULL inputs.)
+ Similarly, the optional
+ send_function converts
+ from the internal representation to the external binary representation.
+ If this function is not supplied, the type cannot participate in binary
+ output. The send function must be
+ declared as taking one argument of the new data type.
+ The send function must return type bytea.
+ Send functions are not invoked for NULL values.
+
+ You should at this point be wondering how the input and output functions
+ can be declared to have results or arguments of the new type, when they
+ have to be created before the new type can be created. The answer is that
+ the type should first be defined as a shell type, which is a
+ placeholder type that has no properties except a name and an owner. This
+ is done by issuing the command CREATE TYPE
+ name, with no additional parameters. Then the
+ C I/O functions can be defined referencing the shell type. Finally,
+ CREATE TYPE with a full definition replaces the shell entry
+ with a complete, valid type definition, after which the new type can be
+ used normally.
+
+ The optional
+ type_modifier_input_function
+ and type_modifier_output_function
+ are needed if the type supports modifiers, that is optional constraints
+ attached to a type declaration, such as char(5) or
+ numeric(30,2). PostgreSQL allows
+ user-defined types to take one or more simple constants or identifiers as
+ modifiers. However, this information must be capable of being packed into a
+ single non-negative integer value for storage in the system catalogs. The
+ type_modifier_input_function
+ is passed the declared modifier(s) in the form of a cstring
+ array. It must check the values for validity (throwing an error if they
+ are wrong), and if they are correct, return a single non-negative
+ integer value that will be stored as the column “typmod”.
+ Type modifiers will be rejected if the type does not have a
+ type_modifier_input_function.
+ The type_modifier_output_function
+ converts the internal integer typmod value back to the correct form for
+ user display. It must return a cstring value that is the exact
+ string to append to the type name; for example numeric's
+ function might return (30,2).
+ It is allowed to omit the
+ type_modifier_output_function,
+ in which case the default display format is just the stored typmod integer
+ value enclosed in parentheses.
+
+ The optional analyze_function
+ performs type-specific statistics collection for columns of the data type.
+ By default, ANALYZE will attempt to gather statistics using
+ the type's “equals” and “less-than” operators, if there
+ is a default b-tree operator class for the type. For non-scalar types
+ this behavior is likely to be unsuitable, so it can be overridden by
+ specifying a custom analysis function. The analysis function must be
+ declared to take a single argument of type internal, and return
+ a boolean result. The detailed API for analysis functions appears
+ in src/include/commands/vacuum.h.
+
+ The optional subscript_function
+ allows the data type to be subscripted in SQL commands. Specifying this
+ function does not cause the type to be considered a “true”
+ array type; for example, it will not be a candidate for the result type
+ of ARRAY[] constructs. But if subscripting a value
+ of the type is a natural notation for extracting data from it, then
+ a subscript_function can
+ be written to define what that means. The subscript function must be
+ declared to take a single argument of type internal, and
+ return an internal result, which is a pointer to a struct
+ of methods (functions) that implement subscripting.
+ The detailed API for subscript functions appears
+ in src/include/nodes/subscripting.h.
+ It may also be useful to read the array implementation
+ in src/backend/utils/adt/arraysubs.c,
+ or the simpler code
+ in contrib/hstore/hstore_subs.c.
+ Additional information appears in
+ Array Types below.
+
+ While the details of the new type's internal representation are only
+ known to the I/O functions and other functions you create to work with
+ the type, there are several properties of the internal representation
+ that must be declared to PostgreSQL.
+ Foremost of these is
+ internallength.
+ Base data types can be fixed-length, in which case
+ internallength is a
+ positive integer, or variable-length, indicated by setting
+ internallength
+ to VARIABLE. (Internally, this is represented
+ by setting typlen to -1.) The internal representation of all
+ variable-length types must start with a 4-byte integer giving the total
+ length of this value of the type. (Note that the length field is often
+ encoded, as described in Section 73.2; it's unwise
+ to access it directly.)
+
+ The optional flag PASSEDBYVALUE indicates that
+ values of this data type are passed by value, rather than by
+ reference. Types passed by value must be fixed-length, and their internal
+ representation cannot be larger than the size of the Datum type
+ (4 bytes on some machines, 8 bytes on others).
+
+ The alignment parameter
+ specifies the storage alignment required for the data type. The
+ allowed values equate to alignment on 1, 2, 4, or 8 byte boundaries.
+ Note that variable-length types must have an alignment of at least
+ 4, since they necessarily contain an int4 as their first component.
+
+ The storage parameter
+ allows selection of storage strategies for variable-length data
+ types. (Only plain is allowed for fixed-length
+ types.) plain specifies that data of the type
+ will always be stored in-line and not compressed.
+ extended specifies that the system will first
+ try to compress a long data value, and will move the value out of
+ the main table row if it's still too long.
+ external allows the value to be moved out of the
+ main table, but the system will not try to compress it.
+ main allows compression, but discourages moving
+ the value out of the main table. (Data items with this storage
+ strategy might still be moved out of the main table if there is no
+ other way to make a row fit, but they will be kept in the main
+ table preferentially over extended and
+ external items.)
+
+ All storage values other
+ than plain imply that the functions of the data type
+ can handle values that have been toasted, as described
+ in Section 73.2 and Section 38.13.1.
+ The specific other value given merely determines the default TOAST
+ storage strategy for columns of a toastable data type; users can pick
+ other strategies for individual columns using ALTER TABLE
+ SET STORAGE.
+
+ The like_type parameter
+ provides an alternative method for specifying the basic representation
+ properties of a data type: copy them from some existing type. The values of
+ internallength,
+ passedbyvalue,
+ alignment, and
+ storage are copied from the
+ named type. (It is possible, though usually undesirable, to override
+ some of these values by specifying them along with the LIKE
+ clause.) Specifying representation this way is especially useful when
+ the low-level implementation of the new type “piggybacks” on an
+ existing type in some fashion.
+
+ The category and
+ preferred parameters can be
+ used to help control which implicit cast will be applied in ambiguous
+ situations. Each data type belongs to a category named by a single ASCII
+ character, and each type is either “preferred” or not within its
+ category. The parser will prefer casting to preferred types (but only from
+ other types within the same category) when this rule is helpful in
+ resolving overloaded functions or operators. For more details see Chapter 10. For types that have no implicit casts to or from any
+ other types, it is sufficient to leave these settings at the defaults.
+ However, for a group of related types that have implicit casts, it is often
+ helpful to mark them all as belonging to a category and select one or two
+ of the “most general” types as being preferred within the category.
+ The category parameter is
+ especially useful when adding a user-defined type to an existing built-in
+ category, such as the numeric or string types. However, it is also
+ possible to create new entirely-user-defined type categories. Select any
+ ASCII character other than an upper-case letter to name such a category.
+
+ A default value can be specified, in case a user wants columns of the
+ data type to default to something other than the null value.
+ Specify the default with the DEFAULT key word.
+ (Such a default can be overridden by an explicit DEFAULT
+ clause attached to a particular column.)
+
+ To indicate that a type is a fixed-length array type,
+ specify the type of the array
+ elements using the ELEMENT key word. For example, to
+ define an array of 4-byte integers (int4), specify
+ ELEMENT = int4. For more details,
+ see Array Types below.
+
+ To indicate the delimiter to be used between values in the external
+ representation of arrays of this type, delimiter can be
+ set to a specific character. The default delimiter is the comma
+ (,). Note that the delimiter is associated
+ with the array element type, not the array type itself.
+
+ If the optional Boolean
+ parameter collatable
+ is true, column definitions and expressions of the type may carry
+ collation information through use of
+ the COLLATE clause. It is up to the
+ implementations of the functions operating on the type to actually
+ make use of the collation information; this does not happen
+ automatically merely by marking the type collatable.
+
Array Types
+ Whenever a user-defined type is created,
+ PostgreSQL automatically creates an
+ associated array type, whose name consists of the element type's
+ name prepended with an underscore, and truncated if necessary to keep
+ it less than NAMEDATALEN bytes long. (If the name
+ so generated collides with an existing type name, the process is
+ repeated until a non-colliding name is found.)
+ This implicitly-created array type is variable length and uses the
+ built-in input and output functions array_in and
+ array_out. Furthermore, this type is what the system
+ uses for constructs such as ARRAY[] over the
+ user-defined type. The array type tracks any changes in its
+ element type's owner or schema, and is dropped if the element type is.
+
+ You might reasonably ask why there is an ELEMENT
+ option, if the system makes the correct array type automatically.
+ The main case where it's useful to use ELEMENT is when you are
+ making a fixed-length type that happens to be internally an array of a number of
+ identical things, and you want to allow these things to be accessed
+ directly by subscripting, in addition to whatever operations you plan
+ to provide for the type as a whole. For example, type point
+ is represented as just two floating-point numbers, which can be accessed
+ using point[0] and point[1].
+ Note that
+ this facility only works for fixed-length types whose internal form
+ is exactly a sequence of identical fixed-length fields.
+ For historical reasons (i.e., this is clearly wrong but it's far too
+ late to change it), subscripting of fixed-length array types starts from
+ zero, rather than from one as for variable-length arrays.
+
+ Specifying the SUBSCRIPT option allows a data type to
+ be subscripted, even though the system does not otherwise regard it as
+ an array type. The behavior just described for fixed-length arrays is
+ actually implemented by the SUBSCRIPT handler
+ function raw_array_subscript_handler, which is
+ used automatically if you specify ELEMENT for a
+ fixed-length type without also writing SUBSCRIPT.
+
+ When specifying a custom SUBSCRIPT function, it is
+ not necessary to specify ELEMENT unless
+ the SUBSCRIPT handler function needs to
+ consult typelem to find out what to return.
+ Be aware that specifying ELEMENT causes the system to
+ assume that the new type contains, or is somehow physically dependent on,
+ the element type; thus for example changing properties of the element
+ type won't be allowed if there are any columns of the dependent type.
+
Parameters
name
+ The name (optionally schema-qualified) of a type to be created.
+
attribute_name
+ The name of an attribute (column) for the composite type.
+
data_type
+ The name of an existing data type to become a column of the
+ composite type.
+
collation
+ The name of an existing collation to be associated with a column of
+ a composite type, or with a range type.
+
label
+ A string literal representing the textual label associated with
+ one value of an enum type.
+
subtype
+ The name of the element type that the range type will represent ranges
+ of.
+
subtype_operator_class
+ The name of a b-tree operator class for the subtype.
+
canonical_function
+ The name of the canonicalization function for the range type.
+
subtype_diff_function
+ The name of a difference function for the subtype.
+
multirange_type_name
+ The name of the corresponding multirange type.
+
input_function
+ The name of a function that converts data from the type's
+ external textual form to its internal form.
+
output_function
+ The name of a function that converts data from the type's
+ internal form to its external textual form.
+
receive_function
+ The name of a function that converts data from the type's
+ external binary form to its internal form.
+
send_function
+ The name of a function that converts data from the type's
+ internal form to its external binary form.
+
type_modifier_input_function
+ The name of a function that converts an array of modifier(s) for the type
+ into internal form.
+
type_modifier_output_function
+ The name of a function that converts the internal form of the type's
+ modifier(s) to external textual form.
+
analyze_function
+ The name of a function that performs statistical analysis for the
+ data type.
+
subscript_function
+ The name of a function that defines what subscripting a value of the
+ data type does.
+
internallength
+ A numeric constant that specifies the length in bytes of the new
+ type's internal representation. The default assumption is that
+ it is variable-length.
+
alignment
+ The storage alignment requirement of the data type. If specified,
+ it must be char, int2,
+ int4, or double; the
+ default is int4.
+
storage
+ The storage strategy for the data type. If specified, must be
+ plain, external,
+ extended, or main; the
+ default is plain.
+
like_type
+ The name of an existing data type that the new type will have the
+ same representation as. The values of
+ internallength,
+ passedbyvalue,
+ alignment, and
+ storage
+ are copied from that type, unless overridden by explicit
+ specification elsewhere in this CREATE TYPE command.
+
category
+ The category code (a single ASCII character) for this type.
+ The default is 'U' for “user-defined type”.
+ Other standard category codes can be found in
+ Table 53.65. You may also choose
+ other ASCII characters in order to create custom categories.
+
preferred
+ True if this type is a preferred type within its type category,
+ else false. The default is false. Be very careful about creating
+ a new preferred type within an existing type category, as this
+ could cause surprising changes in behavior.
+
default
+ The default value for the data type. If this is omitted, the
+ default is null.
+
element
+ The type being created is an array; this specifies the type of
+ the array elements.
+
delimiter
+ The delimiter character to be used between values in arrays made
+ of this type.
+
collatable
+ True if this type's operations can use collation information.
+ The default is false.
+
Notes
+ Because there are no restrictions on use of a data type once it's been
+ created, creating a base type or range type is tantamount to granting
+ public execute permission on the functions mentioned in the type definition.
+ This is usually
+ not an issue for the sorts of functions that are useful in a type
+ definition. But you might want to think twice before designing a type
+ in a way that would require “secret” information to be used
+ while converting it to or from external form.
+
+ Before PostgreSQL version 8.3, the name of
+ a generated array type was always exactly the element type's name with one
+ underscore character (_) prepended. (Type names were
+ therefore restricted in length to one fewer character than other names.)
+ While this is still usually the case, the array type name may vary from
+ this in case of maximum-length names or collisions with user type names
+ that begin with underscore. Writing code that depends on this convention
+ is therefore deprecated. Instead, use
+ pg_type.typarray to locate the array type
+ associated with a given type.
+
+ It may be advisable to avoid using type and table names that begin with
+ underscore. While the server will change generated array type names to
+ avoid collisions with user-given names, there is still risk of confusion,
+ particularly with old client software that may assume that type names
+ beginning with underscores always represent arrays.
+
+ Before PostgreSQL version 8.2, the shell-type
+ creation syntax
+ CREATE TYPE name did not exist.
+ The way to create a new base type was to create its input function first.
+ In this approach, PostgreSQL will first see
+ the name of the new data type as the return type of the input function.
+ The shell type is implicitly created in this situation, and then it
+ can be referenced in the definitions of the remaining I/O functions.
+ This approach still works, but is deprecated and might be disallowed in
+ some future release. Also, to avoid accidentally cluttering
+ the catalogs with shell types as a result of simple typos in function
+ definitions, a shell type will only be made this way when the input
+ function is written in C.
+
+ In PostgreSQL version 16 and later,
+ it is desirable for base types' input functions to
+ return “soft” errors using the
+ new errsave()/ereturn()
+ mechanism, rather than throwing ereport()
+ exceptions as in previous versions.
+ See src/backend/utils/fmgr/README for more
+ information.
+
Examples
+ This example creates a composite type and uses it in
+ a function definition:
+
+CREATE TYPE compfoo AS (f1 int, f2 text);
+
+CREATE FUNCTION getfoo() RETURNS SETOF compfoo AS $$
+ SELECT fooid, fooname FROM foo
+$$ LANGUAGE SQL;
+
+
+ This example creates an enumerated type and uses it in
+ a table definition:
+
+CREATE TYPE bug_status AS ENUM ('new', 'open', 'closed');
+
+CREATE TABLE bug (
+ id serial,
+ description text,
+ status bug_status
+);
+
+
+ This example creates a range type:
+
+CREATE TYPE float8_range AS RANGE (subtype = float8, subtype_diff = float8mi);
+
+
+ This example creates the base data type box and then uses the
+ type in a table definition:
+
+CREATE TYPE box;
+
+CREATE FUNCTION my_box_in_function(cstring) RETURNS box AS ... ;
+CREATE FUNCTION my_box_out_function(box) RETURNS cstring AS ... ;
+
+CREATE TYPE box (
+ INTERNALLENGTH = 16,
+ INPUT = my_box_in_function,
+ OUTPUT = my_box_out_function
+);
+
+CREATE TABLE myboxes (
+ id integer,
+ description box
+);
+
+
+ If the internal structure of box were an array of four
+ float4 elements, we might instead use:
+
+CREATE TYPE box (
+ INTERNALLENGTH = 16,
+ INPUT = my_box_in_function,
+ OUTPUT = my_box_out_function,
+ ELEMENT = float4
+);
+
+ which would allow a box value's component numbers to be accessed
+ by subscripting. Otherwise the type behaves the same as before.
+
+ This example creates a large object type and uses it in
+ a table definition:
+
+CREATE TYPE bigobj (
+ INPUT = lo_filein, OUTPUT = lo_fileout,
+ INTERNALLENGTH = VARIABLE
+);
+CREATE TABLE big_objs (
+ id integer,
+ obj bigobj
+);
+
+
+ More examples, including suitable input and output functions, are
+ in Section 38.13.
+
Compatibility
+ The first form of the CREATE TYPE command, which
+ creates a composite type, conforms to the SQL standard.
+ The other forms are PostgreSQL
+ extensions. The CREATE TYPE statement in
+ the SQL standard also defines other forms that are not
+ implemented in PostgreSQL.
+
+ The ability to create a composite type with zero attributes is
+ a PostgreSQL-specific deviation from the
+ standard (analogous to the same case in CREATE TABLE).
+
CREATE USER
CREATE USER — define a new database role
Synopsis
+CREATE USER name [ [ WITH ] option [ ... ] ]
+
+where option can be:
+
+ SUPERUSER | NOSUPERUSER
+ | CREATEDB | NOCREATEDB
+ | CREATEROLE | NOCREATEROLE
+ | INHERIT | NOINHERIT
+ | LOGIN | NOLOGIN
+ | REPLICATION | NOREPLICATION
+ | BYPASSRLS | NOBYPASSRLS
+ | CONNECTION LIMIT connlimit
+ | [ ENCRYPTED ] PASSWORD 'password' | PASSWORD NULL
+ | VALID UNTIL 'timestamp'
+ | IN ROLE role_name [, ...]
+ | IN GROUP role_name [, ...]
+ | ROLE role_name [, ...]
+ | ADMIN role_name [, ...]
+ | USER role_name [, ...]
+ | SYSID uid
+
Description
+ CREATE USER is now an alias for
+ CREATE ROLE.
+ The only difference is that when the command is spelled
+ CREATE USER, LOGIN is assumed
+ by default, whereas NOLOGIN is assumed when
+ the command is spelled
+ CREATE ROLE.
+
Compatibility
+ The CREATE USER statement is a
+ PostgreSQL extension. The SQL standard
+ leaves the definition of users to the implementation.
+
CREATE USER MAPPING
CREATE USER MAPPING — define a new mapping of a user to a foreign server
Synopsis
+CREATE USER MAPPING [ IF NOT EXISTS ] FOR { user_name | USER | CURRENT_ROLE | CURRENT_USER | PUBLIC }
+ SERVER server_name
+ [ OPTIONS ( option 'value' [ , ... ] ) ]
+Description
+ CREATE USER MAPPING defines a mapping of a user
+ to a foreign server. A user mapping typically encapsulates
+ connection information that a foreign-data wrapper uses together
+ with the information encapsulated by a foreign server to access an
+ external data resource.
+
+ The owner of a foreign server can create user mappings for that
+ server for any user. Also, a user can create a user mapping for
+ their own user name if USAGE privilege on the server has
+ been granted to the user.
+
Parameters
IF NOT EXISTS
+ Do not throw an error if a mapping of the given user to the given foreign
+ server already exists. A notice is issued in this case. Note that there
+ is no guarantee that the existing user mapping is anything like the one
+ that would have been created.
+
user_name
+ The name of an existing user that is mapped to foreign server.
+ CURRENT_ROLE, CURRENT_USER, and USER match the name of
+ the current user. When PUBLIC is specified, a
+ so-called public mapping is created that is used when no
+ user-specific mapping is applicable.
+
server_name
+ The name of an existing server for which the user mapping is
+ to be created.
+
OPTIONS ( option 'value' [, ... ] )
+ This clause specifies the options of the user mapping. The
+ options typically define the actual user name and password of
+ the mapping. Option names must be unique. The allowed option
+ names and values are specific to the server's foreign-data wrapper.
+
Examples
+ Create a user mapping for user bob, server foo:
+
+CREATE USER MAPPING FOR bob SERVER foo OPTIONS (user 'bob', password 'secret');
+
Compatibility
+ CREATE USER MAPPING conforms to ISO/IEC 9075-9 (SQL/MED).
+
CREATE VIEW
CREATE VIEW — define a new view
Synopsis
+CREATE [ OR REPLACE ] [ TEMP | TEMPORARY ] [ RECURSIVE ] VIEW name [ ( column_name [, ...] ) ]
+ [ WITH ( view_option_name [= view_option_value] [, ... ] ) ]
+ AS query
+ [ WITH [ CASCADED | LOCAL ] CHECK OPTION ]
+
Description
+ CREATE VIEW defines a view of a query. The view
+ is not physically materialized. Instead, the query is run every time
+ the view is referenced in a query.
+
+ CREATE OR REPLACE VIEW is similar, but if a view
+ of the same name already exists, it is replaced. The new query must
+ generate the same columns that were generated by the existing view query
+ (that is, the same column names in the same order and with the same data
+ types), but it may add additional columns to the end of the list. The
+ calculations giving rise to the output columns may be completely different.
+
+ If a schema name is given (for example, CREATE VIEW
+ myschema.myview ...) then the view is created in the specified
+ schema. Otherwise it is created in the current schema. Temporary
+ views exist in a special schema, so a schema name cannot be given
+ when creating a temporary view. The name of the view must be
+ distinct from the name of any other relation (table, sequence, index, view,
+ materialized view, or foreign table) in the same schema.
+
Parameters
TEMPORARY or TEMP
+ If specified, the view is created as a temporary view.
+ Temporary views are automatically dropped at the end of the
+ current session. Existing
+ permanent relations with the same name are not visible to the
+ current session while the temporary view exists, unless they are
+ referenced with schema-qualified names.
+
+ If any of the tables referenced by the view are temporary,
+ the view is created as a temporary view (whether
+ TEMPORARY is specified or not).
+
RECURSIVE
+
+
+ Creates a recursive view. The syntax
+
+CREATE RECURSIVE VIEW [ schema . ] view_name (column_names) AS SELECT ...;
+
+ is equivalent to
+
+CREATE VIEW [ schema . ] view_name AS WITH RECURSIVE view_name (column_names) AS (SELECT ...) SELECT column_names FROM view_name;
+
+ A view column name list must be specified for a recursive view.
+
name
+ The name (optionally schema-qualified) of a view to be created.
+
column_name
+ An optional list of names to be used for columns of the view.
+ If not given, the column names are deduced from the query.
+
WITH ( view_option_name [= view_option_value] [, ... ] )
+ This clause specifies optional parameters for a view; the following
+ parameters are supported:
+
+
check_option (enum)
+ This parameter may be either local or
+ cascaded, and is equivalent to specifying
+ WITH [ CASCADED | LOCAL ] CHECK OPTION (see below).
+
security_barrier (boolean)
+ This should be used if the view is intended to provide row-level
+ security. See Section 41.5 for full details.
+
security_invoker (boolean)
+ This option causes the underlying base relations to be checked
+ against the privileges of the user of the view rather than the view
+ owner. See the notes below for full details.
+
+
+ All of the above options can be changed on existing views using ALTER VIEW.
+
query
+ A SELECT or
+ VALUES command
+ which will provide the columns and rows of the view.
+
WITH [ CASCADED | LOCAL ] CHECK OPTION
+
+
+
+ This option controls the behavior of automatically updatable views. When
+ this option is specified, INSERT and UPDATE
+ commands on the view will be checked to ensure that new rows satisfy the
+ view-defining condition (that is, the new rows are checked to ensure that
+ they are visible through the view). If they are not, the update will be
+ rejected. If the CHECK OPTION is not specified,
+ INSERT and UPDATE commands on the view are
+ allowed to create rows that are not visible through the view. The
+ following check options are supported:
+
+
LOCAL
+ New rows are only checked against the conditions defined directly in
+ the view itself. Any conditions defined on underlying base views are
+ not checked (unless they also specify the CHECK OPTION).
+
CASCADED
+ New rows are checked against the conditions of the view and all
+ underlying base views. If the CHECK OPTION is specified,
+ and neither LOCAL nor CASCADED is specified,
+ then CASCADED is assumed.
+
+
+ The CHECK OPTION may not be used with RECURSIVE
+ views.
+
+ Note that the CHECK OPTION is only supported on views that
+ are automatically updatable, and do not have INSTEAD OF
+ triggers or INSTEAD rules. If an automatically updatable
+ view is defined on top of a base view that has INSTEAD OF
+ triggers, then the LOCAL CHECK OPTION may be used to check
+ the conditions on the automatically updatable view, but the conditions
+ on the base view with INSTEAD OF triggers will not be
+ checked (a cascaded check option will not cascade down to a
+ trigger-updatable view, and any check options defined directly on a
+ trigger-updatable view will be ignored). If the view or any of its base
+ relations has an INSTEAD rule that causes the
+ INSERT or UPDATE command to be rewritten, then
+ all check options will be ignored in the rewritten query, including any
+ checks from automatically updatable views defined on top of the relation
+ with the INSTEAD rule.
+
Notes
+ Use the DROP VIEW
+ statement to drop views.
+
+ Be careful that the names and types of the view's columns will be
+ assigned the way you want. For example:
+
+CREATE VIEW vista AS SELECT 'Hello World';
+
+ is bad form because the column name defaults to ?column?;
+ also, the column data type defaults to text, which might not
+ be what you wanted. Better style for a string literal in a view's
+ result is something like:
+
+CREATE VIEW vista AS SELECT text 'Hello World' AS hello;
+
+
+ By default, access to the underlying base relations referenced in the view
+ is determined by the permissions of the view owner. In some cases, this
+ can be used to provide secure but restricted access to the underlying
+ tables. However, not all views are secure against tampering; see Section 41.5 for details.
+
+ If the view has the security_invoker property set to
+ true, access to the underlying base relations is
+ determined by the permissions of the user executing the query, rather than
+ the view owner. Thus, the user of a security invoker view must have the
+ relevant permissions on the view and its underlying base relations.
+
+ If any of the underlying base relations is a security invoker view, it
+ will be treated as if it had been accessed directly from the original
+ query. Thus, a security invoker view will always check its underlying
+ base relations using the permissions of the current user, even if it is
+ accessed from a view without the security_invoker
+ property.
+
+ If any of the underlying base relations has
+ row-level security enabled, then
+ by default, the row-level security policies of the view owner are applied,
+ and access to any additional relations referred to by those policies is
+ determined by the permissions of the view owner. However, if the view has
+ security_invoker set to true, then
+ the policies and permissions of the invoking user are used instead, as if
+ the base relations had been referenced directly from the query using the
+ view.
+
+ Functions called in the view are treated the same as if they had been
+ called directly from the query using the view. Therefore, the user of
+ a view must have permissions to call all functions used by the view.
+ Functions in the view are executed with the privileges of the user
+ executing the query or the function owner, depending on whether the
+ functions are defined as SECURITY INVOKER or
+ SECURITY DEFINER. Thus, for example, calling
+ CURRENT_USER directly in a view will always return the
+ invoking user, not the view owner. This is not affected by the view's
+ security_invoker setting, and so a view with
+ security_invoker set to false is
+ not equivalent to a
+ SECURITY DEFINER function and those concepts should not
+ be confused.
+
+ The user creating or replacing a view must have USAGE
+ privileges on any schemas referred to in the view query, in order to look
+ up the referenced objects in those schemas. Note, however, that this
+ lookup only happens when the view is created or replaced. Therefore, the
+ user of the view only requires the USAGE privilege on
+ the schema containing the view, not on the schemas referred to in the view
+ query, even for a security invoker view.
+
+ When CREATE OR REPLACE VIEW is used on an existing
+ view, only the view's defining SELECT rule, plus any
+ WITH ( ... ) parameters and its
+ CHECK OPTION are changed.
+ Other view properties, including ownership, permissions, and non-SELECT
+ rules, remain unchanged. You must own the view
+ to replace it (this includes being a member of the owning role).
+
Updatable Views
+ Simple views are automatically updatable: the system will allow
+ INSERT, UPDATE and DELETE statements
+ to be used on the view in the same way as on a regular table. A view is
+ automatically updatable if it satisfies all of the following conditions:
+
+
+ The view must have exactly one entry in its FROM list,
+ which must be a table or another updatable view.
+
+ The view definition must not contain WITH,
+ DISTINCT, GROUP BY, HAVING,
+ LIMIT, or OFFSET clauses at the top level.
+
+ The view definition must not contain set operations (UNION,
+ INTERSECT or EXCEPT) at the top level.
+
+ The view's select list must not contain any aggregates, window functions
+ or set-returning functions.
+
+
+ An automatically updatable view may contain a mix of updatable and
+ non-updatable columns. A column is updatable if it is a simple reference
+ to an updatable column of the underlying base relation; otherwise the
+ column is read-only, and an error will be raised if an INSERT
+ or UPDATE statement attempts to assign a value to it.
+
+ If the view is automatically updatable the system will convert any
+ INSERT, UPDATE or DELETE statement
+ on the view into the corresponding statement on the underlying base
+ relation. INSERT statements that have an ON
+ CONFLICT UPDATE clause are fully supported.
+
+ If an automatically updatable view contains a WHERE
+ condition, the condition restricts which rows of the base relation are
+ available to be modified by UPDATE and DELETE
+ statements on the view. However, an UPDATE is allowed to
+ change a row so that it no longer satisfies the WHERE
+ condition, and thus is no longer visible through the view. Similarly,
+ an INSERT command can potentially insert base-relation rows
+ that do not satisfy the WHERE condition and thus are not
+ visible through the view (ON CONFLICT UPDATE may
+ similarly affect an existing row not visible through the view).
+ The CHECK OPTION may be used to prevent
+ INSERT and UPDATE commands from creating
+ such rows that are not visible through the view.
+
+ If an automatically updatable view is marked with the
+ security_barrier property then all the view's WHERE
+ conditions (and any conditions using operators which are marked as LEAKPROOF)
+ will always be evaluated before any conditions that a user of the view has
+ added. See Section 41.5 for full details. Note that,
+ due to this, rows which are not ultimately returned (because they do not
+ pass the user's WHERE conditions) may still end up being locked.
+ EXPLAIN can be used to see which conditions are
+ applied at the relation level (and therefore do not lock rows) and which are
+ not.
+
+ A more complex view that does not satisfy all these conditions is
+ read-only by default: the system will not allow an insert, update, or
+ delete on the view. You can get the effect of an updatable view by
+ creating INSTEAD OF triggers on the view, which must
+ convert attempted inserts, etc. on the view into appropriate actions
+ on other tables. For more information see CREATE TRIGGER. Another possibility is to create rules
+ (see CREATE RULE), but in practice triggers are
+ easier to understand and use correctly.
+
+ Note that the user performing the insert, update or delete on the view
+ must have the corresponding insert, update or delete privilege on the
+ view. In addition, by default, the view's owner must have the relevant
+ privileges on the underlying base relations, whereas the user performing
+ the update does not need any permissions on the underlying base relations
+ (see Section 41.5). However, if the view has
+ security_invoker set to true, the
+ user performing the update, rather than the view owner, must have the
+ relevant privileges on the underlying base relations.
+
Examples
+ Create a view consisting of all comedy films:
+
+
+CREATE VIEW comedies AS
+ SELECT *
+ FROM films
+ WHERE kind = 'Comedy';
+
+ This will create a view containing the columns that are in the
+ film table at the time of view creation. Though
+ * was used to create the view, columns added later to
+ the table will not be part of the view.
+
+ Create a view with LOCAL CHECK OPTION:
+
+
+CREATE VIEW universal_comedies AS
+ SELECT *
+ FROM comedies
+ WHERE classification = 'U'
+ WITH LOCAL CHECK OPTION;
+
+ This will create a view based on the comedies view, showing
+ only films with kind = 'Comedy' and
+ classification = 'U'. Any attempt to INSERT or
+ UPDATE a row in the view will be rejected if the new row
+ doesn't have classification = 'U', but the film
+ kind will not be checked.
+
+ Create a view with CASCADED CHECK OPTION:
+
+
+CREATE VIEW pg_comedies AS
+ SELECT *
+ FROM comedies
+ WHERE classification = 'PG'
+ WITH CASCADED CHECK OPTION;
+
+ This will create a view that checks both the kind and
+ classification of new rows.
+
+ Create a view with a mix of updatable and non-updatable columns:
+
+
+CREATE VIEW comedies AS
+ SELECT f.*,
+ country_code_to_name(f.country_code) AS country,
+ (SELECT avg(r.rating)
+ FROM user_ratings r
+ WHERE r.film_id = f.id) AS avg_rating
+ FROM films f
+ WHERE f.kind = 'Comedy';
+
+ This view will support INSERT, UPDATE and
+ DELETE. All the columns from the films table will
+ be updatable, whereas the computed columns country and
+ avg_rating will be read-only.
+
+ Create a recursive view consisting of the numbers from 1 to 100:
+
+CREATE RECURSIVE VIEW public.nums_1_100 (n) AS
+ VALUES (1)
+UNION ALL
+ SELECT n+1 FROM nums_1_100 WHERE n < 100;
+
+ Notice that although the recursive view's name is schema-qualified in this
+ CREATE, its internal self-reference is not schema-qualified.
+ This is because the implicitly-created CTE's name cannot be
+ schema-qualified.
+
Compatibility
+ CREATE OR REPLACE VIEW is a
+ PostgreSQL language extension.
+ So is the concept of a temporary view.
+ The WITH ( ... ) clause is an extension as well, as are
+ security barrier views and security invoker views.
+
DEALLOCATE
DEALLOCATE — deallocate a prepared statement
Synopsis
+DEALLOCATE [ PREPARE ] { name | ALL }
+Description
+ DEALLOCATE is used to deallocate a previously
+ prepared SQL statement. If you do not explicitly deallocate a
+ prepared statement, it is deallocated when the session ends.
+
+ For more information on prepared statements, see PREPARE.
+
Parameters
PREPARE
+ This key word is ignored.
+
name
+ The name of the prepared statement to deallocate.
+
ALL
+ Deallocate all prepared statements.
+
Compatibility
+ The SQL standard includes a DEALLOCATE
+ statement, but it is only for use in embedded SQL.
+
DECLARE
DECLARE — define a cursor
Synopsis
+DECLARE name [ BINARY ] [ ASENSITIVE | INSENSITIVE ] [ [ NO ] SCROLL ]
+ CURSOR [ { WITH | WITHOUT } HOLD ] FOR query
+
Description
+ DECLARE allows a user to create cursors, which
+ can be used to retrieve
+ a small number of rows at a time out of a larger query.
+ After the cursor is created, rows are fetched from it using
+ FETCH.
+
Note
+ This page describes usage of cursors at the SQL command level.
+ If you are trying to use cursors inside a PL/pgSQL
+ function, the rules are different —
+ see Section 43.7.
+
Parameters
name
+ The name of the cursor to be created.
+ This must be different from any other active cursor name in the
+ session.
+
BINARY
+ Causes the cursor to return data in binary rather than in text format.
+
ASENSITIVE
INSENSITIVE
+ Cursor sensitivity determines whether changes to the data underlying the
+ cursor, done in the same transaction, after the cursor has been
+ declared, are visible in the cursor. INSENSITIVE
+ means they are not visible, ASENSITIVE means the
+ behavior is implementation-dependent. A third behavior,
+ SENSITIVE, meaning that such changes are visible in
+ the cursor, is not available in PostgreSQL.
+ In PostgreSQL, all cursors are insensitive;
+ so these key words have no effect and are only accepted for
+ compatibility with the SQL standard.
+
+ Specifying INSENSITIVE together with FOR
+ UPDATE or FOR SHARE is an error.
+
SCROLL
NO SCROLLSCROLL specifies that the cursor can be used
+ to retrieve rows in a nonsequential fashion (e.g.,
+ backward). Depending upon the complexity of the query's
+ execution plan, specifying SCROLL might impose
+ a performance penalty on the query's execution time.
+ NO SCROLL specifies that the cursor cannot be
+ used to retrieve rows in a nonsequential fashion. The default is to
+ allow scrolling in some cases; this is not the same as specifying
+ SCROLL. See Notes
+ below for details.
+
WITH HOLD
WITHOUT HOLDWITH HOLD specifies that the cursor can
+ continue to be used after the transaction that created it
+ successfully commits. WITHOUT HOLD specifies
+ that the cursor cannot be used outside of the transaction that
+ created it. If neither WITHOUT HOLD nor
+ WITH HOLD is specified, WITHOUT
+ HOLD is the default.
+
query
+ A SELECT or
+ VALUES command
+ which will provide the rows to be returned by the cursor.
+
+ The key words ASENSITIVE, BINARY,
+ INSENSITIVE, and SCROLL can
+ appear in any order.
+
Notes
+ Normal cursors return data in text format, the same as a
+ SELECT would produce. The BINARY option
+ specifies that the cursor should return data in binary format.
+ This reduces conversion effort for both the server and client,
+ at the cost of more programmer effort to deal with platform-dependent
+ binary data formats.
+ As an example, if a query returns a value of one from an integer column,
+ you would get a string of 1 with a default cursor,
+ whereas with a binary cursor you would get
+ a 4-byte field containing the internal representation of the value
+ (in big-endian byte order).
+
+ Binary cursors should be used carefully. Many applications,
+ including psql, are not prepared to
+ handle binary cursors and expect data to come back in the text
+ format.
+
Note
+ When the client application uses the “extended query” protocol
+ to issue a FETCH command, the Bind protocol message
+ specifies whether data is to be retrieved in text or binary format.
+ This choice overrides the way that the cursor is defined. The concept
+ of a binary cursor as such is thus obsolete when using extended query
+ protocol — any cursor can be treated as either text or binary.
+
+ Unless WITH HOLD is specified, the cursor
+ created by this command can only be used within the current
+ transaction. Thus, DECLARE without WITH
+ HOLD is useless outside a transaction block: the cursor would
+ survive only to the completion of the statement. Therefore
+ PostgreSQL reports an error if such a
+ command is used outside a transaction block.
+ Use
+ BEGIN and
+ COMMIT
+ (or ROLLBACK)
+ to define a transaction block.
+
+ If WITH HOLD is specified and the transaction
+ that created the cursor successfully commits, the cursor can
+ continue to be accessed by subsequent transactions in the same
+ session. (But if the creating transaction is aborted, the cursor
+ is removed.) A cursor created with WITH HOLD
+ is closed when an explicit CLOSE command is
+ issued on it, or the session ends. In the current implementation,
+ the rows represented by a held cursor are copied into a temporary
+ file or memory area so that they remain available for subsequent
+ transactions.
+
+ WITH HOLD may not be specified when the query
+ includes FOR UPDATE or FOR SHARE.
+
+ The SCROLL option should be specified when defining a
+ cursor that will be used to fetch backwards. This is required by
+ the SQL standard. However, for compatibility with earlier
+ versions, PostgreSQL will allow
+ backward fetches without SCROLL, if the cursor's query
+ plan is simple enough that no extra overhead is needed to support
+ it. However, application developers are advised not to rely on
+ using backward fetches from a cursor that has not been created
+ with SCROLL. If NO SCROLL is
+ specified, then backward fetches are disallowed in any case.
+
+ Backward fetches are also disallowed when the query
+ includes FOR UPDATE or FOR SHARE; therefore
+ SCROLL may not be specified in this case.
+
Caution
+ Scrollable cursors may give unexpected
+ results if they invoke any volatile functions (see Section 38.7). When a previously fetched row is
+ re-fetched, the functions might be re-executed, perhaps leading to
+ results different from the first time. It's best to
+ specify NO SCROLL for a query involving volatile
+ functions. If that is not practical, one workaround
+ is to declare the cursor SCROLL WITH HOLD and commit the
+ transaction before reading any rows from it. This will force the
+ entire output of the cursor to be materialized in temporary storage,
+ so that volatile functions are executed exactly once for each row.
+
+ If the cursor's query includes FOR UPDATE or FOR
+ SHARE, then returned rows are locked at the time they are first
+ fetched, in the same way as for a regular
+ SELECT command with
+ these options.
+ In addition, the returned rows will be the most up-to-date versions.
+
Caution
+ It is generally recommended to use FOR UPDATE if the cursor
+ is intended to be used with UPDATE ... WHERE CURRENT OF or
+ DELETE ... WHERE CURRENT OF. Using FOR UPDATE
+ prevents other sessions from changing the rows between the time they are
+ fetched and the time they are updated. Without FOR UPDATE,
+ a subsequent WHERE CURRENT OF command will have no effect if
+ the row was changed since the cursor was created.
+
+ Another reason to use FOR UPDATE is that without it, a
+ subsequent WHERE CURRENT OF might fail if the cursor query
+ does not meet the SQL standard's rules for being “simply
+ updatable” (in particular, the cursor must reference just one table
+ and not use grouping or ORDER BY). Cursors
+ that are not simply updatable might work, or might not, depending on plan
+ choice details; so in the worst case, an application might work in testing
+ and then fail in production. If FOR UPDATE is
+ specified, the cursor is guaranteed to be updatable.
+
+ The main reason not to use FOR UPDATE with WHERE
+ CURRENT OF is if you need the cursor to be scrollable, or to be
+ isolated from concurrent updates (that is, continue to show the old
+ data). If this is a requirement, pay close heed to the caveats shown
+ above.
+
+ The SQL standard only makes provisions for cursors in embedded
+ SQL. The PostgreSQL
+ server does not implement an OPEN statement for
+ cursors; a cursor is considered to be open when it is declared.
+ However, ECPG, the embedded SQL
+ preprocessor for PostgreSQL, supports
+ the standard SQL cursor conventions, including those involving
+ DECLARE and OPEN statements.
+
+ The server data structure underlying an open cursor is called a
+ portal. Portal names are exposed in the
+ client protocol: a client can fetch rows directly from an open
+ portal, if it knows the portal name. When creating a cursor with
+ DECLARE, the portal name is the same as the
+ cursor name.
+
+ You can see all available cursors by querying the pg_cursors
+ system view.
+
Examples
+ To declare a cursor:
+
+DECLARE liahona CURSOR FOR SELECT * FROM films;
+
+ See FETCH for more
+ examples of cursor usage.
+
Compatibility
+ The SQL standard allows cursors only in embedded
+ SQL and in modules. PostgreSQL
+ permits cursors to be used interactively.
+
+ According to the SQL standard, changes made to insensitive cursors by
+ UPDATE ... WHERE CURRENT OF and DELETE
+ ... WHERE CURRENT OF statements are visible in that same
+ cursor. PostgreSQL treats these statements like
+ all other data changing statements in that they are not visible in
+ insensitive cursors.
+
+ Binary cursors are a PostgreSQL
+ extension.
+
DELETE
DELETE — delete rows of a table
Synopsis
+[ WITH [ RECURSIVE ] with_query [, ...] ]
+DELETE FROM [ ONLY ] table_name [ * ] [ [ AS ] alias ]
+ [ USING from_item [, ...] ]
+ [ WHERE condition | WHERE CURRENT OF cursor_name ]
+ [ RETURNING * | output_expression [ [ AS ] output_name ] [, ...] ]
+
Description
+ DELETE deletes rows that satisfy the
+ WHERE clause from the specified table. If the
+ WHERE clause is absent, the effect is to delete
+ all rows in the table. The result is a valid, but empty table.
+
Tip
+ TRUNCATE provides a
+ faster mechanism to remove all rows from a table.
+
+ There are two ways to delete rows in a table using information
+ contained in other tables in the database: using sub-selects, or
+ specifying additional tables in the USING clause.
+ Which technique is more appropriate depends on the specific
+ circumstances.
+
+ The optional RETURNING clause causes DELETE
+ to compute and return value(s) based on each row actually deleted.
+ Any expression using the table's columns, and/or columns of other
+ tables mentioned in USING, can be computed.
+ The syntax of the RETURNING list is identical to that of the
+ output list of SELECT.
+
+ You must have the DELETE privilege on the table
+ to delete from it, as well as the SELECT
+ privilege for any table in the USING clause or
+ whose values are read in the condition.
+
Parameters
with_query
+ The WITH clause allows you to specify one or more
+ subqueries that can be referenced by name in the DELETE
+ query. See Section 7.8 and SELECT
+ for details.
+
table_name
+ The name (optionally schema-qualified) of the table to delete rows
+ from. If ONLY is specified before the table name,
+ matching rows are deleted from the named table only. If
+ ONLY is not specified, matching rows are also deleted
+ from any tables inheriting from the named table. Optionally,
+ * can be specified after the table name to explicitly
+ indicate that descendant tables are included.
+
alias
+ A substitute name for the target table. When an alias is
+ provided, it completely hides the actual name of the table. For
+ example, given DELETE FROM foo AS f, the remainder
+ of the DELETE statement must refer to this
+ table as f not foo.
+
from_item
+ A table expression allowing columns from other tables to appear
+ in the WHERE condition. This uses the same
+ syntax as the FROM
+ clause of a SELECT statement; for example, an alias
+ for the table name can be specified. Do not repeat the target
+ table as a from_item
+ unless you wish to set up a self-join (in which case it must appear
+ with an alias in the from_item).
+
condition
+ An expression that returns a value of type boolean.
+ Only rows for which this expression returns true
+ will be deleted.
+
cursor_name
+ The name of the cursor to use in a WHERE CURRENT OF
+ condition. The row to be deleted is the one most recently fetched
+ from this cursor. The cursor must be a non-grouping
+ query on the DELETE's target table.
+ Note that WHERE CURRENT OF cannot be
+ specified together with a Boolean condition. See
+ DECLARE
+ for more information about using cursors with
+ WHERE CURRENT OF.
+
output_expression
+ An expression to be computed and returned by the DELETE
+ command after each row is deleted. The expression can use any
+ column names of the table named by table_name
+ or table(s) listed in USING.
+ Write * to return all columns.
+
output_name
+ A name to use for a returned column.
+
Outputs
+ On successful completion, a DELETE command returns a command
+ tag of the form
+
+DELETE count
+
+ The count is the number
+ of rows deleted. Note that the number may be less than the number of
+ rows that matched the condition when deletes were
+ suppressed by a BEFORE DELETE trigger. If count is 0, no rows were deleted by
+ the query (this is not considered an error).
+
+ If the DELETE command contains a RETURNING
+ clause, the result will be similar to that of a SELECT
+ statement containing the columns and values defined in the
+ RETURNING list, computed over the row(s) deleted by the
+ command.
+
Notes
+ PostgreSQL lets you reference columns of
+ other tables in the WHERE condition by specifying the
+ other tables in the USING clause. For example,
+ to delete all films produced by a given producer, one can do:
+
+DELETE FROM films USING producers
+ WHERE producer_id = producers.id AND producers.name = 'foo';
+
+ What is essentially happening here is a join between films
+ and producers, with all successfully joined
+ films rows being marked for deletion.
+ This syntax is not standard. A more standard way to do it is:
+
+DELETE FROM films
+ WHERE producer_id IN (SELECT id FROM producers WHERE name = 'foo');
+
+ In some cases the join style is easier to write or faster to
+ execute than the sub-select style.
+
Examples
+ Delete all films but musicals:
+
+DELETE FROM films WHERE kind <> 'Musical';
+
+
+ Clear the table films:
+
+DELETE FROM films;
+
+
+ Delete completed tasks, returning full details of the deleted rows:
+
+DELETE FROM tasks WHERE status = 'DONE' RETURNING *;
+
+
+ Delete the row of tasks on which the cursor
+ c_tasks is currently positioned:
+
+DELETE FROM tasks WHERE CURRENT OF c_tasks;
+
Compatibility
+ This command conforms to the SQL standard, except
+ that the USING and RETURNING clauses
+ are PostgreSQL extensions, as is the ability
+ to use WITH with DELETE.
+
DISCARD
DISCARD — discard session state
Synopsis
+DISCARD { ALL | PLANS | SEQUENCES | TEMPORARY | TEMP }
+Description
+ DISCARD releases internal resources associated with a
+ database session. This command is useful for partially or fully
+ resetting the session's state. There are several subcommands to
+ release different types of resources; the DISCARD ALL
+ variant subsumes all the others, and also resets additional state.
+
Parameters
PLANS
+ Releases all cached query plans, forcing re-planning to occur
+ the next time the associated prepared statement is used.
+
SEQUENCES
+ Discards all cached sequence-related state,
+ including currval()/lastval()
+ information and any preallocated sequence values that have not
+ yet been returned by nextval().
+ (See CREATE SEQUENCE for a description of
+ preallocated sequence values.)
+
TEMPORARY or TEMP
+ Drops all temporary tables created in the current session.
+
ALL
+ Releases all temporary resources associated with the current
+ session and resets the session to its initial state.
+ Currently, this has the same effect as executing the following sequence
+ of statements:
+
+CLOSE ALL;
+SET SESSION AUTHORIZATION DEFAULT;
+RESET ALL;
+DEALLOCATE ALL;
+UNLISTEN *;
+SELECT pg_advisory_unlock_all();
+DISCARD PLANS;
+DISCARD TEMP;
+DISCARD SEQUENCES;
+
Notes
+ DISCARD ALL cannot be executed inside a transaction block.
+
Compatibility
+ DISCARD is a PostgreSQL extension.
+
DO
DO — execute an anonymous code block
Synopsis
+DO [ LANGUAGE lang_name ] code
+
Description
+ DO executes an anonymous code block, or in other
+ words a transient anonymous function in a procedural language.
+
+ The code block is treated as though it were the body of a function
+ with no parameters, returning void. It is parsed and
+ executed a single time.
+
+ The optional LANGUAGE clause can be written either
+ before or after the code block.
+
Parameters
code
+ The procedural language code to be executed. This must be specified
+ as a string literal, just as in CREATE FUNCTION.
+ Use of a dollar-quoted literal is recommended.
+
lang_name
+ The name of the procedural language the code is written in.
+ If omitted, the default is plpgsql.
+
Notes
+ The procedural language to be used must already have been installed
+ into the current database by means of CREATE EXTENSION.
+ plpgsql is installed by default, but other languages are not.
+
+ The user must have USAGE privilege for the procedural
+ language, or must be a superuser if the language is untrusted.
+ This is the same privilege requirement as for creating a function
+ in the language.
+
+ If DO is executed in a transaction block, then the
+ procedure code cannot execute transaction control statements. Transaction
+ control statements are only allowed if DO is executed in
+ its own transaction.
+
Examples
+ Grant all privileges on all views in schema public to
+ role webuser:
+
+DO $$DECLARE r record;
+BEGIN
+ FOR r IN SELECT table_schema, table_name FROM information_schema.tables
+ WHERE table_type = 'VIEW' AND table_schema = 'public'
+ LOOP
+ EXECUTE 'GRANT ALL ON ' || quote_ident(r.table_schema) || '.' || quote_ident(r.table_name) || ' TO webuser';
+ END LOOP;
+END$$;
+
Compatibility
+ There is no DO statement in the SQL standard.
+
DROP ACCESS METHOD
DROP ACCESS METHOD — remove an access method
Synopsis
+DROP ACCESS METHOD [ IF EXISTS ] name [ CASCADE | RESTRICT ]
+
Description
+ DROP ACCESS METHOD removes an existing access method.
+ Only superusers can drop access methods.
+
Parameters
IF EXISTS
+ Do not throw an error if the access method does not exist.
+ A notice is issued in this case.
+
name
+ The name of an existing access method.
+
CASCADE
+ Automatically drop objects that depend on the access method
+ (such as operator classes, operator families, and indexes),
+ and in turn all objects that depend on those objects
+ (see Section 5.14).
+
RESTRICT
+ Refuse to drop the access method if any objects depend on it.
+ This is the default.
+
Examples
+ Drop the access method heptree:
+
+DROP ACCESS METHOD heptree;
+
Compatibility
+ DROP ACCESS METHOD is a
+ PostgreSQL extension.
+
DROP OWNED
DROP OWNED — remove database objects owned by a database role
Synopsis
+DROP OWNED BY { name | CURRENT_ROLE | CURRENT_USER | SESSION_USER } [, ...] [ CASCADE | RESTRICT ]
+Description
+ DROP OWNED drops all the objects within the current
+ database that are owned by one of the specified roles. Any
+ privileges granted to the given roles on objects in the current
+ database or on shared objects (databases, tablespaces, configuration
+ parameters) will also be revoked.
+
Parameters
name
+ The name of a role whose objects will be dropped, and whose
+ privileges will be revoked.
+
CASCADE
+ Automatically drop objects that depend on the affected objects,
+ and in turn all objects that depend on those objects
+ (see Section 5.14).
+
RESTRICT
+ Refuse to drop the objects owned by a role if any other database
+ objects depend on one of the affected objects. This is the default.
+
Notes
+ DROP OWNED is often used to prepare for the
+ removal of one or more roles. Because DROP OWNED
+ only affects the objects in the current database, it is usually
+ necessary to execute this command in each database that contains
+ objects owned by a role that is to be removed.
+
+ Using the CASCADE option might make the command
+ recurse to objects owned by other users.
+
+ The REASSIGN OWNED command is an alternative that
+ reassigns the ownership of all the database objects owned by one or
+ more roles. However, REASSIGN OWNED does not deal with
+ privileges for other objects.
+
+ Databases and tablespaces owned by the role(s) will not be removed.
+
+ See Section 22.4 for more discussion.
+
Compatibility
+ The DROP OWNED command is a
+ PostgreSQL extension.
+
DROP AGGREGATE
DROP AGGREGATE — remove an aggregate function
Synopsis
+DROP AGGREGATE [ IF EXISTS ] name ( aggregate_signature ) [, ...] [ CASCADE | RESTRICT ]
+
+where aggregate_signature is:
+
+* |
+[ argmode ] [ argname ] argtype [ , ... ] |
+[ [ argmode ] [ argname ] argtype [ , ... ] ] ORDER BY [ argmode ] [ argname ] argtype [ , ... ]
+
Description
+ DROP AGGREGATE removes an existing
+ aggregate function. To execute this command the current
+ user must be the owner of the aggregate function.
+
Parameters
IF EXISTS
+ Do not throw an error if the aggregate does not exist. A notice is issued
+ in this case.
+
name
+ The name (optionally schema-qualified) of an existing aggregate function.
+
argmode
+ The mode of an argument: IN or VARIADIC.
+ If omitted, the default is IN.
+
argname
+ The name of an argument.
+ Note that DROP AGGREGATE does not actually pay
+ any attention to argument names, since only the argument data
+ types are needed to determine the aggregate function's identity.
+
argtype
+ An input data type on which the aggregate function operates.
+ To reference a zero-argument aggregate function, write *
+ in place of the list of argument specifications.
+ To reference an ordered-set aggregate function, write
+ ORDER BY between the direct and aggregated argument
+ specifications.
+
CASCADE
+ Automatically drop objects that depend on the aggregate function
+ (such as views using it),
+ and in turn all objects that depend on those objects
+ (see Section 5.14).
+
RESTRICT
+ Refuse to drop the aggregate function if any objects depend on
+ it. This is the default.
+
Notes
+ Alternative syntaxes for referencing ordered-set aggregates
+ are described under ALTER AGGREGATE.
+
Examples
+ To remove the aggregate function myavg for type
+ integer:
+
+DROP AGGREGATE myavg(integer);
+
+
+ To remove the hypothetical-set aggregate function myrank,
+ which takes an arbitrary list of ordering columns and a matching list
+ of direct arguments:
+
+DROP AGGREGATE myrank(VARIADIC "any" ORDER BY VARIADIC "any");
+
+
+ To remove multiple aggregate functions in one command:
+
+DROP AGGREGATE myavg(integer), myavg(bigint);
+
Compatibility
+ There is no DROP AGGREGATE statement in the SQL
+ standard.
+
DROP CAST
DROP CAST — remove a cast
Synopsis
+DROP CAST [ IF EXISTS ] (source_type AS target_type) [ CASCADE | RESTRICT ]
+
Description
+ DROP CAST removes a previously defined cast.
+
+ To be able to drop a cast, you must own the source or the target
+ data type. These are the same privileges that are required to
+ create a cast.
+
Parameters
IF EXISTS
+ Do not throw an error if the cast does not exist. A notice is issued
+ in this case.
+
source_type
+ The name of the source data type of the cast.
+
target_type
+ The name of the target data type of the cast.
+
CASCADE
RESTRICT
+ These key words do not have any effect, since there are no
+ dependencies on casts.
+
Examples
+ To drop the cast from type text to type int:
+
+DROP CAST (text AS int);
+
Compatibility
+ The DROP CAST command conforms to the SQL standard.
+
DROP COLLATION
DROP COLLATION — remove a collation
Synopsis
+DROP COLLATION [ IF EXISTS ] name [ CASCADE | RESTRICT ]
+
Description
+ DROP COLLATION removes a previously defined collation.
+ To be able to drop a collation, you must own the collation.
+
Parameters
IF EXISTS
+ Do not throw an error if the collation does not exist.
+ A notice is issued in this case.
+
name
+ The name of the collation. The collation name can be
+ schema-qualified.
+
CASCADE
+ Automatically drop objects that depend on the collation,
+ and in turn all objects that depend on those objects
+ (see Section 5.14).
+
RESTRICT
+ Refuse to drop the collation if any objects depend on it. This
+ is the default.
+
Examples
+ To drop the collation named german:
+
+DROP COLLATION german;
+
Compatibility
+ The DROP COLLATION command conforms to the
+ SQL standard, apart from the IF
+ EXISTS option, which is a PostgreSQL extension.
+
DROP CONVERSION
DROP CONVERSION — remove a conversion
Synopsis
+DROP CONVERSION [ IF EXISTS ] name [ CASCADE | RESTRICT ]
+
Description
+ DROP CONVERSION removes a previously defined conversion.
+ To be able to drop a conversion, you must own the conversion.
+
Parameters
IF EXISTS
+ Do not throw an error if the conversion does not exist.
+ A notice is issued in this case.
+
name
+ The name of the conversion. The conversion name can be
+ schema-qualified.
+
CASCADE
RESTRICT
+ These key words do not have any effect, since there are no
+ dependencies on conversions.
+
Examples
+ To drop the conversion named myname:
+
+DROP CONVERSION myname;
+
Compatibility
+ There is no DROP CONVERSION statement in the SQL
+ standard, but a DROP TRANSLATION statement that
+ goes along with the CREATE TRANSLATION statement
+ that is similar to the CREATE CONVERSION
+ statement in PostgreSQL.
+
DROP DATABASE
DROP DATABASE — remove a database
Synopsis
+DROP DATABASE [ IF EXISTS ] name [ [ WITH ] ( option [, ...] ) ]
+
+where option can be:
+
+ FORCE
+
Description
+ DROP DATABASE drops a database. It removes the
+ catalog entries for the database and deletes the directory
+ containing the data. It can only be executed by the database owner.
+ It cannot be executed while you are connected to the target database.
+ (Connect to postgres or any other database to issue this
+ command.)
+ Also, if anyone else is connected to the target database, this command will
+ fail unless you use the FORCE option described below.
+
+ DROP DATABASE cannot be undone. Use it with care!
+
Parameters
IF EXISTS
+ Do not throw an error if the database does not exist. A notice is issued
+ in this case.
+
name
+ The name of the database to remove.
+
FORCE
+ Attempt to terminate all existing connections to the target database.
+ It doesn't terminate if prepared transactions, active logical replication
+ slots or subscriptions are present in the target database.
+
+ This will fail if the current user has no permissions to terminate other
+ connections. Required permissions are the same as with
+ pg_terminate_backend, described in
+ Section 9.27.2. This will also fail if we
+ are not able to terminate connections.
+
Notes
+ DROP DATABASE cannot be executed inside a transaction
+ block.
+
+ This command cannot be executed while connected to the target
+ database. Thus, it might be more convenient to use the program
+ dropdb instead,
+ which is a wrapper around this command.
+
Compatibility
+ There is no DROP DATABASE statement in the SQL standard.
+
DROP DOMAIN
DROP DOMAIN — remove a domain
Synopsis
+DROP DOMAIN [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
+
Description
+ DROP DOMAIN removes a domain. Only the owner of
+ a domain can remove it.
+
Parameters
IF EXISTS
+ Do not throw an error if the domain does not exist. A notice is issued
+ in this case.
+
name
+ The name (optionally schema-qualified) of an existing domain.
+
CASCADE
+ Automatically drop objects that depend on the domain (such as
+ table columns),
+ and in turn all objects that depend on those objects
+ (see Section 5.14).
+
RESTRICT
+ Refuse to drop the domain if any objects depend on it. This is
+ the default.
+
Examples
+ To remove the domain box:
+
+
+DROP DOMAIN box;
+
Compatibility
+ This command conforms to the SQL standard, except for the
+ IF EXISTS option, which is a PostgreSQL
+ extension.
+
DROP EVENT TRIGGER
DROP EVENT TRIGGER — remove an event trigger
Synopsis
+DROP EVENT TRIGGER [ IF EXISTS ] name [ CASCADE | RESTRICT ]
+
Description
+ DROP EVENT TRIGGER removes an existing event trigger.
+ To execute this command, the current user must be the owner of the event
+ trigger.
+
Parameters
IF EXISTS
+ Do not throw an error if the event trigger does not exist. A notice
+ is issued in this case.
+
name
+ The name of the event trigger to remove.
+
CASCADE
+ Automatically drop objects that depend on the trigger,
+ and in turn all objects that depend on those objects
+ (see Section 5.14).
+
RESTRICT
+ Refuse to drop the trigger if any objects depend on it. This is
+ the default.
+
Examples
+ Destroy the trigger snitch:
+
+
+DROP EVENT TRIGGER snitch;
+
Compatibility
+ There is no DROP EVENT TRIGGER statement in the
+ SQL standard.
+
DROP EXTENSION
DROP EXTENSION — remove an extension
Synopsis
+DROP EXTENSION [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
+
Description
+ DROP EXTENSION removes extensions from the database.
+ Dropping an extension causes its member objects, and other explicitly
+ dependent routines (see ALTER ROUTINE,
+ the DEPENDS ON EXTENSION extension_name
+ action), to be dropped as well.
+
+ You must own the extension to use DROP EXTENSION.
+
Parameters
IF EXISTS
+ Do not throw an error if the extension does not exist. A notice is issued
+ in this case.
+
name
+ The name of an installed extension.
+
CASCADE
+ Automatically drop objects that depend on the extension,
+ and in turn all objects that depend on those objects
+ (see Section 5.14).
+
RESTRICT
+ This option prevents the specified extensions from being dropped if
+ other objects, besides these extensions, their members, and their
+ explicitly dependent routines, depend on them. This is the default.
+
Examples
+ To remove the extension hstore from the current
+ database:
+
+DROP EXTENSION hstore;
+
+ This command will fail if any of hstore's objects
+ are in use in the database, for example if any tables have columns
+ of the hstore type. Add the CASCADE option to
+ forcibly remove those dependent objects as well.
+
Compatibility
+ DROP EXTENSION is a PostgreSQL
+ extension.
+
DROP FOREIGN DATA WRAPPER
DROP FOREIGN DATA WRAPPER — remove a foreign-data wrapper
Synopsis
+DROP FOREIGN DATA WRAPPER [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
+
Description
+ DROP FOREIGN DATA WRAPPER removes an existing
+ foreign-data wrapper. To execute this command, the current user
+ must be the owner of the foreign-data wrapper.
+
Parameters
IF EXISTS
+ Do not throw an error if the foreign-data wrapper does not
+ exist. A notice is issued in this case.
+
name
+ The name of an existing foreign-data wrapper.
+
CASCADE
+ Automatically drop objects that depend on the foreign-data
+ wrapper (such as foreign tables and servers),
+ and in turn all objects that depend on those objects
+ (see Section 5.14).
+
RESTRICT
+ Refuse to drop the foreign-data wrapper if any objects depend
+ on it. This is the default.
+
Examples
+ Drop the foreign-data wrapper dbi:
+
+DROP FOREIGN DATA WRAPPER dbi;
+
Compatibility
+ DROP FOREIGN DATA WRAPPER conforms to ISO/IEC
+ 9075-9 (SQL/MED). The IF EXISTS clause is
+ a PostgreSQL extension.
+
DROP FOREIGN TABLE
DROP FOREIGN TABLE — remove a foreign table
Synopsis
+DROP FOREIGN TABLE [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
+
Description
+ DROP FOREIGN TABLE removes a foreign table.
+ Only the owner of a foreign table can remove it.
+
Parameters
IF EXISTS
+ Do not throw an error if the foreign table does not exist.
+ A notice is issued in this case.
+
name
+ The name (optionally schema-qualified) of the foreign table to drop.
+
CASCADE
+ Automatically drop objects that depend on the foreign table (such as
+ views), and in turn all objects that depend on those objects
+ (see Section 5.14).
+
RESTRICT
+ Refuse to drop the foreign table if any objects depend on it. This is
+ the default.
+
Examples
+ To destroy two foreign tables, films and
+ distributors:
+
+
+DROP FOREIGN TABLE films, distributors;
+
Compatibility
+ This command conforms to ISO/IEC 9075-9 (SQL/MED), except that the
+ standard only allows one foreign table to be dropped per command, and apart
+ from the IF EXISTS option, which is a PostgreSQL
+ extension.
+
DROP FUNCTION
DROP FUNCTION — remove a function
Synopsis
+DROP FUNCTION [ IF EXISTS ] name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ] [, ...]
+ [ CASCADE | RESTRICT ]
+
Description
+ DROP FUNCTION removes the definition of an existing
+ function. To execute this command the user must be the
+ owner of the function. The argument types to the
+ function must be specified, since several different functions
+ can exist with the same name and different argument lists.
+
Parameters
IF EXISTS
+ Do not throw an error if the function does not exist. A notice is issued
+ in this case.
+
name
+ The name (optionally schema-qualified) of an existing function. If no
+ argument list is specified, the name must be unique in its schema.
+
argmode
+ The mode of an argument: IN, OUT,
+ INOUT, or VARIADIC.
+ If omitted, the default is IN.
+ Note that DROP FUNCTION does not actually pay
+ any attention to OUT arguments, since only the input
+ arguments are needed to determine the function's identity.
+ So it is sufficient to list the IN, INOUT,
+ and VARIADIC arguments.
+
argname
+ The name of an argument.
+ Note that DROP FUNCTION does not actually pay
+ any attention to argument names, since only the argument data
+ types are needed to determine the function's identity.
+
argtype
+ The data type(s) of the function's arguments (optionally
+ schema-qualified), if any.
+
CASCADE
+ Automatically drop objects that depend on the function (such as
+ operators or triggers),
+ and in turn all objects that depend on those objects
+ (see Section 5.14).
+
RESTRICT
+ Refuse to drop the function if any objects depend on it. This
+ is the default.
+
Examples
+ This command removes the square root function:
+
+
+DROP FUNCTION sqrt(integer);
+
+ Drop multiple functions in one command:
+
+DROP FUNCTION sqrt(integer), sqrt(bigint);
+
+ If the function name is unique in its schema, it can be referred to without
+ an argument list:
+
+DROP FUNCTION update_employee_salaries;
+
+ Note that this is different from
+
+DROP FUNCTION update_employee_salaries();
+
+ which refers to a function with zero arguments, whereas the first variant
+ can refer to a function with any number of arguments, including zero, as
+ long as the name is unique.
+
Compatibility
+ This command conforms to the SQL standard, with
+ these PostgreSQL extensions:
+
DROP GROUP
DROP GROUP — remove a database role
Synopsis
+DROP GROUP [ IF EXISTS ] name [, ...]
+
Description
+ DROP GROUP is now an alias for
+ DROP ROLE.
+
Compatibility
+ There is no DROP GROUP statement in the SQL standard.
+
DROP INDEX
DROP INDEX — remove an index
Synopsis
+DROP INDEX [ CONCURRENTLY ] [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
+
Description
+ DROP INDEX drops an existing index from the database
+ system. To execute this command you must be the owner of
+ the index.
+
Parameters
CONCURRENTLY
+ Drop the index without locking out concurrent selects, inserts, updates,
+ and deletes on the index's table. A normal DROP INDEX
+ acquires an ACCESS EXCLUSIVE lock on the table,
+ blocking other accesses until the index drop can be completed. With
+ this option, the command instead waits until conflicting transactions
+ have completed.
+
+ There are several caveats to be aware of when using this option.
+ Only one index name can be specified, and the CASCADE option
+ is not supported. (Thus, an index that supports a UNIQUE or
+ PRIMARY KEY constraint cannot be dropped this way.)
+ Also, regular DROP INDEX commands can be
+ performed within a transaction block, but
+ DROP INDEX CONCURRENTLY cannot.
+ Lastly, indexes on partitioned tables cannot be dropped using this
+ option.
+
+ For temporary tables, DROP INDEX is always
+ non-concurrent, as no other session can access them, and
+ non-concurrent index drop is cheaper.
+
IF EXISTS
+ Do not throw an error if the index does not exist. A notice is issued
+ in this case.
+
name
+ The name (optionally schema-qualified) of an index to remove.
+
CASCADE
+ Automatically drop objects that depend on the index,
+ and in turn all objects that depend on those objects
+ (see Section 5.14).
+
RESTRICT
+ Refuse to drop the index if any objects depend on it. This is
+ the default.
+
Examples
+ This command will remove the index title_idx:
+
+
+DROP INDEX title_idx;
+
Compatibility
+ DROP INDEX is a
+ PostgreSQL language extension. There
+ are no provisions for indexes in the SQL standard.
+
DROP LANGUAGE
DROP LANGUAGE — remove a procedural language
Synopsis
+DROP [ PROCEDURAL ] LANGUAGE [ IF EXISTS ] name [ CASCADE | RESTRICT ]
+
Description
+ DROP LANGUAGE removes the definition of a
+ previously registered procedural language. You must be a superuser
+ or the owner of the language to use DROP LANGUAGE.
+
Note
+ As of PostgreSQL 9.1, most procedural
+ languages have been made into “extensions”, and should
+ therefore be removed with DROP EXTENSION
+ not DROP LANGUAGE.
+
Parameters
IF EXISTS
+ Do not throw an error if the language does not exist. A notice is issued
+ in this case.
+
name
+ The name of an existing procedural language.
+
CASCADE
+ Automatically drop objects that depend on the language (such as
+ functions in the language),
+ and in turn all objects that depend on those objects
+ (see Section 5.14).
+
RESTRICT
+ Refuse to drop the language if any objects depend on it. This
+ is the default.
+
Examples
+ This command removes the procedural language
+ plsample:
+
+
+DROP LANGUAGE plsample;
+
Compatibility
+ There is no DROP LANGUAGE statement in the SQL
+ standard.
+
DROP MATERIALIZED VIEW
DROP MATERIALIZED VIEW — remove a materialized view
Synopsis
+DROP MATERIALIZED VIEW [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
+
Description
+ DROP MATERIALIZED VIEW drops an existing materialized
+ view. To execute this command you must be the owner of the materialized
+ view.
+
Parameters
IF EXISTS
+ Do not throw an error if the materialized view does not exist. A notice
+ is issued in this case.
+
name
+ The name (optionally schema-qualified) of the materialized view to
+ remove.
+
CASCADE
+ Automatically drop objects that depend on the materialized view (such as
+ other materialized views, or regular views),
+ and in turn all objects that depend on those objects
+ (see Section 5.14).
+
RESTRICT
+ Refuse to drop the materialized view if any objects depend on it. This
+ is the default.
+
Examples
+ This command will remove the materialized view called
+ order_summary:
+
+DROP MATERIALIZED VIEW order_summary;
+
Compatibility
+ DROP MATERIALIZED VIEW is a
+ PostgreSQL extension.
+
DROP OPERATOR CLASS
DROP OPERATOR CLASS — remove an operator class
Synopsis
+DROP OPERATOR CLASS [ IF EXISTS ] name USING index_method [ CASCADE | RESTRICT ]
+
Description
+ DROP OPERATOR CLASS drops an existing operator class.
+ To execute this command you must be the owner of the operator class.
+
+ DROP OPERATOR CLASS does not drop any of the operators
+ or functions referenced by the class. If there are any indexes depending
+ on the operator class, you will need to specify
+ CASCADE for the drop to complete.
+
Parameters
IF EXISTS
+ Do not throw an error if the operator class does not exist. A notice is issued
+ in this case.
+
name
+ The name (optionally schema-qualified) of an existing operator class.
+
index_method
+ The name of the index access method the operator class is for.
+
CASCADE
+ Automatically drop objects that depend on the operator class (such as
+ indexes), and in turn all objects that depend on those objects
+ (see Section 5.14).
+
RESTRICT
+ Refuse to drop the operator class if any objects depend on it.
+ This is the default.
+
Notes
+ DROP OPERATOR CLASS will not drop the operator family
+ containing the class, even if there is nothing else left in the
+ family (in particular, in the case where the family was implicitly
+ created by CREATE OPERATOR CLASS). An empty operator
+ family is harmless, but for the sake of tidiness you might wish to
+ remove the family with DROP OPERATOR FAMILY; or perhaps
+ better, use DROP OPERATOR FAMILY in the first place.
+
Examples
+ Remove the B-tree operator class widget_ops:
+
+
+DROP OPERATOR CLASS widget_ops USING btree;
+
+
+ This command will not succeed if there are any existing indexes
+ that use the operator class. Add CASCADE to drop
+ such indexes along with the operator class.
+
Compatibility
+ There is no DROP OPERATOR CLASS statement in the
+ SQL standard.
+
DROP OPERATOR
DROP OPERATOR — remove an operator
Synopsis
+DROP OPERATOR [ IF EXISTS ] name ( { left_type | NONE } , right_type ) [, ...] [ CASCADE | RESTRICT ]
+
Description
+ DROP OPERATOR drops an existing operator from
+ the database system. To execute this command you must be the owner
+ of the operator.
+
Parameters
IF EXISTS
+ Do not throw an error if the operator does not exist. A notice is issued
+ in this case.
+
name
+ The name (optionally schema-qualified) of an existing operator.
+
left_type
+ The data type of the operator's left operand; write
+ NONE if the operator has no left operand.
+
right_type
+ The data type of the operator's right operand.
+
CASCADE
+ Automatically drop objects that depend on the operator (such as views
+ using it), and in turn all objects that depend on those objects
+ (see Section 5.14).
+
RESTRICT
+ Refuse to drop the operator if any objects depend on it. This
+ is the default.
+
Examples
+ Remove the power operator a^b for type integer:
+
+DROP OPERATOR ^ (integer, integer);
+
+
+ Remove the bitwise-complement prefix operator
+ ~b for type bit:
+
+DROP OPERATOR ~ (none, bit);
+
+
+ Remove multiple operators in one command:
+
+DROP OPERATOR ~ (none, bit), ^ (integer, integer);
+
Compatibility
+ There is no DROP OPERATOR statement in the SQL standard.
+
DROP OPERATOR FAMILY
DROP OPERATOR FAMILY — remove an operator family
Synopsis
+DROP OPERATOR FAMILY [ IF EXISTS ] name USING index_method [ CASCADE | RESTRICT ]
+
Description
+ DROP OPERATOR FAMILY drops an existing operator family.
+ To execute this command you must be the owner of the operator family.
+
+ DROP OPERATOR FAMILY includes dropping any operator
+ classes contained in the family, but it does not drop any of the operators
+ or functions referenced by the family. If there are any indexes depending
+ on operator classes within the family, you will need to specify
+ CASCADE for the drop to complete.
+
Parameters
IF EXISTS
+ Do not throw an error if the operator family does not exist.
+ A notice is issued in this case.
+
name
+ The name (optionally schema-qualified) of an existing operator family.
+
index_method
+ The name of the index access method the operator family is for.
+
CASCADE
+ Automatically drop objects that depend on the operator family,
+ and in turn all objects that depend on those objects
+ (see Section 5.14).
+
RESTRICT
+ Refuse to drop the operator family if any objects depend on it.
+ This is the default.
+
Examples
+ Remove the B-tree operator family float_ops:
+
+
+DROP OPERATOR FAMILY float_ops USING btree;
+
+
+ This command will not succeed if there are any existing indexes
+ that use operator classes within the family. Add CASCADE to
+ drop such indexes along with the operator family.
+
Compatibility
+ There is no DROP OPERATOR FAMILY statement in the
+ SQL standard.
+
DROP POLICY
DROP POLICY — remove a row-level security policy from a table
Synopsis
+DROP POLICY [ IF EXISTS ] name ON table_name [ CASCADE | RESTRICT ]
+
Description
+ DROP POLICY removes the specified policy from the table.
+ Note that if the last policy is removed for a table and the table still has
+ row-level security enabled via ALTER TABLE, then the
+ default-deny policy will be used. ALTER TABLE ... DISABLE ROW
+ LEVEL SECURITY can be used to disable row-level security for a
+ table, whether policies for the table exist or not.
+
Parameters
IF EXISTS
+ Do not throw an error if the policy does not exist. A notice is issued
+ in this case.
+
name
+ The name of the policy to drop.
+
table_name
+ The name (optionally schema-qualified) of the table that
+ the policy is on.
+
CASCADE
RESTRICT
+ These key words do not have any effect, since there are no
+ dependencies on policies.
+
Examples
+ To drop the policy called p1 on the table named
+ my_table:
+
+
+DROP POLICY p1 ON my_table;
+
Compatibility
+ DROP POLICY is a PostgreSQL extension.
+
DROP PROCEDURE
DROP PROCEDURE — remove a procedure
Synopsis
+DROP PROCEDURE [ IF EXISTS ] name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ] [, ...]
+ [ CASCADE | RESTRICT ]
+
Description
+ DROP PROCEDURE removes the definition of one or more
+ existing procedures. To execute this command the user must be the
+ owner of the procedure(s). The argument types to the
+ procedure(s) usually must be specified, since several different procedures
+ can exist with the same name and different argument lists.
+
Parameters
IF EXISTS
+ Do not throw an error if the procedure does not exist. A notice is issued
+ in this case.
+
name
+ The name (optionally schema-qualified) of an existing procedure.
+
argmode
+ The mode of an argument: IN, OUT,
+ INOUT, or VARIADIC. If omitted,
+ the default is IN (but see below).
+
argname
+ The name of an argument.
+ Note that DROP PROCEDURE does not actually pay
+ any attention to argument names, since only the argument data
+ types are used to determine the procedure's identity.
+
argtype
+ The data type(s) of the procedure's arguments (optionally
+ schema-qualified), if any.
+ See below for details.
+
CASCADE
+ Automatically drop objects that depend on the procedure,
+ and in turn all objects that depend on those objects
+ (see Section 5.14).
+
RESTRICT
+ Refuse to drop the procedure if any objects depend on it. This
+ is the default.
+
Notes
+ If there is only one procedure of the given name, the argument list
+ can be omitted. Omit the parentheses too in this case.
+
+ In PostgreSQL, it's sufficient to list the
+ input (including INOUT) arguments,
+ because no two routines of the same name are allowed to share the same
+ input-argument list. Moreover, the DROP command
+ will not actually check that you wrote the types
+ of OUT arguments correctly; so any arguments that
+ are explicitly marked OUT are just noise. But
+ writing them is recommendable for consistency with the
+ corresponding CREATE command.
+
+ For compatibility with the SQL standard, it is also allowed to write
+ all the argument data types (including those of OUT
+ arguments) without
+ any argmode markers.
+ When this is done, the types of the procedure's OUT
+ argument(s) will be verified against the command.
+ This provision creates an ambiguity, in that when the argument list
+ contains no argmode
+ markers, it's unclear which rule is intended.
+ The DROP command will attempt the lookup both ways,
+ and will throw an error if two different procedures are found.
+ To avoid the risk of such ambiguity, it's recommendable to
+ write IN markers explicitly rather than letting them
+ be defaulted, thus forcing the
+ traditional PostgreSQL interpretation to be
+ used.
+
+ The lookup rules just explained are also used by other commands that
+ act on existing procedures, such as ALTER PROCEDURE
+ and COMMENT ON PROCEDURE.
+
Examples
+ If there is only one procedure do_db_maintenance,
+ this command is sufficient to drop it:
+
+DROP PROCEDURE do_db_maintenance;
+
+
+ Given this procedure definition:
+
+CREATE PROCEDURE do_db_maintenance(IN target_schema text, OUT results text) ...
+
+ any one of these commands would work to drop it:
+
+DROP PROCEDURE do_db_maintenance(IN target_schema text, OUT results text);
+DROP PROCEDURE do_db_maintenance(IN text, OUT text);
+DROP PROCEDURE do_db_maintenance(IN text);
+DROP PROCEDURE do_db_maintenance(text);
+DROP PROCEDURE do_db_maintenance(text, text); -- potentially ambiguous
+
+ However, the last example would be ambiguous if there is also, say,
+
+CREATE PROCEDURE do_db_maintenance(IN target_schema text, IN options text) ...
+
Compatibility
+ This command conforms to the SQL standard, with
+ these PostgreSQL extensions:
+
The standard only allows one procedure to be dropped per command.
The IF EXISTS option is an extension.
The ability to specify argument modes and names is an
+ extension, and the lookup rules differ when modes are given.
DROP PUBLICATION
DROP PUBLICATION — remove a publication
Synopsis
+DROP PUBLICATION [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
+
Description
+ DROP PUBLICATION removes an existing publication from
+ the database.
+
+ A publication can only be dropped by its owner or a superuser.
+
Parameters
IF EXISTS
+ Do not throw an error if the publication does not exist. A notice is
+ issued in this case.
+
name
+ The name of an existing publication.
+
CASCADE
RESTRICT
+ These key words do not have any effect, since there are no dependencies
+ on publications.
+
Examples
+ Drop a publication:
+
+DROP PUBLICATION mypublication;
+
Compatibility
+ DROP PUBLICATION is a PostgreSQL
+ extension.
+
DROP ROLE
DROP ROLE — remove a database role
Synopsis
+DROP ROLE [ IF EXISTS ] name [, ...]
+
Description
+ DROP ROLE removes the specified role(s).
+ To drop a superuser role, you must be a superuser yourself;
+ to drop non-superuser roles, you must have CREATEROLE
+ privilege and have been granted ADMIN OPTION on the role.
+
+ A role cannot be removed if it is still referenced in any database
+ of the cluster; an error will be raised if so. Before dropping the role,
+ you must drop all the objects it owns (or reassign their ownership)
+ and revoke any privileges the role has been granted on other objects.
+ The REASSIGN
+ OWNED and DROP
+ OWNED
+ commands can be useful for this purpose; see Section 22.4
+ for more discussion.
+
+ However, it is not necessary to remove role memberships involving
+ the role; DROP ROLE automatically revokes any memberships
+ of the target role in other roles, and of other roles in the target role.
+ The other roles are not dropped nor otherwise affected.
+
Parameters
IF EXISTS
+ Do not throw an error if the role does not exist. A notice is issued
+ in this case.
+
name
+ The name of the role to remove.
+
Notes
+ PostgreSQL includes a program dropuser that has the
+ same functionality as this command (in fact, it calls this command)
+ but can be run from the command shell.
+
Examples
+ To drop a role:
+
+DROP ROLE jonathan;
+
Compatibility
+ The SQL standard defines DROP ROLE, but it allows
+ only one role to be dropped at a time, and it specifies different
+ privilege requirements than PostgreSQL uses.
+
DROP ROUTINE
DROP ROUTINE — remove a routine
Synopsis
+DROP ROUTINE [ IF EXISTS ] name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ] [, ...]
+ [ CASCADE | RESTRICT ]
+
Description
+ DROP ROUTINE removes the definition of one or more
+ existing routines. The term “routine” includes
+ aggregate functions, normal functions, and procedures. See
+ under DROP AGGREGATE, DROP FUNCTION,
+ and DROP PROCEDURE for the description of the
+ parameters, more examples, and further details.
+
Notes
+ The lookup rules used by DROP ROUTINE are
+ fundamentally the same as for DROP PROCEDURE; in
+ particular, DROP ROUTINE shares that command's
+ behavior of considering an argument list that has
+ no argmode markers to be
+ possibly using the SQL standard's definition that OUT
+ arguments are included in the list. (DROP AGGREGATE
+ and DROP FUNCTION do not do that.)
+
+ In some cases where the same name is shared by routines of different
+ kinds, it is possible for DROP ROUTINE to fail with
+ an ambiguity error when a more specific command (DROP
+ FUNCTION, etc.) would work. Specifying the argument type
+ list more carefully will also resolve such problems.
+
+ These lookup rules are also used by other commands that
+ act on existing routines, such as ALTER ROUTINE
+ and COMMENT ON ROUTINE.
+
Examples
+ To drop the routine foo for type
+ integer:
+
+DROP ROUTINE foo(integer);
+
+ This command will work independent of whether foo is an
+ aggregate, function, or procedure.
+
Compatibility
+ This command conforms to the SQL standard, with
+ these PostgreSQL extensions:
+
The standard only allows one routine to be dropped per command.
The IF EXISTS option is an extension.
The ability to specify argument modes and names is an
+ extension, and the lookup rules differ when modes are given.
User-definable aggregate functions are an extension.
DROP RULE
DROP RULE — remove a rewrite rule
Synopsis
+DROP RULE [ IF EXISTS ] name ON table_name [ CASCADE | RESTRICT ]
+
Description
+ DROP RULE drops a rewrite rule.
+
Parameters
IF EXISTS
+ Do not throw an error if the rule does not exist. A notice is issued
+ in this case.
+
name
+ The name of the rule to drop.
+
table_name
+ The name (optionally schema-qualified) of the table or view that
+ the rule applies to.
+
CASCADE
+ Automatically drop objects that depend on the rule,
+ and in turn all objects that depend on those objects
+ (see Section 5.14).
+
RESTRICT
+ Refuse to drop the rule if any objects depend on it. This is
+ the default.
+
Examples
+ To drop the rewrite rule newrule:
+
+
+DROP RULE newrule ON mytable;
+
Compatibility
+ DROP RULE is a
+ PostgreSQL language extension, as is the
+ entire query rewrite system.
+
DROP SCHEMA
DROP SCHEMA — remove a schema
Synopsis
+DROP SCHEMA [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
+
Description
+ DROP SCHEMA removes schemas from the database.
+
+ A schema can only be dropped by its owner or a superuser. Note that
+ the owner can drop the schema (and thereby all contained objects)
+ even if they do not own some of the objects within the schema.
+
Parameters
IF EXISTS
+ Do not throw an error if the schema does not exist. A notice is issued
+ in this case.
+
name
+ The name of a schema.
+
CASCADE
+ Automatically drop objects (tables, functions, etc.) that are
+ contained in the schema,
+ and in turn all objects that depend on those objects
+ (see Section 5.14).
+
RESTRICT
+ Refuse to drop the schema if it contains any objects. This is
+ the default.
+
Notes
+ Using the CASCADE option might make the command
+ remove objects in other schemas besides the one(s) named.
+
Examples
+ To remove schema mystuff from the database,
+ along with everything it contains:
+
+
+DROP SCHEMA mystuff CASCADE;
+
Compatibility
+ DROP SCHEMA is fully conforming with the SQL
+ standard, except that the standard only allows one schema to be
+ dropped per command, and apart from the
+ IF EXISTS option, which is a PostgreSQL
+ extension.
+
DROP SEQUENCE
DROP SEQUENCE — remove a sequence
Synopsis
+DROP SEQUENCE [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
+
Description
+ DROP SEQUENCE removes sequence number
+ generators. A sequence can only be dropped by its owner or a superuser.
+
Parameters
IF EXISTS
+ Do not throw an error if the sequence does not exist. A notice is issued
+ in this case.
+
name
+ The name (optionally schema-qualified) of a sequence.
+
CASCADE
+ Automatically drop objects that depend on the sequence,
+ and in turn all objects that depend on those objects
+ (see Section 5.14).
+
RESTRICT
+ Refuse to drop the sequence if any objects depend on it. This
+ is the default.
+
Examples
+ To remove the sequence serial:
+
+
+DROP SEQUENCE serial;
+
Compatibility
+ DROP SEQUENCE conforms to the SQL
+ standard, except that the standard only allows one
+ sequence to be dropped per command, and apart from the
+ IF EXISTS option, which is a PostgreSQL
+ extension.
+
DROP SERVER
DROP SERVER — remove a foreign server descriptor
Synopsis
+DROP SERVER [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
+
Description
+ DROP SERVER removes an existing foreign server
+ descriptor. To execute this command, the current user must be the
+ owner of the server.
+
Parameters
IF EXISTS
+ Do not throw an error if the server does not exist. A notice is
+ issued in this case.
+
name
+ The name of an existing server.
+
CASCADE
+ Automatically drop objects that depend on the server (such as
+ user mappings),
+ and in turn all objects that depend on those objects
+ (see Section 5.14).
+
RESTRICT
+ Refuse to drop the server if any objects depend on it. This is
+ the default.
+
Examples
+ Drop a server foo if it exists:
+
+DROP SERVER IF EXISTS foo;
+
Compatibility
+ DROP SERVER conforms to ISO/IEC 9075-9
+ (SQL/MED). The IF EXISTS clause is
+ a PostgreSQL extension.
+
DROP STATISTICS
DROP STATISTICS — remove extended statistics
Synopsis
+DROP STATISTICS [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
+
Description
+ DROP STATISTICS removes statistics object(s) from the
+ database. Only the statistics object's owner, the schema owner, or a
+ superuser can drop a statistics object.
+
Parameters
IF EXISTS
+ Do not throw an error if the statistics object does not exist. A notice
+ is issued in this case.
+
name
+ The name (optionally schema-qualified) of the statistics object to drop.
+
CASCADE
RESTRICT
+ These key words do not have any effect, since there are no dependencies
+ on statistics.
+
Examples
+ To destroy two statistics objects in different schemas, without failing
+ if they don't exist:
+
+
+DROP STATISTICS IF EXISTS
+ accounting.users_uid_creation,
+ public.grants_user_role;
+
Compatibility
+ There is no DROP STATISTICS command in the SQL standard.
+
DROP SUBSCRIPTION
DROP SUBSCRIPTION — remove a subscription
Synopsis
+DROP SUBSCRIPTION [ IF EXISTS ] name [ CASCADE | RESTRICT ]
+
Description
+ DROP SUBSCRIPTION removes a subscription from the
+ database cluster.
+
+ To execute this command the user must be the owner of the subscription.
+
+ DROP SUBSCRIPTION cannot be executed inside a
+ transaction block if the subscription is associated with a replication
+ slot. (You can use ALTER SUBSCRIPTION to unset the
+ slot.)
+
Parameters
name
+ The name of a subscription to be dropped.
+
CASCADE
RESTRICT
+ These key words do not have any effect, since there are no dependencies
+ on subscriptions.
+
Notes
+ When dropping a subscription that is associated with a replication slot on
+ the remote host (the normal state), DROP SUBSCRIPTION
+ will connect to the remote host and try to drop the replication slot (and
+ any remaining table synchronization slots) as
+ part of its operation. This is necessary so that the resources allocated
+ for the subscription on the remote host are released. If this fails,
+ either because the remote host is not reachable or because the remote
+ replication slot cannot be dropped or does not exist or never existed,
+ the DROP SUBSCRIPTION command will fail. To proceed
+ in this situation, first disable the subscription by executing
+ ALTER SUBSCRIPTION ... DISABLE, and then disassociate
+ it from the replication slot by executing
+ ALTER SUBSCRIPTION ... SET (slot_name = NONE).
+ After that, DROP SUBSCRIPTION will no longer attempt any
+ actions on a remote host. Note that if the remote replication slot still
+ exists, it (and any related table synchronization slots) should then be
+ dropped manually; otherwise it/they will continue to
+ reserve WAL and might eventually cause the disk to fill up. See
+ also Section 31.2.1.
+
+ If a subscription is associated with a replication slot, then DROP
+ SUBSCRIPTION cannot be executed inside a transaction block.
+
Examples
+ Drop a subscription:
+
+DROP SUBSCRIPTION mysub;
+
Compatibility
+ DROP SUBSCRIPTION is a PostgreSQL
+ extension.
+
DROP TABLE
DROP TABLE — remove a table
Synopsis
+DROP TABLE [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
+
Description
+ DROP TABLE removes tables from the database.
+ Only the table owner, the schema owner, and superuser can drop a
+ table. To empty a table of rows
+ without destroying the table, use DELETE
+ or TRUNCATE.
+
+ DROP TABLE always removes any indexes, rules,
+ triggers, and constraints that exist for the target table.
+ However, to drop a table that is referenced by a view or a foreign-key
+ constraint of another table, CASCADE must be
+ specified. (CASCADE will remove a dependent view entirely,
+ but in the foreign-key case it will only remove the foreign-key
+ constraint, not the other table entirely.)
+
Parameters
IF EXISTS
+ Do not throw an error if the table does not exist. A notice is issued
+ in this case.
+
name
+ The name (optionally schema-qualified) of the table to drop.
+
CASCADE
+ Automatically drop objects that depend on the table (such as
+ views),
+ and in turn all objects that depend on those objects
+ (see Section 5.14).
+
RESTRICT
+ Refuse to drop the table if any objects depend on it. This is
+ the default.
+
Examples
+ To destroy two tables, films and
+ distributors:
+
+
+DROP TABLE films, distributors;
+
Compatibility
+ This command conforms to the SQL standard, except that the standard only
+ allows one table to be dropped per command, and apart from the
+ IF EXISTS option, which is a PostgreSQL
+ extension.
+
DROP TABLESPACE
DROP TABLESPACE — remove a tablespace
Synopsis
+DROP TABLESPACE [ IF EXISTS ] name
+
Description
+ DROP TABLESPACE removes a tablespace from the system.
+
+ A tablespace can only be dropped by its owner or a superuser.
+ The tablespace must be empty of all database objects before it can be
+ dropped. It is possible that objects in other databases might still reside
+ in the tablespace even if no objects in the current database are using
+ the tablespace. Also, if the tablespace is listed in the temp_tablespaces setting of any active session, the
+ DROP might fail due to temporary files residing in the
+ tablespace.
+
Parameters
IF EXISTS
+ Do not throw an error if the tablespace does not exist. A notice is issued
+ in this case.
+
name
+ The name of a tablespace.
+
Notes
+ DROP TABLESPACE cannot be executed inside a transaction block.
+
Examples
+ To remove tablespace mystuff from the system:
+
+DROP TABLESPACE mystuff;
+
Compatibility
+ DROP TABLESPACE is a PostgreSQL
+ extension.
+
DROP TRANSFORM
DROP TRANSFORM — remove a transform
Synopsis
+DROP TRANSFORM [ IF EXISTS ] FOR type_name LANGUAGE lang_name [ CASCADE | RESTRICT ]
+
Parameters
IF EXISTS
+ Do not throw an error if the transform does not exist. A notice is issued
+ in this case.
+
type_name
+ The name of the data type of the transform.
+
lang_name
+ The name of the language of the transform.
+
CASCADE
+ Automatically drop objects that depend on the transform,
+ and in turn all objects that depend on those objects
+ (see Section 5.14).
+
RESTRICT
+ Refuse to drop the transform if any objects depend on it. This is the
+ default.
+
DROP TRIGGER
DROP TRIGGER — remove a trigger
Synopsis
+DROP TRIGGER [ IF EXISTS ] name ON table_name [ CASCADE | RESTRICT ]
+
Description
+ DROP TRIGGER removes an existing
+ trigger definition. To execute this command, the current
+ user must be the owner of the table for which the trigger is defined.
+
Parameters
IF EXISTS
+ Do not throw an error if the trigger does not exist. A notice is issued
+ in this case.
+
name
+ The name of the trigger to remove.
+
table_name
+ The name (optionally schema-qualified) of the table for which
+ the trigger is defined.
+
CASCADE
+ Automatically drop objects that depend on the trigger,
+ and in turn all objects that depend on those objects
+ (see Section 5.14).
+
RESTRICT
+ Refuse to drop the trigger if any objects depend on it. This is
+ the default.
+
Examples
+ Destroy the trigger if_dist_exists on the table
+ films:
+
+
+DROP TRIGGER if_dist_exists ON films;
+
Compatibility
+ The DROP TRIGGER statement in
+ PostgreSQL is incompatible with the SQL
+ standard. In the SQL standard, trigger names are not local to
+ tables, so the command is simply DROP TRIGGER
+ name.
+
DROP TEXT SEARCH CONFIGURATION
DROP TEXT SEARCH CONFIGURATION — remove a text search configuration
Synopsis
+DROP TEXT SEARCH CONFIGURATION [ IF EXISTS ] name [ CASCADE | RESTRICT ]
+
Description
+ DROP TEXT SEARCH CONFIGURATION drops an existing text
+ search configuration. To execute this command you must be the owner of the
+ configuration.
+
Parameters
IF EXISTS
+ Do not throw an error if the text search configuration does not exist.
+ A notice is issued in this case.
+
name
+ The name (optionally schema-qualified) of an existing text search
+ configuration.
+
CASCADE
+ Automatically drop objects that depend on the text search configuration,
+ and in turn all objects that depend on those objects
+ (see Section 5.14).
+
RESTRICT
+ Refuse to drop the text search configuration if any objects depend on it.
+ This is the default.
+
Examples
+ Remove the text search configuration my_english:
+
+
+DROP TEXT SEARCH CONFIGURATION my_english;
+
+
+ This command will not succeed if there are any existing indexes
+ that reference the configuration in to_tsvector calls.
+ Add CASCADE to
+ drop such indexes along with the text search configuration.
+
Compatibility
+ There is no DROP TEXT SEARCH CONFIGURATION statement in
+ the SQL standard.
+
DROP TEXT SEARCH DICTIONARY
DROP TEXT SEARCH DICTIONARY — remove a text search dictionary
Synopsis
+DROP TEXT SEARCH DICTIONARY [ IF EXISTS ] name [ CASCADE | RESTRICT ]
+
Description
+ DROP TEXT SEARCH DICTIONARY drops an existing text
+ search dictionary. To execute this command you must be the owner of the
+ dictionary.
+
Parameters
IF EXISTS
+ Do not throw an error if the text search dictionary does not exist.
+ A notice is issued in this case.
+
name
+ The name (optionally schema-qualified) of an existing text search
+ dictionary.
+
CASCADE
+ Automatically drop objects that depend on the text search dictionary,
+ and in turn all objects that depend on those objects
+ (see Section 5.14).
+
RESTRICT
+ Refuse to drop the text search dictionary if any objects depend on it.
+ This is the default.
+
Examples
+ Remove the text search dictionary english:
+
+
+DROP TEXT SEARCH DICTIONARY english;
+
+
+ This command will not succeed if there are any existing text search
+ configurations that use the dictionary. Add CASCADE to
+ drop such configurations along with the dictionary.
+
Compatibility
+ There is no DROP TEXT SEARCH DICTIONARY statement in the
+ SQL standard.
+
DROP TEXT SEARCH PARSER
DROP TEXT SEARCH PARSER — remove a text search parser
Synopsis
+DROP TEXT SEARCH PARSER [ IF EXISTS ] name [ CASCADE | RESTRICT ]
+
Description
+ DROP TEXT SEARCH PARSER drops an existing text search
+ parser. You must be a superuser to use this command.
+
Parameters
IF EXISTS
+ Do not throw an error if the text search parser does not exist.
+ A notice is issued in this case.
+
name
+ The name (optionally schema-qualified) of an existing text search parser.
+
CASCADE
+ Automatically drop objects that depend on the text search parser,
+ and in turn all objects that depend on those objects
+ (see Section 5.14).
+
RESTRICT
+ Refuse to drop the text search parser if any objects depend on it.
+ This is the default.
+
Examples
+ Remove the text search parser my_parser:
+
+
+DROP TEXT SEARCH PARSER my_parser;
+
+
+ This command will not succeed if there are any existing text search
+ configurations that use the parser. Add CASCADE to
+ drop such configurations along with the parser.
+
Compatibility
+ There is no DROP TEXT SEARCH PARSER statement in the
+ SQL standard.
+
DROP TEXT SEARCH TEMPLATE
DROP TEXT SEARCH TEMPLATE — remove a text search template
Synopsis
+DROP TEXT SEARCH TEMPLATE [ IF EXISTS ] name [ CASCADE | RESTRICT ]
+
Description
+ DROP TEXT SEARCH TEMPLATE drops an existing text search
+ template. You must be a superuser to use this command.
+
Parameters
IF EXISTS
+ Do not throw an error if the text search template does not exist.
+ A notice is issued in this case.
+
name
+ The name (optionally schema-qualified) of an existing text search
+ template.
+
CASCADE
+ Automatically drop objects that depend on the text search template,
+ and in turn all objects that depend on those objects
+ (see Section 5.14).
+
RESTRICT
+ Refuse to drop the text search template if any objects depend on it.
+ This is the default.
+
Examples
+ Remove the text search template thesaurus:
+
+
+DROP TEXT SEARCH TEMPLATE thesaurus;
+
+
+ This command will not succeed if there are any existing text search
+ dictionaries that use the template. Add CASCADE to
+ drop such dictionaries along with the template.
+
Compatibility
+ There is no DROP TEXT SEARCH TEMPLATE statement in the
+ SQL standard.
+
DROP TYPE
DROP TYPE — remove a data type
Synopsis
+DROP TYPE [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
+
Description
+ DROP TYPE removes a user-defined data type.
+ Only the owner of a type can remove it.
+
Parameters
IF EXISTS
+ Do not throw an error if the type does not exist. A notice is issued
+ in this case.
+
name
+ The name (optionally schema-qualified) of the data type to remove.
+
CASCADE
+ Automatically drop objects that depend on the type (such as
+ table columns, functions, and operators),
+ and in turn all objects that depend on those objects
+ (see Section 5.14).
+
RESTRICT
+ Refuse to drop the type if any objects depend on it. This is
+ the default.
+
Examples
+ To remove the data type box:
+
+DROP TYPE box;
+
Compatibility
+ This command is similar to the corresponding command in the SQL
+ standard, apart from the IF EXISTS
+ option, which is a PostgreSQL extension.
+ But note that much of the CREATE TYPE command
+ and the data type extension mechanisms in
+ PostgreSQL differ from the SQL standard.
+
DROP USER
DROP USER — remove a database role
Synopsis
+DROP USER [ IF EXISTS ] name [, ...]
+
Description
+ DROP USER is simply an alternate spelling of
+ DROP ROLE.
+
Compatibility
+ The DROP USER statement is a
+ PostgreSQL extension. The SQL standard
+ leaves the definition of users to the implementation.
+
DROP USER MAPPING
DROP USER MAPPING — remove a user mapping for a foreign server
Synopsis
+DROP USER MAPPING [ IF EXISTS ] FOR { user_name | USER | CURRENT_ROLE | CURRENT_USER | PUBLIC } SERVER server_name
+Description
+ DROP USER MAPPING removes an existing user
+ mapping from foreign server.
+
+ The owner of a foreign server can drop user mappings for that server
+ for any user. Also, a user can drop a user mapping for their own
+ user name if USAGE privilege on the server has been
+ granted to the user.
+
Parameters
IF EXISTS
+ Do not throw an error if the user mapping does not exist. A
+ notice is issued in this case.
+
user_name
+ User name of the mapping. CURRENT_ROLE, CURRENT_USER,
+ and USER match the name of the current
+ user. PUBLIC is used to match all present and
+ future user names in the system.
+
server_name
+ Server name of the user mapping.
+
Examples
+ Drop a user mapping bob, server foo if it exists:
+
+DROP USER MAPPING IF EXISTS FOR bob SERVER foo;
+
Compatibility
+ DROP USER MAPPING conforms to ISO/IEC 9075-9
+ (SQL/MED). The IF EXISTS clause is
+ a PostgreSQL extension.
+
DROP VIEW
DROP VIEW — remove a view
Synopsis
+DROP VIEW [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
+
Description
+ DROP VIEW drops an existing view. To execute
+ this command you must be the owner of the view.
+
Parameters
IF EXISTS
+ Do not throw an error if the view does not exist. A notice is issued
+ in this case.
+
name
+ The name (optionally schema-qualified) of the view to remove.
+
CASCADE
+ Automatically drop objects that depend on the view (such as
+ other views),
+ and in turn all objects that depend on those objects
+ (see Section 5.14).
+
RESTRICT
+ Refuse to drop the view if any objects depend on it. This is
+ the default.
+
Examples
+ This command will remove the view called kinds:
+
+DROP VIEW kinds;
+
Compatibility
+ This command conforms to the SQL standard, except that the standard only
+ allows one view to be dropped per command, and apart from the
+ IF EXISTS option, which is a PostgreSQL
+ extension.
+
END
END — commit the current transaction
Synopsis
+END [ WORK | TRANSACTION ] [ AND [ NO ] CHAIN ]
+
Description
+ END commits the current transaction. All changes
+ made by the transaction become visible to others and are guaranteed
+ to be durable if a crash occurs. This command is a
+ PostgreSQL extension
+ that is equivalent to COMMIT.
+
Parameters
WORK
TRANSACTION
+ Optional key words. They have no effect.
+
AND CHAIN
+ If AND CHAIN is specified, a new transaction is
+ immediately started with the same transaction characteristics (see SET TRANSACTION) as the just finished one. Otherwise,
+ no new transaction is started.
+
Notes
+ Use ROLLBACK to
+ abort a transaction.
+
+ Issuing END when not inside a transaction does
+ no harm, but it will provoke a warning message.
+
Examples
+ To commit the current transaction and make all changes permanent:
+
+END;
+
Compatibility
+ END is a PostgreSQL
+ extension that provides functionality equivalent to COMMIT, which is
+ specified in the SQL standard.
+
EXECUTE
EXECUTE — execute a prepared statement
Synopsis
+EXECUTE name [ ( parameter [, ...] ) ]
+
Description
+ EXECUTE is used to execute a previously prepared
+ statement. Since prepared statements only exist for the duration of a
+ session, the prepared statement must have been created by a
+ PREPARE statement executed earlier in the
+ current session.
+
+ If the PREPARE statement that created the statement
+ specified some parameters, a compatible set of parameters must be
+ passed to the EXECUTE statement, or else an
+ error is raised. Note that (unlike functions) prepared statements are
+ not overloaded based on the type or number of their parameters; the
+ name of a prepared statement must be unique within a database session.
+
+ For more information on the creation and usage of prepared statements,
+ see PREPARE.
+
Parameters
name
+ The name of the prepared statement to execute.
+
parameter
+ The actual value of a parameter to the prepared statement. This
+ must be an expression yielding a value that is compatible with
+ the data type of this parameter, as was determined when the
+ prepared statement was created.
+
Outputs
+ The command tag returned by EXECUTE
+ is that of the prepared statement, and not EXECUTE.
+
Examples
+ Examples are given in Examples
+ in the PREPARE documentation.
+
Compatibility
+ The SQL standard includes an EXECUTE statement,
+ but it is only for use in embedded SQL. This version of the
+ EXECUTE statement also uses a somewhat different
+ syntax.
+
EXPLAIN
EXPLAIN — show the execution plan of a statement
Synopsis
+EXPLAIN [ ( option [, ...] ) ] statement
+EXPLAIN [ ANALYZE ] [ VERBOSE ] statement
+
+where option can be one of:
+
+ ANALYZE [ boolean ]
+ VERBOSE [ boolean ]
+ COSTS [ boolean ]
+ SETTINGS [ boolean ]
+ GENERIC_PLAN [ boolean ]
+ BUFFERS [ boolean ]
+ WAL [ boolean ]
+ TIMING [ boolean ]
+ SUMMARY [ boolean ]
+ FORMAT { TEXT | XML | JSON | YAML }
+
Description
+ This command displays the execution plan that the
+ PostgreSQL planner generates for the
+ supplied statement. The execution plan shows how the table(s)
+ referenced by the statement will be scanned — by plain sequential scan,
+ index scan, etc. — and if multiple tables are referenced, what join
+ algorithms will be used to bring together the required rows from
+ each input table.
+
+ The most critical part of the display is the estimated statement execution
+ cost, which is the planner's guess at how long it will take to run the
+ statement (measured in cost units that are arbitrary, but conventionally
+ mean disk page fetches). Actually two numbers
+ are shown: the start-up cost before the first row can be returned, and
+ the total cost to return all the rows. For most queries the total cost
+ is what matters, but in contexts such as a subquery in EXISTS, the planner
+ will choose the smallest start-up cost instead of the smallest total cost
+ (since the executor will stop after getting one row, anyway).
+ Also, if you limit the number of rows to return with a LIMIT clause,
+ the planner makes an appropriate interpolation between the endpoint
+ costs to estimate which plan is really the cheapest.
+
+ The ANALYZE option causes the statement to be actually
+ executed, not only planned. Then actual run time statistics are added to
+ the display, including the total elapsed time expended within each plan
+ node (in milliseconds) and the total number of rows it actually returned.
+ This is useful for seeing whether the planner's estimates
+ are close to reality.
+
Important
+ Keep in mind that the statement is actually executed when
+ the ANALYZE option is used. Although
+ EXPLAIN will discard any output that a
+ SELECT would return, other side effects of the
+ statement will happen as usual. If you wish to use
+ EXPLAIN ANALYZE on an
+ INSERT, UPDATE,
+ DELETE, MERGE,
+ CREATE TABLE AS,
+ or EXECUTE statement
+ without letting the command affect your data, use this approach:
+
+BEGIN;
+EXPLAIN ANALYZE ...;
+ROLLBACK;
+
+
+ Only the ANALYZE and VERBOSE options
+ can be specified, and only in that order, without surrounding the option
+ list in parentheses. Prior to PostgreSQL 9.0,
+ the unparenthesized syntax was the only one supported. It is expected that
+ all new options will be supported only in the parenthesized syntax.
+
Parameters
ANALYZE
+ Carry out the command and show actual run times and other statistics.
+ This parameter defaults to FALSE.
+
VERBOSE
+ Display additional information regarding the plan. Specifically, include
+ the output column list for each node in the plan tree, schema-qualify
+ table and function names, always label variables in expressions with
+ their range table alias, and always print the name of each trigger for
+ which statistics are displayed. The query identifier will also be
+ displayed if one has been computed, see compute_query_id for more details. This parameter
+ defaults to FALSE.
+
COSTS
+ Include information on the estimated startup and total cost of each
+ plan node, as well as the estimated number of rows and the estimated
+ width of each row.
+ This parameter defaults to TRUE.
+
SETTINGS
+ Include information on configuration parameters. Specifically, include
+ options affecting query planning with value different from the built-in
+ default value. This parameter defaults to FALSE.
+
GENERIC_PLAN
+ Allow the statement to contain parameter placeholders like
+ $1, and generate a generic plan that does not
+ depend on the values of those parameters.
+ See PREPARE
+ for details about generic plans and the types of statement that
+ support parameters.
+ This parameter cannot be used together with ANALYZE.
+ It defaults to FALSE.
+
BUFFERS
+ Include information on buffer usage. Specifically, include the number of
+ shared blocks hit, read, dirtied, and written, the number of local blocks
+ hit, read, dirtied, and written, the number of temp blocks read and
+ written, and the time spent reading and writing data file blocks and
+ temporary file blocks (in milliseconds) if
+ track_io_timing is enabled. A
+ hit means that a read was avoided because the block
+ was found already in cache when needed.
+ Shared blocks contain data from regular tables and indexes;
+ local blocks contain data from temporary tables and indexes;
+ while temporary blocks contain short-term working data used in sorts,
+ hashes, Materialize plan nodes, and similar cases.
+ The number of blocks dirtied indicates the number of
+ previously unmodified blocks that were changed by this query; while the
+ number of blocks written indicates the number of
+ previously-dirtied blocks evicted from cache by this backend during
+ query processing.
+ The number of blocks shown for an
+ upper-level node includes those used by all its child nodes. In text
+ format, only non-zero values are printed. This parameter defaults to
+ FALSE.
+
WAL
+ Include information on WAL record generation. Specifically, include the
+ number of records, number of full page images (fpi) and the amount of WAL
+ generated in bytes. In text format, only non-zero values are printed.
+ This parameter may only be used when ANALYZE is also
+ enabled. It defaults to FALSE.
+
TIMING
+ Include actual startup time and time spent in each node in the output.
+ The overhead of repeatedly reading the system clock can slow down the
+ query significantly on some systems, so it may be useful to set this
+ parameter to FALSE when only actual row counts, and
+ not exact times, are needed. Run time of the entire statement is
+ always measured, even when node-level timing is turned off with this
+ option.
+ This parameter may only be used when ANALYZE is also
+ enabled. It defaults to TRUE.
+
SUMMARY
+ Include summary information (e.g., totaled timing information) after the
+ query plan. Summary information is included by default when
+ ANALYZE is used but otherwise is not included by
+ default, but can be enabled using this option. Planning time in
+ EXPLAIN EXECUTE includes the time required to fetch
+ the plan from the cache and the time required for re-planning, if
+ necessary.
+
FORMAT
+ Specify the output format, which can be TEXT, XML, JSON, or YAML.
+ Non-text output contains the same information as the text output
+ format, but is easier for programs to parse. This parameter defaults to
+ TEXT.
+
boolean
+ Specifies whether the selected option should be turned on or off.
+ You can write TRUE, ON, or
+ 1 to enable the option, and FALSE,
+ OFF, or 0 to disable it. The
+ boolean value can also
+ be omitted, in which case TRUE is assumed.
+
statement
+ Any SELECT, INSERT, UPDATE,
+ DELETE, MERGE,
+ VALUES, EXECUTE,
+ DECLARE, CREATE TABLE AS, or
+ CREATE MATERIALIZED VIEW AS statement, whose execution
+ plan you wish to see.
+
Outputs
+ The command's result is a textual description of the plan selected
+ for the statement,
+ optionally annotated with execution statistics.
+ Section 14.1 describes the information provided.
+
Notes
+ In order to allow the PostgreSQL query
+ planner to make reasonably informed decisions when optimizing
+ queries, the pg_statistic
+ data should be up-to-date for all tables used in the query. Normally
+ the autovacuum daemon will take care
+ of that automatically. But if a table has recently had substantial
+ changes in its contents, you might need to do a manual
+ ANALYZE rather than wait for autovacuum to catch up
+ with the changes.
+
+ In order to measure the run-time cost of each node in the execution
+ plan, the current implementation of EXPLAIN
+ ANALYZE adds profiling overhead to query execution.
+ As a result, running EXPLAIN ANALYZE
+ on a query can sometimes take significantly longer than executing
+ the query normally. The amount of overhead depends on the nature of
+ the query, as well as the platform being used. The worst case occurs
+ for plan nodes that in themselves require very little time per
+ execution, and on machines that have relatively slow operating
+ system calls for obtaining the time of day.
+
Examples
+ To show the plan for a simple query on a table with a single
+ integer column and 10000 rows:
+
+
+EXPLAIN SELECT * FROM foo;
+
+ QUERY PLAN
+---------------------------------------------------------
+ Seq Scan on foo (cost=0.00..155.00 rows=10000 width=4)
+(1 row)
+
+
+ Here is the same query, with JSON output formatting:
+
+EXPLAIN (FORMAT JSON) SELECT * FROM foo;
+ QUERY PLAN
+--------------------------------
+ [ +
+ { +
+ "Plan": { +
+ "Node Type": "Seq Scan",+
+ "Relation Name": "foo", +
+ "Alias": "foo", +
+ "Startup Cost": 0.00, +
+ "Total Cost": 155.00, +
+ "Plan Rows": 10000, +
+ "Plan Width": 4 +
+ } +
+ } +
+ ]
+(1 row)
+
+
+ If there is an index and we use a query with an indexable
+ WHERE condition, EXPLAIN
+ might show a different plan:
+
+
+EXPLAIN SELECT * FROM foo WHERE i = 4;
+
+ QUERY PLAN
+--------------------------------------------------------------
+ Index Scan using fi on foo (cost=0.00..5.98 rows=1 width=4)
+ Index Cond: (i = 4)
+(2 rows)
+
+
+ Here is the same query, but in YAML format:
+
+EXPLAIN (FORMAT YAML) SELECT * FROM foo WHERE i='4';
+ QUERY PLAN
+-------------------------------
+ - Plan: +
+ Node Type: "Index Scan" +
+ Scan Direction: "Forward"+
+ Index Name: "fi" +
+ Relation Name: "foo" +
+ Alias: "foo" +
+ Startup Cost: 0.00 +
+ Total Cost: 5.98 +
+ Plan Rows: 1 +
+ Plan Width: 4 +
+ Index Cond: "(i = 4)"
+(1 row)
+
+
+ XML format is left as an exercise for the reader.
+
+ Here is the same plan with cost estimates suppressed:
+
+
+EXPLAIN (COSTS FALSE) SELECT * FROM foo WHERE i = 4;
+
+ QUERY PLAN
+----------------------------
+ Index Scan using fi on foo
+ Index Cond: (i = 4)
+(2 rows)
+
+
+ Here is an example of a query plan for a query using an aggregate
+ function:
+
+
+EXPLAIN SELECT sum(i) FROM foo WHERE i < 10;
+
+ QUERY PLAN
+---------------------------------------------------------------------
+ Aggregate (cost=23.93..23.93 rows=1 width=4)
+ -> Index Scan using fi on foo (cost=0.00..23.92 rows=6 width=4)
+ Index Cond: (i < 10)
+(3 rows)
+
+
+ Here is an example of using EXPLAIN EXECUTE to
+ display the execution plan for a prepared query:
+
+
+PREPARE query(int, int) AS SELECT sum(bar) FROM test
+ WHERE id > $1 AND id < $2
+ GROUP BY foo;
+
+EXPLAIN ANALYZE EXECUTE query(100, 200);
+
+ QUERY PLAN
+-------------------------------------------------------------------------------------------------------------------------
+ HashAggregate (cost=10.77..10.87 rows=10 width=12) (actual time=0.043..0.044 rows=10 loops=1)
+ Group Key: foo
+ Batches: 1 Memory Usage: 24kB
+ -> Index Scan using test_pkey on test (cost=0.29..10.27 rows=99 width=8) (actual time=0.009..0.025 rows=99 loops=1)
+ Index Cond: ((id > 100) AND (id < 200))
+ Planning Time: 0.244 ms
+ Execution Time: 0.073 ms
+(7 rows)
+
+
+ Of course, the specific numbers shown here depend on the actual
+ contents of the tables involved. Also note that the numbers, and
+ even the selected query strategy, might vary between
+ PostgreSQL releases due to planner
+ improvements. In addition, the ANALYZE command
+ uses random sampling to estimate data statistics; therefore, it is
+ possible for cost estimates to change after a fresh run of
+ ANALYZE, even if the actual distribution of data
+ in the table has not changed.
+
+ Notice that the previous example showed a “custom” plan
+ for the specific parameter values given in EXECUTE.
+ We might also wish to see the generic plan for a parameterized
+ query, which can be done with GENERIC_PLAN:
+
+
+EXPLAIN (GENERIC_PLAN)
+ SELECT sum(bar) FROM test
+ WHERE id > $1 AND id < $2
+ GROUP BY foo;
+
+ QUERY PLAN
+-------------------------------------------------------------------------------
+ HashAggregate (cost=26.79..26.89 rows=10 width=12)
+ Group Key: foo
+ -> Index Scan using test_pkey on test (cost=0.29..24.29 rows=500 width=8)
+ Index Cond: ((id > $1) AND (id < $2))
+(4 rows)
+
+
+ In this case the parser correctly inferred that $1
+ and $2 should have the same data type
+ as id, so the lack of parameter type information
+ from PREPARE was not a problem. In other cases
+ it might be necessary to explicitly specify types for the parameter
+ symbols, which can be done by casting them, for example:
+
+
+EXPLAIN (GENERIC_PLAN)
+ SELECT sum(bar) FROM test
+ WHERE id > $1::integer AND id < $2::integer
+ GROUP BY foo;
+
+
Compatibility
+ There is no EXPLAIN statement defined in the SQL standard.
+
+ Value expressions are used in a variety of contexts, such
+ as in the target list of the SELECT command, as
+ new column values in INSERT or
+ UPDATE, or in search conditions in a number of
+ commands. The result of a value expression is sometimes called a
+ scalar, to distinguish it from the result of
+ a table expression (which is a table). Value expressions are
+ therefore also called scalar expressions (or
+ even simply expressions). The expression
+ syntax allows the calculation of values from primitive parts using
+ arithmetic, logical, set, and other operations.
+
+ A value expression is one of the following:
+
+
+ A constant or literal value
+
+ A column reference
+
+ A positional parameter reference, in the body of a function definition
+ or prepared statement
+
+ A subscripted expression
+
+ A field selection expression
+
+ An operator invocation
+
+ A function call
+
+ An aggregate expression
+
+ A window function call
+
+ A type cast
+
+ A collation expression
+
+ A scalar subquery
+
+ An array constructor
+
+ A row constructor
+
+ Another value expression in parentheses (used to group
+ subexpressions and override
+ precedence)
+
+
+ In addition to this list, there are a number of constructs that can
+ be classified as an expression but do not follow any general syntax
+ rules. These generally have the semantics of a function or
+ operator and are explained in the appropriate location in Chapter 9. An example is the IS NULL
+ clause.
+
+ We have already discussed constants in Section 4.1.2. The following sections discuss
+ the remaining options.
+
4.2.1. Column References #
+ A column can be referenced in the form:
+
+correlation.columnname
+
+
+ correlation is the name of a
+ table (possibly qualified with a schema name), or an alias for a table
+ defined by means of a FROM clause.
+ The correlation name and separating dot can be omitted if the column name
+ is unique across all the tables being used in the current query. (See also Chapter 7.)
+
4.2.2. Positional Parameters #
+ A positional parameter reference is used to indicate a value
+ that is supplied externally to an SQL statement. Parameters are
+ used in SQL function definitions and in prepared queries. Some
+ client libraries also support specifying data values separately
+ from the SQL command string, in which case parameters are used to
+ refer to the out-of-line data values.
+ The form of a parameter reference is:
+
+$number
+
+
+ For example, consider the definition of a function,
+ dept, as:
+
+
+CREATE FUNCTION dept(text) RETURNS dept
+ AS $$ SELECT * FROM dept WHERE name = $1 $$
+ LANGUAGE SQL;
+
+
+ Here the $1 references the value of the first
+ function argument whenever the function is invoked.
+
+ If an expression yields a value of an array type, then a specific
+ element of the array value can be extracted by writing
+
+expression[subscript]
+
+ or multiple adjacent elements (an “array slice”) can be extracted
+ by writing
+
+expression[lower_subscript:upper_subscript]
+
+ (Here, the brackets [ ] are meant to appear literally.)
+ Each subscript is itself an expression,
+ which will be rounded to the nearest integer value.
+
+ In general the array expression must be
+ parenthesized, but the parentheses can be omitted when the expression
+ to be subscripted is just a column reference or positional parameter.
+ Also, multiple subscripts can be concatenated when the original array
+ is multidimensional.
+ For example:
+
+
+mytable.arraycolumn[4]
+mytable.two_d_column[17][34]
+$1[10:42]
+(arrayfunction(a,b))[42]
+
+
+ The parentheses in the last example are required.
+ See Section 8.15 for more about arrays.
+
+ If an expression yields a value of a composite type (row type), then a
+ specific field of the row can be extracted by writing
+
+expression.fieldname
+
+
+ In general the row expression must be
+ parenthesized, but the parentheses can be omitted when the expression
+ to be selected from is just a table reference or positional parameter.
+ For example:
+
+
+mytable.mycolumn
+$1.somecolumn
+(rowfunction(a,b)).col3
+
+
+ (Thus, a qualified column reference is actually just a special case
+ of the field selection syntax.) An important special case is
+ extracting a field from a table column that is of a composite type:
+
+
+(compositecol).somefield
+(mytable.compositecol).somefield
+
+
+ The parentheses are required here to show that
+ compositecol is a column name not a table name,
+ or that mytable is a table name not a schema name
+ in the second case.
+
+ You can ask for all fields of a composite value by
+ writing .*:
+
+(compositecol).*
+
+ This notation behaves differently depending on context;
+ see Section 8.16.5 for details.
+
4.2.5. Operator Invocations #
+ There are two possible syntaxes for an operator invocation:
+
expression operator expression (binary infix operator) |
operator expression (unary prefix operator) |
+ where the operator token follows the syntax
+ rules of Section 4.1.3, or is one of the
+ key words AND, OR, and
+ NOT, or is a qualified operator name in the form:
+
+OPERATOR(schema.operatorname)
+
+ Which particular operators exist and whether
+ they are unary or binary depends on what operators have been
+ defined by the system or the user. Chapter 9
+ describes the built-in operators.
+
+ The syntax for a function call is the name of a function
+ (possibly qualified with a schema name), followed by its argument list
+ enclosed in parentheses:
+
+
+function_name ([expression [, expression ... ]] )
+
+
+ For example, the following computes the square root of 2:
+
+sqrt(2)
+
+
+ The list of built-in functions is in Chapter 9.
+ Other functions can be added by the user.
+
+ When issuing queries in a database where some users mistrust other users,
+ observe security precautions from Section 10.3 when
+ writing function calls.
+
+ The arguments can optionally have names attached.
+ See Section 4.3 for details.
+
Note
+ A function that takes a single argument of composite type can
+ optionally be called using field-selection syntax, and conversely
+ field selection can be written in functional style. That is, the
+ notations col(table) and table.col are
+ interchangeable. This behavior is not SQL-standard but is provided
+ in PostgreSQL because it allows use of functions to
+ emulate “computed fields”. For more information see
+ Section 8.16.5.
+
4.2.7. Aggregate Expressions #
+ An aggregate expression represents the
+ application of an aggregate function across the rows selected by a
+ query. An aggregate function reduces multiple inputs to a single
+ output value, such as the sum or average of the inputs. The
+ syntax of an aggregate expression is one of the following:
+
+
+aggregate_name (expression [ , ... ] [ order_by_clause ] ) [ FILTER ( WHERE filter_clause ) ]
+aggregate_name (ALL expression [ , ... ] [ order_by_clause ] ) [ FILTER ( WHERE filter_clause ) ]
+aggregate_name (DISTINCT expression [ , ... ] [ order_by_clause ] ) [ FILTER ( WHERE filter_clause ) ]
+aggregate_name ( * ) [ FILTER ( WHERE filter_clause ) ]
+aggregate_name ( [ expression [ , ... ] ] ) WITHIN GROUP ( order_by_clause ) [ FILTER ( WHERE filter_clause ) ]
+
+
+ where aggregate_name is a previously
+ defined aggregate (possibly qualified with a schema name) and
+ expression is
+ any value expression that does not itself contain an aggregate
+ expression or a window function call. The optional
+ order_by_clause and
+ filter_clause are described below.
+
+ The first form of aggregate expression invokes the aggregate
+ once for each input row.
+ The second form is the same as the first, since
+ ALL is the default.
+ The third form invokes the aggregate once for each distinct value
+ of the expression (or distinct set of values, for multiple expressions)
+ found in the input rows.
+ The fourth form invokes the aggregate once for each input row; since no
+ particular input value is specified, it is generally only useful
+ for the count(*) aggregate function.
+ The last form is used with ordered-set aggregate
+ functions, which are described below.
+
+ Most aggregate functions ignore null inputs, so that rows in which
+ one or more of the expression(s) yield null are discarded. This
+ can be assumed to be true, unless otherwise specified, for all
+ built-in aggregates.
+
+ For example, count(*) yields the total number
+ of input rows; count(f1) yields the number of
+ input rows in which f1 is non-null, since
+ count ignores nulls; and
+ count(distinct f1) yields the number of
+ distinct non-null values of f1.
+
+ Ordinarily, the input rows are fed to the aggregate function in an
+ unspecified order. In many cases this does not matter; for example,
+ min produces the same result no matter what order it
+ receives the inputs in. However, some aggregate functions
+ (such as array_agg and string_agg) produce
+ results that depend on the ordering of the input rows. When using
+ such an aggregate, the optional order_by_clause can be
+ used to specify the desired ordering. The order_by_clause
+ has the same syntax as for a query-level ORDER BY clause, as
+ described in Section 7.5, except that its expressions
+ are always just expressions and cannot be output-column names or numbers.
+ For example:
+
+SELECT array_agg(a ORDER BY b DESC) FROM table;
+
+
+ When dealing with multiple-argument aggregate functions, note that the
+ ORDER BY clause goes after all the aggregate arguments.
+ For example, write this:
+
+SELECT string_agg(a, ',' ORDER BY a) FROM table;
+
+ not this:
+
+SELECT string_agg(a ORDER BY a, ',') FROM table; -- incorrect
+
+ The latter is syntactically valid, but it represents a call of a
+ single-argument aggregate function with two ORDER BY keys
+ (the second one being rather useless since it's a constant).
+
+ If DISTINCT is specified in addition to an
+ order_by_clause, then all the ORDER BY
+ expressions must match regular arguments of the aggregate; that is,
+ you cannot sort on an expression that is not included in the
+ DISTINCT list.
+
Note
+ The ability to specify both DISTINCT and ORDER BY
+ in an aggregate function is a PostgreSQL extension.
+
+ Placing ORDER BY within the aggregate's regular argument
+ list, as described so far, is used when ordering the input rows for
+ general-purpose and statistical aggregates, for which ordering is
+ optional. There is a
+ subclass of aggregate functions called ordered-set
+ aggregates for which an order_by_clause
+ is required, usually because the aggregate's computation is
+ only sensible in terms of a specific ordering of its input rows.
+ Typical examples of ordered-set aggregates include rank and percentile
+ calculations. For an ordered-set aggregate,
+ the order_by_clause is written
+ inside WITHIN GROUP (...), as shown in the final syntax
+ alternative above. The expressions in
+ the order_by_clause are evaluated once per
+ input row just like regular aggregate arguments, sorted as per
+ the order_by_clause's requirements, and fed
+ to the aggregate function as input arguments. (This is unlike the case
+ for a non-WITHIN GROUP order_by_clause,
+ which is not treated as argument(s) to the aggregate function.) The
+ argument expressions preceding WITHIN GROUP, if any, are
+ called direct arguments to distinguish them from
+ the aggregated arguments listed in
+ the order_by_clause. Unlike regular aggregate
+ arguments, direct arguments are evaluated only once per aggregate call,
+ not once per input row. This means that they can contain variables only
+ if those variables are grouped by GROUP BY; this restriction
+ is the same as if the direct arguments were not inside an aggregate
+ expression at all. Direct arguments are typically used for things like
+ percentile fractions, which only make sense as a single value per
+ aggregation calculation. The direct argument list can be empty; in this
+ case, write just () not (*).
+ (PostgreSQL will actually accept either spelling, but
+ only the first way conforms to the SQL standard.)
+
+
+ An example of an ordered-set aggregate call is:
+
+
+SELECT percentile_cont(0.5) WITHIN GROUP (ORDER BY income) FROM households;
+ percentile_cont
+-----------------
+ 50489
+
+
+ which obtains the 50th percentile, or median, value of
+ the income column from table households.
+ Here, 0.5 is a direct argument; it would make no sense
+ for the percentile fraction to be a value varying across rows.
+
+ If FILTER is specified, then only the input
+ rows for which the filter_clause
+ evaluates to true are fed to the aggregate function; other rows
+ are discarded. For example:
+
+SELECT
+ count(*) AS unfiltered,
+ count(*) FILTER (WHERE i < 5) AS filtered
+FROM generate_series(1,10) AS s(i);
+ unfiltered | filtered
+------------+----------
+ 10 | 4
+(1 row)
+
+
+ The predefined aggregate functions are described in Section 9.21. Other aggregate functions can be added
+ by the user.
+
+ An aggregate expression can only appear in the result list or
+ HAVING clause of a SELECT command.
+ It is forbidden in other clauses, such as WHERE,
+ because those clauses are logically evaluated before the results
+ of aggregates are formed.
+
+ When an aggregate expression appears in a subquery (see
+ Section 4.2.11 and
+ Section 9.23), the aggregate is normally
+ evaluated over the rows of the subquery. But an exception occurs
+ if the aggregate's arguments (and filter_clause
+ if any) contain only outer-level variables:
+ the aggregate then belongs to the nearest such outer level, and is
+ evaluated over the rows of that query. The aggregate expression
+ as a whole is then an outer reference for the subquery it appears in,
+ and acts as a constant over any one evaluation of that subquery.
+ The restriction about
+ appearing only in the result list or HAVING clause
+ applies with respect to the query level that the aggregate belongs to.
+
4.2.8. Window Function Calls #
+ A window function call represents the application
+ of an aggregate-like function over some portion of the rows selected
+ by a query. Unlike non-window aggregate calls, this is not tied
+ to grouping of the selected rows into a single output row — each
+ row remains separate in the query output. However the window function
+ has access to all the rows that would be part of the current row's
+ group according to the grouping specification (PARTITION BY
+ list) of the window function call.
+ The syntax of a window function call is one of the following:
+
+
+function_name ([expression [, expression ... ]]) [ FILTER ( WHERE filter_clause ) ] OVER window_name
+function_name ([expression [, expression ... ]]) [ FILTER ( WHERE filter_clause ) ] OVER ( window_definition )
+function_name ( * ) [ FILTER ( WHERE filter_clause ) ] OVER window_name
+function_name ( * ) [ FILTER ( WHERE filter_clause ) ] OVER ( window_definition )
+
+ where window_definition
+ has the syntax
+
+[ existing_window_name ]
+[ PARTITION BY expression [, ...] ]
+[ ORDER BY expression [ ASC | DESC | USING operator ] [ NULLS { FIRST | LAST } ] [, ...] ]
+[ frame_clause ]
+
+ The optional frame_clause
+ can be one of
+
+{ RANGE | ROWS | GROUPS } frame_start [ frame_exclusion ]
+{ RANGE | ROWS | GROUPS } BETWEEN frame_start AND frame_end [ frame_exclusion ]
+
+ where frame_start
+ and frame_end can be one of
+
+UNBOUNDED PRECEDING
+offset PRECEDING
+CURRENT ROW
+offset FOLLOWING
+UNBOUNDED FOLLOWING
+
+ and frame_exclusion can be one of
+
+EXCLUDE CURRENT ROW
+EXCLUDE GROUP
+EXCLUDE TIES
+EXCLUDE NO OTHERS
+
+
+ Here, expression represents any value
+ expression that does not itself contain window function calls.
+
+ window_name is a reference to a named window
+ specification defined in the query's WINDOW clause.
+ Alternatively, a full window_definition can
+ be given within parentheses, using the same syntax as for defining a
+ named window in the WINDOW clause; see the
+ SELECT reference page for details. It's worth
+ pointing out that OVER wname is not exactly equivalent to
+ OVER (wname ...); the latter implies copying and modifying the
+ window definition, and will be rejected if the referenced window
+ specification includes a frame clause.
+
+ The PARTITION BY clause groups the rows of the query into
+ partitions, which are processed separately by the window
+ function. PARTITION BY works similarly to a query-level
+ GROUP BY clause, except that its expressions are always just
+ expressions and cannot be output-column names or numbers.
+ Without PARTITION BY, all rows produced by the query are
+ treated as a single partition.
+ The ORDER BY clause determines the order in which the rows
+ of a partition are processed by the window function. It works similarly
+ to a query-level ORDER BY clause, but likewise cannot use
+ output-column names or numbers. Without ORDER BY, rows are
+ processed in an unspecified order.
+
+ The frame_clause specifies
+ the set of rows constituting the window frame, which is a
+ subset of the current partition, for those window functions that act on
+ the frame instead of the whole partition. The set of rows in the frame
+ can vary depending on which row is the current row. The frame can be
+ specified in RANGE, ROWS
+ or GROUPS mode; in each case, it runs from
+ the frame_start to
+ the frame_end.
+ If frame_end is omitted, the end defaults
+ to CURRENT ROW.
+
+ A frame_start of UNBOUNDED PRECEDING means
+ that the frame starts with the first row of the partition, and similarly
+ a frame_end of UNBOUNDED FOLLOWING means
+ that the frame ends with the last row of the partition.
+
+ In RANGE or GROUPS mode,
+ a frame_start of
+ CURRENT ROW means the frame starts with the current
+ row's first peer row (a row that the
+ window's ORDER BY clause sorts as equivalent to the
+ current row), while a frame_end of
+ CURRENT ROW means the frame ends with the current
+ row's last peer row.
+ In ROWS mode, CURRENT ROW simply
+ means the current row.
+
+ In the offset PRECEDING
+ and offset FOLLOWING frame
+ options, the offset must be an expression not
+ containing any variables, aggregate functions, or window functions.
+ The meaning of the offset depends on the
+ frame mode:
+
+ In ROWS mode,
+ the offset must yield a non-null,
+ non-negative integer, and the option means that the frame starts or
+ ends the specified number of rows before or after the current row.
+
+ In GROUPS mode,
+ the offset again must yield a non-null,
+ non-negative integer, and the option means that the frame starts or
+ ends the specified number of peer groups
+ before or after the current row's peer group, where a peer group is a
+ set of rows that are equivalent in the ORDER BY
+ ordering. (There must be an ORDER BY clause
+ in the window definition to use GROUPS mode.)
+
+ In RANGE mode, these options require that
+ the ORDER BY clause specify exactly one column.
+ The offset specifies the maximum
+ difference between the value of that column in the current row and
+ its value in preceding or following rows of the frame. The data type
+ of the offset expression varies depending
+ on the data type of the ordering column. For numeric ordering
+ columns it is typically of the same type as the ordering column,
+ but for datetime ordering columns it is an interval.
+ For example, if the ordering column is of type date
+ or timestamp, one could write RANGE BETWEEN
+ '1 day' PRECEDING AND '10 days' FOLLOWING.
+ The offset is still required to be
+ non-null and non-negative, though the meaning
+ of “non-negative” depends on its data type.
+
+ In any case, the distance to the end of the frame is limited by the
+ distance to the end of the partition, so that for rows near the partition
+ ends the frame might contain fewer rows than elsewhere.
+
+ Notice that in both ROWS and GROUPS
+ mode, 0 PRECEDING and 0 FOLLOWING
+ are equivalent to CURRENT ROW. This normally holds
+ in RANGE mode as well, for an appropriate
+ data-type-specific meaning of “zero”.
+
+ The frame_exclusion option allows rows around
+ the current row to be excluded from the frame, even if they would be
+ included according to the frame start and frame end options.
+ EXCLUDE CURRENT ROW excludes the current row from the
+ frame.
+ EXCLUDE GROUP excludes the current row and its
+ ordering peers from the frame.
+ EXCLUDE TIES excludes any peers of the current
+ row from the frame, but not the current row itself.
+ EXCLUDE NO OTHERS simply specifies explicitly the
+ default behavior of not excluding the current row or its peers.
+
+ The default framing option is RANGE UNBOUNDED PRECEDING,
+ which is the same as RANGE BETWEEN UNBOUNDED PRECEDING AND
+ CURRENT ROW. With ORDER BY, this sets the frame to be
+ all rows from the partition start up through the current row's last
+ ORDER BY peer. Without ORDER BY,
+ this means all rows of the partition are included in the window frame,
+ since all rows become peers of the current row.
+
+ Restrictions are that
+ frame_start cannot be UNBOUNDED FOLLOWING,
+ frame_end cannot be UNBOUNDED PRECEDING,
+ and the frame_end choice cannot appear earlier in the
+ above list of frame_start
+ and frame_end options than
+ the frame_start choice does — for example
+ RANGE BETWEEN CURRENT ROW AND offset
+ PRECEDING is not allowed.
+ But, for example, ROWS BETWEEN 7 PRECEDING AND 8
+ PRECEDING is allowed, even though it would never select any
+ rows.
+
+ If FILTER is specified, then only the input
+ rows for which the filter_clause
+ evaluates to true are fed to the window function; other rows
+ are discarded. Only window functions that are aggregates accept
+ a FILTER clause.
+
+ The built-in window functions are described in Table 9.64. Other window functions can be added by
+ the user. Also, any built-in or user-defined general-purpose or
+ statistical aggregate can be used as a window function. (Ordered-set
+ and hypothetical-set aggregates cannot presently be used as window functions.)
+
+ The syntaxes using * are used for calling parameter-less
+ aggregate functions as window functions, for example
+ count(*) OVER (PARTITION BY x ORDER BY y).
+ The asterisk (*) is customarily not used for
+ window-specific functions. Window-specific functions do not
+ allow DISTINCT or ORDER BY to be used within the
+ function argument list.
+
+ Window function calls are permitted only in the SELECT
+ list and the ORDER BY clause of the query.
+
+ More information about window functions can be found in
+ Section 3.5,
+ Section 9.22, and
+ Section 7.2.5.
+
+ A type cast specifies a conversion from one data type to another.
+ PostgreSQL accepts two equivalent syntaxes
+ for type casts:
+
+CAST ( expression AS type )
+expression::type
+
+ The CAST syntax conforms to SQL; the syntax with
+ :: is historical PostgreSQL
+ usage.
+
+ When a cast is applied to a value expression of a known type, it
+ represents a run-time type conversion. The cast will succeed only
+ if a suitable type conversion operation has been defined. Notice that this
+ is subtly different from the use of casts with constants, as shown in
+ Section 4.1.2.7. A cast applied to an
+ unadorned string literal represents the initial assignment of a type
+ to a literal constant value, and so it will succeed for any type
+ (if the contents of the string literal are acceptable input syntax for the
+ data type).
+
+ An explicit type cast can usually be omitted if there is no ambiguity as
+ to the type that a value expression must produce (for example, when it is
+ assigned to a table column); the system will automatically apply a
+ type cast in such cases. However, automatic casting is only done for
+ casts that are marked “OK to apply implicitly”
+ in the system catalogs. Other casts must be invoked with
+ explicit casting syntax. This restriction is intended to prevent
+ surprising conversions from being applied silently.
+
+ It is also possible to specify a type cast using a function-like
+ syntax:
+
+typename ( expression )
+
+ However, this only works for types whose names are also valid as
+ function names. For example, double precision
+ cannot be used this way, but the equivalent float8
+ can. Also, the names interval, time, and
+ timestamp can only be used in this fashion if they are
+ double-quoted, because of syntactic conflicts. Therefore, the use of
+ the function-like cast syntax leads to inconsistencies and should
+ probably be avoided.
+
Note
+ The function-like syntax is in fact just a function call. When
+ one of the two standard cast syntaxes is used to do a run-time
+ conversion, it will internally invoke a registered function to
+ perform the conversion. By convention, these conversion functions
+ have the same name as their output type, and thus the “function-like
+ syntax” is nothing more than a direct invocation of the underlying
+ conversion function. Obviously, this is not something that a portable
+ application should rely on. For further details see
+ CREATE CAST.
+
4.2.10. Collation Expressions #
+ The COLLATE clause overrides the collation of
+ an expression. It is appended to the expression it applies to:
+
+expr COLLATE collation
+
+ where collation is a possibly
+ schema-qualified identifier. The COLLATE
+ clause binds tighter than operators; parentheses can be used when
+ necessary.
+
+ If no collation is explicitly specified, the database system
+ either derives a collation from the columns involved in the
+ expression, or it defaults to the default collation of the
+ database if no column is involved in the expression.
+
+ The two common uses of the COLLATE clause are
+ overriding the sort order in an ORDER BY clause, for
+ example:
+
+SELECT a, b, c FROM tbl WHERE ... ORDER BY a COLLATE "C";
+
+ and overriding the collation of a function or operator call that
+ has locale-sensitive results, for example:
+
+SELECT * FROM tbl WHERE a > 'foo' COLLATE "C";
+
+ Note that in the latter case the COLLATE clause is
+ attached to an input argument of the operator we wish to affect.
+ It doesn't matter which argument of the operator or function call the
+ COLLATE clause is attached to, because the collation that is
+ applied by the operator or function is derived by considering all
+ arguments, and an explicit COLLATE clause will override the
+ collations of all other arguments. (Attaching non-matching
+ COLLATE clauses to more than one argument, however, is an
+ error. For more details see Section 24.2.)
+ Thus, this gives the same result as the previous example:
+
+SELECT * FROM tbl WHERE a COLLATE "C" > 'foo';
+
+ But this is an error:
+
+SELECT * FROM tbl WHERE (a > 'foo') COLLATE "C";
+
+ because it attempts to apply a collation to the result of the
+ > operator, which is of the non-collatable data type
+ boolean.
+
4.2.11. Scalar Subqueries #
+ A scalar subquery is an ordinary
+ SELECT query in parentheses that returns exactly one
+ row with one column. (See Chapter 7 for information about writing queries.)
+ The SELECT query is executed
+ and the single returned value is used in the surrounding value expression.
+ It is an error to use a query that
+ returns more than one row or more than one column as a scalar subquery.
+ (But if, during a particular execution, the subquery returns no rows,
+ there is no error; the scalar result is taken to be null.)
+ The subquery can refer to variables from the surrounding query,
+ which will act as constants during any one evaluation of the subquery.
+ See also Section 9.23 for other expressions involving subqueries.
+
+ For example, the following finds the largest city population in each
+ state:
+
+SELECT name, (SELECT max(pop) FROM cities WHERE cities.state = states.name)
+ FROM states;
+
+
4.2.12. Array Constructors #
+ An array constructor is an expression that builds an
+ array value using values for its member elements. A simple array
+ constructor
+ consists of the key word ARRAY, a left square bracket
+ [, a list of expressions (separated by commas) for the
+ array element values, and finally a right square bracket ].
+ For example:
+
+SELECT ARRAY[1,2,3+4];
+ array
+---------
+ {1,2,7}
+(1 row)
+
+ By default,
+ the array element type is the common type of the member expressions,
+ determined using the same rules as for UNION or
+ CASE constructs (see Section 10.5).
+ You can override this by explicitly casting the array constructor to the
+ desired type, for example:
+
+SELECT ARRAY[1,2,22.7]::integer[];
+ array
+----------
+ {1,2,23}
+(1 row)
+
+ This has the same effect as casting each expression to the array
+ element type individually.
+ For more on casting, see Section 4.2.9.
+
+ Multidimensional array values can be built by nesting array
+ constructors.
+ In the inner constructors, the key word ARRAY can
+ be omitted. For example, these produce the same result:
+
+
+SELECT ARRAY[ARRAY[1,2], ARRAY[3,4]];
+ array
+---------------
+ {{1,2},{3,4}}
+(1 row)
+
+SELECT ARRAY[[1,2],[3,4]];
+ array
+---------------
+ {{1,2},{3,4}}
+(1 row)
+
+
+ Since multidimensional arrays must be rectangular, inner constructors
+ at the same level must produce sub-arrays of identical dimensions.
+ Any cast applied to the outer ARRAY constructor propagates
+ automatically to all the inner constructors.
+
+ Multidimensional array constructor elements can be anything yielding
+ an array of the proper kind, not only a sub-ARRAY construct.
+ For example:
+
+CREATE TABLE arr(f1 int[], f2 int[]);
+
+INSERT INTO arr VALUES (ARRAY[[1,2],[3,4]], ARRAY[[5,6],[7,8]]);
+
+SELECT ARRAY[f1, f2, '{{9,10},{11,12}}'::int[]] FROM arr;
+ array
+------------------------------------------------
+ {{{1,2},{3,4}},{{5,6},{7,8}},{{9,10},{11,12}}}
+(1 row)
+
+
+ You can construct an empty array, but since it's impossible to have an
+ array with no type, you must explicitly cast your empty array to the
+ desired type. For example:
+
+SELECT ARRAY[]::integer[];
+ array
+-------
+ {}
+(1 row)
+
+
+ It is also possible to construct an array from the results of a
+ subquery. In this form, the array constructor is written with the
+ key word ARRAY followed by a parenthesized (not
+ bracketed) subquery. For example:
+
+SELECT ARRAY(SELECT oid FROM pg_proc WHERE proname LIKE 'bytea%');
+ array
+------------------------------------------------------------------
+ {2011,1954,1948,1952,1951,1244,1950,2005,1949,1953,2006,31,2412}
+(1 row)
+
+SELECT ARRAY(SELECT ARRAY[i, i*2] FROM generate_series(1,5) AS a(i));
+ array
+----------------------------------
+ {{1,2},{2,4},{3,6},{4,8},{5,10}}
+(1 row)
+
+ The subquery must return a single column.
+ If the subquery's output column is of a non-array type, the resulting
+ one-dimensional array will have an element for each row in the
+ subquery result, with an element type matching that of the
+ subquery's output column.
+ If the subquery's output column is of an array type, the result will be
+ an array of the same type but one higher dimension; in this case all
+ the subquery rows must yield arrays of identical dimensionality, else
+ the result would not be rectangular.
+
+ The subscripts of an array value built with ARRAY
+ always begin with one. For more information about arrays, see
+ Section 8.15.
+
4.2.13. Row Constructors #
+ A row constructor is an expression that builds a row value (also
+ called a composite value) using values
+ for its member fields. A row constructor consists of the key word
+ ROW, a left parenthesis, zero or more
+ expressions (separated by commas) for the row field values, and finally
+ a right parenthesis. For example:
+
+SELECT ROW(1,2.5,'this is a test');
+
+ The key word ROW is optional when there is more than one
+ expression in the list.
+
+ A row constructor can include the syntax
+ rowvalue.*,
+ which will be expanded to a list of the elements of the row value,
+ just as occurs when the .* syntax is used at the top level
+ of a SELECT list (see Section 8.16.5).
+ For example, if table t has
+ columns f1 and f2, these are the same:
+
+SELECT ROW(t.*, 42) FROM t;
+SELECT ROW(t.f1, t.f2, 42) FROM t;
+
+
Note
+ Before PostgreSQL 8.2, the
+ .* syntax was not expanded in row constructors, so
+ that writing ROW(t.*, 42) created a two-field row whose first
+ field was another row value. The new behavior is usually more useful.
+ If you need the old behavior of nested row values, write the inner
+ row value without .*, for instance
+ ROW(t, 42).
+
+ By default, the value created by a ROW expression is of
+ an anonymous record type. If necessary, it can be cast to a named
+ composite type — either the row type of a table, or a composite type
+ created with CREATE TYPE AS. An explicit cast might be needed
+ to avoid ambiguity. For example:
+
+CREATE TABLE mytable(f1 int, f2 float, f3 text);
+
+CREATE FUNCTION getf1(mytable) RETURNS int AS 'SELECT $1.f1' LANGUAGE SQL;
+
+-- No cast needed since only one getf1() exists
+SELECT getf1(ROW(1,2.5,'this is a test'));
+ getf1
+-------
+ 1
+(1 row)
+
+CREATE TYPE myrowtype AS (f1 int, f2 text, f3 numeric);
+
+CREATE FUNCTION getf1(myrowtype) RETURNS int AS 'SELECT $1.f1' LANGUAGE SQL;
+
+-- Now we need a cast to indicate which function to call:
+SELECT getf1(ROW(1,2.5,'this is a test'));
+ERROR: function getf1(record) is not unique
+
+SELECT getf1(ROW(1,2.5,'this is a test')::mytable);
+ getf1
+-------
+ 1
+(1 row)
+
+SELECT getf1(CAST(ROW(11,'this is a test',2.5) AS myrowtype));
+ getf1
+-------
+ 11
+(1 row)
+
+
+ Row constructors can be used to build composite values to be stored
+ in a composite-type table column, or to be passed to a function that
+ accepts a composite parameter. Also,
+ it is possible to compare two row values or test a row with
+ IS NULL or IS NOT NULL, for example:
+
+SELECT ROW(1,2.5,'this is a test') = ROW(1, 3, 'not the same');
+
+SELECT ROW(table.*) IS NULL FROM table; -- detect all-null rows
+
+ For more detail see Section 9.24.
+ Row constructors can also be used in connection with subqueries,
+ as discussed in Section 9.23.
+
4.2.14. Expression Evaluation Rules #
+ The order of evaluation of subexpressions is not defined. In
+ particular, the inputs of an operator or function are not necessarily
+ evaluated left-to-right or in any other fixed order.
+
+ Furthermore, if the result of an expression can be determined by
+ evaluating only some parts of it, then other subexpressions
+ might not be evaluated at all. For instance, if one wrote:
+
+SELECT true OR somefunc();
+
+ then somefunc() would (probably) not be called
+ at all. The same would be the case if one wrote:
+
+SELECT somefunc() OR true;
+
+ Note that this is not the same as the left-to-right
+ “short-circuiting” of Boolean operators that is found
+ in some programming languages.
+
+ As a consequence, it is unwise to use functions with side effects
+ as part of complex expressions. It is particularly dangerous to
+ rely on side effects or evaluation order in WHERE and HAVING clauses,
+ since those clauses are extensively reprocessed as part of
+ developing an execution plan. Boolean
+ expressions (AND/OR/NOT combinations) in those clauses can be reorganized
+ in any manner allowed by the laws of Boolean algebra.
+
+ When it is essential to force evaluation order, a CASE
+ construct (see Section 9.18) can be
+ used. For example, this is an untrustworthy way of trying to
+ avoid division by zero in a WHERE clause:
+
+SELECT ... WHERE x > 0 AND y/x > 1.5;
+
+ But this is safe:
+
+SELECT ... WHERE CASE WHEN x > 0 THEN y/x > 1.5 ELSE false END;
+
+ A CASE construct used in this fashion will defeat optimization
+ attempts, so it should only be done when necessary. (In this particular
+ example, it would be better to sidestep the problem by writing
+ y > 1.5*x instead.)
+
+ CASE is not a cure-all for such issues, however.
+ One limitation of the technique illustrated above is that it does not
+ prevent early evaluation of constant subexpressions.
+ As described in Section 38.7, functions and
+ operators marked IMMUTABLE can be evaluated when
+ the query is planned rather than when it is executed. Thus for example
+
+SELECT CASE WHEN x > 0 THEN x ELSE 1/0 END FROM tab;
+
+ is likely to result in a division-by-zero failure due to the planner
+ trying to simplify the constant subexpression,
+ even if every row in the table has x > 0 so that the
+ ELSE arm would never be entered at run time.
+
+ While that particular example might seem silly, related cases that don't
+ obviously involve constants can occur in queries executed within
+ functions, since the values of function arguments and local variables
+ can be inserted into queries as constants for planning purposes.
+ Within PL/pgSQL functions, for example, using an
+ IF-THEN-ELSE statement to protect
+ a risky computation is much safer than just nesting it in a
+ CASE expression.
+
+ Another limitation of the same kind is that a CASE cannot
+ prevent evaluation of an aggregate expression contained within it,
+ because aggregate expressions are computed before other
+ expressions in a SELECT list or HAVING clause
+ are considered. For example, the following query can cause a
+ division-by-zero error despite seemingly having protected against it:
+
+SELECT CASE WHEN min(employees) > 0
+ THEN avg(expenses / employees)
+ END
+ FROM departments;
+
+ The min() and avg() aggregates are computed
+ concurrently over all the input rows, so if any row
+ has employees equal to zero, the division-by-zero error
+ will occur before there is any opportunity to test the result of
+ min(). Instead, use a WHERE
+ or FILTER clause to prevent problematic input rows from
+ reaching an aggregate function in the first place.
+
FETCH
FETCH — retrieve rows from a query using a cursor
Synopsis
+FETCH [ direction ] [ FROM | IN ] cursor_name
+
+where direction can be one of:
+
+ NEXT
+ PRIOR
+ FIRST
+ LAST
+ ABSOLUTE count
+ RELATIVE count
+ count
+ ALL
+ FORWARD
+ FORWARD count
+ FORWARD ALL
+ BACKWARD
+ BACKWARD count
+ BACKWARD ALL
+
Description
+ FETCH retrieves rows using a previously-created cursor.
+
+ A cursor has an associated position, which is used by
+ FETCH. The cursor position can be before the first row of the
+ query result, on any particular row of the result, or after the last row
+ of the result. When created, a cursor is positioned before the first row.
+ After fetching some rows, the cursor is positioned on the row most recently
+ retrieved. If FETCH runs off the end of the available rows
+ then the cursor is left positioned after the last row, or before the first
+ row if fetching backward. FETCH ALL or FETCH BACKWARD
+ ALL will always leave the cursor positioned after the last row or before
+ the first row.
+
+ The forms NEXT, PRIOR, FIRST,
+ LAST, ABSOLUTE, RELATIVE fetch
+ a single row after moving the cursor appropriately. If there is no
+ such row, an empty result is returned, and the cursor is left
+ positioned before the first row or after the last row as
+ appropriate.
+
+ The forms using FORWARD and BACKWARD
+ retrieve the indicated number of rows moving in the forward or
+ backward direction, leaving the cursor positioned on the
+ last-returned row (or after/before all rows, if the count exceeds the number of rows
+ available).
+
+ RELATIVE 0, FORWARD 0, and
+ BACKWARD 0 all request fetching the current row without
+ moving the cursor, that is, re-fetching the most recently fetched
+ row. This will succeed unless the cursor is positioned before the
+ first row or after the last row; in which case, no row is returned.
+
Note
+ This page describes usage of cursors at the SQL command level.
+ If you are trying to use cursors inside a PL/pgSQL
+ function, the rules are different —
+ see Section 43.7.3.
+
Parameters
directiondirection defines
+ the fetch direction and number of rows to fetch. It can be one
+ of the following:
+
+
NEXT
+ Fetch the next row. This is the default if direction is omitted.
+
PRIOR
+ Fetch the prior row.
+
FIRST
+ Fetch the first row of the query (same as ABSOLUTE 1).
+
LAST
+ Fetch the last row of the query (same as ABSOLUTE -1).
+
ABSOLUTE count
+ Fetch the count'th row of the query,
+ or the abs(count)'th row from
+ the end if count is negative. Position
+ before first row or after last row if count is out of range; in
+ particular, ABSOLUTE 0 positions before
+ the first row.
+
RELATIVE count
+ Fetch the count'th succeeding row, or
+ the abs(count)'th prior
+ row if count is
+ negative. RELATIVE 0 re-fetches the
+ current row, if any.
+
count
+ Fetch the next count rows (same as
+ FORWARD count).
+
ALL
+ Fetch all remaining rows (same as FORWARD ALL).
+
FORWARD
+ Fetch the next row (same as NEXT).
+
FORWARD count
+ Fetch the next count rows.
+ FORWARD 0 re-fetches the current row.
+
FORWARD ALL
+ Fetch all remaining rows.
+
BACKWARD
+ Fetch the prior row (same as PRIOR).
+
BACKWARD count
+ Fetch the prior count rows (scanning
+ backwards). BACKWARD 0 re-fetches the
+ current row.
+
BACKWARD ALL
+ Fetch all prior rows (scanning backwards).
+
countcount is a
+ possibly-signed integer constant, determining the location or
+ number of rows to fetch. For FORWARD and
+ BACKWARD cases, specifying a negative count is equivalent to changing
+ the sense of FORWARD and BACKWARD.
+
cursor_name
+ An open cursor's name.
+
Outputs
+ On successful completion, a FETCH command returns a command
+ tag of the form
+
+FETCH count
+
+ The count is the number
+ of rows fetched (possibly zero). Note that in
+ psql, the command tag will not actually be
+ displayed, since psql displays the fetched
+ rows instead.
+
Notes
+ The cursor should be declared with the SCROLL
+ option if one intends to use any variants of FETCH
+ other than FETCH NEXT or FETCH FORWARD with
+ a positive count. For simple queries
+ PostgreSQL will allow backwards fetch
+ from cursors not declared with SCROLL, but this
+ behavior is best not relied on. If the cursor is declared with
+ NO SCROLL, no backward fetches are allowed.
+
+ ABSOLUTE fetches are not any faster than
+ navigating to the desired row with a relative move: the underlying
+ implementation must traverse all the intermediate rows anyway.
+ Negative absolute fetches are even worse: the query must be read to
+ the end to find the last row, and then traversed backward from
+ there. However, rewinding to the start of the query (as with
+ FETCH ABSOLUTE 0) is fast.
+
+ DECLARE
+ is used to define a cursor. Use
+ MOVE
+ to change cursor position without retrieving data.
+
Examples
+ The following example traverses a table using a cursor:
+
+
+BEGIN WORK;
+
+-- Set up a cursor:
+DECLARE liahona SCROLL CURSOR FOR SELECT * FROM films;
+
+-- Fetch the first 5 rows in the cursor liahona:
+FETCH FORWARD 5 FROM liahona;
+
+ code | title | did | date_prod | kind | len
+-------+-------------------------+-----+------------+----------+-------
+ BL101 | The Third Man | 101 | 1949-12-23 | Drama | 01:44
+ BL102 | The African Queen | 101 | 1951-08-11 | Romantic | 01:43
+ JL201 | Une Femme est une Femme | 102 | 1961-03-12 | Romantic | 01:25
+ P_301 | Vertigo | 103 | 1958-11-14 | Action | 02:08
+ P_302 | Becket | 103 | 1964-02-03 | Drama | 02:28
+
+-- Fetch the previous row:
+FETCH PRIOR FROM liahona;
+
+ code | title | did | date_prod | kind | len
+-------+---------+-----+------------+--------+-------
+ P_301 | Vertigo | 103 | 1958-11-14 | Action | 02:08
+
+-- Close the cursor and end the transaction:
+CLOSE liahona;
+COMMIT WORK;
+
Compatibility
+ The SQL standard defines FETCH for use in
+ embedded SQL only. The variant of FETCH
+ described here returns the data as if it were a
+ SELECT result rather than placing it in host
+ variables. Other than this point, FETCH is
+ fully upward-compatible with the SQL standard.
+
+ The FETCH forms involving
+ FORWARD and BACKWARD, as well
+ as the forms FETCH count and FETCH
+ ALL, in which FORWARD is implicit, are
+ PostgreSQL extensions.
+
+ The SQL standard allows only FROM preceding the cursor
+ name; the option to use IN, or to leave them out altogether, is
+ an extension.
+
GRANT
GRANT — define access privileges
Synopsis
+GRANT { { SELECT | INSERT | UPDATE | DELETE | TRUNCATE | REFERENCES | TRIGGER }
+ [, ...] | ALL [ PRIVILEGES ] }
+ ON { [ TABLE ] table_name [, ...]
+ | ALL TABLES IN SCHEMA schema_name [, ...] }
+ TO role_specification [, ...] [ WITH GRANT OPTION ]
+ [ GRANTED BY role_specification ]
+
+GRANT { { SELECT | INSERT | UPDATE | REFERENCES } ( column_name [, ...] )
+ [, ...] | ALL [ PRIVILEGES ] ( column_name [, ...] ) }
+ ON [ TABLE ] table_name [, ...]
+ TO role_specification [, ...] [ WITH GRANT OPTION ]
+ [ GRANTED BY role_specification ]
+
+GRANT { { USAGE | SELECT | UPDATE }
+ [, ...] | ALL [ PRIVILEGES ] }
+ ON { SEQUENCE sequence_name [, ...]
+ | ALL SEQUENCES IN SCHEMA schema_name [, ...] }
+ TO role_specification [, ...] [ WITH GRANT OPTION ]
+ [ GRANTED BY role_specification ]
+
+GRANT { { CREATE | CONNECT | TEMPORARY | TEMP } [, ...] | ALL [ PRIVILEGES ] }
+ ON DATABASE database_name [, ...]
+ TO role_specification [, ...] [ WITH GRANT OPTION ]
+ [ GRANTED BY role_specification ]
+
+GRANT { USAGE | ALL [ PRIVILEGES ] }
+ ON DOMAIN domain_name [, ...]
+ TO role_specification [, ...] [ WITH GRANT OPTION ]
+ [ GRANTED BY role_specification ]
+
+GRANT { USAGE | ALL [ PRIVILEGES ] }
+ ON FOREIGN DATA WRAPPER fdw_name [, ...]
+ TO role_specification [, ...] [ WITH GRANT OPTION ]
+ [ GRANTED BY role_specification ]
+
+GRANT { USAGE | ALL [ PRIVILEGES ] }
+ ON FOREIGN SERVER server_name [, ...]
+ TO role_specification [, ...] [ WITH GRANT OPTION ]
+ [ GRANTED BY role_specification ]
+
+GRANT { EXECUTE | ALL [ PRIVILEGES ] }
+ ON { { FUNCTION | PROCEDURE | ROUTINE } routine_name [ ( [ [ argmode ] [ arg_name ] arg_type [, ...] ] ) ] [, ...]
+ | ALL { FUNCTIONS | PROCEDURES | ROUTINES } IN SCHEMA schema_name [, ...] }
+ TO role_specification [, ...] [ WITH GRANT OPTION ]
+ [ GRANTED BY role_specification ]
+
+GRANT { USAGE | ALL [ PRIVILEGES ] }
+ ON LANGUAGE lang_name [, ...]
+ TO role_specification [, ...] [ WITH GRANT OPTION ]
+ [ GRANTED BY role_specification ]
+
+GRANT { { SELECT | UPDATE } [, ...] | ALL [ PRIVILEGES ] }
+ ON LARGE OBJECT loid [, ...]
+ TO role_specification [, ...] [ WITH GRANT OPTION ]
+ [ GRANTED BY role_specification ]
+
+GRANT { { SET | ALTER SYSTEM } [, ... ] | ALL [ PRIVILEGES ] }
+ ON PARAMETER configuration_parameter [, ...]
+ TO role_specification [, ...] [ WITH GRANT OPTION ]
+ [ GRANTED BY role_specification ]
+
+GRANT { { CREATE | USAGE } [, ...] | ALL [ PRIVILEGES ] }
+ ON SCHEMA schema_name [, ...]
+ TO role_specification [, ...] [ WITH GRANT OPTION ]
+ [ GRANTED BY role_specification ]
+
+GRANT { CREATE | ALL [ PRIVILEGES ] }
+ ON TABLESPACE tablespace_name [, ...]
+ TO role_specification [, ...] [ WITH GRANT OPTION ]
+ [ GRANTED BY role_specification ]
+
+GRANT { USAGE | ALL [ PRIVILEGES ] }
+ ON TYPE type_name [, ...]
+ TO role_specification [, ...] [ WITH GRANT OPTION ]
+ [ GRANTED BY role_specification ]
+
+GRANT role_name [, ...] TO role_specification [, ...]
+ [ WITH { ADMIN | INHERIT | SET } { OPTION | TRUE | FALSE } ]
+ [ GRANTED BY role_specification ]
+
+where role_specification can be:
+
+ [ GROUP ] role_name
+ | PUBLIC
+ | CURRENT_ROLE
+ | CURRENT_USER
+ | SESSION_USER
+Description
+ The GRANT command has two basic variants: one
+ that grants privileges on a database object (table, column, view,
+ foreign table, sequence, database, foreign-data wrapper, foreign server,
+ function, procedure, procedural language, large object, configuration
+ parameter, schema, tablespace, or type), and one that grants
+ membership in a role. These variants are similar in many ways, but
+ they are different enough to be described separately.
+
GRANT on Database Objects
+ This variant of the GRANT command gives specific
+ privileges on a database object to
+ one or more roles. These privileges are added
+ to those already granted, if any.
+
+ The key word PUBLIC indicates that the
+ privileges are to be granted to all roles, including those that might
+ be created later. PUBLIC can be thought of as an
+ implicitly defined group that always includes all roles.
+ Any particular role will have the sum
+ of privileges granted directly to it, privileges granted to any role it
+ is presently a member of, and privileges granted to
+ PUBLIC.
+
+ If WITH GRANT OPTION is specified, the recipient
+ of the privilege can in turn grant it to others. Without a grant
+ option, the recipient cannot do that. Grant options cannot be granted
+ to PUBLIC.
+
+ If GRANTED BY is specified, the specified grantor must
+ be the current user. This clause is currently present in this form only
+ for SQL compatibility.
+
+ There is no need to grant privileges to the owner of an object
+ (usually the user that created it),
+ as the owner has all privileges by default. (The owner could,
+ however, choose to revoke some of their own privileges for safety.)
+
+ The right to drop an object, or to alter its definition in any way, is
+ not treated as a grantable privilege; it is inherent in the owner,
+ and cannot be granted or revoked. (However, a similar effect can be
+ obtained by granting or revoking membership in the role that owns
+ the object; see below.) The owner implicitly has all grant
+ options for the object, too.
+
+ The possible privileges are:
+
+
SELECT
INSERT
UPDATE
DELETE
TRUNCATE
REFERENCES
TRIGGER
CREATE
CONNECT
TEMPORARY
EXECUTE
USAGE
SET
ALTER SYSTEM
+ Specific types of privileges, as defined in Section 5.7.
+
TEMP
+ Alternative spelling for TEMPORARY.
+
ALL PRIVILEGES
+ Grant all of the privileges available for the object's type.
+ The PRIVILEGES key word is optional in
+ PostgreSQL, though it is required by
+ strict SQL.
+
+
+ The FUNCTION syntax works for plain functions,
+ aggregate functions, and window functions, but not for procedures;
+ use PROCEDURE for those.
+ Alternatively, use ROUTINE to refer to a function,
+ aggregate function, window function, or procedure regardless of its
+ precise type.
+
+ There is also an option to grant privileges on all objects of the same
+ type within one or more schemas. This functionality is currently supported
+ only for tables, sequences, functions, and procedures. ALL
+ TABLES also affects views and foreign tables, just like the
+ specific-object GRANT command. ALL
+ FUNCTIONS also affects aggregate and window functions, but not
+ procedures, again just like the specific-object GRANT
+ command. Use ALL ROUTINES to include procedures.
+
GRANT on Roles
+ This variant of the GRANT command grants membership
+ in a role to one or more other roles, and the modification of
+ membership options SET, INHERIT,
+ and ADMIN; see Section 22.3
+ for details. Membership in a role is significant
+ because it potentially allows access to the privileges granted to a role
+ to each of its members, and potentially also the ability to make changes
+ to the role itself. However, the actual permissions conferred depend on
+ the options associated with the grant. To modify that options of
+ an existing membership, simply specify the membership with updated
+ option values.
+
+ Each of the options described below can be set to either
+ TRUE or FALSE. The keyword
+ OPTION is accepted as a synonym for
+ TRUE, so that WITH ADMIN OPTION
+ is a synonym for WITH ADMIN TRUE. When altering
+ an existing membership the omission of an option results in the current
+ value being retained.
+
+ The ADMIN option allows the member to
+ in turn grant membership in the role to others, and revoke membership
+ in the role as well. Without the admin option, ordinary users cannot
+ do that. A role is not considered to hold WITH ADMIN
+ OPTION on itself. Database superusers can grant or revoke
+ membership in any role to anyone. This option defaults to
+ FALSE.
+
+ The INHERIT option controls the inheritance status
+ of the new membership; see Section 22.3 for
+ details on inheritance. If it is set to TRUE,
+ it causes the new member to inherit from the granted role. If
+ set to FALSE, the new member does not inherit.
+ If unspecified when creating a new role membership, this defaults to the
+ inheritance attribute of the new member.
+
+ The SET option, if it is set to
+ TRUE, allows the member to change to the granted
+ role using the
+ SET ROLE
+ command. If a role is an indirect member of another role, it can use
+ SET ROLE to change to that role only if there is a
+ chain of grants each of which has SET TRUE.
+ This option defaults to TRUE.
+
+ To create an object owned by another role or give ownership of an existing
+ object to another role, you must have the ability to SET
+ ROLE to that role; otherwise, commands such as ALTER
+ ... OWNER TO or CREATE DATABASE ... OWNER
+ will fail. However, a user who inherits the privileges of a role but does
+ not have the ability to SET ROLE to that role may be
+ able to obtain full access to the role by manipulating existing objects
+ owned by that role (e.g. they could redefine an existing function to act
+ as a Trojan horse). Therefore, if a role's privileges are to be inherited
+ but should not be accessible via SET ROLE, it should not
+ own any SQL objects.
+
+ If GRANTED BY is specified, the grant is recorded as
+ having been done by the specified role. A user can only attribute a grant
+ to another role if they possess the privileges of that role. The role
+ recorded as the grantor must have ADMIN OPTION on the
+ target role, unless it is the bootstrap superuser. When a grant is recorded
+ as having a grantor other than the bootstrap superuser, it depends on the
+ grantor continuing to possess ADMIN OPTION on the role;
+ so, if ADMIN OPTION is revoked, dependent grants must
+ be revoked as well.
+
+ Unlike the case with privileges, membership in a role cannot be granted
+ to PUBLIC. Note also that this form of the command
+ does not allow the noise word GROUP
+ in role_specification.
+
Notes
+ The REVOKE command is used
+ to revoke access privileges.
+
+ Since PostgreSQL 8.1, the concepts of users and
+ groups have been unified into a single kind of entity called a role.
+ It is therefore no longer necessary to use the keyword GROUP
+ to identify whether a grantee is a user or a group. GROUP
+ is still allowed in the command, but it is a noise word.
+
+ A user may perform SELECT, INSERT, etc. on a
+ column if they hold that privilege for either the specific column or
+ its whole table. Granting the privilege at the table level and then
+ revoking it for one column will not do what one might wish: the
+ table-level grant is unaffected by a column-level operation.
+
+ When a non-owner of an object attempts to GRANT privileges
+ on the object, the command will fail outright if the user has no
+ privileges whatsoever on the object. As long as some privilege is
+ available, the command will proceed, but it will grant only those
+ privileges for which the user has grant options. The GRANT ALL
+ PRIVILEGES forms will issue a warning message if no grant options are
+ held, while the other forms will issue a warning if grant options for
+ any of the privileges specifically named in the command are not held.
+ (In principle these statements apply to the object owner as well, but
+ since the owner is always treated as holding all grant options, the
+ cases can never occur.)
+
+ It should be noted that database superusers can access
+ all objects regardless of object privilege settings. This
+ is comparable to the rights of root in a Unix system.
+ As with root, it's unwise to operate as a superuser
+ except when absolutely necessary.
+
+ If a superuser chooses to issue a GRANT or REVOKE
+ command, the command is performed as though it were issued by the
+ owner of the affected object. In particular, privileges granted via
+ such a command will appear to have been granted by the object owner.
+ (For role membership, the membership appears to have been granted
+ by the bootstrap superuser.)
+
+ GRANT and REVOKE can also be done by a role
+ that is not the owner of the affected object, but is a member of the role
+ that owns the object, or is a member of a role that holds privileges
+ WITH GRANT OPTION on the object. In this case the
+ privileges will be recorded as having been granted by the role that
+ actually owns the object or holds the privileges
+ WITH GRANT OPTION. For example, if table
+ t1 is owned by role g1, of which role
+ u1 is a member, then u1 can grant privileges
+ on t1 to u2, but those privileges will appear
+ to have been granted directly by g1. Any other member
+ of role g1 could revoke them later.
+
+ If the role executing GRANT holds the required privileges
+ indirectly via more than one role membership path, it is unspecified
+ which containing role will be recorded as having done the grant. In such
+ cases it is best practice to use SET ROLE to become the
+ specific role you want to do the GRANT as.
+
+ Granting permission on a table does not automatically extend
+ permissions to any sequences used by the table, including
+ sequences tied to SERIAL columns. Permissions on
+ sequences must be set separately.
+
+ See Section 5.7 for more information about specific
+ privilege types, as well as how to inspect objects' privileges.
+
Examples
+ Grant insert privilege to all users on table films:
+
+
+GRANT INSERT ON films TO PUBLIC;
+
+
+ Grant all available privileges to user manuel on view
+ kinds:
+
+
+GRANT ALL PRIVILEGES ON kinds TO manuel;
+
+
+ Note that while the above will indeed grant all privileges if executed by a
+ superuser or the owner of kinds, when executed by someone
+ else it will only grant those permissions for which the someone else has
+ grant options.
+
+ Grant membership in role admins to user joe:
+
+
+GRANT admins TO joe;
+
Compatibility
+ According to the SQL standard, the PRIVILEGES
+ key word in ALL PRIVILEGES is required. The
+ SQL standard does not support setting the privileges on more than
+ one object per command.
+
+ PostgreSQL allows an object owner to revoke their
+ own ordinary privileges: for example, a table owner can make the table
+ read-only to themselves by revoking their own INSERT,
+ UPDATE, DELETE, and TRUNCATE
+ privileges. This is not possible according to the SQL standard. The
+ reason is that PostgreSQL treats the owner's
+ privileges as having been granted by the owner to themselves; therefore they
+ can revoke them too. In the SQL standard, the owner's privileges are
+ granted by an assumed entity “_SYSTEM”. Not being
+ “_SYSTEM”, the owner cannot revoke these rights.
+
+ According to the SQL standard, grant options can be granted to
+ PUBLIC; PostgreSQL only supports granting grant options
+ to roles.
+
+ The SQL standard allows the GRANTED BY option to
+ specify only CURRENT_USER or
+ CURRENT_ROLE. The other variants are PostgreSQL
+ extensions.
+
+ The SQL standard provides for a USAGE privilege
+ on other kinds of objects: character sets, collations,
+ translations.
+
+ In the SQL standard, sequences only have a USAGE
+ privilege, which controls the use of the NEXT VALUE FOR
+ expression, which is equivalent to the
+ function nextval in PostgreSQL. The sequence
+ privileges SELECT and UPDATE are
+ PostgreSQL extensions. The application of the
+ sequence USAGE privilege to
+ the currval function is also a PostgreSQL extension (as
+ is the function itself).
+
+ Privileges on databases, tablespaces, schemas, languages, and
+ configuration parameters are
+ PostgreSQL extensions.
+
IMPORT FOREIGN SCHEMA
IMPORT FOREIGN SCHEMA — import table definitions from a foreign server
Synopsis
+IMPORT FOREIGN SCHEMA remote_schema
+ [ { LIMIT TO | EXCEPT } ( table_name [, ...] ) ]
+ FROM SERVER server_name
+ INTO local_schema
+ [ OPTIONS ( option 'value' [, ... ] ) ]
+
Description
+ IMPORT FOREIGN SCHEMA creates foreign tables that
+ represent tables existing on a foreign server. The new foreign tables
+ will be owned by the user issuing the command and are created with
+ the correct column definitions and options to match the remote tables.
+
+ By default, all tables and views existing in a particular schema on the
+ foreign server are imported. Optionally, the list of tables can be limited
+ to a specified subset, or specific tables can be excluded. The new foreign
+ tables are all created in the target schema, which must already exist.
+
+ To use IMPORT FOREIGN SCHEMA, the user must have
+ USAGE privilege on the foreign server, as well as
+ CREATE privilege on the target schema.
+
Parameters
remote_schema
+ The remote schema to import from. The specific meaning of a remote schema
+ depends on the foreign data wrapper in use.
+
LIMIT TO ( table_name [, ...] )
+ Import only foreign tables matching one of the given table names.
+ Other tables existing in the foreign schema will be ignored.
+
EXCEPT ( table_name [, ...] )
+ Exclude specified foreign tables from the import. All tables
+ existing in the foreign schema will be imported except the
+ ones listed here.
+
server_name
+ The foreign server to import from.
+
local_schema
+ The schema in which the imported foreign tables will be created.
+
OPTIONS ( option 'value' [, ...] )
+ Options to be used during the import.
+ The allowed option names and values are specific to each foreign
+ data wrapper.
+
Examples
+ Import table definitions from a remote schema foreign_films
+ on server film_server, creating the foreign tables in
+ local schema films:
+
+
+IMPORT FOREIGN SCHEMA foreign_films
+ FROM SERVER film_server INTO films;
+
+
+ As above, but import only the two tables actors and
+ directors (if they exist):
+
+
+IMPORT FOREIGN SCHEMA foreign_films LIMIT TO (actors, directors)
+ FROM SERVER film_server INTO films;
+
Compatibility
+ The IMPORT FOREIGN SCHEMA command conforms to the
+ SQL standard, except that the OPTIONS
+ clause is a PostgreSQL extension.
+
INSERT
INSERT — create new rows in a table
Synopsis
+[ WITH [ RECURSIVE ] with_query [, ...] ]
+INSERT INTO table_name [ AS alias ] [ ( column_name [, ...] ) ]
+ [ OVERRIDING { SYSTEM | USER } VALUE ]
+ { DEFAULT VALUES | VALUES ( { expression | DEFAULT } [, ...] ) [, ...] | query }
+ [ ON CONFLICT [ conflict_target ] conflict_action ]
+ [ RETURNING * | output_expression [ [ AS ] output_name ] [, ...] ]
+
+where conflict_target can be one of:
+
+ ( { index_column_name | ( index_expression ) } [ COLLATE collation ] [ opclass ] [, ...] ) [ WHERE index_predicate ]
+ ON CONSTRAINT constraint_name
+
+and conflict_action is one of:
+
+ DO NOTHING
+ DO UPDATE SET { column_name = { expression | DEFAULT } |
+ ( column_name [, ...] ) = [ ROW ] ( { expression | DEFAULT } [, ...] ) |
+ ( column_name [, ...] ) = ( sub-SELECT )
+ } [, ...]
+ [ WHERE condition ]
+
Description
+ INSERT inserts new rows into a table.
+ One can insert one or more rows specified by value expressions,
+ or zero or more rows resulting from a query.
+
+ The target column names can be listed in any order. If no list of
+ column names is given at all, the default is all the columns of the
+ table in their declared order; or the first N column
+ names, if there are only N columns supplied by the
+ VALUES clause or query. The values
+ supplied by the VALUES clause or query are
+ associated with the explicit or implicit column list left-to-right.
+
+ Each column not present in the explicit or implicit column list will be
+ filled with a default value, either its declared default value
+ or null if there is none.
+
+ If the expression for any column is not of the correct data type,
+ automatic type conversion will be attempted.
+
+ INSERT into tables that lack unique indexes will
+ not be blocked by concurrent activity. Tables with unique indexes
+ might block if concurrent sessions perform actions that lock or modify
+ rows matching the unique index values being inserted; the details
+ are covered in Section 64.5.
+ ON CONFLICT can be used to specify an alternative
+ action to raising a unique constraint or exclusion constraint
+ violation error. (See ON CONFLICT Clause below.)
+
+ The optional RETURNING clause causes INSERT
+ to compute and return value(s) based on each row actually inserted
+ (or updated, if an ON CONFLICT DO UPDATE clause was
+ used). This is primarily useful for obtaining values that were
+ supplied by defaults, such as a serial sequence number. However,
+ any expression using the table's columns is allowed. The syntax of
+ the RETURNING list is identical to that of the output
+ list of SELECT. Only rows that were successfully
+ inserted or updated will be returned. For example, if a row was
+ locked but not updated because an ON CONFLICT DO UPDATE
+ ... WHERE clause condition was not satisfied, the
+ row will not be returned.
+
+ You must have INSERT privilege on a table in
+ order to insert into it. If ON CONFLICT DO UPDATE is
+ present, UPDATE privilege on the table is also
+ required.
+
+ If a column list is specified, you only need
+ INSERT privilege on the listed columns.
+ Similarly, when ON CONFLICT DO UPDATE is specified, you
+ only need UPDATE privilege on the column(s) that are
+ listed to be updated. However, ON CONFLICT DO UPDATE
+ also requires SELECT privilege on any column whose
+ values are read in the ON CONFLICT DO UPDATE
+ expressions or condition.
+
+ Use of the RETURNING clause requires SELECT
+ privilege on all columns mentioned in RETURNING.
+ If you use the query clause to insert rows from a
+ query, you of course need to have SELECT privilege on
+ any table or column used in the query.
+
Parameters
Inserting
+ This section covers parameters that may be used when only
+ inserting new rows. Parameters exclusively
+ used with the ON CONFLICT clause are described
+ separately.
+
with_query
+ The WITH clause allows you to specify one or more
+ subqueries that can be referenced by name in the INSERT
+ query. See Section 7.8 and SELECT
+ for details.
+
+ It is possible for the query
+ (SELECT statement)
+ to also contain a WITH clause. In such a case both
+ sets of with_query can be referenced within
+ the query, but the
+ second one takes precedence since it is more closely nested.
+
table_name
+ The name (optionally schema-qualified) of an existing table.
+
alias
+ A substitute name for table_name. When an alias is
+ provided, it completely hides the actual name of the table.
+ This is particularly useful when ON CONFLICT DO UPDATE
+ targets a table named excluded, since that will otherwise
+ be taken as the name of the special table representing the row proposed
+ for insertion.
+
column_name
+ The name of a column in the table named by table_name. The column name
+ can be qualified with a subfield name or array subscript, if
+ needed. (Inserting into only some fields of a composite
+ column leaves the other fields null.) When referencing a
+ column with ON CONFLICT DO UPDATE, do not include
+ the table's name in the specification of a target column. For
+ example, INSERT INTO table_name ... ON CONFLICT DO UPDATE
+ SET table_name.col = 1 is invalid (this follows the general
+ behavior for UPDATE).
+
OVERRIDING SYSTEM VALUE
+ If this clause is specified, then any values supplied for identity
+ columns will override the default sequence-generated values.
+
+ For an identity column defined as GENERATED ALWAYS,
+ it is an error to insert an explicit value (other than
+ DEFAULT) without specifying either
+ OVERRIDING SYSTEM VALUE or OVERRIDING USER
+ VALUE. (For an identity column defined as
+ GENERATED BY DEFAULT, OVERRIDING SYSTEM
+ VALUE is the normal behavior and specifying it does nothing,
+ but PostgreSQL allows it as an extension.)
+
OVERRIDING USER VALUE
+ If this clause is specified, then any values supplied for identity
+ columns are ignored and the default sequence-generated values are
+ applied.
+
+ This clause is useful for example when copying values between tables.
+ Writing INSERT INTO tbl2 OVERRIDING USER VALUE SELECT * FROM
+ tbl1 will copy from tbl1 all columns that
+ are not identity columns in tbl2 while values for
+ the identity columns in tbl2 will be generated by
+ the sequences associated with tbl2.
+
DEFAULT VALUES
+ All columns will be filled with their default values, as if
+ DEFAULT were explicitly specified for each column.
+ (An OVERRIDING clause is not permitted in this
+ form.)
+
expression
+ An expression or value to assign to the corresponding column.
+
DEFAULT
+ The corresponding column will be filled with its default value. An
+ identity column will be filled with a new value generated by the
+ associated sequence. For a generated column, specifying this is
+ permitted but merely specifies the normal behavior of computing the
+ column from its generation expression.
+
query
+ A query (SELECT statement) that supplies the
+ rows to be inserted. Refer to the
+ SELECT
+ statement for a description of the syntax.
+
output_expression
+ An expression to be computed and returned by the
+ INSERT command after each row is inserted or
+ updated. The expression can use any column names of the table
+ named by table_name. Write
+ * to return all columns of the inserted or updated
+ row(s).
+
output_name
+ A name to use for a returned column.
+
ON CONFLICT Clause
+ The optional ON CONFLICT clause specifies an
+ alternative action to raising a unique violation or exclusion
+ constraint violation error. For each individual row proposed for
+ insertion, either the insertion proceeds, or, if an
+ arbiter constraint or index specified by
+ conflict_target is violated, the
+ alternative conflict_action is taken.
+ ON CONFLICT DO NOTHING simply avoids inserting
+ a row as its alternative action. ON CONFLICT DO
+ UPDATE updates the existing row that conflicts with the
+ row proposed for insertion as its alternative action.
+
+ conflict_target can perform
+ unique index inference. When performing
+ inference, it consists of one or more index_column_name columns and/or
+ index_expression
+ expressions, and an optional index_predicate. All table_name unique indexes that,
+ without regard to order, contain exactly the
+ conflict_target-specified
+ columns/expressions are inferred (chosen) as arbiter indexes. If
+ an index_predicate is
+ specified, it must, as a further requirement for inference,
+ satisfy arbiter indexes. Note that this means a non-partial
+ unique index (a unique index without a predicate) will be inferred
+ (and thus used by ON CONFLICT) if such an index
+ satisfying every other criteria is available. If an attempt at
+ inference is unsuccessful, an error is raised.
+
+ ON CONFLICT DO UPDATE guarantees an atomic
+ INSERT or UPDATE outcome;
+ provided there is no independent error, one of those two outcomes
+ is guaranteed, even under high concurrency. This is also known as
+ UPSERT — “UPDATE or
+ INSERT”.
+
conflict_target
+ Specifies which conflicts ON CONFLICT takes
+ the alternative action on by choosing arbiter
+ indexes. Either performs unique index
+ inference, or names a constraint explicitly. For
+ ON CONFLICT DO NOTHING, it is optional to
+ specify a conflict_target; when
+ omitted, conflicts with all usable constraints (and unique
+ indexes) are handled. For ON CONFLICT DO
+ UPDATE, a conflict_target
+ must be provided.
+
conflict_action
+ conflict_action specifies an
+ alternative ON CONFLICT action. It can be
+ either DO NOTHING, or a DO
+ UPDATE clause specifying the exact details of the
+ UPDATE action to be performed in case of a
+ conflict. The SET and
+ WHERE clauses in ON CONFLICT DO
+ UPDATE have access to the existing row using the
+ table's name (or an alias), and to the row proposed for insertion
+ using the special excluded table.
+ SELECT privilege is required on any column in the
+ target table where corresponding excluded
+ columns are read.
+
+ Note that the effects of all per-row BEFORE
+ INSERT triggers are reflected in
+ excluded values, since those effects may
+ have contributed to the row being excluded from insertion.
+
index_column_name
+ The name of a table_name column. Used to
+ infer arbiter indexes. Follows CREATE
+ INDEX format. SELECT privilege on
+ index_column_name
+ is required.
+
index_expression
+ Similar to index_column_name, but used to
+ infer expressions on table_name columns appearing
+ within index definitions (not simple columns). Follows
+ CREATE INDEX format. SELECT
+ privilege on any column appearing within index_expression is required.
+
collation
+ When specified, mandates that corresponding index_column_name or
+ index_expression
+ use a particular collation in order to be matched during
+ inference. Typically this is omitted, as collations usually
+ do not affect whether or not a constraint violation occurs.
+ Follows CREATE INDEX format.
+
opclass
+ When specified, mandates that corresponding index_column_name or
+ index_expression
+ use particular operator class in order to be matched during
+ inference. Typically this is omitted, as the
+ equality semantics are often equivalent
+ across a type's operator classes anyway, or because it's
+ sufficient to trust that the defined unique indexes have the
+ pertinent definition of equality. Follows CREATE
+ INDEX format.
+
index_predicate
+ Used to allow inference of partial unique indexes. Any
+ indexes that satisfy the predicate (which need not actually be
+ partial indexes) can be inferred. Follows CREATE
+ INDEX format. SELECT privilege on any
+ column appearing within index_predicate is required.
+
constraint_name
+ Explicitly specifies an arbiter
+ constraint by name, rather than inferring
+ a constraint or index.
+
condition
+ An expression that returns a value of type
+ boolean. Only rows for which this expression
+ returns true will be updated, although all
+ rows will be locked when the ON CONFLICT DO UPDATE
+ action is taken. Note that
+ condition is evaluated last, after
+ a conflict has been identified as a candidate to update.
+
+ Note that exclusion constraints are not supported as arbiters with
+ ON CONFLICT DO UPDATE. In all cases, only
+ NOT DEFERRABLE constraints and unique indexes
+ are supported as arbiters.
+
+ INSERT with an ON CONFLICT DO UPDATE
+ clause is a “deterministic” statement. This means
+ that the command will not be allowed to affect any single existing
+ row more than once; a cardinality violation error will be raised
+ when this situation arises. Rows proposed for insertion should
+ not duplicate each other in terms of attributes constrained by an
+ arbiter index or constraint.
+
+ Note that it is currently not supported for the
+ ON CONFLICT DO UPDATE clause of an
+ INSERT applied to a partitioned table to update the
+ partition key of a conflicting row such that it requires the row be moved
+ to a new partition.
+
Tip
+ It is often preferable to use unique index inference rather than
+ naming a constraint directly using ON CONFLICT ON
+ CONSTRAINT
+ constraint_name. Inference will continue to work
+ correctly when the underlying index is replaced by another more
+ or less equivalent index in an overlapping way, for example when
+ using CREATE UNIQUE INDEX ... CONCURRENTLY
+ before dropping the index being replaced.
+
Outputs
+ On successful completion, an INSERT command returns a command
+ tag of the form
+
+INSERT oid count
+
+ The count is the number of
+ rows inserted or updated. oid is always 0 (it
+ used to be the OID assigned to the inserted row if
+ count was exactly one and the target table was
+ declared WITH OIDS and 0 otherwise, but creating a table
+ WITH OIDS is not supported anymore).
+
+ If the INSERT command contains a RETURNING
+ clause, the result will be similar to that of a SELECT
+ statement containing the columns and values defined in the
+ RETURNING list, computed over the row(s) inserted or
+ updated by the command.
+
Notes
+ If the specified table is a partitioned table, each row is routed to
+ the appropriate partition and inserted into it. If the specified table
+ is a partition, an error will occur if one of the input rows violates
+ the partition constraint.
+
+ You may also wish to consider using MERGE, since that
+ allows mixing INSERT, UPDATE, and
+ DELETE within a single statement.
+ See MERGE.
+
Examples
+ Insert a single row into table films:
+
+
+INSERT INTO films VALUES
+ ('UA502', 'Bananas', 105, '1971-07-13', 'Comedy', '82 minutes');
+
+
+ In this example, the len column is
+ omitted and therefore it will have the default value:
+
+
+INSERT INTO films (code, title, did, date_prod, kind)
+ VALUES ('T_601', 'Yojimbo', 106, '1961-06-16', 'Drama');
+
+
+ This example uses the DEFAULT clause for
+ the date columns rather than specifying a value:
+
+
+INSERT INTO films VALUES
+ ('UA502', 'Bananas', 105, DEFAULT, 'Comedy', '82 minutes');
+INSERT INTO films (code, title, did, date_prod, kind)
+ VALUES ('T_601', 'Yojimbo', 106, DEFAULT, 'Drama');
+
+
+ To insert a row consisting entirely of default values:
+
+
+INSERT INTO films DEFAULT VALUES;
+
+
+ To insert multiple rows using the multirow VALUES syntax:
+
+
+INSERT INTO films (code, title, did, date_prod, kind) VALUES
+ ('B6717', 'Tampopo', 110, '1985-02-10', 'Comedy'),
+ ('HG120', 'The Dinner Game', 140, DEFAULT, 'Comedy');
+
+
+ This example inserts some rows into table
+ films from a table tmp_films
+ with the same column layout as films:
+
+
+INSERT INTO films SELECT * FROM tmp_films WHERE date_prod < '2004-05-07';
+
+
+ This example inserts into array columns:
+
+
+-- Create an empty 3x3 gameboard for noughts-and-crosses
+INSERT INTO tictactoe (game, board[1:3][1:3])
+ VALUES (1, '{{" "," "," "},{" "," "," "},{" "," "," "}}');
+-- The subscripts in the above example aren't really needed
+INSERT INTO tictactoe (game, board)
+ VALUES (2, '{{X," "," "},{" ",O," "},{" ",X," "}}');
+
+
+ Insert a single row into table distributors, returning
+ the sequence number generated by the DEFAULT clause:
+
+
+INSERT INTO distributors (did, dname) VALUES (DEFAULT, 'XYZ Widgets')
+ RETURNING did;
+
+
+ Increment the sales count of the salesperson who manages the
+ account for Acme Corporation, and record the whole updated row
+ along with current time in a log table:
+
+WITH upd AS (
+ UPDATE employees SET sales_count = sales_count + 1 WHERE id =
+ (SELECT sales_person FROM accounts WHERE name = 'Acme Corporation')
+ RETURNING *
+)
+INSERT INTO employees_log SELECT *, current_timestamp FROM upd;
+
+
+ Insert or update new distributors as appropriate. Assumes a unique
+ index has been defined that constrains values appearing in the
+ did column. Note that the special
+ excluded table is used to reference values originally
+ proposed for insertion:
+
+INSERT INTO distributors (did, dname)
+ VALUES (5, 'Gizmo Transglobal'), (6, 'Associated Computing, Inc')
+ ON CONFLICT (did) DO UPDATE SET dname = EXCLUDED.dname;
+
+
+ Insert a distributor, or do nothing for rows proposed for insertion
+ when an existing, excluded row (a row with a matching constrained
+ column or columns after before row insert triggers fire) exists.
+ Example assumes a unique index has been defined that constrains
+ values appearing in the did column:
+
+INSERT INTO distributors (did, dname) VALUES (7, 'Redline GmbH')
+ ON CONFLICT (did) DO NOTHING;
+
+
+ Insert or update new distributors as appropriate. Example assumes
+ a unique index has been defined that constrains values appearing in
+ the did column. WHERE clause is
+ used to limit the rows actually updated (any existing row not
+ updated will still be locked, though):
+
+-- Don't update existing distributors based in a certain ZIP code
+INSERT INTO distributors AS d (did, dname) VALUES (8, 'Anvil Distribution')
+ ON CONFLICT (did) DO UPDATE
+ SET dname = EXCLUDED.dname || ' (formerly ' || d.dname || ')'
+ WHERE d.zipcode <> '21201';
+
+-- Name a constraint directly in the statement (uses associated
+-- index to arbitrate taking the DO NOTHING action)
+INSERT INTO distributors (did, dname) VALUES (9, 'Antwerp Design')
+ ON CONFLICT ON CONSTRAINT distributors_pkey DO NOTHING;
+
+
+ Insert new distributor if possible; otherwise
+ DO NOTHING. Example assumes a unique index has been
+ defined that constrains values appearing in the
+ did column on a subset of rows where the
+ is_active Boolean column evaluates to
+ true:
+
+-- This statement could infer a partial unique index on "did"
+-- with a predicate of "WHERE is_active", but it could also
+-- just use a regular unique constraint on "did"
+INSERT INTO distributors (did, dname) VALUES (10, 'Conrad International')
+ ON CONFLICT (did) WHERE is_active DO NOTHING;
+
Compatibility
+ INSERT conforms to the SQL standard, except that
+ the RETURNING clause is a
+ PostgreSQL extension, as is the ability
+ to use WITH with INSERT, and the ability to
+ specify an alternative action with ON CONFLICT.
+ Also, the case in
+ which a column name list is omitted, but not all the columns are
+ filled from the VALUES clause or query,
+ is disallowed by the standard. If you prefer a more SQL standard
+ conforming statement than ON CONFLICT, see
+ MERGE.
+
+ The SQL standard specifies that OVERRIDING SYSTEM VALUE
+ can only be specified if an identity column that is generated always
+ exists. PostgreSQL allows the clause in any case and ignores it if it is
+ not applicable.
+
+ Possible limitations of the query clause are documented under
+ SELECT.
+
Appendix C. SQL Key Words
+ Table C.1 lists all tokens that are key words
+ in the SQL standard and in PostgreSQL
+ 16.3. Background information can be found in Section 4.1.1.
+ (For space reasons, only the latest two versions of the SQL standard, and
+ SQL-92 for historical comparison, are included. The differences between
+ those and the other intermediate standard versions are small.)
+
+ SQL distinguishes between reserved and
+ non-reserved key words. According to the standard,
+ reserved key words
+ are the only real key words; they are never allowed as identifiers.
+ Non-reserved key words only have a special meaning in particular
+ contexts and can be used as identifiers in other contexts. Most
+ non-reserved key words are actually the names of built-in tables
+ and functions specified by SQL. The concept of non-reserved key
+ words essentially only exists to declare that some predefined meaning
+ is attached to a word in some contexts.
+
+ In the PostgreSQL parser, life is a bit
+ more complicated. There are several different classes of tokens
+ ranging from those that can never be used as an identifier to those
+ that have absolutely no special status in the parser, but are considered
+ ordinary identifiers. (The latter is usually the case for
+ functions specified by SQL.) Even reserved key words are not
+ completely reserved in PostgreSQL, but
+ can be used as column labels (for example, SELECT 55 AS
+ CHECK, even though CHECK is a reserved key
+ word).
+
+ In Table C.1 in the column for
+ PostgreSQL we classify as
+ “non-reserved” those key words that are explicitly
+ known to the parser but are allowed as column or table names.
+ Some key words that are otherwise
+ non-reserved cannot be used as function or data type names and are
+ marked accordingly. (Most of these words represent built-in
+ functions or data types with special syntax. The function or type
+ is still available but it cannot be redefined by the user.) Labeled
+ “reserved” are those tokens that are not allowed as
+ column or table names. Some reserved key words are
+ allowable as names for functions or data types; this is also shown in the
+ table. If not so marked, a reserved key word is only allowed as a
+ column label.
+ A blank entry in this column means that the word is treated as an
+ ordinary identifier by PostgreSQL.
+
+ Furthermore, while most key words can be used as “bare”
+ column labels without writing AS before them (as
+ described in Section 7.3.2), there are a few
+ that require a leading AS to avoid ambiguity. These
+ are marked in the table as “requires AS”.
+
+ As a general rule, if you get spurious parser errors for commands
+ that use any of the listed key words as an identifier, you should
+ try quoting the identifier to see if the problem goes away.
+
+ It is important to understand before studying Table C.1 that the fact that a key word is not
+ reserved in PostgreSQL does not mean that
+ the feature related to the word is not implemented. Conversely, the
+ presence of a key word does not indicate the existence of a feature.
+
Table C.1. SQL Key Words
| Key Word | PostgreSQL | SQL:2023 | SQL:2016 | SQL-92 |
|---|
A | | non-reserved | non-reserved | |
ABORT | non-reserved | | | |
ABS | | reserved | reserved | |
ABSENT | non-reserved | reserved | reserved | |
ABSOLUTE | non-reserved | non-reserved | non-reserved | reserved |
ACCESS | non-reserved | | | |
ACCORDING | | non-reserved | non-reserved | |
ACOS | | reserved | reserved | |
ACTION | non-reserved | non-reserved | non-reserved | reserved |
ADA | | non-reserved | non-reserved | non-reserved |
ADD | non-reserved | non-reserved | non-reserved | reserved |
ADMIN | non-reserved | non-reserved | non-reserved | |
AFTER | non-reserved | non-reserved | non-reserved | |
AGGREGATE | non-reserved | | | |
ALL | reserved | reserved | reserved | reserved |
ALLOCATE | | reserved | reserved | reserved |
ALSO | non-reserved | | | |
ALTER | non-reserved | reserved | reserved | reserved |
ALWAYS | non-reserved | non-reserved | non-reserved | |
ANALYSE | reserved | | | |
ANALYZE | reserved | | | |
AND | reserved | reserved | reserved | reserved |
ANY | reserved | reserved | reserved | reserved |
ANY_VALUE | | reserved | | |
ARE | | reserved | reserved | reserved |
ARRAY | reserved, requires AS | reserved | reserved | |
ARRAY_AGG | | reserved | reserved | |
ARRAY_MAX_CARDINALITY | | reserved | reserved | |
AS | reserved, requires AS | reserved | reserved | reserved |
ASC | reserved | non-reserved | non-reserved | reserved |
ASENSITIVE | non-reserved | reserved | reserved | |
ASIN | | reserved | reserved | |
ASSERTION | non-reserved | non-reserved | non-reserved | reserved |
ASSIGNMENT | non-reserved | non-reserved | non-reserved | |
ASYMMETRIC | reserved | reserved | reserved | |
AT | non-reserved | reserved | reserved | reserved |
ATAN | | reserved | reserved | |
ATOMIC | non-reserved | reserved | reserved | |
ATTACH | non-reserved | | | |
ATTRIBUTE | non-reserved | non-reserved | non-reserved | |
ATTRIBUTES | | non-reserved | non-reserved | |
AUTHORIZATION | reserved (can be function or type) | reserved | reserved | reserved |
AVG | | reserved | reserved | reserved |
BACKWARD | non-reserved | | | |
BASE64 | | non-reserved | non-reserved | |
BEFORE | non-reserved | non-reserved | non-reserved | |
BEGIN | non-reserved | reserved | reserved | reserved |
BEGIN_FRAME | | reserved | reserved | |
BEGIN_PARTITION | | reserved | reserved | |
BERNOULLI | | non-reserved | non-reserved | |
BETWEEN | non-reserved (cannot be function or type) | reserved | reserved | reserved |
BIGINT | non-reserved (cannot be function or type) | reserved | reserved | |
BINARY | reserved (can be function or type) | reserved | reserved | |
BIT | non-reserved (cannot be function or type) | | | reserved |
BIT_LENGTH | | | | reserved |
BLOB | | reserved | reserved | |
BLOCKED | | non-reserved | non-reserved | |
BOM | | non-reserved | non-reserved | |
BOOLEAN | non-reserved (cannot be function or type) | reserved | reserved | |
BOTH | reserved | reserved | reserved | reserved |
BREADTH | non-reserved | non-reserved | non-reserved | |
BTRIM | | reserved | | |
BY | non-reserved | reserved | reserved | reserved |
C | | non-reserved | non-reserved | non-reserved |
CACHE | non-reserved | | | |
CALL | non-reserved | reserved | reserved | |
CALLED | non-reserved | reserved | reserved | |
CARDINALITY | | reserved | reserved | |
CASCADE | non-reserved | non-reserved | non-reserved | reserved |
CASCADED | non-reserved | reserved | reserved | reserved |
CASE | reserved | reserved | reserved | reserved |
CAST | reserved | reserved | reserved | reserved |
CATALOG | non-reserved | non-reserved | non-reserved | reserved |
CATALOG_NAME | | non-reserved | non-reserved | non-reserved |
CEIL | | reserved | reserved | |
CEILING | | reserved | reserved | |
CHAIN | non-reserved | non-reserved | non-reserved | |
CHAINING | | non-reserved | non-reserved | |
CHAR | non-reserved (cannot be function or type), requires AS | reserved | reserved | reserved |
CHARACTER | non-reserved (cannot be function or type), requires AS | reserved | reserved | reserved |
CHARACTERISTICS | non-reserved | non-reserved | non-reserved | |
CHARACTERS | | non-reserved | non-reserved | |
CHARACTER_LENGTH | | reserved | reserved | reserved |
CHARACTER_SET_CATALOG | | non-reserved | non-reserved | non-reserved |
CHARACTER_SET_NAME | | non-reserved | non-reserved | non-reserved |
CHARACTER_SET_SCHEMA | | non-reserved | non-reserved | non-reserved |
CHAR_LENGTH | | reserved | reserved | reserved |
CHECK | reserved | reserved | reserved | reserved |
CHECKPOINT | non-reserved | | | |
CLASS | non-reserved | | | |
CLASSIFIER | | reserved | reserved | |
CLASS_ORIGIN | | non-reserved | non-reserved | non-reserved |
CLOB | | reserved | reserved | |
CLOSE | non-reserved | reserved | reserved | reserved |
CLUSTER | non-reserved | | | |
COALESCE | non-reserved (cannot be function or type) | reserved | reserved | reserved |
COBOL | | non-reserved | non-reserved | non-reserved |
COLLATE | reserved | reserved | reserved | reserved |
COLLATION | reserved (can be function or type) | non-reserved | non-reserved | reserved |
COLLATION_CATALOG | | non-reserved | non-reserved | non-reserved |
COLLATION_NAME | | non-reserved | non-reserved | non-reserved |
COLLATION_SCHEMA | | non-reserved | non-reserved | non-reserved |
COLLECT | | reserved | reserved | |
COLUMN | reserved | reserved | reserved | reserved |
COLUMNS | non-reserved | non-reserved | non-reserved | |
COLUMN_NAME | | non-reserved | non-reserved | non-reserved |
COMMAND_FUNCTION | | non-reserved | non-reserved | non-reserved |
COMMAND_FUNCTION_CODE | | non-reserved | non-reserved | |
COMMENT | non-reserved | | | |
COMMENTS | non-reserved | | | |
COMMIT | non-reserved | reserved | reserved | reserved |
COMMITTED | non-reserved | non-reserved | non-reserved | non-reserved |
COMPRESSION | non-reserved | | | |
CONCURRENTLY | reserved (can be function or type) | | | |
CONDITION | | reserved | reserved | |
CONDITIONAL | | non-reserved | non-reserved | |
CONDITION_NUMBER | | non-reserved | non-reserved | non-reserved |
CONFIGURATION | non-reserved | | | |
CONFLICT | non-reserved | | | |
CONNECT | | reserved | reserved | reserved |
CONNECTION | non-reserved | non-reserved | non-reserved | reserved |
CONNECTION_NAME | | non-reserved | non-reserved | non-reserved |
CONSTRAINT | reserved | reserved | reserved | reserved |
CONSTRAINTS | non-reserved | non-reserved | non-reserved | reserved |
CONSTRAINT_CATALOG | | non-reserved | non-reserved | non-reserved |
CONSTRAINT_NAME | | non-reserved | non-reserved | non-reserved |
CONSTRAINT_SCHEMA | | non-reserved | non-reserved | non-reserved |
CONSTRUCTOR | | non-reserved | non-reserved | |
CONTAINS | | reserved | reserved | |
CONTENT | non-reserved | non-reserved | non-reserved | |
CONTINUE | non-reserved | non-reserved | non-reserved | reserved |
CONTROL | | non-reserved | non-reserved | |
CONVERSION | non-reserved | | | |
CONVERT | | reserved | reserved | reserved |
COPARTITION | | non-reserved | | |
COPY | non-reserved | reserved | reserved | |
CORR | | reserved | reserved | |
CORRESPONDING | | reserved | reserved | reserved |
COS | | reserved | reserved | |
COSH | | reserved | reserved | |
COST | non-reserved | | | |
COUNT | | reserved | reserved | reserved |
COVAR_POP | | reserved | reserved | |
COVAR_SAMP | | reserved | reserved | |
CREATE | reserved, requires AS | reserved | reserved | reserved |
CROSS | reserved (can be function or type) | reserved | reserved | reserved |
CSV | non-reserved | | | |
CUBE | non-reserved | reserved | reserved | |
CUME_DIST | | reserved | reserved | |
CURRENT | non-reserved | reserved | reserved | reserved |
CURRENT_CATALOG | reserved | reserved | reserved | |
CURRENT_DATE | reserved | reserved | reserved | reserved |
CURRENT_DEFAULT_TRANSFORM_GROUP | | reserved | reserved | |
CURRENT_PATH | | reserved | reserved | |
CURRENT_ROLE | reserved | reserved | reserved | |
CURRENT_ROW | | reserved | reserved | |
CURRENT_SCHEMA | reserved (can be function or type) | reserved | reserved | |
CURRENT_TIME | reserved | reserved | reserved | reserved |
CURRENT_TIMESTAMP | reserved | reserved | reserved | reserved |
CURRENT_TRANSFORM_GROUP_FOR_TYPE | | reserved | reserved | |
CURRENT_USER | reserved | reserved | reserved | reserved |
CURSOR | non-reserved | reserved | reserved | reserved |
CURSOR_NAME | | non-reserved | non-reserved | non-reserved |
CYCLE | non-reserved | reserved | reserved | |
DATA | non-reserved | non-reserved | non-reserved | non-reserved |
DATABASE | non-reserved | | | |
DATALINK | | reserved | reserved | |
DATE | | reserved | reserved | reserved |
DATETIME_INTERVAL_CODE | | non-reserved | non-reserved | non-reserved |
DATETIME_INTERVAL_PRECISION | | non-reserved | non-reserved | non-reserved |
DAY | non-reserved, requires AS | reserved | reserved | reserved |
DB | | non-reserved | non-reserved | |
DEALLOCATE | non-reserved | reserved | reserved | reserved |
DEC | non-reserved (cannot be function or type) | reserved | reserved | reserved |
DECFLOAT | | reserved | reserved | |
DECIMAL | non-reserved (cannot be function or type) | reserved | reserved | reserved |
DECLARE | non-reserved | reserved | reserved | reserved |
DEFAULT | reserved | reserved | reserved | reserved |
DEFAULTS | non-reserved | non-reserved | non-reserved | |
DEFERRABLE | reserved | non-reserved | non-reserved | reserved |
DEFERRED | non-reserved | non-reserved | non-reserved | reserved |
DEFINE | | reserved | reserved | |
DEFINED | | non-reserved | non-reserved | |
DEFINER | non-reserved | non-reserved | non-reserved | |
DEGREE | | non-reserved | non-reserved | |
DELETE | non-reserved | reserved | reserved | reserved |
DELIMITER | non-reserved | | | |
DELIMITERS | non-reserved | | | |
DENSE_RANK | | reserved | reserved | |
DEPENDS | non-reserved | | | |
DEPTH | non-reserved | non-reserved | non-reserved | |
DEREF | | reserved | reserved | |
DERIVED | | non-reserved | non-reserved | |
DESC | reserved | non-reserved | non-reserved | reserved |
DESCRIBE | | reserved | reserved | reserved |
DESCRIPTOR | | non-reserved | non-reserved | reserved |
DETACH | non-reserved | | | |
DETERMINISTIC | | reserved | reserved | |
DIAGNOSTICS | | non-reserved | non-reserved | reserved |
DICTIONARY | non-reserved | | | |
DISABLE | non-reserved | | | |
DISCARD | non-reserved | | | |
DISCONNECT | | reserved | reserved | reserved |
DISPATCH | | non-reserved | non-reserved | |
DISTINCT | reserved | reserved | reserved | reserved |
DLNEWCOPY | | reserved | reserved | |
DLPREVIOUSCOPY | | reserved | reserved | |
DLURLCOMPLETE | | reserved | reserved | |
DLURLCOMPLETEONLY | | reserved | reserved | |
DLURLCOMPLETEWRITE | | reserved | reserved | |
DLURLPATH | | reserved | reserved | |
DLURLPATHONLY | | reserved | reserved | |
DLURLPATHWRITE | | reserved | reserved | |
DLURLSCHEME | | reserved | reserved | |
DLURLSERVER | | reserved | reserved | |
DLVALUE | | reserved | reserved | |
DO | reserved | | | |
DOCUMENT | non-reserved | non-reserved | non-reserved | |
DOMAIN | non-reserved | non-reserved | non-reserved | reserved |
DOUBLE | non-reserved | reserved | reserved | reserved |
DROP | non-reserved | reserved | reserved | reserved |
DYNAMIC | | reserved | reserved | |
DYNAMIC_FUNCTION | | non-reserved | non-reserved | non-reserved |
DYNAMIC_FUNCTION_CODE | | non-reserved | non-reserved | |
EACH | non-reserved | reserved | reserved | |
ELEMENT | | reserved | reserved | |
ELSE | reserved | reserved | reserved | reserved |
EMPTY | | reserved | reserved | |
ENABLE | non-reserved | | | |
ENCODING | non-reserved | non-reserved | non-reserved | |
ENCRYPTED | non-reserved | | | |
END | reserved | reserved | reserved | reserved |
END-EXEC | | reserved | reserved | reserved |
END_FRAME | | reserved | reserved | |
END_PARTITION | | reserved | reserved | |
ENFORCED | | non-reserved | non-reserved | |
ENUM | non-reserved | | | |
EQUALS | | reserved | reserved | |
ERROR | | non-reserved | non-reserved | |
ESCAPE | non-reserved | reserved | reserved | reserved |
EVENT | non-reserved | | | |
EVERY | | reserved | reserved | |
EXCEPT | reserved, requires AS | reserved | reserved | reserved |
EXCEPTION | | | | reserved |
EXCLUDE | non-reserved | non-reserved | non-reserved | |
EXCLUDING | non-reserved | non-reserved | non-reserved | |
EXCLUSIVE | non-reserved | | | |
EXEC | | reserved | reserved | reserved |
EXECUTE | non-reserved | reserved | reserved | reserved |
EXISTS | non-reserved (cannot be function or type) | reserved | reserved | reserved |
EXP | | reserved | reserved | |
EXPLAIN | non-reserved | | | |
EXPRESSION | non-reserved | non-reserved | non-reserved | |
EXTENSION | non-reserved | | | |
EXTERNAL | non-reserved | reserved | reserved | reserved |
EXTRACT | non-reserved (cannot be function or type) | reserved | reserved | reserved |
FALSE | reserved | reserved | reserved | reserved |
FAMILY | non-reserved | | | |
FETCH | reserved, requires AS | reserved | reserved | reserved |
FILE | | non-reserved | non-reserved | |
FILTER | non-reserved, requires AS | reserved | reserved | |
FINAL | | non-reserved | non-reserved | |
FINALIZE | non-reserved | | | |
FINISH | | non-reserved | non-reserved | |
FIRST | non-reserved | non-reserved | non-reserved | reserved |
FIRST_VALUE | | reserved | reserved | |
FLAG | | non-reserved | non-reserved | |
FLOAT | non-reserved (cannot be function or type) | reserved | reserved | reserved |
FLOOR | | reserved | reserved | |
FOLLOWING | non-reserved | non-reserved | non-reserved | |
FOR | reserved, requires AS | reserved | reserved | reserved |
FORCE | non-reserved | | | |
FOREIGN | reserved | reserved | reserved | reserved |
FORMAT | non-reserved | non-reserved | non-reserved | |
FORTRAN | | non-reserved | non-reserved | non-reserved |
FORWARD | non-reserved | | | |
FOUND | | non-reserved | non-reserved | reserved |
FRAME_ROW | | reserved | reserved | |
FREE | | reserved | reserved | |
FREEZE | reserved (can be function or type) | | | |
FROM | reserved, requires AS | reserved | reserved | reserved |
FS | | non-reserved | non-reserved | |
FULFILL | | non-reserved | non-reserved | |
FULL | reserved (can be function or type) | reserved | reserved | reserved |
FUNCTION | non-reserved | reserved | reserved | |
FUNCTIONS | non-reserved | | | |
FUSION | | reserved | reserved | |
G | | non-reserved | non-reserved | |
GENERAL | | non-reserved | non-reserved | |
GENERATED | non-reserved | non-reserved | non-reserved | |
GET | | reserved | reserved | reserved |
GLOBAL | non-reserved | reserved | reserved | reserved |
GO | | non-reserved | non-reserved | reserved |
GOTO | | non-reserved | non-reserved | reserved |
GRANT | reserved, requires AS | reserved | reserved | reserved |
GRANTED | non-reserved | non-reserved | non-reserved | |
GREATEST | non-reserved (cannot be function or type) | reserved | | |
GROUP | reserved, requires AS | reserved | reserved | reserved |
GROUPING | non-reserved (cannot be function or type) | reserved | reserved | |
GROUPS | non-reserved | reserved | reserved | |
HANDLER | non-reserved | | | |
HAVING | reserved, requires AS | reserved | reserved | reserved |
HEADER | non-reserved | | | |
HEX | | non-reserved | non-reserved | |
HIERARCHY | | non-reserved | non-reserved | |
HOLD | non-reserved | reserved | reserved | |
HOUR | non-reserved, requires AS | reserved | reserved | reserved |
ID | | non-reserved | non-reserved | |
IDENTITY | non-reserved | reserved | reserved | reserved |
IF | non-reserved | | | |
IGNORE | | non-reserved | non-reserved | |
ILIKE | reserved (can be function or type) | | | |
IMMEDIATE | non-reserved | non-reserved | non-reserved | reserved |
IMMEDIATELY | | non-reserved | non-reserved | |
IMMUTABLE | non-reserved | | | |
IMPLEMENTATION | | non-reserved | non-reserved | |
IMPLICIT | non-reserved | | | |
IMPORT | non-reserved | reserved | reserved | |
IN | reserved | reserved | reserved | reserved |
INCLUDE | non-reserved | | | |
INCLUDING | non-reserved | non-reserved | non-reserved | |
INCREMENT | non-reserved | non-reserved | non-reserved | |
INDENT | non-reserved | non-reserved | non-reserved | |
INDEX | non-reserved | | | |
INDEXES | non-reserved | | | |
INDICATOR | | reserved | reserved | reserved |
INHERIT | non-reserved | | | |
INHERITS | non-reserved | | | |
INITIAL | | reserved | reserved | |
INITIALLY | reserved | non-reserved | non-reserved | reserved |
INLINE | non-reserved | | | |
INNER | reserved (can be function or type) | reserved | reserved | reserved |
INOUT | non-reserved (cannot be function or type) | reserved | reserved | |
INPUT | non-reserved | non-reserved | non-reserved | reserved |
INSENSITIVE | non-reserved | reserved | reserved | reserved |
INSERT | non-reserved | reserved | reserved | reserved |
INSTANCE | | non-reserved | non-reserved | |
INSTANTIABLE | | non-reserved | non-reserved | |
INSTEAD | non-reserved | non-reserved | non-reserved | |
INT | non-reserved (cannot be function or type) | reserved | reserved | reserved |
INTEGER | non-reserved (cannot be function or type) | reserved | reserved | reserved |
INTEGRITY | | non-reserved | non-reserved | |
INTERSECT | reserved, requires AS | reserved | reserved | reserved |
INTERSECTION | | reserved | reserved | |
INTERVAL | non-reserved (cannot be function or type) | reserved | reserved | reserved |
INTO | reserved, requires AS | reserved | reserved | reserved |
INVOKER | non-reserved | non-reserved | non-reserved | |
IS | reserved (can be function or type) | reserved | reserved | reserved |
ISNULL | reserved (can be function or type), requires AS | | | |
ISOLATION | non-reserved | non-reserved | non-reserved | reserved |
JOIN | reserved (can be function or type) | reserved | reserved | reserved |
JSON | non-reserved | reserved | | |
JSON_ARRAY | non-reserved (cannot be function or type) | reserved | reserved | |
JSON_ARRAYAGG | non-reserved (cannot be function or type) | reserved | reserved | |
JSON_EXISTS | | reserved | reserved | |
JSON_OBJECT | non-reserved (cannot be function or type) | reserved | reserved | |
JSON_OBJECTAGG | non-reserved (cannot be function or type) | reserved | reserved | |
JSON_QUERY | | reserved | reserved | |
JSON_SCALAR | | reserved | | |
JSON_SERIALIZE | | reserved | | |
JSON_TABLE | | reserved | reserved | |
JSON_TABLE_PRIMITIVE | | reserved | reserved | |
JSON_VALUE | | reserved | reserved | |
K | | non-reserved | non-reserved | |
KEEP | | non-reserved | non-reserved | |
KEY | non-reserved | non-reserved | non-reserved | reserved |
KEYS | non-reserved | non-reserved | non-reserved | |
KEY_MEMBER | | non-reserved | non-reserved | |
KEY_TYPE | | non-reserved | non-reserved | |
LABEL | non-reserved | | | |
LAG | | reserved | reserved | |
LANGUAGE | non-reserved | reserved | reserved | reserved |
LARGE | non-reserved | reserved | reserved | |
LAST | non-reserved | non-reserved | non-reserved | reserved |
LAST_VALUE | | reserved | reserved | |
LATERAL | reserved | reserved | reserved | |
LEAD | | reserved | reserved | |
LEADING | reserved | reserved | reserved | reserved |
LEAKPROOF | non-reserved | | | |
LEAST | non-reserved (cannot be function or type) | reserved | | |
LEFT | reserved (can be function or type) | reserved | reserved | reserved |
LENGTH | | non-reserved | non-reserved | non-reserved |
LEVEL | non-reserved | non-reserved | non-reserved | reserved |
LIBRARY | | non-reserved | non-reserved | |
LIKE | reserved (can be function or type) | reserved | reserved | reserved |
LIKE_REGEX | | reserved | reserved | |
LIMIT | reserved, requires AS | non-reserved | non-reserved | |
LINK | | non-reserved | non-reserved | |
LISTAGG | | reserved | reserved | |
LISTEN | non-reserved | | | |
LN | | reserved | reserved | |
LOAD | non-reserved | | | |
LOCAL | non-reserved | reserved | reserved | reserved |
LOCALTIME | reserved | reserved | reserved | |
LOCALTIMESTAMP | reserved | reserved | reserved | |
LOCATION | non-reserved | non-reserved | non-reserved | |
LOCATOR | | non-reserved | non-reserved | |
LOCK | non-reserved | | | |
LOCKED | non-reserved | | | |
LOG | | reserved | reserved | |
LOG10 | | reserved | reserved | |
LOGGED | non-reserved | | | |
LOWER | | reserved | reserved | reserved |
LPAD | | reserved | | |
LTRIM | | reserved | | |
M | | non-reserved | non-reserved | |
MAP | | non-reserved | non-reserved | |
MAPPING | non-reserved | non-reserved | non-reserved | |
MATCH | non-reserved | reserved | reserved | reserved |
MATCHED | non-reserved | non-reserved | non-reserved | |
MATCHES | | reserved | reserved | |
MATCH_NUMBER | | reserved | reserved | |
MATCH_RECOGNIZE | | reserved | reserved | |
MATERIALIZED | non-reserved | | | |
MAX | | reserved | reserved | reserved |
MAXVALUE | non-reserved | non-reserved | non-reserved | |
MEASURES | | non-reserved | non-reserved | |
MEMBER | | reserved | reserved | |
MERGE | non-reserved | reserved | reserved | |
MESSAGE_LENGTH | | non-reserved | non-reserved | non-reserved |
MESSAGE_OCTET_LENGTH | | non-reserved | non-reserved | non-reserved |
MESSAGE_TEXT | | non-reserved | non-reserved | non-reserved |
METHOD | non-reserved | reserved | reserved | |
MIN | | reserved | reserved | reserved |
MINUTE | non-reserved, requires AS | reserved | reserved | reserved |
MINVALUE | non-reserved | non-reserved | non-reserved | |
MOD | | reserved | reserved | |
MODE | non-reserved | | | |
MODIFIES | | reserved | reserved | |
MODULE | | reserved | reserved | reserved |
MONTH | non-reserved, requires AS | reserved | reserved | reserved |
MORE | | non-reserved | non-reserved | non-reserved |
MOVE | non-reserved | | | |
MULTISET | | reserved | reserved | |
MUMPS | | non-reserved | non-reserved | non-reserved |
NAME | non-reserved | non-reserved | non-reserved | non-reserved |
NAMES | non-reserved | non-reserved | non-reserved | reserved |
NAMESPACE | | non-reserved | non-reserved | |
NATIONAL | non-reserved (cannot be function or type) | reserved | reserved | reserved |
NATURAL | reserved (can be function or type) | reserved | reserved | reserved |
NCHAR | non-reserved (cannot be function or type) | reserved | reserved | reserved |
NCLOB | | reserved | reserved | |
NESTED | | non-reserved | non-reserved | |
NESTING | | non-reserved | non-reserved | |
NEW | non-reserved | reserved | reserved | |
NEXT | non-reserved | non-reserved | non-reserved | reserved |
NFC | non-reserved | non-reserved | non-reserved | |
NFD | non-reserved | non-reserved | non-reserved | |
NFKC | non-reserved | non-reserved | non-reserved | |
NFKD | non-reserved | non-reserved | non-reserved | |
NIL | | non-reserved | non-reserved | |
NO | non-reserved | reserved | reserved | reserved |
NONE | non-reserved (cannot be function or type) | reserved | reserved | |
NORMALIZE | non-reserved (cannot be function or type) | reserved | reserved | |
NORMALIZED | non-reserved | non-reserved | non-reserved | |
NOT | reserved | reserved | reserved | reserved |
NOTHING | non-reserved | | | |
NOTIFY | non-reserved | | | |
NOTNULL | reserved (can be function or type), requires AS | | | |
NOWAIT | non-reserved | | | |
NTH_VALUE | | reserved | reserved | |
NTILE | | reserved | reserved | |
NULL | reserved | reserved | reserved | reserved |
NULLABLE | | non-reserved | non-reserved | non-reserved |
NULLIF | non-reserved (cannot be function or type) | reserved | reserved | reserved |
NULLS | non-reserved | non-reserved | non-reserved | |
NULL_ORDERING | | non-reserved | non-reserved | |
NUMBER | | non-reserved | non-reserved | non-reserved |
NUMERIC | non-reserved (cannot be function or type) | reserved | reserved | reserved |
OBJECT | non-reserved | non-reserved | non-reserved | |
OCCURRENCE | | non-reserved | non-reserved | |
OCCURRENCES_REGEX | | reserved | reserved | |
OCTETS | | non-reserved | non-reserved | |
OCTET_LENGTH | | reserved | reserved | reserved |
OF | non-reserved | reserved | reserved | reserved |
OFF | non-reserved | non-reserved | non-reserved | |
OFFSET | reserved, requires AS | reserved | reserved | |
OIDS | non-reserved | | | |
OLD | non-reserved | reserved | reserved | |
OMIT | | reserved | reserved | |
ON | reserved, requires AS | reserved | reserved | reserved |
ONE | | reserved | reserved | |
ONLY | reserved | reserved | reserved | reserved |
OPEN | | reserved | reserved | reserved |
OPERATOR | non-reserved | | | |
OPTION | non-reserved | non-reserved | non-reserved | reserved |
OPTIONS | non-reserved | non-reserved | non-reserved | |
OR | reserved | reserved | reserved | reserved |
ORDER | reserved, requires AS | reserved | reserved | reserved |
ORDERING | | non-reserved | non-reserved | |
ORDINALITY | non-reserved | non-reserved | non-reserved | |
OTHERS | non-reserved | non-reserved | non-reserved | |
OUT | non-reserved (cannot be function or type) | reserved | reserved | |
OUTER | reserved (can be function or type) | reserved | reserved | reserved |
OUTPUT | | non-reserved | non-reserved | reserved |
OVER | non-reserved, requires AS | reserved | reserved | |
OVERFLOW | | non-reserved | non-reserved | |
OVERLAPS | reserved (can be function or type), requires AS | reserved | reserved | reserved |
OVERLAY | non-reserved (cannot be function or type) | reserved | reserved | |
OVERRIDING | non-reserved | non-reserved | non-reserved | |
OWNED | non-reserved | | | |
OWNER | non-reserved | | | |
P | | non-reserved | non-reserved | |
PAD | | non-reserved | non-reserved | reserved |
PARALLEL | non-reserved | | | |
PARAMETER | non-reserved | reserved | reserved | |
PARAMETER_MODE | | non-reserved | non-reserved | |
PARAMETER_NAME | | non-reserved | non-reserved | |
PARAMETER_ORDINAL_POSITION | | non-reserved | non-reserved | |
PARAMETER_SPECIFIC_CATALOG | | non-reserved | non-reserved | |
PARAMETER_SPECIFIC_NAME | | non-reserved | non-reserved | |
PARAMETER_SPECIFIC_SCHEMA | | non-reserved | non-reserved | |
PARSER | non-reserved | | | |
PARTIAL | non-reserved | non-reserved | non-reserved | reserved |
PARTITION | non-reserved | reserved | reserved | |
PASCAL | | non-reserved | non-reserved | non-reserved |
PASS | | non-reserved | non-reserved | |
PASSING | non-reserved | non-reserved | non-reserved | |
PASSTHROUGH | | non-reserved | non-reserved | |
PASSWORD | non-reserved | | | |
PAST | | non-reserved | non-reserved | |
PATH | | non-reserved | non-reserved | |
PATTERN | | reserved | reserved | |
PER | | reserved | reserved | |
PERCENT | | reserved | reserved | |
PERCENTILE_CONT | | reserved | reserved | |
PERCENTILE_DISC | | reserved | reserved | |
PERCENT_RANK | | reserved | reserved | |
PERIOD | | reserved | reserved | |
PERMISSION | | non-reserved | non-reserved | |
PERMUTE | | non-reserved | non-reserved | |
PIPE | | non-reserved | non-reserved | |
PLACING | reserved | non-reserved | non-reserved | |
PLAN | | non-reserved | non-reserved | |
PLANS | non-reserved | | | |
PLI | | non-reserved | non-reserved | non-reserved |
POLICY | non-reserved | | | |
PORTION | | reserved | reserved | |
POSITION | non-reserved (cannot be function or type) | reserved | reserved | reserved |
POSITION_REGEX | | reserved | reserved | |
POWER | | reserved | reserved | |
PRECEDES | | reserved | reserved | |
PRECEDING | non-reserved | non-reserved | non-reserved | |
PRECISION | non-reserved (cannot be function or type), requires AS | reserved | reserved | reserved |
PREPARE | non-reserved | reserved | reserved | reserved |
PREPARED | non-reserved | | | |
PRESERVE | non-reserved | non-reserved | non-reserved | reserved |
PREV | | non-reserved | non-reserved | |
PRIMARY | reserved | reserved | reserved | reserved |
PRIOR | non-reserved | non-reserved | non-reserved | reserved |
PRIVATE | | non-reserved | non-reserved | |
PRIVILEGES | non-reserved | non-reserved | non-reserved | reserved |
PROCEDURAL | non-reserved | | | |
PROCEDURE | non-reserved | reserved | reserved | reserved |
PROCEDURES | non-reserved | | | |
PROGRAM | non-reserved | | | |
PRUNE | | non-reserved | non-reserved | |
PTF | | reserved | reserved | |
PUBLIC | | non-reserved | non-reserved | reserved |
PUBLICATION | non-reserved | | | |
QUOTE | non-reserved | | | |
QUOTES | | non-reserved | non-reserved | |
RANGE | non-reserved | reserved | reserved | |
RANK | | reserved | reserved | |
READ | non-reserved | non-reserved | non-reserved | reserved |
READS | | reserved | reserved | |
REAL | non-reserved (cannot be function or type) | reserved | reserved | reserved |
REASSIGN | non-reserved | | | |
RECHECK | non-reserved | | | |
RECOVERY | | non-reserved | non-reserved | |
RECURSIVE | non-reserved | reserved | reserved | |
REF | non-reserved | reserved | reserved | |
REFERENCES | reserved | reserved | reserved | reserved |
REFERENCING | non-reserved | reserved | reserved | |
REFRESH | non-reserved | | | |
REGR_AVGX | | reserved | reserved | |
REGR_AVGY | | reserved | reserved | |
REGR_COUNT | | reserved | reserved | |
REGR_INTERCEPT | | reserved | reserved | |
REGR_R2 | | reserved | reserved | |
REGR_SLOPE | | reserved | reserved | |
REGR_SXX | | reserved | reserved | |
REGR_SXY | | reserved | reserved | |
REGR_SYY | | reserved | reserved | |
REINDEX | non-reserved | | | |
RELATIVE | non-reserved | non-reserved | non-reserved | reserved |
RELEASE | non-reserved | reserved | reserved | |
RENAME | non-reserved | | | |
REPEATABLE | non-reserved | non-reserved | non-reserved | non-reserved |
REPLACE | non-reserved | | | |
REPLICA | non-reserved | | | |
REQUIRING | | non-reserved | non-reserved | |
RESET | non-reserved | | | |
RESPECT | | non-reserved | non-reserved | |
RESTART | non-reserved | non-reserved | non-reserved | |
RESTORE | | non-reserved | non-reserved | |
RESTRICT | non-reserved | non-reserved | non-reserved | reserved |
RESULT | | reserved | reserved | |
RETURN | non-reserved | reserved | reserved | |
RETURNED_CARDINALITY | | non-reserved | non-reserved | |
RETURNED_LENGTH | | non-reserved | non-reserved | non-reserved |
RETURNED_OCTET_LENGTH | | non-reserved | non-reserved | non-reserved |
RETURNED_SQLSTATE | | non-reserved | non-reserved | non-reserved |
RETURNING | reserved, requires AS | non-reserved | non-reserved | |
RETURNS | non-reserved | reserved | reserved | |
REVOKE | non-reserved | reserved | reserved | reserved |
RIGHT | reserved (can be function or type) | reserved | reserved | reserved |
ROLE | non-reserved | non-reserved | non-reserved | |
ROLLBACK | non-reserved | reserved | reserved | reserved |
ROLLUP | non-reserved | reserved | reserved | |
ROUTINE | non-reserved | non-reserved | non-reserved | |
ROUTINES | non-reserved | | | |
ROUTINE_CATALOG | | non-reserved | non-reserved | |
ROUTINE_NAME | | non-reserved | non-reserved | |
ROUTINE_SCHEMA | | non-reserved | non-reserved | |
ROW | non-reserved (cannot be function or type) | reserved | reserved | |
ROWS | non-reserved | reserved | reserved | reserved |
ROW_COUNT | | non-reserved | non-reserved | non-reserved |
ROW_NUMBER | | reserved | reserved | |
RPAD | | reserved | | |
RTRIM | | reserved | | |
RULE | non-reserved | | | |
RUNNING | | reserved | reserved | |
SAVEPOINT | non-reserved | reserved | reserved | |
SCALAR | non-reserved | non-reserved | non-reserved | |
SCALE | | non-reserved | non-reserved | non-reserved |
SCHEMA | non-reserved | non-reserved | non-reserved | reserved |
SCHEMAS | non-reserved | | | |
SCHEMA_NAME | | non-reserved | non-reserved | non-reserved |
SCOPE | | reserved | reserved | |
SCOPE_CATALOG | | non-reserved | non-reserved | |
SCOPE_NAME | | non-reserved | non-reserved | |
SCOPE_SCHEMA | | non-reserved | non-reserved | |
SCROLL | non-reserved | reserved | reserved | reserved |
SEARCH | non-reserved | reserved | reserved | |
SECOND | non-reserved, requires AS | reserved | reserved | reserved |
SECTION | | non-reserved | non-reserved | reserved |
SECURITY | non-reserved | non-reserved | non-reserved | |
SEEK | | reserved | reserved | |
SELECT | reserved | reserved | reserved | reserved |
SELECTIVE | | non-reserved | non-reserved | |
SELF | | non-reserved | non-reserved | |
SEMANTICS | | non-reserved | non-reserved | |
SENSITIVE | | reserved | reserved | |
SEQUENCE | non-reserved | non-reserved | non-reserved | |
SEQUENCES | non-reserved | | | |
SERIALIZABLE | non-reserved | non-reserved | non-reserved | non-reserved |
SERVER | non-reserved | non-reserved | non-reserved | |
SERVER_NAME | | non-reserved | non-reserved | non-reserved |
SESSION | non-reserved | non-reserved | non-reserved | reserved |
SESSION_USER | reserved | reserved | reserved | reserved |
SET | non-reserved | reserved | reserved | reserved |
SETOF | non-reserved (cannot be function or type) | | | |
SETS | non-reserved | non-reserved | non-reserved | |
SHARE | non-reserved | | | |
SHOW | non-reserved | reserved | reserved | |
SIMILAR | reserved (can be function or type) | reserved | reserved | |
SIMPLE | non-reserved | non-reserved | non-reserved | |
SIN | | reserved | reserved | |
SINH | | reserved | reserved | |
SIZE | | non-reserved | non-reserved | reserved |
SKIP | non-reserved | reserved | reserved | |
SMALLINT | non-reserved (cannot be function or type) | reserved | reserved | reserved |
SNAPSHOT | non-reserved | | | |
SOME | reserved | reserved | reserved | reserved |
SORT_DIRECTION | | non-reserved | non-reserved | |
SOURCE | | non-reserved | non-reserved | |
SPACE | | non-reserved | non-reserved | reserved |
SPECIFIC | | reserved | reserved | |
SPECIFICTYPE | | reserved | reserved | |
SPECIFIC_NAME | | non-reserved | non-reserved | |
SQL | non-reserved | reserved | reserved | reserved |
SQLCODE | | | | reserved |
SQLERROR | | | | reserved |
SQLEXCEPTION | | reserved | reserved | |
SQLSTATE | | reserved | reserved | reserved |
SQLWARNING | | reserved | reserved | |
SQRT | | reserved | reserved | |
STABLE | non-reserved | | | |
STANDALONE | non-reserved | non-reserved | non-reserved | |
START | non-reserved | reserved | reserved | |
STATE | | non-reserved | non-reserved | |
STATEMENT | non-reserved | non-reserved | non-reserved | |
STATIC | | reserved | reserved | |
STATISTICS | non-reserved | | | |
STDDEV_POP | | reserved | reserved | |
STDDEV_SAMP | | reserved | reserved | |
STDIN | non-reserved | | | |
STDOUT | non-reserved | | | |
STORAGE | non-reserved | | | |
STORED | non-reserved | | | |
STRICT | non-reserved | | | |
STRING | | non-reserved | non-reserved | |
STRIP | non-reserved | non-reserved | non-reserved | |
STRUCTURE | | non-reserved | non-reserved | |
STYLE | | non-reserved | non-reserved | |
SUBCLASS_ORIGIN | | non-reserved | non-reserved | non-reserved |
SUBMULTISET | | reserved | reserved | |
SUBSCRIPTION | non-reserved | | | |
SUBSET | | reserved | reserved | |
SUBSTRING | non-reserved (cannot be function or type) | reserved | reserved | reserved |
SUBSTRING_REGEX | | reserved | reserved | |
SUCCEEDS | | reserved | reserved | |
SUM | | reserved | reserved | reserved |
SUPPORT | non-reserved | | | |
SYMMETRIC | reserved | reserved | reserved | |
SYSID | non-reserved | | | |
SYSTEM | non-reserved | reserved | reserved | |
SYSTEM_TIME | | reserved | reserved | |
SYSTEM_USER | reserved | reserved | reserved | reserved |
T | | non-reserved | non-reserved | |
TABLE | reserved | reserved | reserved | reserved |
TABLES | non-reserved | | | |
TABLESAMPLE | reserved (can be function or type) | reserved | reserved | |
TABLESPACE | non-reserved | | | |
TABLE_NAME | | non-reserved | non-reserved | non-reserved |
TAN | | reserved | reserved | |
TANH | | reserved | reserved | |
TEMP | non-reserved | | | |
TEMPLATE | non-reserved | | | |
TEMPORARY | non-reserved | non-reserved | non-reserved | reserved |
TEXT | non-reserved | | | |
THEN | reserved | reserved | reserved | reserved |
THROUGH | | non-reserved | non-reserved | |
TIES | non-reserved | non-reserved | non-reserved | |
TIME | non-reserved (cannot be function or type) | reserved | reserved | reserved |
TIMESTAMP | non-reserved (cannot be function or type) | reserved | reserved | reserved |
TIMEZONE_HOUR | | reserved | reserved | reserved |
TIMEZONE_MINUTE | | reserved | reserved | reserved |
TO | reserved, requires AS | reserved | reserved | reserved |
TOKEN | | non-reserved | non-reserved | |
TOP_LEVEL_COUNT | | non-reserved | non-reserved | |
TRAILING | reserved | reserved | reserved | reserved |
TRANSACTION | non-reserved | non-reserved | non-reserved | reserved |
TRANSACTIONS_COMMITTED | | non-reserved | non-reserved | |
TRANSACTIONS_ROLLED_BACK | | non-reserved | non-reserved | |
TRANSACTION_ACTIVE | | non-reserved | non-reserved | |
TRANSFORM | non-reserved | non-reserved | non-reserved | |
TRANSFORMS | | non-reserved | non-reserved | |
TRANSLATE | | reserved | reserved | reserved |
TRANSLATE_REGEX | | reserved | reserved | |
TRANSLATION | | reserved | reserved | reserved |
TREAT | non-reserved (cannot be function or type) | reserved | reserved | |
TRIGGER | non-reserved | reserved | reserved | |
TRIGGER_CATALOG | | non-reserved | non-reserved | |
TRIGGER_NAME | | non-reserved | non-reserved | |
TRIGGER_SCHEMA | | non-reserved | non-reserved | |
TRIM | non-reserved (cannot be function or type) | reserved | reserved | reserved |
TRIM_ARRAY | | reserved | reserved | |
TRUE | reserved | reserved | reserved | reserved |
TRUNCATE | non-reserved | reserved | reserved | |
TRUSTED | non-reserved | | | |
TYPE | non-reserved | non-reserved | non-reserved | non-reserved |
TYPES | non-reserved | | | |
UESCAPE | non-reserved | reserved | reserved | |
UNBOUNDED | non-reserved | non-reserved | non-reserved | |
UNCOMMITTED | non-reserved | non-reserved | non-reserved | non-reserved |
UNCONDITIONAL | | non-reserved | non-reserved | |
UNDER | | non-reserved | non-reserved | |
UNENCRYPTED | non-reserved | | | |
UNION | reserved, requires AS | reserved | reserved | reserved |
UNIQUE | reserved | reserved | reserved | reserved |
UNKNOWN | non-reserved | reserved | reserved | reserved |
UNLINK | | non-reserved | non-reserved | |
UNLISTEN | non-reserved | | | |
UNLOGGED | non-reserved | | | |
UNMATCHED | | non-reserved | non-reserved | |
UNNAMED | | non-reserved | non-reserved | non-reserved |
UNNEST | | reserved | reserved | |
UNTIL | non-reserved | | | |
UNTYPED | | non-reserved | non-reserved | |
UPDATE | non-reserved | reserved | reserved | reserved |
UPPER | | reserved | reserved | reserved |
URI | | non-reserved | non-reserved | |
USAGE | | non-reserved | non-reserved | reserved |
USER | reserved | reserved | reserved | reserved |
USER_DEFINED_TYPE_CATALOG | | non-reserved | non-reserved | |
USER_DEFINED_TYPE_CODE | | non-reserved | non-reserved | |
USER_DEFINED_TYPE_NAME | | non-reserved | non-reserved | |
USER_DEFINED_TYPE_SCHEMA | | non-reserved | non-reserved | |
USING | reserved | reserved | reserved | reserved |
UTF16 | | non-reserved | non-reserved | |
UTF32 | | non-reserved | non-reserved | |
UTF8 | | non-reserved | non-reserved | |
VACUUM | non-reserved | | | |
VALID | non-reserved | non-reserved | non-reserved | |
VALIDATE | non-reserved | | | |
VALIDATOR | non-reserved | | | |
VALUE | non-reserved | reserved | reserved | reserved |
VALUES | non-reserved (cannot be function or type) | reserved | reserved | reserved |
VALUE_OF | | reserved | reserved | |
VARBINARY | | reserved | reserved | |
VARCHAR | non-reserved (cannot be function or type) | reserved | reserved | reserved |
VARIADIC | reserved | | | |
VARYING | non-reserved, requires AS | reserved | reserved | reserved |
VAR_POP | | reserved | reserved | |
VAR_SAMP | | reserved | reserved | |
VERBOSE | reserved (can be function or type) | | | |
VERSION | non-reserved | non-reserved | non-reserved | |
VERSIONING | | reserved | reserved | |
VIEW | non-reserved | non-reserved | non-reserved | reserved |
VIEWS | non-reserved | | | |
VOLATILE | non-reserved | | | |
WHEN | reserved | reserved | reserved | reserved |
WHENEVER | | reserved | reserved | reserved |
WHERE | reserved, requires AS | reserved | reserved | reserved |
WHITESPACE | non-reserved | non-reserved | non-reserved | |
WIDTH_BUCKET | | reserved | reserved | |
WINDOW | reserved, requires AS | reserved | reserved | |
WITH | reserved, requires AS | reserved | reserved | reserved |
WITHIN | non-reserved, requires AS | reserved | reserved | |
WITHOUT | non-reserved, requires AS | reserved | reserved | |
WORK | non-reserved | non-reserved | non-reserved | reserved |
WRAPPER | non-reserved | non-reserved | non-reserved | |
WRITE | non-reserved | non-reserved | non-reserved | reserved |
XML | non-reserved | reserved | reserved | |
XMLAGG | | reserved | reserved | |
XMLATTRIBUTES | non-reserved (cannot be function or type) | reserved | reserved | |
XMLBINARY | | reserved | reserved | |
XMLCAST | | reserved | reserved | |
XMLCOMMENT | | reserved | reserved | |
XMLCONCAT | non-reserved (cannot be function or type) | reserved | reserved | |
XMLDECLARATION | | non-reserved | non-reserved | |
XMLDOCUMENT | | reserved | reserved | |
XMLELEMENT | non-reserved (cannot be function or type) | reserved | reserved | |
XMLEXISTS | non-reserved (cannot be function or type) | reserved | reserved | |
XMLFOREST | non-reserved (cannot be function or type) | reserved | reserved | |
XMLITERATE | | reserved | reserved | |
XMLNAMESPACES | non-reserved (cannot be function or type) | reserved | reserved | |
XMLPARSE | non-reserved (cannot be function or type) | reserved | reserved | |
XMLPI | non-reserved (cannot be function or type) | reserved | reserved | |
XMLQUERY | | reserved | reserved | |
XMLROOT | non-reserved (cannot be function or type) | | | |
XMLSCHEMA | | non-reserved | non-reserved | |
XMLSERIALIZE | non-reserved (cannot be function or type) | reserved | reserved | |
XMLTABLE | non-reserved (cannot be function or type) | reserved | reserved | |
XMLTEXT | | reserved | reserved | |
XMLVALIDATE | | reserved | reserved | |
YEAR | non-reserved, requires AS | reserved | reserved | reserved |
YES | non-reserved | non-reserved | non-reserved | |
ZONE | non-reserved | non-reserved | non-reserved | reserved |
LISTEN
LISTEN — listen for a notification
Synopsis
+LISTEN channel
+
Description
+ LISTEN registers the current session as a
+ listener on the notification channel named channel.
+ If the current session is already registered as a listener for
+ this notification channel, nothing is done.
+
+ Whenever the command NOTIFY channel is invoked, either
+ by this session or another one connected to the same database, all
+ the sessions currently listening on that notification channel are
+ notified, and each will in turn notify its connected client
+ application.
+
+ A session can be unregistered for a given notification channel with the
+ UNLISTEN command. A session's listen
+ registrations are automatically cleared when the session ends.
+
+ The method a client application must use to detect notification events depends on
+ which PostgreSQL application programming interface it
+ uses. With the libpq library, the application issues
+ LISTEN as an ordinary SQL command, and then must
+ periodically call the function PQnotifies to find out
+ whether any notification events have been received. Other interfaces such as
+ libpgtcl provide higher-level methods for handling notify events; indeed,
+ with libpgtcl the application programmer should not even issue
+ LISTEN or UNLISTEN directly. See the
+ documentation for the interface you are using for more details.
+
Parameters
channel
+ Name of a notification channel (any identifier).
+
Notes
+ LISTEN takes effect at transaction commit.
+ If LISTEN or UNLISTEN is executed
+ within a transaction that later rolls back, the set of notification
+ channels being listened to is unchanged.
+
+ A transaction that has executed LISTEN cannot be
+ prepared for two-phase commit.
+
+ There is a race condition when first setting up a listening session:
+ if concurrently-committing transactions are sending notify events,
+ exactly which of those will the newly listening session receive?
+ The answer is that the session will receive all events committed after
+ an instant during the transaction's commit step. But that is slightly
+ later than any database state that the transaction could have observed
+ in queries. This leads to the following rule for
+ using LISTEN: first execute (and commit!) that
+ command, then in a new transaction inspect the database state as needed
+ by the application logic, then rely on notifications to find out about
+ subsequent changes to the database state. The first few received
+ notifications might refer to updates already observed in the initial
+ database inspection, but this is usually harmless.
+
+ NOTIFY
+ contains a more extensive
+ discussion of the use of LISTEN and
+ NOTIFY.
+
Examples
+ Configure and execute a listen/notify sequence from
+ psql:
+
+
+LISTEN virtual;
+NOTIFY virtual;
+Asynchronous notification "virtual" received from server process with PID 8448.
+
Compatibility
+ There is no LISTEN statement in the SQL
+ standard.
+
LOAD
LOAD — load a shared library file
Synopsis
+LOAD 'filename'
+
Description
+ This command loads a shared library file into the PostgreSQL
+ server's address space. If the file has been loaded already,
+ the command does nothing. Shared library files that contain C functions
+ are automatically loaded whenever one of their functions is called.
+ Therefore, an explicit LOAD is usually only needed to
+ load a library that modifies the server's behavior through “hooks”
+ rather than providing a set of functions.
+
+ The library file name is typically given as just a bare file name,
+ which is sought in the server's library search path (set
+ by dynamic_library_path). Alternatively it can be
+ given as a full path name. In either case the platform's standard shared
+ library file name extension may be omitted.
+ See Section 38.10.1 for more information on this topic.
+
+ Non-superusers can only apply LOAD to library files
+ located in $libdir/plugins/ — the specified
+ filename must begin
+ with exactly that string. (It is the database administrator's
+ responsibility to ensure that only “safe” libraries
+ are installed there.)
+
Compatibility
+ LOAD is a PostgreSQL
+ extension.
+
Synopsis
+LOCK [ TABLE ] [ ONLY ] name [ * ] [, ...] [ IN lockmode MODE ] [ NOWAIT ]
+
+where lockmode is one of:
+
+ ACCESS SHARE | ROW SHARE | ROW EXCLUSIVE | SHARE UPDATE EXCLUSIVE
+ | SHARE | SHARE ROW EXCLUSIVE | EXCLUSIVE | ACCESS EXCLUSIVE
+
Description
+ LOCK TABLE obtains a table-level lock, waiting
+ if necessary for any conflicting locks to be released. If
+ NOWAIT is specified, LOCK
+ TABLE does not wait to acquire the desired lock: if it
+ cannot be acquired immediately, the command is aborted and an
+ error is emitted. Once obtained, the lock is held for the
+ remainder of the current transaction. (There is no UNLOCK
+ TABLE command; locks are always released at transaction
+ end.)
+
+ When a view is locked, all relations appearing in the view definition
+ query are also locked recursively with the same lock mode.
+
+ When acquiring locks automatically for commands that reference
+ tables, PostgreSQL always uses the least
+ restrictive lock mode possible. LOCK TABLE
+ provides for cases when you might need more restrictive locking.
+ For example, suppose an application runs a transaction at the
+ READ COMMITTED isolation level and needs to ensure that
+ data in a table remains stable for the duration of the transaction.
+ To achieve this you could obtain SHARE lock mode over the
+ table before querying. This will prevent concurrent data changes
+ and ensure subsequent reads of the table see a stable view of
+ committed data, because SHARE lock mode conflicts with
+ the ROW EXCLUSIVE lock acquired by writers, and your
+ LOCK TABLE name IN SHARE MODE
+ statement will wait until any concurrent holders of ROW
+ EXCLUSIVE mode locks commit or roll back. Thus, once you
+ obtain the lock, there are no uncommitted writes outstanding;
+ furthermore none can begin until you release the lock.
+
+ To achieve a similar effect when running a transaction at the
+ REPEATABLE READ or SERIALIZABLE
+ isolation level, you have to execute the LOCK TABLE statement
+ before executing any SELECT or data modification statement.
+ A REPEATABLE READ or SERIALIZABLE transaction's
+ view of data will be frozen when its first
+ SELECT or data modification statement begins. A LOCK
+ TABLE later in the transaction will still prevent concurrent writes
+ — but it won't ensure that what the transaction reads corresponds to
+ the latest committed values.
+
+ If a transaction of this sort is going to change the data in the
+ table, then it should use SHARE ROW EXCLUSIVE lock mode
+ instead of SHARE mode. This ensures that only one
+ transaction of this type runs at a time. Without this, a deadlock
+ is possible: two transactions might both acquire SHARE
+ mode, and then be unable to also acquire ROW EXCLUSIVE
+ mode to actually perform their updates. (Note that a transaction's
+ own locks never conflict, so a transaction can acquire ROW
+ EXCLUSIVE mode when it holds SHARE mode — but not
+ if anyone else holds SHARE mode.) To avoid deadlocks,
+ make sure all transactions acquire locks on the same objects in the
+ same order, and if multiple lock modes are involved for a single
+ object, then transactions should always acquire the most
+ restrictive mode first.
+
+ More information about the lock modes and locking strategies can be
+ found in Section 13.3.
+
Parameters
name
+ The name (optionally schema-qualified) of an existing table to
+ lock. If ONLY is specified before the table name, only that
+ table is locked. If ONLY is not specified, the table and all
+ its descendant tables (if any) are locked. Optionally, *
+ can be specified after the table name to explicitly indicate that
+ descendant tables are included.
+
+ The command LOCK TABLE a, b; is equivalent to
+ LOCK TABLE a; LOCK TABLE b;. The tables are locked
+ one-by-one in the order specified in the LOCK
+ TABLE command.
+
lockmode
+ The lock mode specifies which locks this lock conflicts with.
+ Lock modes are described in Section 13.3.
+
+ If no lock mode is specified, then ACCESS
+ EXCLUSIVE, the most restrictive mode, is used.
+
NOWAIT
+ Specifies that LOCK TABLE should not wait for
+ any conflicting locks to be released: if the specified lock(s)
+ cannot be acquired immediately without waiting, the transaction
+ is aborted.
+
Notes
+ To lock a table, the user must have the right privilege for the specified
+ lockmode, or be the table's
+ owner or a superuser. If the user has
+ UPDATE, DELETE, or
+ TRUNCATE privileges on the table, any lockmode is permitted. If the user has
+ INSERT privileges on the table, ROW EXCLUSIVE
+ MODE (or a less-conflicting mode as described in Section 13.3) is permitted. If a user has
+ SELECT privileges on the table, ACCESS SHARE
+ MODE is permitted.
+
+ The user performing the lock on the view must have the corresponding
+ privilege on the view. In addition, by default, the view's owner must
+ have the relevant privileges on the underlying base relations, whereas the
+ user performing the lock does not need any permissions on the underlying
+ base relations. However, if the view has
+ security_invoker set to true
+ (see CREATE VIEW),
+ the user performing the lock, rather than the view owner, must have the
+ relevant privileges on the underlying base relations.
+
+ LOCK TABLE is useless outside a transaction block: the lock
+ would remain held only to the completion of the statement. Therefore
+ PostgreSQL reports an error if LOCK
+ is used outside a transaction block.
+ Use
+ BEGIN and
+ COMMIT
+ (or ROLLBACK)
+ to define a transaction block.
+
+ LOCK TABLE only deals with table-level locks, and so
+ the mode names involving ROW are all misnomers. These
+ mode names should generally be read as indicating the intention of
+ the user to acquire row-level locks within the locked table. Also,
+ ROW EXCLUSIVE mode is a shareable table lock. Keep in
+ mind that all the lock modes have identical semantics so far as
+ LOCK TABLE is concerned, differing only in the rules
+ about which modes conflict with which. For information on how to
+ acquire an actual row-level lock, see Section 13.3.2
+ and The Locking Clause
+ in the SELECT documentation.
+
Examples
+ Obtain a SHARE lock on a primary key table when going to perform
+ inserts into a foreign key table:
+
+
+BEGIN WORK;
+LOCK TABLE films IN SHARE MODE;
+SELECT id FROM films
+ WHERE name = 'Star Wars: Episode I - The Phantom Menace';
+-- Do ROLLBACK if record was not returned
+INSERT INTO films_user_comments VALUES
+ (_id_, 'GREAT! I was waiting for it for so long!');
+COMMIT WORK;
+
+
+ Take a SHARE ROW EXCLUSIVE lock on a primary key table when going to perform
+ a delete operation:
+
+
+BEGIN WORK;
+LOCK TABLE films IN SHARE ROW EXCLUSIVE MODE;
+DELETE FROM films_user_comments WHERE id IN
+ (SELECT id FROM films WHERE rating < 5);
+DELETE FROM films WHERE rating < 5;
+COMMIT WORK;
+
Compatibility
+ There is no LOCK TABLE in the SQL standard,
+ which instead uses SET TRANSACTION to specify
+ concurrency levels on transactions. PostgreSQL supports that too;
+ see SET TRANSACTION for details.
+
+ Except for ACCESS SHARE, ACCESS EXCLUSIVE,
+ and SHARE UPDATE EXCLUSIVE lock modes, the
+ PostgreSQL lock modes and the
+ LOCK TABLE syntax are compatible with those
+ present in Oracle.
+
MERGE
MERGE — conditionally insert, update, or delete rows of a table
Synopsis
+[ WITH with_query [, ...] ]
+MERGE INTO [ ONLY ] target_table_name [ * ] [ [ AS ] target_alias ]
+USING data_source ON join_condition
+when_clause [...]
+
+where data_source is:
+
+{ [ ONLY ] source_table_name [ * ] | ( source_query ) } [ [ AS ] source_alias ]
+
+and when_clause is:
+
+{ WHEN MATCHED [ AND condition ] THEN { merge_update | merge_delete | DO NOTHING } |
+ WHEN NOT MATCHED [ AND condition ] THEN { merge_insert | DO NOTHING } }
+
+and merge_insert is:
+
+INSERT [( column_name [, ...] )]
+[ OVERRIDING { SYSTEM | USER } VALUE ]
+{ VALUES ( { expression | DEFAULT } [, ...] ) | DEFAULT VALUES }
+
+and merge_update is:
+
+UPDATE SET { column_name = { expression | DEFAULT } |
+ ( column_name [, ...] ) = [ ROW ] ( { expression | DEFAULT } [, ...] ) |
+ ( column_name [, ...] ) = ( sub-SELECT )
+ } [, ...]
+
+and merge_delete is:
+
+DELETE
+
Description
+ MERGE performs actions that modify rows in the
+ target table identified as target_table_name,
+ using the data_source.
+ MERGE provides a single SQL
+ statement that can conditionally INSERT,
+ UPDATE or DELETE rows, a task
+ that would otherwise require multiple procedural language statements.
+
+ First, the MERGE command performs a join
+ from data_source to
+ the target table
+ producing zero or more candidate change rows. For each candidate change
+ row, the status of MATCHED or NOT MATCHED
+ is set just once, after which WHEN clauses are evaluated
+ in the order specified. For each candidate change row, the first clause to
+ evaluate as true is executed. No more than one WHEN
+ clause is executed for any candidate change row.
+
+ MERGE actions have the same effect as
+ regular UPDATE, INSERT, or
+ DELETE commands of the same names. The syntax of
+ those commands is different, notably that there is no WHERE
+ clause and no table name is specified. All actions refer to the
+ target table,
+ though modifications to other tables may be made using triggers.
+
+ When DO NOTHING is specified, the source row is
+ skipped. Since actions are evaluated in their specified order, DO
+ NOTHING can be handy to skip non-interesting source rows before
+ more fine-grained handling.
+
+ There is no separate MERGE privilege.
+ If you specify an update action, you must have the
+ UPDATE privilege on the column(s)
+ of the target table
+ that are referred to in the SET clause.
+ If you specify an insert action, you must have the INSERT
+ privilege on the target table.
+ If you specify a delete action, you must have the DELETE
+ privilege on the target table.
+ If you specify a DO NOTHING action, you must have
+ the SELECT privilege on at least one column
+ of the target table.
+ You will also need SELECT privilege on any column(s)
+ of the data_source and
+ of the target table referred to
+ in any condition (including join_condition)
+ or expression.
+ Privileges are tested once at statement start and are checked
+ whether or not particular WHEN clauses are executed.
+
+ MERGE is not supported if the
+ target table is a
+ materialized view, foreign table, or if it has any
+ rules defined on it.
+
Parameters
with_query
+ The WITH clause allows you to specify one or more
+ subqueries that can be referenced by name in the MERGE
+ query. See Section 7.8 and SELECT
+ for details. Note that WITH RECURSIVE is not supported
+ by MERGE.
+
target_table_name
+ The name (optionally schema-qualified) of the target table to merge into.
+ If ONLY is specified before the table name, matching
+ rows are updated or deleted in the named table only. If
+ ONLY is not specified, matching rows are also updated
+ or deleted in any tables inheriting from the named table. Optionally,
+ * can be specified after the table name to explicitly
+ indicate that descendant tables are included. The
+ ONLY keyword and * option do not
+ affect insert actions, which always insert into the named table only.
+
target_alias
+ A substitute name for the target table. When an alias is
+ provided, it completely hides the actual name of the table. For
+ example, given MERGE INTO foo AS f, the remainder of the
+ MERGE statement must refer to this table as
+ f not foo.
+
source_table_name
+ The name (optionally schema-qualified) of the source table, view, or
+ transition table. If ONLY is specified before the
+ table name, matching rows are included from the named table only. If
+ ONLY is not specified, matching rows are also included
+ from any tables inheriting from the named table. Optionally,
+ * can be specified after the table name to explicitly
+ indicate that descendant tables are included.
+
source_query
+ A query (SELECT statement or VALUES
+ statement) that supplies the rows to be merged into the
+ target table.
+ Refer to the SELECT
+ statement or VALUES
+ statement for a description of the syntax.
+
source_alias
+ A substitute name for the data source. When an alias is
+ provided, it completely hides the actual name of the table or the fact
+ that a query was issued.
+
join_condition
+ join_condition is
+ an expression resulting in a value of type
+ boolean (similar to a WHERE
+ clause) that specifies which rows in the
+ data_source
+ match rows in the target table.
+
Warning
+ Only columns from the target table
+ that attempt to match data_source
+ rows should appear in join_condition.
+ join_condition subexpressions that
+ only reference the target table's
+ columns can affect which action is taken, often in surprising ways.
+
when_clause
+ At least one WHEN clause is required.
+
+ If the WHEN clause specifies WHEN MATCHED
+ and the candidate change row matches a row in the
+ target table,
+ the WHEN clause is executed if the
+ condition is
+ absent or it evaluates to true.
+
+ Conversely, if the WHEN clause specifies
+ WHEN NOT MATCHED
+ and the candidate change row does not match a row in the
+ target table,
+ the WHEN clause is executed if the
+ condition is
+ absent or it evaluates to true.
+
condition
+ An expression that returns a value of type boolean.
+ If this expression for a WHEN clause
+ returns true, then the action for that clause
+ is executed for that row.
+
+ A condition on a WHEN MATCHED clause can refer to columns
+ in both the source and the target relations. A condition on a
+ WHEN NOT MATCHED clause can only refer to columns from
+ the source relation, since by definition there is no matching target row.
+ Only the system attributes from the target table are accessible.
+
merge_insert
+ The specification of an INSERT action that inserts
+ one row into the target table.
+ The target column names can be listed in any order. If no list of
+ column names is given at all, the default is all the columns of the
+ table in their declared order.
+
+ Each column not present in the explicit or implicit column list will be
+ filled with a default value, either its declared default value
+ or null if there is none.
+
+ If the target table
+ is a partitioned table, each row is routed to the appropriate partition
+ and inserted into it.
+ If the target table
+ is a partition, an error will occur if any input row violates the
+ partition constraint.
+
+ Column names may not be specified more than once.
+ INSERT actions cannot contain sub-selects.
+
+ Only one VALUES clause can be specified.
+ The VALUES clause can only refer to columns from
+ the source relation, since by definition there is no matching target row.
+
merge_update
+ The specification of an UPDATE action that updates
+ the current row of the target table.
+ Column names may not be specified more than once.
+
+ Neither a table name nor a WHERE clause are allowed.
+
merge_delete
+ Specifies a DELETE action that deletes the current row
+ of the target table.
+ Do not include the table name or any other clauses, as you would normally
+ do with a DELETE command.
+
column_name
+ The name of a column in the target table. The column name
+ can be qualified with a subfield name or array subscript, if
+ needed. (Inserting into only some fields of a composite
+ column leaves the other fields null.)
+ Do not include the table's name in the specification
+ of a target column.
+
OVERRIDING SYSTEM VALUE
+ Without this clause, it is an error to specify an explicit value
+ (other than DEFAULT) for an identity column defined
+ as GENERATED ALWAYS. This clause overrides that
+ restriction.
+
OVERRIDING USER VALUE
+ If this clause is specified, then any values supplied for identity
+ columns defined as GENERATED BY DEFAULT are ignored
+ and the default sequence-generated values are applied.
+
DEFAULT VALUES
+ All columns will be filled with their default values.
+ (An OVERRIDING clause is not permitted in this
+ form.)
+
expression
+ An expression to assign to the column. If used in a
+ WHEN MATCHED clause, the expression can use values
+ from the original row in the target table, and values from the
+ data_source row.
+ If used in a WHEN NOT MATCHED clause, the
+ expression can use values from the
+ data_source row.
+
DEFAULT
+ Set the column to its default value (which will be NULL
+ if no specific default expression has been assigned to it).
+
sub-SELECT
+ A SELECT sub-query that produces as many output columns
+ as are listed in the parenthesized column list preceding it. The
+ sub-query must yield no more than one row when executed. If it
+ yields one row, its column values are assigned to the target columns;
+ if it yields no rows, NULL values are assigned to the target columns.
+ The sub-query can refer to values from the original row in the target table,
+ and values from the data_source
+ row.
+
Outputs
+ On successful completion, a MERGE command returns a command
+ tag of the form
+
+MERGE total_count
+
+ The total_count is the total
+ number of rows changed (whether inserted, updated, or deleted).
+ If total_count is 0, no rows
+ were changed in any way.
+
Notes
+ The following steps take place during the execution of
+ MERGE.
+
+ Perform any BEFORE STATEMENT triggers for all
+ actions specified, whether or not their WHEN
+ clauses match.
+
+ Perform a join from source to target table.
+ The resulting query will be optimized normally and will produce
+ a set of candidate change rows. For each candidate change row,
+
+ Evaluate whether each row is MATCHED or
+ NOT MATCHED.
+
+ Test each WHEN condition in the order
+ specified until one returns true.
+
+ When a condition returns true, perform the following actions:
+
+ Perform any BEFORE ROW triggers that fire
+ for the action's event type.
+
+ Perform the specified action, invoking any check constraints on the
+ target table.
+
+ Perform any AFTER ROW triggers that fire for
+ the action's event type.
+
+ Perform any AFTER STATEMENT triggers for actions
+ specified, whether or not they actually occur. This is similar to the
+ behavior of an UPDATE statement that modifies no rows.
+
+ In summary, statement triggers for an event type (say,
+ INSERT) will be fired whenever we
+ specify an action of that kind.
+ In contrast, row-level triggers will fire only for the specific event type
+ being executed.
+ So a MERGE command might fire statement triggers for both
+ UPDATE and INSERT, even though only
+ UPDATE row triggers were fired.
+
+ You should ensure that the join produces at most one candidate change row
+ for each target row. In other words, a target row shouldn't join to more
+ than one data source row. If it does, then only one of the candidate change
+ rows will be used to modify the target row; later attempts to modify the
+ row will cause an error.
+ This can also occur if row triggers make changes to the target table
+ and the rows so modified are then subsequently also modified by
+ MERGE.
+ If the repeated action is an INSERT, this will
+ cause a uniqueness violation, while a repeated UPDATE
+ or DELETE will cause a cardinality violation; the
+ latter behavior is required by the SQL standard.
+ This differs from historical PostgreSQL
+ behavior of joins in UPDATE and
+ DELETE statements where second and subsequent
+ attempts to modify the same row are simply ignored.
+
+ If a WHEN clause omits an AND
+ sub-clause, it becomes the final reachable clause of that
+ kind (MATCHED or NOT MATCHED).
+ If a later WHEN clause of that kind
+ is specified it would be provably unreachable and an error is raised.
+ If no final reachable clause is specified of either kind, it is
+ possible that no action will be taken for a candidate change row.
+
+ The order in which rows are generated from the data source is
+ indeterminate by default.
+ A source_query can be
+ used to specify a consistent ordering, if required, which might be
+ needed to avoid deadlocks between concurrent transactions.
+
+ There is no RETURNING clause with
+ MERGE. Actions of INSERT,
+ UPDATE and DELETE cannot contain
+ RETURNING or WITH clauses.
+
+ When MERGE is run concurrently with other commands
+ that modify the target table, the usual transaction isolation rules
+ apply; see Section 13.2 for an explanation
+ on the behavior at each isolation level.
+ You may also wish to consider using INSERT ... ON CONFLICT
+ as an alternative statement which offers the ability to run an
+ UPDATE if a concurrent INSERT
+ occurs. There are a variety of differences and restrictions between
+ the two statement types and they are not interchangeable.
+
Examples
+ Perform maintenance on customer_accounts based
+ upon new recent_transactions.
+
+
+MERGE INTO customer_account ca
+USING recent_transactions t
+ON t.customer_id = ca.customer_id
+WHEN MATCHED THEN
+ UPDATE SET balance = balance + transaction_value
+WHEN NOT MATCHED THEN
+ INSERT (customer_id, balance)
+ VALUES (t.customer_id, t.transaction_value);
+
+
+ Notice that this would be exactly equivalent to the following
+ statement because the MATCHED result does not change
+ during execution.
+
+
+MERGE INTO customer_account ca
+USING (SELECT customer_id, transaction_value FROM recent_transactions) AS t
+ON t.customer_id = ca.customer_id
+WHEN MATCHED THEN
+ UPDATE SET balance = balance + transaction_value
+WHEN NOT MATCHED THEN
+ INSERT (customer_id, balance)
+ VALUES (t.customer_id, t.transaction_value);
+
+
+ Attempt to insert a new stock item along with the quantity of stock. If
+ the item already exists, instead update the stock count of the existing
+ item. Don't allow entries that have zero stock.
+
+MERGE INTO wines w
+USING wine_stock_changes s
+ON s.winename = w.winename
+WHEN NOT MATCHED AND s.stock_delta > 0 THEN
+ INSERT VALUES(s.winename, s.stock_delta)
+WHEN MATCHED AND w.stock + s.stock_delta > 0 THEN
+ UPDATE SET stock = w.stock + s.stock_delta
+WHEN MATCHED THEN
+ DELETE;
+
+
+ The wine_stock_changes table might be, for example, a
+ temporary table recently loaded into the database.
+
Compatibility
+ This command conforms to the SQL standard.
+
+ The WITH clause and DO NOTHING
+ action are extensions to the SQL standard.
+
MOVE
MOVE — position a cursor
Synopsis
+MOVE [ direction ] [ FROM | IN ] cursor_name
+
+where direction can be one of:
+
+ NEXT
+ PRIOR
+ FIRST
+ LAST
+ ABSOLUTE count
+ RELATIVE count
+ count
+ ALL
+ FORWARD
+ FORWARD count
+ FORWARD ALL
+ BACKWARD
+ BACKWARD count
+ BACKWARD ALL
+
Description
+ MOVE repositions a cursor without retrieving any data.
+ MOVE works exactly like the FETCH
+ command, except it only positions the cursor and does not return rows.
+
+ The parameters for the MOVE command are identical to
+ those of the FETCH command; refer to
+ FETCH
+ for details on syntax and usage.
+
Outputs
+ On successful completion, a MOVE command returns a command
+ tag of the form
+
+MOVE count
+
+ The count is the number
+ of rows that a FETCH command with the same parameters
+ would have returned (possibly zero).
+
Examples
+BEGIN WORK;
+DECLARE liahona CURSOR FOR SELECT * FROM films;
+
+-- Skip the first 5 rows:
+MOVE FORWARD 5 IN liahona;
+MOVE 5
+
+-- Fetch the 6th row from the cursor liahona:
+FETCH 1 FROM liahona;
+ code | title | did | date_prod | kind | len
+-------+--------+-----+------------+--------+-------
+ P_303 | 48 Hrs | 103 | 1982-10-22 | Action | 01:37
+(1 row)
+
+-- Close the cursor liahona and end the transaction:
+CLOSE liahona;
+COMMIT WORK;
+
Compatibility
+ There is no MOVE statement in the SQL standard.
+
NOTIFY
NOTIFY — generate a notification
Synopsis
+NOTIFY channel [ , payload ]
+
Description
+ The NOTIFY command sends a notification event together
+ with an optional “payload” string to each client application that
+ has previously executed
+ LISTEN channel
+ for the specified channel name in the current database.
+ Notifications are visible to all users.
+
+ NOTIFY provides a simple
+ interprocess communication mechanism for a collection of processes
+ accessing the same PostgreSQL database.
+ A payload string can be sent along with the notification, and
+ higher-level mechanisms for passing structured data can be built by using
+ tables in the database to pass additional data from notifier to listener(s).
+
+ The information passed to the client for a notification event includes the
+ notification channel
+ name, the notifying session's server process PID, and the
+ payload string, which is an empty string if it has not been specified.
+
+ It is up to the database designer to define the channel names that will
+ be used in a given database and what each one means.
+ Commonly, the channel name is the same as the name of some table in
+ the database, and the notify event essentially means, “I changed this table,
+ take a look at it to see what's new”. But no such association is enforced by
+ the NOTIFY and LISTEN commands. For
+ example, a database designer could use several different channel names
+ to signal different sorts of changes to a single table. Alternatively,
+ the payload string could be used to differentiate various cases.
+
+ When NOTIFY is used to signal the occurrence of changes
+ to a particular table, a useful programming technique is to put the
+ NOTIFY in a statement trigger that is triggered by table updates.
+ In this way, notification happens automatically when the table is changed,
+ and the application programmer cannot accidentally forget to do it.
+
+ NOTIFY interacts with SQL transactions in some important
+ ways. Firstly, if a NOTIFY is executed inside a
+ transaction, the notify events are not delivered until and unless the
+ transaction is committed. This is appropriate, since if the transaction
+ is aborted, all the commands within it have had no
+ effect, including NOTIFY. But it can be disconcerting if one
+ is expecting the notification events to be delivered immediately. Secondly, if
+ a listening session receives a notification signal while it is within a transaction,
+ the notification event will not be delivered to its connected client until just
+ after the transaction is completed (either committed or aborted). Again, the
+ reasoning is that if a notification were delivered within a transaction that was
+ later aborted, one would want the notification to be undone somehow —
+ but
+ the server cannot “take back” a notification once it has sent it to the client.
+ So notification events are only delivered between transactions. The upshot of this
+ is that applications using NOTIFY for real-time signaling
+ should try to keep their transactions short.
+
+ If the same channel name is signaled multiple times with identical
+ payload strings within the same transaction, only one instance of the
+ notification event is delivered to listeners.
+ On the other hand, notifications with distinct payload strings will
+ always be delivered as distinct notifications. Similarly, notifications from
+ different transactions will never get folded into one notification.
+ Except for dropping later instances of duplicate notifications,
+ NOTIFY guarantees that notifications from the same
+ transaction get delivered in the order they were sent. It is also
+ guaranteed that messages from different transactions are delivered in
+ the order in which the transactions committed.
+
+ It is common for a client that executes NOTIFY
+ to be listening on the same notification channel itself. In that case
+ it will get back a notification event, just like all the other
+ listening sessions. Depending on the application logic, this could
+ result in useless work, for example, reading a database table to
+ find the same updates that that session just wrote out. It is
+ possible to avoid such extra work by noticing whether the notifying
+ session's server process PID (supplied in the
+ notification event message) is the same as one's own session's
+ PID (available from libpq). When they
+ are the same, the notification event is one's own work bouncing
+ back, and can be ignored.
+
Parameters
channel
+ Name of the notification channel to be signaled (any identifier).
+
payload
+ The “payload” string to be communicated along with the
+ notification. This must be specified as a simple string literal.
+ In the default configuration it must be shorter than 8000 bytes.
+ (If binary data or large amounts of information need to be communicated,
+ it's best to put it in a database table and send the key of the record.)
+
Notes
+ There is a queue that holds notifications that have been sent but not
+ yet processed by all listening sessions. If this queue becomes full,
+ transactions calling NOTIFY will fail at commit.
+ The queue is quite large (8GB in a standard installation) and should be
+ sufficiently sized for almost every use case. However, no cleanup can take
+ place if a session executes LISTEN and then enters a
+ transaction for a very long time. Once the queue is half full you will see
+ warnings in the log file pointing you to the session that is preventing
+ cleanup. In this case you should make sure that this session ends its
+ current transaction so that cleanup can proceed.
+
+ The function pg_notification_queue_usage returns the
+ fraction of the queue that is currently occupied by pending notifications.
+ See Section 9.26 for more information.
+
+ A transaction that has executed NOTIFY cannot be
+ prepared for two-phase commit.
+
pg_notify
+ To send a notification you can also use the function
+ pg_notify(text,
+ text)NOTIFY command if you need to work with
+ non-constant channel names and payloads.
+
Examples
+ Configure and execute a listen/notify sequence from
+ psql:
+
+
+LISTEN virtual;
+NOTIFY virtual;
+Asynchronous notification "virtual" received from server process with PID 8448.
+NOTIFY virtual, 'This is the payload';
+Asynchronous notification "virtual" with payload "This is the payload" received from server process with PID 8448.
+
+LISTEN foo;
+SELECT pg_notify('fo' || 'o', 'pay' || 'load');
+Asynchronous notification "foo" with payload "payload" received from server process with PID 14728.
+Compatibility
+ There is no NOTIFY statement in the SQL
+ standard.
+
PREPARE TRANSACTION
PREPARE TRANSACTION — prepare the current transaction for two-phase commit
Synopsis
+PREPARE TRANSACTION transaction_id
+
Description
+ PREPARE TRANSACTION prepares the current transaction
+ for two-phase commit. After this command, the transaction is no longer
+ associated with the current session; instead, its state is fully stored on
+ disk, and there is a very high probability that it can be committed
+ successfully, even if a database crash occurs before the commit is
+ requested.
+
+ Once prepared, a transaction can later be committed or rolled back
+ with COMMIT PREPARED
+ or ROLLBACK PREPARED,
+ respectively. Those commands can be issued from any session, not
+ only the one that executed the original transaction.
+
+ From the point of view of the issuing session, PREPARE
+ TRANSACTION is not unlike a ROLLBACK command:
+ after executing it, there is no active current transaction, and the
+ effects of the prepared transaction are no longer visible. (The effects
+ will become visible again if the transaction is committed.)
+
+ If the PREPARE TRANSACTION command fails for any
+ reason, it becomes a ROLLBACK: the current transaction
+ is canceled.
+
Parameters
transaction_id
+ An arbitrary identifier that later identifies this transaction for
+ COMMIT PREPARED or ROLLBACK PREPARED.
+ The identifier must be written as a string literal, and must be
+ less than 200 bytes long. It must not be the same as the identifier
+ used for any currently prepared transaction.
+
Notes
+ PREPARE TRANSACTION is not intended for use in applications
+ or interactive sessions. Its purpose is to allow an external
+ transaction manager to perform atomic global transactions across multiple
+ databases or other transactional resources. Unless you're writing a
+ transaction manager, you probably shouldn't be using PREPARE
+ TRANSACTION.
+
+ This command must be used inside a transaction block. Use BEGIN to start one.
+
+ It is not currently allowed to PREPARE a transaction that
+ has executed any operations involving temporary tables or the session's
+ temporary namespace, created any cursors WITH HOLD, or
+ executed LISTEN, UNLISTEN, or
+ NOTIFY.
+ Those features are too tightly
+ tied to the current session to be useful in a transaction to be prepared.
+
+ If the transaction modified any run-time parameters with SET
+ (without the LOCAL option),
+ those effects persist after PREPARE TRANSACTION, and will not
+ be affected by any later COMMIT PREPARED or
+ ROLLBACK PREPARED. Thus, in this one respect
+ PREPARE TRANSACTION acts more like COMMIT than
+ ROLLBACK.
+
+ All currently available prepared transactions are listed in the
+ pg_prepared_xacts
+ system view.
+
Caution
+ It is unwise to leave transactions in the prepared state for a long time.
+ This will interfere with the ability of VACUUM to reclaim
+ storage, and in extreme cases could cause the database to shut down
+ to prevent transaction ID wraparound (see Section 25.1.5). Keep in mind also that the transaction
+ continues to hold whatever locks it held. The intended usage of the
+ feature is that a prepared transaction will normally be committed or
+ rolled back as soon as an external transaction manager has verified that
+ other databases are also prepared to commit.
+
+ If you have not set up an external transaction manager to track prepared
+ transactions and ensure they get closed out promptly, it is best to keep
+ the prepared-transaction feature disabled by setting
+ max_prepared_transactions to zero. This will
+ prevent accidental creation of prepared transactions that might then
+ be forgotten and eventually cause problems.
+
Examples
+ Prepare the current transaction for two-phase commit, using
+ foobar as the transaction identifier:
+
+
+PREPARE TRANSACTION 'foobar';
+
Compatibility
+ PREPARE TRANSACTION is a
+ PostgreSQL extension. It is intended for use by
+ external transaction management systems, some of which are covered by
+ standards (such as X/Open XA), but the SQL side of those systems is not
+ standardized.
+
PREPARE
PREPARE — prepare a statement for execution
Synopsis
+PREPARE name [ ( data_type [, ...] ) ] AS statement
+
Description
+ PREPARE creates a prepared statement. A prepared
+ statement is a server-side object that can be used to optimize
+ performance. When the PREPARE statement is
+ executed, the specified statement is parsed, analyzed, and rewritten.
+ When an EXECUTE command is subsequently
+ issued, the prepared statement is planned and executed. This division
+ of labor avoids repetitive parse analysis work, while allowing
+ the execution plan to depend on the specific parameter values supplied.
+
+ Prepared statements can take parameters: values that are
+ substituted into the statement when it is executed. When creating
+ the prepared statement, refer to parameters by position, using
+ $1, $2, etc. A corresponding list of
+ parameter data types can optionally be specified. When a
+ parameter's data type is not specified or is declared as
+ unknown, the type is inferred from the context
+ in which the parameter is first referenced (if possible). When executing the
+ statement, specify the actual values for these parameters in the
+ EXECUTE statement. Refer to EXECUTE for more
+ information about that.
+
+ Prepared statements only last for the duration of the current
+ database session. When the session ends, the prepared statement is
+ forgotten, so it must be recreated before being used again. This
+ also means that a single prepared statement cannot be used by
+ multiple simultaneous database clients; however, each client can create
+ their own prepared statement to use. Prepared statements can be
+ manually cleaned up using the DEALLOCATE command.
+
+ Prepared statements potentially have the largest performance advantage
+ when a single session is being used to execute a large number of similar
+ statements. The performance difference will be particularly
+ significant if the statements are complex to plan or rewrite, e.g.,
+ if the query involves a join of many tables or requires
+ the application of several rules. If the statement is relatively simple
+ to plan and rewrite but relatively expensive to execute, the
+ performance advantage of prepared statements will be less noticeable.
+
Parameters
name
+ An arbitrary name given to this particular prepared
+ statement. It must be unique within a single session and is
+ subsequently used to execute or deallocate a previously prepared
+ statement.
+
data_type
+ The data type of a parameter to the prepared statement. If the
+ data type of a particular parameter is unspecified or is
+ specified as unknown, it will be inferred
+ from the context in which the parameter is first referenced. To refer to the
+ parameters in the prepared statement itself, use
+ $1, $2, etc.
+
statement
+ Any SELECT, INSERT, UPDATE,
+ DELETE, MERGE, or VALUES
+ statement.
+
Notes
+ A prepared statement can be executed with either a generic
+ plan or a custom plan. A generic
+ plan is the same across all executions, while a custom plan is generated
+ for a specific execution using the parameter values given in that call.
+ Use of a generic plan avoids planning overhead, but in some situations
+ a custom plan will be much more efficient to execute because the planner
+ can make use of knowledge of the parameter values. (Of course, if the
+ prepared statement has no parameters, then this is moot and a generic
+ plan is always used.)
+
+ By default (that is, when plan_cache_mode is set
+ to auto), the server will automatically choose
+ whether to use a generic or custom plan for a prepared statement that
+ has parameters. The current rule for this is that the first five
+ executions are done with custom plans and the average estimated cost of
+ those plans is calculated. Then a generic plan is created and its
+ estimated cost is compared to the average custom-plan cost. Subsequent
+ executions use the generic plan if its cost is not so much higher than
+ the average custom-plan cost as to make repeated replanning seem
+ preferable.
+
+ This heuristic can be overridden, forcing the server to use either
+ generic or custom plans, by setting plan_cache_mode
+ to force_generic_plan
+ or force_custom_plan respectively.
+ This setting is primarily useful if the generic plan's cost estimate
+ is badly off for some reason, allowing it to be chosen even though
+ its actual cost is much more than that of a custom plan.
+
+ To examine the query plan PostgreSQL is using
+ for a prepared statement, use EXPLAIN, for example
+
+EXPLAIN EXECUTE name(parameter_values);
+
+ If a generic plan is in use, it will contain parameter symbols
+ $n, while a custom plan
+ will have the supplied parameter values substituted into it.
+
+ For more information on query planning and the statistics collected
+ by PostgreSQL for that purpose, see
+ the ANALYZE
+ documentation.
+
+ Although the main point of a prepared statement is to avoid repeated parse
+ analysis and planning of the statement, PostgreSQL will
+ force re-analysis and re-planning of the statement before using it
+ whenever database objects used in the statement have undergone
+ definitional (DDL) changes or their planner statistics have
+ been updated since the previous use of the prepared
+ statement. Also, if the value of search_path changes
+ from one use to the next, the statement will be re-parsed using the new
+ search_path. (This latter behavior is new as of
+ PostgreSQL 9.3.) These rules make use of a
+ prepared statement semantically almost equivalent to re-submitting the
+ same query text over and over, but with a performance benefit if no object
+ definitions are changed, especially if the best plan remains the same
+ across uses. An example of a case where the semantic equivalence is not
+ perfect is that if the statement refers to a table by an unqualified name,
+ and then a new table of the same name is created in a schema appearing
+ earlier in the search_path, no automatic re-parse will occur
+ since no object used in the statement changed. However, if some other
+ change forces a re-parse, the new table will be referenced in subsequent
+ uses.
+
+ You can see all prepared statements available in the session by querying the
+ pg_prepared_statements
+ system view.
+
Examples
+ Create a prepared statement for an INSERT
+ statement, and then execute it:
+
+PREPARE fooplan (int, text, bool, numeric) AS
+ INSERT INTO foo VALUES($1, $2, $3, $4);
+EXECUTE fooplan(1, 'Hunter Valley', 't', 200.00);
+
+
+ Create a prepared statement for a SELECT
+ statement, and then execute it:
+
+PREPARE usrrptplan (int) AS
+ SELECT * FROM users u, logs l WHERE u.usrid=$1 AND u.usrid=l.usrid
+ AND l.date = $2;
+EXECUTE usrrptplan(1, current_date);
+
+
+ In this example, the data type of the second parameter is not specified,
+ so it is inferred from the context in which $2 is used.
+
Compatibility
+ The SQL standard includes a PREPARE statement,
+ but it is only for use in embedded SQL. This version of the
+ PREPARE statement also uses a somewhat different
+ syntax.
+
REASSIGN OWNED
REASSIGN OWNED — change the ownership of database objects owned by a database role
Synopsis
+REASSIGN OWNED BY { old_role | CURRENT_ROLE | CURRENT_USER | SESSION_USER } [, ...]
+ TO { new_role | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+Description
+ REASSIGN OWNED instructs the system to change
+ the ownership of database objects owned by any of the
+ old_roles to
+ new_role.
+
Parameters
old_role
+ The name of a role. The ownership of all the objects within the
+ current database, and of all shared objects (databases, tablespaces),
+ owned by this role will be reassigned to
+ new_role.
+
new_role
+ The name of the role that will be made the new owner of the
+ affected objects.
+
Notes
+ REASSIGN OWNED is often used to prepare for the
+ removal of one or more roles. Because REASSIGN
+ OWNED does not affect objects within other databases,
+ it is usually necessary to execute this command in each database
+ that contains objects owned by a role that is to be removed.
+
+ REASSIGN OWNED requires membership on both the
+ source role(s) and the target role.
+
+ The DROP OWNED command is an alternative that
+ simply drops all the database objects owned by one or more roles.
+
+ The REASSIGN OWNED command does not affect any
+ privileges granted to
+ the old_roles on objects
+ that are not owned by them. Likewise, it does not affect default
+ privileges created with ALTER DEFAULT PRIVILEGES.
+ Use DROP OWNED to revoke such privileges.
+
+ See Section 22.4 for more discussion.
+
Compatibility
+ The REASSIGN OWNED command is a
+ PostgreSQL extension.
+
REFRESH MATERIALIZED VIEW
REFRESH MATERIALIZED VIEW — replace the contents of a materialized view
Synopsis
+REFRESH MATERIALIZED VIEW [ CONCURRENTLY ] name
+ [ WITH [ NO ] DATA ]
+
Description
+ REFRESH MATERIALIZED VIEW completely replaces the
+ contents of a materialized view. To execute this command you must be the
+ owner of the materialized view. The old contents are discarded. If
+ WITH DATA is specified (or defaults) the backing query
+ is executed to provide the new data, and the materialized view is left in a
+ scannable state. If WITH NO DATA is specified no new
+ data is generated and the materialized view is left in an unscannable
+ state.
+
+ CONCURRENTLY and WITH NO DATA may not
+ be specified together.
+
Parameters
CONCURRENTLY
+ Refresh the materialized view without locking out concurrent selects on
+ the materialized view. Without this option a refresh which affects a
+ lot of rows will tend to use fewer resources and complete more quickly,
+ but could block other connections which are trying to read from the
+ materialized view. This option may be faster in cases where a small
+ number of rows are affected.
+
+ This option is only allowed if there is at least one
+ UNIQUE index on the materialized view which uses only
+ column names and includes all rows; that is, it must not be an
+ expression index or include a WHERE clause.
+
+ This option may not be used when the materialized view is not already
+ populated.
+
+ Even with this option only one REFRESH at a time may
+ run against any one materialized view.
+
name
+ The name (optionally schema-qualified) of the materialized view to
+ refresh.
+
Notes
+ If there is an ORDER BY clause in the materialized
+ view's defining query, the original contents of the materialized view
+ will be ordered that way; but REFRESH MATERIALIZED
+ VIEW does not guarantee to preserve that ordering.
+
Examples
+ This command will replace the contents of the materialized view called
+ order_summary using the query from the materialized
+ view's definition, and leave it in a scannable state:
+
+REFRESH MATERIALIZED VIEW order_summary;
+
+
+ This command will free storage associated with the materialized view
+ annual_statistics_basis and leave it in an unscannable
+ state:
+
+REFRESH MATERIALIZED VIEW annual_statistics_basis WITH NO DATA;
+
Compatibility
+ REFRESH MATERIALIZED VIEW is a
+ PostgreSQL extension.
+
REINDEX
REINDEX — rebuild indexes
Synopsis
+REINDEX [ ( option [, ...] ) ] { INDEX | TABLE | SCHEMA } [ CONCURRENTLY ] name
+REINDEX [ ( option [, ...] ) ] { DATABASE | SYSTEM } [ CONCURRENTLY ] [ name ]
+
+where option can be one of:
+
+ CONCURRENTLY [ boolean ]
+ TABLESPACE new_tablespace
+ VERBOSE [ boolean ]
+
Description
+ REINDEX rebuilds an index using the data
+ stored in the index's table, replacing the old copy of the index. There are
+ several scenarios in which to use REINDEX:
+
+
+ An index has become corrupted, and no longer contains valid
+ data. Although in theory this should never happen, in
+ practice indexes can become corrupted due to software bugs or
+ hardware failures. REINDEX provides a
+ recovery method.
+
+ An index has become “bloated”, that is it contains many
+ empty or nearly-empty pages. This can occur with B-tree indexes in
+ PostgreSQL under certain uncommon access
+ patterns. REINDEX provides a way to reduce
+ the space consumption of the index by writing a new version of
+ the index without the dead pages. See Section 25.2 for more information.
+
+ You have altered a storage parameter (such as fillfactor)
+ for an index, and wish to ensure that the change has taken full effect.
+
+ If an index build fails with the CONCURRENTLY option,
+ this index is left as “invalid”. Such indexes are useless
+ but it can be convenient to use REINDEX to rebuild
+ them. Note that only REINDEX INDEX is able
+ to perform a concurrent build on an invalid index.
+
Parameters
INDEX
+ Recreate the specified index. This form of REINDEX
+ cannot be executed inside a transaction block when used with a
+ partitioned index.
+
TABLE
+ Recreate all indexes of the specified table. If the table has a
+ secondary “TOAST” table, that is reindexed as well.
+ This form of REINDEX cannot be executed inside a
+ transaction block when used with a partitioned table.
+
SCHEMA
+ Recreate all indexes of the specified schema. If a table of this
+ schema has a secondary “TOAST” table, that is reindexed as
+ well. Indexes on shared system catalogs are also processed.
+ This form of REINDEX cannot be executed inside a
+ transaction block.
+
DATABASE
+ Recreate all indexes within the current database, except system
+ catalogs.
+ Indexes on system catalogs are not processed.
+ This form of REINDEX cannot be executed inside a
+ transaction block.
+
SYSTEM
+ Recreate all indexes on system catalogs within the current database.
+ Indexes on shared system catalogs are included.
+ Indexes on user tables are not processed.
+ This form of REINDEX cannot be executed inside a
+ transaction block.
+
name
+ The name of the specific index, table, or database to be
+ reindexed. Index and table names can be schema-qualified.
+ Presently, REINDEX DATABASE and REINDEX SYSTEM
+ can only reindex the current database. Their parameter is optional,
+ and it must match the current database's name.
+
CONCURRENTLY
+ When this option is used, PostgreSQL will rebuild the
+ index without taking any locks that prevent concurrent inserts,
+ updates, or deletes on the table; whereas a standard index rebuild
+ locks out writes (but not reads) on the table until it's done.
+ There are several caveats to be aware of when using this option
+ — see Rebuilding Indexes Concurrently below.
+
+ For temporary tables, REINDEX is always
+ non-concurrent, as no other session can access them, and
+ non-concurrent reindex is cheaper.
+
TABLESPACE
+ Specifies that indexes will be rebuilt on a new tablespace.
+
VERBOSE
+ Prints a progress report as each index is reindexed.
+
boolean
+ Specifies whether the selected option should be turned on or off.
+ You can write TRUE, ON, or
+ 1 to enable the option, and FALSE,
+ OFF, or 0 to disable it. The
+ boolean value can also
+ be omitted, in which case TRUE is assumed.
+
new_tablespace
+ The tablespace where indexes will be rebuilt.
+
Notes
+ If you suspect corruption of an index on a user table, you can
+ simply rebuild that index, or all indexes on the table, using
+ REINDEX INDEX or REINDEX TABLE.
+
+ Things are more difficult if you need to recover from corruption of
+ an index on a system table. In this case it's important for the
+ system to not have used any of the suspect indexes itself.
+ (Indeed, in this sort of scenario you might find that server
+ processes are crashing immediately at start-up, due to reliance on
+ the corrupted indexes.) To recover safely, the server must be started
+ with the -P option, which prevents it from using
+ indexes for system catalog lookups.
+
+ One way to do this is to shut down the server and start a single-user
+ PostgreSQL server
+ with the -P option included on its command line.
+ Then, REINDEX DATABASE, REINDEX SYSTEM,
+ REINDEX TABLE, or REINDEX INDEX can be
+ issued, depending on how much you want to reconstruct. If in
+ doubt, use REINDEX SYSTEM to select
+ reconstruction of all system indexes in the database. Then quit
+ the single-user server session and restart the regular server.
+ See the postgres reference page for more
+ information about how to interact with the single-user server
+ interface.
+
+ Alternatively, a regular server session can be started with
+ -P included in its command line options.
+ The method for doing this varies across clients, but in all
+ libpq-based clients, it is possible to set
+ the PGOPTIONS environment variable to -P
+ before starting the client. Note that while this method does not
+ require locking out other clients, it might still be wise to prevent
+ other users from connecting to the damaged database until repairs
+ have been completed.
+
+ REINDEX is similar to a drop and recreate of the index
+ in that the index contents are rebuilt from scratch. However, the locking
+ considerations are rather different. REINDEX locks out writes
+ but not reads of the index's parent table. It also takes an
+ ACCESS EXCLUSIVE lock on the specific index being processed,
+ which will block reads that attempt to use that index. In particular,
+ the query planner tries to take an ACCESS SHARE
+ lock on every index of the table, regardless of the query, and so
+ REINDEX blocks virtually any queries except for some
+ prepared queries whose plan has been cached and which don't use this very
+ index. In contrast,
+ DROP INDEX momentarily takes an
+ ACCESS EXCLUSIVE lock on the parent table, blocking both
+ writes and reads. The subsequent CREATE INDEX locks out
+ writes but not reads; since the index is not there, no read will attempt to
+ use it, meaning that there will be no blocking but reads might be forced
+ into expensive sequential scans.
+
+ Reindexing a single index or table requires being the owner of that
+ index or table. Reindexing a schema or database requires being the
+ owner of that schema or database. Note specifically that it's thus
+ possible for non-superusers to rebuild indexes of tables owned by
+ other users. However, as a special exception, when
+ REINDEX DATABASE, REINDEX SCHEMA
+ or REINDEX SYSTEM is issued by a non-superuser,
+ indexes on shared catalogs will be skipped unless the user owns the
+ catalog (which typically won't be the case). Of course, superusers
+ can always reindex anything.
+
+ Reindexing partitioned indexes or partitioned tables is supported
+ with REINDEX INDEX or REINDEX TABLE,
+ respectively. Each partition of the specified partitioned relation is
+ reindexed in a separate transaction. Those commands cannot be used inside
+ a transaction block when working on a partitioned table or index.
+
+ When using the TABLESPACE clause with
+ REINDEX on a partitioned index or table, only the
+ tablespace references of the leaf partitions are updated. As partitioned
+ indexes are not updated, it is recommended to separately use
+ ALTER TABLE ONLY on them so as any new partitions
+ attached inherit the new tablespace. On failure, it may not have moved
+ all the indexes to the new tablespace. Re-running the command will rebuild
+ all the leaf partitions and move previously-unprocessed indexes to the new
+ tablespace.
+
+ If SCHEMA, DATABASE or
+ SYSTEM is used with TABLESPACE,
+ system relations are skipped and a single WARNING
+ will be generated. Indexes on TOAST tables are rebuilt, but not moved
+ to the new tablespace.
+
Rebuilding Indexes Concurrently
+ Rebuilding an index can interfere with regular operation of a database.
+ Normally PostgreSQL locks the table whose index is rebuilt
+ against writes and performs the entire index build with a single scan of the
+ table. Other transactions can still read the table, but if they try to
+ insert, update, or delete rows in the table they will block until the
+ index rebuild is finished. This could have a severe effect if the system is
+ a live production database. Very large tables can take many hours to be
+ indexed, and even for smaller tables, an index rebuild can lock out writers
+ for periods that are unacceptably long for a production system.
+
+ PostgreSQL supports rebuilding indexes with minimum locking
+ of writes. This method is invoked by specifying the
+ CONCURRENTLY option of REINDEX. When this option
+ is used, PostgreSQL must perform two scans of the table
+ for each index that needs to be rebuilt and wait for termination of
+ all existing transactions that could potentially use the index.
+ This method requires more total work than a standard index
+ rebuild and takes significantly longer to complete as it needs to wait
+ for unfinished transactions that might modify the index. However, since
+ it allows normal operations to continue while the index is being rebuilt, this
+ method is useful for rebuilding indexes in a production environment. Of
+ course, the extra CPU, memory and I/O load imposed by the index rebuild
+ may slow down other operations.
+
+ The following steps occur in a concurrent reindex. Each step is run in a
+ separate transaction. If there are multiple indexes to be rebuilt, then
+ each step loops through all the indexes before moving to the next step.
+
+
+ A new transient index definition is added to the catalog
+ pg_index. This definition will be used to replace
+ the old index. A SHARE UPDATE EXCLUSIVE lock at
+ session level is taken on the indexes being reindexed as well as their
+ associated tables to prevent any schema modification while processing.
+
+ A first pass to build the index is done for each new index. Once the
+ index is built, its flag pg_index.indisready is
+ switched to “true” to make it ready for inserts, making it
+ visible to other sessions once the transaction that performed the build
+ is finished. This step is done in a separate transaction for each
+ index.
+
+ Then a second pass is performed to add tuples that were added while the
+ first pass was running. This step is also done in a separate
+ transaction for each index.
+
+ All the constraints that refer to the index are changed to refer to the
+ new index definition, and the names of the indexes are changed. At
+ this point, pg_index.indisvalid is switched to
+ “true” for the new index and to “false” for
+ the old, and a cache invalidation is done causing all sessions that
+ referenced the old index to be invalidated.
+
+ The old indexes have pg_index.indisready switched to
+ “false” to prevent any new tuple insertions, after waiting
+ for running queries that might reference the old index to complete.
+
+ The old indexes are dropped. The SHARE UPDATE
+ EXCLUSIVE session locks for the indexes and the table are
+ released.
+
+
+ If a problem arises while rebuilding the indexes, such as a
+ uniqueness violation in a unique index, the REINDEX
+ command will fail but leave behind an “invalid” new index in addition to
+ the pre-existing one. This index will be ignored for querying purposes
+ because it might be incomplete; however it will still consume update
+ overhead. The psql \d command will report
+ such an index as INVALID:
+
+
+postgres=# \d tab
+ Table "public.tab"
+ Column | Type | Modifiers
+--------+---------+-----------
+ col | integer |
+Indexes:
+ "idx" btree (col)
+ "idx_ccnew" btree (col) INVALID
+
+
+ If the index marked INVALID is suffixed
+ ccnew, then it corresponds to the transient
+ index created during the concurrent operation, and the recommended
+ recovery method is to drop it using DROP INDEX,
+ then attempt REINDEX CONCURRENTLY again.
+ If the invalid index is instead suffixed ccold,
+ it corresponds to the original index which could not be dropped;
+ the recommended recovery method is to just drop said index, since the
+ rebuild proper has been successful.
+
+ Regular index builds permit other regular index builds on the same table
+ to occur simultaneously, but only one concurrent index build can occur on a
+ table at a time. In both cases, no other types of schema modification on
+ the table are allowed meanwhile. Another difference is that a regular
+ REINDEX TABLE or REINDEX INDEX
+ command can be performed within a transaction block, but REINDEX
+ CONCURRENTLY cannot.
+
+ Like any long-running transaction, REINDEX on a table
+ can affect which tuples can be removed by concurrent
+ VACUUM on any other table.
+
+ REINDEX SYSTEM does not support
+ CONCURRENTLY since system catalogs cannot be reindexed
+ concurrently.
+
+ Furthermore, indexes for exclusion constraints cannot be reindexed
+ concurrently. If such an index is named directly in this command, an
+ error is raised. If a table or database with exclusion constraint indexes
+ is reindexed concurrently, those indexes will be skipped. (It is possible
+ to reindex such indexes without the CONCURRENTLY option.)
+
+ Each backend running REINDEX will report its progress
+ in the pg_stat_progress_create_index view. See
+ Section 28.4.4 for details.
+
Examples
+ Rebuild a single index:
+
+
+REINDEX INDEX my_index;
+
+
+ Rebuild all the indexes on the table my_table:
+
+
+REINDEX TABLE my_table;
+
+
+ Rebuild all indexes in a particular database, without trusting the
+ system indexes to be valid already:
+
+
+$ export PGOPTIONS="-P"
+$ psql broken_db
+...
+broken_db=> REINDEX DATABASE broken_db;
+broken_db=> \q
+
+ Rebuild indexes for a table, without blocking read and write operations
+ on involved relations while reindexing is in progress:
+
+
+REINDEX TABLE CONCURRENTLY my_broken_table;
+
Compatibility
+ There is no REINDEX command in the SQL standard.
+
RELEASE SAVEPOINT
RELEASE SAVEPOINT — release a previously defined savepoint
Synopsis
+RELEASE [ SAVEPOINT ] savepoint_name
+
Description
+ RELEASE SAVEPOINT releases the named savepoint and
+ all active savepoints that were created after the named savepoint,
+ and frees their resources. All changes made since the creation of
+ the savepoint that didn't already get rolled back are merged into
+ the transaction or savepoint that was active when the named savepoint
+ was created. Changes made after RELEASE SAVEPOINT
+ will also be part of this active transaction or savepoint.
+
Parameters
savepoint_name
+ The name of the savepoint to release.
+
Notes
+ Specifying a savepoint name that was not previously defined is an error.
+
+ It is not possible to release a savepoint when the transaction is in
+ an aborted state; to do that, use ROLLBACK TO SAVEPOINT.
+
+ If multiple savepoints have the same name, only the most recently defined
+ unreleased one is released. Repeated commands will release progressively
+ older savepoints.
+
Examples
+ To establish and later release a savepoint:
+
+BEGIN;
+ INSERT INTO table1 VALUES (3);
+ SAVEPOINT my_savepoint;
+ INSERT INTO table1 VALUES (4);
+ RELEASE SAVEPOINT my_savepoint;
+COMMIT;
+
+ The above transaction will insert both 3 and 4.
+
+ A more complex example with multiple nested subtransactions:
+
+BEGIN;
+ INSERT INTO table1 VALUES (1);
+ SAVEPOINT sp1;
+ INSERT INTO table1 VALUES (2);
+ SAVEPOINT sp2;
+ INSERT INTO table1 VALUES (3);
+ RELEASE SAVEPOINT sp2;
+ INSERT INTO table1 VALUES (4))); -- generates an error
+
+ In this example, the application requests the release of the savepoint
+ sp2, which inserted 3. This changes the insert's
+ transaction context to sp1. When the statement
+ attempting to insert value 4 generates an error, the insertion of 2 and
+ 4 are lost because they are in the same, now-rolled back savepoint,
+ and value 3 is in the same transaction context. The application can
+ now only choose one of these two commands, since all other commands
+ will be ignored:
+
+ ROLLBACK;
+ ROLLBACK TO SAVEPOINT sp1;
+
+ Choosing ROLLBACK will abort everything, including
+ value 1, whereas ROLLBACK TO SAVEPOINT sp1 will retain
+ value 1 and allow the transaction to continue.
+
Compatibility
+ This command conforms to the SQL standard. The standard
+ specifies that the key word SAVEPOINT is
+ mandatory, but PostgreSQL allows it to
+ be omitted.
+
RESET
RESET — restore the value of a run-time parameter to the default value
Synopsis
+RESET configuration_parameter
+RESET ALL
+
Description
+ RESET restores run-time parameters to their
+ default values. RESET is an alternative
+ spelling for
+
+SET configuration_parameter TO DEFAULT
+
+ Refer to SET for
+ details.
+
+ The default value is defined as the value that the parameter would
+ have had, if no SET had ever been issued for it in the
+ current session. The actual source of this value might be a
+ compiled-in default, the configuration file, command-line options,
+ or per-database or per-user default settings. This is subtly different
+ from defining it as “the value that the parameter had at session
+ start”, because if the value came from the configuration file, it
+ will be reset to whatever is specified by the configuration file now.
+ See Chapter 20 for details.
+
+ The transactional behavior of RESET is the same as
+ SET: its effects will be undone by transaction rollback.
+
Parameters
configuration_parameter
+ Name of a settable run-time parameter. Available parameters are
+ documented in Chapter 20 and on the
+ SET reference page.
+
ALL
+ Resets all settable run-time parameters to default values.
+
Examples
+ Set the timezone configuration variable to its default value:
+
+RESET timezone;
+
Compatibility
+ RESET is a PostgreSQL extension.
+
REVOKE
REVOKE — remove access privileges
Synopsis
+REVOKE [ GRANT OPTION FOR ]
+ { { SELECT | INSERT | UPDATE | DELETE | TRUNCATE | REFERENCES | TRIGGER }
+ [, ...] | ALL [ PRIVILEGES ] }
+ ON { [ TABLE ] table_name [, ...]
+ | ALL TABLES IN SCHEMA schema_name [, ...] }
+ FROM role_specification [, ...]
+ [ GRANTED BY role_specification ]
+ [ CASCADE | RESTRICT ]
+
+REVOKE [ GRANT OPTION FOR ]
+ { { SELECT | INSERT | UPDATE | REFERENCES } ( column_name [, ...] )
+ [, ...] | ALL [ PRIVILEGES ] ( column_name [, ...] ) }
+ ON [ TABLE ] table_name [, ...]
+ FROM role_specification [, ...]
+ [ GRANTED BY role_specification ]
+ [ CASCADE | RESTRICT ]
+
+REVOKE [ GRANT OPTION FOR ]
+ { { USAGE | SELECT | UPDATE }
+ [, ...] | ALL [ PRIVILEGES ] }
+ ON { SEQUENCE sequence_name [, ...]
+ | ALL SEQUENCES IN SCHEMA schema_name [, ...] }
+ FROM role_specification [, ...]
+ [ GRANTED BY role_specification ]
+ [ CASCADE | RESTRICT ]
+
+REVOKE [ GRANT OPTION FOR ]
+ { { CREATE | CONNECT | TEMPORARY | TEMP } [, ...] | ALL [ PRIVILEGES ] }
+ ON DATABASE database_name [, ...]
+ FROM role_specification [, ...]
+ [ GRANTED BY role_specification ]
+ [ CASCADE | RESTRICT ]
+
+REVOKE [ GRANT OPTION FOR ]
+ { USAGE | ALL [ PRIVILEGES ] }
+ ON DOMAIN domain_name [, ...]
+ FROM role_specification [, ...]
+ [ GRANTED BY role_specification ]
+ [ CASCADE | RESTRICT ]
+
+REVOKE [ GRANT OPTION FOR ]
+ { USAGE | ALL [ PRIVILEGES ] }
+ ON FOREIGN DATA WRAPPER fdw_name [, ...]
+ FROM role_specification [, ...]
+ [ GRANTED BY role_specification ]
+ [ CASCADE | RESTRICT ]
+
+REVOKE [ GRANT OPTION FOR ]
+ { USAGE | ALL [ PRIVILEGES ] }
+ ON FOREIGN SERVER server_name [, ...]
+ FROM role_specification [, ...]
+ [ GRANTED BY role_specification ]
+ [ CASCADE | RESTRICT ]
+
+REVOKE [ GRANT OPTION FOR ]
+ { EXECUTE | ALL [ PRIVILEGES ] }
+ ON { { FUNCTION | PROCEDURE | ROUTINE } function_name [ ( [ [ argmode ] [ arg_name ] arg_type [, ...] ] ) ] [, ...]
+ | ALL { FUNCTIONS | PROCEDURES | ROUTINES } IN SCHEMA schema_name [, ...] }
+ FROM role_specification [, ...]
+ [ GRANTED BY role_specification ]
+ [ CASCADE | RESTRICT ]
+
+REVOKE [ GRANT OPTION FOR ]
+ { USAGE | ALL [ PRIVILEGES ] }
+ ON LANGUAGE lang_name [, ...]
+ FROM role_specification [, ...]
+ [ GRANTED BY role_specification ]
+ [ CASCADE | RESTRICT ]
+
+REVOKE [ GRANT OPTION FOR ]
+ { { SELECT | UPDATE } [, ...] | ALL [ PRIVILEGES ] }
+ ON LARGE OBJECT loid [, ...]
+ FROM role_specification [, ...]
+ [ GRANTED BY role_specification ]
+ [ CASCADE | RESTRICT ]
+
+REVOKE [ GRANT OPTION FOR ]
+ { { SET | ALTER SYSTEM } [, ...] | ALL [ PRIVILEGES ] }
+ ON PARAMETER configuration_parameter [, ...]
+ FROM role_specification [, ...]
+ [ GRANTED BY role_specification ]
+ [ CASCADE | RESTRICT ]
+
+REVOKE [ GRANT OPTION FOR ]
+ { { CREATE | USAGE } [, ...] | ALL [ PRIVILEGES ] }
+ ON SCHEMA schema_name [, ...]
+ FROM role_specification [, ...]
+ [ GRANTED BY role_specification ]
+ [ CASCADE | RESTRICT ]
+
+REVOKE [ GRANT OPTION FOR ]
+ { CREATE | ALL [ PRIVILEGES ] }
+ ON TABLESPACE tablespace_name [, ...]
+ FROM role_specification [, ...]
+ [ GRANTED BY role_specification ]
+ [ CASCADE | RESTRICT ]
+
+REVOKE [ GRANT OPTION FOR ]
+ { USAGE | ALL [ PRIVILEGES ] }
+ ON TYPE type_name [, ...]
+ FROM role_specification [, ...]
+ [ GRANTED BY role_specification ]
+ [ CASCADE | RESTRICT ]
+
+REVOKE [ { ADMIN | INHERIT | SET } OPTION FOR ]
+ role_name [, ...] FROM role_specification [, ...]
+ [ GRANTED BY role_specification ]
+ [ CASCADE | RESTRICT ]
+
+where role_specification can be:
+
+ [ GROUP ] role_name
+ | PUBLIC
+ | CURRENT_ROLE
+ | CURRENT_USER
+ | SESSION_USER
+Description
+ The REVOKE command revokes previously granted
+ privileges from one or more roles. The key word
+ PUBLIC refers to the implicitly defined group of
+ all roles.
+
+ See the description of the GRANT command for
+ the meaning of the privilege types.
+
+ Note that any particular role will have the sum
+ of privileges granted directly to it, privileges granted to any role it
+ is presently a member of, and privileges granted to
+ PUBLIC. Thus, for example, revoking SELECT privilege
+ from PUBLIC does not necessarily mean that all roles
+ have lost SELECT privilege on the object: those who have it granted
+ directly or via another role will still have it. Similarly, revoking
+ SELECT from a user might not prevent that user from using
+ SELECT if PUBLIC or another membership
+ role still has SELECT rights.
+
+ If GRANT OPTION FOR is specified, only the grant
+ option for the privilege is revoked, not the privilege itself.
+ Otherwise, both the privilege and the grant option are revoked.
+
+ If a user holds a privilege with grant option and has granted it to
+ other users then the privileges held by those other users are
+ called dependent privileges. If the privilege or the grant option
+ held by the first user is being revoked and dependent privileges
+ exist, those dependent privileges are also revoked if
+ CASCADE is specified; if it is not, the revoke action
+ will fail. This recursive revocation only affects privileges that
+ were granted through a chain of users that is traceable to the user
+ that is the subject of this REVOKE command.
+ Thus, the affected users might effectively keep the privilege if it
+ was also granted through other users.
+
+ When revoking privileges on a table, the corresponding column privileges
+ (if any) are automatically revoked on each column of the table, as well.
+ On the other hand, if a role has been granted privileges on a table, then
+ revoking the same privileges from individual columns will have no effect.
+
+ When revoking membership in a role, GRANT OPTION is instead
+ called ADMIN OPTION, but the behavior is similar.
+ Note that, in releases prior to PostgreSQL 16,
+ dependent privileges were not tracked for grants of role membership,
+ and thus CASCADE had no effect for role membership.
+ This is no longer the case.
+ Note also that this form of the command does not
+ allow the noise word GROUP
+ in role_specification.
+
+ Just as ADMIN OPTION can be removed from an existing
+ role grant, it is also possible to revoke INHERIT OPTION
+ or SET OPTION. This is equivalent to setting the value
+ of the corresponding option to FALSE.
+
Notes
+ A user can only revoke privileges that were granted directly by
+ that user. If, for example, user A has granted a privilege with
+ grant option to user B, and user B has in turn granted it to user
+ C, then user A cannot revoke the privilege directly from C.
+ Instead, user A could revoke the grant option from user B and use
+ the CASCADE option so that the privilege is
+ in turn revoked from user C. For another example, if both A and B
+ have granted the same privilege to C, A can revoke their own grant
+ but not B's grant, so C will still effectively have the privilege.
+
+ When a non-owner of an object attempts to REVOKE privileges
+ on the object, the command will fail outright if the user has no
+ privileges whatsoever on the object. As long as some privilege is
+ available, the command will proceed, but it will revoke only those
+ privileges for which the user has grant options. The REVOKE ALL
+ PRIVILEGES forms will issue a warning message if no grant options are
+ held, while the other forms will issue a warning if grant options for
+ any of the privileges specifically named in the command are not held.
+ (In principle these statements apply to the object owner as well, but
+ since the owner is always treated as holding all grant options, the
+ cases can never occur.)
+
+ If a superuser chooses to issue a GRANT or REVOKE
+ command, the command is performed as though it were issued by the
+ owner of the affected object. (Since roles do not have owners, in the
+ case of a GRANT of role membership, the command is
+ performed as though it were issued by the bootstrap superuser.)
+ Since all privileges ultimately come
+ from the object owner (possibly indirectly via chains of grant options),
+ it is possible for a superuser to revoke all privileges, but this might
+ require use of CASCADE as stated above.
+
+ REVOKE can also be done by a role
+ that is not the owner of the affected object, but is a member of the role
+ that owns the object, or is a member of a role that holds privileges
+ WITH GRANT OPTION on the object. In this case the
+ command is performed as though it were issued by the containing role that
+ actually owns the object or holds the privileges
+ WITH GRANT OPTION. For example, if table
+ t1 is owned by role g1, of which role
+ u1 is a member, then u1 can revoke privileges
+ on t1 that are recorded as being granted by g1.
+ This would include grants made by u1 as well as by other
+ members of role g1.
+
+ If the role executing REVOKE holds privileges
+ indirectly via more than one role membership path, it is unspecified
+ which containing role will be used to perform the command. In such cases
+ it is best practice to use SET ROLE to become the specific
+ role you want to do the REVOKE as. Failure to do so might
+ lead to revoking privileges other than the ones you intended, or not
+ revoking anything at all.
+
+ See Section 5.7 for more information about specific
+ privilege types, as well as how to inspect objects' privileges.
+
Examples
+ Revoke insert privilege for the public on table
+ films:
+
+
+REVOKE INSERT ON films FROM PUBLIC;
+
+
+ Revoke all privileges from user manuel on view
+ kinds:
+
+
+REVOKE ALL PRIVILEGES ON kinds FROM manuel;
+
+
+ Note that this actually means “revoke all privileges that I
+ granted”.
+
+ Revoke membership in role admins from user joe:
+
+
+REVOKE admins FROM joe;
+
Compatibility
+ The compatibility notes of the GRANT command
+ apply analogously to REVOKE.
+ The keyword RESTRICT or CASCADE
+ is required according to the standard, but PostgreSQL
+ assumes RESTRICT by default.
+
ROLLBACK PREPARED
ROLLBACK PREPARED — cancel a transaction that was earlier prepared for two-phase commit
Synopsis
+ROLLBACK PREPARED transaction_id
+
Description
+ ROLLBACK PREPARED rolls back a transaction that is in
+ prepared state.
+
Parameters
transaction_id
+ The transaction identifier of the transaction that is to be
+ rolled back.
+
Notes
+ To roll back a prepared transaction, you must be either the same user that
+ executed the transaction originally, or a superuser. But you do not
+ have to be in the same session that executed the transaction.
+
+ This command cannot be executed inside a transaction block. The prepared
+ transaction is rolled back immediately.
+
+ All currently available prepared transactions are listed in the
+ pg_prepared_xacts
+ system view.
+
Examples
+ Roll back the transaction identified by the transaction
+ identifier foobar:
+
+
+ROLLBACK PREPARED 'foobar';
+
Compatibility
+ ROLLBACK PREPARED is a
+ PostgreSQL extension. It is intended for use by
+ external transaction management systems, some of which are covered by
+ standards (such as X/Open XA), but the SQL side of those systems is not
+ standardized.
+
ROLLBACK TO SAVEPOINT
ROLLBACK TO SAVEPOINT — roll back to a savepoint
Synopsis
+ROLLBACK [ WORK | TRANSACTION ] TO [ SAVEPOINT ] savepoint_name
+
Description
+ Roll back all commands that were executed after the savepoint was
+ established and then start a new subtransaction at the same transaction level.
+ The savepoint remains valid and can be rolled back to again later,
+ if needed.
+
+ ROLLBACK TO SAVEPOINT implicitly destroys all savepoints that
+ were established after the named savepoint.
+
Parameters
savepoint_name
+ The savepoint to roll back to.
+
Notes
+ Use RELEASE SAVEPOINT to destroy a savepoint
+ without discarding the effects of commands executed after it was
+ established.
+
+ Specifying a savepoint name that has not been established is an error.
+
+ Cursors have somewhat non-transactional behavior with respect to
+ savepoints. Any cursor that is opened inside a savepoint will be closed
+ when the savepoint is rolled back. If a previously opened cursor is
+ affected by a FETCH or MOVE command inside a
+ savepoint that is later rolled back, the cursor remains at the
+ position that FETCH left it pointing to (that is, the cursor
+ motion caused by FETCH is not rolled back).
+ Closing a cursor is not undone by rolling back, either.
+ However, other side-effects caused by the cursor's query (such as
+ side-effects of volatile functions called by the query) are
+ rolled back if they occur during a savepoint that is later rolled back.
+ A cursor whose execution causes a transaction to abort is put in a
+ cannot-execute state, so while the transaction can be restored using
+ ROLLBACK TO SAVEPOINT, the cursor can no longer be used.
+
Examples
+ To undo the effects of the commands executed after my_savepoint
+ was established:
+
+ROLLBACK TO SAVEPOINT my_savepoint;
+
+
+ Cursor positions are not affected by savepoint rollback:
+
+BEGIN;
+
+DECLARE foo CURSOR FOR SELECT 1 UNION SELECT 2;
+
+SAVEPOINT foo;
+
+FETCH 1 FROM foo;
+ ?column?
+----------
+ 1
+
+ROLLBACK TO SAVEPOINT foo;
+
+FETCH 1 FROM foo;
+ ?column?
+----------
+ 2
+
+COMMIT;
+
Compatibility
+ The SQL standard specifies that the key word
+ SAVEPOINT is mandatory, but PostgreSQL
+ and Oracle allow it to be omitted. SQL allows
+ only WORK, not TRANSACTION, as a noise word
+ after ROLLBACK. Also, SQL has an optional clause
+ AND [ NO ] CHAIN which is not currently supported by
+ PostgreSQL. Otherwise, this command conforms to
+ the SQL standard.
+
ROLLBACK
ROLLBACK — abort the current transaction
Synopsis
+ROLLBACK [ WORK | TRANSACTION ] [ AND [ NO ] CHAIN ]
+
Description
+ ROLLBACK rolls back the current transaction and causes
+ all the updates made by the transaction to be discarded.
+
Parameters
WORK
TRANSACTION #
+ Optional key words. They have no effect.
+
AND CHAIN #
+ If AND CHAIN is specified, a new (not aborted)
+ transaction is immediately started with the same transaction
+ characteristics (see SET TRANSACTION) as the
+ just finished one. Otherwise, no new transaction is started.
+
Notes
+ Use COMMIT to
+ successfully terminate a transaction.
+
+ Issuing ROLLBACK outside of a transaction
+ block emits a warning and otherwise has no effect. ROLLBACK AND
+ CHAIN outside of a transaction block is an error.
+
Examples
+ To abort all changes:
+
+ROLLBACK;
+
Compatibility
+ The command ROLLBACK conforms to the SQL standard. The
+ form ROLLBACK TRANSACTION is a PostgreSQL extension.
+
SAVEPOINT
SAVEPOINT — define a new savepoint within the current transaction
Synopsis
+SAVEPOINT savepoint_name
+
Description
+ SAVEPOINT establishes a new savepoint within
+ the current transaction.
+
+ A savepoint is a special mark inside a transaction that allows all commands
+ that are executed after it was established to be rolled back, restoring
+ the transaction state to what it was at the time of the savepoint.
+
Parameters
savepoint_name
+ The name to give to the new savepoint. If savepoints with the
+ same name already exist, they will be inaccessible until newer
+ identically-named savepoints are released.
+
Notes
+ Use ROLLBACK TO to
+ rollback to a savepoint. Use RELEASE SAVEPOINT
+ to destroy a savepoint, keeping
+ the effects of commands executed after it was established.
+
+ Savepoints can only be established when inside a transaction block.
+ There can be multiple savepoints defined within a transaction.
+
Examples
+ To establish a savepoint and later undo the effects of all commands executed
+ after it was established:
+
+BEGIN;
+ INSERT INTO table1 VALUES (1);
+ SAVEPOINT my_savepoint;
+ INSERT INTO table1 VALUES (2);
+ ROLLBACK TO SAVEPOINT my_savepoint;
+ INSERT INTO table1 VALUES (3);
+COMMIT;
+
+ The above transaction will insert the values 1 and 3, but not 2.
+
+ To establish and later destroy a savepoint:
+
+BEGIN;
+ INSERT INTO table1 VALUES (3);
+ SAVEPOINT my_savepoint;
+ INSERT INTO table1 VALUES (4);
+ RELEASE SAVEPOINT my_savepoint;
+COMMIT;
+
+ The above transaction will insert both 3 and 4.
+
+ To use a single savepoint name:
+
+BEGIN;
+ INSERT INTO table1 VALUES (1);
+ SAVEPOINT my_savepoint;
+ INSERT INTO table1 VALUES (2);
+ SAVEPOINT my_savepoint;
+ INSERT INTO table1 VALUES (3);
+
+ -- rollback to the second savepoint
+ ROLLBACK TO SAVEPOINT my_savepoint;
+ SELECT * FROM table1; -- shows rows 1 and 2
+
+ -- release the second savepoint
+ RELEASE SAVEPOINT my_savepoint;
+
+ -- rollback to the first savepoint
+ ROLLBACK TO SAVEPOINT my_savepoint;
+ SELECT * FROM table1; -- shows only row 1
+COMMIT;
+
+ The above transaction shows row 3 being rolled back first, then row 2.
+
Compatibility
+ SQL requires a savepoint to be destroyed automatically when another
+ savepoint with the same name is established. In
+ PostgreSQL, the old savepoint is kept, though only the more
+ recent one will be used when rolling back or releasing. (Releasing the
+ newer savepoint with RELEASE SAVEPOINT will cause the older one
+ to again become accessible to ROLLBACK TO SAVEPOINT and
+ RELEASE SAVEPOINT.) Otherwise, SAVEPOINT is
+ fully SQL conforming.
+
SECURITY LABEL
SECURITY LABEL — define or change a security label applied to an object
Synopsis
+SECURITY LABEL [ FOR provider ] ON
+{
+ TABLE object_name |
+ COLUMN table_name.column_name |
+ AGGREGATE aggregate_name ( aggregate_signature ) |
+ DATABASE object_name |
+ DOMAIN object_name |
+ EVENT TRIGGER object_name |
+ FOREIGN TABLE object_name |
+ FUNCTION function_name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ] |
+ LARGE OBJECT large_object_oid |
+ MATERIALIZED VIEW object_name |
+ [ PROCEDURAL ] LANGUAGE object_name |
+ PROCEDURE procedure_name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ] |
+ PUBLICATION object_name |
+ ROLE object_name |
+ ROUTINE routine_name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ] |
+ SCHEMA object_name |
+ SEQUENCE object_name |
+ SUBSCRIPTION object_name |
+ TABLESPACE object_name |
+ TYPE object_name |
+ VIEW object_name
+} IS { string_literal | NULL }
+
+where aggregate_signature is:
+
+* |
+[ argmode ] [ argname ] argtype [ , ... ] |
+[ [ argmode ] [ argname ] argtype [ , ... ] ] ORDER BY [ argmode ] [ argname ] argtype [ , ... ]
+
Description
+ SECURITY LABEL applies a security label to a database
+ object. An arbitrary number of security labels, one per label provider, can
+ be associated with a given database object. Label providers are loadable
+ modules which register themselves by using the function
+ register_label_provider.
+
Note
+ register_label_provider is not an SQL function; it can
+ only be called from C code loaded into the backend.
+
+ The label provider determines whether a given label is valid and whether
+ it is permissible to assign that label to a given object. The meaning of a
+ given label is likewise at the discretion of the label provider.
+ PostgreSQL places no restrictions on whether or how a
+ label provider must interpret security labels; it merely provides a
+ mechanism for storing them. In practice, this facility is intended to allow
+ integration with label-based mandatory access control (MAC) systems such as
+ SELinux. Such systems make all access control decisions
+ based on object labels, rather than traditional discretionary access control
+ (DAC) concepts such as users and groups.
+
Parameters
object_name
table_name.column_name
aggregate_name
function_name
procedure_name
routine_name
+ The name of the object to be labeled. Names of objects that reside in
+ schemas (tables, functions, etc.) can be schema-qualified.
+
provider
+ The name of the provider with which this label is to be associated. The
+ named provider must be loaded and must consent to the proposed labeling
+ operation. If exactly one provider is loaded, the provider name may be
+ omitted for brevity.
+
argmode
+ The mode of a function, procedure, or aggregate
+ argument: IN, OUT,
+ INOUT, or VARIADIC.
+ If omitted, the default is IN.
+ Note that SECURITY LABEL does not actually
+ pay any attention to OUT arguments, since only the input
+ arguments are needed to determine the function's identity.
+ So it is sufficient to list the IN, INOUT,
+ and VARIADIC arguments.
+
argname
+ The name of a function, procedure, or aggregate argument.
+ Note that SECURITY LABEL does not actually
+ pay any attention to argument names, since only the argument data
+ types are needed to determine the function's identity.
+
argtype
+ The data type of a function, procedure, or aggregate argument.
+
large_object_oid
+ The OID of the large object.
+
PROCEDURAL
+ This is a noise word.
+
string_literal
+ The new setting of the security label, written as a string literal.
+
NULL
+ Write NULL to drop the security label.
+
Examples
+ The following example shows how the security label of a table could
+ be set or changed:
+
+
+SECURITY LABEL FOR selinux ON TABLE mytable IS 'system_u:object_r:sepgsql_table_t:s0';
+
+
+ To remove the label:
+
+
+SECURITY LABEL FOR selinux ON TABLE mytable IS NULL;
+
+
Compatibility
+ There is no SECURITY LABEL command in the SQL standard.
+
See Also
sepgsql, src/test/modules/dummy_seclabelSELECT
SELECT, TABLE, WITH — retrieve rows from a table or view
Synopsis
+[ WITH [ RECURSIVE ] with_query [, ...] ]
+SELECT [ ALL | DISTINCT [ ON ( expression [, ...] ) ] ]
+ [ * | expression [ [ AS ] output_name ] [, ...] ]
+ [ FROM from_item [, ...] ]
+ [ WHERE condition ]
+ [ GROUP BY [ ALL | DISTINCT ] grouping_element [, ...] ]
+ [ HAVING condition ]
+ [ WINDOW window_name AS ( window_definition ) [, ...] ]
+ [ { UNION | INTERSECT | EXCEPT } [ ALL | DISTINCT ] select ]
+ [ ORDER BY expression [ ASC | DESC | USING operator ] [ NULLS { FIRST | LAST } ] [, ...] ]
+ [ LIMIT { count | ALL } ]
+ [ OFFSET start [ ROW | ROWS ] ]
+ [ FETCH { FIRST | NEXT } [ count ] { ROW | ROWS } { ONLY | WITH TIES } ]
+ [ FOR { UPDATE | NO KEY UPDATE | SHARE | KEY SHARE } [ OF table_name [, ...] ] [ NOWAIT | SKIP LOCKED ] [...] ]
+
+where from_item can be one of:
+
+ [ ONLY ] table_name [ * ] [ [ AS ] alias [ ( column_alias [, ...] ) ] ]
+ [ TABLESAMPLE sampling_method ( argument [, ...] ) [ REPEATABLE ( seed ) ] ]
+ [ LATERAL ] ( select ) [ [ AS ] alias [ ( column_alias [, ...] ) ] ]
+ with_query_name [ [ AS ] alias [ ( column_alias [, ...] ) ] ]
+ [ LATERAL ] function_name ( [ argument [, ...] ] )
+ [ WITH ORDINALITY ] [ [ AS ] alias [ ( column_alias [, ...] ) ] ]
+ [ LATERAL ] function_name ( [ argument [, ...] ] ) [ AS ] alias ( column_definition [, ...] )
+ [ LATERAL ] function_name ( [ argument [, ...] ] ) AS ( column_definition [, ...] )
+ [ LATERAL ] ROWS FROM( function_name ( [ argument [, ...] ] ) [ AS ( column_definition [, ...] ) ] [, ...] )
+ [ WITH ORDINALITY ] [ [ AS ] alias [ ( column_alias [, ...] ) ] ]
+ from_item join_type from_item { ON join_condition | USING ( join_column [, ...] ) [ AS join_using_alias ] }
+ from_item NATURAL join_type from_item
+ from_item CROSS JOIN from_item
+
+and grouping_element can be one of:
+
+ ( )
+ expression
+ ( expression [, ...] )
+ ROLLUP ( { expression | ( expression [, ...] ) } [, ...] )
+ CUBE ( { expression | ( expression [, ...] ) } [, ...] )
+ GROUPING SETS ( grouping_element [, ...] )
+
+and with_query is:
+
+ with_query_name [ ( column_name [, ...] ) ] AS [ [ NOT ] MATERIALIZED ] ( select | values | insert | update | delete )
+ [ SEARCH { BREADTH | DEPTH } FIRST BY column_name [, ...] SET search_seq_col_name ]
+ [ CYCLE column_name [, ...] SET cycle_mark_col_name [ TO cycle_mark_value DEFAULT cycle_mark_default ] USING cycle_path_col_name ]
+
+TABLE [ ONLY ] table_name [ * ]
+
Description
+ SELECT retrieves rows from zero or more tables.
+ The general processing of SELECT is as follows:
+
+
+ All queries in the WITH list are computed.
+ These effectively serve as temporary tables that can be referenced
+ in the FROM list. A WITH query
+ that is referenced more than once in FROM is
+ computed only once,
+ unless specified otherwise with NOT MATERIALIZED.
+ (See WITH Clause below.)
+
+ All elements in the FROM list are computed.
+ (Each element in the FROM list is a real or
+ virtual table.) If more than one element is specified in the
+ FROM list, they are cross-joined together.
+ (See FROM Clause below.)
+
+ If the WHERE clause is specified, all rows
+ that do not satisfy the condition are eliminated from the
+ output. (See WHERE Clause below.)
+
+ If the GROUP BY clause is specified,
+ or if there are aggregate function calls, the
+ output is combined into groups of rows that match on one or more
+ values, and the results of aggregate functions are computed.
+ If the HAVING clause is present, it
+ eliminates groups that do not satisfy the given condition. (See
+ GROUP BY Clause and
+ HAVING Clause below.)
+ Although query output columns are nominally computed in the next
+ step, they can also be referenced (by name or ordinal number)
+ in the GROUP BY clause.
+
+ The actual output rows are computed using the
+ SELECT output expressions for each selected
+ row or row group. (See SELECT List below.)
+
SELECT DISTINCT eliminates duplicate rows from the
+ result. SELECT DISTINCT ON eliminates rows that
+ match on all the specified expressions. SELECT ALL
+ (the default) will return all candidate rows, including
+ duplicates. (See DISTINCT Clause below.)
+
+ Using the operators UNION,
+ INTERSECT, and EXCEPT, the
+ output of more than one SELECT statement can
+ be combined to form a single result set. The
+ UNION operator returns all rows that are in
+ one or both of the result sets. The
+ INTERSECT operator returns all rows that are
+ strictly in both result sets. The EXCEPT
+ operator returns the rows that are in the first result set but
+ not in the second. In all three cases, duplicate rows are
+ eliminated unless ALL is specified. The noise
+ word DISTINCT can be added to explicitly specify
+ eliminating duplicate rows. Notice that DISTINCT is
+ the default behavior here, even though ALL is
+ the default for SELECT itself. (See
+ UNION Clause, INTERSECT Clause, and
+ EXCEPT Clause below.)
+
+ If the ORDER BY clause is specified, the
+ returned rows are sorted in the specified order. If
+ ORDER BY is not given, the rows are returned
+ in whatever order the system finds fastest to produce. (See
+ ORDER BY Clause below.)
+
+ If the LIMIT (or FETCH FIRST) or OFFSET
+ clause is specified, the SELECT statement
+ only returns a subset of the result rows. (See LIMIT Clause below.)
+
+ If FOR UPDATE, FOR NO KEY UPDATE, FOR SHARE
+ or FOR KEY SHARE
+ is specified, the
+ SELECT statement locks the selected rows
+ against concurrent updates. (See The Locking Clause
+ below.)
+
+
+ You must have SELECT privilege on each column used
+ in a SELECT command. The use of FOR NO KEY UPDATE,
+ FOR UPDATE,
+ FOR SHARE or FOR KEY SHARE requires
+ UPDATE privilege as well (for at least one column
+ of each table so selected).
+
Parameters
WITH Clause
+ The WITH clause allows you to specify one or more
+ subqueries that can be referenced by name in the primary query.
+ The subqueries effectively act as temporary tables or views
+ for the duration of the primary query.
+ Each subquery can be a SELECT, TABLE, VALUES,
+ INSERT, UPDATE or
+ DELETE statement.
+ When writing a data-modifying statement (INSERT,
+ UPDATE or DELETE) in
+ WITH, it is usual to include a RETURNING clause.
+ It is the output of RETURNING, not the underlying
+ table that the statement modifies, that forms the temporary table that is
+ read by the primary query. If RETURNING is omitted, the
+ statement is still executed, but it produces no output so it cannot be
+ referenced as a table by the primary query.
+
+ A name (without schema qualification) must be specified for each
+ WITH query. Optionally, a list of column names
+ can be specified; if this is omitted,
+ the column names are inferred from the subquery.
+
+ If RECURSIVE is specified, it allows a
+ SELECT subquery to reference itself by name. Such a
+ subquery must have the form
+
+non_recursive_term UNION [ ALL | DISTINCT ] recursive_term
+
+ where the recursive self-reference must appear on the right-hand
+ side of the UNION. Only one recursive self-reference
+ is permitted per query. Recursive data-modifying statements are not
+ supported, but you can use the results of a recursive
+ SELECT query in
+ a data-modifying statement. See Section 7.8 for
+ an example.
+
+ Another effect of RECURSIVE is that
+ WITH queries need not be ordered: a query
+ can reference another one that is later in the list. (However,
+ circular references, or mutual recursion, are not implemented.)
+ Without RECURSIVE, WITH queries
+ can only reference sibling WITH queries
+ that are earlier in the WITH list.
+
+ When there are multiple queries in the WITH
+ clause, RECURSIVE should be written only once,
+ immediately after WITH. It applies to all queries
+ in the WITH clause, though it has no effect on
+ queries that do not use recursion or forward references.
+
+ The optional SEARCH clause computes a search
+ sequence column that can be used for ordering the results of a
+ recursive query in either breadth-first or depth-first order. The
+ supplied column name list specifies the row key that is to be used for
+ keeping track of visited rows. A column named
+ search_seq_col_name will be added to the result
+ column list of the WITH query. This column can be
+ ordered by in the outer query to achieve the respective ordering. See
+ Section 7.8.2.1 for examples.
+
+ The optional CYCLE clause is used to detect cycles in
+ recursive queries. The supplied column name list specifies the row key
+ that is to be used for keeping track of visited rows. A column named
+ cycle_mark_col_name will be added to the result
+ column list of the WITH query. This column will be set
+ to cycle_mark_value when a cycle has been
+ detected, else to cycle_mark_default.
+ Furthermore, processing of the recursive union will stop when a cycle has
+ been detected. cycle_mark_value and
+ cycle_mark_default must be constants and they
+ must be coercible to a common data type, and the data type must have an
+ inequality operator. (The SQL standard requires that they be Boolean
+ constants or character strings, but PostgreSQL does not require that.) By
+ default, TRUE and FALSE (of type
+ boolean) are used. Furthermore, a column
+ named cycle_path_col_name will be added to the
+ result column list of the WITH query. This column is
+ used internally for tracking visited rows. See Section 7.8.2.2 for examples.
+
+ Both the SEARCH and the CYCLE clause
+ are only valid for recursive WITH queries. The
+ with_query must be a UNION
+ (or UNION ALL) of two SELECT (or
+ equivalent) commands (no nested UNIONs). If both
+ clauses are used, the column added by the SEARCH clause
+ appears before the columns added by the CYCLE clause.
+
+ The primary query and the WITH queries are all
+ (notionally) executed at the same time. This implies that the effects of
+ a data-modifying statement in WITH cannot be seen from
+ other parts of the query, other than by reading its RETURNING
+ output. If two such data-modifying statements attempt to modify the same
+ row, the results are unspecified.
+
+ A key property of WITH queries is that they
+ are normally evaluated only once per execution of the primary query,
+ even if the primary query refers to them more than once.
+ In particular, data-modifying statements are guaranteed to be
+ executed once and only once, regardless of whether the primary query
+ reads all or any of their output.
+
+ However, a WITH query can be marked
+ NOT MATERIALIZED to remove this guarantee. In that
+ case, the WITH query can be folded into the primary
+ query much as though it were a simple sub-SELECT in
+ the primary query's FROM clause. This results in
+ duplicate computations if the primary query refers to
+ that WITH query more than once; but if each such use
+ requires only a few rows of the WITH query's total
+ output, NOT MATERIALIZED can provide a net savings by
+ allowing the queries to be optimized jointly.
+ NOT MATERIALIZED is ignored if it is attached to
+ a WITH query that is recursive or is not
+ side-effect-free (i.e., is not a plain SELECT
+ containing no volatile functions).
+
+ By default, a side-effect-free WITH query is folded
+ into the primary query if it is used exactly once in the primary
+ query's FROM clause. This allows joint optimization
+ of the two query levels in situations where that should be semantically
+ invisible. However, such folding can be prevented by marking the
+ WITH query as MATERIALIZED.
+ That might be useful, for example, if the WITH query
+ is being used as an optimization fence to prevent the planner from
+ choosing a bad plan.
+ PostgreSQL versions before v12 never did
+ such folding, so queries written for older versions might rely on
+ WITH to act as an optimization fence.
+
+ See Section 7.8 for additional information.
+
FROM Clause
+ The FROM clause specifies one or more source
+ tables for the SELECT. If multiple sources are
+ specified, the result is the Cartesian product (cross join) of all
+ the sources. But usually qualification conditions are added (via
+ WHERE) to restrict the returned rows to a small subset of the
+ Cartesian product.
+
+ The FROM clause can contain the following
+ elements:
+
+
table_name
+ The name (optionally schema-qualified) of an existing table or view.
+ If ONLY is specified before the table name, only that
+ table is scanned. If ONLY is not specified, the table
+ and all its descendant tables (if any) are scanned. Optionally,
+ * can be specified after the table name to explicitly
+ indicate that descendant tables are included.
+
alias
+ A substitute name for the FROM item containing the
+ alias. An alias is used for brevity or to eliminate ambiguity
+ for self-joins (where the same table is scanned multiple
+ times). When an alias is provided, it completely hides the
+ actual name of the table or function; for example given
+ FROM foo AS f, the remainder of the
+ SELECT must refer to this FROM
+ item as f not foo. If an alias is
+ written, a column alias list can also be written to provide
+ substitute names for one or more columns of the table.
+
TABLESAMPLE sampling_method ( argument [, ...] ) [ REPEATABLE ( seed ) ]
+ A TABLESAMPLE clause after
+ a table_name indicates that the
+ specified sampling_method
+ should be used to retrieve a subset of the rows in that table.
+ This sampling precedes the application of any other filters such
+ as WHERE clauses.
+ The standard PostgreSQL distribution
+ includes two sampling methods, BERNOULLI
+ and SYSTEM, and other sampling methods can be
+ installed in the database via extensions.
+
+ The BERNOULLI and SYSTEM sampling methods
+ each accept a single argument
+ which is the fraction of the table to sample, expressed as a
+ percentage between 0 and 100. This argument can be
+ any real-valued expression. (Other sampling methods might
+ accept more or different arguments.) These two methods each return
+ a randomly-chosen sample of the table that will contain
+ approximately the specified percentage of the table's rows.
+ The BERNOULLI method scans the whole table and
+ selects or ignores individual rows independently with the specified
+ probability.
+ The SYSTEM method does block-level sampling with
+ each block having the specified chance of being selected; all rows
+ in each selected block are returned.
+ The SYSTEM method is significantly faster than
+ the BERNOULLI method when small sampling
+ percentages are specified, but it may return a less-random sample of
+ the table as a result of clustering effects.
+
+ The optional REPEATABLE clause specifies
+ a seed number or expression to use
+ for generating random numbers within the sampling method. The seed
+ value can be any non-null floating-point value. Two queries that
+ specify the same seed and argument
+ values will select the same sample of the table, if the table has
+ not been changed meanwhile. But different seed values will usually
+ produce different samples.
+ If REPEATABLE is not given then a new random
+ sample is selected for each query, based upon a system-generated seed.
+ Note that some add-on sampling methods do not
+ accept REPEATABLE, and will always produce new
+ samples on each use.
+
select
+ A sub-SELECT can appear in the
+ FROM clause. This acts as though its
+ output were created as a temporary table for the duration of
+ this single SELECT command. Note that the
+ sub-SELECT must be surrounded by
+ parentheses, and an alias can be provided in the same way as for a
+ table. A
+ VALUES command
+ can also be used here.
+
with_query_name
+ A WITH query is referenced by writing its name,
+ just as though the query's name were a table name. (In fact,
+ the WITH query hides any real table of the same name
+ for the purposes of the primary query. If necessary, you can
+ refer to a real table of the same name by schema-qualifying
+ the table's name.)
+ An alias can be provided in the same way as for a table.
+
function_name
+ Function calls can appear in the FROM
+ clause. (This is especially useful for functions that return
+ result sets, but any function can be used.) This acts as
+ though the function's output were created as a temporary table for the
+ duration of this single SELECT command.
+ If the function's result type is composite (including the case of a
+ function with multiple OUT parameters), each
+ attribute becomes a separate column in the implicit table.
+
+ When the optional WITH ORDINALITY clause is added
+ to the function call, an additional column of type bigint
+ will be appended to the function's result column(s). This column
+ numbers the rows of the function's result set, starting from 1.
+ By default, this column is named ordinality.
+
+ An alias can be provided in the same way as for a table.
+ If an alias is written, a column
+ alias list can also be written to provide substitute names for
+ one or more attributes of the function's composite return
+ type, including the ordinality column if present.
+
+ Multiple function calls can be combined into a
+ single FROM-clause item by surrounding them
+ with ROWS FROM( ... ). The output of such an item is the
+ concatenation of the first row from each function, then the second
+ row from each function, etc. If some of the functions produce fewer
+ rows than others, null values are substituted for the missing data, so
+ that the total number of rows returned is always the same as for the
+ function that produced the most rows.
+
+ If the function has been defined as returning the
+ record data type, then an alias or the key word
+ AS must be present, followed by a column
+ definition list in the form ( column_name data_type [, ...
+ ]). The column definition list must match the
+ actual number and types of columns returned by the function.
+
+ When using the ROWS FROM( ... ) syntax, if one of the
+ functions requires a column definition list, it's preferred to put
+ the column definition list after the function call inside
+ ROWS FROM( ... ). A column definition list can be placed
+ after the ROWS FROM( ... ) construct only if there's just
+ a single function and no WITH ORDINALITY clause.
+
+ To use ORDINALITY together with a column definition
+ list, you must use the ROWS FROM( ... ) syntax and put the
+ column definition list inside ROWS FROM( ... ).
+
join_type
+ One of
+
[ INNER ] JOIN
LEFT [ OUTER ] JOIN
RIGHT [ OUTER ] JOIN
FULL [ OUTER ] JOIN
+
+ For the INNER and OUTER join types, a
+ join condition must be specified, namely exactly one of
+ ON join_condition,
+ USING (join_column [, ...]),
+ or NATURAL. See below for the meaning.
+
+ A JOIN clause combines two FROM
+ items, which for convenience we will refer to as “tables”,
+ though in reality they can be any type of FROM item.
+ Use parentheses if necessary to determine the order of nesting.
+ In the absence of parentheses, JOINs nest
+ left-to-right. In any case JOIN binds more
+ tightly than the commas separating FROM-list items.
+ All the JOIN options are just a notational
+ convenience, since they do nothing you couldn't do with plain
+ FROM and WHERE.
+
LEFT OUTER JOIN returns all rows in the qualified
+ Cartesian product (i.e., all combined rows that pass its join
+ condition), plus one copy of each row in the left-hand table
+ for which there was no right-hand row that passed the join
+ condition. This left-hand row is extended to the full width
+ of the joined table by inserting null values for the
+ right-hand columns. Note that only the JOIN
+ clause's own condition is considered while deciding which rows
+ have matches. Outer conditions are applied afterwards.
+
+ Conversely, RIGHT OUTER JOIN returns all the
+ joined rows, plus one row for each unmatched right-hand row
+ (extended with nulls on the left). This is just a notational
+ convenience, since you could convert it to a LEFT
+ OUTER JOIN by switching the left and right tables.
+
FULL OUTER JOIN returns all the joined rows, plus
+ one row for each unmatched left-hand row (extended with nulls
+ on the right), plus one row for each unmatched right-hand row
+ (extended with nulls on the left).
+
ON join_conditionjoin_condition is
+ an expression resulting in a value of type
+ boolean (similar to a WHERE
+ clause) that specifies which rows in a join are considered to
+ match.
+
USING ( join_column [, ...] ) [ AS join_using_alias ]
+ A clause of the form USING ( a, b, ... ) is
+ shorthand for ON left_table.a = right_table.a AND
+ left_table.b = right_table.b .... Also,
+ USING implies that only one of each pair of
+ equivalent columns will be included in the join output, not
+ both.
+
+ If a join_using_alias
+ name is specified, it provides a table alias for the join columns.
+ Only the join columns listed in the USING clause
+ are addressable by this name. Unlike a regular alias, this does not hide the names of
+ the joined tables from the rest of the query. Also unlike a regular
+ alias, you cannot write a
+ column alias list — the output names of the join columns are the
+ same as they appear in the USING list.
+
NATURAL
+ NATURAL is shorthand for a
+ USING list that mentions all columns in the two
+ tables that have matching names. If there are no common
+ column names, NATURAL is equivalent
+ to ON TRUE.
+
CROSS JOIN
+ CROSS JOIN is equivalent to INNER JOIN ON
+ (TRUE), that is, no rows are removed by qualification.
+ They produce a simple Cartesian product, the same result as you get from
+ listing the two tables at the top level of FROM,
+ but restricted by the join condition (if any).
+
LATERAL
+ The LATERAL key word can precede a
+ sub-SELECT FROM item. This allows the
+ sub-SELECT to refer to columns of FROM
+ items that appear before it in the FROM list. (Without
+ LATERAL, each sub-SELECT is
+ evaluated independently and so cannot cross-reference any other
+ FROM item.)
+
LATERAL can also precede a function-call
+ FROM item, but in this case it is a noise word, because
+ the function expression can refer to earlier FROM items
+ in any case.
+
+ A LATERAL item can appear at top level in the
+ FROM list, or within a JOIN tree. In the
+ latter case it can also refer to any items that are on the left-hand
+ side of a JOIN that it is on the right-hand side of.
+
+ When a FROM item contains LATERAL
+ cross-references, evaluation proceeds as follows: for each row of the
+ FROM item providing the cross-referenced column(s), or
+ set of rows of multiple FROM items providing the
+ columns, the LATERAL item is evaluated using that
+ row or row set's values of the columns. The resulting row(s) are
+ joined as usual with the rows they were computed from. This is
+ repeated for each row or set of rows from the column source table(s).
+
+ The column source table(s) must be INNER or
+ LEFT joined to the LATERAL item, else
+ there would not be a well-defined set of rows from which to compute
+ each set of rows for the LATERAL item. Thus,
+ although a construct such as X RIGHT JOIN
+ LATERAL YY to reference
+ X.
+
+
WHERE Clause
+ The optional WHERE clause has the general form
+
+WHERE condition
+
+ where condition is
+ any expression that evaluates to a result of type
+ boolean. Any row that does not satisfy this
+ condition will be eliminated from the output. A row satisfies the
+ condition if it returns true when the actual row values are
+ substituted for any variable references.
+
GROUP BY Clause
+ The optional GROUP BY clause has the general form
+
+GROUP BY [ ALL | DISTINCT ] grouping_element [, ...]
+
+
+ GROUP BY will condense into a single row all
+ selected rows that share the same values for the grouped
+ expressions. An expression used inside a
+ grouping_element
+ can be an input column name, or the name or ordinal number of an
+ output column (SELECT list item), or an arbitrary
+ expression formed from input-column values. In case of ambiguity,
+ a GROUP BY name will be interpreted as an
+ input-column name rather than an output column name.
+
+ If any of GROUPING SETS, ROLLUP or
+ CUBE are present as grouping elements, then the
+ GROUP BY clause as a whole defines some number of
+ independent grouping sets. The effect of this is
+ equivalent to constructing a UNION ALL between
+ subqueries with the individual grouping sets as their
+ GROUP BY clauses. The optional DISTINCT
+ clause removes duplicate sets before processing; it does not
+ transform the UNION ALL into a UNION DISTINCT.
+ For further details on the handling
+ of grouping sets see Section 7.2.4.
+
+ Aggregate functions, if any are used, are computed across all rows
+ making up each group, producing a separate value for each group.
+ (If there are aggregate functions but no GROUP BY
+ clause, the query is treated as having a single group comprising all
+ the selected rows.)
+ The set of rows fed to each aggregate function can be further filtered by
+ attaching a FILTER clause to the aggregate function
+ call; see Section 4.2.7 for more information. When
+ a FILTER clause is present, only those rows matching it
+ are included in the input to that aggregate function.
+
+ When GROUP BY is present,
+ or any aggregate functions are present, it is not valid for
+ the SELECT list expressions to refer to
+ ungrouped columns except within aggregate functions or when the
+ ungrouped column is functionally dependent on the grouped columns,
+ since there would otherwise be more than one possible value to
+ return for an ungrouped column. A functional dependency exists if
+ the grouped columns (or a subset thereof) are the primary key of
+ the table containing the ungrouped column.
+
+ Keep in mind that all aggregate functions are evaluated before
+ evaluating any “scalar” expressions in the HAVING
+ clause or SELECT list. This means that, for example,
+ a CASE expression cannot be used to skip evaluation of
+ an aggregate function; see Section 4.2.14.
+
+ Currently, FOR NO KEY UPDATE, FOR UPDATE,
+ FOR SHARE and FOR KEY SHARE cannot be
+ specified with GROUP BY.
+
HAVING Clause
+ The optional HAVING clause has the general form
+
+HAVING condition
+
+ where condition is
+ the same as specified for the WHERE clause.
+
+ HAVING eliminates group rows that do not
+ satisfy the condition. HAVING is different
+ from WHERE: WHERE filters
+ individual rows before the application of GROUP
+ BY, while HAVING filters group rows
+ created by GROUP BY. Each column referenced in
+ condition must
+ unambiguously reference a grouping column, unless the reference
+ appears within an aggregate function or the ungrouped column is
+ functionally dependent on the grouping columns.
+
+ The presence of HAVING turns a query into a grouped
+ query even if there is no GROUP BY clause. This is the
+ same as what happens when the query contains aggregate functions but
+ no GROUP BY clause. All the selected rows are considered to
+ form a single group, and the SELECT list and
+ HAVING clause can only reference table columns from
+ within aggregate functions. Such a query will emit a single row if the
+ HAVING condition is true, zero rows if it is not true.
+
+ Currently, FOR NO KEY UPDATE, FOR UPDATE,
+ FOR SHARE and FOR KEY SHARE cannot be
+ specified with HAVING.
+
WINDOW Clause
+ The optional WINDOW clause has the general form
+
+WINDOW window_name AS ( window_definition ) [, ...]
+
+ where window_name is
+ a name that can be referenced from OVER clauses or
+ subsequent window definitions, and
+ window_definition is
+
+[ existing_window_name ]
+[ PARTITION BY expression [, ...] ]
+[ ORDER BY expression [ ASC | DESC | USING operator ] [ NULLS { FIRST | LAST } ] [, ...] ]
+[ frame_clause ]
+
+
+ If an existing_window_name
+ is specified it must refer to an earlier entry in the WINDOW
+ list; the new window copies its partitioning clause from that entry,
+ as well as its ordering clause if any. In this case the new window cannot
+ specify its own PARTITION BY clause, and it can specify
+ ORDER BY only if the copied window does not have one.
+ The new window always uses its own frame clause; the copied window
+ must not specify a frame clause.
+
+ The elements of the PARTITION BY list are interpreted in
+ much the same fashion as elements of a GROUP BY clause, except that
+ they are always simple expressions and never the name or number of an
+ output column.
+ Another difference is that these expressions can contain aggregate
+ function calls, which are not allowed in a regular GROUP BY
+ clause. They are allowed here because windowing occurs after grouping
+ and aggregation.
+
+ Similarly, the elements of the ORDER BY list are interpreted
+ in much the same fashion as elements of a statement-level ORDER BY clause, except that
+ the expressions are always taken as simple expressions and never the name
+ or number of an output column.
+
+ The optional frame_clause defines
+ the window frame for window functions that depend on the
+ frame (not all do). The window frame is a set of related rows for
+ each row of the query (called the current row).
+ The frame_clause can be one of
+
+
+{ RANGE | ROWS | GROUPS } frame_start [ frame_exclusion ]
+{ RANGE | ROWS | GROUPS } BETWEEN frame_start AND frame_end [ frame_exclusion ]
+
+
+ where frame_start
+ and frame_end can be one of
+
+
+UNBOUNDED PRECEDING
+offset PRECEDING
+CURRENT ROW
+offset FOLLOWING
+UNBOUNDED FOLLOWING
+
+
+ and frame_exclusion can be one of
+
+
+EXCLUDE CURRENT ROW
+EXCLUDE GROUP
+EXCLUDE TIES
+EXCLUDE NO OTHERS
+
+
+ If frame_end is omitted it defaults to CURRENT
+ ROW. Restrictions are that
+ frame_start cannot be UNBOUNDED FOLLOWING,
+ frame_end cannot be UNBOUNDED PRECEDING,
+ and the frame_end choice cannot appear earlier in the
+ above list of frame_start
+ and frame_end options than
+ the frame_start choice does — for example
+ RANGE BETWEEN CURRENT ROW AND offset
+ PRECEDING is not allowed.
+
+ The default framing option is RANGE UNBOUNDED PRECEDING,
+ which is the same as RANGE BETWEEN UNBOUNDED PRECEDING AND
+ CURRENT ROW; it sets the frame to be all rows from the partition start
+ up through the current row's last peer (a row
+ that the window's ORDER BY clause considers
+ equivalent to the current row; all rows are peers if there
+ is no ORDER BY).
+ In general, UNBOUNDED PRECEDING means that the frame
+ starts with the first row of the partition, and similarly
+ UNBOUNDED FOLLOWING means that the frame ends with the last
+ row of the partition, regardless
+ of RANGE, ROWS
+ or GROUPS mode.
+ In ROWS mode, CURRENT ROW means
+ that the frame starts or ends with the current row; but
+ in RANGE or GROUPS mode it means
+ that the frame starts or ends with the current row's first or last peer
+ in the ORDER BY ordering.
+ The offset PRECEDING and
+ offset FOLLOWING options
+ vary in meaning depending on the frame mode.
+ In ROWS mode, the offset
+ is an integer indicating that the frame starts or ends that many rows
+ before or after the current row.
+ In GROUPS mode, the offset
+ is an integer indicating that the frame starts or ends that many peer
+ groups before or after the current row's peer group, where
+ a peer group is a group of rows that are
+ equivalent according to the window's ORDER BY clause.
+ In RANGE mode, use of
+ an offset option requires that there be
+ exactly one ORDER BY column in the window definition.
+ Then the frame contains those rows whose ordering column value is no
+ more than offset less than
+ (for PRECEDING) or more than
+ (for FOLLOWING) the current row's ordering column
+ value. In these cases the data type of
+ the offset expression depends on the data
+ type of the ordering column. For numeric ordering columns it is
+ typically of the same type as the ordering column, but for datetime
+ ordering columns it is an interval.
+ In all these cases, the value of the offset
+ must be non-null and non-negative. Also, while
+ the offset does not have to be a simple
+ constant, it cannot contain variables, aggregate functions, or window
+ functions.
+
+ The frame_exclusion option allows rows around
+ the current row to be excluded from the frame, even if they would be
+ included according to the frame start and frame end options.
+ EXCLUDE CURRENT ROW excludes the current row from the
+ frame.
+ EXCLUDE GROUP excludes the current row and its
+ ordering peers from the frame.
+ EXCLUDE TIES excludes any peers of the current
+ row from the frame, but not the current row itself.
+ EXCLUDE NO OTHERS simply specifies explicitly the
+ default behavior of not excluding the current row or its peers.
+
+ Beware that the ROWS mode can produce unpredictable
+ results if the ORDER BY ordering does not order the rows
+ uniquely. The RANGE and GROUPS
+ modes are designed to ensure that rows that are peers in
+ the ORDER BY ordering are treated alike: all rows of
+ a given peer group will be in the frame or excluded from it.
+
+ The purpose of a WINDOW clause is to specify the
+ behavior of window functions appearing in the query's
+ SELECT list or
+ ORDER BY clause.
+ These functions
+ can reference the WINDOW clause entries by name
+ in their OVER clauses. A WINDOW clause
+ entry does not have to be referenced anywhere, however; if it is not
+ used in the query it is simply ignored. It is possible to use window
+ functions without any WINDOW clause at all, since
+ a window function call can specify its window definition directly in
+ its OVER clause. However, the WINDOW
+ clause saves typing when the same window definition is needed for more
+ than one window function.
+
+ Currently, FOR NO KEY UPDATE, FOR UPDATE,
+ FOR SHARE and FOR KEY SHARE cannot be
+ specified with WINDOW.
+
+ Window functions are described in detail in
+ Section 3.5,
+ Section 4.2.8, and
+ Section 7.2.5.
+
SELECT List
+ The SELECT list (between the key words
+ SELECT and FROM) specifies expressions
+ that form the output rows of the SELECT
+ statement. The expressions can (and usually do) refer to columns
+ computed in the FROM clause.
+
+ Just as in a table, every output column of a SELECT
+ has a name. In a simple SELECT this name is just
+ used to label the column for display, but when the SELECT
+ is a sub-query of a larger query, the name is seen by the larger query
+ as the column name of the virtual table produced by the sub-query.
+ To specify the name to use for an output column, write
+ AS output_name
+ after the column's expression. (You can omit AS,
+ but only if the desired output name does not match any
+ PostgreSQL keyword (see Appendix C). For protection against possible
+ future keyword additions, it is recommended that you always either
+ write AS or double-quote the output name.)
+ If you do not specify a column name, a name is chosen automatically
+ by PostgreSQL. If the column's expression
+ is a simple column reference then the chosen name is the same as that
+ column's name. In more complex cases a function or type name may be
+ used, or the system may fall back on a generated name such as
+ ?column?.
+
+ An output column's name can be used to refer to the column's value in
+ ORDER BY and GROUP BY clauses, but not in the
+ WHERE or HAVING clauses; there you must write
+ out the expression instead.
+
+ Instead of an expression, * can be written in
+ the output list as a shorthand for all the columns of the selected
+ rows. Also, you can write table_name.*AS;
+ the output column names will be the same as the table columns' names.
+
+ According to the SQL standard, the expressions in the output list should
+ be computed before applying DISTINCT, ORDER
+ BY, or LIMIT. This is obviously necessary
+ when using DISTINCT, since otherwise it's not clear
+ what values are being made distinct. However, in many cases it is
+ convenient if output expressions are computed after ORDER
+ BY and LIMIT; particularly if the output list
+ contains any volatile or expensive functions. With that behavior, the
+ order of function evaluations is more intuitive and there will not be
+ evaluations corresponding to rows that never appear in the output.
+ PostgreSQL will effectively evaluate output expressions
+ after sorting and limiting, so long as those expressions are not
+ referenced in DISTINCT, ORDER BY
+ or GROUP BY. (As a counterexample, SELECT
+ f(x) FROM tab ORDER BY 1 clearly must evaluate f(x)
+ before sorting.) Output expressions that contain set-returning functions
+ are effectively evaluated after sorting and before limiting, so
+ that LIMIT will act to cut off the output from a
+ set-returning function.
+
Note
+ PostgreSQL versions before 9.6 did not provide any
+ guarantees about the timing of evaluation of output expressions versus
+ sorting and limiting; it depended on the form of the chosen query plan.
+
DISTINCT Clause
+ If SELECT DISTINCT is specified, all duplicate rows are
+ removed from the result set (one row is kept from each group of
+ duplicates). SELECT ALL specifies the opposite: all rows are
+ kept; that is the default.
+
+ SELECT DISTINCT ON ( expression [, ...] )
+ keeps only the first row of each set of rows where the given
+ expressions evaluate to equal. The DISTINCT ON
+ expressions are interpreted using the same rules as for
+ ORDER BY (see above). Note that the “first
+ row” of each set is unpredictable unless ORDER
+ BY is used to ensure that the desired row appears first. For
+ example:
+
+SELECT DISTINCT ON (location) location, time, report
+ FROM weather_reports
+ ORDER BY location, time DESC;
+
+ retrieves the most recent weather report for each location. But
+ if we had not used ORDER BY to force descending order
+ of time values for each location, we'd have gotten a report from
+ an unpredictable time for each location.
+
+ The DISTINCT ON expression(s) must match the leftmost
+ ORDER BY expression(s). The ORDER BY clause
+ will normally contain additional expression(s) that determine the
+ desired precedence of rows within each DISTINCT ON group.
+
+ Currently, FOR NO KEY UPDATE, FOR UPDATE,
+ FOR SHARE and FOR KEY SHARE cannot be
+ specified with DISTINCT.
+
UNION Clause
+ The UNION clause has this general form:
+
+select_statement UNION [ ALL | DISTINCT ] select_statement
+
select_statement is
+ any SELECT statement without an ORDER
+ BY, LIMIT, FOR NO KEY UPDATE, FOR UPDATE,
+ FOR SHARE, or FOR KEY SHARE clause.
+ (ORDER BY and LIMIT can be attached to a
+ subexpression if it is enclosed in parentheses. Without
+ parentheses, these clauses will be taken to apply to the result of
+ the UNION, not to its right-hand input
+ expression.)
+
+ The UNION operator computes the set union of
+ the rows returned by the involved SELECT
+ statements. A row is in the set union of two result sets if it
+ appears in at least one of the result sets. The two
+ SELECT statements that represent the direct
+ operands of the UNION must produce the same
+ number of columns, and corresponding columns must be of compatible
+ data types.
+
+ The result of UNION does not contain any duplicate
+ rows unless the ALL option is specified.
+ ALL prevents elimination of duplicates. (Therefore,
+ UNION ALL is usually significantly quicker than
+ UNION; use ALL when you can.)
+ DISTINCT can be written to explicitly specify the
+ default behavior of eliminating duplicate rows.
+
+ Multiple UNION operators in the same
+ SELECT statement are evaluated left to right,
+ unless otherwise indicated by parentheses.
+
+ Currently, FOR NO KEY UPDATE, FOR UPDATE, FOR SHARE and
+ FOR KEY SHARE cannot be
+ specified either for a UNION result or for any input of a
+ UNION.
+
INTERSECT Clause
+ The INTERSECT clause has this general form:
+
+select_statement INTERSECT [ ALL | DISTINCT ] select_statement
+
select_statement is
+ any SELECT statement without an ORDER
+ BY, LIMIT, FOR NO KEY UPDATE, FOR UPDATE,
+ FOR SHARE, or FOR KEY SHARE clause.
+
+ The INTERSECT operator computes the set
+ intersection of the rows returned by the involved
+ SELECT statements. A row is in the
+ intersection of two result sets if it appears in both result sets.
+
+ The result of INTERSECT does not contain any
+ duplicate rows unless the ALL option is specified.
+ With ALL, a row that has m duplicates in the
+ left table and n duplicates in the right table will appear
+ min(m,n) times in the result set.
+ DISTINCT can be written to explicitly specify the
+ default behavior of eliminating duplicate rows.
+
+ Multiple INTERSECT operators in the same
+ SELECT statement are evaluated left to right,
+ unless parentheses dictate otherwise.
+ INTERSECT binds more tightly than
+ UNION. That is, A UNION B INTERSECT
+ C will be read as A UNION (B INTERSECT
+ C).
+
+ Currently, FOR NO KEY UPDATE, FOR UPDATE, FOR SHARE and
+ FOR KEY SHARE cannot be
+ specified either for an INTERSECT result or for any input of
+ an INTERSECT.
+
EXCEPT Clause
+ The EXCEPT clause has this general form:
+
+select_statement EXCEPT [ ALL | DISTINCT ] select_statement
+
select_statement is
+ any SELECT statement without an ORDER
+ BY, LIMIT, FOR NO KEY UPDATE, FOR UPDATE,
+ FOR SHARE, or FOR KEY SHARE clause.
+
+ The EXCEPT operator computes the set of rows
+ that are in the result of the left SELECT
+ statement but not in the result of the right one.
+
+ The result of EXCEPT does not contain any
+ duplicate rows unless the ALL option is specified.
+ With ALL, a row that has m duplicates in the
+ left table and n duplicates in the right table will appear
+ max(m-n,0) times in the result set.
+ DISTINCT can be written to explicitly specify the
+ default behavior of eliminating duplicate rows.
+
+ Multiple EXCEPT operators in the same
+ SELECT statement are evaluated left to right,
+ unless parentheses dictate otherwise. EXCEPT binds at
+ the same level as UNION.
+
+ Currently, FOR NO KEY UPDATE, FOR UPDATE, FOR SHARE and
+ FOR KEY SHARE cannot be
+ specified either for an EXCEPT result or for any input of
+ an EXCEPT.
+
ORDER BY Clause
+ The optional ORDER BY clause has this general form:
+
+ORDER BY expression [ ASC | DESC | USING operator ] [ NULLS { FIRST | LAST } ] [, ...]
+
+ The ORDER BY clause causes the result rows to
+ be sorted according to the specified expression(s). If two rows are
+ equal according to the leftmost expression, they are compared
+ according to the next expression and so on. If they are equal
+ according to all specified expressions, they are returned in
+ an implementation-dependent order.
+
+ Each expression can be the
+ name or ordinal number of an output column
+ (SELECT list item), or it can be an arbitrary
+ expression formed from input-column values.
+
+ The ordinal number refers to the ordinal (left-to-right) position
+ of the output column. This feature makes it possible to define an
+ ordering on the basis of a column that does not have a unique
+ name. This is never absolutely necessary because it is always
+ possible to assign a name to an output column using the
+ AS clause.
+
+ It is also possible to use arbitrary expressions in the
+ ORDER BY clause, including columns that do not
+ appear in the SELECT output list. Thus the
+ following statement is valid:
+
+SELECT name FROM distributors ORDER BY code;
+
+ A limitation of this feature is that an ORDER BY
+ clause applying to the result of a UNION,
+ INTERSECT, or EXCEPT clause can only
+ specify an output column name or number, not an expression.
+
+ If an ORDER BY expression is a simple name that
+ matches both an output column name and an input column name,
+ ORDER BY will interpret it as the output column name.
+ This is the opposite of the choice that GROUP BY will
+ make in the same situation. This inconsistency is made to be
+ compatible with the SQL standard.
+
+ Optionally one can add the key word ASC (ascending) or
+ DESC (descending) after any expression in the
+ ORDER BY clause. If not specified, ASC is
+ assumed by default. Alternatively, a specific ordering operator
+ name can be specified in the USING clause.
+ An ordering operator must be a less-than or greater-than
+ member of some B-tree operator family.
+ ASC is usually equivalent to USING < and
+ DESC is usually equivalent to USING >.
+ (But the creator of a user-defined data type can define exactly what the
+ default sort ordering is, and it might correspond to operators with other
+ names.)
+
+ If NULLS LAST is specified, null values sort after all
+ non-null values; if NULLS FIRST is specified, null values
+ sort before all non-null values. If neither is specified, the default
+ behavior is NULLS LAST when ASC is specified
+ or implied, and NULLS FIRST when DESC is specified
+ (thus, the default is to act as though nulls are larger than non-nulls).
+ When USING is specified, the default nulls ordering depends
+ on whether the operator is a less-than or greater-than operator.
+
+ Note that ordering options apply only to the expression they follow;
+ for example ORDER BY x, y DESC does not mean
+ the same thing as ORDER BY x DESC, y DESC.
+
+ Character-string data is sorted according to the collation that applies
+ to the column being sorted. That can be overridden at need by including
+ a COLLATE clause in the
+ expression, for example
+ ORDER BY mycolumn COLLATE "en_US".
+ For more information see Section 4.2.10 and
+ Section 24.2.
+
LIMIT Clause
+ The LIMIT clause consists of two independent
+ sub-clauses:
+
+LIMIT { count | ALL }
+OFFSET start
+
+ The parameter count specifies the
+ maximum number of rows to return, while start specifies the number of rows
+ to skip before starting to return rows. When both are specified,
+ start rows are skipped
+ before starting to count the count rows to be returned.
+
+ If the count expression
+ evaluates to NULL, it is treated as LIMIT ALL, i.e., no
+ limit. If start evaluates
+ to NULL, it is treated the same as OFFSET 0.
+
+ SQL:2008 introduced a different syntax to achieve the same result,
+ which PostgreSQL also supports. It is:
+
+OFFSET start { ROW | ROWS }
+FETCH { FIRST | NEXT } [ count ] { ROW | ROWS } { ONLY | WITH TIES }
+
+ In this syntax, the start
+ or count value is required by
+ the standard to be a literal constant, a parameter, or a variable name;
+ as a PostgreSQL extension, other expressions
+ are allowed, but will generally need to be enclosed in parentheses to avoid
+ ambiguity.
+ If count is
+ omitted in a FETCH clause, it defaults to 1.
+ The WITH TIES option is used to return any additional
+ rows that tie for the last place in the result set according to
+ the ORDER BY clause; ORDER BY
+ is mandatory in this case, and SKIP LOCKED is
+ not allowed.
+ ROW and ROWS as well as
+ FIRST and NEXT are noise
+ words that don't influence the effects of these clauses.
+ According to the standard, the OFFSET clause must come
+ before the FETCH clause if both are present; but
+ PostgreSQL is laxer and allows either order.
+
+ When using LIMIT, it is a good idea to use an
+ ORDER BY clause that constrains the result rows into a
+ unique order. Otherwise you will get an unpredictable subset of
+ the query's rows — you might be asking for the tenth through
+ twentieth rows, but tenth through twentieth in what ordering? You
+ don't know what ordering unless you specify ORDER BY.
+
+ The query planner takes LIMIT into account when
+ generating a query plan, so you are very likely to get different
+ plans (yielding different row orders) depending on what you use
+ for LIMIT and OFFSET. Thus, using
+ different LIMIT/OFFSET values to select
+ different subsets of a query result will give
+ inconsistent results unless you enforce a predictable
+ result ordering with ORDER BY. This is not a bug; it
+ is an inherent consequence of the fact that SQL does not promise
+ to deliver the results of a query in any particular order unless
+ ORDER BY is used to constrain the order.
+
+ It is even possible for repeated executions of the same LIMIT
+ query to return different subsets of the rows of a table, if there
+ is not an ORDER BY to enforce selection of a deterministic
+ subset. Again, this is not a bug; determinism of the results is
+ simply not guaranteed in such a case.
+
The Locking Clause
+ FOR UPDATE, FOR NO KEY UPDATE, FOR SHARE
+ and FOR KEY SHARE
+ are locking clauses; they affect how SELECT
+ locks rows as they are obtained from the table.
+
+ The locking clause has the general form
+
+
+FOR lock_strength [ OF table_name [, ...] ] [ NOWAIT | SKIP LOCKED ]
+
+
+ where lock_strength can be one of
+
+
+UPDATE
+NO KEY UPDATE
+SHARE
+KEY SHARE
+
+
+ For more information on each row-level lock mode, refer to
+ Section 13.3.2.
+
+ To prevent the operation from waiting for other transactions to commit,
+ use either the NOWAIT or SKIP LOCKED
+ option. With NOWAIT, the statement reports an error, rather
+ than waiting, if a selected row cannot be locked immediately.
+ With SKIP LOCKED, any selected rows that cannot be
+ immediately locked are skipped. Skipping locked rows provides an
+ inconsistent view of the data, so this is not suitable for general purpose
+ work, but can be used to avoid lock contention with multiple consumers
+ accessing a queue-like table.
+ Note that NOWAIT and SKIP LOCKED apply only
+ to the row-level lock(s) — the required ROW SHARE
+ table-level lock is still taken in the ordinary way (see
+ Chapter 13). You can use
+ LOCK
+ with the NOWAIT option first,
+ if you need to acquire the table-level lock without waiting.
+
+ If specific tables are named in a locking clause,
+ then only rows coming from those tables are locked; any other
+ tables used in the SELECT are simply read as
+ usual. A locking
+ clause without a table list affects all tables used in the statement.
+ If a locking clause is
+ applied to a view or sub-query, it affects all tables used in
+ the view or sub-query.
+ However, these clauses
+ do not apply to WITH queries referenced by the primary query.
+ If you want row locking to occur within a WITH query, specify
+ a locking clause within the WITH query.
+
+ Multiple locking
+ clauses can be written if it is necessary to specify different locking
+ behavior for different tables. If the same table is mentioned (or
+ implicitly affected) by more than one locking clause,
+ then it is processed as if it was only specified by the strongest one.
+ Similarly, a table is processed
+ as NOWAIT if that is specified in any of the clauses
+ affecting it. Otherwise, it is processed
+ as SKIP LOCKED if that is specified in any of the
+ clauses affecting it.
+
+ The locking clauses cannot be
+ used in contexts where returned rows cannot be clearly identified with
+ individual table rows; for example they cannot be used with aggregation.
+
+ When a locking clause
+ appears at the top level of a SELECT query, the rows that
+ are locked are exactly those that are returned by the query; in the
+ case of a join query, the rows locked are those that contribute to
+ returned join rows. In addition, rows that satisfied the query
+ conditions as of the query snapshot will be locked, although they
+ will not be returned if they were updated after the snapshot
+ and no longer satisfy the query conditions. If a
+ LIMIT is used, locking stops
+ once enough rows have been returned to satisfy the limit (but note that
+ rows skipped over by OFFSET will get locked). Similarly,
+ if a locking clause
+ is used in a cursor's query, only rows actually fetched or stepped past
+ by the cursor will be locked.
+
+ When a locking clause
+ appears in a sub-SELECT, the rows locked are those
+ returned to the outer query by the sub-query. This might involve
+ fewer rows than inspection of the sub-query alone would suggest,
+ since conditions from the outer query might be used to optimize
+ execution of the sub-query. For example,
+
+SELECT * FROM (SELECT * FROM mytable FOR UPDATE) ss WHERE col1 = 5;
+
+ will lock only rows having col1 = 5, even though that
+ condition is not textually within the sub-query.
+
+ Previous releases failed to preserve a lock which is upgraded by a later
+ savepoint. For example, this code:
+
+BEGIN;
+SELECT * FROM mytable WHERE key = 1 FOR UPDATE;
+SAVEPOINT s;
+UPDATE mytable SET ... WHERE key = 1;
+ROLLBACK TO s;
+
+ would fail to preserve the FOR UPDATE lock after the
+ ROLLBACK TO. This has been fixed in release 9.3.
+
Caution
+ It is possible for a SELECT command running at the READ
+ COMMITTED transaction isolation level and using ORDER
+ BY and a locking clause to return rows out of
+ order. This is because ORDER BY is applied first.
+ The command sorts the result, but might then block trying to obtain a lock
+ on one or more of the rows. Once the SELECT unblocks, some
+ of the ordering column values might have been modified, leading to those
+ rows appearing to be out of order (though they are in order in terms
+ of the original column values). This can be worked around at need by
+ placing the FOR UPDATE/SHARE clause in a sub-query,
+ for example
+
+SELECT * FROM (SELECT * FROM mytable FOR UPDATE) ss ORDER BY column1;
+
+ Note that this will result in locking all rows of mytable,
+ whereas FOR UPDATE at the top level would lock only the
+ actually returned rows. This can make for a significant performance
+ difference, particularly if the ORDER BY is combined with
+ LIMIT or other restrictions. So this technique is recommended
+ only if concurrent updates of the ordering columns are expected and a
+ strictly sorted result is required.
+
+ At the REPEATABLE READ or SERIALIZABLE
+ transaction isolation level this would cause a serialization failure (with
+ an SQLSTATE of '40001'), so there is
+ no possibility of receiving rows out of order under these isolation levels.
+
TABLE Command
+ The command
+
+TABLE name
+
+ is equivalent to
+
+SELECT * FROM name
+
+ It can be used as a top-level command or as a space-saving syntax
+ variant in parts of complex queries. Only the WITH,
+ UNION, INTERSECT, EXCEPT,
+ ORDER BY, LIMIT, OFFSET,
+ FETCH and FOR locking clauses can be used
+ with TABLE; the WHERE clause and any form of
+ aggregation cannot
+ be used.
+
Examples
+ To join the table films with the table
+ distributors:
+
+
+SELECT f.title, f.did, d.name, f.date_prod, f.kind
+ FROM distributors d JOIN films f USING (did);
+
+ title | did | name | date_prod | kind
+-------------------+-----+--------------+------------+----------
+ The Third Man | 101 | British Lion | 1949-12-23 | Drama
+ The African Queen | 101 | British Lion | 1951-08-11 | Romantic
+ ...
+
+
+ To sum the column len of all films and group
+ the results by kind:
+
+
+SELECT kind, sum(len) AS total FROM films GROUP BY kind;
+
+ kind | total
+----------+-------
+ Action | 07:34
+ Comedy | 02:58
+ Drama | 14:28
+ Musical | 06:42
+ Romantic | 04:38
+
+
+ To sum the column len of all films, group
+ the results by kind and show those group totals
+ that are less than 5 hours:
+
+
+SELECT kind, sum(len) AS total
+ FROM films
+ GROUP BY kind
+ HAVING sum(len) < interval '5 hours';
+
+ kind | total
+----------+-------
+ Comedy | 02:58
+ Romantic | 04:38
+
+
+ The following two examples are identical ways of sorting the individual
+ results according to the contents of the second column
+ (name):
+
+
+SELECT * FROM distributors ORDER BY name;
+SELECT * FROM distributors ORDER BY 2;
+
+ did | name
+-----+------------------
+ 109 | 20th Century Fox
+ 110 | Bavaria Atelier
+ 101 | British Lion
+ 107 | Columbia
+ 102 | Jean Luc Godard
+ 113 | Luso films
+ 104 | Mosfilm
+ 103 | Paramount
+ 106 | Toho
+ 105 | United Artists
+ 111 | Walt Disney
+ 112 | Warner Bros.
+ 108 | Westward
+
+
+ The next example shows how to obtain the union of the tables
+ distributors and
+ actors, restricting the results to those that begin
+ with the letter W in each table. Only distinct rows are wanted, so the
+ key word ALL is omitted.
+
+
+distributors: actors:
+ did | name id | name
+-----+-------------- ----+----------------
+ 108 | Westward 1 | Woody Allen
+ 111 | Walt Disney 2 | Warren Beatty
+ 112 | Warner Bros. 3 | Walter Matthau
+ ... ...
+
+SELECT distributors.name
+ FROM distributors
+ WHERE distributors.name LIKE 'W%'
+UNION
+SELECT actors.name
+ FROM actors
+ WHERE actors.name LIKE 'W%';
+
+ name
+----------------
+ Walt Disney
+ Walter Matthau
+ Warner Bros.
+ Warren Beatty
+ Westward
+ Woody Allen
+
+
+ This example shows how to use a function in the FROM
+ clause, both with and without a column definition list:
+
+
+CREATE FUNCTION distributors(int) RETURNS SETOF distributors AS $$
+ SELECT * FROM distributors WHERE did = $1;
+$$ LANGUAGE SQL;
+
+SELECT * FROM distributors(111);
+ did | name
+-----+-------------
+ 111 | Walt Disney
+
+CREATE FUNCTION distributors_2(int) RETURNS SETOF record AS $$
+ SELECT * FROM distributors WHERE did = $1;
+$$ LANGUAGE SQL;
+
+SELECT * FROM distributors_2(111) AS (f1 int, f2 text);
+ f1 | f2
+-----+-------------
+ 111 | Walt Disney
+
+
+ Here is an example of a function with an ordinality column added:
+
+
+SELECT * FROM unnest(ARRAY['a','b','c','d','e','f']) WITH ORDINALITY;
+ unnest | ordinality
+--------+----------
+ a | 1
+ b | 2
+ c | 3
+ d | 4
+ e | 5
+ f | 6
+(6 rows)
+
+
+ This example shows how to use a simple WITH clause:
+
+
+WITH t AS (
+ SELECT random() as x FROM generate_series(1, 3)
+ )
+SELECT * FROM t
+UNION ALL
+SELECT * FROM t;
+ x
+--------------------
+ 0.534150459803641
+ 0.520092216785997
+ 0.0735620250925422
+ 0.534150459803641
+ 0.520092216785997
+ 0.0735620250925422
+
+
+ Notice that the WITH query was evaluated only once,
+ so that we got two sets of the same three random values.
+
+ This example uses WITH RECURSIVE to find all
+ subordinates (direct or indirect) of the employee Mary, and their
+ level of indirectness, from a table that shows only direct
+ subordinates:
+
+
+WITH RECURSIVE employee_recursive(distance, employee_name, manager_name) AS (
+ SELECT 1, employee_name, manager_name
+ FROM employee
+ WHERE manager_name = 'Mary'
+ UNION ALL
+ SELECT er.distance + 1, e.employee_name, e.manager_name
+ FROM employee_recursive er, employee e
+ WHERE er.employee_name = e.manager_name
+ )
+SELECT distance, employee_name FROM employee_recursive;
+
+
+ Notice the typical form of recursive queries:
+ an initial condition, followed by UNION,
+ followed by the recursive part of the query. Be sure that the
+ recursive part of the query will eventually return no tuples, or
+ else the query will loop indefinitely. (See Section 7.8
+ for more examples.)
+
+ This example uses LATERAL to apply a set-returning function
+ get_product_names() for each row of the
+ manufacturers table:
+
+
+SELECT m.name AS mname, pname
+FROM manufacturers m, LATERAL get_product_names(m.id) pname;
+
+
+ Manufacturers not currently having any products would not appear in the
+ result, since it is an inner join. If we wished to include the names of
+ such manufacturers in the result, we could do:
+
+
+SELECT m.name AS mname, pname
+FROM manufacturers m LEFT JOIN LATERAL get_product_names(m.id) pname ON true;
+
Compatibility
+ Of course, the SELECT statement is compatible
+ with the SQL standard. But there are some extensions and some
+ missing features.
+
Omitted FROM Clauses
+ PostgreSQL allows one to omit the
+ FROM clause. It has a straightforward use to
+ compute the results of simple expressions:
+
+SELECT 2+2;
+
+ ?column?
+----------
+ 4
+
+ Some other SQL databases cannot do this except
+ by introducing a dummy one-row table from which to do the
+ SELECT.
+
Empty SELECT Lists
+ The list of output expressions after SELECT can be
+ empty, producing a zero-column result table.
+ This is not valid syntax according to the SQL standard.
+ PostgreSQL allows it to be consistent with
+ allowing zero-column tables.
+ However, an empty list is not allowed when DISTINCT is used.
+
Omitting the AS Key Word
+ In the SQL standard, the optional key word AS can be
+ omitted before an output column name whenever the new column name
+ is a valid column name (that is, not the same as any reserved
+ keyword). PostgreSQL is slightly more
+ restrictive: AS is required if the new column name
+ matches any keyword at all, reserved or not. Recommended practice is
+ to use AS or double-quote output column names, to prevent
+ any possible conflict against future keyword additions.
+
+ In FROM items, both the standard and
+ PostgreSQL allow AS to
+ be omitted before an alias that is an unreserved keyword. But
+ this is impractical for output column names, because of syntactic
+ ambiguities.
+
Omitting Sub-SELECT Aliases in FROM
+ According to the SQL standard, a sub-SELECT in the
+ FROM list must have an alias. In
+ PostgreSQL, this alias may be omitted.
+
ONLY and Inheritance
+ The SQL standard requires parentheses around the table name when
+ writing ONLY, for example SELECT * FROM ONLY
+ (tab1), ONLY (tab2) WHERE .... PostgreSQL
+ considers these parentheses to be optional.
+
+ PostgreSQL allows a trailing * to be written to
+ explicitly specify the non-ONLY behavior of including
+ child tables. The standard does not allow this.
+
+ (These points apply equally to all SQL commands supporting the
+ ONLY option.)
+
TABLESAMPLE Clause Restrictions
+ The TABLESAMPLE clause is currently accepted only on
+ regular tables and materialized views. According to the SQL standard
+ it should be possible to apply it to any FROM item.
+
Function Calls in FROM
+ PostgreSQL allows a function call to be
+ written directly as a member of the FROM list. In the SQL
+ standard it would be necessary to wrap such a function call in a
+ sub-SELECT; that is, the syntax
+ FROM func(...) alias
+ is approximately equivalent to
+ FROM LATERAL (SELECT func(...)) alias.
+ Note that LATERAL is considered to be implicit; this is
+ because the standard requires LATERAL semantics for an
+ UNNEST() item in FROM.
+ PostgreSQL treats UNNEST() the
+ same as other set-returning functions.
+
Namespace Available to GROUP BY and ORDER BY
+ In the SQL-92 standard, an ORDER BY clause can
+ only use output column names or numbers, while a GROUP
+ BY clause can only use expressions based on input column
+ names. PostgreSQL extends each of
+ these clauses to allow the other choice as well (but it uses the
+ standard's interpretation if there is ambiguity).
+ PostgreSQL also allows both clauses to
+ specify arbitrary expressions. Note that names appearing in an
+ expression will always be taken as input-column names, not as
+ output-column names.
+
+ SQL:1999 and later use a slightly different definition which is not
+ entirely upward compatible with SQL-92.
+ In most cases, however, PostgreSQL
+ will interpret an ORDER BY or GROUP
+ BY expression the same way SQL:1999 does.
+
Functional Dependencies
+ PostgreSQL recognizes functional dependency
+ (allowing columns to be omitted from GROUP BY) only when
+ a table's primary key is included in the GROUP BY list.
+ The SQL standard specifies additional conditions that should be
+ recognized.
+
LIMIT and OFFSET
+ The clauses LIMIT and OFFSET
+ are PostgreSQL-specific syntax, also
+ used by MySQL. The SQL:2008 standard
+ has introduced the clauses OFFSET ... FETCH {FIRST|NEXT}
+ ... for the same functionality, as shown above
+ in LIMIT Clause. This
+ syntax is also used by IBM DB2.
+ (Applications written for Oracle
+ frequently use a workaround involving the automatically
+ generated rownum column, which is not available in
+ PostgreSQL, to implement the effects of these clauses.)
+
FOR NO KEY UPDATE, FOR UPDATE, FOR SHARE, FOR KEY SHARE
+ Although FOR UPDATE appears in the SQL standard, the
+ standard allows it only as an option of DECLARE CURSOR.
+ PostgreSQL allows it in any SELECT
+ query as well as in sub-SELECTs, but this is an extension.
+ The FOR NO KEY UPDATE, FOR SHARE and
+ FOR KEY SHARE variants, as well as the NOWAIT
+ and SKIP LOCKED options, do not appear in the
+ standard.
+
Data-Modifying Statements in WITH
+ PostgreSQL allows INSERT,
+ UPDATE, and DELETE to be used as WITH
+ queries. This is not found in the SQL standard.
+
Nonstandard Clauses
+ DISTINCT ON ( ... ) is an extension of the
+ SQL standard.
+
+ ROWS FROM( ... ) is an extension of the SQL standard.
+
+ The MATERIALIZED and NOT
+ MATERIALIZED options of WITH are extensions
+ of the SQL standard.
+
SELECT INTO
SELECT INTO — define a new table from the results of a query
Synopsis
+[ WITH [ RECURSIVE ] with_query [, ...] ]
+SELECT [ ALL | DISTINCT [ ON ( expression [, ...] ) ] ]
+ * | expression [ [ AS ] output_name ] [, ...]
+ INTO [ TEMPORARY | TEMP | UNLOGGED ] [ TABLE ] new_table
+ [ FROM from_item [, ...] ]
+ [ WHERE condition ]
+ [ GROUP BY expression [, ...] ]
+ [ HAVING condition ]
+ [ WINDOW window_name AS ( window_definition ) [, ...] ]
+ [ { UNION | INTERSECT | EXCEPT } [ ALL | DISTINCT ] select ]
+ [ ORDER BY expression [ ASC | DESC | USING operator ] [ NULLS { FIRST | LAST } ] [, ...] ]
+ [ LIMIT { count | ALL } ]
+ [ OFFSET start [ ROW | ROWS ] ]
+ [ FETCH { FIRST | NEXT } [ count ] { ROW | ROWS } ONLY ]
+ [ FOR { UPDATE | SHARE } [ OF table_name [, ...] ] [ NOWAIT ] [...] ]
+
Description
+ SELECT INTO creates a new table and fills it
+ with data computed by a query. The data is not returned to the
+ client, as it is with a normal SELECT. The new
+ table's columns have the names and data types associated with the
+ output columns of the SELECT.
+
Parameters
TEMPORARY or TEMP
+ If specified, the table is created as a temporary table. Refer
+ to CREATE TABLE for details.
+
UNLOGGED
+ If specified, the table is created as an unlogged table. Refer
+ to CREATE TABLE for details.
+
new_table
+ The name (optionally schema-qualified) of the table to be created.
+
+ All other parameters are described in detail under SELECT.
+
Notes
+ CREATE TABLE AS is functionally similar to
+ SELECT INTO. CREATE TABLE AS
+ is the recommended syntax, since this form of SELECT
+ INTO is not available in ECPG
+ or PL/pgSQL, because they interpret the
+ INTO clause differently. Furthermore,
+ CREATE TABLE AS offers a superset of the
+ functionality provided by SELECT INTO.
+
+ In contrast to CREATE TABLE AS, SELECT
+ INTO does not allow specifying properties like a table's access
+ method with USING method or the table's
+ tablespace with TABLESPACE tablespace_name. Use
+ CREATE TABLE AS if necessary. Therefore, the default table
+ access method is chosen for the new table. See default_table_access_method for more information.
+
Examples
+ Create a new table films_recent consisting of only
+ recent entries from the table films:
+
+
+SELECT * INTO films_recent FROM films WHERE date_prod >= '2002-01-01';
+
Compatibility
+ The SQL standard uses SELECT INTO to
+ represent selecting values into scalar variables of a host program,
+ rather than creating a new table. This indeed is the usage found
+ in ECPG (see Chapter 36) and
+ PL/pgSQL (see Chapter 43).
+ The PostgreSQL usage of SELECT
+ INTO to represent table creation is historical. Some other SQL
+ implementations also use SELECT INTO in this way (but
+ most SQL implementations support CREATE TABLE AS
+ instead). Apart from such compatibility considerations, it is best to use
+ CREATE TABLE AS for this purpose in new code.
+
SET CONSTRAINTS
SET CONSTRAINTS — set constraint check timing for the current transaction
Synopsis
+SET CONSTRAINTS { ALL | name [, ...] } { DEFERRED | IMMEDIATE }
+Description
+ SET CONSTRAINTS sets the behavior of constraint
+ checking within the current transaction. IMMEDIATE
+ constraints are checked at the end of each
+ statement. DEFERRED constraints are not checked until
+ transaction commit. Each constraint has its own
+ IMMEDIATE or DEFERRED mode.
+
+ Upon creation, a constraint is given one of three
+ characteristics: DEFERRABLE INITIALLY DEFERRED,
+ DEFERRABLE INITIALLY IMMEDIATE, or
+ NOT DEFERRABLE. The third
+ class is always IMMEDIATE and is not affected by the
+ SET CONSTRAINTS command. The first two classes start
+ every transaction in the indicated mode, but their behavior can be changed
+ within a transaction by SET CONSTRAINTS.
+
+ SET CONSTRAINTS with a list of constraint names changes
+ the mode of just those constraints (which must all be deferrable). Each
+ constraint name can be schema-qualified. The
+ current schema search path is used to find the first matching name if
+ no schema name is specified. SET CONSTRAINTS ALL
+ changes the mode of all deferrable constraints.
+
+ When SET CONSTRAINTS changes the mode of a constraint
+ from DEFERRED
+ to IMMEDIATE, the new mode takes effect
+ retroactively: any outstanding data modifications that would have
+ been checked at the end of the transaction are instead checked during the
+ execution of the SET CONSTRAINTS command.
+ If any such constraint is violated, the SET CONSTRAINTS
+ fails (and does not change the constraint mode). Thus, SET
+ CONSTRAINTS can be used to force checking of constraints to
+ occur at a specific point in a transaction.
+
+ Currently, only UNIQUE, PRIMARY KEY,
+ REFERENCES (foreign key), and EXCLUDE
+ constraints are affected by this setting.
+ NOT NULL and CHECK constraints are
+ always checked immediately when a row is inserted or modified
+ (not at the end of the statement).
+ Uniqueness and exclusion constraints that have not been declared
+ DEFERRABLE are also checked immediately.
+
+ The firing of triggers that are declared as “constraint triggers”
+ is also controlled by this setting — they fire at the same time
+ that the associated constraint should be checked.
+
Notes
+ Because PostgreSQL does not require constraint
+ names to be unique within a schema (but only per-table), it is possible
+ that there is more than one match for a specified constraint name.
+ In this case SET CONSTRAINTS will act on all matches.
+ For a non-schema-qualified name, once a match or matches have been found in
+ some schema in the search path, schemas appearing later in the path are not
+ searched.
+
+ This command only alters the behavior of constraints within the
+ current transaction. Issuing this outside of a transaction block
+ emits a warning and otherwise has no effect.
+
Compatibility
+ This command complies with the behavior defined in the SQL
+ standard, except for the limitation that, in
+ PostgreSQL, it does not apply to
+ NOT NULL and CHECK constraints.
+ Also, PostgreSQL checks non-deferrable
+ uniqueness constraints immediately, not at end of statement as the
+ standard would suggest.
+
SET ROLE
SET ROLE — set the current user identifier of the current session
Synopsis
+SET [ SESSION | LOCAL ] ROLE role_name
+SET [ SESSION | LOCAL ] ROLE NONE
+RESET ROLE
+
Description
+ This command sets the current user
+ identifier of the current SQL session to be role_name. The role name can be
+ written as either an identifier or a string literal.
+ After SET ROLE, permissions checking for SQL commands
+ is carried out as though the named role were the one that had logged
+ in originally.
+
+ The current session user must have the SET option for the
+ specified role_name, either
+ directly or indirectly via a chain of memberships with the
+ SET option.
+ (If the session user is a superuser, any role can be selected.)
+
+ The SESSION and LOCAL modifiers act the same
+ as for the regular SET
+ command.
+
+ SET ROLE NONE sets the current user identifier to the
+ current session user identifier, as returned by
+ session_user. RESET ROLE sets the
+ current user identifier to the connection-time setting specified by the
+ command-line options,
+ ALTER ROLE, or
+ ALTER DATABASE,
+ if any such settings exist. Otherwise, RESET ROLE sets
+ the current user identifier to the current session user identifier. These
+ forms can be executed by any user.
+
Notes
+ Using this command, it is possible to either add privileges or restrict
+ one's privileges. If the session user role has been granted memberships
+ WITH INHERIT TRUE, it automatically has all the
+ privileges of every such role. In this case, SET ROLE
+ effectively drops all the privileges except for those which the target role
+ directly possesses or inherits. On the other hand, if the session user role
+ has been granted memberships WITH INHERIT FALSE, the
+ privileges of the granted roles can't be accessed by default. However, if
+ the role was granted WITH SET TRUE, the
+ session user can use SET ROLE to drop the privileges
+ assigned directly to the session user and instead acquire the privileges
+ available to the named role. If the role was granted WITH INHERIT
+ FALSE, SET FALSE then the privileges of that role cannot be
+ exercised either with or without SET ROLE.
+
+ Note that when a superuser chooses to SET ROLE to a
+ non-superuser role, they lose their superuser privileges.
+
+ SET ROLE has effects comparable to
+ SET SESSION AUTHORIZATION, but the privilege
+ checks involved are quite different. Also,
+ SET SESSION AUTHORIZATION determines which roles are
+ allowable for later SET ROLE commands, whereas changing
+ roles with SET ROLE does not change the set of roles
+ allowed to a later SET ROLE.
+
+ SET ROLE does not process session variables as specified by
+ the role's ALTER ROLE settings; this only happens during
+ login.
+
+ SET ROLE cannot be used within a
+ SECURITY DEFINER function.
+
Examples
+SELECT SESSION_USER, CURRENT_USER;
+
+ session_user | current_user
+--------------+--------------
+ peter | peter
+
+SET ROLE 'paul';
+
+SELECT SESSION_USER, CURRENT_USER;
+
+ session_user | current_user
+--------------+--------------
+ peter | paul
+
Compatibility
+ PostgreSQL
+ allows identifier syntax ("rolename"), while
+ the SQL standard requires the role name to be written as a string
+ literal. SQL does not allow this command during a transaction;
+ PostgreSQL does not make this
+ restriction because there is no reason to.
+ The SESSION and LOCAL modifiers are a
+ PostgreSQL extension, as is the
+ RESET syntax.
+
SET SESSION AUTHORIZATION
SET SESSION AUTHORIZATION — set the session user identifier and the current user identifier of the current session
Synopsis
+SET [ SESSION | LOCAL ] SESSION AUTHORIZATION user_name
+SET [ SESSION | LOCAL ] SESSION AUTHORIZATION DEFAULT
+RESET SESSION AUTHORIZATION
+
Description
+ This command sets the session user identifier and the current user
+ identifier of the current SQL session to be user_name. The user name can be
+ written as either an identifier or a string literal. Using this
+ command, it is possible, for example, to temporarily become an
+ unprivileged user and later switch back to being a superuser.
+
+ The session user identifier is initially set to be the (possibly
+ authenticated) user name provided by the client. The current user
+ identifier is normally equal to the session user identifier, but
+ might change temporarily in the context of SECURITY DEFINER
+ functions and similar mechanisms; it can also be changed by
+ SET ROLE.
+ The current user identifier is relevant for permission checking.
+
+ The session user identifier can be changed only if the initial session
+ user (the authenticated user) had the
+ superuser privilege. Otherwise, the command is accepted only if it
+ specifies the authenticated user name.
+
+ The SESSION and LOCAL modifiers act the same
+ as for the regular SET
+ command.
+
+ The DEFAULT and RESET forms reset the session
+ and current user identifiers to be the originally authenticated user
+ name. These forms can be executed by any user.
+
Notes
+ SET SESSION AUTHORIZATION cannot be used within a
+ SECURITY DEFINER function.
+
Examples
+SELECT SESSION_USER, CURRENT_USER;
+
+ session_user | current_user
+--------------+--------------
+ peter | peter
+
+SET SESSION AUTHORIZATION 'paul';
+
+SELECT SESSION_USER, CURRENT_USER;
+
+ session_user | current_user
+--------------+--------------
+ paul | paul
+
Compatibility
+ The SQL standard allows some other expressions to appear in place
+ of the literal user_name, but these options
+ are not important in practice. PostgreSQL
+ allows identifier syntax ("username"), which SQL
+ does not. SQL does not allow this command during a transaction;
+ PostgreSQL does not make this
+ restriction because there is no reason to.
+ The SESSION and LOCAL modifiers are a
+ PostgreSQL extension, as is the
+ RESET syntax.
+
+ The privileges necessary to execute this command are left
+ implementation-defined by the standard.
+
SET TRANSACTION
SET TRANSACTION — set the characteristics of the current transaction
Synopsis
+SET TRANSACTION transaction_mode [, ...]
+SET TRANSACTION SNAPSHOT snapshot_id
+SET SESSION CHARACTERISTICS AS TRANSACTION transaction_mode [, ...]
+
+where transaction_mode is one of:
+
+ ISOLATION LEVEL { SERIALIZABLE | REPEATABLE READ | READ COMMITTED | READ UNCOMMITTED }
+ READ WRITE | READ ONLY
+ [ NOT ] DEFERRABLE
+
Description
+ The SET TRANSACTION command sets the
+ characteristics of the current transaction. It has no effect on any
+ subsequent transactions. SET SESSION
+ CHARACTERISTICS sets the default transaction
+ characteristics for subsequent transactions of a session. These
+ defaults can be overridden by SET TRANSACTION
+ for an individual transaction.
+
+ The available transaction characteristics are the transaction
+ isolation level, the transaction access mode (read/write or
+ read-only), and the deferrable mode.
+ In addition, a snapshot can be selected, though only for the current
+ transaction, not as a session default.
+
+ The isolation level of a transaction determines what data the
+ transaction can see when other transactions are running concurrently:
+
+
READ COMMITTED
+ A statement can only see rows committed before it began. This
+ is the default.
+
REPEATABLE READ
+ All statements of the current transaction can only see rows committed
+ before the first query or data-modification statement was executed in
+ this transaction.
+
SERIALIZABLE
+ All statements of the current transaction can only see rows committed
+ before the first query or data-modification statement was executed in
+ this transaction. If a pattern of reads and writes among concurrent
+ serializable transactions would create a situation which could not
+ have occurred for any serial (one-at-a-time) execution of those
+ transactions, one of them will be rolled back with a
+ serialization_failure error.
+
+
+ The SQL standard defines one additional level, READ
+ UNCOMMITTED.
+ In PostgreSQL READ
+ UNCOMMITTED is treated as READ COMMITTED.
+
+ The transaction isolation level cannot be changed after the first query or
+ data-modification statement (SELECT,
+ INSERT, DELETE,
+ UPDATE, MERGE,
+ FETCH, or
+ COPY) of a transaction has been executed. See
+ Chapter 13 for more information about transaction
+ isolation and concurrency control.
+
+ The transaction access mode determines whether the transaction is
+ read/write or read-only. Read/write is the default. When a
+ transaction is read-only, the following SQL commands are
+ disallowed: INSERT, UPDATE,
+ DELETE, MERGE, and
+ COPY FROM if the
+ table they would write to is not a temporary table; all
+ CREATE, ALTER, and
+ DROP commands; COMMENT,
+ GRANT, REVOKE,
+ TRUNCATE; and EXPLAIN ANALYZE
+ and EXECUTE if the command they would execute is
+ among those listed. This is a high-level notion of read-only that
+ does not prevent all writes to disk.
+
+ The DEFERRABLE transaction property has no effect
+ unless the transaction is also SERIALIZABLE and
+ READ ONLY. When all three of these properties are
+ selected for a
+ transaction, the transaction may block when first acquiring its snapshot,
+ after which it is able to run without the normal overhead of a
+ SERIALIZABLE transaction and without any risk of
+ contributing to or being canceled by a serialization failure. This mode
+ is well suited for long-running reports or backups.
+
+ The SET TRANSACTION SNAPSHOT command allows a new
+ transaction to run with the same snapshot as an existing
+ transaction. The pre-existing transaction must have exported its snapshot
+ with the pg_export_snapshot function (see Section 9.27.5). That function returns a
+ snapshot identifier, which must be given to SET TRANSACTION
+ SNAPSHOT to specify which snapshot is to be imported. The
+ identifier must be written as a string literal in this command, for example
+ '00000003-0000001B-1'.
+ SET TRANSACTION SNAPSHOT can only be executed at the
+ start of a transaction, before the first query or
+ data-modification statement (SELECT,
+ INSERT, DELETE,
+ UPDATE, MERGE,
+ FETCH, or
+ COPY) of the transaction. Furthermore, the transaction
+ must already be set to SERIALIZABLE or
+ REPEATABLE READ isolation level (otherwise, the snapshot
+ would be discarded immediately, since READ COMMITTED mode takes
+ a new snapshot for each command). If the importing transaction uses
+ SERIALIZABLE isolation level, then the transaction that
+ exported the snapshot must also use that isolation level. Also, a
+ non-read-only serializable transaction cannot import a snapshot from a
+ read-only transaction.
+
Notes
+ If SET TRANSACTION is executed without a prior
+ START TRANSACTION or BEGIN,
+ it emits a warning and otherwise has no effect.
+
+ It is possible to dispense with SET TRANSACTION
+ by instead specifying the desired transaction_modes in
+ BEGIN or START TRANSACTION.
+ But that option is not available for SET TRANSACTION
+ SNAPSHOT.
+
+ The session default transaction modes can also be set or examined via the
+ configuration parameters default_transaction_isolation,
+ default_transaction_read_only, and
+ default_transaction_deferrable.
+ (In fact SET SESSION CHARACTERISTICS is just a
+ verbose equivalent for setting these variables with SET.)
+ This means the defaults can be set in the configuration file, via
+ ALTER DATABASE, etc. Consult Chapter 20
+ for more information.
+
+ The current transaction's modes can similarly be set or examined via the
+ configuration parameters transaction_isolation,
+ transaction_read_only, and
+ transaction_deferrable. Setting one of these
+ parameters acts the same as the corresponding SET
+ TRANSACTION option, with the same restrictions on when it can
+ be done. However, these parameters cannot be set in the configuration
+ file, or from any source other than live SQL.
+
Examples
+ To begin a new transaction with the same snapshot as an already
+ existing transaction, first export the snapshot from the existing
+ transaction. That will return the snapshot identifier, for example:
+
+
+BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ;
+SELECT pg_export_snapshot();
+ pg_export_snapshot
+---------------------
+ 00000003-0000001B-1
+(1 row)
+
+
+ Then give the snapshot identifier in a SET TRANSACTION
+ SNAPSHOT command at the beginning of the newly opened
+ transaction:
+
+
+BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ;
+SET TRANSACTION SNAPSHOT '00000003-0000001B-1';
+
Compatibility
+ These commands are defined in the SQL standard,
+ except for the DEFERRABLE transaction mode
+ and the SET TRANSACTION SNAPSHOT form, which are
+ PostgreSQL extensions.
+
+ SERIALIZABLE is the default transaction
+ isolation level in the standard. In
+ PostgreSQL the default is ordinarily
+ READ COMMITTED, but you can change it as
+ mentioned above.
+
+ In the SQL standard, there is one other transaction characteristic
+ that can be set with these commands: the size of the diagnostics
+ area. This concept is specific to embedded SQL, and therefore is
+ not implemented in the PostgreSQL server.
+
+ The SQL standard requires commas between successive transaction_modes, but for historical
+ reasons PostgreSQL allows the commas to be
+ omitted.
+
SET
SET — change a run-time parameter
Synopsis
+SET [ SESSION | LOCAL ] configuration_parameter { TO | = } { value | 'value' | DEFAULT }
+SET [ SESSION | LOCAL ] TIME ZONE { value | 'value' | LOCAL | DEFAULT }
+
Description
+ The SET command changes run-time configuration
+ parameters. Many of the run-time parameters listed in
+ Chapter 20 can be changed on-the-fly with
+ SET.
+ (Some parameters can only be changed by superusers and users who
+ have been granted SET privilege on that parameter.
+ There are also parameters that cannot be changed after server or
+ session start.)
+ SET only affects the value used by the current
+ session.
+
+ If SET (or equivalently SET SESSION)
+ is issued within a transaction that is later aborted, the effects of the
+ SET command disappear when the transaction is rolled
+ back. Once the surrounding transaction is committed, the effects
+ will persist until the end of the session, unless overridden by another
+ SET.
+
+ The effects of SET LOCAL last only till the end of
+ the current transaction, whether committed or not. A special case is
+ SET followed by SET LOCAL within
+ a single transaction: the SET LOCAL value will be
+ seen until the end of the transaction, but afterwards (if the transaction
+ is committed) the SET value will take effect.
+
+ The effects of SET or SET LOCAL are
+ also canceled by rolling back to a savepoint that is earlier than the
+ command.
+
+ If SET LOCAL is used within a function that has a
+ SET option for the same variable (see
+ CREATE FUNCTION),
+ the effects of the SET LOCAL command disappear at
+ function exit; that is, the value in effect when the function was called is
+ restored anyway. This allows SET LOCAL to be used for
+ dynamic or repeated changes of a parameter within a function, while still
+ having the convenience of using the SET option to save and
+ restore the caller's value. However, a regular SET command
+ overrides any surrounding function's SET option; its effects
+ will persist unless rolled back.
+
Note
+ In PostgreSQL versions 8.0 through 8.2,
+ the effects of a SET LOCAL would be canceled by
+ releasing an earlier savepoint, or by successful exit from a
+ PL/pgSQL exception block. This behavior
+ has been changed because it was deemed unintuitive.
+
Parameters
SESSION
+ Specifies that the command takes effect for the current session.
+ (This is the default if neither SESSION nor
+ LOCAL appears.)
+
LOCAL
+ Specifies that the command takes effect for only the current
+ transaction. After COMMIT or ROLLBACK,
+ the session-level setting takes effect again. Issuing this
+ outside of a transaction block emits a warning and otherwise has
+ no effect.
+
configuration_parameter
+ Name of a settable run-time parameter. Available parameters are
+ documented in Chapter 20 and below.
+
value
+ New value of parameter. Values can be specified as string
+ constants, identifiers, numbers, or comma-separated lists of
+ these, as appropriate for the particular parameter.
+ DEFAULT can be written to specify
+ resetting the parameter to its default value (that is, whatever
+ value it would have had if no SET had been executed
+ in the current session).
+
+ Besides the configuration parameters documented in Chapter 20, there are a few that can only be
+ adjusted using the SET command or that have a
+ special syntax:
+
+
SCHEMASET SCHEMA 'value' is an alias for
+ SET search_path TO value. Only one
+ schema can be specified using this syntax.
+
NAMESSET NAMES value is an alias for
+ SET client_encoding TO value.
+
SEED
+ Sets the internal seed for the random number generator (the
+ function random). Allowed values are
+ floating-point numbers between -1 and 1 inclusive.
+
+ The seed can also be set by invoking the function
+ setseed:
+
+SELECT setseed(value);
+
TIME ZONESET TIME ZONE 'value' is an alias
+ for SET timezone TO 'value'. The
+ syntax SET TIME ZONE allows special syntax
+ for the time zone specification. Here are examples of valid
+ values:
+
+
'PST8PDT'
+ The time zone for Berkeley, California.
+
'Europe/Rome'
+ The time zone for Italy.
+
-7
+ The time zone 7 hours west from UTC (equivalent
+ to PDT). Positive values are east from UTC.
+
INTERVAL '-08:00' HOUR TO MINUTE
+ The time zone 8 hours west from UTC (equivalent
+ to PST).
+
LOCAL
DEFAULT
+ Set the time zone to your local time zone (that is, the
+ server's default value of timezone).
+
+
+ Timezone settings given as numbers or intervals are internally
+ translated to POSIX timezone syntax. For example, after
+ SET TIME ZONE -7, SHOW TIME ZONE would
+ report <-07>+07.
+
+ Time zone abbreviations are not supported by SET;
+ see Section 8.5.3 for more information
+ about time zones.
+
+
Notes
+ The function set_config provides equivalent
+ functionality; see Section 9.27.1.
+ Also, it is possible to UPDATE the
+ pg_settings
+ system view to perform the equivalent of SET.
+
Examples
+ Set the schema search path:
+
+SET search_path TO my_schema, public;
+
+
+ Set the style of date to traditional
+ POSTGRES with “day before month”
+ input convention:
+
+SET datestyle TO postgres, dmy;
+
+
+ Set the time zone for Berkeley, California:
+
+SET TIME ZONE 'PST8PDT';
+
+
+ Set the time zone for Italy:
+
+SET TIME ZONE 'Europe/Rome';
+
Compatibility
+ SET TIME ZONE extends syntax defined in the SQL
+ standard. The standard allows only numeric time zone offsets while
+ PostgreSQL allows more flexible
+ time-zone specifications. All other SET
+ features are PostgreSQL extensions.
+
SHOW
SHOW — show the value of a run-time parameter
Synopsis
+SHOW name
+SHOW ALL
+
Description
+ SHOW will display the current setting of
+ run-time parameters. These variables can be set using the
+ SET statement, by editing the
+ postgresql.conf configuration file, through
+ the PGOPTIONS environmental variable (when using
+ libpq or a libpq-based
+ application), or through command-line flags when starting the
+ postgres server. See Chapter 20 for details.
+
Parameters
name
+ The name of a run-time parameter. Available parameters are
+ documented in Chapter 20 and on the SET reference page. In
+ addition, there are a few parameters that can be shown but not
+ set:
+
+
SERVER_VERSION
+ Shows the server's version number.
+
SERVER_ENCODING
+ Shows the server-side character set encoding. At present,
+ this parameter can be shown but not set, because the
+ encoding is determined at database creation time.
+
LC_COLLATE
+ Shows the database's locale setting for collation (text
+ ordering). At present, this parameter can be shown but not
+ set, because the setting is determined at database creation
+ time.
+
LC_CTYPE
+ Shows the database's locale setting for character
+ classification. At present, this parameter can be shown but
+ not set, because the setting is determined at database creation
+ time.
+
IS_SUPERUSER
+ True if the current role has superuser privileges.
+
ALL
+ Show the values of all configuration parameters, with descriptions.
+
Notes
+ The function current_setting produces
+ equivalent output; see Section 9.27.1.
+ Also, the
+ pg_settings
+ system view produces the same information.
+
+
Examples
+ Show the current setting of the parameter DateStyle:
+
+
+SHOW DateStyle;
+ DateStyle
+-----------
+ ISO, MDY
+(1 row)
+
+
+ Show the current setting of the parameter geqo:
+
+SHOW geqo;
+ geqo
+------
+ on
+(1 row)
+
+
+ Show all settings:
+
+SHOW ALL;
+ name | setting | description
+-------------------------+---------+-------------------------------------------------
+ allow_system_table_mods | off | Allows modifications of the structure of ...
+ .
+ .
+ .
+ xmloption | content | Sets whether XML data in implicit parsing ...
+ zero_damaged_pages | off | Continues processing past damaged page headers.
+(196 rows)
+
Compatibility
+ The SHOW command is a
+ PostgreSQL extension.
+
START TRANSACTION
START TRANSACTION — start a transaction block
Synopsis
+START TRANSACTION [ transaction_mode [, ...] ]
+
+where transaction_mode is one of:
+
+ ISOLATION LEVEL { SERIALIZABLE | REPEATABLE READ | READ COMMITTED | READ UNCOMMITTED }
+ READ WRITE | READ ONLY
+ [ NOT ] DEFERRABLE
+
Description
+ This command begins a new transaction block. If the isolation level,
+ read/write mode, or deferrable mode is specified, the new transaction has those
+ characteristics, as if SET TRANSACTION was executed. This is the same
+ as the BEGIN command.
+
Parameters
+ Refer to SET TRANSACTION for information on the meaning
+ of the parameters to this statement.
+
Compatibility
+ In the standard, it is not necessary to issue START TRANSACTION
+ to start a transaction block: any SQL command implicitly begins a block.
+ PostgreSQL's behavior can be seen as implicitly
+ issuing a COMMIT after each command that does not
+ follow START TRANSACTION (or BEGIN),
+ and it is therefore often called “autocommit”.
+ Other relational database systems might offer an autocommit feature
+ as a convenience.
+
+ The DEFERRABLE
+ transaction_mode
+ is a PostgreSQL language extension.
+
+ The SQL standard requires commas between successive transaction_modes, but for historical
+ reasons PostgreSQL allows the commas to be
+ omitted.
+
+ See also the compatibility section of SET TRANSACTION.
+
+ PostgreSQL allows functions that have named
+ parameters to be called using either positional or
+ named notation. Named notation is especially
+ useful for functions that have a large number of parameters, since it
+ makes the associations between parameters and actual arguments more
+ explicit and reliable.
+ In positional notation, a function call is written with
+ its argument values in the same order as they are defined in the function
+ declaration. In named notation, the arguments are matched to the
+ function parameters by name and can be written in any order.
+ For each notation, also consider the effect of function argument types,
+ documented in Section 10.3.
+
+ In either notation, parameters that have default values given in the
+ function declaration need not be written in the call at all. But this
+ is particularly useful in named notation, since any combination of
+ parameters can be omitted; while in positional notation parameters can
+ only be omitted from right to left.
+
+ PostgreSQL also supports
+ mixed notation, which combines positional and
+ named notation. In this case, positional parameters are written first
+ and named parameters appear after them.
+
+ The following examples will illustrate the usage of all three
+ notations, using the following function definition:
+
+CREATE FUNCTION concat_lower_or_upper(a text, b text, uppercase boolean DEFAULT false)
+RETURNS text
+AS
+$$
+ SELECT CASE
+ WHEN $3 THEN UPPER($1 || ' ' || $2)
+ ELSE LOWER($1 || ' ' || $2)
+ END;
+$$
+LANGUAGE SQL IMMUTABLE STRICT;
+
+ Function concat_lower_or_upper has two mandatory
+ parameters, a and b. Additionally
+ there is one optional parameter uppercase which defaults
+ to false. The a and
+ b inputs will be concatenated, and forced to either
+ upper or lower case depending on the uppercase
+ parameter. The remaining details of this function
+ definition are not important here (see Chapter 38 for
+ more information).
+
4.3.1. Using Positional Notation #
+ Positional notation is the traditional mechanism for passing arguments
+ to functions in PostgreSQL. An example is:
+
+SELECT concat_lower_or_upper('Hello', 'World', true);
+ concat_lower_or_upper
+-----------------------
+ HELLO WORLD
+(1 row)
+
+ All arguments are specified in order. The result is upper case since
+ uppercase is specified as true.
+ Another example is:
+
+SELECT concat_lower_or_upper('Hello', 'World');
+ concat_lower_or_upper
+-----------------------
+ hello world
+(1 row)
+
+ Here, the uppercase parameter is omitted, so it
+ receives its default value of false, resulting in
+ lower case output. In positional notation, arguments can be omitted
+ from right to left so long as they have defaults.
+
4.3.2. Using Named Notation #
+ In named notation, each argument's name is specified using
+ => to separate it from the argument expression.
+ For example:
+
+SELECT concat_lower_or_upper(a => 'Hello', b => 'World');
+ concat_lower_or_upper
+-----------------------
+ hello world
+(1 row)
+
+ Again, the argument uppercase was omitted
+ so it is set to false implicitly. One advantage of
+ using named notation is that the arguments may be specified in any
+ order, for example:
+
+SELECT concat_lower_or_upper(a => 'Hello', b => 'World', uppercase => true);
+ concat_lower_or_upper
+-----------------------
+ HELLO WORLD
+(1 row)
+
+SELECT concat_lower_or_upper(a => 'Hello', uppercase => true, b => 'World');
+ concat_lower_or_upper
+-----------------------
+ HELLO WORLD
+(1 row)
+
+
+ An older syntax based on ":=" is supported for backward compatibility:
+
+SELECT concat_lower_or_upper(a := 'Hello', uppercase := true, b := 'World');
+ concat_lower_or_upper
+-----------------------
+ HELLO WORLD
+(1 row)
+
+
4.3.3. Using Mixed Notation #
+ The mixed notation combines positional and named notation. However, as
+ already mentioned, named arguments cannot precede positional arguments.
+ For example:
+
+SELECT concat_lower_or_upper('Hello', 'World', uppercase => true);
+ concat_lower_or_upper
+-----------------------
+ HELLO WORLD
+(1 row)
+
+ In the above query, the arguments a and
+ b are specified positionally, while
+ uppercase is specified by name. In this example,
+ that adds little except documentation. With a more complex function
+ having numerous parameters that have default values, named or mixed
+ notation can save a great deal of writing and reduce chances for error.
+
Note
+ Named and mixed call notations currently cannot be used when calling an
+ aggregate function (but they do work when an aggregate function is used
+ as a window function).
+
+ SQL input consists of a sequence of
+ commands. A command is composed of a
+ sequence of tokens, terminated by a
+ semicolon (“;”). The end of the input stream also
+ terminates a command. Which tokens are valid depends on the syntax
+ of the particular command.
+
+ A token can be a key word, an
+ identifier, a quoted
+ identifier, a literal (or
+ constant), or a special character symbol. Tokens are normally
+ separated by whitespace (space, tab, newline), but need not be if
+ there is no ambiguity (which is generally only the case if a
+ special character is adjacent to some other token type).
+
+ For example, the following is (syntactically) valid SQL input:
+
+SELECT * FROM MY_TABLE;
+UPDATE MY_TABLE SET A = 5;
+INSERT INTO MY_TABLE VALUES (3, 'hi there');
+
+ This is a sequence of three commands, one per line (although this
+ is not required; more than one command can be on a line, and
+ commands can usefully be split across lines).
+
+ Additionally, comments can occur in SQL
+ input. They are not tokens, they are effectively equivalent to
+ whitespace.
+
+ The SQL syntax is not very consistent regarding what tokens
+ identify commands and which are operands or parameters. The first
+ few tokens are generally the command name, so in the above example
+ we would usually speak of a “SELECT”, an
+ “UPDATE”, and an “INSERT” command. But
+ for instance the UPDATE command always requires
+ a SET token to appear in a certain position, and
+ this particular variation of INSERT also
+ requires a VALUES in order to be complete. The
+ precise syntax rules for each command are described in Part VI.
+
4.1.1. Identifiers and Key Words #
+ Tokens such as SELECT, UPDATE, or
+ VALUES in the example above are examples of
+ key words, that is, words that have a fixed
+ meaning in the SQL language. The tokens MY_TABLE
+ and A are examples of
+ identifiers. They identify names of
+ tables, columns, or other database objects, depending on the
+ command they are used in. Therefore they are sometimes simply
+ called “names”. Key words and identifiers have the
+ same lexical structure, meaning that one cannot know whether a
+ token is an identifier or a key word without knowing the language.
+ A complete list of key words can be found in Appendix C.
+
+ SQL identifiers and key words must begin with a letter
+ (a-z, but also letters with
+ diacritical marks and non-Latin letters) or an underscore
+ (_). Subsequent characters in an identifier or
+ key word can be letters, underscores, digits
+ (0-9), or dollar signs
+ ($). Note that dollar signs are not allowed in identifiers
+ according to the letter of the SQL standard, so their use might render
+ applications less portable.
+ The SQL standard will not define a key word that contains
+ digits or starts or ends with an underscore, so identifiers of this
+ form are safe against possible conflict with future extensions of the
+ standard.
+
+
+ The system uses no more than NAMEDATALEN-1
+ bytes of an identifier; longer names can be written in
+ commands, but they will be truncated. By default,
+ NAMEDATALEN is 64 so the maximum identifier
+ length is 63 bytes. If this limit is problematic, it can be raised by
+ changing the NAMEDATALEN constant in
+ src/include/pg_config_manual.h.
+
+
+ Key words and unquoted identifiers are case-insensitive. Therefore:
+
+UPDATE MY_TABLE SET A = 5;
+
+ can equivalently be written as:
+
+uPDaTE my_TabLE SeT a = 5;
+
+ A convention often used is to write key words in upper
+ case and names in lower case, e.g.:
+
+UPDATE my_table SET a = 5;
+
+
+
+ There is a second kind of identifier: the delimited
+ identifier or quoted
+ identifier. It is formed by enclosing an arbitrary
+ sequence of characters in double-quotes
+ ("). A delimited
+ identifier is always an identifier, never a key word. So
+ "select" could be used to refer to a column or
+ table named “select”, whereas an unquoted
+ select would be taken as a key word and
+ would therefore provoke a parse error when used where a table or
+ column name is expected. The example can be written with quoted
+ identifiers like this:
+
+UPDATE "my_table" SET "a" = 5;
+
+
+ Quoted identifiers can contain any character, except the character
+ with code zero. (To include a double quote, write two double quotes.)
+ This allows constructing table or column names that would
+ otherwise not be possible, such as ones containing spaces or
+ ampersands. The length limitation still applies.
+
+ Quoting an identifier also makes it case-sensitive, whereas
+ unquoted names are always folded to lower case. For example, the
+ identifiers FOO, foo, and
+ "foo" are considered the same by
+ PostgreSQL, but
+ "Foo" and "FOO" are
+ different from these three and each other. (The folding of
+ unquoted names to lower case in PostgreSQL is
+ incompatible with the SQL standard, which says that unquoted names
+ should be folded to upper case. Thus, foo
+ should be equivalent to "FOO" not
+ "foo" according to the standard. If you want
+ to write portable applications you are advised to always quote a
+ particular name or never quote it.)
+
+ A variant of quoted
+ identifiers allows including escaped Unicode characters identified
+ by their code points. This variant starts
+ with U& (upper or lower case U followed by
+ ampersand) immediately before the opening double quote, without
+ any spaces in between, for example U&"foo".
+ (Note that this creates an ambiguity with the
+ operator &. Use spaces around the operator to
+ avoid this problem.) Inside the quotes, Unicode characters can be
+ specified in escaped form by writing a backslash followed by the
+ four-digit hexadecimal code point number or alternatively a
+ backslash followed by a plus sign followed by a six-digit
+ hexadecimal code point number. For example, the
+ identifier "data" could be written as
+
+U&"d\0061t\+000061"
+
+ The following less trivial example writes the Russian
+ word “slon” (elephant) in Cyrillic letters:
+
+U&"\0441\043B\043E\043D"
+
+
+ If a different escape character than backslash is desired, it can
+ be specified using
+ the UESCAPE
+ clause after the string, for example:
+
+U&"d!0061t!+000061" UESCAPE '!'
+
+ The escape character can be any single character other than a
+ hexadecimal digit, the plus sign, a single quote, a double quote,
+ or a whitespace character. Note that the escape character is
+ written in single quotes, not double quotes,
+ after UESCAPE.
+
+ To include the escape character in the identifier literally, write
+ it twice.
+
+ Either the 4-digit or the 6-digit escape form can be used to
+ specify UTF-16 surrogate pairs to compose characters with code
+ points larger than U+FFFF, although the availability of the
+ 6-digit form technically makes this unnecessary. (Surrogate
+ pairs are not stored directly, but are combined into a single
+ code point.)
+
+ If the server encoding is not UTF-8, the Unicode code point identified
+ by one of these escape sequences is converted to the actual server
+ encoding; an error is reported if that's not possible.
+
+ There are three kinds of implicitly-typed
+ constants in PostgreSQL:
+ strings, bit strings, and numbers.
+ Constants can also be specified with explicit types, which can
+ enable more accurate representation and more efficient handling by
+ the system. These alternatives are discussed in the following
+ subsections.
+
4.1.2.1. String Constants #
+
+ A string constant in SQL is an arbitrary sequence of characters
+ bounded by single quotes ('), for example
+ 'This is a string'. To include
+ a single-quote character within a string constant,
+ write two adjacent single quotes, e.g.,
+ 'Dianne''s horse'.
+ Note that this is not the same as a double-quote
+ character (").
+
+ Two string constants that are only separated by whitespace
+ with at least one newline are concatenated
+ and effectively treated as if the string had been written as one
+ constant. For example:
+
+SELECT 'foo'
+'bar';
+
+ is equivalent to:
+
+SELECT 'foobar';
+
+ but:
+
+SELECT 'foo' 'bar';
+
+ is not valid syntax. (This slightly bizarre behavior is specified
+ by SQL; PostgreSQL is
+ following the standard.)
+
4.1.2.2. String Constants with C-Style Escapes #
+ PostgreSQL also accepts “escape”
+ string constants, which are an extension to the SQL standard.
+ An escape string constant is specified by writing the letter
+ E (upper or lower case) just before the opening single
+ quote, e.g., E'foo'. (When continuing an escape string
+ constant across lines, write E only before the first opening
+ quote.)
+ Within an escape string, a backslash character (\) begins a
+ C-like backslash escape sequence, in which the combination
+ of backslash and following character(s) represent a special byte
+ value, as shown in Table 4.1.
+
Table 4.1. Backslash Escape Sequences
| Backslash Escape Sequence | Interpretation |
|---|
\b | backspace |
\f | form feed |
\n | newline |
\r | carriage return |
\t | tab |
+ \o,
+ \oo,
+ \ooo
+ (o = 0–7)
+ | octal byte value |
+ \xh,
+ \xhh
+ (h = 0–9, A–F)
+ | hexadecimal byte value |
+ \uxxxx,
+ \Uxxxxxxxx
+ (x = 0–9, A–F)
+ | 16 or 32-bit hexadecimal Unicode character value |
+ Any other
+ character following a backslash is taken literally. Thus, to
+ include a backslash character, write two backslashes (\\).
+ Also, a single quote can be included in an escape string by writing
+ \', in addition to the normal way of ''.
+
+ It is your responsibility that the byte sequences you create,
+ especially when using the octal or hexadecimal escapes, compose
+ valid characters in the server character set encoding.
+ A useful alternative is to use Unicode escapes or the
+ alternative Unicode escape syntax, explained
+ in Section 4.1.2.3; then the server
+ will check that the character conversion is possible.
+
Caution
+ If the configuration parameter
+ standard_conforming_strings is off,
+ then PostgreSQL recognizes backslash escapes
+ in both regular and escape string constants. However, as of
+ PostgreSQL 9.1, the default is on, meaning
+ that backslash escapes are recognized only in escape string constants.
+ This behavior is more standards-compliant, but might break applications
+ which rely on the historical behavior, where backslash escapes
+ were always recognized. As a workaround, you can set this parameter
+ to off, but it is better to migrate away from using backslash
+ escapes. If you need to use a backslash escape to represent a special
+ character, write the string constant with an E.
+
+ In addition to standard_conforming_strings, the configuration
+ parameters escape_string_warning and
+ backslash_quote govern treatment of backslashes
+ in string constants.
+
+ The character with the code zero cannot be in a string constant.
+
4.1.2.3. String Constants with Unicode Escapes #
+ PostgreSQL also supports another type
+ of escape syntax for strings that allows specifying arbitrary
+ Unicode characters by code point. A Unicode escape string
+ constant starts with U& (upper or lower case
+ letter U followed by ampersand) immediately before the opening
+ quote, without any spaces in between, for
+ example U&'foo'. (Note that this creates an
+ ambiguity with the operator &. Use spaces
+ around the operator to avoid this problem.) Inside the quotes,
+ Unicode characters can be specified in escaped form by writing a
+ backslash followed by the four-digit hexadecimal code point
+ number or alternatively a backslash followed by a plus sign
+ followed by a six-digit hexadecimal code point number. For
+ example, the string 'data' could be written as
+
+U&'d\0061t\+000061'
+
+ The following less trivial example writes the Russian
+ word “slon” (elephant) in Cyrillic letters:
+
+U&'\0441\043B\043E\043D'
+
+
+ If a different escape character than backslash is desired, it can
+ be specified using
+ the UESCAPE
+ clause after the string, for example:
+
+U&'d!0061t!+000061' UESCAPE '!'
+
+ The escape character can be any single character other than a
+ hexadecimal digit, the plus sign, a single quote, a double quote,
+ or a whitespace character.
+
+ To include the escape character in the string literally, write
+ it twice.
+
+ Either the 4-digit or the 6-digit escape form can be used to
+ specify UTF-16 surrogate pairs to compose characters with code
+ points larger than U+FFFF, although the availability of the
+ 6-digit form technically makes this unnecessary. (Surrogate
+ pairs are not stored directly, but are combined into a single
+ code point.)
+
+ If the server encoding is not UTF-8, the Unicode code point identified
+ by one of these escape sequences is converted to the actual server
+ encoding; an error is reported if that's not possible.
+
+ Also, the Unicode escape syntax for string constants only works
+ when the configuration
+ parameter standard_conforming_strings is
+ turned on. This is because otherwise this syntax could confuse
+ clients that parse the SQL statements to the point that it could
+ lead to SQL injections and similar security issues. If the
+ parameter is set to off, this syntax will be rejected with an
+ error message.
+
4.1.2.4. Dollar-Quoted String Constants #
+ While the standard syntax for specifying string constants is usually
+ convenient, it can be difficult to understand when the desired string
+ contains many single quotes, since each of those must
+ be doubled. To allow more readable queries in such situations,
+ PostgreSQL provides another way, called
+ “dollar quoting”, to write string constants.
+ A dollar-quoted string constant
+ consists of a dollar sign ($), an optional
+ “tag” of zero or more characters, another dollar
+ sign, an arbitrary sequence of characters that makes up the
+ string content, a dollar sign, the same tag that began this
+ dollar quote, and a dollar sign. For example, here are two
+ different ways to specify the string “Dianne's horse”
+ using dollar quoting:
+
+$$Dianne's horse$$
+$SomeTag$Dianne's horse$SomeTag$
+
+ Notice that inside the dollar-quoted string, single quotes can be
+ used without needing to be escaped. Indeed, no characters inside
+ a dollar-quoted string are ever escaped: the string content is always
+ written literally. Backslashes are not special, and neither are
+ dollar signs, unless they are part of a sequence matching the opening
+ tag.
+
+ It is possible to nest dollar-quoted string constants by choosing
+ different tags at each nesting level. This is most commonly used in
+ writing function definitions. For example:
+
+$function$
+BEGIN
+ RETURN ($1 ~ $q$[\t\r\n\v\\]$q$);
+END;
+$function$
+
+ Here, the sequence $q$[\t\r\n\v\\]$q$ represents a
+ dollar-quoted literal string [\t\r\n\v\\], which will
+ be recognized when the function body is executed by
+ PostgreSQL. But since the sequence does not match
+ the outer dollar quoting delimiter $function$, it is
+ just some more characters within the constant so far as the outer
+ string is concerned.
+
+ The tag, if any, of a dollar-quoted string follows the same rules
+ as an unquoted identifier, except that it cannot contain a dollar sign.
+ Tags are case sensitive, so $tag$String content$tag$
+ is correct, but $TAG$String content$tag$ is not.
+
+ A dollar-quoted string that follows a keyword or identifier must
+ be separated from it by whitespace; otherwise the dollar quoting
+ delimiter would be taken as part of the preceding identifier.
+
+ Dollar quoting is not part of the SQL standard, but it is often a more
+ convenient way to write complicated string literals than the
+ standard-compliant single quote syntax. It is particularly useful when
+ representing string constants inside other constants, as is often needed
+ in procedural function definitions. With single-quote syntax, each
+ backslash in the above example would have to be written as four
+ backslashes, which would be reduced to two backslashes in parsing the
+ original string constant, and then to one when the inner string constant
+ is re-parsed during function execution.
+
4.1.2.5. Bit-String Constants #
+ Bit-string constants look like regular string constants with a
+ B (upper or lower case) immediately before the
+ opening quote (no intervening whitespace), e.g.,
+ B'1001'. The only characters allowed within
+ bit-string constants are 0 and
+ 1.
+
+ Alternatively, bit-string constants can be specified in hexadecimal
+ notation, using a leading X (upper or lower case),
+ e.g., X'1FF'. This notation is equivalent to
+ a bit-string constant with four binary digits for each hexadecimal digit.
+
+ Both forms of bit-string constant can be continued
+ across lines in the same way as regular string constants.
+ Dollar quoting cannot be used in a bit-string constant.
+
4.1.2.6. Numeric Constants #
+ Numeric constants are accepted in these general forms:
+
+digits
+digits.[digits][e[+-]digits]
+[digits].digits[e[+-]digits]
+digitse[+-]digits
+
+ where digits is one or more decimal
+ digits (0 through 9). At least one digit must be before or after the
+ decimal point, if one is used. At least one digit must follow the
+ exponent marker (e), if one is present.
+ There cannot be any spaces or other characters embedded in the
+ constant, except for underscores, which can be used for visual grouping as
+ described below. Note that any leading plus or minus sign is not actually
+ considered part of the constant; it is an operator applied to the
+ constant.
+
+ These are some examples of valid numeric constants:
+
+42
+3.5
+4.
+.001
+5e2
+1.925e-3
+
+
+ Additionally, non-decimal integer constants are accepted in these forms:
+
+0xhexdigits
+0ooctdigits
+0bbindigits
+
+ where hexdigits is one or more hexadecimal digits
+ (0-9, A-F), octdigits is one or more octal
+ digits (0-7), and bindigits is one or more binary
+ digits (0 or 1). Hexadecimal digits and the radix prefixes can be in
+ upper or lower case. Note that only integers can have non-decimal forms,
+ not numbers with fractional parts.
+
+ These are some examples of valid non-decimal integer constants:
+
+0b100101
+0B10011001
+0o273
+0O755
+0x42f
+0XFFFF
+
+
+ For visual grouping, underscores can be inserted between digits. These
+ have no further effect on the value of the constant. For example:
+
+1_500_000_000
+0b10001000_00000000
+0o_1_755
+0xFFFF_FFFF
+1.618_034
+
+ Underscores are not allowed at the start or end of a numeric constant or
+ a group of digits (that is, immediately before or after the decimal point
+ or the exponent marker), and more than one underscore in a row is not
+ allowed.
+
+
+
+
+ A numeric constant that contains neither a decimal point nor an
+ exponent is initially presumed to be type integer if its
+ value fits in type integer (32 bits); otherwise it is
+ presumed to be type bigint if its
+ value fits in type bigint (64 bits); otherwise it is
+ taken to be type numeric. Constants that contain decimal
+ points and/or exponents are always initially presumed to be type
+ numeric.
+
+ The initially assigned data type of a numeric constant is just a
+ starting point for the type resolution algorithms. In most cases
+ the constant will be automatically coerced to the most
+ appropriate type depending on context. When necessary, you can
+ force a numeric value to be interpreted as a specific data type
+ by casting it.
+ For example, you can force a numeric value to be treated as type
+ real (float4) by writing:
+
+
+REAL '1.23' -- string style
+1.23::REAL -- PostgreSQL (historical) style
+
+
+ These are actually just special cases of the general casting
+ notations discussed next.
+
4.1.2.7. Constants of Other Types #
+ A constant of an arbitrary type can be
+ entered using any one of the following notations:
+
+type 'string'
+'string'::type
+CAST ( 'string' AS type )
+
+ The string constant's text is passed to the input conversion
+ routine for the type called type. The
+ result is a constant of the indicated type. The explicit type
+ cast can be omitted if there is no ambiguity as to the type the
+ constant must be (for example, when it is assigned directly to a
+ table column), in which case it is automatically coerced.
+
+ The string constant can be written using either regular SQL
+ notation or dollar-quoting.
+
+ It is also possible to specify a type coercion using a function-like
+ syntax:
+
+typename ( 'string' )
+
+ but not all type names can be used in this way; see Section 4.2.9 for details.
+
+ The ::, CAST(), and
+ function-call syntaxes can also be used to specify run-time type
+ conversions of arbitrary expressions, as discussed in Section 4.2.9. To avoid syntactic ambiguity, the
+ type 'string'type 'string'::
+ or CAST() to specify the type of an array constant.
+
+ The CAST() syntax conforms to SQL. The
+ type 'string':: is historical PostgreSQL
+ usage, as is the function-call syntax.
+
+ An operator name is a sequence of up to NAMEDATALEN-1
+ (63 by default) characters from the following list:
+
++ - * / < > = ~ ! @ # % ^ & | ` ?
+
+
+ There are a few restrictions on operator names, however:
+
+ -- and /* cannot appear
+ anywhere in an operator name, since they will be taken as the
+ start of a comment.
+
+ A multiple-character operator name cannot end in + or -,
+ unless the name also contains at least one of these characters:
+
+ For example, @- is an allowed operator name,
+ but *- is not. This restriction allows
+ PostgreSQL to parse SQL-compliant
+ queries without requiring spaces between tokens.
+
+
+ When working with non-SQL-standard operator names, you will usually
+ need to separate adjacent operators with spaces to avoid ambiguity.
+ For example, if you have defined a prefix operator named @,
+ you cannot write X*@Y; you must write
+ X* @Y to ensure that
+ PostgreSQL reads it as two operator names
+ not one.
+
4.1.4. Special Characters #
+ Some characters that are not alphanumeric have a special meaning
+ that is different from being an operator. Details on the usage can
+ be found at the location where the respective syntax element is
+ described. This section only exists to advise the existence and
+ summarize the purposes of these characters.
+
+
+ A dollar sign ($) followed by digits is used
+ to represent a positional parameter in the body of a function
+ definition or a prepared statement. In other contexts the
+ dollar sign can be part of an identifier or a dollar-quoted string
+ constant.
+
+ Parentheses (()) have their usual meaning to
+ group expressions and enforce precedence. In some cases
+ parentheses are required as part of the fixed syntax of a
+ particular SQL command.
+
+ Brackets ([]) are used to select the elements
+ of an array. See Section 8.15 for more information
+ on arrays.
+
+ Commas (,) are used in some syntactical
+ constructs to separate the elements of a list.
+
+ The semicolon (;) terminates an SQL command.
+ It cannot appear anywhere within a command, except within a
+ string constant or quoted identifier.
+
+ The colon (:) is used to select
+ “slices” from arrays. (See Section 8.15.) In certain SQL dialects (such as Embedded
+ SQL), the colon is used to prefix variable names.
+
+ The asterisk (*) is used in some contexts to denote
+ all the fields of a table row or composite value. It also
+ has a special meaning when used as the argument of an
+ aggregate function, namely that the aggregate does not require
+ any explicit parameter.
+
+ The period (.) is used in numeric
+ constants, and to separate schema, table, and column names.
+
+
+
4.1.6. Operator Precedence #
+ Table 4.2 shows the precedence and
+ associativity of the operators in PostgreSQL.
+ Most operators have the same precedence and are left-associative.
+ The precedence and associativity of the operators is hard-wired
+ into the parser.
+ Add parentheses if you want an expression with multiple operators
+ to be parsed in some other way than what the precedence rules imply.
+
Table 4.2. Operator Precedence (highest to lowest)
| Operator/Element | Associativity | Description |
|---|
. | left | table/column name separator |
:: | left | PostgreSQL-style typecast |
[ ] | left | array element selection |
+ - | right | unary plus, unary minus |
COLLATE | left | collation selection |
AT | left | AT TIME ZONE |
^ | left | exponentiation |
* / % | left | multiplication, division, modulo |
+ - | left | addition, subtraction |
| (any other operator) | left | all other native and user-defined operators |
BETWEEN IN LIKE ILIKE SIMILAR | | range containment, set membership, string matching |
< > = <= >= <>
+ | | comparison operators |
IS ISNULL NOTNULL | | IS TRUE, IS FALSE, IS
+ NULL, IS DISTINCT FROM, etc. |
NOT | right | logical negation |
AND | left | logical conjunction |
OR | left | logical disjunction |
+ Note that the operator precedence rules also apply to user-defined
+ operators that have the same names as the built-in operators
+ mentioned above. For example, if you define a
+ “+” operator for some custom data type it will have
+ the same precedence as the built-in “+” operator, no
+ matter what yours does.
+
+ When a schema-qualified operator name is used in the
+ OPERATOR syntax, as for example in:
+
+SELECT 3 OPERATOR(pg_catalog.+) 4;
+
+ the OPERATOR construct is taken to have the default precedence
+ shown in Table 4.2 for
+ “any other operator”. This is true no matter
+ which specific operator appears inside OPERATOR().
+
Note
+ PostgreSQL versions before 9.5 used slightly different
+ operator precedence rules. In particular, <=
+ >= and <> used to be treated as
+ generic operators; IS tests used to have higher priority;
+ and NOT BETWEEN and related constructs acted inconsistently,
+ being taken in some cases as having the precedence of NOT
+ rather than BETWEEN. These rules were changed for better
+ compliance with the SQL standard and to reduce confusion from
+ inconsistent treatment of logically equivalent constructs. In most
+ cases, these changes will result in no behavioral change, or perhaps
+ in “no such operator” failures which can be resolved by adding
+ parentheses. However there are corner cases in which a query might
+ change behavior without any parsing error being reported.
+
+ This chapter describes the syntax of SQL. It forms the foundation
+ for understanding the following chapters which will go into detail
+ about how SQL commands are applied to define and modify data.
+
+ We also advise users who are already familiar with SQL to read this
+ chapter carefully because it contains several rules and concepts that
+ are implemented inconsistently among SQL databases or that are
+ specific to PostgreSQL.
+
TRUNCATE
TRUNCATE — empty a table or set of tables
Synopsis
+TRUNCATE [ TABLE ] [ ONLY ] name [ * ] [, ... ]
+ [ RESTART IDENTITY | CONTINUE IDENTITY ] [ CASCADE | RESTRICT ]
+
Description
+ TRUNCATE quickly removes all rows from a set of
+ tables. It has the same effect as an unqualified
+ DELETE on each table, but since it does not actually
+ scan the tables it is faster. Furthermore, it reclaims disk space
+ immediately, rather than requiring a subsequent VACUUM
+ operation. This is most useful on large tables.
+
Parameters
name
+ The name (optionally schema-qualified) of a table to truncate.
+ If ONLY is specified before the table name, only that table
+ is truncated. If ONLY is not specified, the table and all
+ its descendant tables (if any) are truncated. Optionally, *
+ can be specified after the table name to explicitly indicate that
+ descendant tables are included.
+
RESTART IDENTITY
+ Automatically restart sequences owned by columns of
+ the truncated table(s).
+
CONTINUE IDENTITY
+ Do not change the values of sequences. This is the default.
+
CASCADE
+ Automatically truncate all tables that have foreign-key references
+ to any of the named tables, or to any tables added to the group
+ due to CASCADE.
+
RESTRICT
+ Refuse to truncate if any of the tables have foreign-key references
+ from tables that are not listed in the command. This is the default.
+
Notes
+ You must have the TRUNCATE privilege on a table
+ to truncate it.
+
+ TRUNCATE acquires an ACCESS EXCLUSIVE lock on each
+ table it operates on, which blocks all other concurrent operations
+ on the table. When RESTART IDENTITY is specified, any
+ sequences that are to be restarted are likewise locked exclusively.
+ If concurrent access to a table is required, then
+ the DELETE command should be used instead.
+
+ TRUNCATE cannot be used on a table that has foreign-key
+ references from other tables, unless all such tables are also truncated
+ in the same command. Checking validity in such cases would require table
+ scans, and the whole point is not to do one. The CASCADE
+ option can be used to automatically include all dependent tables —
+ but be very careful when using this option, or else you might lose data you
+ did not intend to!
+ Note in particular that when the table to be truncated is a partition,
+ siblings partitions are left untouched, but cascading occurs to all
+ referencing tables and all their partitions with no distinction.
+
+ TRUNCATE will not fire any ON DELETE
+ triggers that might exist for the tables. But it will fire
+ ON TRUNCATE triggers.
+ If ON TRUNCATE triggers are defined for any of
+ the tables, then all BEFORE TRUNCATE triggers are
+ fired before any truncation happens, and all AFTER
+ TRUNCATE triggers are fired after the last truncation is
+ performed and any sequences are reset.
+ The triggers will fire in the order that the tables are
+ to be processed (first those listed in the command, and then any
+ that were added due to cascading).
+
+ TRUNCATE is not MVCC-safe. After truncation, the table will
+ appear empty to concurrent transactions, if they are using a snapshot
+ taken before the truncation occurred.
+ See Section 13.6 for more details.
+
+ TRUNCATE is transaction-safe with respect to the data
+ in the tables: the truncation will be safely rolled back if the surrounding
+ transaction does not commit.
+
+ When RESTART IDENTITY is specified, the implied
+ ALTER SEQUENCE RESTART operations are also done
+ transactionally; that is, they will be rolled back if the surrounding
+ transaction does not commit. Be aware that if any additional
+ sequence operations are done on the restarted sequences before the
+ transaction rolls back, the effects of these operations on the sequences
+ will be rolled back, but not their effects on currval();
+ that is, after the transaction currval() will continue to
+ reflect the last sequence value obtained inside the failed transaction,
+ even though the sequence itself may no longer be consistent with that.
+ This is similar to the usual behavior of currval() after
+ a failed transaction.
+
+ TRUNCATE can be used for foreign tables if
+ supported by the foreign data wrapper, for instance,
+ see postgres_fdw.
+
Examples
+ Truncate the tables bigtable and
+ fattable:
+
+
+TRUNCATE bigtable, fattable;
+
+
+ The same, and also reset any associated sequence generators:
+
+
+TRUNCATE bigtable, fattable RESTART IDENTITY;
+
+
+ Truncate the table othertable, and cascade to any tables
+ that reference othertable via foreign-key
+ constraints:
+
+
+TRUNCATE othertable CASCADE;
+
Compatibility
+ The SQL:2008 standard includes a TRUNCATE command
+ with the syntax TRUNCATE TABLE
+ tablename. The clauses
+ CONTINUE IDENTITY/RESTART IDENTITY
+ also appear in that standard, but have slightly different though related
+ meanings. Some of the concurrency behavior of this command is left
+ implementation-defined by the standard, so the above notes should be
+ considered and compared with other implementations if necessary.
+
UNLISTEN
UNLISTEN — stop listening for a notification
Synopsis
+UNLISTEN { channel | * }
+Description
+ UNLISTEN is used to remove an existing
+ registration for NOTIFY events.
+ UNLISTEN cancels any existing registration of
+ the current PostgreSQL session as a
+ listener on the notification channel named channel. The special wildcard
+ * cancels all listener registrations for the
+ current session.
+
+ NOTIFY
+ contains a more extensive
+ discussion of the use of LISTEN and
+ NOTIFY.
+
Parameters
channel
+ Name of a notification channel (any identifier).
+
*
+ All current listen registrations for this session are cleared.
+
Notes
+ You can unlisten something you were not listening for; no warning or error
+ will appear.
+
+ At the end of each session, UNLISTEN * is
+ automatically executed.
+
+ A transaction that has executed UNLISTEN cannot be
+ prepared for two-phase commit.
+
Examples
+ To make a registration:
+
+
+LISTEN virtual;
+NOTIFY virtual;
+Asynchronous notification "virtual" received from server process with PID 8448.
+
+
+ Once UNLISTEN has been executed, further NOTIFY
+ messages will be ignored:
+
+
+UNLISTEN virtual;
+NOTIFY virtual;
+-- no NOTIFY event is received
+
Compatibility
+ There is no UNLISTEN command in the SQL standard.
+
UPDATE
UPDATE — update rows of a table
Synopsis
+[ WITH [ RECURSIVE ] with_query [, ...] ]
+UPDATE [ ONLY ] table_name [ * ] [ [ AS ] alias ]
+ SET { column_name = { expression | DEFAULT } |
+ ( column_name [, ...] ) = [ ROW ] ( { expression | DEFAULT } [, ...] ) |
+ ( column_name [, ...] ) = ( sub-SELECT )
+ } [, ...]
+ [ FROM from_item [, ...] ]
+ [ WHERE condition | WHERE CURRENT OF cursor_name ]
+ [ RETURNING * | output_expression [ [ AS ] output_name ] [, ...] ]
+
Description
+ UPDATE changes the values of the specified
+ columns in all rows that satisfy the condition. Only the columns to
+ be modified need be mentioned in the SET clause;
+ columns not explicitly modified retain their previous values.
+
+ There are two ways to modify a table using information contained in
+ other tables in the database: using sub-selects, or specifying
+ additional tables in the FROM clause. Which
+ technique is more appropriate depends on the specific
+ circumstances.
+
+ The optional RETURNING clause causes UPDATE
+ to compute and return value(s) based on each row actually updated.
+ Any expression using the table's columns, and/or columns of other
+ tables mentioned in FROM, can be computed.
+ The new (post-update) values of the table's columns are used.
+ The syntax of the RETURNING list is identical to that of the
+ output list of SELECT.
+
+ You must have the UPDATE privilege on the table,
+ or at least on the column(s) that are listed to be updated.
+ You must also have the SELECT
+ privilege on any column whose values are read in the
+ expressions or
+ condition.
+
Parameters
with_query
+ The WITH clause allows you to specify one or more
+ subqueries that can be referenced by name in the UPDATE
+ query. See Section 7.8 and SELECT
+ for details.
+
table_name
+ The name (optionally schema-qualified) of the table to update.
+ If ONLY is specified before the table name, matching rows
+ are updated in the named table only. If ONLY is not
+ specified, matching rows are also updated in any tables inheriting from
+ the named table. Optionally, * can be specified after the
+ table name to explicitly indicate that descendant tables are included.
+
alias
+ A substitute name for the target table. When an alias is
+ provided, it completely hides the actual name of the table. For
+ example, given UPDATE foo AS f, the remainder of the
+ UPDATE statement must refer to this table as
+ f not foo.
+
column_name
+ The name of a column in the table named by table_name.
+ The column name can be qualified with a subfield name or array
+ subscript, if needed. Do not include the table's name in the
+ specification of a target column — for example,
+ UPDATE table_name SET table_name.col = 1 is invalid.
+
expression
+ An expression to assign to the column. The expression can use the
+ old values of this and other columns in the table.
+
DEFAULT
+ Set the column to its default value (which will be NULL if no specific
+ default expression has been assigned to it). An identity column will be
+ set to a new value generated by the associated sequence. For a
+ generated column, specifying this is permitted but merely specifies the
+ normal behavior of computing the column from its generation expression.
+
sub-SELECT
+ A SELECT sub-query that produces as many output columns
+ as are listed in the parenthesized column list preceding it. The
+ sub-query must yield no more than one row when executed. If it
+ yields one row, its column values are assigned to the target columns;
+ if it yields no rows, NULL values are assigned to the target columns.
+ The sub-query can refer to old values of the current row of the table
+ being updated.
+
from_item
+ A table expression allowing columns from other tables to appear in
+ the WHERE condition and update expressions. This
+ uses the same syntax as the FROM clause of
+ a SELECT statement;
+ for example, an alias for the table name can be specified. Do not
+ repeat the target table as a from_item
+ unless you intend a self-join (in which case it must appear with
+ an alias in the from_item).
+
condition
+ An expression that returns a value of type boolean.
+ Only rows for which this expression returns true
+ will be updated.
+
cursor_name
+ The name of the cursor to use in a WHERE CURRENT OF
+ condition. The row to be updated is the one most recently fetched
+ from this cursor. The cursor must be a non-grouping
+ query on the UPDATE's target table.
+ Note that WHERE CURRENT OF cannot be
+ specified together with a Boolean condition. See
+ DECLARE
+ for more information about using cursors with
+ WHERE CURRENT OF.
+
output_expression
+ An expression to be computed and returned by the UPDATE
+ command after each row is updated. The expression can use any
+ column names of the table named by table_name
+ or table(s) listed in FROM.
+ Write * to return all columns.
+
output_name
+ A name to use for a returned column.
+
Outputs
+ On successful completion, an UPDATE command returns a command
+ tag of the form
+
+UPDATE count
+
+ The count is the number
+ of rows updated, including matched rows whose values did not change.
+ Note that the number may be less than the number of rows that matched
+ the condition when
+ updates were suppressed by a BEFORE UPDATE trigger. If
+ count is 0, no rows were
+ updated by the query (this is not considered an error).
+
+ If the UPDATE command contains a RETURNING
+ clause, the result will be similar to that of a SELECT
+ statement containing the columns and values defined in the
+ RETURNING list, computed over the row(s) updated by the
+ command.
+
Notes
+ When a FROM clause is present, what essentially happens
+ is that the target table is joined to the tables mentioned in the
+ from_item list, and each output row of the join
+ represents an update operation for the target table. When using
+ FROM you should ensure that the join
+ produces at most one output row for each row to be modified. In
+ other words, a target row shouldn't join to more than one row from
+ the other table(s). If it does, then only one of the join rows
+ will be used to update the target row, but which one will be used
+ is not readily predictable.
+
+ Because of this indeterminacy, referencing other tables only within
+ sub-selects is safer, though often harder to read and slower than
+ using a join.
+
+ In the case of a partitioned table, updating a row might cause it to no
+ longer satisfy the partition constraint of the containing partition. In that
+ case, if there is some other partition in the partition tree for which this
+ row satisfies its partition constraint, then the row is moved to that
+ partition. If there is no such partition, an error will occur. Behind the
+ scenes, the row movement is actually a DELETE and
+ INSERT operation.
+
+ There is a possibility that a concurrent UPDATE or
+ DELETE on the row being moved will get a serialization
+ failure error. Suppose session 1 is performing an UPDATE
+ on a partition key, and meanwhile a concurrent session 2 for which this
+ row is visible performs an UPDATE or
+ DELETE operation on this row. In such case,
+ session 2's UPDATE or DELETE will
+ detect the row movement and raise a serialization failure error (which
+ always returns with an SQLSTATE code '40001'). Applications may wish to
+ retry the transaction if this occurs. In the usual case where the table
+ is not partitioned, or where there is no row movement, session 2 would
+ have identified the newly updated row and carried out the
+ UPDATE/DELETE on this new row
+ version.
+
+ Note that while rows can be moved from local partitions to a foreign-table
+ partition (provided the foreign data wrapper supports tuple routing), they
+ cannot be moved from a foreign-table partition to another partition.
+
+ An attempt of moving a row from one partition to another will fail if a
+ foreign key is found to directly reference an ancestor of the source
+ partition that is not the same as the ancestor that's mentioned in the
+ UPDATE query.
+
Examples
+ Change the word Drama to Dramatic in the
+ column kind of the table films:
+
+
+UPDATE films SET kind = 'Dramatic' WHERE kind = 'Drama';
+
+
+ Adjust temperature entries and reset precipitation to its default
+ value in one row of the table weather:
+
+
+UPDATE weather SET temp_lo = temp_lo+1, temp_hi = temp_lo+15, prcp = DEFAULT
+ WHERE city = 'San Francisco' AND date = '2003-07-03';
+
+
+ Perform the same operation and return the updated entries:
+
+
+UPDATE weather SET temp_lo = temp_lo+1, temp_hi = temp_lo+15, prcp = DEFAULT
+ WHERE city = 'San Francisco' AND date = '2003-07-03'
+ RETURNING temp_lo, temp_hi, prcp;
+
+
+ Use the alternative column-list syntax to do the same update:
+
+UPDATE weather SET (temp_lo, temp_hi, prcp) = (temp_lo+1, temp_lo+15, DEFAULT)
+ WHERE city = 'San Francisco' AND date = '2003-07-03';
+
+
+ Increment the sales count of the salesperson who manages the
+ account for Acme Corporation, using the FROM
+ clause syntax:
+
+UPDATE employees SET sales_count = sales_count + 1 FROM accounts
+ WHERE accounts.name = 'Acme Corporation'
+ AND employees.id = accounts.sales_person;
+
+
+ Perform the same operation, using a sub-select in the
+ WHERE clause:
+
+UPDATE employees SET sales_count = sales_count + 1 WHERE id =
+ (SELECT sales_person FROM accounts WHERE name = 'Acme Corporation');
+
+
+ Update contact names in an accounts table to match the currently assigned
+ salespeople:
+
+UPDATE accounts SET (contact_first_name, contact_last_name) =
+ (SELECT first_name, last_name FROM employees
+ WHERE employees.id = accounts.sales_person);
+
+ A similar result could be accomplished with a join:
+
+UPDATE accounts SET contact_first_name = first_name,
+ contact_last_name = last_name
+ FROM employees WHERE employees.id = accounts.sales_person;
+
+ However, the second query may give unexpected results
+ if employees.id is not a unique key, whereas
+ the first query is guaranteed to raise an error if there are multiple
+ id matches. Also, if there is no match for a particular
+ accounts.sales_person entry, the first query
+ will set the corresponding name fields to NULL, whereas the second query
+ will not update that row at all.
+
+ Update statistics in a summary table to match the current data:
+
+UPDATE summary s SET (sum_x, sum_y, avg_x, avg_y) =
+ (SELECT sum(x), sum(y), avg(x), avg(y) FROM data d
+ WHERE d.group_id = s.group_id);
+
+
+ Attempt to insert a new stock item along with the quantity of stock. If
+ the item already exists, instead update the stock count of the existing
+ item. To do this without failing the entire transaction, use savepoints:
+
+BEGIN;
+-- other operations
+SAVEPOINT sp1;
+INSERT INTO wines VALUES('Chateau Lafite 2003', '24');
+-- Assume the above fails because of a unique key violation,
+-- so now we issue these commands:
+ROLLBACK TO sp1;
+UPDATE wines SET stock = stock + 24 WHERE winename = 'Chateau Lafite 2003';
+-- continue with other operations, and eventually
+COMMIT;
+
+
+ Change the kind column of the table
+ films in the row on which the cursor
+ c_films is currently positioned:
+
+UPDATE films SET kind = 'Dramatic' WHERE CURRENT OF c_films;
+
Compatibility
+ This command conforms to the SQL standard, except
+ that the FROM and RETURNING clauses
+ are PostgreSQL extensions, as is the ability
+ to use WITH with UPDATE.
+
+ Some other database systems offer a FROM option in which
+ the target table is supposed to be listed again within FROM.
+ That is not how PostgreSQL interprets
+ FROM. Be careful when porting applications that use this
+ extension.
+
+ According to the standard, the source value for a parenthesized sub-list of
+ target column names can be any row-valued expression yielding the correct
+ number of columns. PostgreSQL only allows the
+ source value to be a row
+ constructor or a sub-SELECT. An individual column's
+ updated value can be specified as DEFAULT in the
+ row-constructor case, but not inside a sub-SELECT.
+
VACUUM
VACUUM — garbage-collect and optionally analyze a database
Synopsis
+VACUUM [ ( option [, ...] ) ] [ table_and_columns [, ...] ]
+VACUUM [ FULL ] [ FREEZE ] [ VERBOSE ] [ ANALYZE ] [ table_and_columns [, ...] ]
+
+where option can be one of:
+
+ FULL [ boolean ]
+ FREEZE [ boolean ]
+ VERBOSE [ boolean ]
+ ANALYZE [ boolean ]
+ DISABLE_PAGE_SKIPPING [ boolean ]
+ SKIP_LOCKED [ boolean ]
+ INDEX_CLEANUP { AUTO | ON | OFF }
+ PROCESS_MAIN [ boolean ]
+ PROCESS_TOAST [ boolean ]
+ TRUNCATE [ boolean ]
+ PARALLEL integer
+ SKIP_DATABASE_STATS [ boolean ]
+ ONLY_DATABASE_STATS [ boolean ]
+ BUFFER_USAGE_LIMIT size
+
+and table_and_columns is:
+
+ table_name [ ( column_name [, ...] ) ]
+
Description
+ VACUUM reclaims storage occupied by dead tuples.
+ In normal PostgreSQL operation, tuples that
+ are deleted or obsoleted by an update are not physically removed from
+ their table; they remain present until a VACUUM is
+ done. Therefore it's necessary to do VACUUM
+ periodically, especially on frequently-updated tables.
+
+ Without a table_and_columns
+ list, VACUUM processes every table and materialized view
+ in the current database that the current user has permission to vacuum.
+ With a list, VACUUM processes only those table(s).
+
+ VACUUM ANALYZE performs a VACUUM
+ and then an ANALYZE for each selected table. This
+ is a handy combination form for routine maintenance scripts. See
+ ANALYZE
+ for more details about its processing.
+
+ Plain VACUUM (without FULL) simply reclaims
+ space and makes it
+ available for re-use. This form of the command can operate in parallel
+ with normal reading and writing of the table, as an exclusive lock
+ is not obtained. However, extra space is not returned to the operating
+ system (in most cases); it's just kept available for re-use within the
+ same table. It also allows us to leverage multiple CPUs in order to process
+ indexes. This feature is known as parallel vacuum.
+ To disable this feature, one can use PARALLEL option and
+ specify parallel workers as zero. VACUUM FULL rewrites
+ the entire contents of the table into a new disk file with no extra space,
+ allowing unused space to be returned to the operating system. This form is
+ much slower and requires an ACCESS EXCLUSIVE lock on
+ each table while it is being processed.
+
+ When the option list is surrounded by parentheses, the options can be
+ written in any order. Without parentheses, options must be specified
+ in exactly the order shown above.
+ The parenthesized syntax was added in
+ PostgreSQL 9.0; the unparenthesized
+ syntax is deprecated.
+
Parameters
FULL
+ Selects “full” vacuum, which can reclaim more
+ space, but takes much longer and exclusively locks the table.
+ This method also requires extra disk space, since it writes a
+ new copy of the table and doesn't release the old copy until
+ the operation is complete. Usually this should only be used when a
+ significant amount of space needs to be reclaimed from within the table.
+
FREEZE
+ Selects aggressive “freezing” of tuples.
+ Specifying FREEZE is equivalent to performing
+ VACUUM with the
+ vacuum_freeze_min_age and
+ vacuum_freeze_table_age parameters
+ set to zero. Aggressive freezing is always performed when the
+ table is rewritten, so this option is redundant when FULL
+ is specified.
+
VERBOSE
+ Prints a detailed vacuum activity report for each table.
+
ANALYZE
+ Updates statistics used by the planner to determine the most
+ efficient way to execute a query.
+
DISABLE_PAGE_SKIPPING
+ Normally, VACUUM will skip pages based on the visibility map. Pages where
+ all tuples are known to be frozen can always be skipped, and those
+ where all tuples are known to be visible to all transactions may be
+ skipped except when performing an aggressive vacuum. Furthermore,
+ except when performing an aggressive vacuum, some pages may be skipped
+ in order to avoid waiting for other sessions to finish using them.
+ This option disables all page-skipping behavior, and is intended to
+ be used only when the contents of the visibility map are
+ suspect, which should happen only if there is a hardware or software
+ issue causing database corruption.
+
SKIP_LOCKED
+ Specifies that VACUUM should not wait for any
+ conflicting locks to be released when beginning work on a relation:
+ if a relation cannot be locked immediately without waiting, the relation
+ is skipped. Note that even with this option,
+ VACUUM may still block when opening the relation's
+ indexes. Additionally, VACUUM ANALYZE may still
+ block when acquiring sample rows from partitions, table inheritance
+ children, and some types of foreign tables. Also, while
+ VACUUM ordinarily processes all partitions of
+ specified partitioned tables, this option will cause
+ VACUUM to skip all partitions if there is a
+ conflicting lock on the partitioned table.
+
INDEX_CLEANUP
+ Normally, VACUUM will skip index vacuuming
+ when there are very few dead tuples in the table. The cost of
+ processing all of the table's indexes is expected to greatly
+ exceed the benefit of removing dead index tuples when this
+ happens. This option can be used to force
+ VACUUM to process indexes when there are more
+ than zero dead tuples. The default is AUTO,
+ which allows VACUUM to skip index vacuuming
+ when appropriate. If INDEX_CLEANUP is set to
+ ON, VACUUM will
+ conservatively remove all dead tuples from indexes. This may be
+ useful for backwards compatibility with earlier releases of
+ PostgreSQL where this was the
+ standard behavior.
+
+ INDEX_CLEANUP can also be set to
+ OFF to force VACUUM to
+ always skip index vacuuming, even when
+ there are many dead tuples in the table. This may be useful
+ when it is necessary to make VACUUM run as
+ quickly as possible to avoid imminent transaction ID wraparound
+ (see Section 25.1.5). However, the
+ wraparound failsafe mechanism controlled by vacuum_failsafe_age will generally trigger
+ automatically to avoid transaction ID wraparound failure, and
+ should be preferred. If index cleanup is not performed
+ regularly, performance may suffer, because as the table is
+ modified indexes will accumulate dead tuples and the table
+ itself will accumulate dead line pointers that cannot be removed
+ until index cleanup is completed.
+
+ This option has no effect for tables that have no index and is
+ ignored if the FULL option is used. It also
+ has no effect on the transaction ID wraparound failsafe
+ mechanism. When triggered it will skip index vacuuming, even
+ when INDEX_CLEANUP is set to
+ ON.
+
PROCESS_MAIN
+ Specifies that VACUUM should attempt to process the
+ main relation. This is usually the desired behavior and is the default.
+ Setting this option to false may be useful when it is only necessary to
+ vacuum a relation's corresponding TOAST table.
+
PROCESS_TOAST
+ Specifies that VACUUM should attempt to process the
+ corresponding TOAST table for each relation, if one
+ exists. This is usually the desired behavior and is the default.
+ Setting this option to false may be useful when it is only necessary to
+ vacuum the main relation. This option is required when the
+ FULL option is used.
+
TRUNCATE
+ Specifies that VACUUM should attempt to
+ truncate off any empty pages at the end of the table and allow
+ the disk space for the truncated pages to be returned to
+ the operating system. This is normally the desired behavior
+ and is the default unless the vacuum_truncate
+ option has been set to false for the table to be vacuumed.
+ Setting this option to false may be useful to avoid
+ ACCESS EXCLUSIVE lock on the table that
+ the truncation requires. This option is ignored if the
+ FULL option is used.
+
PARALLEL
+ Perform index vacuum and index cleanup phases of VACUUM
+ in parallel using integer
+ background workers (for the details of each vacuum phase, please
+ refer to Table 28.45). The number of workers used
+ to perform the operation is equal to the number of indexes on the
+ relation that support parallel vacuum which is limited by the number of
+ workers specified with PARALLEL option if any which is
+ further limited by max_parallel_maintenance_workers.
+ An index can participate in parallel vacuum if and only if the size of the
+ index is more than min_parallel_index_scan_size.
+ Please note that it is not guaranteed that the number of parallel workers
+ specified in integer will be
+ used during execution. It is possible for a vacuum to run with fewer
+ workers than specified, or even with no workers at all. Only one worker
+ can be used per index. So parallel workers are launched only when there
+ are at least 2 indexes in the table. Workers for
+ vacuum are launched before the start of each phase and exit at the end of
+ the phase. These behaviors might change in a future release. This
+ option can't be used with the FULL option.
+
SKIP_DATABASE_STATS
+ Specifies that VACUUM should skip updating the
+ database-wide statistics about oldest unfrozen XIDs. Normally
+ VACUUM will update these statistics once at the
+ end of the command. However, this can take awhile in a database
+ with a very large number of tables, and it will accomplish nothing
+ unless the table that had contained the oldest unfrozen XID was
+ among those vacuumed. Moreover, if multiple VACUUM
+ commands are issued in parallel, only one of them can update the
+ database-wide statistics at a time. Therefore, if an application
+ intends to issue a series of many VACUUM
+ commands, it can be helpful to set this option in all but the last
+ such command; or set it in all the commands and separately
+ issue VACUUM (ONLY_DATABASE_STATS) afterwards.
+
ONLY_DATABASE_STATS
+ Specifies that VACUUM should do nothing except
+ update the database-wide statistics about oldest unfrozen XIDs.
+ When this option is specified,
+ the table_and_columns
+ list must be empty, and no other option may be enabled
+ except VERBOSE.
+
BUFFER_USAGE_LIMIT
+ Specifies the
+ Buffer Access Strategy
+ ring buffer size for VACUUM. This size is used to
+ calculate the number of shared buffers which will be reused as part of
+ this strategy. 0 disables use of a
+ Buffer Access Strategy. If ANALYZE
+ is also specified, the BUFFER_USAGE_LIMIT value is used
+ for both the vacuum and analyze stages. This option can't be used with
+ the FULL option except if ANALYZE is
+ also specified. When this option is not specified,
+ VACUUM uses the value from
+ vacuum_buffer_usage_limit. Higher settings can
+ allow VACUUM to run more quickly, but having too
+ large a setting may cause too many other useful pages to be evicted from
+ shared buffers. The minimum value is 128 kB and the
+ maximum value is 16 GB.
+
boolean
+ Specifies whether the selected option should be turned on or off.
+ You can write TRUE, ON, or
+ 1 to enable the option, and FALSE,
+ OFF, or 0 to disable it. The
+ boolean value can also
+ be omitted, in which case TRUE is assumed.
+
integer
+ Specifies a non-negative integer value passed to the selected option.
+
size
+ Specifies an amount of memory in kilobytes. Sizes may also be specified
+ as a string containing the numerical size followed by any one of the
+ following memory units: B (bytes),
+ kB (kilobytes), MB (megabytes),
+ GB (gigabytes), or TB (terabytes).
+
table_name
+ The name (optionally schema-qualified) of a specific table or
+ materialized view to vacuum. If the specified table is a partitioned
+ table, all of its leaf partitions are vacuumed.
+
column_name
+ The name of a specific column to analyze. Defaults to all columns.
+ If a column list is specified, ANALYZE must also be
+ specified.
+
Outputs
+ When VERBOSE is specified, VACUUM emits
+ progress messages to indicate which table is currently being
+ processed. Various statistics about the tables are printed as well.
+
Notes
+ To vacuum a table, one must ordinarily be the table's owner or a
+ superuser. However, database owners are allowed to
+ vacuum all tables in their databases, except shared catalogs.
+ (The restriction for shared catalogs means that a true database-wide
+ VACUUM can only be performed by a superuser.)
+ VACUUM will skip over any tables that the calling user
+ does not have permission to vacuum.
+
+ VACUUM cannot be executed inside a transaction block.
+
+ For tables with GIN indexes, VACUUM (in
+ any form) also completes any pending index insertions, by moving pending
+ index entries to the appropriate places in the main GIN index
+ structure. See Section 70.4.1 for details.
+
+ We recommend that all databases be vacuumed regularly in
+ order to remove dead rows. PostgreSQL includes
+ an “autovacuum” facility which can automate routine vacuum
+ maintenance. For more information about automatic and manual vacuuming,
+ see Section 25.1.
+
+ The FULL option is not recommended for routine use,
+ but might be useful in special cases. An example is when you have deleted
+ or updated most of the rows in a table and would like the table to
+ physically shrink to occupy less disk space and allow faster table
+ scans. VACUUM FULL will usually shrink the table
+ more than a plain VACUUM would.
+
+ The PARALLEL option is used only for vacuum purposes.
+ If this option is specified with the ANALYZE option,
+ it does not affect ANALYZE.
+
+ VACUUM causes a substantial increase in I/O traffic,
+ which might cause poor performance for other active sessions. Therefore,
+ it is sometimes advisable to use the cost-based vacuum delay feature. For
+ parallel vacuum, each worker sleeps in proportion to the work done by that
+ worker. See Section 20.4.4 for
+ details.
+
+ Each backend running VACUUM without the
+ FULL option will report its progress in the
+ pg_stat_progress_vacuum view. Backends running
+ VACUUM FULL will instead report their progress in the
+ pg_stat_progress_cluster view. See
+ Section 28.4.5 and
+ Section 28.4.2 for details.
+
Examples
+ To clean a single table onek, analyze it for
+ the optimizer and print a detailed vacuum activity report:
+
+
+VACUUM (VERBOSE, ANALYZE) onek;
+
Compatibility
+ There is no VACUUM statement in the SQL standard.
+
VALUES
VALUES — compute a set of rows
Synopsis
+VALUES ( expression [, ...] ) [, ...]
+ [ ORDER BY sort_expression [ ASC | DESC | USING operator ] [, ...] ]
+ [ LIMIT { count | ALL } ]
+ [ OFFSET start [ ROW | ROWS ] ]
+ [ FETCH { FIRST | NEXT } [ count ] { ROW | ROWS } ONLY ]
+
Description
+ VALUES computes a row value or set of row values
+ specified by value expressions. It is most commonly used to generate
+ a “constant table” within a larger command, but it can be
+ used on its own.
+
+ When more than one row is specified, all the rows must have the same
+ number of elements. The data types of the resulting table's columns are
+ determined by combining the explicit or inferred types of the expressions
+ appearing in that column, using the same rules as for UNION
+ (see Section 10.5).
+
+ Within larger commands, VALUES is syntactically allowed
+ anywhere that SELECT is. Because it is treated like a
+ SELECT by the grammar, it is possible to use
+ the ORDER BY, LIMIT (or
+ equivalently FETCH FIRST),
+ and OFFSET clauses with a
+ VALUES command.
+
Parameters
expression
+ A constant or expression to compute and insert at the indicated place
+ in the resulting table (set of rows). In a VALUES list
+ appearing at the top level of an INSERT, an
+ expression can be replaced
+ by DEFAULT to indicate that the destination column's
+ default value should be inserted. DEFAULT cannot
+ be used when VALUES appears in other contexts.
+
sort_expression
+ An expression or integer constant indicating how to sort the result
+ rows. This expression can refer to the columns of the
+ VALUES result as column1, column2,
+ etc. For more details see
+ ORDER BY Clause
+ in the SELECT documentation.
+
operator
+ A sorting operator. For details see
+ ORDER BY Clause
+ in the SELECT documentation.
+
count
+ The maximum number of rows to return. For details see
+ LIMIT Clause
+ in the SELECT documentation.
+
start
+ The number of rows to skip before starting to return rows.
+ For details see LIMIT Clause
+ in the SELECT documentation.
+
Notes
+ VALUES lists with very large numbers of rows should be avoided,
+ as you might encounter out-of-memory failures or poor performance.
+ VALUES appearing within INSERT is a special case
+ (because the desired column types are known from the INSERT's
+ target table, and need not be inferred by scanning the VALUES
+ list), so it can handle larger lists than are practical in other contexts.
+
Examples
+ A bare VALUES command:
+
+
+VALUES (1, 'one'), (2, 'two'), (3, 'three');
+
+
+ This will return a table of two columns and three rows. It's effectively
+ equivalent to:
+
+
+SELECT 1 AS column1, 'one' AS column2
+UNION ALL
+SELECT 2, 'two'
+UNION ALL
+SELECT 3, 'three';
+
+
+
+ More usually, VALUES is used within a larger SQL command.
+ The most common use is in INSERT:
+
+
+INSERT INTO films (code, title, did, date_prod, kind)
+ VALUES ('T_601', 'Yojimbo', 106, '1961-06-16', 'Drama');
+
+
+ In the context of INSERT, entries of a VALUES list
+ can be DEFAULT to indicate that the column default
+ should be used here instead of specifying a value:
+
+
+INSERT INTO films VALUES
+ ('UA502', 'Bananas', 105, DEFAULT, 'Comedy', '82 minutes'),
+ ('T_601', 'Yojimbo', 106, DEFAULT, 'Drama', DEFAULT);
+
+
+ VALUES can also be used where a sub-SELECT might
+ be written, for example in a FROM clause:
+
+
+SELECT f.*
+ FROM films f, (VALUES('MGM', 'Horror'), ('UA', 'Sci-Fi')) AS t (studio, kind)
+ WHERE f.studio = t.studio AND f.kind = t.kind;
+
+UPDATE employees SET salary = salary * v.increase
+ FROM (VALUES(1, 200000, 1.2), (2, 400000, 1.4)) AS v (depno, target, increase)
+ WHERE employees.depno = v.depno AND employees.sales >= v.target;
+
+
+ Note that an AS clause is required when VALUES
+ is used in a FROM clause, just as is true for
+ SELECT. It is not required that the AS clause
+ specify names for all the columns, but it's good practice to do so.
+ (The default column names for VALUES are column1,
+ column2, etc. in PostgreSQL, but
+ these names might be different in other database systems.)
+
+ When VALUES is used in INSERT, the values are all
+ automatically coerced to the data type of the corresponding destination
+ column. When it's used in other contexts, it might be necessary to specify
+ the correct data type. If the entries are all quoted literal constants,
+ coercing the first is sufficient to determine the assumed type for all:
+
+
+SELECT * FROM machines
+WHERE ip_address IN (VALUES('192.168.0.1'::inet), ('192.168.0.10'), ('192.168.1.43'));
+Tip
+ For simple IN tests, it's better to rely on the
+ list-of-scalars
+ form of IN than to write a VALUES
+ query as shown above. The list of scalars method requires less writing
+ and is often more efficient.
+
Compatibility
VALUES conforms to the SQL standard.
+ LIMIT and OFFSET are
+ PostgreSQL extensions; see also
+ under SELECT.
+
Part II. The SQL Language
+ This part describes the use of the SQL language
+ in PostgreSQL. We start with
+ describing the general syntax of SQL, then
+ explain how to create the structures to hold data, how to populate
+ the database, and how to query it. The middle part lists the
+ available data types and functions for use in
+ SQL commands. The rest treats several
+ aspects that are important for tuning a database for optimal
+ performance.
+
+ The information in this part is arranged so that a novice user can
+ follow it start to end to gain a full understanding of the topics
+ without having to refer forward too many times. The chapters are
+ intended to be self-contained, so that advanced users can read the
+ chapters individually as they choose. The information in this
+ part is presented in a narrative fashion in topical units.
+ Readers looking for a complete description of a particular command
+ should see Part VI.
+
+ Readers of this part should know how to connect to a
+ PostgreSQL database and issue
+ SQL commands. Readers that are unfamiliar with
+ these issues are encouraged to read Part I
+ first. SQL commands are typically entered
+ using the PostgreSQL interactive terminal
+ psql, but other programs that have
+ similar functionality can be used as well.
+
19.11. Secure TCP/IP Connections with SSH Tunnels #
+ It is possible to use SSH to encrypt the network
+ connection between clients and a
+ PostgreSQL server. Done properly, this
+ provides an adequately secure network connection, even for non-SSL-capable
+ clients.
+
+ First make sure that an SSH server is
+ running properly on the same machine as the
+ PostgreSQL server and that you can log in using
+ ssh as some user; you then can establish a
+ secure tunnel to the remote server. A secure tunnel listens on a
+ local port and forwards all traffic to a port on the remote machine.
+ Traffic sent to the remote port can arrive on its
+ localhost address, or different bind
+ address if desired; it does not appear as coming from your
+ local machine. This command creates a secure tunnel from the client
+ machine to the remote machine foo.com:
+
+ssh -L 63333:localhost:5432 joe@foo.com
+
+ The first number in the -L argument, 63333, is the
+ local port number of the tunnel; it can be any unused port. (IANA
+ reserves ports 49152 through 65535 for private use.) The name or IP
+ address after this is the remote bind address you are connecting to,
+ i.e., localhost, which is the default. The second
+ number, 5432, is the remote end of the tunnel, e.g., the port number
+ your database server is using. In order to connect to the database
+ server using this tunnel, you connect to port 63333 on the local
+ machine:
+
+psql -h localhost -p 63333 postgres
+
+ To the database server it will then look as though you are
+ user joe on host foo.com
+ connecting to the localhost bind address, and it
+ will use whatever authentication procedure was configured for
+ connections by that user to that bind address. Note that the server will not
+ think the connection is SSL-encrypted, since in fact it is not
+ encrypted between the
+ SSH server and the
+ PostgreSQL server. This should not pose any
+ extra security risk because they are on the same machine.
+
+ In order for the
+ tunnel setup to succeed you must be allowed to connect via
+ ssh as joe@foo.com, just
+ as if you had attempted to use ssh to create a
+ terminal session.
+
+ You could also have set up port forwarding as
+
+ssh -L 63333:foo.com:5432 joe@foo.com
+
+ but then the database server will see the connection as coming in
+ on its foo.com bind address, which is not opened by
+ the default setting listen_addresses =
+ 'localhost'. This is usually not what you want.
+
+ If you have to “hop” to the database server via some
+ login host, one possible setup could look like this:
+
+ssh -L 63333:db.foo.com:5432 joe@shell.foo.com
+
+ Note that this way the connection
+ from shell.foo.com
+ to db.foo.com will not be encrypted by the SSH
+ tunnel.
+ SSH offers quite a few configuration possibilities when the network
+ is restricted in various ways. Please refer to the SSH
+ documentation for details.
+
Tip
+ Several other applications exist that can provide secure tunnels using
+ a procedure similar in concept to the one just described.
+
19.9. Secure TCP/IP Connections with SSL #
+ PostgreSQL has native support for using
+ SSL connections to encrypt client/server communications
+ for increased security. This requires that
+ OpenSSL is installed on both client and
+ server systems and that support in PostgreSQL is
+ enabled at build time (see Chapter 17).
+
+ The terms SSL and TLS are often used
+ interchangeably to mean a secure encrypted connection using a
+ TLS protocol. SSL protocols are the
+ precursors to TLS protocols, and the term
+ SSL is still used for encrypted connections even though
+ SSL protocols are no longer supported.
+ SSL is used interchangeably with TLS
+ in PostgreSQL.
+
+
+ With SSL support compiled in, the
+ PostgreSQL server can be started with
+ support for encrypted connections using TLS protocols
+ enabled by setting the parameter
+ ssl to on in
+ postgresql.conf. The server will listen for both normal
+ and SSL connections on the same TCP port, and will negotiate
+ with any connecting client on whether to use SSL. By
+ default, this is at the client's option; see Section 21.1 about how to set up the server to require
+ use of SSL for some or all connections.
+
+ To start in SSL mode, files containing the server certificate
+ and private key must exist. By default, these files are expected to be
+ named server.crt and server.key, respectively, in
+ the server's data directory, but other names and locations can be specified
+ using the configuration parameters ssl_cert_file
+ and ssl_key_file.
+
+ On Unix systems, the permissions on server.key must
+ disallow any access to world or group; achieve this by the command
+ chmod 0600 server.key. Alternatively, the file can be
+ owned by root and have group read access (that is, 0640
+ permissions). That setup is intended for installations where certificate
+ and key files are managed by the operating system. The user under which
+ the PostgreSQL server runs should then be made a
+ member of the group that has access to those certificate and key files.
+
+ If the data directory allows group read access then certificate files may
+ need to be located outside of the data directory in order to conform to the
+ security requirements outlined above. Generally, group access is enabled
+ to allow an unprivileged user to backup the database, and in that case the
+ backup software will not be able to read the certificate files and will
+ likely error.
+
+ If the private key is protected with a passphrase, the
+ server will prompt for the passphrase and will not start until it has
+ been entered.
+ Using a passphrase by default disables the ability to change the server's
+ SSL configuration without a server restart, but see ssl_passphrase_command_supports_reload.
+ Furthermore, passphrase-protected private keys cannot be used at all
+ on Windows.
+
+ The first certificate in server.crt must be the
+ server's certificate because it must match the server's private key.
+ The certificates of “intermediate” certificate authorities
+ can also be appended to the file. Doing this avoids the necessity of
+ storing intermediate certificates on clients, assuming the root and
+ intermediate certificates were created with v3_ca
+ extensions. (This sets the certificate's basic constraint of
+ CA to true.)
+ This allows easier expiration of intermediate certificates.
+
+ It is not necessary to add the root certificate to
+ server.crt. Instead, clients must have the root
+ certificate of the server's certificate chain.
+
19.9.2. OpenSSL Configuration #
+ PostgreSQL reads the system-wide
+ OpenSSL configuration file. By default, this
+ file is named openssl.cnf and is located in the
+ directory reported by openssl version -d.
+ This default can be overridden by setting environment variable
+ OPENSSL_CONF to the name of the desired configuration file.
+
+ OpenSSL supports a wide range of ciphers
+ and authentication algorithms, of varying strength. While a list of
+ ciphers can be specified in the OpenSSL
+ configuration file, you can specify ciphers specifically for use by
+ the database server by modifying ssl_ciphers in
+ postgresql.conf.
+
Note
+ It is possible to have authentication without encryption overhead by
+ using NULL-SHA or NULL-MD5 ciphers. However,
+ a man-in-the-middle could read and pass communications between client
+ and server. Also, encryption overhead is minimal compared to the
+ overhead of authentication. For these reasons NULL ciphers are not
+ recommended.
+
19.9.3. Using Client Certificates #
+ To require the client to supply a trusted certificate,
+ place certificates of the root certificate authorities
+ (CAs) you trust in a file in the data
+ directory, set the parameter ssl_ca_file in
+ postgresql.conf to the new file name, and add the
+ authentication option clientcert=verify-ca or
+ clientcert=verify-full to the appropriate
+ hostssl line(s) in pg_hba.conf.
+ A certificate will then be requested from the client during SSL
+ connection startup. (See Section 34.19 for a description
+ of how to set up certificates on the client.)
+
+ For a hostssl entry with
+ clientcert=verify-ca, the server will verify
+ that the client's certificate is signed by one of the trusted
+ certificate authorities. If clientcert=verify-full
+ is specified, the server will not only verify the certificate
+ chain, but it will also check whether the username or its mapping
+ matches the cn (Common Name) of the provided certificate.
+ Note that certificate chain validation is always ensured when the
+ cert authentication method is used
+ (see Section 21.12).
+
+ Intermediate certificates that chain up to existing root certificates
+ can also appear in the ssl_ca_file file if
+ you wish to avoid storing them on clients (assuming the root and
+ intermediate certificates were created with v3_ca
+ extensions). Certificate Revocation List (CRL) entries are also
+ checked if the parameter ssl_crl_file or
+ ssl_crl_dir is set.
+
+ The clientcert authentication option is available for
+ all authentication methods, but only in pg_hba.conf lines
+ specified as hostssl. When clientcert is
+ not specified, the server verifies the client certificate against its CA
+ file only if a client certificate is presented and the CA is configured.
+
+ There are two approaches to enforce that users provide a certificate during login.
+
+ The first approach makes use of the cert authentication
+ method for hostssl entries in pg_hba.conf,
+ such that the certificate itself is used for authentication while also
+ providing ssl connection security. See Section 21.12 for details.
+ (It is not necessary to specify any clientcert options
+ explicitly when using the cert authentication method.)
+ In this case, the cn (Common Name) provided in
+ the certificate is checked against the user name or an applicable mapping.
+
+ The second approach combines any authentication method for hostssl
+ entries with the verification of client certificates by setting the
+ clientcert authentication option to verify-ca
+ or verify-full. The former option only enforces that
+ the certificate is valid, while the latter also ensures that the
+ cn (Common Name) in the certificate matches
+ the user name or an applicable mapping.
+
19.9.4. SSL Server File Usage #
+ Table 19.2 summarizes the files that are
+ relevant to the SSL setup on the server. (The shown file names are default
+ names. The locally configured names could be different.)
+
Table 19.2. SSL Server File Usage
| File | Contents | Effect |
|---|
ssl_cert_file ($PGDATA/server.crt) | server certificate | sent to client to indicate server's identity |
ssl_key_file ($PGDATA/server.key) | server private key | proves server certificate was sent by the owner; does not indicate
+ certificate owner is trustworthy |
| ssl_ca_file | trusted certificate authorities | checks that client certificate is
+ signed by a trusted certificate authority |
| ssl_crl_file | certificates revoked by certificate authorities | client certificate must not be on this list |
+ The server reads these files at server start and whenever the server
+ configuration is reloaded. On Windows
+ systems, they are also re-read whenever a new backend process is spawned
+ for a new client connection.
+
+ If an error in these files is detected at server start, the server will
+ refuse to start. But if an error is detected during a configuration
+ reload, the files are ignored and the old SSL configuration continues to
+ be used. On Windows systems, if an error in
+ these files is detected at backend start, that backend will be unable to
+ establish an SSL connection. In all these cases, the error condition is
+ reported in the server log.
+
19.9.5. Creating Certificates #
+ To create a simple self-signed certificate for the server, valid for 365
+ days, use the following OpenSSL command,
+ replacing dbhost.yourdomain.com with the
+ server's host name:
+
+openssl req -new -x509 -days 365 -nodes -text -out server.crt \
+ -keyout server.key -subj "/CN=dbhost.yourdomain.com"
+
+ Then do:
+
+chmod og-rwx server.key
+
+ because the server will reject the file if its permissions are more
+ liberal than this.
+ For more details on how to create your server private key and
+ certificate, refer to the OpenSSL documentation.
+
+ While a self-signed certificate can be used for testing, a certificate
+ signed by a certificate authority (CA) (usually an
+ enterprise-wide root CA) should be used in production.
+
+ To create a server certificate whose identity can be validated
+ by clients, first create a certificate signing request
+ (CSR) and a public/private key file:
+
+openssl req -new -nodes -text -out root.csr \
+ -keyout root.key -subj "/CN=root.yourdomain.com"
+chmod og-rwx root.key
+
+ Then, sign the request with the key to create a root certificate
+ authority (using the default OpenSSL
+ configuration file location on Linux):
+
+openssl x509 -req -in root.csr -text -days 3650 \
+ -extfile /etc/ssl/openssl.cnf -extensions v3_ca \
+ -signkey root.key -out root.crt
+
+ Finally, create a server certificate signed by the new root certificate
+ authority:
+
+openssl req -new -nodes -text -out server.csr \
+ -keyout server.key -subj "/CN=dbhost.yourdomain.com"
+chmod og-rwx server.key
+
+openssl x509 -req -in server.csr -text -days 365 \
+ -CA root.crt -CAkey root.key -CAcreateserial \
+ -out server.crt
+
+ server.crt and server.key
+ should be stored on the server, and root.crt should
+ be stored on the client so the client can verify that the server's leaf
+ certificate was signed by its trusted root certificate.
+ root.key should be stored offline for use in
+ creating future certificates.
+
+ It is also possible to create a chain of trust that includes
+ intermediate certificates:
+
+# root
+openssl req -new -nodes -text -out root.csr \
+ -keyout root.key -subj "/CN=root.yourdomain.com"
+chmod og-rwx root.key
+openssl x509 -req -in root.csr -text -days 3650 \
+ -extfile /etc/ssl/openssl.cnf -extensions v3_ca \
+ -signkey root.key -out root.crt
+
+# intermediate
+openssl req -new -nodes -text -out intermediate.csr \
+ -keyout intermediate.key -subj "/CN=intermediate.yourdomain.com"
+chmod og-rwx intermediate.key
+openssl x509 -req -in intermediate.csr -text -days 1825 \
+ -extfile /etc/ssl/openssl.cnf -extensions v3_ca \
+ -CA root.crt -CAkey root.key -CAcreateserial \
+ -out intermediate.crt
+
+# leaf
+openssl req -new -nodes -text -out server.csr \
+ -keyout server.key -subj "/CN=dbhost.yourdomain.com"
+chmod og-rwx server.key
+openssl x509 -req -in server.csr -text -days 365 \
+ -CA intermediate.crt -CAkey intermediate.key -CAcreateserial \
+ -out server.crt
+
+ server.crt and
+ intermediate.crt should be concatenated
+ into a certificate file bundle and stored on the server.
+ server.key should also be stored on the server.
+ root.crt should be stored on the client so
+ the client can verify that the server's leaf certificate was signed
+ by a chain of certificates linked to its trusted root certificate.
+ root.key and intermediate.key
+ should be stored offline for use in creating future certificates.
+
F.42. sslinfo — obtain client SSL information #
+ The sslinfo module provides information about the SSL
+ certificate that the current client provided when connecting to
+ PostgreSQL. The module is useless (most functions
+ will return NULL) if the current connection does not use SSL.
+
+ Some of the information available through this module can also be obtained
+ using the built-in system view
+ pg_stat_ssl.
+
+ This extension won't build at all unless the installation was
+ configured with --with-ssl=openssl.
+
F.42.1. Functions Provided #
-
+
ssl_is_used() returns boolean
+
+
+ Returns true if current connection to server uses SSL, and false
+ otherwise.
+
-
+
ssl_version() returns text
+
+
+ Returns the name of the protocol used for the SSL connection (e.g., TLSv1.0,
+ TLSv1.1, TLSv1.2 or TLSv1.3).
+
-
+
ssl_cipher() returns text
+
+
+ Returns the name of the cipher used for the SSL connection
+ (e.g., DHE-RSA-AES256-SHA).
+
-
+
ssl_client_cert_present() returns boolean
+
+
+ Returns true if current client has presented a valid SSL client
+ certificate to the server, and false otherwise. (The server
+ might or might not be configured to require a client certificate.)
+
-
+
ssl_client_serial() returns numeric
+
+
+ Returns serial number of current client certificate. The combination of
+ certificate serial number and certificate issuer is guaranteed to
+ uniquely identify a certificate (but not its owner — the owner
+ ought to regularly change their keys, and get new certificates from the
+ issuer).
+
+ So, if you run your own CA and allow only certificates from this CA to
+ be accepted by the server, the serial number is the most reliable (albeit
+ not very mnemonic) means to identify a user.
+
-
+
ssl_client_dn() returns text
+
+
+ Returns the full subject of the current client certificate, converting
+ character data into the current database encoding. It is assumed that
+ if you use non-ASCII characters in the certificate names, your
+ database is able to represent these characters, too. If your database
+ uses the SQL_ASCII encoding, non-ASCII characters in the name will be
+ represented as UTF-8 sequences.
+
+ The result looks like /CN=Somebody /C=Some country/O=Some organization.
+
-
+
ssl_issuer_dn() returns text
+
+
+ Returns the full issuer name of the current client certificate, converting
+ character data into the current database encoding. Encoding conversions
+ are handled the same as for ssl_client_dn.
+
+ The combination of the return value of this function with the
+ certificate serial number uniquely identifies the certificate.
+
+ This function is really useful only if you have more than one trusted CA
+ certificate in your server's certificate authority file, or if this CA
+ has issued some intermediate certificate authority certificates.
+
-
+
ssl_client_dn_field(fieldname text) returns text
+
+
+ This function returns the value of the specified field in the
+ certificate subject, or NULL if the field is not present.
+ Field names are string constants that are converted into ASN1 object
+ identifiers using the OpenSSL object
+ database. The following values are acceptable:
+
+commonName (alias CN)
+surname (alias SN)
+name
+givenName (alias GN)
+countryName (alias C)
+localityName (alias L)
+stateOrProvinceName (alias ST)
+organizationName (alias O)
+organizationalUnitName (alias OU)
+title
+description
+initials
+postalCode
+streetAddress
+generationQualifier
+description
+dnQualifier
+x500UniqueIdentifier
+pseudonym
+role
+emailAddress
+
+ All of these fields are optional, except commonName.
+ It depends
+ entirely on your CA's policy which of them would be included and which
+ wouldn't. The meaning of these fields, however, is strictly defined by
+ the X.500 and X.509 standards, so you cannot just assign arbitrary
+ meaning to them.
+
-
+
ssl_issuer_field(fieldname text) returns text
+
+
+ Same as ssl_client_dn_field, but for the certificate issuer
+ rather than the certificate subject.
+
-
+
ssl_extension_info() returns setof record
+
+
+ Provide information about extensions of client certificate: extension name,
+ extension value, and if it is a critical extension.
+
21.7. SSPI Authentication #
+ SSPI is a Windows
+ technology for secure authentication with single sign-on.
+ PostgreSQL will use SSPI in
+ negotiate mode, which will use
+ Kerberos when possible and automatically
+ fall back to NTLM in other cases.
+ SSPI and GSSAPI
+ interoperate as clients and servers, e.g., an
+ SSPI client can authenticate to an
+ GSSAPI server. It is recommended to use
+ SSPI on Windows clients and servers and
+ GSSAPI on non-Windows platforms.
+
+ When using Kerberos authentication,
+ SSPI works the same way
+ GSSAPI does; see Section 21.6
+ for details.
+
+ The following configuration options are supported for SSPI:
+
include_realm
+ If set to 0, the realm name from the authenticated user principal is
+ stripped off before being passed through the user name mapping
+ (Section 21.2). This is discouraged and is
+ primarily available for backwards compatibility, as it is not secure
+ in multi-realm environments unless krb_realm is
+ also used. It is recommended to
+ leave include_realm set to the default (1) and to
+ provide an explicit mapping in pg_ident.conf to convert
+ principal names to PostgreSQL user names.
+
compat_realm
+ If set to 1, the domain's SAM-compatible name (also known as the
+ NetBIOS name) is used for the include_realm
+ option. This is the default. If set to 0, the true realm name from
+ the Kerberos user principal name is used.
+
+ Do not disable this option unless your server runs under a domain
+ account (this includes virtual service accounts on a domain member
+ system) and all clients authenticating through SSPI are also using
+ domain accounts, or authentication will fail.
+
upn_username
+ If this option is enabled along with compat_realm,
+ the user name from the Kerberos UPN is used for authentication. If
+ it is disabled (the default), the SAM-compatible user name is used.
+ By default, these two names are identical for new user accounts.
+
+ Note that libpq uses the SAM-compatible name if no
+ explicit user name is specified. If you use
+ libpq or a driver based on it, you should
+ leave this option disabled or explicitly specify user name in the
+ connection string.
+
map
+ Allows for mapping between system and database user names. See
+ Section 21.2 for details. For an SSPI/Kerberos
+ principal, such as username@EXAMPLE.COM (or, less
+ commonly, username/hostbased@EXAMPLE.COM), the
+ user name used for mapping is
+ username@EXAMPLE.COM (or
+ username/hostbased@EXAMPLE.COM, respectively),
+ unless include_realm has been set to 0, in which case
+ username (or username/hostbased)
+ is what is seen as the system user name when mapping.
+
krb_realm
+ Sets the realm to match user principal names against. If this parameter
+ is set, only users of that realm will be accepted. If it is not set,
+ users of any realm can connect, subject to whatever user name mapping
+ is done.
+
+
73.1. Database File Layout #
+This section describes the storage format at the level of files and
+directories.
+
+Traditionally, the configuration and data files used by a database
+cluster are stored together within the cluster's data
+directory, commonly referred to as PGDATA (after the name of the
+environment variable that can be used to define it). A common location for
+PGDATA is /var/lib/pgsql/data. Multiple clusters,
+managed by different server instances, can exist on the same machine.
+
+The PGDATA directory contains several subdirectories and control
+files, as shown in Table 73.1. In addition to
+these required items, the cluster configuration files
+postgresql.conf, pg_hba.conf, and
+pg_ident.conf are traditionally stored in
+PGDATA, although it is possible to place them elsewhere.
+
Table 73.1. Contents of PGDATA
|
+Item
+ | Description |
|---|
PG_VERSION | A file containing the major version number of PostgreSQL |
base | Subdirectory containing per-database subdirectories |
current_logfiles | File recording the log file(s) currently written to by the logging
+ collector |
global | Subdirectory containing cluster-wide tables, such as
+ pg_database |
pg_commit_ts | Subdirectory containing transaction commit timestamp data |
pg_dynshmem | Subdirectory containing files used by the dynamic shared memory
+ subsystem |
pg_logical | Subdirectory containing status data for logical decoding |
pg_multixact | Subdirectory containing multitransaction status data
+ (used for shared row locks) |
pg_notify | Subdirectory containing LISTEN/NOTIFY status data |
pg_replslot | Subdirectory containing replication slot data |
pg_serial | Subdirectory containing information about committed serializable transactions |
pg_snapshots | Subdirectory containing exported snapshots |
pg_stat | Subdirectory containing permanent files for the statistics
+ subsystem |
pg_stat_tmp | Subdirectory containing temporary files for the statistics
+ subsystem |
pg_subtrans | Subdirectory containing subtransaction status data |
pg_tblspc | Subdirectory containing symbolic links to tablespaces |
pg_twophase | Subdirectory containing state files for prepared transactions |
pg_wal | Subdirectory containing WAL (Write Ahead Log) files |
pg_xact | Subdirectory containing transaction commit status data |
postgresql.auto.conf | A file used for storing configuration parameters that are set by
+ALTER SYSTEM |
postmaster.opts | A file recording the command-line options the server was
+last started with |
postmaster.pid | A lock file recording the current postmaster process ID (PID),
+ cluster data directory path,
+ postmaster start timestamp,
+ port number,
+ Unix-domain socket directory path (could be empty),
+ first valid listen_address (IP address or *, or empty if
+ not listening on TCP),
+ and shared memory segment ID
+ (this file is not present after server shutdown) |
+For each database in the cluster there is a subdirectory within
+PGDATA/base, named after the database's OID in
+pg_database. This subdirectory is the default location
+for the database's files; in particular, its system catalogs are stored
+there.
+
+ Note that the following sections describe the behavior of the builtin
+ heap table access method,
+ and the builtin index access methods. Due
+ to the extensible nature of PostgreSQL, other
+ access methods might work differently.
+
+Each table and index is stored in a separate file. For ordinary relations,
+these files are named after the table or index's filenode number,
+which can be found in pg_class.relfilenode. But
+for temporary relations, the file name is of the form
+tBBB_FFF, where BBB
+is the backend ID of the backend which created the file, and FFF
+is the filenode number. In either case, in addition to the main file (a/k/a
+main fork), each table and index has a free space map (see Section 73.3), which stores information about free space available in
+the relation. The free space map is stored in a file named with the filenode
+number plus the suffix _fsm. Tables also have a
+visibility map, stored in a fork with the suffix _vm,
+to track which pages are known to have no dead tuples. The visibility map is
+described further in Section 73.4. Unlogged tables and indexes
+have a third fork, known as the initialization fork, which is stored in a fork
+with the suffix _init (see Section 73.5).
+
Caution
+Note that while a table's filenode often matches its OID, this is
+not necessarily the case; some operations, like
+TRUNCATE, REINDEX, CLUSTER and some forms
+of ALTER TABLE, can change the filenode while preserving the OID.
+Avoid assuming that filenode and table OID are the same.
+Also, for certain system catalogs including pg_class itself,
+pg_class.relfilenode contains zero. The
+actual filenode number of these catalogs is stored in a lower-level data
+structure, and can be obtained using the pg_relation_filenode()
+function.
+
+When a table or index exceeds 1 GB, it is divided into gigabyte-sized
+segments. The first segment's file name is the same as the
+filenode; subsequent segments are named filenode.1, filenode.2, etc.
+This arrangement avoids problems on platforms that have file size limitations.
+(Actually, 1 GB is just the default segment size. The segment size can be
+adjusted using the configuration option --with-segsize
+when building PostgreSQL.)
+In principle, free space map and visibility map forks could require multiple
+segments as well, though this is unlikely to happen in practice.
+
+A table that has columns with potentially large entries will have an
+associated TOAST table, which is used for out-of-line storage of
+field values that are too large to keep in the table rows proper.
+pg_class.reltoastrelid links from a table to
+its TOAST table, if any.
+See Section 73.2 for more information.
+
+The contents of tables and indexes are discussed further in
+Section 73.6.
+
+Tablespaces make the scenario more complicated. Each user-defined tablespace
+has a symbolic link inside the PGDATA/pg_tblspc
+directory, which points to the physical tablespace directory (i.e., the
+location specified in the tablespace's CREATE TABLESPACE command).
+This symbolic link is named after
+the tablespace's OID. Inside the physical tablespace directory there is
+a subdirectory with a name that depends on the PostgreSQL
+server version, such as PG_9.0_201008051. (The reason for using
+this subdirectory is so that successive versions of the database can use
+the same CREATE TABLESPACE location value without conflicts.)
+Within the version-specific subdirectory, there is
+a subdirectory for each database that has elements in the tablespace, named
+after the database's OID. Tables and indexes are stored within that
+directory, using the filenode naming scheme.
+The pg_default tablespace is not accessed through
+pg_tblspc, but corresponds to
+PGDATA/base. Similarly, the pg_global
+tablespace is not accessed through pg_tblspc, but corresponds to
+PGDATA/global.
+
+The pg_relation_filepath() function shows the entire path
+(relative to PGDATA) of any relation. It is often useful
+as a substitute for remembering many of the above rules. But keep in
+mind that this function just gives the name of the first segment of the
+main fork of the relation — you may need to append a segment number
+and/or _fsm, _vm, or _init to find all
+the files associated with the relation.
+
+Temporary files (for operations such as sorting more data than can fit in
+memory) are created within PGDATA/base/pgsql_tmp,
+or within a pgsql_tmp subdirectory of a tablespace directory
+if a tablespace other than pg_default is specified for them.
+The name of a temporary file has the form
+pgsql_tmpPPP.NNN,
+where PPP is the PID of the owning backend and
+NNN distinguishes different temporary files of that backend.
+
+Each heap and index relation, except for hash indexes, has a Free Space Map
+(FSM) to keep track of available space in the relation.
+It's stored alongside the main relation data in a separate relation fork,
+named after the filenode number of the relation, plus a _fsm
+suffix. For example, if the filenode of a relation is 12345, the
+FSM is stored in a file called
+12345_fsm, in the same directory as the main relation file.
+
+The Free Space Map is organized as a tree of FSM pages. The
+bottom level FSM pages store the free space available on each
+heap (or index) page, using one byte to represent each such page. The upper
+levels aggregate information from the lower levels.
+
+Within each FSM page is a binary tree, stored in an array with
+one byte per node. Each leaf node represents a heap page, or a lower level
+FSM page. In each non-leaf node, the higher of its children's
+values is stored. The maximum value in the leaf nodes is therefore stored
+at the root.
+
+See src/backend/storage/freespace/README for more details on
+how the FSM is structured, and how it's updated and searched.
+The pg_freespacemap module
+can be used to examine the information stored in free space maps.
+
73.7. Heap-Only Tuples (HOT) #
+ To allow for high concurrency, PostgreSQL
+ uses multiversion concurrency
+ control (MVCC) to store rows. However,
+ MVCC has some downsides for update queries.
+ Specifically, updates require new versions of rows to be added to
+ tables. This can also require new index entries for each updated row,
+ and removal of old versions of rows and their index entries can be
+ expensive.
+
+ To help reduce the overhead of updates,
+ PostgreSQL has an optimization called
+ heap-only tuples (HOT). This optimization is
+ possible when:
+
+
+ The update does not modify any columns referenced by the table's indexes,
+ not including summarizing indexes. The only summarizing index method in
+ the core PostgreSQL distribution is BRIN.
+
+ There is sufficient free space on the page containing the old row
+ for the updated row.
+
+
+ In such cases, heap-only tuples provide two optimizations:
+
+
+ New index entries are not needed to represent updated rows, however,
+ summary indexes may still need to be updated.
+
+ Old versions of updated rows can be completely removed during normal
+ operation, including SELECTs, instead of requiring
+ periodic vacuum operations. (This is possible because indexes
+ do not reference their page
+ item identifiers.)
+
+
+ You can increase the likelihood of sufficient page space for
+ HOT updates by decreasing a table's fillfactor. If you
+ don't, HOT updates will still happen because new rows
+ will naturally migrate to new pages and existing pages with sufficient free
+ space for new row versions. The system view pg_stat_all_tables
+ allows monitoring of the occurrence of HOT and non-HOT updates.
+
73.5. The Initialization Fork #
+Each unlogged table, and each index on an unlogged table, has an initialization
+fork. The initialization fork is an empty table or index of the appropriate
+type. When an unlogged table must be reset to empty due to a crash, the
+initialization fork is copied over the main fork, and any other forks are
+erased (they will be recreated automatically as needed).
+
73.6. Database Page Layout #
+This section provides an overview of the page format used within
+PostgreSQL tables and indexes.
+Sequences and TOAST tables are formatted just like a regular table.
+
+In the following explanation, a
+byte
+is assumed to contain 8 bits. In addition, the term
+item
+refers to an individual data value that is stored on a page. In a table,
+an item is a row; in an index, an item is an index entry.
+
+Every table and index is stored as an array of pages of a
+fixed size (usually 8 kB, although a different page size can be selected
+when compiling the server). In a table, all the pages are logically
+equivalent, so a particular item (row) can be stored in any page. In
+indexes, the first page is generally reserved as a metapage
+holding control information, and there can be different types of pages
+within the index, depending on the index access method.
+
+Table 73.2 shows the overall layout of a page.
+There are five parts to each page.
+
Table 73.2. Overall Page Layout
|
+Item
+ | Description |
|---|
| PageHeaderData | 24 bytes long. Contains general information about the page, including
+free space pointers. |
| ItemIdData | Array of item identifiers pointing to the actual items. Each
+entry is an (offset,length) pair. 4 bytes per item. |
| Free space | The unallocated space. New item identifiers are allocated from
+the start of this area, new items from the end. |
| Items | The actual items themselves. |
| Special space | Index access method specific data. Different methods store different
+data. Empty in ordinary tables. |
+
+ The first 24 bytes of each page consists of a page header
+ (PageHeaderData). Its format is detailed in Table 73.3. The first field tracks the most
+ recent WAL entry related to this page. The second field contains
+ the page checksum if data checksums are
+ enabled. Next is a 2-byte field containing flag bits. This is followed
+ by three 2-byte integer fields (pd_lower,
+ pd_upper, and
+ pd_special). These contain byte offsets
+ from the page start to the start of unallocated space, to the end of
+ unallocated space, and to the start of the special space. The next 2
+ bytes of the page header, pd_pagesize_version,
+ store both the page size and a version indicator. Beginning with
+ PostgreSQL 8.3 the version number is 4;
+ PostgreSQL 8.1 and 8.2 used version number 3;
+ PostgreSQL 8.0 used version number 2;
+ PostgreSQL 7.3 and 7.4 used version number 1;
+ prior releases used version number 0.
+ (The basic page layout and header format has not changed in most of these
+ versions, but the layout of heap row headers has.) The page size
+ is basically only present as a cross-check; there is no support for having
+ more than one page size in an installation.
+ The last field is a hint that shows whether pruning the page is likely
+ to be profitable: it tracks the oldest un-pruned XMAX on the page.
+
+
+ All the details can be found in
+ src/include/storage/bufpage.h.
+
+ Following the page header are item identifiers
+ (ItemIdData), each requiring four bytes.
+ An item identifier contains a byte-offset to
+ the start of an item, its length in bytes, and a few attribute bits
+ which affect its interpretation.
+ New item identifiers are allocated
+ as needed from the beginning of the unallocated space.
+ The number of item identifiers present can be determined by looking at
+ pd_lower, which is increased to allocate a new identifier.
+ Because an item
+ identifier is never moved until it is freed, its index can be used on a
+ long-term basis to reference an item, even when the item itself is moved
+ around on the page to compact free space. In fact, every pointer to an
+ item (ItemPointer, also known as
+ CTID) created by
+ PostgreSQL consists of a page number and the
+ index of an item identifier.
+
+
+
+ The items themselves are stored in space allocated backwards from the end
+ of unallocated space. The exact structure varies depending on what the
+ table is to contain. Tables and sequences both use a structure named
+ HeapTupleHeaderData, described below.
+
+
+
+ The final section is the “special section” which can
+ contain anything the access method wishes to store. For example,
+ b-tree indexes store links to the page's left and right siblings,
+ as well as some other data relevant to the index structure.
+ Ordinary tables do not use a special section at all (indicated by setting
+ pd_special to equal the page size).
+
+
+ Figure 73.1 illustrates how these parts are
+ laid out in a page.
+
73.6.1. Table Row Layout #
+
+ All table rows are structured in the same way. There is a fixed-size
+ header (occupying 23 bytes on most machines), followed by an optional null
+ bitmap, an optional object ID field, and the user data. The header is
+ detailed
+ in Table 73.4. The actual user data
+ (columns of the row) begins at the offset indicated by
+ t_hoff, which must always be a multiple of the MAXALIGN
+ distance for the platform.
+ The null bitmap is
+ only present if the HEAP_HASNULL bit is set in
+ t_infomask. If it is present it begins just after
+ the fixed header and occupies enough bytes to have one bit per data column
+ (that is, the number of bits that equals the attribute count in
+ t_infomask2). In this list of bits, a
+ 1 bit indicates not-null, a 0 bit is a null. When the bitmap is not
+ present, all columns are assumed not-null.
+ The object ID is only present if the HEAP_HASOID_OLD bit
+ is set in t_infomask. If present, it appears just
+ before the t_hoff boundary. Any padding needed to make
+ t_hoff a MAXALIGN multiple will appear between the null
+ bitmap and the object ID. (This in turn ensures that the object ID is
+ suitably aligned.)
+
+
+ All the details can be found in
+ src/include/access/htup_details.h.
+
+
+ Interpreting the actual data can only be done with information obtained
+ from other tables, mostly pg_attribute. The
+ key values needed to identify field locations are
+ attlen and attalign.
+ There is no way to directly get a
+ particular attribute, except when there are only fixed width fields and no
+ null values. All this trickery is wrapped up in the functions
+ heap_getattr, fastgetattr
+ and heap_getsysattr.
+
+
+
+ To read the data you need to examine each attribute in turn. First check
+ whether the field is NULL according to the null bitmap. If it is, go to
+ the next. Then make sure you have the right alignment. If the field is a
+ fixed width field, then all the bytes are simply placed. If it's a
+ variable length field (attlen = -1) then it's a bit more complicated.
+ All variable-length data types share the common header structure
+ struct varlena, which includes the total length of the stored
+ value and some flag bits. Depending on the flags, the data can be either
+ inline or in a TOAST table;
+ it might be compressed, too (see Section 73.2).
+
+
+This section provides an overview of TOAST (The
+Oversized-Attribute Storage Technique).
+
+PostgreSQL uses a fixed page size (commonly
+8 kB), and does not allow tuples to span multiple pages. Therefore, it is
+not possible to store very large field values directly. To overcome
+this limitation, large field values are compressed and/or broken up into
+multiple physical rows. This happens transparently to the user, with only
+small impact on most of the backend code. The technique is affectionately
+known as TOAST (or “the best thing since sliced bread”).
+The TOAST infrastructure is also used to improve handling of
+large data values in-memory.
+
+Only certain data types support TOAST — there is no need to
+impose the overhead on data types that cannot produce large field values.
+To support TOAST, a data type must have a variable-length
+(varlena) representation, in which, ordinarily, the first
+four-byte word of any stored value contains the total length of the value in
+bytes (including itself). TOAST does not constrain the rest
+of the data type's representation. The special representations collectively
+called TOASTed values work by modifying or
+reinterpreting this initial length word. Therefore, the C-level functions
+supporting a TOAST-able data type must be careful about how they
+handle potentially TOASTed input values: an input might not
+actually consist of a four-byte length word and contents until after it's
+been detoasted. (This is normally done by invoking
+PG_DETOAST_DATUM before doing anything with an input value,
+but in some cases more efficient approaches are possible.
+See Section 38.13.1 for more detail.)
+
+TOAST usurps two bits of the varlena length word (the high-order
+bits on big-endian machines, the low-order bits on little-endian machines),
+thereby limiting the logical size of any value of a TOAST-able
+data type to 1 GB (230 - 1 bytes). When both bits are zero,
+the value is an ordinary un-TOASTed value of the data type, and
+the remaining bits of the length word give the total datum size (including
+length word) in bytes. When the highest-order or lowest-order bit is set,
+the value has only a single-byte header instead of the normal four-byte
+header, and the remaining bits of that byte give the total datum size
+(including length byte) in bytes. This alternative supports space-efficient
+storage of values shorter than 127 bytes, while still allowing the data type
+to grow to 1 GB at need. Values with single-byte headers aren't aligned on
+any particular boundary, whereas values with four-byte headers are aligned on
+at least a four-byte boundary; this omission of alignment padding provides
+additional space savings that is significant compared to short values.
+As a special case, if the remaining bits of a single-byte header are all
+zero (which would be impossible for a self-inclusive length), the value is
+a pointer to out-of-line data, with several possible alternatives as
+described below. The type and size of such a TOAST pointer
+are determined by a code stored in the second byte of the datum.
+Lastly, when the highest-order or lowest-order bit is clear but the adjacent
+bit is set, the content of the datum has been compressed and must be
+decompressed before use. In this case the remaining bits of the four-byte
+length word give the total size of the compressed datum, not the
+original data. Note that compression is also possible for out-of-line data
+but the varlena header does not tell whether it has occurred —
+the content of the TOAST pointer tells that, instead.
+
+The compression technique used for either in-line or out-of-line compressed
+data can be selected for each column by setting
+the COMPRESSION column option in CREATE
+TABLE or ALTER TABLE. The default for columns
+with no explicit setting is to consult the
+default_toast_compression parameter at the time data is
+inserted.
+
+As mentioned, there are multiple types of TOAST pointer datums.
+The oldest and most common type is a pointer to out-of-line data stored in
+a TOAST table that is separate from, but
+associated with, the table containing the TOAST pointer datum
+itself. These on-disk pointer datums are created by the
+TOAST management code (in access/common/toast_internals.c)
+when a tuple to be stored on disk is too large to be stored as-is.
+Further details appear in Section 73.2.1.
+Alternatively, a TOAST pointer datum can contain a pointer to
+out-of-line data that appears elsewhere in memory. Such datums are
+necessarily short-lived, and will never appear on-disk, but they are very
+useful for avoiding copying and redundant processing of large data values.
+Further details appear in Section 73.2.2.
+
73.2.1. Out-of-Line, On-Disk TOAST Storage #
+If any of the columns of a table are TOAST-able, the table will
+have an associated TOAST table, whose OID is stored in the table's
+pg_class.reltoastrelid entry. On-disk
+TOASTed values are kept in the TOAST table, as
+described in more detail below.
+
+Out-of-line values are divided (after compression if used) into chunks of at
+most TOAST_MAX_CHUNK_SIZE bytes (by default this value is chosen
+so that four chunk rows will fit on a page, making it about 2000 bytes).
+Each chunk is stored as a separate row in the TOAST table
+belonging to the owning table. Every
+TOAST table has the columns chunk_id (an OID
+identifying the particular TOASTed value),
+chunk_seq (a sequence number for the chunk within its value),
+and chunk_data (the actual data of the chunk). A unique index
+on chunk_id and chunk_seq provides fast
+retrieval of the values. A pointer datum representing an out-of-line on-disk
+TOASTed value therefore needs to store the OID of the
+TOAST table in which to look and the OID of the specific value
+(its chunk_id). For convenience, pointer datums also store the
+logical datum size (original uncompressed data length), physical stored size
+(different if compression was applied), and the compression method used, if
+any. Allowing for the varlena header bytes,
+the total size of an on-disk TOAST pointer datum is therefore 18
+bytes regardless of the actual size of the represented value.
+
+The TOAST management code is triggered only
+when a row value to be stored in a table is wider than
+TOAST_TUPLE_THRESHOLD bytes (normally 2 kB).
+The TOAST code will compress and/or move
+field values out-of-line until the row value is shorter than
+TOAST_TUPLE_TARGET bytes (also normally 2 kB, adjustable)
+or no more gains can be had. During an UPDATE
+operation, values of unchanged fields are normally preserved as-is; so an
+UPDATE of a row with out-of-line values incurs no TOAST costs if
+none of the out-of-line values change.
+
+The TOAST management code recognizes four different strategies
+for storing TOAST-able columns on disk:
+
+
+ PLAIN prevents either compression or
+ out-of-line storage. This is the only possible strategy for
+ columns of non-TOAST-able data types.
+
+ EXTENDED allows both compression and out-of-line
+ storage. This is the default for most TOAST-able data types.
+ Compression will be attempted first, then out-of-line storage if
+ the row is still too big.
+
+ EXTERNAL allows out-of-line storage but not
+ compression. Use of EXTERNAL will
+ make substring operations on wide text and
+ bytea columns faster (at the penalty of increased storage
+ space) because these operations are optimized to fetch only the
+ required parts of the out-of-line value when it is not compressed.
+
+ MAIN allows compression but not out-of-line
+ storage. (Actually, out-of-line storage will still be performed
+ for such columns, but only as a last resort when there is no other
+ way to make the row small enough to fit on a page.)
+
+
+Each TOAST-able data type specifies a default strategy for columns
+of that data type, but the strategy for a given table column can be altered
+with ALTER TABLE ... SET STORAGE.
+
+TOAST_TUPLE_TARGET can be adjusted for each table using
+ALTER TABLE ... SET (toast_tuple_target = N)
+
+This scheme has a number of advantages compared to a more straightforward
+approach such as allowing row values to span pages. Assuming that queries are
+usually qualified by comparisons against relatively small key values, most of
+the work of the executor will be done using the main row entry. The big values
+of TOASTed attributes will only be pulled out (if selected at all)
+at the time the result set is sent to the client. Thus, the main table is much
+smaller and more of its rows fit in the shared buffer cache than would be the
+case without any out-of-line storage. Sort sets shrink also, and sorts will
+more often be done entirely in memory. A little test showed that a table
+containing typical HTML pages and their URLs was stored in about half of the
+raw data size including the TOAST table, and that the main table
+contained only about 10% of the entire data (the URLs and some small HTML
+pages). There was no run time difference compared to an un-TOASTed
+comparison table, in which all the HTML pages were cut down to 7 kB to fit.
+
73.2.2. Out-of-Line, In-Memory TOAST Storage #
+TOAST pointers can point to data that is not on disk, but is
+elsewhere in the memory of the current server process. Such pointers
+obviously cannot be long-lived, but they are nonetheless useful. There
+are currently two sub-cases:
+pointers to indirect data and
+pointers to expanded data.
+
+Indirect TOAST pointers simply point at a non-indirect varlena
+value stored somewhere in memory. This case was originally created merely
+as a proof of concept, but it is currently used during logical decoding to
+avoid possibly having to create physical tuples exceeding 1 GB (as pulling
+all out-of-line field values into the tuple might do). The case is of
+limited use since the creator of the pointer datum is entirely responsible
+that the referenced data survives for as long as the pointer could exist,
+and there is no infrastructure to help with this.
+
+Expanded TOAST pointers are useful for complex data types
+whose on-disk representation is not especially suited for computational
+purposes. As an example, the standard varlena representation of a
+PostgreSQL array includes dimensionality information, a
+nulls bitmap if there are any null elements, then the values of all the
+elements in order. When the element type itself is variable-length, the
+only way to find the N'th element is to scan through all the
+preceding elements. This representation is appropriate for on-disk storage
+because of its compactness, but for computations with the array it's much
+nicer to have an “expanded” or “deconstructed”
+representation in which all the element starting locations have been
+identified. The TOAST pointer mechanism supports this need by
+allowing a pass-by-reference Datum to point to either a standard varlena
+value (the on-disk representation) or a TOAST pointer that
+points to an expanded representation somewhere in memory. The details of
+this expanded representation are up to the data type, though it must have
+a standard header and meet the other API requirements given
+in src/include/utils/expandeddatum.h. C-level functions
+working with the data type can choose to handle either representation.
+Functions that do not know about the expanded representation, but simply
+apply PG_DETOAST_DATUM to their inputs, will automatically
+receive the traditional varlena representation; so support for an expanded
+representation can be introduced incrementally, one function at a time.
+
+TOAST pointers to expanded values are further broken down
+into read-write and read-only pointers.
+The pointed-to representation is the same either way, but a function that
+receives a read-write pointer is allowed to modify the referenced value
+in-place, whereas one that receives a read-only pointer must not; it must
+first create a copy if it wants to make a modified version of the value.
+This distinction and some associated conventions make it possible to avoid
+unnecessary copying of expanded values during query execution.
+
+For all types of in-memory TOAST pointer, the TOAST
+management code ensures that no such pointer datum can accidentally get
+stored on disk. In-memory TOAST pointers are automatically
+expanded to normal in-line varlena values before storage — and then
+possibly converted to on-disk TOAST pointers, if the containing
+tuple would otherwise be too big.
+
+Each heap relation has a Visibility Map
+(VM) to keep track of which pages contain only tuples that are known to be
+visible to all active transactions; it also keeps track of which pages contain
+only frozen tuples. It's stored
+alongside the main relation data in a separate relation fork, named after the
+filenode number of the relation, plus a _vm suffix. For example,
+if the filenode of a relation is 12345, the VM is stored in a file called
+12345_vm, in the same directory as the main relation file.
+Note that indexes do not have VMs.
+
+The visibility map stores two bits per heap page. The first bit, if set,
+indicates that the page is all-visible, or in other words that the page does
+not contain any tuples that need to be vacuumed.
+This information can also be used
+by index-only
+scans to answer queries using only the index tuple.
+The second bit, if set, means that all tuples on the page have been frozen.
+That means that even an anti-wraparound vacuum need not revisit the page.
+
+The map is conservative in the sense that we make sure that whenever a bit is
+set, we know the condition is true, but if a bit is not set, it might or
+might not be true. Visibility map bits are only set by vacuum, but are
+cleared by any data-modifying operations on a page.
+
+The pg_visibility module can be used to examine the
+information stored in the visibility map.
+
Chapter 73. Database Physical Storage
+This chapter provides an overview of the physical storage format used by
+PostgreSQL databases.
+
+ Subtransactions are started inside transactions, allowing large
+ transactions to be broken into smaller units. Subtransactions can
+ commit or abort without affecting their parent transactions, allowing
+ parent transactions to continue. This allows errors to be handled
+ more easily, which is a common application development pattern.
+ The word subtransaction is often abbreviated as
+ subxact.
+
+ Subtransactions can be started explicitly using the
+ SAVEPOINT command, but can also be started in
+ other ways, such as PL/pgSQL's EXCEPTION clause.
+ PL/Python and PL/Tcl also support explicit subtransactions.
+ Subtransactions can also be started from other subtransactions.
+ The top-level transaction and its child subtransactions form a
+ hierarchy or tree, which is why we refer to the main transaction as
+ the top-level transaction.
+
+ If a subtransaction is assigned a non-virtual transaction ID,
+ its transaction ID is referred to as a “subxid”.
+ Read-only subtransactions are not assigned subxids, but once they
+ attempt to write, they will be assigned one. This also causes all of
+ a subxid's parents, up to and including the top-level transaction,
+ to be assigned non-virtual transaction ids. We ensure that a parent
+ xid is always lower than any of its child subxids.
+
+ The immediate parent xid of each subxid is recorded in the
+ pg_subtrans directory. No entry is made for
+ top-level xids since they do not have a parent, nor is an entry made
+ for read-only subtransactions.
+
+ When a subtransaction commits, all of its committed child
+ subtransactions with subxids will also be considered subcommitted
+ in that transaction. When a subtransaction aborts, all of its child
+ subtransactions will also be considered aborted.
+
+ When a top-level transaction with an xid commits, all of its
+ subcommitted child subtransactions are also persistently recorded
+ as committed in the pg_xact subdirectory. If the
+ top-level transaction aborts, all its subtransactions are also aborted,
+ even if they were subcommitted.
+
+ The more subtransactions each transaction keeps open (not
+ rolled back or released), the greater the transaction management
+ overhead. Up to 64 open subxids are cached in shared memory for
+ each backend; after that point, the storage I/O overhead increases
+ significantly due to additional lookups of subxid entries in
+ pg_subtrans.
+
17.6. Supported Platforms #
+ A platform (that is, a CPU architecture and operating system combination)
+ is considered supported by the PostgreSQL development
+ community if the code contains provisions to work on that platform and
+ it has recently been verified to build and pass its regression tests
+ on that platform. Currently, most testing of platform compatibility
+ is done automatically by test machines in the
+ PostgreSQL Build Farm.
+ If you are interested in using PostgreSQL on a platform
+ that is not represented in the build farm, but on which the code works
+ or can be made to work, you are strongly encouraged to set up a build
+ farm member machine so that continued compatibility can be assured.
+
+ In general, PostgreSQL can be expected to work on
+ these CPU architectures: x86, PowerPC, S/390, SPARC, ARM, MIPS, RISC-V,
+ and PA-RISC, including
+ big-endian, little-endian, 32-bit, and 64-bit variants where applicable.
+ It is often
+ possible to build on an unsupported CPU type by configuring with
+ --disable-spinlocks, but performance will be poor.
+
+ PostgreSQL can be expected to work on current
+ versions of these operating systems: Linux, Windows,
+ FreeBSD, OpenBSD, NetBSD, DragonFlyBSD, macOS, AIX, Solaris, and illumos.
+ Other Unix-like systems may also work but are not currently
+ being tested. In most cases, all CPU architectures supported by
+ a given operating system will work. Look in
+ Section 17.7 below to see if
+ there is information
+ specific to your operating system, particularly if using an older system.
+
+ If you have installation problems on a platform that is known
+ to be supported according to recent build farm results, please report
+ it to <pgsql-bugs@lists.postgresql.org>. If you are interested
+ in porting PostgreSQL to a new platform,
+ <pgsql-hackers@lists.postgresql.org> is the appropriate place
+ to discuss that.
+
+ Historical versions of PostgreSQL or POSTGRES
+ also ran on CPU architectures including Alpha, Itanium, M32R, M68K,
+ M88K, NS32K, SuperH, and VAX, and operating systems including 4.3BSD, BEOS,
+ BSD/OS, DG/UX, Dynix, HP-UX, IRIX, NeXTSTEP, QNX, SCO, SINIX, Sprite, SunOS,
+ Tru64 UNIX, and ULTRIX.
+
75.1. System Catalog Declaration Rules #
+ The key part of a catalog header file is a C structure definition
+ describing the layout of each row of the catalog. This begins with
+ a CATALOG macro, which so far as the C compiler is
+ concerned is just shorthand for typedef struct
+ FormData_catalogname.
+ Each field in the struct gives rise to a catalog column.
+ Fields can be annotated using the BKI property macros described
+ in genbki.h, for example to define a default value
+ for a field or mark it as nullable or not nullable.
+ The CATALOG line can also be annotated, with some
+ other BKI property macros described in genbki.h, to
+ define other properties of the catalog as a whole, such as whether
+ it is a shared relation.
+
+ The system catalog cache code (and most catalog-munging code in general)
+ assumes that the fixed-length portions of all system catalog tuples are
+ in fact present, because it maps this C struct declaration onto them.
+ Thus, all variable-length fields and nullable fields must be placed at
+ the end, and they cannot be accessed as struct fields.
+ For example, if you tried to
+ set pg_type.typrelid
+ to be NULL, it would fail when some piece of code tried to reference
+ typetup->typrelid (or worse,
+ typetup->typelem, because that follows
+ typrelid). This would result in
+ random errors or even segmentation violations.
+
+ As a partial guard against this type of error, variable-length or
+ nullable fields should not be made directly visible to the C compiler.
+ This is accomplished by wrapping them in #ifdef
+ CATALOG_VARLEN ... #endif (where
+ CATALOG_VARLEN is a symbol that is never defined).
+ This prevents C code from carelessly trying to access fields that might
+ not be there or might be at some other offset.
+ As an independent guard against creating incorrect rows, we
+ require all columns that should be non-nullable to be marked so
+ in pg_attribute. The bootstrap code will
+ automatically mark catalog columns as NOT NULL
+ if they are fixed-width and are not preceded by any nullable or
+ variable-width column.
+ Where this rule is inadequate, you can force correct marking by using
+ BKI_FORCE_NOT_NULL
+ and BKI_FORCE_NULL annotations as needed.
+
+ Frontend code should not include any pg_xxx.h
+ catalog header file, as these files may contain C code that won't compile
+ outside the backend. (Typically, that happens because these files also
+ contain declarations for functions
+ in src/backend/catalog/ files.)
+ Instead, frontend code may include the corresponding
+ generated pg_xxx_d.h header, which will contain
+ OID #defines and any other data that might be of use
+ on the client side. If you want macros or other code in a catalog header
+ to be visible to frontend code, write #ifdef
+ EXPOSE_TO_CLIENT_CODE ... #endif around that
+ section to instruct genbki.pl to copy that section
+ to the pg_xxx_d.h header.
+
+ A few of the catalogs are so fundamental that they can't even be created
+ by the BKI create command that's
+ used for most catalogs, because that command needs to write information
+ into these catalogs to describe the new catalog. These are
+ called bootstrap catalogs, and defining one takes
+ a lot of extra work: you have to manually prepare appropriate entries for
+ them in the pre-loaded contents of pg_class
+ and pg_type, and those entries will need to be
+ updated for subsequent changes to the catalog's structure.
+ (Bootstrap catalogs also need pre-loaded entries
+ in pg_attribute, but
+ fortunately genbki.pl handles that chore nowadays.)
+ Avoid making new catalogs be bootstrap catalogs if at all possible.
+
75.2. System Catalog Initial Data #
+ Each catalog that has any manually-created initial data (some do not)
+ has a corresponding .dat file that contains its
+ initial data in an editable format.
+
+ A catalog row appearing in the initial data can be given a
+ manually-assigned OID by writing an oid
+ => nnnn metadata field.
+ Furthermore, if an OID is assigned, a C macro for that OID can be
+ created by writing an oid_symbol
+ => name metadata field.
+
+ Pre-loaded catalog rows must have preassigned OIDs if there are OID
+ references to them in other pre-loaded rows. A preassigned OID is
+ also needed if the row's OID must be referenced from C code.
+ If neither case applies, the oid metadata field can
+ be omitted, in which case the bootstrap code assigns an OID
+ automatically.
+ In practice we usually preassign OIDs for all or none of the pre-loaded
+ rows in a given catalog, even if only some of them are actually
+ cross-referenced.
+
+ Writing the actual numeric value of any OID in C code is considered
+ very bad form; always use a macro, instead. Direct references
+ to pg_proc OIDs are common enough that there's
+ a special mechanism to create the necessary macros automatically;
+ see src/backend/utils/Gen_fmgrtab.pl. Similarly
+ — but, for historical reasons, not done the same way —
+ there's an automatic method for creating macros
+ for pg_type
+ OIDs. oid_symbol entries are therefore not
+ necessary in those two catalogs. Likewise, macros for
+ the pg_class OIDs of system catalogs and
+ indexes are set up automatically. For all other system catalogs, you
+ have to manually specify any macros you need
+ via oid_symbol entries.
+
+ To find an available OID for a new pre-loaded row, run the
+ script src/include/catalog/unused_oids.
+ It prints inclusive ranges of unused OIDs (e.g., the output
+ line 45-900 means OIDs 45 through 900 have not been
+ allocated yet). Currently, OIDs 1–9999 are reserved for manual
+ assignment; the unused_oids script simply looks
+ through the catalog headers and .dat files
+ to see which ones do not appear. You can also use
+ the duplicate_oids script to check for mistakes.
+ (genbki.pl will assign OIDs for any rows that
+ didn't get one hand-assigned to them, and it will also detect duplicate
+ OIDs at compile time.)
+
+ When choosing OIDs for a patch that is not expected to be committed
+ immediately, best practice is to use a group of more-or-less
+ consecutive OIDs starting with some random choice in the range
+ 8000—9999. This minimizes the risk of OID collisions with other
+ patches being developed concurrently. To keep the 8000—9999
+ range free for development purposes, after a patch has been committed
+ to the master git repository its OIDs should be renumbered into
+ available space below that range. Typically, this will be done
+ near the end of each development cycle, moving all OIDs consumed by
+ patches committed in that cycle at the same time. The script
+ renumber_oids.pl can be used for this purpose.
+ If an uncommitted patch is found to have OID conflicts with some
+ recently-committed patch, renumber_oids.pl may
+ also be useful for recovering from that situation.
+
+ Because of this convention of possibly renumbering OIDs assigned by
+ patches, the OIDs assigned by a patch should not be considered stable
+ until the patch has been included in an official release. We do not
+ change manually-assigned object OIDs once released, however, as that
+ would create assorted compatibility problems.
+
+ If genbki.pl needs to assign an OID to a catalog
+ entry that does not have a manually-assigned OID, it will use a value in
+ the range 10000—11999. The server's OID counter is set to 10000
+ at the start of a bootstrap run, so that any objects created on-the-fly
+ during bootstrap processing also receive OIDs in this range. (The
+ usual OID assignment mechanism takes care of preventing any conflicts.)
+
+ Objects with OIDs below FirstUnpinnedObjectId (12000)
+ are considered “pinned”, preventing them from being
+ deleted. (There are a small number of exceptions, which are
+ hard-wired into IsPinnedObject().)
+ initdb forces the OID counter up
+ to FirstUnpinnedObjectId as soon as it's ready to
+ create unpinned objects. Thus objects created during the later phases
+ of initdb, such as objects created while
+ running the information_schema.sql script, will
+ not be pinned, while all objects known
+ to genbki.pl will be.
+
+ OIDs assigned during normal database operation are constrained to be
+ 16384 or higher. This ensures that the range 10000—16383 is free
+ for OIDs assigned automatically by genbki.pl or
+ during initdb. These
+ automatically-assigned OIDs are not considered stable, and may change
+ from one installation to another.
+
75.2.3. OID Reference Lookup #
+ In principle, cross-references from one initial catalog row to another
+ could be written just by writing the preassigned OID of the referenced
+ row in the referencing field. However, that is against project
+ policy, because it is error-prone, hard to read, and subject to
+ breakage if a newly-assigned OID is renumbered. Therefore
+ genbki.pl provides mechanisms to write
+ symbolic references instead.
+ The rules are as follows:
+
+ Use of symbolic references is enabled in a particular catalog column
+ by attaching BKI_LOOKUP(lookuprule)
+ to the column's definition, where lookuprule
+ is the name of the referenced catalog, e.g., pg_proc.
+ BKI_LOOKUP can be attached to columns of
+ type Oid, regproc, oidvector,
+ or Oid[]; in the latter two cases it implies performing a
+ lookup on each element of the array.
+
+ It's also permissible to attach BKI_LOOKUP(encoding)
+ to integer columns to reference character set encodings, which are
+ not currently represented as catalog OIDs, but have a set of values
+ known to genbki.pl.
+
+ In some catalog columns, it's allowed for entries to be zero instead
+ of a valid reference. If this is allowed, write
+ BKI_LOOKUP_OPT instead
+ of BKI_LOOKUP. Then you can
+ write 0 for an entry. (If the column is
+ declared regproc, you can optionally
+ write - instead of 0.)
+ Except for this special case, all entries in
+ a BKI_LOOKUP column must be symbolic references.
+ genbki.pl will warn about unrecognized names.
+
+ Most kinds of catalog objects are simply referenced by their names.
+ Note that type names must exactly match the
+ referenced pg_type
+ entry's typname; you do not get to use
+ any aliases such as integer
+ for int4.
+
+ A function can be represented by
+ its proname, if that is unique among
+ the pg_proc.dat entries (this works like regproc
+ input). Otherwise, write it
+ as proname(argtypename,argtypename,...),
+ like regprocedure. The argument type names must be spelled exactly as
+ they are in the pg_proc.dat entry's
+ proargtypes field. Do not insert any
+ spaces.
+
+ Operators are represented
+ by oprname(lefttype,righttype),
+ writing the type names exactly as they appear in
+ the pg_operator.dat
+ entry's oprleft
+ and oprright fields.
+ (Write 0 for the omitted operand of a unary
+ operator.)
+
+ The names of opclasses and opfamilies are only unique within an
+ access method, so they are represented
+ by access_method_name/object_name.
+
+ In none of these cases is there any provision for
+ schema-qualification; all objects created during bootstrap are
+ expected to be in the pg_catalog schema.
+
+ genbki.pl resolves all symbolic references while it
+ runs, and puts simple numeric OIDs into the emitted BKI file. There is
+ therefore no need for the bootstrap backend to deal with symbolic
+ references.
+
+ It's desirable to mark OID reference columns
+ with BKI_LOOKUP or BKI_LOOKUP_OPT
+ even if the catalog has no initial data that requires lookup. This
+ allows genbki.pl to record the foreign key
+ relationships that exist in the system catalogs. That information is
+ used in the regression tests to check for incorrect entries. See also
+ the macros DECLARE_FOREIGN_KEY,
+ DECLARE_FOREIGN_KEY_OPT,
+ DECLARE_ARRAY_FOREIGN_KEY,
+ and DECLARE_ARRAY_FOREIGN_KEY_OPT, which are
+ used to declare foreign key relationships that are too complex
+ for BKI_LOOKUP (typically, multi-column foreign
+ keys).
+
75.2.4. Automatic Creation of Array Types #
+ Most scalar data types should have a corresponding array type (that is,
+ a standard varlena array type whose element type is the scalar type, and
+ which is referenced by the typarray field of
+ the scalar type's pg_type
+ entry). genbki.pl is able to generate
+ the pg_type entry for the array type
+ automatically in most cases.
+
+ To use this facility, just write an array_type_oid
+ => nnnn metadata field in the
+ scalar type's pg_type entry, specifying the OID
+ to use for the array type. You may then omit
+ the typarray field, since it will be filled
+ automatically with that OID.
+
+ The generated array type's name is the scalar type's name with an
+ underscore prepended. The array entry's other fields are filled from
+ BKI_ARRAY_DEFAULT(value)
+ annotations in pg_type.h, or if there isn't one,
+ copied from the scalar type. (There's also a special case
+ for typalign.) Then
+ the typelem
+ and typarray fields of the two entries are
+ set to cross-reference each other.
+
75.2.5. Recipes for Editing Data Files #
+ Here are some suggestions about the easiest ways to perform common tasks
+ when updating catalog data files.
+
Add a new column with a default to a catalog:
+ Add the column to the header file with
+ a BKI_DEFAULT(value)
+ annotation. The data file need only be adjusted by adding the field
+ in existing rows where a non-default value is needed.
+
Add a default value to an existing column that doesn't have
+ one:
+ Add a BKI_DEFAULT annotation to the header file,
+ then run make reformat-dat-files to remove
+ now-redundant field entries.
+
Remove a column, whether it has a default or not:
+ Remove the column from the header, then run make
+ reformat-dat-files to remove now-useless field entries.
+
Change or remove an existing default value:
+ You cannot simply change the header file, since that will cause the
+ current data to be interpreted incorrectly. First run make
+ expand-dat-files to rewrite the data files with all
+ default values inserted explicitly, then change or remove
+ the BKI_DEFAULT annotation, then run make
+ reformat-dat-files to remove superfluous fields again.
+
Ad-hoc bulk editing:
+ reformat_dat_file.pl can be adapted to perform
+ many kinds of bulk changes. Look for its block comments showing where
+ one-off code can be inserted. In the following example, we are going
+ to consolidate two Boolean fields in pg_proc
+ into a char field:
+
+
+ Add the new column, with a default,
+ to pg_proc.h:
+
++ /* see PROKIND_ categories below */
++ char prokind BKI_DEFAULT(f);
+
+
+ Create a new script based on reformat_dat_file.pl
+ to insert appropriate values on-the-fly:
+
+- # At this point we have the full row in memory as a hash
+- # and can do any operations we want. As written, it only
+- # removes default values, but this script can be adapted to
+- # do one-off bulk-editing.
++ # One-off change to migrate to prokind
++ # Default has already been filled in by now, so change to other
++ # values as appropriate
++ if ($values{proisagg} eq 't')
++ {
++ $values{prokind} = 'a';
++ }
++ elsif ($values{proiswindow} eq 't')
++ {
++ $values{prokind} = 'w';
++ }
+
+
+ Run the new script:
+
+$ cd src/include/catalog
+$ perl rewrite_dat_with_prokind.pl pg_proc.dat
+
+ At this point pg_proc.dat has all three
+ columns, prokind,
+ proisagg,
+ and proiswindow, though they will appear
+ only in rows where they have non-default values.
+
+ Remove the old columns from pg_proc.h:
+
+- /* is it an aggregate? */
+- bool proisagg BKI_DEFAULT(f);
+-
+- /* is it a window function? */
+- bool proiswindow BKI_DEFAULT(f);
+
+
+ Finally, run make reformat-dat-files to remove
+ the useless old entries from pg_proc.dat.
+
+
+ For further examples of scripts used for bulk editing, see
+ convert_oid2name.pl
+ and remove_pg_type_oid_symbols.pl attached to this
+ message:
+ https://www.postgresql.org/message-id/CAJVSVGVX8gXnPm+Xa=DxR7kFYprcQ1tNcCT5D0O3ShfnM6jehA@mail.gmail.com
+
Chapter 63. Table Access Method Interface Definition
+ This chapter explains the interface between the core
+ PostgreSQL system and table access
+ methods, which manage the storage for tables. The core system
+ knows little about these access methods beyond what is specified here, so
+ it is possible to develop entirely new access method types by writing
+ add-on code.
+
+ Each table access method is described by a row in the pg_am system
+ catalog. The pg_am entry specifies a name and a
+ handler function for the table access method. These
+ entries can be created and deleted using the CREATE ACCESS METHOD and DROP ACCESS METHOD SQL commands.
+
+ A table access method handler function must be declared to accept a single
+ argument of type internal and to return the pseudo-type
+ table_am_handler. The argument is a dummy value that simply
+ serves to prevent handler functions from being called directly from SQL commands.
+
+ The result of the function must be a pointer to a struct of type
+ TableAmRoutine, which contains everything that the
+ core code needs to know to make use of the table access method. The return
+ value needs to be of server lifetime, which is typically achieved by
+ defining it as a static const variable in global
+ scope. The TableAmRoutine struct, also called the
+ access method's API struct, defines the behavior of
+ the access method using callbacks. These callbacks are pointers to plain C
+ functions and are not visible or callable at the SQL level. All the
+ callbacks and their behavior is defined in the
+ TableAmRoutine structure (with comments inside the
+ struct defining the requirements for callbacks). Most callbacks have
+ wrapper functions, which are documented from the point of view of a user
+ (rather than an implementor) of the table access method. For details,
+ please refer to the
+ src/include/access/tableam.h file.
+
+ To implement an access method, an implementor will typically need to
+ implement an AM-specific type of tuple table slot (see
+
+ src/include/executor/tuptable.h), which allows
+ code outside the access method to hold references to tuples of the AM, and
+ to access the columns of the tuple.
+
+ Currently, the way an AM actually stores data is fairly unconstrained. For
+ example, it's possible, but not required, to use postgres' shared buffer
+ cache. In case it is used, it likely makes sense to use
+ PostgreSQL's standard page layout as described in
+ Section 73.6.
+
+ One fairly large constraint of the table access method API is that,
+ currently, if the AM wants to support modifications and/or indexes, it is
+ necessary for each tuple to have a tuple identifier (TID)
+ consisting of a block number and an item number (see also Section 73.6). It is not strictly necessary that the
+ sub-parts of TIDs have the same meaning they e.g., have
+ for heap, but if bitmap scan support is desired (it is
+ optional), the block number needs to provide locality.
+
+ For crash safety, an AM can use postgres' WAL, or a custom implementation.
+ If WAL is chosen, either Generic WAL Records can be used,
+ or a Custom WAL Resource Manager can be
+ implemented.
+
+ To implement transactional support in a manner that allows different table
+ access methods be accessed within a single transaction, it likely is
+ necessary to closely integrate with the machinery in
+ src/backend/access/transam/xlog.c.
+
+ Any developer of a new table access method can refer to
+ the existing heap implementation present in
+ src/backend/access/heap/heapam_handler.c for details of
+ its implementation.
+
F.43. tablefunc — functions that return tables (crosstab and others) #
+ The tablefunc module includes various functions that return
+ tables (that is, multiple rows). These functions are useful both in their
+ own right and as examples of how to write C functions that return
+ multiple rows.
+
+ This module is considered “trusted”, that is, it can be
+ installed by non-superusers who have CREATE privilege
+ on the current database.
+
F.43.1. Functions Provided #
+ Table F.32 summarizes the functions provided
+ by the tablefunc module.
+
Table F.32. tablefunc Functions
+ Function
+
+
+ Description
+ |
|---|
+ normal_rand ( numvals integer, mean float8, stddev float8 )
+ → setof float8
+
+
+ Produces a set of normally distributed random values.
+ |
+ crosstab ( sql text )
+ → setof record
+
+
+ Produces a “pivot table” containing
+ row names plus N value columns, where
+ N is determined by the row type specified
+ in the calling query.
+ |
+ crosstabN ( sql text )
+ → setof table_crosstab_N
+
+
+ Produces a “pivot table” containing
+ row names plus N value columns.
+ crosstab2, crosstab3, and
+ crosstab4 are predefined, but you can create additional
+ crosstabN functions as described below.
+ |
+ crosstab ( source_sql text, category_sql text )
+ → setof record
+
+
+ Produces a “pivot table”
+ with the value columns specified by a second query.
+ |
+ crosstab ( sql text, N integer )
+ → setof record
+
+
+ Obsolete version of crosstab(text).
+ The parameter N is now ignored, since the
+ number of value columns is always determined by the calling query.
+ |
+
+ connectby ( relname text, keyid_fld text, parent_keyid_fld text
+ [, orderby_fld text ], start_with text, max_depth integer
+ [, branch_delim text ] )
+ → setof record
+
+
+ Produces a representation of a hierarchical tree structure.
+ |
+normal_rand(int numvals, float8 mean, float8 stddev) returns setof float8
+
+ normal_rand produces a set of normally distributed random
+ values (Gaussian distribution).
+
+ numvals is the number of values to be returned
+ from the function. mean is the mean of the normal
+ distribution of values and stddev is the standard
+ deviation of the normal distribution of values.
+
+ For example, this call requests 1000 values with a mean of 5 and a
+ standard deviation of 3:
+
+test=# SELECT * FROM normal_rand(1000, 5, 3);
+ normal_rand
+----------------------
+ 1.56556322244898
+ 9.10040991424657
+ 5.36957140345079
+ -0.369151492880995
+ 0.283600703686639
+ .
+ .
+ .
+ 4.82992125404908
+ 9.71308014517282
+ 2.49639286969028
+(1000 rows)
+
F.43.1.2. crosstab(text) #
+crosstab(text sql)
+crosstab(text sql, int N)
+
+ The crosstab function is used to produce “pivot”
+ displays, wherein data is listed across the page rather than down.
+ For example, we might have data like
+
+row1 val11
+row1 val12
+row1 val13
+...
+row2 val21
+row2 val22
+row2 val23
+...
+
+ which we wish to display like
+
+row1 val11 val12 val13 ...
+row2 val21 val22 val23 ...
+...
+
+ The crosstab function takes a text parameter that is an SQL
+ query producing raw data formatted in the first way, and produces a table
+ formatted in the second way.
+
+ The sql parameter is an SQL statement that produces
+ the source set of data. This statement must return one
+ row_name column, one
+ category column, and one
+ value column. N is an
+ obsolete parameter, ignored if supplied (formerly this had to match the
+ number of output value columns, but now that is determined by the
+ calling query).
+
+ For example, the provided query might produce a set something like:
+
+ row_name cat value
+----------+-------+-------
+ row1 cat1 val1
+ row1 cat2 val2
+ row1 cat3 val3
+ row1 cat4 val4
+ row2 cat1 val5
+ row2 cat2 val6
+ row2 cat3 val7
+ row2 cat4 val8
+
+
+ The crosstab function is declared to return setof
+ record, so the actual names and types of the output columns must be
+ defined in the FROM clause of the calling SELECT
+ statement, for example:
+
+SELECT * FROM crosstab('...') AS ct(row_name text, category_1 text, category_2 text);
+
+ This example produces a set something like:
+
+ <== value columns ==>
+ row_name category_1 category_2
+----------+------------+------------
+ row1 val1 val2
+ row2 val5 val6
+
+
+ The FROM clause must define the output as one
+ row_name column (of the same data type as the first result
+ column of the SQL query) followed by N value columns
+ (all of the same data type as the third result column of the SQL query).
+ You can set up as many output value columns as you wish. The names of the
+ output columns are up to you.
+
+ The crosstab function produces one output row for each
+ consecutive group of input rows with the same
+ row_name value. It fills the output
+ value columns, left to right, with the
+ value fields from these rows. If there
+ are fewer rows in a group than there are output value
+ columns, the extra output columns are filled with nulls; if there are
+ more rows, the extra input rows are skipped.
+
+ In practice the SQL query should always specify ORDER BY 1,2
+ to ensure that the input rows are properly ordered, that is, values with
+ the same row_name are brought together and
+ correctly ordered within the row. Notice that crosstab
+ itself does not pay any attention to the second column of the query
+ result; it's just there to be ordered by, to control the order in which
+ the third-column values appear across the page.
+
+ Here is a complete example:
+
+CREATE TABLE ct(id SERIAL, rowid TEXT, attribute TEXT, value TEXT);
+INSERT INTO ct(rowid, attribute, value) VALUES('test1','att1','val1');
+INSERT INTO ct(rowid, attribute, value) VALUES('test1','att2','val2');
+INSERT INTO ct(rowid, attribute, value) VALUES('test1','att3','val3');
+INSERT INTO ct(rowid, attribute, value) VALUES('test1','att4','val4');
+INSERT INTO ct(rowid, attribute, value) VALUES('test2','att1','val5');
+INSERT INTO ct(rowid, attribute, value) VALUES('test2','att2','val6');
+INSERT INTO ct(rowid, attribute, value) VALUES('test2','att3','val7');
+INSERT INTO ct(rowid, attribute, value) VALUES('test2','att4','val8');
+
+SELECT *
+FROM crosstab(
+ 'select rowid, attribute, value
+ from ct
+ where attribute = ''att2'' or attribute = ''att3''
+ order by 1,2')
+AS ct(row_name text, category_1 text, category_2 text, category_3 text);
+
+ row_name | category_1 | category_2 | category_3
+----------+------------+------------+------------
+ test1 | val2 | val3 |
+ test2 | val6 | val7 |
+(2 rows)
+
+
+ You can avoid always having to write out a FROM clause to
+ define the output columns, by setting up a custom crosstab function that
+ has the desired output row type wired into its definition. This is
+ described in the next section. Another possibility is to embed the
+ required FROM clause in a view definition.
+
Note
+ See also the \crosstabview
+ command in psql, which provides functionality similar
+ to crosstab().
+
F.43.1.3. crosstabN(text) #
+crosstabN(text sql)
+
+ The crosstabN functions are examples of how
+ to set up custom wrappers for the general crosstab function,
+ so that you need not write out column names and types in the calling
+ SELECT query. The tablefunc module includes
+ crosstab2, crosstab3, and
+ crosstab4, whose output row types are defined as
+
+CREATE TYPE tablefunc_crosstab_N AS (
+ row_name TEXT,
+ category_1 TEXT,
+ category_2 TEXT,
+ .
+ .
+ .
+ category_N TEXT
+);
+
+ Thus, these functions can be used directly when the input query produces
+ row_name and value columns of type
+ text, and you want 2, 3, or 4 output values columns.
+ In all other ways they behave exactly as described above for the
+ general crosstab function.
+
+ For instance, the example given in the previous section would also
+ work as
+
+SELECT *
+FROM crosstab3(
+ 'select rowid, attribute, value
+ from ct
+ where attribute = ''att2'' or attribute = ''att3''
+ order by 1,2');
+
+
+ These functions are provided mostly for illustration purposes. You
+ can create your own return types and functions based on the
+ underlying crosstab() function. There are two ways
+ to do it:
+
+
+ Create a composite type describing the desired output columns,
+ similar to the examples in
+ contrib/tablefunc/tablefunc--1.0.sql.
+ Then define a
+ unique function name accepting one text parameter and returning
+ setof your_type_name, but linking to the same underlying
+ crosstab C function. For example, if your source data
+ produces row names that are text, and values that are
+ float8, and you want 5 value columns:
+
+CREATE TYPE my_crosstab_float8_5_cols AS (
+ my_row_name text,
+ my_category_1 float8,
+ my_category_2 float8,
+ my_category_3 float8,
+ my_category_4 float8,
+ my_category_5 float8
+);
+
+CREATE OR REPLACE FUNCTION crosstab_float8_5_cols(text)
+ RETURNS setof my_crosstab_float8_5_cols
+ AS '$libdir/tablefunc','crosstab' LANGUAGE C STABLE STRICT;
+
+
+ Use OUT parameters to define the return type implicitly.
+ The same example could also be done this way:
+
+CREATE OR REPLACE FUNCTION crosstab_float8_5_cols(
+ IN text,
+ OUT my_row_name text,
+ OUT my_category_1 float8,
+ OUT my_category_2 float8,
+ OUT my_category_3 float8,
+ OUT my_category_4 float8,
+ OUT my_category_5 float8)
+ RETURNS setof record
+ AS '$libdir/tablefunc','crosstab' LANGUAGE C STABLE STRICT;
+
+
+
F.43.1.4. crosstab(text, text) #
+crosstab(text source_sql, text category_sql)
+
+ The main limitation of the single-parameter form of crosstab
+ is that it treats all values in a group alike, inserting each value into
+ the first available column. If you want the value
+ columns to correspond to specific categories of data, and some groups
+ might not have data for some of the categories, that doesn't work well.
+ The two-parameter form of crosstab handles this case by
+ providing an explicit list of the categories corresponding to the
+ output columns.
+
+ source_sql is an SQL statement that produces the
+ source set of data. This statement must return one
+ row_name column, one
+ category column, and one
+ value column. It may also have one or more
+ “extra” columns.
+ The row_name column must be first. The
+ category and value
+ columns must be the last two columns, in that order. Any columns between
+ row_name and
+ category are treated as “extra”.
+ The “extra” columns are expected to be the same for all rows
+ with the same row_name value.
+
+ For example, source_sql might produce a set
+ something like:
+
+SELECT row_name, extra_col, cat, value FROM foo ORDER BY 1;
+
+ row_name extra_col cat value
+----------+------------+-----+---------
+ row1 extra1 cat1 val1
+ row1 extra1 cat2 val2
+ row1 extra1 cat4 val4
+ row2 extra2 cat1 val5
+ row2 extra2 cat2 val6
+ row2 extra2 cat3 val7
+ row2 extra2 cat4 val8
+
+
+ category_sql is an SQL statement that produces
+ the set of categories. This statement must return only one column.
+ It must produce at least one row, or an error will be generated.
+ Also, it must not produce duplicate values, or an error will be
+ generated. category_sql might be something like:
+
+
+SELECT DISTINCT cat FROM foo ORDER BY 1;
+ cat
+ -------
+ cat1
+ cat2
+ cat3
+ cat4
+
+
+ The crosstab function is declared to return setof
+ record, so the actual names and types of the output columns must be
+ defined in the FROM clause of the calling SELECT
+ statement, for example:
+
+
+SELECT * FROM crosstab('...', '...')
+ AS ct(row_name text, extra text, cat1 text, cat2 text, cat3 text, cat4 text);
+
+
+ This will produce a result something like:
+
+ <== value columns ==>
+row_name extra cat1 cat2 cat3 cat4
+---------+-------+------+------+------+------
+ row1 extra1 val1 val2 val4
+ row2 extra2 val5 val6 val7 val8
+
+
+ The FROM clause must define the proper number of output
+ columns of the proper data types. If there are N
+ columns in the source_sql query's result, the first
+ N-2 of them must match up with the first
+ N-2 output columns. The remaining output columns
+ must have the type of the last column of the source_sql
+ query's result, and there must be exactly as many of them as there
+ are rows in the category_sql query's result.
+
+ The crosstab function produces one output row for each
+ consecutive group of input rows with the same
+ row_name value. The output
+ row_name column, plus any “extra”
+ columns, are copied from the first row of the group. The output
+ value columns are filled with the
+ value fields from rows having matching
+ category values. If a row's category
+ does not match any output of the category_sql
+ query, its value is ignored. Output
+ columns whose matching category is not present in any input row
+ of the group are filled with nulls.
+
+ In practice the source_sql query should always
+ specify ORDER BY 1 to ensure that values with the same
+ row_name are brought together. However,
+ ordering of the categories within a group is not important.
+ Also, it is essential to be sure that the order of the
+ category_sql query's output matches the specified
+ output column order.
+
+ Here are two complete examples:
+
+create table sales(year int, month int, qty int);
+insert into sales values(2007, 1, 1000);
+insert into sales values(2007, 2, 1500);
+insert into sales values(2007, 7, 500);
+insert into sales values(2007, 11, 1500);
+insert into sales values(2007, 12, 2000);
+insert into sales values(2008, 1, 1000);
+
+select * from crosstab(
+ 'select year, month, qty from sales order by 1',
+ 'select m from generate_series(1,12) m'
+) as (
+ year int,
+ "Jan" int,
+ "Feb" int,
+ "Mar" int,
+ "Apr" int,
+ "May" int,
+ "Jun" int,
+ "Jul" int,
+ "Aug" int,
+ "Sep" int,
+ "Oct" int,
+ "Nov" int,
+ "Dec" int
+);
+ year | Jan | Feb | Mar | Apr | May | Jun | Jul | Aug | Sep | Oct | Nov | Dec
+------+------+------+-----+-----+-----+-----+-----+-----+-----+-----+------+------
+ 2007 | 1000 | 1500 | | | | | 500 | | | | 1500 | 2000
+ 2008 | 1000 | | | | | | | | | | |
+(2 rows)
+
+
+
+CREATE TABLE cth(rowid text, rowdt timestamp, attribute text, val text);
+INSERT INTO cth VALUES('test1','01 March 2003','temperature','42');
+INSERT INTO cth VALUES('test1','01 March 2003','test_result','PASS');
+INSERT INTO cth VALUES('test1','01 March 2003','volts','2.6987');
+INSERT INTO cth VALUES('test2','02 March 2003','temperature','53');
+INSERT INTO cth VALUES('test2','02 March 2003','test_result','FAIL');
+INSERT INTO cth VALUES('test2','02 March 2003','test_startdate','01 March 2003');
+INSERT INTO cth VALUES('test2','02 March 2003','volts','3.1234');
+
+SELECT * FROM crosstab
+(
+ 'SELECT rowid, rowdt, attribute, val FROM cth ORDER BY 1',
+ 'SELECT DISTINCT attribute FROM cth ORDER BY 1'
+)
+AS
+(
+ rowid text,
+ rowdt timestamp,
+ temperature int4,
+ test_result text,
+ test_startdate timestamp,
+ volts float8
+);
+ rowid | rowdt | temperature | test_result | test_startdate | volts
+-------+--------------------------+-------------+-------------+--------------------------+--------
+ test1 | Sat Mar 01 00:00:00 2003 | 42 | PASS | | 2.6987
+ test2 | Sun Mar 02 00:00:00 2003 | 53 | FAIL | Sat Mar 01 00:00:00 2003 | 3.1234
+(2 rows)
+
+
+ You can create predefined functions to avoid having to write out
+ the result column names and types in each query. See the examples
+ in the previous section. The underlying C function for this form
+ of crosstab is named crosstab_hash.
+
+connectby(text relname, text keyid_fld, text parent_keyid_fld
+ [, text orderby_fld ], text start_with, int max_depth
+ [, text branch_delim ])
+
+ The connectby function produces a display of hierarchical
+ data that is stored in a table. The table must have a key field that
+ uniquely identifies rows, and a parent-key field that references the
+ parent (if any) of each row. connectby can display the
+ sub-tree descending from any row.
+
+ Table F.33 explains the
+ parameters.
+
Table F.33. connectby Parameters
| Parameter | Description |
|---|
relname | Name of the source relation |
keyid_fld | Name of the key field |
parent_keyid_fld | Name of the parent-key field |
orderby_fld | Name of the field to order siblings by (optional) |
start_with | Key value of the row to start at |
max_depth | Maximum depth to descend to, or zero for unlimited depth |
branch_delim | String to separate keys with in branch output (optional) |
+ The key and parent-key fields can be any data type, but they must be
+ the same type. Note that the start_with value must be
+ entered as a text string, regardless of the type of the key field.
+
+ The connectby function is declared to return setof
+ record, so the actual names and types of the output columns must be
+ defined in the FROM clause of the calling SELECT
+ statement, for example:
+
+SELECT * FROM connectby('connectby_tree', 'keyid', 'parent_keyid', 'pos', 'row2', 0, '~')
+ AS t(keyid text, parent_keyid text, level int, branch text, pos int);
+
+ The first two output columns are used for the current row's key and
+ its parent row's key; they must match the type of the table's key field.
+ The third output column is the depth in the tree and must be of type
+ integer. If a branch_delim parameter was
+ given, the next output column is the branch display and must be of type
+ text. Finally, if an orderby_fld
+ parameter was given, the last output column is a serial number, and must
+ be of type integer.
+
+ The “branch” output column shows the path of keys taken to
+ reach the current row. The keys are separated by the specified
+ branch_delim string. If no branch display is
+ wanted, omit both the branch_delim parameter
+ and the branch column in the output column list.
+
+ If the ordering of siblings of the same parent is important,
+ include the orderby_fld parameter to
+ specify which field to order siblings by. This field can be of any
+ sortable data type. The output column list must include a final
+ integer serial-number column, if and only if
+ orderby_fld is specified.
+
+ The parameters representing table and field names are copied as-is
+ into the SQL queries that connectby generates internally.
+ Therefore, include double quotes if the names are mixed-case or contain
+ special characters. You may also need to schema-qualify the table name.
+
+ In large tables, performance will be poor unless there is an index on
+ the parent-key field.
+
+ It is important that the branch_delim string
+ not appear in any key values, else connectby may incorrectly
+ report an infinite-recursion error. Note that if
+ branch_delim is not provided, a default value
+ of ~ is used for recursion detection purposes.
+
+
+ Here is an example:
+
+CREATE TABLE connectby_tree(keyid text, parent_keyid text, pos int);
+
+INSERT INTO connectby_tree VALUES('row1',NULL, 0);
+INSERT INTO connectby_tree VALUES('row2','row1', 0);
+INSERT INTO connectby_tree VALUES('row3','row1', 0);
+INSERT INTO connectby_tree VALUES('row4','row2', 1);
+INSERT INTO connectby_tree VALUES('row5','row2', 0);
+INSERT INTO connectby_tree VALUES('row6','row4', 0);
+INSERT INTO connectby_tree VALUES('row7','row3', 0);
+INSERT INTO connectby_tree VALUES('row8','row6', 0);
+INSERT INTO connectby_tree VALUES('row9','row5', 0);
+
+-- with branch, without orderby_fld (order of results is not guaranteed)
+SELECT * FROM connectby('connectby_tree', 'keyid', 'parent_keyid', 'row2', 0, '~')
+ AS t(keyid text, parent_keyid text, level int, branch text);
+ keyid | parent_keyid | level | branch
+-------+--------------+-------+---------------------
+ row2 | | 0 | row2
+ row4 | row2 | 1 | row2~row4
+ row6 | row4 | 2 | row2~row4~row6
+ row8 | row6 | 3 | row2~row4~row6~row8
+ row5 | row2 | 1 | row2~row5
+ row9 | row5 | 2 | row2~row5~row9
+(6 rows)
+
+-- without branch, without orderby_fld (order of results is not guaranteed)
+SELECT * FROM connectby('connectby_tree', 'keyid', 'parent_keyid', 'row2', 0)
+ AS t(keyid text, parent_keyid text, level int);
+ keyid | parent_keyid | level
+-------+--------------+-------
+ row2 | | 0
+ row4 | row2 | 1
+ row6 | row4 | 2
+ row8 | row6 | 3
+ row5 | row2 | 1
+ row9 | row5 | 2
+(6 rows)
+
+-- with branch, with orderby_fld (notice that row5 comes before row4)
+SELECT * FROM connectby('connectby_tree', 'keyid', 'parent_keyid', 'pos', 'row2', 0, '~')
+ AS t(keyid text, parent_keyid text, level int, branch text, pos int);
+ keyid | parent_keyid | level | branch | pos
+-------+--------------+-------+---------------------+-----
+ row2 | | 0 | row2 | 1
+ row5 | row2 | 1 | row2~row5 | 2
+ row9 | row5 | 2 | row2~row5~row9 | 3
+ row4 | row2 | 1 | row2~row4 | 4
+ row6 | row4 | 2 | row2~row4~row6 | 5
+ row8 | row6 | 3 | row2~row4~row6~row8 | 6
+(6 rows)
+
+-- without branch, with orderby_fld (notice that row5 comes before row4)
+SELECT * FROM connectby('connectby_tree', 'keyid', 'parent_keyid', 'pos', 'row2', 0)
+ AS t(keyid text, parent_keyid text, level int, pos int);
+ keyid | parent_keyid | level | pos
+-------+--------------+-------+-----
+ row2 | | 0 | 1
+ row5 | row2 | 1 | 2
+ row9 | row5 | 2 | 3
+ row4 | row2 | 1 | 4
+ row6 | row4 | 2 | 5
+ row8 | row6 | 3 | 6
+(6 rows)
+
+
Chapter 60. Writing a Table Sampling Method
+ PostgreSQL's implementation of the TABLESAMPLE
+ clause supports custom table sampling methods, in addition to
+ the BERNOULLI and SYSTEM methods that are required
+ by the SQL standard. The sampling method determines which rows of the
+ table will be selected when the TABLESAMPLE clause is used.
+
+ At the SQL level, a table sampling method is represented by a single SQL
+ function, typically implemented in C, having the signature
+
+method_name(internal) RETURNS tsm_handler
+
+ The name of the function is the same method name appearing in the
+ TABLESAMPLE clause. The internal argument is a dummy
+ (always having value zero) that simply serves to prevent this function from
+ being called directly from an SQL command.
+ The result of the function must be a palloc'd struct of
+ type TsmRoutine, which contains pointers to support functions for
+ the sampling method. These support functions are plain C functions and
+ are not visible or callable at the SQL level. The support functions are
+ described in Section 60.1.
+
+ In addition to function pointers, the TsmRoutine struct must
+ provide these additional fields:
+
List *parameterTypes
+ This is an OID list containing the data type OIDs of the parameter(s)
+ that will be accepted by the TABLESAMPLE clause when this
+ sampling method is used. For example, for the built-in methods, this
+ list contains a single item with value FLOAT4OID, which
+ represents the sampling percentage. Custom sampling methods can have
+ more or different parameters.
+
bool repeatable_across_queries
+ If true, the sampling method can deliver identical samples
+ across successive queries, if the same parameters
+ and REPEATABLE seed value are supplied each time and the
+ table contents have not changed. When this is false,
+ the REPEATABLE clause is not accepted for use with the
+ sampling method.
+
bool repeatable_across_scans
+ If true, the sampling method can deliver identical samples
+ across successive scans in the same query (assuming unchanging
+ parameters, seed value, and snapshot).
+ When this is false, the planner will not select plans that
+ would require scanning the sampled table more than once, since that
+ might result in inconsistent query output.
+
+ The TsmRoutine struct type is declared
+ in src/include/access/tsmapi.h, which see for additional
+ details.
+
+ The table sampling methods included in the standard distribution are good
+ references when trying to write your own. Look into
+ the src/backend/access/tablesample subdirectory of the source
+ tree for the built-in sampling methods, and into the contrib
+ subdirectory for add-on methods.
+
60.1. Sampling Method Support Functions #
+ The TSM handler function returns a palloc'd TsmRoutine struct
+ containing pointers to the support functions described below. Most of
+ the functions are required, but some are optional, and those pointers can
+ be NULL.
+
+
+void
+SampleScanGetSampleSize (PlannerInfo *root,
+ RelOptInfo *baserel,
+ List *paramexprs,
+ BlockNumber *pages,
+ double *tuples);
+
+
+ This function is called during planning. It must estimate the number of
+ relation pages that will be read during a sample scan, and the number of
+ tuples that will be selected by the scan. (For example, these might be
+ determined by estimating the sampling fraction, and then multiplying
+ the baserel->pages and baserel->tuples
+ numbers by that, being sure to round the results to integral values.)
+ The paramexprs list holds the expression(s) that are
+ parameters to the TABLESAMPLE clause. It is recommended to
+ use estimate_expression_value() to try to reduce these
+ expressions to constants, if their values are needed for estimation
+ purposes; but the function must provide size estimates even if they cannot
+ be reduced, and it should not fail even if the values appear invalid
+ (remember that they're only estimates of what the run-time values will be).
+ The pages and tuples parameters are outputs.
+
+
+void
+InitSampleScan (SampleScanState *node,
+ int eflags);
+
+
+ Initialize for execution of a SampleScan plan node.
+ This is called during executor startup.
+ It should perform any initialization needed before processing can start.
+ The SampleScanState node has already been created, but
+ its tsm_state field is NULL.
+ The InitSampleScan function can palloc whatever internal
+ state data is needed by the sampling method, and store a pointer to
+ it in node->tsm_state.
+ Information about the table to scan is accessible through other fields
+ of the SampleScanState node (but note that the
+ node->ss.ss_currentScanDesc scan descriptor is not set
+ up yet).
+ eflags contains flag bits describing the executor's
+ operating mode for this plan node.
+
+ When (eflags & EXEC_FLAG_EXPLAIN_ONLY) is true,
+ the scan will not actually be performed, so this function should only do
+ the minimum required to make the node state valid for EXPLAIN
+ and EndSampleScan.
+
+ This function can be omitted (set the pointer to NULL), in which case
+ BeginSampleScan must perform all initialization needed
+ by the sampling method.
+
+
+void
+BeginSampleScan (SampleScanState *node,
+ Datum *params,
+ int nparams,
+ uint32 seed);
+
+
+ Begin execution of a sampling scan.
+ This is called just before the first attempt to fetch a tuple, and
+ may be called again if the scan needs to be restarted.
+ Information about the table to scan is accessible through fields
+ of the SampleScanState node (but note that the
+ node->ss.ss_currentScanDesc scan descriptor is not set
+ up yet).
+ The params array, of length nparams, contains the
+ values of the parameters supplied in the TABLESAMPLE clause.
+ These will have the number and types specified in the sampling
+ method's parameterTypes list, and have been checked
+ to not be null.
+ seed contains a seed to use for any random numbers generated
+ within the sampling method; it is either a hash derived from the
+ REPEATABLE value if one was given, or the result
+ of random() if not.
+
+ This function may adjust the fields node->use_bulkread
+ and node->use_pagemode.
+ If node->use_bulkread is true, which it is by
+ default, the scan will use a buffer access strategy that encourages
+ recycling buffers after use. It might be reasonable to set this
+ to false if the scan will visit only a small fraction of the
+ table's pages.
+ If node->use_pagemode is true, which it is by
+ default, the scan will perform visibility checking in a single pass for
+ all tuples on each visited page. It might be reasonable to set this
+ to false if the scan will select only a small fraction of the
+ tuples on each visited page. That will result in fewer tuple visibility
+ checks being performed, though each one will be more expensive because it
+ will require more locking.
+
+ If the sampling method is
+ marked repeatable_across_scans, it must be able to
+ select the same set of tuples during a rescan as it did originally, that is
+ a fresh call of BeginSampleScan must lead to selecting the
+ same tuples as before (if the TABLESAMPLE parameters
+ and seed don't change).
+
+
+BlockNumber
+NextSampleBlock (SampleScanState *node, BlockNumber nblocks);
+
+
+ Returns the block number of the next page to be scanned, or
+ InvalidBlockNumber if no pages remain to be scanned.
+
+ This function can be omitted (set the pointer to NULL), in which case
+ the core code will perform a sequential scan of the entire relation.
+ Such a scan can use synchronized scanning, so that the sampling method
+ cannot assume that the relation pages are visited in the same order on
+ each scan.
+
+
+OffsetNumber
+NextSampleTuple (SampleScanState *node,
+ BlockNumber blockno,
+ OffsetNumber maxoffset);
+
+
+ Returns the offset number of the next tuple to be sampled on the
+ specified page, or InvalidOffsetNumber if no tuples remain to
+ be sampled. maxoffset is the largest offset number in use
+ on the page.
+
Note
+ NextSampleTuple is not explicitly told which of the offset
+ numbers in the range 1 .. maxoffset actually contain valid
+ tuples. This is not normally a problem since the core code ignores
+ requests to sample missing or invisible tuples; that should not result in
+ any bias in the sample. However, if necessary, the function can use
+ node->donetuples to examine how many of the tuples
+ it returned were valid and visible.
+
Note
+ NextSampleTuple must not assume
+ that blockno is the same page number returned by the most
+ recent NextSampleBlock call. It was returned by some
+ previous NextSampleBlock call, but the core code is allowed
+ to call NextSampleBlock in advance of actually scanning
+ pages, so as to support prefetching. It is OK to assume that once
+ sampling of a given page begins, successive NextSampleTuple
+ calls all refer to the same page until InvalidOffsetNumber is
+ returned.
+
+
+void
+EndSampleScan (SampleScanState *node);
+
+
+ End the scan and release resources. It is normally not important
+ to release palloc'd memory, but any externally-visible resources
+ should be cleaned up.
+ This function can be omitted (set the pointer to NULL) in the common
+ case where no such resources exist.
+
F.44. tcn — a trigger function to notify listeners of changes to table content #
+ The tcn module provides a trigger function that notifies
+ listeners of changes to any table on which it is attached. It must be
+ used as an AFTER trigger FOR EACH ROW.
+
+ This module is considered “trusted”, that is, it can be
+ installed by non-superusers who have CREATE privilege
+ on the current database.
+
+ Only one parameter may be supplied to the function in a
+ CREATE TRIGGER statement, and that is optional. If supplied
+ it will be used for the channel name for the notifications. If omitted
+ tcn will be used for the channel name.
+
+ The payload of the notifications consists of the table name, a letter to
+ indicate which type of operation was performed, and column name/value pairs
+ for primary key columns. Each part is separated from the next by a comma.
+ For ease of parsing using regular expressions, table and column names are
+ always wrapped in double quotes, and data values are always wrapped in
+ single quotes. Embedded quotes are doubled.
+
+ A brief example of using the extension follows.
+
+
+test=# create table tcndata
+test-# (
+test(# a int not null,
+test(# b date not null,
+test(# c text,
+test(# primary key (a, b)
+test(# );
+CREATE TABLE
+test=# create trigger tcndata_tcn_trigger
+test-# after insert or update or delete on tcndata
+test-# for each row execute function triggered_change_notification();
+CREATE TRIGGER
+test=# listen tcn;
+LISTEN
+test=# insert into tcndata values (1, date '2012-12-22', 'one'),
+test-# (1, date '2012-12-23', 'another'),
+test-# (2, date '2012-12-23', 'two');
+INSERT 0 3
+Asynchronous notification "tcn" with payload ""tcndata",I,"a"='1',"b"='2012-12-22'" received from server process with PID 22770.
+Asynchronous notification "tcn" with payload ""tcndata",I,"a"='1',"b"='2012-12-23'" received from server process with PID 22770.
+Asynchronous notification "tcn" with payload ""tcndata",I,"a"='2',"b"='2012-12-23'" received from server process with PID 22770.
+test=# update tcndata set c = 'uno' where a = 1;
+UPDATE 2
+Asynchronous notification "tcn" with payload ""tcndata",U,"a"='1',"b"='2012-12-22'" received from server process with PID 22770.
+Asynchronous notification "tcn" with payload ""tcndata",U,"a"='1',"b"='2012-12-23'" received from server process with PID 22770.
+test=# delete from tcndata where a = 1 and b = date '2012-12-22';
+DELETE 1
+Asynchronous notification "tcn" with payload ""tcndata",D,"a"='1',"b"='2012-12-22'" received from server process with PID 22770.
+
+
F.45. test_decoding — SQL-based test/example module for WAL logical decoding #
+ test_decoding is an example of a logical decoding
+ output plugin. It doesn't do anything especially useful, but can serve as
+ a starting point for developing your own output plugin.
+
+ test_decoding receives WAL through the logical decoding
+ mechanism and decodes it into text representations of the operations
+ performed.
+
+ Typical output from this plugin, used over the SQL logical decoding
+ interface, might be:
+
+
+postgres=# SELECT * FROM pg_logical_slot_get_changes('test_slot', NULL, NULL, 'include-xids', '0');
+ lsn | xid | data
+-----------+-----+--------------------------------------------------
+ 0/16D30F8 | 691 | BEGIN
+ 0/16D32A0 | 691 | table public.data: INSERT: id[int4]:2 data[text]:'arg'
+ 0/16D32A0 | 691 | table public.data: INSERT: id[int4]:3 data[text]:'demo'
+ 0/16D32A0 | 691 | COMMIT
+ 0/16D32D8 | 692 | BEGIN
+ 0/16D3398 | 692 | table public.data: DELETE: id[int4]:2
+ 0/16D3398 | 692 | table public.data: DELETE: id[int4]:3
+ 0/16D3398 | 692 | COMMIT
+(8 rows)
+
+
+ We can also get the changes of the in-progress transaction, and the typical
+ output might be:
+
+
+postgres[33712]=#* SELECT * FROM pg_logical_slot_get_changes('test_slot', NULL, NULL, 'stream-changes', '1');
+ lsn | xid | data
+-----------+-----+--------------------------------------------------
+ 0/16B21F8 | 503 | opening a streamed block for transaction TXN 503
+ 0/16B21F8 | 503 | streaming change for TXN 503
+ 0/16B2300 | 503 | streaming change for TXN 503
+ 0/16B2408 | 503 | streaming change for TXN 503
+ 0/16BEBA0 | 503 | closing a streamed block for transaction TXN 503
+ 0/16B21F8 | 503 | opening a streamed block for transaction TXN 503
+ 0/16BECA8 | 503 | streaming change for TXN 503
+ 0/16BEDB0 | 503 | streaming change for TXN 503
+ 0/16BEEB8 | 503 | streaming change for TXN 503
+ 0/16BEBA0 | 503 | closing a streamed block for transaction TXN 503
+(10 rows)
+
+
12.7. Configuration Example #
+ A text search configuration specifies all options necessary to transform a
+ document into a tsvector: the parser to use to break text
+ into tokens, and the dictionaries to use to transform each token into a
+ lexeme. Every call of
+ to_tsvector or to_tsquery
+ needs a text search configuration to perform its processing.
+ The configuration parameter
+ default_text_search_config
+ specifies the name of the default configuration, which is the
+ one used by text search functions if an explicit configuration
+ parameter is omitted.
+ It can be set in postgresql.conf, or set for an
+ individual session using the SET command.
+
+ Several predefined text search configurations are available, and
+ you can create custom configurations easily. To facilitate management
+ of text search objects, a set of SQL commands
+ is available, and there are several psql commands that display information
+ about text search objects (Section 12.10).
+
+ As an example we will create a configuration
+ pg, starting by duplicating the built-in
+ english configuration:
+
+
+CREATE TEXT SEARCH CONFIGURATION public.pg ( COPY = pg_catalog.english );
+
+
+ We will use a PostgreSQL-specific synonym list
+ and store it in $SHAREDIR/tsearch_data/pg_dict.syn.
+ The file contents look like:
+
+
+postgres pg
+pgsql pg
+postgresql pg
+
+
+ We define the synonym dictionary like this:
+
+
+CREATE TEXT SEARCH DICTIONARY pg_dict (
+ TEMPLATE = synonym,
+ SYNONYMS = pg_dict
+);
+
+
+ Next we register the Ispell dictionary
+ english_ispell, which has its own configuration files:
+
+
+CREATE TEXT SEARCH DICTIONARY english_ispell (
+ TEMPLATE = ispell,
+ DictFile = english,
+ AffFile = english,
+ StopWords = english
+);
+
+
+ Now we can set up the mappings for words in configuration
+ pg:
+
+
+ALTER TEXT SEARCH CONFIGURATION pg
+ ALTER MAPPING FOR asciiword, asciihword, hword_asciipart,
+ word, hword, hword_part
+ WITH pg_dict, english_ispell, english_stem;
+
+
+ We choose not to index or search some token types that the built-in
+ configuration does handle:
+
+
+ALTER TEXT SEARCH CONFIGURATION pg
+ DROP MAPPING FOR email, url, url_path, sfloat, float;
+
+
+ Now we can test our configuration:
+
+
+SELECT * FROM ts_debug('public.pg', '
+PostgreSQL, the highly scalable, SQL compliant, open source object-relational
+database management system, is now undergoing beta testing of the next
+version of our software.
+');
+
+
+ The next step is to set the session to use the new configuration, which was
+ created in the public schema:
+
+
+=> \dF
+ List of text search configurations
+ Schema | Name | Description
+---------+------+-------------
+ public | pg |
+
+SET default_text_search_config = 'public.pg';
+SET
+
+SHOW default_text_search_config;
+ default_text_search_config
+----------------------------
+ public.pg
+
+
12.3. Controlling Text Search #
+ To implement full text searching there must be a function to create a
+ tsvector from a document and a tsquery from a
+ user query. Also, we need to return results in a useful order, so we need
+ a function that compares documents with respect to their relevance to
+ the query. It's also important to be able to display the results nicely.
+ PostgreSQL provides support for all of these
+ functions.
+
12.3.1. Parsing Documents #
+ PostgreSQL provides the
+ function to_tsvector for converting a document to
+ the tsvector data type.
+
+to_tsvector([ config regconfig, ] document text) returns tsvector
+
+ to_tsvector parses a textual document into tokens,
+ reduces the tokens to lexemes, and returns a tsvector which
+ lists the lexemes together with their positions in the document.
+ The document is processed according to the specified or default
+ text search configuration.
+ Here is a simple example:
+
+
+SELECT to_tsvector('english', 'a fat cat sat on a mat - it ate a fat rats');
+ to_tsvector
+-----------------------------------------------------
+ 'ate':9 'cat':3 'fat':2,11 'mat':7 'rat':12 'sat':4
+
+
+ In the example above we see that the resulting tsvector does not
+ contain the words a, on, or
+ it, the word rats became
+ rat, and the punctuation sign - was
+ ignored.
+
+ The to_tsvector function internally calls a parser
+ which breaks the document text into tokens and assigns a type to
+ each token. For each token, a list of
+ dictionaries (Section 12.6) is consulted,
+ where the list can vary depending on the token type. The first dictionary
+ that recognizes the token emits one or more normalized
+ lexemes to represent the token. For example,
+ rats became rat because one of the
+ dictionaries recognized that the word rats is a plural
+ form of rat. Some words are recognized as
+ stop words (Section 12.6.1), which
+ causes them to be ignored since they occur too frequently to be useful in
+ searching. In our example these are
+ a, on, and it.
+ If no dictionary in the list recognizes the token then it is also ignored.
+ In this example that happened to the punctuation sign -
+ because there are in fact no dictionaries assigned for its token type
+ (Space symbols), meaning space tokens will never be
+ indexed. The choices of parser, dictionaries and which types of tokens to
+ index are determined by the selected text search configuration (Section 12.7). It is possible to have
+ many different configurations in the same database, and predefined
+ configurations are available for various languages. In our example
+ we used the default configuration english for the
+ English language.
+
+ The function setweight can be used to label the
+ entries of a tsvector with a given weight,
+ where a weight is one of the letters A, B,
+ C, or D.
+ This is typically used to mark entries coming from
+ different parts of a document, such as title versus body. Later, this
+ information can be used for ranking of search results.
+
+ Because to_tsvector(NULL) will
+ return NULL, it is recommended to use
+ coalesce whenever a field might be null.
+ Here is the recommended method for creating
+ a tsvector from a structured document:
+
+
+UPDATE tt SET ti =
+ setweight(to_tsvector(coalesce(title,'')), 'A') ||
+ setweight(to_tsvector(coalesce(keyword,'')), 'B') ||
+ setweight(to_tsvector(coalesce(abstract,'')), 'C') ||
+ setweight(to_tsvector(coalesce(body,'')), 'D');
+
+
+ Here we have used setweight to label the source
+ of each lexeme in the finished tsvector, and then merged
+ the labeled tsvector values using the tsvector
+ concatenation operator ||. (Section 12.4.1 gives details about these
+ operations.)
+
12.3.2. Parsing Queries #
+ PostgreSQL provides the
+ functions to_tsquery,
+ plainto_tsquery,
+ phraseto_tsquery and
+ websearch_to_tsquery
+ for converting a query to the tsquery data type.
+ to_tsquery offers access to more features
+ than either plainto_tsquery or
+ phraseto_tsquery, but it is less forgiving about its
+ input. websearch_to_tsquery is a simplified version
+ of to_tsquery with an alternative syntax, similar
+ to the one used by web search engines.
+
+to_tsquery([ config regconfig, ] querytext text) returns tsquery
+
+ to_tsquery creates a tsquery value from
+ querytext, which must consist of single tokens
+ separated by the tsquery operators & (AND),
+ | (OR), ! (NOT), and
+ <-> (FOLLOWED BY), possibly grouped
+ using parentheses. In other words, the input to
+ to_tsquery must already follow the general rules for
+ tsquery input, as described in Section 8.11.2. The difference is that while basic
+ tsquery input takes the tokens at face value,
+ to_tsquery normalizes each token into a lexeme using
+ the specified or default configuration, and discards any tokens that are
+ stop words according to the configuration. For example:
+
+
+SELECT to_tsquery('english', 'The & Fat & Rats');
+ to_tsquery
+---------------
+ 'fat' & 'rat'
+
+
+ As in basic tsquery input, weight(s) can be attached to each
+ lexeme to restrict it to match only tsvector lexemes of those
+ weight(s). For example:
+
+
+SELECT to_tsquery('english', 'Fat | Rats:AB');
+ to_tsquery
+------------------
+ 'fat' | 'rat':AB
+
+
+ Also, * can be attached to a lexeme to specify prefix matching:
+
+
+SELECT to_tsquery('supern:*A & star:A*B');
+ to_tsquery
+--------------------------
+ 'supern':*A & 'star':*AB
+
+
+ Such a lexeme will match any word in a tsvector that begins
+ with the given string.
+
+ to_tsquery can also accept single-quoted
+ phrases. This is primarily useful when the configuration includes a
+ thesaurus dictionary that may trigger on such phrases.
+ In the example below, a thesaurus contains the rule supernovae
+ stars : sn:
+
+
+SELECT to_tsquery('''supernovae stars'' & !crab');
+ to_tsquery
+---------------
+ 'sn' & !'crab'
+
+
+ Without quotes, to_tsquery will generate a syntax
+ error for tokens that are not separated by an AND, OR, or FOLLOWED BY
+ operator.
+
+plainto_tsquery([ config regconfig, ] querytext text) returns tsquery
+
+ plainto_tsquery transforms the unformatted text
+ querytext to a tsquery value.
+ The text is parsed and normalized much as for to_tsvector,
+ then the & (AND) tsquery operator is
+ inserted between surviving words.
+
+ Example:
+
+
+SELECT plainto_tsquery('english', 'The Fat Rats');
+ plainto_tsquery
+-----------------
+ 'fat' & 'rat'
+
+
+ Note that plainto_tsquery will not
+ recognize tsquery operators, weight labels,
+ or prefix-match labels in its input:
+
+
+SELECT plainto_tsquery('english', 'The Fat & Rats:C');
+ plainto_tsquery
+---------------------
+ 'fat' & 'rat' & 'c'
+
+
+ Here, all the input punctuation was discarded.
+
+phraseto_tsquery([ config regconfig, ] querytext text) returns tsquery
+
+ phraseto_tsquery behaves much like
+ plainto_tsquery, except that it inserts
+ the <-> (FOLLOWED BY) operator between
+ surviving words instead of the & (AND) operator.
+ Also, stop words are not simply discarded, but are accounted for by
+ inserting <N> operators rather
+ than <-> operators. This function is useful
+ when searching for exact lexeme sequences, since the FOLLOWED BY
+ operators check lexeme order not just the presence of all the lexemes.
+
+ Example:
+
+
+SELECT phraseto_tsquery('english', 'The Fat Rats');
+ phraseto_tsquery
+------------------
+ 'fat' <-> 'rat'
+
+
+ Like plainto_tsquery, the
+ phraseto_tsquery function will not
+ recognize tsquery operators, weight labels,
+ or prefix-match labels in its input:
+
+
+SELECT phraseto_tsquery('english', 'The Fat & Rats:C');
+ phraseto_tsquery
+-----------------------------
+ 'fat' <-> 'rat' <-> 'c'
+
+
+websearch_to_tsquery([ config regconfig, ] querytext text) returns tsquery
+
+ websearch_to_tsquery creates a tsquery
+ value from querytext using an alternative
+ syntax in which simple unformatted text is a valid query.
+ Unlike plainto_tsquery
+ and phraseto_tsquery, it also recognizes certain
+ operators. Moreover, this function will never raise syntax errors,
+ which makes it possible to use raw user-supplied input for search.
+ The following syntax is supported:
+
+
+ unquoted text: text not inside quote marks will be
+ converted to terms separated by & operators, as
+ if processed by plainto_tsquery.
+
+ "quoted text": text inside quote marks will be
+ converted to terms separated by <->
+ operators, as if processed by phraseto_tsquery.
+
+ OR: the word “or” will be converted to
+ the | operator.
+
+ -: a dash will be converted to
+ the ! operator.
+
+
+ Other punctuation is ignored. So
+ like plainto_tsquery
+ and phraseto_tsquery,
+ the websearch_to_tsquery function will not
+ recognize tsquery operators, weight labels, or prefix-match
+ labels in its input.
+
+ Examples:
+
+SELECT websearch_to_tsquery('english', 'The fat rats');
+ websearch_to_tsquery
+----------------------
+ 'fat' & 'rat'
+(1 row)
+
+SELECT websearch_to_tsquery('english', '"supernovae stars" -crab');
+ websearch_to_tsquery
+----------------------------------
+ 'supernova' <-> 'star' & !'crab'
+(1 row)
+
+SELECT websearch_to_tsquery('english', '"sad cat" or "fat rat"');
+ websearch_to_tsquery
+-----------------------------------
+ 'sad' <-> 'cat' | 'fat' <-> 'rat'
+(1 row)
+
+SELECT websearch_to_tsquery('english', 'signal -"segmentation fault"');
+ websearch_to_tsquery
+---------------------------------------
+ 'signal' & !( 'segment' <-> 'fault' )
+(1 row)
+
+SELECT websearch_to_tsquery('english', '""" )( dummy \\ query <->');
+ websearch_to_tsquery
+----------------------
+ 'dummi' & 'queri'
+(1 row)
+
+
12.3.3. Ranking Search Results #
+ Ranking attempts to measure how relevant documents are to a particular
+ query, so that when there are many matches the most relevant ones can be
+ shown first. PostgreSQL provides two
+ predefined ranking functions, which take into account lexical, proximity,
+ and structural information; that is, they consider how often the query
+ terms appear in the document, how close together the terms are in the
+ document, and how important is the part of the document where they occur.
+ However, the concept of relevancy is vague and very application-specific.
+ Different applications might require additional information for ranking,
+ e.g., document modification time. The built-in ranking functions are only
+ examples. You can write your own ranking functions and/or combine their
+ results with additional factors to fit your specific needs.
+
+ The two ranking functions currently available are:
+
+
-
+
+
+
ts_rank([ weights float4[], ] vector tsvector, query tsquery [, normalization integer ]) returns float4
+
+ Ranks vectors based on the frequency of their matching lexemes.
+
-
+
+
+
ts_rank_cd([ weights float4[], ] vector tsvector, query tsquery [, normalization integer ]) returns float4
+
+ This function computes the cover density
+ ranking for the given document vector and query, as described in
+ Clarke, Cormack, and Tudhope's "Relevance Ranking for One to Three
+ Term Queries" in the journal "Information Processing and Management",
+ 1999. Cover density is similar to ts_rank ranking
+ except that the proximity of matching lexemes to each other is
+ taken into consideration.
+
+ This function requires lexeme positional information to perform
+ its calculation. Therefore, it ignores any “stripped”
+ lexemes in the tsvector. If there are no unstripped
+ lexemes in the input, the result will be zero. (See Section 12.4.1 for more information
+ about the strip function and positional information
+ in tsvectors.)
+
+
+
+ For both these functions,
+ the optional weights
+ argument offers the ability to weigh word instances more or less
+ heavily depending on how they are labeled. The weight arrays specify
+ how heavily to weigh each category of word, in the order:
+
+
+{D-weight, C-weight, B-weight, A-weight}
+
+
+ If no weights are provided,
+ then these defaults are used:
+
+
+{0.1, 0.2, 0.4, 1.0}
+
+
+ Typically weights are used to mark words from special areas of the
+ document, like the title or an initial abstract, so they can be
+ treated with more or less importance than words in the document body.
+
+ Since a longer document has a greater chance of containing a query term
+ it is reasonable to take into account document size, e.g., a hundred-word
+ document with five instances of a search word is probably more relevant
+ than a thousand-word document with five instances. Both ranking functions
+ take an integer normalization option that
+ specifies whether and how a document's length should impact its rank.
+ The integer option controls several behaviors, so it is a bit mask:
+ you can specify one or more behaviors using
+ | (for example, 2|4).
+
+
+ 0 (the default) ignores the document length
+
+ 1 divides the rank by 1 + the logarithm of the document length
+
+ 2 divides the rank by the document length
+
+ 4 divides the rank by the mean harmonic distance between extents
+ (this is implemented only by ts_rank_cd)
+
+ 8 divides the rank by the number of unique words in document
+
+ 16 divides the rank by 1 + the logarithm of the number
+ of unique words in document
+
+ 32 divides the rank by itself + 1
+
+
+ If more than one flag bit is specified, the transformations are
+ applied in the order listed.
+
+ It is important to note that the ranking functions do not use any global
+ information, so it is impossible to produce a fair normalization to 1% or
+ 100% as sometimes desired. Normalization option 32
+ (rank/(rank+1)) can be applied to scale all ranks
+ into the range zero to one, but of course this is just a cosmetic change;
+ it will not affect the ordering of the search results.
+
+ Here is an example that selects only the ten highest-ranked matches:
+
+
+SELECT title, ts_rank_cd(textsearch, query) AS rank
+FROM apod, to_tsquery('neutrino|(dark & matter)') query
+WHERE query @@ textsearch
+ORDER BY rank DESC
+LIMIT 10;
+ title | rank
+-----------------------------------------------+----------
+ Neutrinos in the Sun | 3.1
+ The Sudbury Neutrino Detector | 2.4
+ A MACHO View of Galactic Dark Matter | 2.01317
+ Hot Gas and Dark Matter | 1.91171
+ The Virgo Cluster: Hot Plasma and Dark Matter | 1.90953
+ Rafting for Solar Neutrinos | 1.9
+ NGC 4650A: Strange Galaxy and Dark Matter | 1.85774
+ Hot Gas and Dark Matter | 1.6123
+ Ice Fishing for Cosmic Neutrinos | 1.6
+ Weak Lensing Distorts the Universe | 0.818218
+
+
+ This is the same example using normalized ranking:
+
+
+SELECT title, ts_rank_cd(textsearch, query, 32 /* rank/(rank+1) */ ) AS rank
+FROM apod, to_tsquery('neutrino|(dark & matter)') query
+WHERE query @@ textsearch
+ORDER BY rank DESC
+LIMIT 10;
+ title | rank
+-----------------------------------------------+-------------------
+ Neutrinos in the Sun | 0.756097569485493
+ The Sudbury Neutrino Detector | 0.705882361190954
+ A MACHO View of Galactic Dark Matter | 0.668123210574724
+ Hot Gas and Dark Matter | 0.65655958650282
+ The Virgo Cluster: Hot Plasma and Dark Matter | 0.656301290640973
+ Rafting for Solar Neutrinos | 0.655172410958162
+ NGC 4650A: Strange Galaxy and Dark Matter | 0.650072921219637
+ Hot Gas and Dark Matter | 0.617195790024749
+ Ice Fishing for Cosmic Neutrinos | 0.615384618911517
+ Weak Lensing Distorts the Universe | 0.450010798361481
+
+
+ Ranking can be expensive since it requires consulting the
+ tsvector of each matching document, which can be I/O bound and
+ therefore slow. Unfortunately, it is almost impossible to avoid since
+ practical queries often result in large numbers of matches.
+
12.3.4. Highlighting Results #
+ To present search results it is ideal to show a part of each document and
+ how it is related to the query. Usually, search engines show fragments of
+ the document with marked search terms. PostgreSQL
+ provides a function ts_headline that
+ implements this functionality.
+
+ts_headline([ config regconfig, ] document text, query tsquery [, options text ]) returns text
+
+ ts_headline accepts a document along
+ with a query, and returns an excerpt from
+ the document in which terms from the query are highlighted.
+ Specifically, the function will use the query to select relevant
+ text fragments, and then highlight all words that appear in the query,
+ even if those word positions do not match the query's restrictions. The
+ configuration to be used to parse the document can be specified by
+ config; if config
+ is omitted, the
+ default_text_search_config configuration is used.
+
+ If an options string is specified it must
+ consist of a comma-separated list of one or more
+ option=value pairs.
+ The available options are:
+
+
+ MaxWords, MinWords (integers):
+ these numbers determine the longest and shortest headlines to output.
+ The default values are 35 and 15.
+
+ ShortWord (integer): words of this length or less
+ will be dropped at the start and end of a headline, unless they are
+ query terms. The default value of three eliminates common English
+ articles.
+
+ HighlightAll (boolean): if
+ true the whole document will be used as the
+ headline, ignoring the preceding three parameters. The default
+ is false.
+
+ MaxFragments (integer): maximum number of text
+ fragments to display. The default value of zero selects a
+ non-fragment-based headline generation method. A value greater
+ than zero selects fragment-based headline generation (see below).
+
+ StartSel, StopSel (strings):
+ the strings with which to delimit query words appearing in the
+ document, to distinguish them from other excerpted words. The
+ default values are “<b>” and
+ “</b>”, which can be suitable
+ for HTML output.
+
+ FragmentDelimiter (string): When more than one
+ fragment is displayed, the fragments will be separated by this string.
+ The default is “ ... ”.
+
+
+ These option names are recognized case-insensitively.
+ You must double-quote string values if they contain spaces or commas.
+
+ In non-fragment-based headline
+ generation, ts_headline locates matches for the
+ given query and chooses a
+ single one to display, preferring matches that have more query words
+ within the allowed headline length.
+ In fragment-based headline generation, ts_headline
+ locates the query matches and splits each match
+ into “fragments” of no more than MaxWords
+ words each, preferring fragments with more query words, and when
+ possible “stretching” fragments to include surrounding
+ words. The fragment-based mode is thus more useful when the query
+ matches span large sections of the document, or when it's desirable to
+ display multiple matches.
+ In either mode, if no query matches can be identified, then a single
+ fragment of the first MinWords words in the document
+ will be displayed.
+
+ For example:
+
+
+SELECT ts_headline('english',
+ 'The most common type of search
+is to find all documents containing given query terms
+and return them in order of their similarity to the
+query.',
+ to_tsquery('english', 'query & similarity'));
+ ts_headline
+------------------------------------------------------------
+ containing given <b>query</b> terms +
+ and return them in order of their <b>similarity</b> to the+
+ <b>query</b>.
+
+SELECT ts_headline('english',
+ 'Search terms may occur
+many times in a document,
+requiring ranking of the search matches to decide which
+occurrences to display in the result.',
+ to_tsquery('english', 'search & term'),
+ 'MaxFragments=10, MaxWords=7, MinWords=3, StartSel=<<, StopSel=>>');
+ ts_headline
+------------------------------------------------------------
+ <<Search>> <<terms>> may occur +
+ many times ... ranking of the <<search>> matches to decide
+
+
+ ts_headline uses the original document, not a
+ tsvector summary, so it can be slow and should be used with
+ care.
+
12.8. Testing and Debugging Text Search #
+ The behavior of a custom text search configuration can easily become
+ confusing. The functions described
+ in this section are useful for testing text search objects. You can
+ test a complete configuration, or test parsers and dictionaries separately.
+
12.8.1. Configuration Testing #
+ The function ts_debug allows easy testing of a
+ text search configuration.
+
+ts_debug([ config regconfig, ] document text,
+ OUT alias text,
+ OUT description text,
+ OUT token text,
+ OUT dictionaries regdictionary[],
+ OUT dictionary regdictionary,
+ OUT lexemes text[])
+ returns setof record
+
+ ts_debug displays information about every token of
+ document as produced by the
+ parser and processed by the configured dictionaries. It uses the
+ configuration specified by config,
+ or default_text_search_config if that argument is
+ omitted.
+
+ ts_debug returns one row for each token identified in the text
+ by the parser. The columns returned are
+
+
+ alias text — short name of the token type
+
+ description text — description of the
+ token type
+
+ token text — text of the token
+
+ dictionaries regdictionary[] — the
+ dictionaries selected by the configuration for this token type
+
+ dictionary regdictionary — the dictionary
+ that recognized the token, or NULL if none did
+
+ lexemes text[] — the lexeme(s) produced
+ by the dictionary that recognized the token, or NULL if
+ none did; an empty array ({}) means it was recognized as a
+ stop word
+
+
+ Here is a simple example:
+
+
+SELECT * FROM ts_debug('english', 'a fat cat sat on a mat - it ate a fat rats');
+ alias | description | token | dictionaries | dictionary | lexemes
+-----------+-----------------+-------+----------------+--------------+---------
+ asciiword | Word, all ASCII | a | {english_stem} | english_stem | {}
+ blank | Space symbols | | {} | |
+ asciiword | Word, all ASCII | fat | {english_stem} | english_stem | {fat}
+ blank | Space symbols | | {} | |
+ asciiword | Word, all ASCII | cat | {english_stem} | english_stem | {cat}
+ blank | Space symbols | | {} | |
+ asciiword | Word, all ASCII | sat | {english_stem} | english_stem | {sat}
+ blank | Space symbols | | {} | |
+ asciiword | Word, all ASCII | on | {english_stem} | english_stem | {}
+ blank | Space symbols | | {} | |
+ asciiword | Word, all ASCII | a | {english_stem} | english_stem | {}
+ blank | Space symbols | | {} | |
+ asciiword | Word, all ASCII | mat | {english_stem} | english_stem | {mat}
+ blank | Space symbols | | {} | |
+ blank | Space symbols | - | {} | |
+ asciiword | Word, all ASCII | it | {english_stem} | english_stem | {}
+ blank | Space symbols | | {} | |
+ asciiword | Word, all ASCII | ate | {english_stem} | english_stem | {ate}
+ blank | Space symbols | | {} | |
+ asciiword | Word, all ASCII | a | {english_stem} | english_stem | {}
+ blank | Space symbols | | {} | |
+ asciiword | Word, all ASCII | fat | {english_stem} | english_stem | {fat}
+ blank | Space symbols | | {} | |
+ asciiword | Word, all ASCII | rats | {english_stem} | english_stem | {rat}
+
+
+ For a more extensive demonstration, we
+ first create a public.english configuration and
+ Ispell dictionary for the English language:
+
+CREATE TEXT SEARCH CONFIGURATION public.english ( COPY = pg_catalog.english );
+
+CREATE TEXT SEARCH DICTIONARY english_ispell (
+ TEMPLATE = ispell,
+ DictFile = english,
+ AffFile = english,
+ StopWords = english
+);
+
+ALTER TEXT SEARCH CONFIGURATION public.english
+ ALTER MAPPING FOR asciiword WITH english_ispell, english_stem;
+
+SELECT * FROM ts_debug('public.english', 'The Brightest supernovaes');
+ alias | description | token | dictionaries | dictionary | lexemes
+-----------+-----------------+-------------+-------------------------------+----------------+-------------
+ asciiword | Word, all ASCII | The | {english_ispell,english_stem} | english_ispell | {}
+ blank | Space symbols | | {} | |
+ asciiword | Word, all ASCII | Brightest | {english_ispell,english_stem} | english_ispell | {bright}
+ blank | Space symbols | | {} | |
+ asciiword | Word, all ASCII | supernovaes | {english_ispell,english_stem} | english_stem | {supernova}
+
+ In this example, the word Brightest was recognized by the
+ parser as an ASCII word (alias asciiword).
+ For this token type the dictionary list is
+ english_ispell and
+ english_stem. The word was recognized by
+ english_ispell, which reduced it to the noun
+ bright. The word supernovaes is
+ unknown to the english_ispell dictionary so it
+ was passed to the next dictionary, and, fortunately, was recognized (in
+ fact, english_stem is a Snowball dictionary which
+ recognizes everything; that is why it was placed at the end of the
+ dictionary list).
+
+ The word The was recognized by the
+ english_ispell dictionary as a stop word (Section 12.6.1) and will not be indexed.
+ The spaces are discarded too, since the configuration provides no
+ dictionaries at all for them.
+
+ You can reduce the width of the output by explicitly specifying which columns
+ you want to see:
+
+
+SELECT alias, token, dictionary, lexemes
+FROM ts_debug('public.english', 'The Brightest supernovaes');
+ alias | token | dictionary | lexemes
+-----------+-------------+----------------+-------------
+ asciiword | The | english_ispell | {}
+ blank | | |
+ asciiword | Brightest | english_ispell | {bright}
+ blank | | |
+ asciiword | supernovaes | english_stem | {supernova}
+
+
+ The following functions allow direct testing of a text search parser.
+
+ts_parse(parser_name text, document text,
+ OUT tokid integer, OUT token text) returns setof record
+ts_parse(parser_oid oid, document text,
+ OUT tokid integer, OUT token text) returns setof record
+
+ ts_parse parses the given document
+ and returns a series of records, one for each token produced by
+ parsing. Each record includes a tokid showing the
+ assigned token type and a token which is the text of the
+ token. For example:
+
+
+SELECT * FROM ts_parse('default', '123 - a number');
+ tokid | token
+-------+--------
+ 22 | 123
+ 12 |
+ 12 | -
+ 1 | a
+ 12 |
+ 1 | number
+
+
+ts_token_type(parser_name text, OUT tokid integer,
+ OUT alias text, OUT description text) returns setof record
+ts_token_type(parser_oid oid, OUT tokid integer,
+ OUT alias text, OUT description text) returns setof record
+
+ ts_token_type returns a table which describes each type of
+ token the specified parser can recognize. For each token type, the table
+ gives the integer tokid that the parser uses to label a
+ token of that type, the alias that names the token type
+ in configuration commands, and a short description. For
+ example:
+
+
+SELECT * FROM ts_token_type('default');
+ tokid | alias | description
+-------+-----------------+------------------------------------------
+ 1 | asciiword | Word, all ASCII
+ 2 | word | Word, all letters
+ 3 | numword | Word, letters and digits
+ 4 | email | Email address
+ 5 | url | URL
+ 6 | host | Host
+ 7 | sfloat | Scientific notation
+ 8 | version | Version number
+ 9 | hword_numpart | Hyphenated word part, letters and digits
+ 10 | hword_part | Hyphenated word part, all letters
+ 11 | hword_asciipart | Hyphenated word part, all ASCII
+ 12 | blank | Space symbols
+ 13 | tag | XML tag
+ 14 | protocol | Protocol head
+ 15 | numhword | Hyphenated word, letters and digits
+ 16 | asciihword | Hyphenated word, all ASCII
+ 17 | hword | Hyphenated word, all letters
+ 18 | url_path | URL path
+ 19 | file | File or path name
+ 20 | float | Decimal notation
+ 21 | int | Signed integer
+ 22 | uint | Unsigned integer
+ 23 | entity | XML entity
+
+
12.8.3. Dictionary Testing #
+ The ts_lexize function facilitates dictionary testing.
+
+ts_lexize(dict regdictionary, token text) returns text[]
+
+ ts_lexize returns an array of lexemes if the input
+ token is known to the dictionary,
+ or an empty array if the token
+ is known to the dictionary but it is a stop word, or
+ NULL if it is an unknown word.
+
+ Examples:
+
+
+SELECT ts_lexize('english_stem', 'stars');
+ ts_lexize
+-----------
+ {star}
+
+SELECT ts_lexize('english_stem', 'a');
+ ts_lexize
+-----------
+ {}
+
+
Note
+ The ts_lexize function expects a single
+ token, not text. Here is a case
+ where this can be confusing:
+
+
+SELECT ts_lexize('thesaurus_astro', 'supernovae stars') is null;
+ ?column?
+----------
+ t
+
+
+ The thesaurus dictionary thesaurus_astro does know the
+ phrase supernovae stars, but ts_lexize
+ fails since it does not parse the input text but treats it as a single
+ token. Use plainto_tsquery or to_tsvector to
+ test thesaurus dictionaries, for example:
+
+
+SELECT plainto_tsquery('supernovae stars');
+ plainto_tsquery
+-----------------
+ 'sn'
+
+
+ Dictionaries are used to eliminate words that should not be considered in a
+ search (stop words), and to normalize words so
+ that different derived forms of the same word will match. A successfully
+ normalized word is called a lexeme. Aside from
+ improving search quality, normalization and removal of stop words reduce the
+ size of the tsvector representation of a document, thereby
+ improving performance. Normalization does not always have linguistic meaning
+ and usually depends on application semantics.
+
+ Some examples of normalization:
+
+
+ Linguistic — Ispell dictionaries try to reduce input words to a
+ normalized form; stemmer dictionaries remove word endings
+
+ URL locations can be canonicalized to make
+ equivalent URLs match:
+
+
+ http://www.pgsql.ru/db/mw/index.html
+
+ http://www.pgsql.ru/db/mw/
+
+ http://www.pgsql.ru/db/../db/mw/index.html
+
+
+ Color names can be replaced by their hexadecimal values, e.g.,
+ red, green, blue, magenta -> FF0000, 00FF00, 0000FF, FF00FF
+
+ If indexing numbers, we can
+ remove some fractional digits to reduce the range of possible
+ numbers, so for example 3.14159265359,
+ 3.1415926, 3.14 will be the same
+ after normalization if only two digits are kept after the decimal point.
+
+
+
+ A dictionary is a program that accepts a token as
+ input and returns:
+
+ an array of lexemes if the input token is known to the dictionary
+ (notice that one token can produce more than one lexeme)
+
+ a single lexeme with the TSL_FILTER flag set, to replace
+ the original token with a new token to be passed to subsequent
+ dictionaries (a dictionary that does this is called a
+ filtering dictionary)
+
+ an empty array if the dictionary knows the token, but it is a stop word
+
+ NULL if the dictionary does not recognize the input token
+
+
+ PostgreSQL provides predefined dictionaries for
+ many languages. There are also several predefined templates that can be
+ used to create new dictionaries with custom parameters. Each predefined
+ dictionary template is described below. If no existing
+ template is suitable, it is possible to create new ones; see the
+ contrib/ area of the PostgreSQL distribution
+ for examples.
+
+ A text search configuration binds a parser together with a set of
+ dictionaries to process the parser's output tokens. For each token
+ type that the parser can return, a separate list of dictionaries is
+ specified by the configuration. When a token of that type is found
+ by the parser, each dictionary in the list is consulted in turn,
+ until some dictionary recognizes it as a known word. If it is identified
+ as a stop word, or if no dictionary recognizes the token, it will be
+ discarded and not indexed or searched for.
+ Normally, the first dictionary that returns a non-NULL
+ output determines the result, and any remaining dictionaries are not
+ consulted; but a filtering dictionary can replace the given word
+ with a modified word, which is then passed to subsequent dictionaries.
+
+ The general rule for configuring a list of dictionaries
+ is to place first the most narrow, most specific dictionary, then the more
+ general dictionaries, finishing with a very general dictionary, like
+ a Snowball stemmer or simple, which
+ recognizes everything. For example, for an astronomy-specific search
+ (astro_en configuration) one could bind token type
+ asciiword (ASCII word) to a synonym dictionary of astronomical
+ terms, a general English dictionary and a Snowball English
+ stemmer:
+
+
+ALTER TEXT SEARCH CONFIGURATION astro_en
+ ADD MAPPING FOR asciiword WITH astrosyn, english_ispell, english_stem;
+
+
+ A filtering dictionary can be placed anywhere in the list, except at the
+ end where it'd be useless. Filtering dictionaries are useful to partially
+ normalize words to simplify the task of later dictionaries. For example,
+ a filtering dictionary could be used to remove accents from accented
+ letters, as is done by the unaccent module.
+
+ Stop words are words that are very common, appear in almost every
+ document, and have no discrimination value. Therefore, they can be ignored
+ in the context of full text searching. For example, every English text
+ contains words like a and the, so it is
+ useless to store them in an index. However, stop words do affect the
+ positions in tsvector, which in turn affect ranking:
+
+
+SELECT to_tsvector('english', 'in the list of stop words');
+ to_tsvector
+----------------------------
+ 'list':3 'stop':5 'word':6
+
+
+ The missing positions 1,2,4 are because of stop words. Ranks
+ calculated for documents with and without stop words are quite different:
+
+
+SELECT ts_rank_cd (to_tsvector('english', 'in the list of stop words'), to_tsquery('list & stop'));
+ ts_rank_cd
+------------
+ 0.05
+
+SELECT ts_rank_cd (to_tsvector('english', 'list stop words'), to_tsquery('list & stop'));
+ ts_rank_cd
+------------
+ 0.1
+
+
+
+ It is up to the specific dictionary how it treats stop words. For example,
+ ispell dictionaries first normalize words and then
+ look at the list of stop words, while Snowball stemmers
+ first check the list of stop words. The reason for the different
+ behavior is an attempt to decrease noise.
+
12.6.2. Simple Dictionary #
+ The simple dictionary template operates by converting the
+ input token to lower case and checking it against a file of stop words.
+ If it is found in the file then an empty array is returned, causing
+ the token to be discarded. If not, the lower-cased form of the word
+ is returned as the normalized lexeme. Alternatively, the dictionary
+ can be configured to report non-stop-words as unrecognized, allowing
+ them to be passed on to the next dictionary in the list.
+
+ Here is an example of a dictionary definition using the simple
+ template:
+
+
+CREATE TEXT SEARCH DICTIONARY public.simple_dict (
+ TEMPLATE = pg_catalog.simple,
+ STOPWORDS = english
+);
+
+
+ Here, english is the base name of a file of stop words.
+ The file's full name will be
+ $SHAREDIR/tsearch_data/english.stop,
+ where $SHAREDIR means the
+ PostgreSQL installation's shared-data directory,
+ often /usr/local/share/postgresql (use pg_config
+ --sharedir to determine it if you're not sure).
+ The file format is simply a list
+ of words, one per line. Blank lines and trailing spaces are ignored,
+ and upper case is folded to lower case, but no other processing is done
+ on the file contents.
+
+ Now we can test our dictionary:
+
+
+SELECT ts_lexize('public.simple_dict', 'YeS');
+ ts_lexize
+-----------
+ {yes}
+
+SELECT ts_lexize('public.simple_dict', 'The');
+ ts_lexize
+-----------
+ {}
+
+
+ We can also choose to return NULL, instead of the lower-cased
+ word, if it is not found in the stop words file. This behavior is
+ selected by setting the dictionary's Accept parameter to
+ false. Continuing the example:
+
+
+ALTER TEXT SEARCH DICTIONARY public.simple_dict ( Accept = false );
+
+SELECT ts_lexize('public.simple_dict', 'YeS');
+ ts_lexize
+-----------
+
+
+SELECT ts_lexize('public.simple_dict', 'The');
+ ts_lexize
+-----------
+ {}
+
+
+ With the default setting of Accept = true,
+ it is only useful to place a simple dictionary at the end
+ of a list of dictionaries, since it will never pass on any token to
+ a following dictionary. Conversely, Accept = false
+ is only useful when there is at least one following dictionary.
+
Caution
+ Most types of dictionaries rely on configuration files, such as files of
+ stop words. These files must be stored in UTF-8 encoding.
+ They will be translated to the actual database encoding, if that is
+ different, when they are read into the server.
+
Caution
+ Normally, a database session will read a dictionary configuration file
+ only once, when it is first used within the session. If you modify a
+ configuration file and want to force existing sessions to pick up the
+ new contents, issue an ALTER TEXT SEARCH DICTIONARY command
+ on the dictionary. This can be a “dummy” update that doesn't
+ actually change any parameter values.
+
12.6.3. Synonym Dictionary #
+ This dictionary template is used to create dictionaries that replace a
+ word with a synonym. Phrases are not supported (use the thesaurus
+ template (Section 12.6.4) for that). A synonym
+ dictionary can be used to overcome linguistic problems, for example, to
+ prevent an English stemmer dictionary from reducing the word “Paris” to
+ “pari”. It is enough to have a Paris paris line in the
+ synonym dictionary and put it before the english_stem
+ dictionary. For example:
+
+
+SELECT * FROM ts_debug('english', 'Paris');
+ alias | description | token | dictionaries | dictionary | lexemes
+-----------+-----------------+-------+----------------+--------------+---------
+ asciiword | Word, all ASCII | Paris | {english_stem} | english_stem | {pari}
+
+CREATE TEXT SEARCH DICTIONARY my_synonym (
+ TEMPLATE = synonym,
+ SYNONYMS = my_synonyms
+);
+
+ALTER TEXT SEARCH CONFIGURATION english
+ ALTER MAPPING FOR asciiword
+ WITH my_synonym, english_stem;
+
+SELECT * FROM ts_debug('english', 'Paris');
+ alias | description | token | dictionaries | dictionary | lexemes
+-----------+-----------------+-------+---------------------------+------------+---------
+ asciiword | Word, all ASCII | Paris | {my_synonym,english_stem} | my_synonym | {paris}
+
+
+ The only parameter required by the synonym template is
+ SYNONYMS, which is the base name of its configuration file
+ — my_synonyms in the above example.
+ The file's full name will be
+ $SHAREDIR/tsearch_data/my_synonyms.syn
+ (where $SHAREDIR means the
+ PostgreSQL installation's shared-data directory).
+ The file format is just one line
+ per word to be substituted, with the word followed by its synonym,
+ separated by white space. Blank lines and trailing spaces are ignored.
+
+ The synonym template also has an optional parameter
+ CaseSensitive, which defaults to false. When
+ CaseSensitive is false, words in the synonym file
+ are folded to lower case, as are input tokens. When it is
+ true, words and tokens are not folded to lower case,
+ but are compared as-is.
+
+ An asterisk (*) can be placed at the end of a synonym
+ in the configuration file. This indicates that the synonym is a prefix.
+ The asterisk is ignored when the entry is used in
+ to_tsvector(), but when it is used in
+ to_tsquery(), the result will be a query item with
+ the prefix match marker (see
+ Section 12.3.2).
+ For example, suppose we have these entries in
+ $SHAREDIR/tsearch_data/synonym_sample.syn:
+
+postgres pgsql
+postgresql pgsql
+postgre pgsql
+gogle googl
+indices index*
+
+ Then we will get these results:
+
+mydb=# CREATE TEXT SEARCH DICTIONARY syn (template=synonym, synonyms='synonym_sample');
+mydb=# SELECT ts_lexize('syn', 'indices');
+ ts_lexize
+-----------
+ {index}
+(1 row)
+
+mydb=# CREATE TEXT SEARCH CONFIGURATION tst (copy=simple);
+mydb=# ALTER TEXT SEARCH CONFIGURATION tst ALTER MAPPING FOR asciiword WITH syn;
+mydb=# SELECT to_tsvector('tst', 'indices');
+ to_tsvector
+-------------
+ 'index':1
+(1 row)
+
+mydb=# SELECT to_tsquery('tst', 'indices');
+ to_tsquery
+------------
+ 'index':*
+(1 row)
+
+mydb=# SELECT 'indexes are very useful'::tsvector;
+ tsvector
+---------------------------------
+ 'are' 'indexes' 'useful' 'very'
+(1 row)
+
+mydb=# SELECT 'indexes are very useful'::tsvector @@ to_tsquery('tst', 'indices');
+ ?column?
+----------
+ t
+(1 row)
+
+
12.6.4. Thesaurus Dictionary #
+ A thesaurus dictionary (sometimes abbreviated as TZ) is
+ a collection of words that includes information about the relationships
+ of words and phrases, i.e., broader terms (BT), narrower
+ terms (NT), preferred terms, non-preferred terms, related
+ terms, etc.
+
+ Basically a thesaurus dictionary replaces all non-preferred terms by one
+ preferred term and, optionally, preserves the original terms for indexing
+ as well. PostgreSQL's current implementation of the
+ thesaurus dictionary is an extension of the synonym dictionary with added
+ phrase support. A thesaurus dictionary requires
+ a configuration file of the following format:
+
+
+# this is a comment
+sample word(s) : indexed word(s)
+more sample word(s) : more indexed word(s)
+...
+
+
+ where the colon (:) symbol acts as a delimiter between a
+ phrase and its replacement.
+
+ A thesaurus dictionary uses a subdictionary (which
+ is specified in the dictionary's configuration) to normalize the input
+ text before checking for phrase matches. It is only possible to select one
+ subdictionary. An error is reported if the subdictionary fails to
+ recognize a word. In that case, you should remove the use of the word or
+ teach the subdictionary about it. You can place an asterisk
+ (*) at the beginning of an indexed word to skip applying
+ the subdictionary to it, but all sample words must be known
+ to the subdictionary.
+
+ The thesaurus dictionary chooses the longest match if there are multiple
+ phrases matching the input, and ties are broken by using the last
+ definition.
+
+ Specific stop words recognized by the subdictionary cannot be
+ specified; instead use ? to mark the location where any
+ stop word can appear. For example, assuming that a and
+ the are stop words according to the subdictionary:
+
+
+? one ? two : swsw
+
+
+ matches a one the two and the one a two;
+ both would be replaced by swsw.
+
+ Since a thesaurus dictionary has the capability to recognize phrases it
+ must remember its state and interact with the parser. A thesaurus dictionary
+ uses these assignments to check if it should handle the next word or stop
+ accumulation. The thesaurus dictionary must be configured
+ carefully. For example, if the thesaurus dictionary is assigned to handle
+ only the asciiword token, then a thesaurus dictionary
+ definition like one 7 will not work since token type
+ uint is not assigned to the thesaurus dictionary.
+
Caution
+ Thesauruses are used during indexing so any change in the thesaurus
+ dictionary's parameters requires reindexing.
+ For most other dictionary types, small changes such as adding or
+ removing stopwords does not force reindexing.
+
12.6.4.1. Thesaurus Configuration #
+ To define a new thesaurus dictionary, use the thesaurus
+ template. For example:
+
+
+CREATE TEXT SEARCH DICTIONARY thesaurus_simple (
+ TEMPLATE = thesaurus,
+ DictFile = mythesaurus,
+ Dictionary = pg_catalog.english_stem
+);
+
+
+ Here:
+
+ thesaurus_simple is the new dictionary's name
+
+ mythesaurus is the base name of the thesaurus
+ configuration file.
+ (Its full name will be $SHAREDIR/tsearch_data/mythesaurus.ths,
+ where $SHAREDIR means the installation shared-data
+ directory.)
+
+ pg_catalog.english_stem is the subdictionary (here,
+ a Snowball English stemmer) to use for thesaurus normalization.
+ Notice that the subdictionary will have its own
+ configuration (for example, stop words), which is not shown here.
+
+
+ Now it is possible to bind the thesaurus dictionary thesaurus_simple
+ to the desired token types in a configuration, for example:
+
+
+ALTER TEXT SEARCH CONFIGURATION russian
+ ALTER MAPPING FOR asciiword, asciihword, hword_asciipart
+ WITH thesaurus_simple;
+
+
12.6.4.2. Thesaurus Example #
+ Consider a simple astronomical thesaurus thesaurus_astro,
+ which contains some astronomical word combinations:
+
+
+supernovae stars : sn
+crab nebulae : crab
+
+
+ Below we create a dictionary and bind some token types to
+ an astronomical thesaurus and English stemmer:
+
+
+CREATE TEXT SEARCH DICTIONARY thesaurus_astro (
+ TEMPLATE = thesaurus,
+ DictFile = thesaurus_astro,
+ Dictionary = english_stem
+);
+
+ALTER TEXT SEARCH CONFIGURATION russian
+ ALTER MAPPING FOR asciiword, asciihword, hword_asciipart
+ WITH thesaurus_astro, english_stem;
+
+
+ Now we can see how it works.
+ ts_lexize is not very useful for testing a thesaurus,
+ because it treats its input as a single token. Instead we can use
+ plainto_tsquery and to_tsvector
+ which will break their input strings into multiple tokens:
+
+
+SELECT plainto_tsquery('supernova star');
+ plainto_tsquery
+-----------------
+ 'sn'
+
+SELECT to_tsvector('supernova star');
+ to_tsvector
+-------------
+ 'sn':1
+
+
+ In principle, one can use to_tsquery if you quote
+ the argument:
+
+
+SELECT to_tsquery('''supernova star''');
+ to_tsquery
+------------
+ 'sn'
+
+
+ Notice that supernova star matches supernovae
+ stars in thesaurus_astro because we specified
+ the english_stem stemmer in the thesaurus definition.
+ The stemmer removed the e and s.
+
+ To index the original phrase as well as the substitute, just include it
+ in the right-hand part of the definition:
+
+
+supernovae stars : sn supernovae stars
+
+SELECT plainto_tsquery('supernova star');
+ plainto_tsquery
+-----------------------------
+ 'sn' & 'supernova' & 'star'
+
+
12.6.5. Ispell Dictionary #
+ The Ispell dictionary template supports
+ morphological dictionaries, which can normalize many
+ different linguistic forms of a word into the same lexeme. For example,
+ an English Ispell dictionary can match all declensions and
+ conjugations of the search term bank, e.g.,
+ banking, banked, banks,
+ banks', and bank's.
+
+ The standard PostgreSQL distribution does
+ not include any Ispell configuration files.
+ Dictionaries for a large number of languages are available from Ispell.
+ Also, some more modern dictionary file formats are supported — MySpell (OO < 2.0.1)
+ and Hunspell
+ (OO >= 2.0.2). A large list of dictionaries is available on the OpenOffice
+ Wiki.
+
+ To create an Ispell dictionary perform these steps:
+
+ download dictionary configuration files. OpenOffice
+ extension files have the .oxt extension. It is necessary
+ to extract .aff and .dic files, change
+ extensions to .affix and .dict. For some
+ dictionary files it is also needed to convert characters to the UTF-8
+ encoding with commands (for example, for a Norwegian language dictionary):
+
+iconv -f ISO_8859-1 -t UTF-8 -o nn_no.affix nn_NO.aff
+iconv -f ISO_8859-1 -t UTF-8 -o nn_no.dict nn_NO.dic
+
+
+ copy files to the $SHAREDIR/tsearch_data directory
+
+ load files into PostgreSQL with the following command:
+
+CREATE TEXT SEARCH DICTIONARY english_hunspell (
+ TEMPLATE = ispell,
+ DictFile = en_us,
+ AffFile = en_us,
+ Stopwords = english);
+
+
+ Here, DictFile, AffFile, and StopWords
+ specify the base names of the dictionary, affixes, and stop-words files.
+ The stop-words file has the same format explained above for the
+ simple dictionary type. The format of the other files is
+ not specified here but is available from the above-mentioned web sites.
+
+ Ispell dictionaries usually recognize a limited set of words, so they
+ should be followed by another broader dictionary; for
+ example, a Snowball dictionary, which recognizes everything.
+
+ The .affix file of Ispell has the following
+ structure:
+
+prefixes
+flag *A:
+ . > RE # As in enter > reenter
+suffixes
+flag T:
+ E > ST # As in late > latest
+ [^AEIOU]Y > -Y,IEST # As in dirty > dirtiest
+ [AEIOU]Y > EST # As in gray > grayest
+ [^EY] > EST # As in small > smallest
+
+
+ And the .dict file has the following structure:
+
+lapse/ADGRS
+lard/DGRS
+large/PRTY
+lark/MRS
+
+
+ Format of the .dict file is:
+
+basic_form/affix_class_name
+
+
+ In the .affix file every affix flag is described in the
+ following format:
+
+condition > [-stripping_letters,] adding_affix
+
+
+ Here, condition has a format similar to the format of regular expressions.
+ It can use groupings [...] and [^...].
+ For example, [AEIOU]Y means that the last letter of the word
+ is "y" and the penultimate letter is "a",
+ "e", "i", "o" or "u".
+ [^EY] means that the last letter is neither "e"
+ nor "y".
+
+ Ispell dictionaries support splitting compound words;
+ a useful feature.
+ Notice that the affix file should specify a special flag using the
+ compoundwords controlled statement that marks dictionary
+ words that can participate in compound formation:
+
+
+compoundwords controlled z
+
+
+ Here are some examples for the Norwegian language:
+
+
+SELECT ts_lexize('norwegian_ispell', 'overbuljongterningpakkmesterassistent');
+ {over,buljong,terning,pakk,mester,assistent}
+SELECT ts_lexize('norwegian_ispell', 'sjokoladefabrikk');
+ {sjokoladefabrikk,sjokolade,fabrikk}
+
+
+ MySpell format is a subset of Hunspell.
+ The .affix file of Hunspell has the following
+ structure:
+
+PFX A Y 1
+PFX A 0 re .
+SFX T N 4
+SFX T 0 st e
+SFX T y iest [^aeiou]y
+SFX T 0 est [aeiou]y
+SFX T 0 est [^ey]
+
+
+ The first line of an affix class is the header. Fields of an affix rules are
+ listed after the header:
+
+ parameter name (PFX or SFX)
+
+ flag (name of the affix class)
+
+ stripping characters from beginning (at prefix) or end (at suffix) of the
+ word
+
+ adding affix
+
+ condition that has a format similar to the format of regular expressions.
+
+ The .dict file looks like the .dict file of
+ Ispell:
+
+larder/M
+lardy/RT
+large/RSPMYT
+largehearted
+
+
Note
+ MySpell does not support compound words.
+ Hunspell has sophisticated support for compound words. At
+ present, PostgreSQL implements only the basic
+ compound word operations of Hunspell.
+
12.6.6. Snowball Dictionary #
+ The Snowball dictionary template is based on a project
+ by Martin Porter, inventor of the popular Porter's stemming algorithm
+ for the English language. Snowball now provides stemming algorithms for
+ many languages (see the Snowball
+ site for more information). Each algorithm understands how to
+ reduce common variant forms of words to a base, or stem, spelling within
+ its language. A Snowball dictionary requires a language
+ parameter to identify which stemmer to use, and optionally can specify a
+ stopword file name that gives a list of words to eliminate.
+ (PostgreSQL's standard stopword lists are also
+ provided by the Snowball project.)
+ For example, there is a built-in definition equivalent to
+
+
+CREATE TEXT SEARCH DICTIONARY english_stem (
+ TEMPLATE = snowball,
+ Language = english,
+ StopWords = english
+);
+
+
+ The stopword file format is the same as already explained.
+
+ A Snowball dictionary recognizes everything, whether
+ or not it is able to simplify the word, so it should be placed
+ at the end of the dictionary list. It is useless to have it
+ before any other dictionary because a token will never pass through it to
+ the next dictionary.
+
12.4. Additional Features #
+ This section describes additional functions and operators that are
+ useful in connection with text search.
+
12.4.1. Manipulating Documents #
+ Section 12.3.1 showed how raw textual
+ documents can be converted into tsvector values.
+ PostgreSQL also provides functions and
+ operators that can be used to manipulate documents that are already
+ in tsvector form.
+
-
+
+
+
tsvector || tsvector
+ The tsvector concatenation operator
+ returns a vector which combines the lexemes and positional information
+ of the two vectors given as arguments. Positions and weight labels
+ are retained during the concatenation.
+ Positions appearing in the right-hand vector are offset by the largest
+ position mentioned in the left-hand vector, so that the result is
+ nearly equivalent to the result of performing to_tsvector
+ on the concatenation of the two original document strings. (The
+ equivalence is not exact, because any stop-words removed from the
+ end of the left-hand argument will not affect the result, whereas
+ they would have affected the positions of the lexemes in the
+ right-hand argument if textual concatenation were used.)
+
+ One advantage of using concatenation in the vector form, rather than
+ concatenating text before applying to_tsvector, is that
+ you can use different configurations to parse different sections
+ of the document. Also, because the setweight function
+ marks all lexemes of the given vector the same way, it is necessary
+ to parse the text and do setweight before concatenating
+ if you want to label different parts of the document with different
+ weights.
+
-
+
+
+
setweight(vector tsvector, weight "char") returns tsvector
+
+ setweight returns a copy of the input vector in which every
+ position has been labeled with the given weight, either
+ A, B, C, or
+ D. (D is the default for new
+ vectors and as such is not displayed on output.) These labels are
+ retained when vectors are concatenated, allowing words from different
+ parts of a document to be weighted differently by ranking functions.
+
+ Note that weight labels apply to positions, not
+ lexemes. If the input vector has been stripped of
+ positions then setweight does nothing.
+
-
+
+
+
length(vector tsvector) returns integer
+
+ Returns the number of lexemes stored in the vector.
+
-
+
+
+
strip(vector tsvector) returns tsvector
+
+ Returns a vector that lists the same lexemes as the given vector, but
+ lacks any position or weight information. The result is usually much
+ smaller than an unstripped vector, but it is also less useful.
+ Relevance ranking does not work as well on stripped vectors as
+ unstripped ones. Also,
+ the <-> (FOLLOWED BY) tsquery operator
+ will never match stripped input, since it cannot determine the
+ distance between lexeme occurrences.
+
+ A full list of tsvector-related functions is available
+ in Table 9.43.
+
12.4.2. Manipulating Queries #
+ Section 12.3.2 showed how raw textual
+ queries can be converted into tsquery values.
+ PostgreSQL also provides functions and
+ operators that can be used to manipulate queries that are already
+ in tsquery form.
+
-
+
tsquery && tsquery
+ Returns the AND-combination of the two given queries.
+
-
+
tsquery || tsquery
+ Returns the OR-combination of the two given queries.
+
-
+
!! tsquery
+
+ Returns the negation (NOT) of the given query.
+
-
+
tsquery <-> tsquery
+ Returns a query that searches for a match to the first given query
+ immediately followed by a match to the second given query, using
+ the <-> (FOLLOWED BY)
+ tsquery operator. For example:
+
+
+SELECT to_tsquery('fat') <-> to_tsquery('cat | rat');
+ ?column?
+----------------------------
+ 'fat' <-> ( 'cat' | 'rat' )
+
+
-
+
+
+
tsquery_phrase(query1 tsquery, query2 tsquery [, distance integer ]) returns tsquery
+
+ Returns a query that searches for a match to the first given query
+ followed by a match to the second given query at a distance of exactly
+ distance lexemes, using
+ the <N>
+ tsquery operator. For example:
+
+
+SELECT tsquery_phrase(to_tsquery('fat'), to_tsquery('cat'), 10);
+ tsquery_phrase
+------------------
+ 'fat' <10> 'cat'
+
+
-
+
+
+
numnode(query tsquery) returns integer
+
+ Returns the number of nodes (lexemes plus operators) in a
+ tsquery. This function is useful
+ to determine if the query is meaningful
+ (returns > 0), or contains only stop words (returns 0).
+ Examples:
+
+
+SELECT numnode(plainto_tsquery('the any'));
+NOTICE: query contains only stopword(s) or doesn't contain lexeme(s), ignored
+ numnode
+---------
+ 0
+
+SELECT numnode('foo & bar'::tsquery);
+ numnode
+---------
+ 3
+
+
-
+
+
+
querytree(query tsquery) returns text
+
+ Returns the portion of a tsquery that can be used for
+ searching an index. This function is useful for detecting
+ unindexable queries, for example those containing only stop words
+ or only negated terms. For example:
+
+
+SELECT querytree(to_tsquery('defined'));
+ querytree
+-----------
+ 'defin'
+
+SELECT querytree(to_tsquery('!defined'));
+ querytree
+-----------
+ T
+
+
12.4.2.1. Query Rewriting #
+ The ts_rewrite family of functions search a
+ given tsquery for occurrences of a target
+ subquery, and replace each occurrence with a
+ substitute subquery. In essence this operation is a
+ tsquery-specific version of substring replacement.
+ A target and substitute combination can be
+ thought of as a query rewrite rule. A collection
+ of such rewrite rules can be a powerful search aid.
+ For example, you can expand the search using synonyms
+ (e.g., new york, big apple, nyc,
+ gotham) or narrow the search to direct the user to some hot
+ topic. There is some overlap in functionality between this feature
+ and thesaurus dictionaries (Section 12.6.4).
+ However, you can modify a set of rewrite rules on-the-fly without
+ reindexing, whereas updating a thesaurus requires reindexing to be
+ effective.
+
-
+
ts_rewrite (query tsquery, target tsquery, substitute tsquery) returns tsquery
+
+ This form of ts_rewrite simply applies a single
+ rewrite rule: target
+ is replaced by substitute
+ wherever it appears in query. For example:
+
+
+SELECT ts_rewrite('a & b'::tsquery, 'a'::tsquery, 'c'::tsquery);
+ ts_rewrite
+------------
+ 'b' & 'c'
+
+
-
+
ts_rewrite (query tsquery, select text) returns tsquery
+
+ This form of ts_rewrite accepts a starting
+ query and an SQL select command, which
+ is given as a text string. The select must yield two
+ columns of tsquery type. For each row of the
+ select result, occurrences of the first column value
+ (the target) are replaced by the second column value (the substitute)
+ within the current query value. For example:
+
+
+CREATE TABLE aliases (t tsquery PRIMARY KEY, s tsquery);
+INSERT INTO aliases VALUES('a', 'c');
+
+SELECT ts_rewrite('a & b'::tsquery, 'SELECT t,s FROM aliases');
+ ts_rewrite
+------------
+ 'b' & 'c'
+
+
+ Note that when multiple rewrite rules are applied in this way,
+ the order of application can be important; so in practice you will
+ want the source query to ORDER BY some ordering key.
+
+ Let's consider a real-life astronomical example. We'll expand query
+ supernovae using table-driven rewriting rules:
+
+
+CREATE TABLE aliases (t tsquery primary key, s tsquery);
+INSERT INTO aliases VALUES(to_tsquery('supernovae'), to_tsquery('supernovae|sn'));
+
+SELECT ts_rewrite(to_tsquery('supernovae & crab'), 'SELECT * FROM aliases');
+ ts_rewrite
+---------------------------------
+ 'crab' & ( 'supernova' | 'sn' )
+
+
+ We can change the rewriting rules just by updating the table:
+
+
+UPDATE aliases
+SET s = to_tsquery('supernovae|sn & !nebulae')
+WHERE t = to_tsquery('supernovae');
+
+SELECT ts_rewrite(to_tsquery('supernovae & crab'), 'SELECT * FROM aliases');
+ ts_rewrite
+---------------------------------------------
+ 'crab' & ( 'supernova' | 'sn' & !'nebula' )
+
+
+ Rewriting can be slow when there are many rewriting rules, since it
+ checks every rule for a possible match. To filter out obvious non-candidate
+ rules we can use the containment operators for the tsquery
+ type. In the example below, we select only those rules which might match
+ the original query:
+
+
+SELECT ts_rewrite('a & b'::tsquery,
+ 'SELECT t,s FROM aliases WHERE ''a & b''::tsquery @> t');
+ ts_rewrite
+------------
+ 'b' & 'c'
+
+
12.4.3. Triggers for Automatic Updates #
Note
+ The method described in this section has been obsoleted by the use of
+ stored generated columns, as described in Section 12.2.2.
+
+ When using a separate column to store the tsvector representation
+ of your documents, it is necessary to create a trigger to update the
+ tsvector column when the document content columns change.
+ Two built-in trigger functions are available for this, or you can write
+ your own.
+
+tsvector_update_trigger(tsvector_column_name, config_name, text_column_name [, ... ])
+tsvector_update_trigger_column(tsvector_column_name, config_column_name, text_column_name [, ... ])
+
+ These trigger functions automatically compute a tsvector
+ column from one or more textual columns, under the control of
+ parameters specified in the CREATE TRIGGER command.
+ An example of their use is:
+
+
+CREATE TABLE messages (
+ title text,
+ body text,
+ tsv tsvector
+);
+
+CREATE TRIGGER tsvectorupdate BEFORE INSERT OR UPDATE
+ON messages FOR EACH ROW EXECUTE FUNCTION
+tsvector_update_trigger(tsv, 'pg_catalog.english', title, body);
+
+INSERT INTO messages VALUES('title here', 'the body text is here');
+
+SELECT * FROM messages;
+ title | body | tsv
+------------+-----------------------+----------------------------
+ title here | the body text is here | 'bodi':4 'text':5 'titl':1
+
+SELECT title, body FROM messages WHERE tsv @@ to_tsquery('title & body');
+ title | body
+------------+-----------------------
+ title here | the body text is here
+
+
+ Having created this trigger, any change in title or
+ body will automatically be reflected into
+ tsv, without the application having to worry about it.
+
+ The first trigger argument must be the name of the tsvector
+ column to be updated. The second argument specifies the text search
+ configuration to be used to perform the conversion. For
+ tsvector_update_trigger, the configuration name is simply
+ given as the second trigger argument. It must be schema-qualified as
+ shown above, so that the trigger behavior will not change with changes
+ in search_path. For
+ tsvector_update_trigger_column, the second trigger argument
+ is the name of another table column, which must be of type
+ regconfig. This allows a per-row selection of configuration
+ to be made. The remaining argument(s) are the names of textual columns
+ (of type text, varchar, or char). These
+ will be included in the document in the order given. NULL values will
+ be skipped (but the other columns will still be indexed).
+
+ A limitation of these built-in triggers is that they treat all the
+ input columns alike. To process columns differently — for
+ example, to weight title differently from body — it is necessary
+ to write a custom trigger. Here is an example using
+ PL/pgSQL as the trigger language:
+
+
+CREATE FUNCTION messages_trigger() RETURNS trigger AS $$
+begin
+ new.tsv :=
+ setweight(to_tsvector('pg_catalog.english', coalesce(new.title,'')), 'A') ||
+ setweight(to_tsvector('pg_catalog.english', coalesce(new.body,'')), 'D');
+ return new;
+end
+$$ LANGUAGE plpgsql;
+
+CREATE TRIGGER tsvectorupdate BEFORE INSERT OR UPDATE
+ ON messages FOR EACH ROW EXECUTE FUNCTION messages_trigger();
+
+
+ Keep in mind that it is important to specify the configuration name
+ explicitly when creating tsvector values inside triggers,
+ so that the column's contents will not be affected by changes to
+ default_text_search_config. Failure to do this is likely to
+ lead to problems such as search results changing after a dump and restore.
+
12.4.4. Gathering Document Statistics #
+ The function ts_stat is useful for checking your
+ configuration and for finding stop-word candidates.
+
+ts_stat(sqlquery text, [ weights text, ]
+ OUT word text, OUT ndoc integer,
+ OUT nentry integer) returns setof record
+
+ sqlquery is a text value containing an SQL
+ query which must return a single tsvector column.
+ ts_stat executes the query and returns statistics about
+ each distinct lexeme (word) contained in the tsvector
+ data. The columns returned are
+
+
+ word text — the value of a lexeme
+
+ ndoc integer — number of documents
+ (tsvectors) the word occurred in
+
+ nentry integer — total number of
+ occurrences of the word
+
+
+ If weights is supplied, only occurrences
+ having one of those weights are counted.
+
+ For example, to find the ten most frequent words in a document collection:
+
+
+SELECT * FROM ts_stat('SELECT vector FROM apod')
+ORDER BY nentry DESC, ndoc DESC, word
+LIMIT 10;
+
+
+ The same, but counting only word occurrences with weight A
+ or B:
+
+
+SELECT * FROM ts_stat('SELECT vector FROM apod', 'ab')
+ORDER BY nentry DESC, ndoc DESC, word
+LIMIT 10;
+
+
12.9. Preferred Index Types for Text Search #
+ There are two kinds of indexes that can be used to speed up full text
+ searches:
+ GIN and
+ GiST.
+ Note that indexes are not mandatory for full text searching, but in
+ cases where a column is searched on a regular basis, an index is
+ usually desirable.
+
+ To create such an index, do one of:
+
+
-
+
+
+
CREATE INDEX name ON table USING GIN (column);
+
+ Creates a GIN (Generalized Inverted Index)-based index.
+ The column must be of tsvector type.
+
-
+
+
+
CREATE INDEX name ON table USING GIST (column [ { DEFAULT | tsvector_ops } (siglen = number) ] );
+
+ Creates a GiST (Generalized Search Tree)-based index.
+ The column can be of tsvector or
+ tsquery type.
+ Optional integer parameter siglen determines
+ signature length in bytes (see below for details).
+
+
+ GIN indexes are the preferred text search index type. As inverted
+ indexes, they contain an index entry for each word (lexeme), with a
+ compressed list of matching locations. Multi-word searches can find
+ the first match, then use the index to remove rows that are lacking
+ additional words. GIN indexes store only the words (lexemes) of
+ tsvector values, and not their weight labels. Thus a table
+ row recheck is needed when using a query that involves weights.
+
+ A GiST index is lossy, meaning that the index
+ might produce false matches, and it is necessary
+ to check the actual table row to eliminate such false matches.
+ (PostgreSQL does this automatically when needed.)
+ GiST indexes are lossy because each document is represented in the
+ index by a fixed-length signature. The signature length in bytes is determined
+ by the value of the optional integer parameter siglen.
+ The default signature length (when siglen is not specified) is
+ 124 bytes, the maximum signature length is 2024 bytes. The signature is generated by hashing
+ each word into a single bit in an n-bit string, with all these bits OR-ed
+ together to produce an n-bit document signature. When two words hash to
+ the same bit position there will be a false match. If all words in
+ the query have matches (real or false) then the table row must be
+ retrieved to see if the match is correct. Longer signatures lead to a more
+ precise search (scanning a smaller fraction of the index and fewer heap
+ pages), at the cost of a larger index.
+
+ A GiST index can be covering, i.e., use the INCLUDE
+ clause. Included columns can have data types without any GiST operator
+ class. Included attributes will be stored uncompressed.
+
+ Lossiness causes performance degradation due to unnecessary fetches of table
+ records that turn out to be false matches. Since random access to table
+ records is slow, this limits the usefulness of GiST indexes. The
+ likelihood of false matches depends on several factors, in particular the
+ number of unique words, so using dictionaries to reduce this number is
+ recommended.
+
+ Note that GIN index build time can often be improved
+ by increasing maintenance_work_mem, while
+ GiST index build time is not sensitive to that
+ parameter.
+
+ Partitioning of big collections and the proper use of GIN and GiST indexes
+ allows the implementation of very fast searches with online update.
+ Partitioning can be done at the database level using table inheritance,
+ or by distributing documents over
+ servers and collecting external search results, e.g., via Foreign Data access.
+ The latter is possible because ranking functions use
+ only local information.
+
+ Full Text Searching (or just text search) provides
+ the capability to identify natural-language documents that
+ satisfy a query, and optionally to sort them by
+ relevance to the query. The most common type of search
+ is to find all documents containing given query terms
+ and return them in order of their similarity to the
+ query. Notions of query and
+ similarity are very flexible and depend on the specific
+ application. The simplest search considers query as a
+ set of words and similarity as the frequency of query
+ words in the document.
+
+ Textual search operators have existed in databases for years.
+ PostgreSQL has
+ ~, ~*, LIKE, and
+ ILIKE operators for textual data types, but they lack
+ many essential properties required by modern information systems:
+
+ There is no linguistic support, even for English. Regular expressions
+ are not sufficient because they cannot easily handle derived words, e.g.,
+ satisfies and satisfy. You might
+ miss documents that contain satisfies, although you
+ probably would like to find them when searching for
+ satisfy. It is possible to use OR
+ to search for multiple derived forms, but this is tedious and error-prone
+ (some words can have several thousand derivatives).
+
+ They provide no ordering (ranking) of search results, which makes them
+ ineffective when thousands of matching documents are found.
+
+ They tend to be slow because there is no index support, so they must
+ process all documents for every search.
+
+ Full text indexing allows documents to be preprocessed
+ and an index saved for later rapid searching. Preprocessing includes:
+
+ Parsing documents into tokens. It is
+ useful to identify various classes of tokens, e.g., numbers, words,
+ complex words, email addresses, so that they can be processed
+ differently. In principle token classes depend on the specific
+ application, but for most purposes it is adequate to use a predefined
+ set of classes.
+ PostgreSQL uses a parser to
+ perform this step. A standard parser is provided, and custom parsers
+ can be created for specific needs.
+
+ Converting tokens into lexemes.
+ A lexeme is a string, just like a token, but it has been
+ normalized so that different forms of the same word
+ are made alike. For example, normalization almost always includes
+ folding upper-case letters to lower-case, and often involves removal
+ of suffixes (such as s or es in English).
+ This allows searches to find variant forms of the
+ same word, without tediously entering all the possible variants.
+ Also, this step typically eliminates stop words, which
+ are words that are so common that they are useless for searching.
+ (In short, then, tokens are raw fragments of the document text, while
+ lexemes are words that are believed useful for indexing and searching.)
+ PostgreSQL uses dictionaries to
+ perform this step. Various standard dictionaries are provided, and
+ custom ones can be created for specific needs.
+
+ Storing preprocessed documents optimized for
+ searching. For example, each document can be represented
+ as a sorted array of normalized lexemes. Along with the lexemes it is
+ often desirable to store positional information to use for
+ proximity ranking, so that a document that
+ contains a more “dense” region of query words is
+ assigned a higher rank than one with scattered query words.
+
+ Dictionaries allow fine-grained control over how tokens are normalized.
+ With appropriate dictionaries, you can:
+
+ Define stop words that should not be indexed.
+
+ Map synonyms to a single word using Ispell.
+
+ Map phrases to a single word using a thesaurus.
+
+ Map different variations of a word to a canonical form using
+ an Ispell dictionary.
+
+ Map different variations of a word to a canonical form using
+ Snowball stemmer rules.
+
+ A data type tsvector is provided for storing preprocessed
+ documents, along with a type tsquery for representing processed
+ queries (Section 8.11). There are many
+ functions and operators available for these data types
+ (Section 9.13), the most important of which is
+ the match operator @@, which we introduce in
+ Section 12.1.2. Full text searches can be accelerated
+ using indexes (Section 12.9).
+
12.1.1. What Is a Document? #
+ A document is the unit of searching in a full text search
+ system; for example, a magazine article or email message. The text search
+ engine must be able to parse documents and store associations of lexemes
+ (key words) with their parent document. Later, these associations are
+ used to search for documents that contain query words.
+
+ For searches within PostgreSQL,
+ a document is normally a textual field within a row of a database table,
+ or possibly a combination (concatenation) of such fields, perhaps stored
+ in several tables or obtained dynamically. In other words, a document can
+ be constructed from different parts for indexing and it might not be
+ stored anywhere as a whole. For example:
+
+
+SELECT title || ' ' || author || ' ' || abstract || ' ' || body AS document
+FROM messages
+WHERE mid = 12;
+
+SELECT m.title || ' ' || m.author || ' ' || m.abstract || ' ' || d.body AS document
+FROM messages m, docs d
+WHERE m.mid = d.did AND m.mid = 12;
+
+
Note
+ Actually, in these example queries, coalesce
+ should be used to prevent a single NULL attribute from
+ causing a NULL result for the whole document.
+
+ Another possibility is to store the documents as simple text files in the
+ file system. In this case, the database can be used to store the full text
+ index and to execute searches, and some unique identifier can be used to
+ retrieve the document from the file system. However, retrieving files
+ from outside the database requires superuser permissions or special
+ function support, so this is usually less convenient than keeping all
+ the data inside PostgreSQL. Also, keeping
+ everything inside the database allows easy access
+ to document metadata to assist in indexing and display.
+
+ For text search purposes, each document must be reduced to the
+ preprocessed tsvector format. Searching and ranking
+ are performed entirely on the tsvector representation
+ of a document — the original text need only be retrieved
+ when the document has been selected for display to a user.
+ We therefore often speak of the tsvector as being the
+ document, but of course it is only a compact representation of
+ the full document.
+
12.1.2. Basic Text Matching #
+ Full text searching in PostgreSQL is based on
+ the match operator @@, which returns
+ true if a tsvector
+ (document) matches a tsquery (query).
+ It doesn't matter which data type is written first:
+
+
+SELECT 'a fat cat sat on a mat and ate a fat rat'::tsvector @@ 'cat & rat'::tsquery;
+ ?column?
+----------
+ t
+
+SELECT 'fat & cow'::tsquery @@ 'a fat cat sat on a mat and ate a fat rat'::tsvector;
+ ?column?
+----------
+ f
+
+
+ As the above example suggests, a tsquery is not just raw
+ text, any more than a tsvector is. A tsquery
+ contains search terms, which must be already-normalized lexemes, and
+ may combine multiple terms using AND, OR, NOT, and FOLLOWED BY operators.
+ (For syntax details see Section 8.11.2.) There are
+ functions to_tsquery, plainto_tsquery,
+ and phraseto_tsquery
+ that are helpful in converting user-written text into a proper
+ tsquery, primarily by normalizing words appearing in
+ the text. Similarly, to_tsvector is used to parse and
+ normalize a document string. So in practice a text search match would
+ look more like this:
+
+
+SELECT to_tsvector('fat cats ate fat rats') @@ to_tsquery('fat & rat');
+ ?column?
+----------
+ t
+
+
+ Observe that this match would not succeed if written as
+
+
+SELECT 'fat cats ate fat rats'::tsvector @@ to_tsquery('fat & rat');
+ ?column?
+----------
+ f
+
+
+ since here no normalization of the word rats will occur.
+ The elements of a tsvector are lexemes, which are assumed
+ already normalized, so rats does not match rat.
+
+ The @@ operator also
+ supports text input, allowing explicit conversion of a text
+ string to tsvector or tsquery to be skipped
+ in simple cases. The variants available are:
+
+
+tsvector @@ tsquery
+tsquery @@ tsvector
+text @@ tsquery
+text @@ text
+
+
+ The first two of these we saw already.
+ The form text @@ tsquery
+ is equivalent to to_tsvector(x) @@ y.
+ The form text @@ text
+ is equivalent to to_tsvector(x) @@ plainto_tsquery(y).
+
+ Within a tsquery, the & (AND) operator
+ specifies that both its arguments must appear in the document to have a
+ match. Similarly, the | (OR) operator specifies that
+ at least one of its arguments must appear, while the ! (NOT)
+ operator specifies that its argument must not appear in
+ order to have a match.
+ For example, the query fat & ! rat matches documents that
+ contain fat but not rat.
+
+ Searching for phrases is possible with the help of
+ the <-> (FOLLOWED BY) tsquery operator, which
+ matches only if its arguments have matches that are adjacent and in the
+ given order. For example:
+
+
+SELECT to_tsvector('fatal error') @@ to_tsquery('fatal <-> error');
+ ?column?
+----------
+ t
+
+SELECT to_tsvector('error is not fatal') @@ to_tsquery('fatal <-> error');
+ ?column?
+----------
+ f
+
+
+ There is a more general version of the FOLLOWED BY operator having the
+ form <N>,
+ where N is an integer standing for the difference between
+ the positions of the matching lexemes. <1> is
+ the same as <->, while <2>
+ allows exactly one other lexeme to appear between the matches, and so
+ on. The phraseto_tsquery function makes use of this
+ operator to construct a tsquery that can match a multi-word
+ phrase when some of the words are stop words. For example:
+
+
+SELECT phraseto_tsquery('cats ate rats');
+ phraseto_tsquery
+-------------------------------
+ 'cat' <-> 'ate' <-> 'rat'
+
+SELECT phraseto_tsquery('the cats ate the rats');
+ phraseto_tsquery
+-------------------------------
+ 'cat' <-> 'ate' <2> 'rat'
+
+
+ A special case that's sometimes useful is that <0>
+ can be used to require that two patterns match the same word.
+
+ Parentheses can be used to control nesting of the tsquery
+ operators. Without parentheses, | binds least tightly,
+ then &, then <->,
+ and ! most tightly.
+
+ It's worth noticing that the AND/OR/NOT operators mean something subtly
+ different when they are within the arguments of a FOLLOWED BY operator
+ than when they are not, because within FOLLOWED BY the exact position of
+ the match is significant. For example, normally !x matches
+ only documents that do not contain x anywhere.
+ But !x <-> y matches y if it is not
+ immediately after an x; an occurrence of x
+ elsewhere in the document does not prevent a match. Another example is
+ that x & y normally only requires that x
+ and y both appear somewhere in the document, but
+ (x & y) <-> z requires x
+ and y to match at the same place, immediately before
+ a z. Thus this query behaves differently from
+ x <-> z & y <-> z, which will match a
+ document containing two separate sequences x z and
+ y z. (This specific query is useless as written,
+ since x and y could not match at the same place;
+ but with more complex situations such as prefix-match patterns, a query
+ of this form could be useful.)
+
+ The above are all simple text search examples. As mentioned before, full
+ text search functionality includes the ability to do many more things:
+ skip indexing certain words (stop words), process synonyms, and use
+ sophisticated parsing, e.g., parse based on more than just white space.
+ This functionality is controlled by text search
+ configurations. PostgreSQL comes with predefined
+ configurations for many languages, and you can easily create your own
+ configurations. (psql's \dF command
+ shows all available configurations.)
+
+ During installation an appropriate configuration is selected and
+ default_text_search_config is set accordingly
+ in postgresql.conf. If you are using the same text search
+ configuration for the entire cluster you can use the value in
+ postgresql.conf. To use different configurations
+ throughout the cluster but the same configuration within any one database,
+ use ALTER DATABASE ... SET. Otherwise, you can set
+ default_text_search_config in each session.
+
+ Each text search function that depends on a configuration has an optional
+ regconfig argument, so that the configuration to use can be
+ specified explicitly. default_text_search_config
+ is used only when this argument is omitted.
+
+ To make it easier to build custom text search configurations, a
+ configuration is built up from simpler database objects.
+ PostgreSQL's text search facility provides
+ four types of configuration-related database objects:
+
+ Text search parsers break documents into tokens
+ and classify each token (for example, as words or numbers).
+
+ Text search dictionaries convert tokens to normalized
+ form and reject stop words.
+
+ Text search templates provide the functions underlying
+ dictionaries. (A dictionary simply specifies a template and a set
+ of parameters for the template.)
+
+ Text search configurations select a parser and a set
+ of dictionaries to use to normalize the tokens produced by the parser.
+
+ Text search parsers and templates are built from low-level C functions;
+ therefore it requires C programming ability to develop new ones, and
+ superuser privileges to install one into a database. (There are examples
+ of add-on parsers and templates in the contrib/ area of the
+ PostgreSQL distribution.) Since dictionaries and
+ configurations just parameterize and connect together some underlying
+ parsers and templates, no special privilege is needed to create a new
+ dictionary or configuration. Examples of creating custom dictionaries and
+ configurations appear later in this chapter.
+
+ The current limitations of PostgreSQL's
+ text search features are:
+
The length of each lexeme must be less than 2 kilobytes
The length of a tsvector (lexemes + positions) must be
+ less than 1 megabyte
The number of lexemes must be less than
+ 264
Position values in tsvector must be greater than 0 and
+ no more than 16,383
The match distance in a <N>
+ (FOLLOWED BY) tsquery operator cannot be more than
+ 16,384
No more than 256 positions per lexeme
The number of nodes (lexemes + operators) in a tsquery
+ must be less than 32,768
+
+ For comparison, the PostgreSQL 8.1 documentation
+ contained 10,441 unique words, a total of 335,420 words, and the most
+ frequent word “postgresql” was mentioned 6,127 times in 655
+ documents.
+
+ Another example — the PostgreSQL mailing
+ list archives contained 910,989 unique words with 57,491,343 lexemes in
+ 461,020 messages.
+
+ Text search parsers are responsible for splitting raw document text
+ into tokens and identifying each token's type, where
+ the set of possible types is defined by the parser itself.
+ Note that a parser does not modify the text at all — it simply
+ identifies plausible word boundaries. Because of this limited scope,
+ there is less need for application-specific custom parsers than there is
+ for custom dictionaries. At present PostgreSQL
+ provides just one built-in parser, which has been found to be useful for a
+ wide range of applications.
+
+ The built-in parser is named pg_catalog.default.
+ It recognizes 23 token types, shown in Table 12.1.
+
Table 12.1. Default Parser's Token Types
| Alias | Description | Example |
|---|
asciiword | Word, all ASCII letters | elephant |
word | Word, all letters | mañana |
numword | Word, letters and digits | beta1 |
asciihword | Hyphenated word, all ASCII | up-to-date |
hword | Hyphenated word, all letters | lógico-matemática |
numhword | Hyphenated word, letters and digits | postgresql-beta1 |
hword_asciipart | Hyphenated word part, all ASCII | postgresql in the context postgresql-beta1 |
hword_part | Hyphenated word part, all letters | lógico or matemática
+ in the context lógico-matemática |
hword_numpart | Hyphenated word part, letters and digits | beta1 in the context
+ postgresql-beta1 |
email | Email address | foo@example.com |
protocol | Protocol head | http:// |
url | URL | example.com/stuff/index.html |
host | Host | example.com |
url_path | URL path | /stuff/index.html, in the context of a URL |
file | File or path name | /usr/local/foo.txt, if not within a URL |
sfloat | Scientific notation | -1.234e56 |
float | Decimal notation | -1.234 |
int | Signed integer | -1234 |
uint | Unsigned integer | 1234 |
version | Version number | 8.3.0 |
tag | XML tag | <a href="dictionaries.html"> |
entity | XML entity | & |
blank | Space symbols | (any whitespace or punctuation not otherwise recognized) |
Note
+ The parser's notion of a “letter” is determined by the database's
+ locale setting, specifically lc_ctype. Words containing
+ only the basic ASCII letters are reported as a separate token type,
+ since it is sometimes useful to distinguish them. In most European
+ languages, token types word and asciiword
+ should be treated alike.
+
+ email does not support all valid email characters as
+ defined by RFC 5322.
+ Specifically, the only non-alphanumeric characters supported for
+ email user names are period, dash, and underscore.
+
+ It is possible for the parser to produce overlapping tokens from the same
+ piece of text. As an example, a hyphenated word will be reported both
+ as the entire word and as each component:
+
+
+SELECT alias, description, token FROM ts_debug('foo-bar-beta1');
+ alias | description | token
+-----------------+------------------------------------------+---------------
+ numhword | Hyphenated word, letters and digits | foo-bar-beta1
+ hword_asciipart | Hyphenated word part, all ASCII | foo
+ blank | Space symbols | -
+ hword_asciipart | Hyphenated word part, all ASCII | bar
+ blank | Space symbols | -
+ hword_numpart | Hyphenated word part, letters and digits | beta1
+
+
+ This behavior is desirable since it allows searches to work for both
+ the whole compound word and for components. Here is another
+ instructive example:
+
+
+SELECT alias, description, token FROM ts_debug('http://example.com/stuff/index.html');
+ alias | description | token
+----------+---------------+------------------------------
+ protocol | Protocol head | http://
+ url | URL | example.com/stuff/index.html
+ host | Host | example.com
+ url_path | URL path | /stuff/index.html
+
+
+ Information about text search configuration objects can be obtained
+ in psql using a set of commands:
+
+\dF{d,p,t}[+] [PATTERN]
+
+ An optional + produces more details.
+
+ The optional parameter PATTERN can be the name of
+ a text search object, optionally schema-qualified. If
+ PATTERN is omitted then information about all
+ visible objects will be displayed. PATTERN can be a
+ regular expression and can provide separate patterns
+ for the schema and object names. The following examples illustrate this:
+
+
+=> \dF *fulltext*
+ List of text search configurations
+ Schema | Name | Description
+--------+--------------+-------------
+ public | fulltext_cfg |
+
+
+
+=> \dF *.fulltext*
+ List of text search configurations
+ Schema | Name | Description
+----------+----------------------------
+ fulltext | fulltext_cfg |
+ public | fulltext_cfg |
+
+
+ The available commands are:
+
\dF[+] [PATTERN]
+ List text search configurations (add + for more detail).
+
+=> \dF russian
+ List of text search configurations
+ Schema | Name | Description
+------------+---------+------------------------------------
+ pg_catalog | russian | configuration for russian language
+
+=> \dF+ russian
+Text search configuration "pg_catalog.russian"
+Parser: "pg_catalog.default"
+ Token | Dictionaries
+-----------------+--------------
+ asciihword | english_stem
+ asciiword | english_stem
+ email | simple
+ file | simple
+ float | simple
+ host | simple
+ hword | russian_stem
+ hword_asciipart | english_stem
+ hword_numpart | simple
+ hword_part | russian_stem
+ int | simple
+ numhword | simple
+ numword | simple
+ sfloat | simple
+ uint | simple
+ url | simple
+ url_path | simple
+ version | simple
+ word | russian_stem
+
+
\dFd[+] [PATTERN]
+ List text search dictionaries (add + for more detail).
+
+=> \dFd
+ List of text search dictionaries
+ Schema | Name | Description
+------------+-----------------+-----------------------------------------------------------
+ pg_catalog | arabic_stem | snowball stemmer for arabic language
+ pg_catalog | armenian_stem | snowball stemmer for armenian language
+ pg_catalog | basque_stem | snowball stemmer for basque language
+ pg_catalog | catalan_stem | snowball stemmer for catalan language
+ pg_catalog | danish_stem | snowball stemmer for danish language
+ pg_catalog | dutch_stem | snowball stemmer for dutch language
+ pg_catalog | english_stem | snowball stemmer for english language
+ pg_catalog | finnish_stem | snowball stemmer for finnish language
+ pg_catalog | french_stem | snowball stemmer for french language
+ pg_catalog | german_stem | snowball stemmer for german language
+ pg_catalog | greek_stem | snowball stemmer for greek language
+ pg_catalog | hindi_stem | snowball stemmer for hindi language
+ pg_catalog | hungarian_stem | snowball stemmer for hungarian language
+ pg_catalog | indonesian_stem | snowball stemmer for indonesian language
+ pg_catalog | irish_stem | snowball stemmer for irish language
+ pg_catalog | italian_stem | snowball stemmer for italian language
+ pg_catalog | lithuanian_stem | snowball stemmer for lithuanian language
+ pg_catalog | nepali_stem | snowball stemmer for nepali language
+ pg_catalog | norwegian_stem | snowball stemmer for norwegian language
+ pg_catalog | portuguese_stem | snowball stemmer for portuguese language
+ pg_catalog | romanian_stem | snowball stemmer for romanian language
+ pg_catalog | russian_stem | snowball stemmer for russian language
+ pg_catalog | serbian_stem | snowball stemmer for serbian language
+ pg_catalog | simple | simple dictionary: just lower case and check for stopword
+ pg_catalog | spanish_stem | snowball stemmer for spanish language
+ pg_catalog | swedish_stem | snowball stemmer for swedish language
+ pg_catalog | tamil_stem | snowball stemmer for tamil language
+ pg_catalog | turkish_stem | snowball stemmer for turkish language
+ pg_catalog | yiddish_stem | snowball stemmer for yiddish language
+
+
\dFp[+] [PATTERN]
+ List text search parsers (add + for more detail).
+
+=> \dFp
+ List of text search parsers
+ Schema | Name | Description
+------------+---------+---------------------
+ pg_catalog | default | default word parser
+=> \dFp+
+ Text search parser "pg_catalog.default"
+ Method | Function | Description
+-----------------+----------------+-------------
+ Start parse | prsd_start |
+ Get next token | prsd_nexttoken |
+ End parse | prsd_end |
+ Get headline | prsd_headline |
+ Get token types | prsd_lextype |
+
+ Token types for parser "pg_catalog.default"
+ Token name | Description
+-----------------+------------------------------------------
+ asciihword | Hyphenated word, all ASCII
+ asciiword | Word, all ASCII
+ blank | Space symbols
+ email | Email address
+ entity | XML entity
+ file | File or path name
+ float | Decimal notation
+ host | Host
+ hword | Hyphenated word, all letters
+ hword_asciipart | Hyphenated word part, all ASCII
+ hword_numpart | Hyphenated word part, letters and digits
+ hword_part | Hyphenated word part, all letters
+ int | Signed integer
+ numhword | Hyphenated word, letters and digits
+ numword | Word, letters and digits
+ protocol | Protocol head
+ sfloat | Scientific notation
+ tag | XML tag
+ uint | Unsigned integer
+ url | URL
+ url_path | URL path
+ version | Version number
+ word | Word, all letters
+(23 rows)
+
+
\dFt[+] [PATTERN]
+ List text search templates (add + for more detail).
+
+=> \dFt
+ List of text search templates
+ Schema | Name | Description
+------------+-----------+-----------------------------------------------------------
+ pg_catalog | ispell | ispell dictionary
+ pg_catalog | simple | simple dictionary: just lower case and check for stopword
+ pg_catalog | snowball | snowball stemmer
+ pg_catalog | synonym | synonym dictionary: replace word by its synonym
+ pg_catalog | thesaurus | thesaurus dictionary: phrase by phrase substitution
+
+
12.2. Tables and Indexes #
+ The examples in the previous section illustrated full text matching using
+ simple constant strings. This section shows how to search table data,
+ optionally using indexes.
+
12.2.1. Searching a Table #
+ It is possible to do a full text search without an index. A simple query
+ to print the title of each row that contains the word
+ friend in its body field is:
+
+
+SELECT title
+FROM pgweb
+WHERE to_tsvector('english', body) @@ to_tsquery('english', 'friend');
+
+
+ This will also find related words such as friends
+ and friendly, since all these are reduced to the same
+ normalized lexeme.
+
+ The query above specifies that the english configuration
+ is to be used to parse and normalize the strings. Alternatively we
+ could omit the configuration parameters:
+
+
+SELECT title
+FROM pgweb
+WHERE to_tsvector(body) @@ to_tsquery('friend');
+
+
+ This query will use the configuration set by default_text_search_config.
+
+ A more complex example is to
+ select the ten most recent documents that contain create and
+ table in the title or body:
+
+
+SELECT title
+FROM pgweb
+WHERE to_tsvector(title || ' ' || body) @@ to_tsquery('create & table')
+ORDER BY last_mod_date DESC
+LIMIT 10;
+
+
+ For clarity we omitted the coalesce function calls
+ which would be needed to find rows that contain NULL
+ in one of the two fields.
+
+ Although these queries will work without an index, most applications
+ will find this approach too slow, except perhaps for occasional ad-hoc
+ searches. Practical use of text searching usually requires creating
+ an index.
+
12.2.2. Creating Indexes #
+ We can create a GIN index (Section 12.9) to speed up text searches:
+
+
+CREATE INDEX pgweb_idx ON pgweb USING GIN (to_tsvector('english', body));
+
+
+ Notice that the 2-argument version of to_tsvector is
+ used. Only text search functions that specify a configuration name can
+ be used in expression indexes (Section 11.7).
+ This is because the index contents must be unaffected by default_text_search_config. If they were affected, the
+ index contents might be inconsistent because different entries could
+ contain tsvectors that were created with different text search
+ configurations, and there would be no way to guess which was which. It
+ would be impossible to dump and restore such an index correctly.
+
+ Because the two-argument version of to_tsvector was
+ used in the index above, only a query reference that uses the 2-argument
+ version of to_tsvector with the same configuration
+ name will use that index. That is, WHERE
+ to_tsvector('english', body) @@ 'a & b' can use the index,
+ but WHERE to_tsvector(body) @@ 'a & b' cannot.
+ This ensures that an index will be used only with the same configuration
+ used to create the index entries.
+
+ It is possible to set up more complex expression indexes wherein the
+ configuration name is specified by another column, e.g.:
+
+
+CREATE INDEX pgweb_idx ON pgweb USING GIN (to_tsvector(config_name, body));
+
+
+ where config_name is a column in the pgweb
+ table. This allows mixed configurations in the same index while
+ recording which configuration was used for each index entry. This
+ would be useful, for example, if the document collection contained
+ documents in different languages. Again,
+ queries that are meant to use the index must be phrased to match, e.g.,
+ WHERE to_tsvector(config_name, body) @@ 'a & b'.
+
+ Indexes can even concatenate columns:
+
+
+CREATE INDEX pgweb_idx ON pgweb USING GIN (to_tsvector('english', title || ' ' || body));
+
+
+ Another approach is to create a separate tsvector column
+ to hold the output of to_tsvector. To keep this
+ column automatically up to date with its source data, use a stored
+ generated column. This example is a
+ concatenation of title and body,
+ using coalesce to ensure that one field will still be
+ indexed when the other is NULL:
+
+
+ALTER TABLE pgweb
+ ADD COLUMN textsearchable_index_col tsvector
+ GENERATED ALWAYS AS (to_tsvector('english', coalesce(title, '') || ' ' || coalesce(body, ''))) STORED;
+
+
+ Then we create a GIN index to speed up the search:
+
+
+CREATE INDEX textsearch_idx ON pgweb USING GIN (textsearchable_index_col);
+
+
+ Now we are ready to perform a fast full text search:
+
+
+SELECT title
+FROM pgweb
+WHERE textsearchable_index_col @@ to_tsquery('create & table')
+ORDER BY last_mod_date DESC
+LIMIT 10;
+
+
+ One advantage of the separate-column approach over an expression index
+ is that it is not necessary to explicitly specify the text search
+ configuration in queries in order to make use of the index. As shown
+ in the example above, the query can depend on
+ default_text_search_config. Another advantage is that
+ searches will be faster, since it will not be necessary to redo the
+ to_tsvector calls to verify index matches. (This is more
+ important when using a GiST index than a GIN index; see Section 12.9.) The expression-index approach is
+ simpler to set up, however, and it requires less disk space since the
+ tsvector representation is not stored explicitly.
+
Chapter 12. Full Text Search
74.1. Transactions and Identifiers #
+ Transactions can be created explicitly using BEGIN
+ or START TRANSACTION and ended using
+ COMMIT or ROLLBACK. SQL
+ statements outside of explicit transactions automatically use
+ single-statement transactions.
+
+ Every transaction is identified by a unique
+ VirtualTransactionId (also called
+ virtualXID or vxid), which
+ is comprised of a backend ID (or backendID)
+ and a sequentially-assigned number local to each backend, known as
+ localXID. For example, the virtual transaction
+ ID 4/12532 has a backendID
+ of 4 and a localXID of
+ 12532.
+
+ Non-virtual TransactionIds (or xid),
+ e.g., 278394, are assigned sequentially to
+ transactions from a global counter used by all databases within
+ the PostgreSQL cluster. This assignment
+ happens when a transaction first writes to the database. This means
+ lower-numbered xids started writing before higher-numbered xids.
+ Note that the order in which transactions perform their first database
+ write might be different from the order in which the transactions
+ started, particularly if the transaction started with statements that
+ only performed database reads.
+
+ The internal transaction ID type xid is 32 bits wide
+ and wraps around every
+ 4 billion transactions. A 32-bit epoch is incremented during each
+ wraparound. There is also a 64-bit type xid8 which
+ includes this epoch and therefore does not wrap around during the
+ life of an installation; it can be converted to xid by casting.
+ The functions in Table 9.80
+ return xid8 values. Xids are used as the
+ basis for PostgreSQL's MVCC concurrency mechanism and streaming
+ replication.
+
+ When a top-level transaction with a (non-virtual) xid commits,
+ it is marked as committed in the pg_xact
+ directory. Additional information is recorded in the
+ pg_commit_ts directory if track_commit_timestamp is enabled.
+
+ In addition to vxid and xid,
+ prepared transactions are also assigned Global Transaction
+ Identifiers (GID). GIDs are string literals up
+ to 200 bytes long, which must be unique amongst other currently
+ prepared transactions. The mapping of GID to xid is shown in pg_prepared_xacts.
+
13.2. Transaction Isolation #
+ The SQL standard defines four levels of
+ transaction isolation. The most strict is Serializable,
+ which is defined by the standard in a paragraph which says that any
+ concurrent execution of a set of Serializable transactions is guaranteed
+ to produce the same effect as running them one at a time in some order.
+ The other three levels are defined in terms of phenomena, resulting from
+ interaction between concurrent transactions, which must not occur at
+ each level. The standard notes that due to the definition of
+ Serializable, none of these phenomena are possible at that level. (This
+ is hardly surprising -- if the effect of the transactions must be
+ consistent with having been run one at a time, how could you see any
+ phenomena caused by interactions?)
+
+ The phenomena which are prohibited at various levels are:
+
+
-
+ dirty read
+
+
+ A transaction reads data written by a concurrent uncommitted transaction.
+
-
+ nonrepeatable read
+
+
+ A transaction re-reads data it has previously read and finds that data
+ has been modified by another transaction (that committed since the
+ initial read).
+
-
+ phantom read
+
+
+ A transaction re-executes a query returning a set of rows that satisfy a
+ search condition and finds that the set of rows satisfying the condition
+ has changed due to another recently-committed transaction.
+
-
+ serialization anomaly
+
+
+ The result of successfully committing a group of transactions
+ is inconsistent with all possible orderings of running those
+ transactions one at a time.
+
+
+
+ The SQL standard and PostgreSQL-implemented transaction isolation levels
+ are described in Table 13.1.
+
Table 13.1. Transaction Isolation Levels
|
+ Isolation Level
+ |
+ Dirty Read
+ |
+ Nonrepeatable Read
+ |
+ Phantom Read
+ |
+ Serialization Anomaly
+ |
|---|
|
+ Read uncommitted
+ |
+ Allowed, but not in PG
+ |
+ Possible
+ |
+ Possible
+ |
+ Possible
+ |
|
+ Read committed
+ |
+ Not possible
+ |
+ Possible
+ |
+ Possible
+ |
+ Possible
+ |
|
+ Repeatable read
+ |
+ Not possible
+ |
+ Not possible
+ |
+ Allowed, but not in PG
+ |
+ Possible
+ |
|
+ Serializable
+ |
+ Not possible
+ |
+ Not possible
+ |
+ Not possible
+ |
+ Not possible
+ |
+ In PostgreSQL, you can request any of
+ the four standard transaction isolation levels, but internally only
+ three distinct isolation levels are implemented, i.e., PostgreSQL's
+ Read Uncommitted mode behaves like Read Committed. This is because
+ it is the only sensible way to map the standard isolation levels to
+ PostgreSQL's multiversion concurrency control architecture.
+
+ The table also shows that PostgreSQL's Repeatable Read implementation
+ does not allow phantom reads. This is acceptable under the SQL
+ standard because the standard specifies which anomalies must
+ not occur at certain isolation levels; higher
+ guarantees are acceptable.
+ The behavior of the available isolation levels is detailed in the
+ following subsections.
+
+ To set the transaction isolation level of a transaction, use the
+ command SET TRANSACTION.
+
Important
+ Some PostgreSQL data types and functions have
+ special rules regarding transactional behavior. In particular, changes
+ made to a sequence (and therefore the counter of a
+ column declared using serial) are immediately visible
+ to all other transactions and are not rolled back if the transaction
+ that made the changes aborts. See Section 9.17
+ and Section 8.1.4.
+
13.2.1. Read Committed Isolation Level #
+ Read Committed is the default isolation
+ level in PostgreSQL. When a transaction
+ uses this isolation level, a SELECT query
+ (without a FOR UPDATE/SHARE clause) sees only data
+ committed before the query began; it never sees either uncommitted
+ data or changes committed by concurrent transactions during the query's
+ execution. In effect, a SELECT query sees
+ a snapshot of the database as of the instant the query begins to
+ run. However, SELECT does see the effects
+ of previous updates executed within its own transaction, even
+ though they are not yet committed. Also note that two successive
+ SELECT commands can see different data, even
+ though they are within a single transaction, if other transactions
+ commit changes after the first SELECT starts and
+ before the second SELECT starts.
+
+ UPDATE, DELETE, SELECT
+ FOR UPDATE, and SELECT FOR SHARE commands
+ behave the same as SELECT
+ in terms of searching for target rows: they will only find target rows
+ that were committed as of the command start time. However, such a target
+ row might have already been updated (or deleted or locked) by
+ another concurrent transaction by the time it is found. In this case, the
+ would-be updater will wait for the first updating transaction to commit or
+ roll back (if it is still in progress). If the first updater rolls back,
+ then its effects are negated and the second updater can proceed with
+ updating the originally found row. If the first updater commits, the
+ second updater will ignore the row if the first updater deleted it,
+ otherwise it will attempt to apply its operation to the updated version of
+ the row. The search condition of the command (the WHERE clause) is
+ re-evaluated to see if the updated version of the row still matches the
+ search condition. If so, the second updater proceeds with its operation
+ using the updated version of the row. In the case of
+ SELECT FOR UPDATE and SELECT FOR
+ SHARE, this means it is the updated version of the row that is
+ locked and returned to the client.
+
+ INSERT with an ON CONFLICT DO UPDATE clause
+ behaves similarly. In Read Committed mode, each row proposed for insertion
+ will either insert or update. Unless there are unrelated errors, one of
+ those two outcomes is guaranteed. If a conflict originates in another
+ transaction whose effects are not yet visible to the INSERT,
+ the UPDATE clause will affect that row,
+ even though possibly no version of that row is
+ conventionally visible to the command.
+
+ INSERT with an ON CONFLICT DO
+ NOTHING clause may have insertion not proceed for a row due to
+ the outcome of another transaction whose effects are not visible
+ to the INSERT snapshot. Again, this is only
+ the case in Read Committed mode.
+
+ MERGE allows the user to specify various
+ combinations of INSERT, UPDATE
+ and DELETE subcommands. A MERGE
+ command with both INSERT and UPDATE
+ subcommands looks similar to INSERT with an
+ ON CONFLICT DO UPDATE clause but does not
+ guarantee that either INSERT or
+ UPDATE will occur.
+ If MERGE attempts an UPDATE or
+ DELETE and the row is concurrently updated but
+ the join condition still passes for the current target and the
+ current source tuple, then MERGE will behave
+ the same as the UPDATE or
+ DELETE commands and perform its action on the
+ updated version of the row. However, because MERGE
+ can specify several actions and they can be conditional, the
+ conditions for each action are re-evaluated on the updated version of
+ the row, starting from the first action, even if the action that had
+ originally matched appears later in the list of actions.
+ On the other hand, if the row is concurrently updated or deleted so
+ that the join condition fails, then MERGE will
+ evaluate the condition's NOT MATCHED actions next,
+ and execute the first one that succeeds.
+ If MERGE attempts an INSERT
+ and a unique index is present and a duplicate row is concurrently
+ inserted, then a uniqueness violation error is raised;
+ MERGE does not attempt to avoid such
+ errors by restarting evaluation of MATCHED
+ conditions.
+
+ Because of the above rules, it is possible for an updating command to see
+ an inconsistent snapshot: it can see the effects of concurrent updating
+ commands on the same rows it is trying to update, but it
+ does not see effects of those commands on other rows in the database.
+ This behavior makes Read Committed mode unsuitable for commands that
+ involve complex search conditions; however, it is just right for simpler
+ cases. For example, consider updating bank balances with transactions
+ like:
+
+
+BEGIN;
+UPDATE accounts SET balance = balance + 100.00 WHERE acctnum = 12345;
+UPDATE accounts SET balance = balance - 100.00 WHERE acctnum = 7534;
+COMMIT;
+
+
+ If two such transactions concurrently try to change the balance of account
+ 12345, we clearly want the second transaction to start with the updated
+ version of the account's row. Because each command is affecting only a
+ predetermined row, letting it see the updated version of the row does
+ not create any troublesome inconsistency.
+
+ More complex usage can produce undesirable results in Read Committed
+ mode. For example, consider a DELETE command
+ operating on data that is being both added and removed from its
+ restriction criteria by another command, e.g., assume
+ website is a two-row table with
+ website.hits equaling 9 and
+ 10:
+
+
+BEGIN;
+UPDATE website SET hits = hits + 1;
+-- run from another session: DELETE FROM website WHERE hits = 10;
+COMMIT;
+
+
+ The DELETE will have no effect even though
+ there is a website.hits = 10 row before and
+ after the UPDATE. This occurs because the
+ pre-update row value 9 is skipped, and when the
+ UPDATE completes and DELETE
+ obtains a lock, the new row value is no longer 10 but
+ 11, which no longer matches the criteria.
+
+ Because Read Committed mode starts each command with a new snapshot
+ that includes all transactions committed up to that instant,
+ subsequent commands in the same transaction will see the effects
+ of the committed concurrent transaction in any case. The point
+ at issue above is whether or not a single command
+ sees an absolutely consistent view of the database.
+
+ The partial transaction isolation provided by Read Committed mode
+ is adequate for many applications, and this mode is fast and simple
+ to use; however, it is not sufficient for all cases. Applications
+ that do complex queries and updates might require a more rigorously
+ consistent view of the database than Read Committed mode provides.
+
13.2.2. Repeatable Read Isolation Level #
+ The Repeatable Read isolation level only sees
+ data committed before the transaction began; it never sees either
+ uncommitted data or changes committed by concurrent transactions during
+ the transaction's execution. (However, each query does see the
+ effects of previous updates executed within its own transaction,
+ even though they are not yet committed.) This is a stronger
+ guarantee than is required by the SQL standard
+ for this isolation level, and prevents all of the phenomena described
+ in Table 13.1 except for serialization
+ anomalies. As mentioned above, this is
+ specifically allowed by the standard, which only describes the
+ minimum protections each isolation level must
+ provide.
+
+ This level is different from Read Committed in that a query in a
+ repeatable read transaction sees a snapshot as of the start of the
+ first non-transaction-control statement in the
+ transaction, not as of the start
+ of the current statement within the transaction. Thus, successive
+ SELECT commands within a single
+ transaction see the same data, i.e., they do not see changes made by
+ other transactions that committed after their own transaction started.
+
+ Applications using this level must be prepared to retry transactions
+ due to serialization failures.
+
+ UPDATE, DELETE,
+ MERGE, SELECT FOR UPDATE,
+ and SELECT FOR SHARE commands
+ behave the same as SELECT
+ in terms of searching for target rows: they will only find target rows
+ that were committed as of the transaction start time. However, such a
+ target row might have already been updated (or deleted or locked) by
+ another concurrent transaction by the time it is found. In this case, the
+ repeatable read transaction will wait for the first updating transaction to commit or
+ roll back (if it is still in progress). If the first updater rolls back,
+ then its effects are negated and the repeatable read transaction can proceed
+ with updating the originally found row. But if the first updater commits
+ (and actually updated or deleted the row, not just locked it)
+ then the repeatable read transaction will be rolled back with the message
+
+
+ERROR: could not serialize access due to concurrent update
+
+
+ because a repeatable read transaction cannot modify or lock rows changed by
+ other transactions after the repeatable read transaction began.
+
+ When an application receives this error message, it should abort
+ the current transaction and retry the whole transaction from
+ the beginning. The second time through, the transaction will see the
+ previously-committed change as part of its initial view of the database,
+ so there is no logical conflict in using the new version of the row
+ as the starting point for the new transaction's update.
+
+ Note that only updating transactions might need to be retried; read-only
+ transactions will never have serialization conflicts.
+
+ The Repeatable Read mode provides a rigorous guarantee that each
+ transaction sees a completely stable view of the database. However,
+ this view will not necessarily always be consistent with some serial
+ (one at a time) execution of concurrent transactions of the same level.
+ For example, even a read-only transaction at this level may see a
+ control record updated to show that a batch has been completed but
+ not see one of the detail records which is logically
+ part of the batch because it read an earlier revision of the control
+ record. Attempts to enforce business rules by transactions running at
+ this isolation level are not likely to work correctly without careful use
+ of explicit locks to block conflicting transactions.
+
+ The Repeatable Read isolation level is implemented using a technique
+ known in academic database literature and in some other database products
+ as Snapshot Isolation. Differences in behavior
+ and performance may be observed when compared with systems that use a
+ traditional locking technique that reduces concurrency. Some other
+ systems may even offer Repeatable Read and Snapshot Isolation as distinct
+ isolation levels with different behavior. The permitted phenomena that
+ distinguish the two techniques were not formalized by database researchers
+ until after the SQL standard was developed, and are outside the scope of
+ this manual. For a full treatment, please see
+ [berenson95].
+
Note
+ Prior to PostgreSQL version 9.1, a request
+ for the Serializable transaction isolation level provided exactly the
+ same behavior described here. To retain the legacy Serializable
+ behavior, Repeatable Read should now be requested.
+
13.2.3. Serializable Isolation Level #
+ The Serializable isolation level provides
+ the strictest transaction isolation. This level emulates serial
+ transaction execution for all committed transactions;
+ as if transactions had been executed one after another, serially,
+ rather than concurrently. However, like the Repeatable Read level,
+ applications using this level must
+ be prepared to retry transactions due to serialization failures.
+ In fact, this isolation level works exactly the same as Repeatable
+ Read except that it also monitors for conditions which could make
+ execution of a concurrent set of serializable transactions behave
+ in a manner inconsistent with all possible serial (one at a time)
+ executions of those transactions. This monitoring does not
+ introduce any blocking beyond that present in repeatable read, but
+ there is some overhead to the monitoring, and detection of the
+ conditions which could cause a
+ serialization anomaly will trigger a
+ serialization failure.
+
+ As an example,
+ consider a table mytab, initially containing:
+
+ class | value
+-------+-------
+ 1 | 10
+ 1 | 20
+ 2 | 100
+ 2 | 200
+
+ Suppose that serializable transaction A computes:
+
+SELECT SUM(value) FROM mytab WHERE class = 1;
+
+ and then inserts the result (30) as the value in a
+ new row with class = 2. Concurrently, serializable
+ transaction B computes:
+
+SELECT SUM(value) FROM mytab WHERE class = 2;
+
+ and obtains the result 300, which it inserts in a new row with
+ class = 1. Then both transactions try to commit.
+ If either transaction were running at the Repeatable Read isolation level,
+ both would be allowed to commit; but since there is no serial order of execution
+ consistent with the result, using Serializable transactions will allow one
+ transaction to commit and will roll the other back with this message:
+
+
+ERROR: could not serialize access due to read/write dependencies among transactions
+
+
+ This is because if A had
+ executed before B, B would have computed the sum 330, not 300, and
+ similarly the other order would have resulted in a different sum
+ computed by A.
+
+ When relying on Serializable transactions to prevent anomalies, it is
+ important that any data read from a permanent user table not be
+ considered valid until the transaction which read it has successfully
+ committed. This is true even for read-only transactions, except that
+ data read within a deferrable read-only
+ transaction is known to be valid as soon as it is read, because such a
+ transaction waits until it can acquire a snapshot guaranteed to be free
+ from such problems before starting to read any data. In all other cases
+ applications must not depend on results read during a transaction that
+ later aborted; instead, they should retry the transaction until it
+ succeeds.
+
+ To guarantee true serializability PostgreSQL
+ uses predicate locking, which means that it keeps locks
+ which allow it to determine when a write would have had an impact on
+ the result of a previous read from a concurrent transaction, had it run
+ first. In PostgreSQL these locks do not
+ cause any blocking and therefore can not play any part in
+ causing a deadlock. They are used to identify and flag dependencies
+ among concurrent Serializable transactions which in certain combinations
+ can lead to serialization anomalies. In contrast, a Read Committed or
+ Repeatable Read transaction which wants to ensure data consistency may
+ need to take out a lock on an entire table, which could block other
+ users attempting to use that table, or it may use SELECT FOR
+ UPDATE or SELECT FOR SHARE which not only
+ can block other transactions but cause disk access.
+
+ Predicate locks in PostgreSQL, like in most
+ other database systems, are based on data actually accessed by a
+ transaction. These will show up in the
+ pg_locks
+ system view with a mode of SIReadLock. The
+ particular locks
+ acquired during execution of a query will depend on the plan used by
+ the query, and multiple finer-grained locks (e.g., tuple locks) may be
+ combined into fewer coarser-grained locks (e.g., page locks) during the
+ course of the transaction to prevent exhaustion of the memory used to
+ track the locks. A READ ONLY transaction may be able to
+ release its SIRead locks before completion, if it detects that no
+ conflicts can still occur which could lead to a serialization anomaly.
+ In fact, READ ONLY transactions will often be able to
+ establish that fact at startup and avoid taking any predicate locks.
+ If you explicitly request a SERIALIZABLE READ ONLY DEFERRABLE
+ transaction, it will block until it can establish this fact. (This is
+ the only case where Serializable transactions block but
+ Repeatable Read transactions don't.) On the other hand, SIRead locks
+ often need to be kept past transaction commit, until overlapping read
+ write transactions complete.
+
+ Consistent use of Serializable transactions can simplify development.
+ The guarantee that any set of successfully committed concurrent
+ Serializable transactions will have the same effect as if they were run
+ one at a time means that if you can demonstrate that a single transaction,
+ as written, will do the right thing when run by itself, you can have
+ confidence that it will do the right thing in any mix of Serializable
+ transactions, even without any information about what those other
+ transactions might do, or it will not successfully commit. It is
+ important that an environment which uses this technique have a
+ generalized way of handling serialization failures (which always return
+ with an SQLSTATE value of '40001'), because it will be very hard to
+ predict exactly which transactions might contribute to the read/write
+ dependencies and need to be rolled back to prevent serialization
+ anomalies. The monitoring of read/write dependencies has a cost, as does
+ the restart of transactions which are terminated with a serialization
+ failure, but balanced against the cost and blocking involved in use of
+ explicit locks and SELECT FOR UPDATE or SELECT FOR
+ SHARE, Serializable transactions are the best performance choice
+ for some environments.
+
+ While PostgreSQL's Serializable transaction isolation
+ level only allows concurrent transactions to commit if it can prove there
+ is a serial order of execution that would produce the same effect, it
+ doesn't always prevent errors from being raised that would not occur in
+ true serial execution. In particular, it is possible to see unique
+ constraint violations caused by conflicts with overlapping Serializable
+ transactions even after explicitly checking that the key isn't present
+ before attempting to insert it. This can be avoided by making sure
+ that all Serializable transactions that insert potentially
+ conflicting keys explicitly check if they can do so first. For example,
+ imagine an application that asks the user for a new key and then checks
+ that it doesn't exist already by trying to select it first, or generates
+ a new key by selecting the maximum existing key and adding one. If some
+ Serializable transactions insert new keys directly without following this
+ protocol, unique constraints violations might be reported even in cases
+ where they could not occur in a serial execution of the concurrent
+ transactions.
+
+ For optimal performance when relying on Serializable transactions for
+ concurrency control, these issues should be considered:
+
+
+ Declare transactions as READ ONLY when possible.
+
+ Control the number of active connections, using a connection pool if
+ needed. This is always an important performance consideration, but
+ it can be particularly important in a busy system using Serializable
+ transactions.
+
+ Don't put more into a single transaction than needed for integrity
+ purposes.
+
+ Don't leave connections dangling “idle in transaction”
+ longer than necessary. The configuration parameter
+ idle_in_transaction_session_timeout may be used to
+ automatically disconnect lingering sessions.
+
+ Eliminate explicit locks, SELECT FOR UPDATE, and
+ SELECT FOR SHARE where no longer needed due to the
+ protections automatically provided by Serializable transactions.
+
+ When the system is forced to combine multiple page-level predicate
+ locks into a single relation-level predicate lock because the predicate
+ lock table is short of memory, an increase in the rate of serialization
+ failures may occur. You can avoid this by increasing
+ max_pred_locks_per_transaction,
+ max_pred_locks_per_relation, and/or
+ max_pred_locks_per_page.
+
+ A sequential scan will always necessitate a relation-level predicate
+ lock. This can result in an increased rate of serialization failures.
+ It may be helpful to encourage the use of index scans by reducing
+ random_page_cost and/or increasing
+ cpu_tuple_cost. Be sure to weigh any decrease
+ in transaction rollbacks and restarts against any overall change in
+ query execution time.
+
+
+ The Serializable isolation level is implemented using a technique known
+ in academic database literature as Serializable Snapshot Isolation, which
+ builds on Snapshot Isolation by adding checks for serialization anomalies.
+ Some differences in behavior and performance may be observed when compared
+ with other systems that use a traditional locking technique. Please see
+ [ports12] for detailed information.
+
Chapter 74. Transaction Processing
+ This chapter provides an overview of the internals of
+ PostgreSQL's transaction management system.
+ The word transaction is often abbreviated as xact.
+
39.2. Visibility of Data Changes #
+ If you execute SQL commands in your trigger function, and these
+ commands access the table that the trigger is for, then
+ you need to be aware of the data visibility rules, because they determine
+ whether these SQL commands will see the data change that the trigger
+ is fired for. Briefly:
+
+
+ Statement-level triggers follow simple visibility rules: none of
+ the changes made by a statement are visible to statement-level
+ BEFORE triggers, whereas all
+ modifications are visible to statement-level AFTER
+ triggers.
+
+ The data change (insertion, update, or deletion) causing the
+ trigger to fire is naturally not visible
+ to SQL commands executed in a row-level BEFORE trigger,
+ because it hasn't happened yet.
+
+ However, SQL commands executed in a row-level BEFORE
+ trigger will see the effects of data
+ changes for rows previously processed in the same outer
+ command. This requires caution, since the ordering of these
+ change events is not in general predictable; an SQL command that
+ affects multiple rows can visit the rows in any order.
+
+ Similarly, a row-level INSTEAD OF trigger will see the
+ effects of data changes made by previous firings of INSTEAD
+ OF triggers in the same outer command.
+
+ When a row-level AFTER trigger is fired, all data
+ changes made
+ by the outer command are already complete, and are visible to
+ the invoked trigger function.
+
+
+ If your trigger function is written in any of the standard procedural
+ languages, then the above statements apply only if the function is
+ declared VOLATILE. Functions that are declared
+ STABLE or IMMUTABLE will not see changes made by
+ the calling command in any case.
+
+ Further information about data visibility rules can be found in
+ Section 47.5. The example in Section 39.4 contains a demonstration of these rules.
+
39.1. Overview of Trigger Behavior #
+ A trigger is a specification that the database should automatically
+ execute a particular function whenever a certain type of operation is
+ performed. Triggers can be attached to tables (partitioned or not),
+ views, and foreign tables.
+
+ On tables and foreign tables, triggers can be defined to execute either
+ before or after any INSERT, UPDATE,
+ or DELETE operation, either once per modified row,
+ or once per SQL statement.
+ UPDATE triggers can moreover be set to fire only if
+ certain columns are mentioned in the SET clause of
+ the UPDATE statement. Triggers can also fire
+ for TRUNCATE statements. If a trigger event occurs,
+ the trigger's function is called at the appropriate time to handle the
+ event.
+
+ On views, triggers can be defined to execute instead of
+ INSERT, UPDATE, or
+ DELETE operations.
+ Such INSTEAD OF triggers
+ are fired once for each row that needs to be modified in the view.
+ It is the responsibility of the
+ trigger's function to perform the necessary modifications to the view's
+ underlying base table(s) and, where appropriate, return the modified
+ row as it will appear in the view. Triggers on views can also be defined
+ to execute once per SQL statement, before or after
+ INSERT, UPDATE, or
+ DELETE operations.
+ However, such triggers are fired only if there is also
+ an INSTEAD OF trigger on the view. Otherwise,
+ any statement targeting the view must be rewritten into a statement
+ affecting its underlying base table(s), and then the triggers
+ that will be fired are the ones attached to the base table(s).
+
+ The trigger function must be defined before the trigger itself can be
+ created. The trigger function must be declared as a
+ function taking no arguments and returning type trigger.
+ (The trigger function receives its input through a specially-passed
+ TriggerData structure, not in the form of ordinary function
+ arguments.)
+
+ Once a suitable trigger function has been created, the trigger is
+ established with
+ CREATE TRIGGER.
+ The same trigger function can be used for multiple triggers.
+
+ PostgreSQL offers both per-row
+ triggers and per-statement triggers. With a per-row
+ trigger, the trigger function
+ is invoked once for each row that is affected by the statement
+ that fired the trigger. In contrast, a per-statement trigger is
+ invoked only once when an appropriate statement is executed,
+ regardless of the number of rows affected by that statement. In
+ particular, a statement that affects zero rows will still result
+ in the execution of any applicable per-statement triggers. These
+ two types of triggers are sometimes called row-level
+ triggers and statement-level triggers,
+ respectively. Triggers on TRUNCATE may only be
+ defined at statement level, not per-row.
+
+ Triggers are also classified according to whether they fire
+ before, after, or
+ instead of the operation. These are referred to
+ as BEFORE triggers, AFTER triggers, and
+ INSTEAD OF triggers respectively.
+ Statement-level BEFORE triggers naturally fire before the
+ statement starts to do anything, while statement-level AFTER
+ triggers fire at the very end of the statement. These types of
+ triggers may be defined on tables, views, or foreign tables. Row-level
+ BEFORE triggers fire immediately before a particular row is
+ operated on, while row-level AFTER triggers fire at the end of
+ the statement (but before any statement-level AFTER triggers).
+ These types of triggers may only be defined on tables and
+ foreign tables, not views.
+ INSTEAD OF triggers may only be
+ defined on views, and only at row level; they fire immediately as each
+ row in the view is identified as needing to be operated on.
+
+ The execution of an AFTER trigger can be deferred
+ to the end of the transaction, rather than the end of the statement,
+ if it was defined as a constraint trigger.
+ In all cases, a trigger is executed as part of the same transaction as
+ the statement that triggered it, so if either the statement or the
+ trigger causes an error, the effects of both will be rolled back.
+
+ A statement that targets a parent table in an inheritance or partitioning
+ hierarchy does not cause the statement-level triggers of affected child
+ tables to be fired; only the parent table's statement-level triggers are
+ fired. However, row-level triggers of any affected child tables will be
+ fired.
+
+ If an INSERT contains an ON CONFLICT
+ DO UPDATE clause, it is possible that the effects of
+ row-level BEFORE INSERT triggers and
+ row-level BEFORE UPDATE triggers can
+ both be applied in a way that is apparent from the final state of
+ the updated row, if an EXCLUDED column is referenced.
+ There need not be an EXCLUDED column reference for
+ both sets of row-level BEFORE triggers to execute,
+ though. The
+ possibility of surprising outcomes should be considered when there
+ are both BEFORE INSERT and
+ BEFORE UPDATE row-level triggers
+ that change a row being inserted/updated (this can be
+ problematic even if the modifications are more or less equivalent, if
+ they're not also idempotent). Note that statement-level
+ UPDATE triggers are executed when ON
+ CONFLICT DO UPDATE is specified, regardless of whether or not
+ any rows were affected by the UPDATE (and
+ regardless of whether the alternative UPDATE
+ path was ever taken). An INSERT with an
+ ON CONFLICT DO UPDATE clause will execute
+ statement-level BEFORE INSERT
+ triggers first, then statement-level BEFORE
+ UPDATE triggers, followed by statement-level
+ AFTER UPDATE triggers and finally
+ statement-level AFTER INSERT
+ triggers.
+
+ If an UPDATE on a partitioned table causes a row to move
+ to another partition, it will be performed as a DELETE
+ from the original partition followed by an INSERT into
+ the new partition. In this case, all row-level BEFORE
+ UPDATE triggers and all row-level
+ BEFORE DELETE triggers are fired on
+ the original partition. Then all row-level BEFORE
+ INSERT triggers are fired on the destination partition.
+ The possibility of surprising outcomes should be considered when all these
+ triggers affect the row being moved. As far as AFTER ROW
+ triggers are concerned, AFTER DELETE
+ and AFTER INSERT triggers are
+ applied; but AFTER UPDATE triggers
+ are not applied because the UPDATE has been converted to
+ a DELETE and an INSERT. As far as
+ statement-level triggers are concerned, none of the
+ DELETE or INSERT triggers are fired,
+ even if row movement occurs; only the UPDATE triggers
+ defined on the target table used in the UPDATE statement
+ will be fired.
+
+ No separate triggers are defined for MERGE. Instead,
+ statement-level or row-level UPDATE,
+ DELETE, and INSERT triggers are fired
+ depending on (for statement-level triggers) what actions are specified in
+ the MERGE query and (for row-level triggers) what
+ actions are performed.
+
+ While running a MERGE command, statement-level
+ BEFORE and AFTER triggers are
+ fired for events specified in the actions of the MERGE
+ command, irrespective of whether or not the action is ultimately performed.
+ This is the same as an UPDATE statement that updates
+ no rows, yet statement-level triggers are fired.
+ The row-level triggers are fired only when a row is actually updated,
+ inserted or deleted. So it's perfectly legal that while statement-level
+ triggers are fired for certain types of action, no row-level triggers
+ are fired for the same kind of action.
+
+ Trigger functions invoked by per-statement triggers should always
+ return NULL. Trigger functions invoked by per-row
+ triggers can return a table row (a value of
+ type HeapTuple) to the calling executor,
+ if they choose. A row-level trigger fired before an operation has
+ the following choices:
+
+
+ It can return NULL to skip the operation for the
+ current row. This instructs the executor to not perform the
+ row-level operation that invoked the trigger (the insertion,
+ modification, or deletion of a particular table row).
+
+ For row-level INSERT
+ and UPDATE triggers only, the returned row
+ becomes the row that will be inserted or will replace the row
+ being updated. This allows the trigger function to modify the
+ row being inserted or updated.
+
+
+ A row-level BEFORE trigger that does not intend to cause
+ either of these behaviors must be careful to return as its result the same
+ row that was passed in (that is, the NEW row
+ for INSERT and UPDATE
+ triggers, the OLD row for
+ DELETE triggers).
+
+ A row-level INSTEAD OF trigger should either return
+ NULL to indicate that it did not modify any data from
+ the view's underlying base tables, or it should return the view
+ row that was passed in (the NEW row
+ for INSERT and UPDATE
+ operations, or the OLD row for
+ DELETE operations). A nonnull return value is
+ used to signal that the trigger performed the necessary data
+ modifications in the view. This will cause the count of the number
+ of rows affected by the command to be incremented. For
+ INSERT and UPDATE operations only, the trigger
+ may modify the NEW row before returning it. This will
+ change the data returned by
+ INSERT RETURNING or UPDATE RETURNING,
+ and is useful when the view will not show exactly the same data
+ that was provided.
+
+ The return value is ignored for row-level triggers fired after an
+ operation, and so they can return NULL.
+
+ Some considerations apply for generated
+ columns. Stored generated columns are computed after
+ BEFORE triggers and before AFTER
+ triggers. Therefore, the generated value can be inspected in
+ AFTER triggers. In BEFORE triggers,
+ the OLD row contains the old generated value, as one
+ would expect, but the NEW row does not yet contain the
+ new generated value and should not be accessed. In the C language
+ interface, the content of the column is undefined at this point; a
+ higher-level programming language should prevent access to a stored
+ generated column in the NEW row in a
+ BEFORE trigger. Changes to the value of a generated
+ column in a BEFORE trigger are ignored and will be
+ overwritten.
+
+ If more than one trigger is defined for the same event on the same
+ relation, the triggers will be fired in alphabetical order by
+ trigger name. In the case of BEFORE and
+ INSTEAD OF triggers, the possibly-modified row returned by
+ each trigger becomes the input to the next trigger. If any
+ BEFORE or INSTEAD OF trigger returns
+ NULL, the operation is abandoned for that row and subsequent
+ triggers are not fired (for that row).
+
+ A trigger definition can also specify a Boolean WHEN
+ condition, which will be tested to see whether the trigger should
+ be fired. In row-level triggers the WHEN condition can
+ examine the old and/or new values of columns of the row. (Statement-level
+ triggers can also have WHEN conditions, although the feature
+ is not so useful for them.) In a BEFORE trigger, the
+ WHEN
+ condition is evaluated just before the function is or would be executed,
+ so using WHEN is not materially different from testing the
+ same condition at the beginning of the trigger function. However, in
+ an AFTER trigger, the WHEN condition is evaluated
+ just after the row update occurs, and it determines whether an event is
+ queued to fire the trigger at the end of statement. So when an
+ AFTER trigger's
+ WHEN condition does not return true, it is not necessary
+ to queue an event nor to re-fetch the row at end of statement. This
+ can result in significant speedups in statements that modify many
+ rows, if the trigger only needs to be fired for a few of the rows.
+ INSTEAD OF triggers do not support
+ WHEN conditions.
+
+ Typically, row-level BEFORE triggers are used for checking or
+ modifying the data that will be inserted or updated. For example,
+ a BEFORE trigger might be used to insert the current time into a
+ timestamp column, or to check that two elements of the row are
+ consistent. Row-level AFTER triggers are most sensibly
+ used to propagate the updates to other tables, or make consistency
+ checks against other tables. The reason for this division of labor is
+ that an AFTER trigger can be certain it is seeing the final
+ value of the row, while a BEFORE trigger cannot; there might
+ be other BEFORE triggers firing after it. If you have no
+ specific reason to make a trigger BEFORE or
+ AFTER, the BEFORE case is more efficient, since
+ the information about
+ the operation doesn't have to be saved until end of statement.
+
+ If a trigger function executes SQL commands then these
+ commands might fire triggers again. This is known as cascading
+ triggers. There is no direct limitation on the number of cascade
+ levels. It is possible for cascades to cause a recursive invocation
+ of the same trigger; for example, an INSERT
+ trigger might execute a command that inserts an additional row
+ into the same table, causing the INSERT trigger
+ to be fired again. It is the trigger programmer's responsibility
+ to avoid infinite recursion in such scenarios.
+
+
+ When a trigger is being defined, arguments can be specified for
+ it. The purpose of including arguments in the
+ trigger definition is to allow different triggers with similar
+ requirements to call the same function. As an example, there
+ could be a generalized trigger function that takes as its
+ arguments two column names and puts the current user in one and
+ the current time stamp in the other. Properly written, this
+ trigger function would be independent of the specific table it is
+ triggering on. So the same function could be used for
+ INSERT events on any table with suitable
+ columns, to automatically track creation of records in a
+ transaction table for example. It could also be used to track
+ last-update events if defined as an UPDATE
+ trigger.
+
+ Each programming language that supports triggers has its own method
+ for making the trigger input data available to the trigger function.
+ This input data includes the type of trigger event (e.g.,
+ INSERT or UPDATE) as well as any
+ arguments that were listed in CREATE TRIGGER.
+ For a row-level trigger, the input data also includes the
+ NEW row for INSERT and
+ UPDATE triggers, and/or the OLD row
+ for UPDATE and DELETE triggers.
+
+ By default, statement-level triggers do not have any way to examine the
+ individual row(s) modified by the statement. But an AFTER
+ STATEMENT trigger can request that transition tables
+ be created to make the sets of affected rows available to the trigger.
+ AFTER ROW triggers can also request transition tables, so
+ that they can see the total changes in the table as well as the change in
+ the individual row they are currently being fired for. The method for
+ examining the transition tables again depends on the programming language
+ that is being used, but the typical approach is to make the transition
+ tables act like read-only temporary tables that can be accessed by SQL
+ commands issued within the trigger function.
+
39.4. A Complete Trigger Example #
+ Here is a very simple example of a trigger function written in C.
+ (Examples of triggers written in procedural languages can be found
+ in the documentation of the procedural languages.)
+
+ The function trigf reports the number of rows in the
+ table ttest and skips the actual operation if the
+ command attempts to insert a null value into the column
+ x. (So the trigger acts as a not-null constraint but
+ doesn't abort the transaction.)
+
+ First, the table definition:
+
+CREATE TABLE ttest (
+ x integer
+);
+
+
+ This is the source code of the trigger function:
+
+#include "postgres.h"
+#include "fmgr.h"
+#include "executor/spi.h" /* this is what you need to work with SPI */
+#include "commands/trigger.h" /* ... triggers ... */
+#include "utils/rel.h" /* ... and relations */
+
+PG_MODULE_MAGIC;
+
+PG_FUNCTION_INFO_V1(trigf);
+
+Datum
+trigf(PG_FUNCTION_ARGS)
+{
+ TriggerData *trigdata = (TriggerData *) fcinfo->context;
+ TupleDesc tupdesc;
+ HeapTuple rettuple;
+ char *when;
+ bool checknull = false;
+ bool isnull;
+ int ret, i;
+
+ /* make sure it's called as a trigger at all */
+ if (!CALLED_AS_TRIGGER(fcinfo))
+ elog(ERROR, "trigf: not called by trigger manager");
+
+ /* tuple to return to executor */
+ if (TRIGGER_FIRED_BY_UPDATE(trigdata->tg_event))
+ rettuple = trigdata->tg_newtuple;
+ else
+ rettuple = trigdata->tg_trigtuple;
+
+ /* check for null values */
+ if (!TRIGGER_FIRED_BY_DELETE(trigdata->tg_event)
+ && TRIGGER_FIRED_BEFORE(trigdata->tg_event))
+ checknull = true;
+
+ if (TRIGGER_FIRED_BEFORE(trigdata->tg_event))
+ when = "before";
+ else
+ when = "after ";
+
+ tupdesc = trigdata->tg_relation->rd_att;
+
+ /* connect to SPI manager */
+ if ((ret = SPI_connect()) < 0)
+ elog(ERROR, "trigf (fired %s): SPI_connect returned %d", when, ret);
+
+ /* get number of rows in table */
+ ret = SPI_exec("SELECT count(*) FROM ttest", 0);
+
+ if (ret < 0)
+ elog(ERROR, "trigf (fired %s): SPI_exec returned %d", when, ret);
+
+ /* count(*) returns int8, so be careful to convert */
+ i = DatumGetInt64(SPI_getbinval(SPI_tuptable->vals[0],
+ SPI_tuptable->tupdesc,
+ 1,
+ &isnull));
+
+ elog (INFO, "trigf (fired %s): there are %d rows in ttest", when, i);
+
+ SPI_finish();
+
+ if (checknull)
+ {
+ SPI_getbinval(rettuple, tupdesc, 1, &isnull);
+ if (isnull)
+ rettuple = NULL;
+ }
+
+ return PointerGetDatum(rettuple);
+}
+
+
+
+ After you have compiled the source code (see Section 38.10.5), declare the function and the triggers:
+
+CREATE FUNCTION trigf() RETURNS trigger
+ AS 'filename'
+ LANGUAGE C;
+
+CREATE TRIGGER tbefore BEFORE INSERT OR UPDATE OR DELETE ON ttest
+ FOR EACH ROW EXECUTE FUNCTION trigf();
+
+CREATE TRIGGER tafter AFTER INSERT OR UPDATE OR DELETE ON ttest
+ FOR EACH ROW EXECUTE FUNCTION trigf();
+
+
+ Now you can test the operation of the trigger:
+
+=> INSERT INTO ttest VALUES (NULL);
+INFO: trigf (fired before): there are 0 rows in ttest
+INSERT 0 0
+
+-- Insertion skipped and AFTER trigger is not fired
+
+=> SELECT * FROM ttest;
+ x
+---
+(0 rows)
+
+=> INSERT INTO ttest VALUES (1);
+INFO: trigf (fired before): there are 0 rows in ttest
+INFO: trigf (fired after ): there are 1 rows in ttest
+ ^^^^^^^^
+ remember what we said about visibility.
+INSERT 167793 1
+vac=> SELECT * FROM ttest;
+ x
+---
+ 1
+(1 row)
+
+=> INSERT INTO ttest SELECT x * 2 FROM ttest;
+INFO: trigf (fired before): there are 1 rows in ttest
+INFO: trigf (fired after ): there are 2 rows in ttest
+ ^^^^^^
+ remember what we said about visibility.
+INSERT 167794 1
+=> SELECT * FROM ttest;
+ x
+---
+ 1
+ 2
+(2 rows)
+
+=> UPDATE ttest SET x = NULL WHERE x = 2;
+INFO: trigf (fired before): there are 2 rows in ttest
+UPDATE 0
+=> UPDATE ttest SET x = 4 WHERE x = 2;
+INFO: trigf (fired before): there are 2 rows in ttest
+INFO: trigf (fired after ): there are 2 rows in ttest
+UPDATE 1
+vac=> SELECT * FROM ttest;
+ x
+---
+ 1
+ 4
+(2 rows)
+
+=> DELETE FROM ttest;
+INFO: trigf (fired before): there are 2 rows in ttest
+INFO: trigf (fired before): there are 1 rows in ttest
+INFO: trigf (fired after ): there are 0 rows in ttest
+INFO: trigf (fired after ): there are 0 rows in ttest
+ ^^^^^^
+ remember what we said about visibility.
+DELETE 2
+=> SELECT * FROM ttest;
+ x
+---
+(0 rows)
+
+
+
+ There are more complex examples in
+ src/test/regress/regress.c and
+ in spi.
+
39.3. Writing Trigger Functions in C #
+ This section describes the low-level details of the interface to a
+ trigger function. This information is only needed when writing
+ trigger functions in C. If you are using a higher-level language then
+ these details are handled for you. In most cases you should consider
+ using a procedural language before writing your triggers in C. The
+ documentation of each procedural language explains how to write a
+ trigger in that language.
+
+ Trigger functions must use the “version 1” function manager
+ interface.
+
+ When a function is called by the trigger manager, it is not passed
+ any normal arguments, but it is passed a “context”
+ pointer pointing to a TriggerData structure. C
+ functions can check whether they were called from the trigger
+ manager or not by executing the macro:
+
+CALLED_AS_TRIGGER(fcinfo)
+
+ which expands to:
+
+((fcinfo)->context != NULL && IsA((fcinfo)->context, TriggerData))
+
+ If this returns true, then it is safe to cast
+ fcinfo->context to type TriggerData
+ * and make use of the pointed-to
+ TriggerData structure. The function must
+ not alter the TriggerData
+ structure or any of the data it points to.
+
+ struct TriggerData is defined in
+ commands/trigger.h:
+
+
+typedef struct TriggerData
+{
+ NodeTag type;
+ TriggerEvent tg_event;
+ Relation tg_relation;
+ HeapTuple tg_trigtuple;
+ HeapTuple tg_newtuple;
+ Trigger *tg_trigger;
+ TupleTableSlot *tg_trigslot;
+ TupleTableSlot *tg_newslot;
+ Tuplestorestate *tg_oldtable;
+ Tuplestorestate *tg_newtable;
+ const Bitmapset *tg_updatedcols;
+} TriggerData;
+
+
+ where the members are defined as follows:
+
+
type
+ Always T_TriggerData.
+
tg_event
+ Describes the event for which the function is called. You can use the
+ following macros to examine tg_event:
+
+
TRIGGER_FIRED_BEFORE(tg_event)
+ Returns true if the trigger fired before the operation.
+
TRIGGER_FIRED_AFTER(tg_event)
+ Returns true if the trigger fired after the operation.
+
TRIGGER_FIRED_INSTEAD(tg_event)
+ Returns true if the trigger fired instead of the operation.
+
TRIGGER_FIRED_FOR_ROW(tg_event)
+ Returns true if the trigger fired for a row-level event.
+
TRIGGER_FIRED_FOR_STATEMENT(tg_event)
+ Returns true if the trigger fired for a statement-level event.
+
TRIGGER_FIRED_BY_INSERT(tg_event)
+ Returns true if the trigger was fired by an INSERT command.
+
TRIGGER_FIRED_BY_UPDATE(tg_event)
+ Returns true if the trigger was fired by an UPDATE command.
+
TRIGGER_FIRED_BY_DELETE(tg_event)
+ Returns true if the trigger was fired by a DELETE command.
+
TRIGGER_FIRED_BY_TRUNCATE(tg_event)
+ Returns true if the trigger was fired by a TRUNCATE command.
+
+
tg_relation
+ A pointer to a structure describing the relation that the trigger fired for.
+ Look at utils/rel.h for details about
+ this structure. The most interesting things are
+ tg_relation->rd_att (descriptor of the relation
+ tuples) and tg_relation->rd_rel->relname
+ (relation name; the type is not char* but
+ NameData; use
+ SPI_getrelname(tg_relation) to get a char* if you
+ need a copy of the name).
+
tg_trigtuple
+ A pointer to the row for which the trigger was fired. This is
+ the row being inserted, updated, or deleted. If this trigger
+ was fired for an INSERT or
+ DELETE then this is what you should return
+ from the function if you don't want to replace the row with
+ a different one (in the case of INSERT) or
+ skip the operation. For triggers on foreign tables, values of system
+ columns herein are unspecified.
+
tg_newtuple
+ A pointer to the new version of the row, if the trigger was
+ fired for an UPDATE, and NULL if
+ it is for an INSERT or a
+ DELETE. This is what you have to return
+ from the function if the event is an UPDATE
+ and you don't want to replace this row by a different one or
+ skip the operation. For triggers on foreign tables, values of system
+ columns herein are unspecified.
+
tg_trigger
+ A pointer to a structure of type Trigger,
+ defined in utils/reltrigger.h:
+
+
+typedef struct Trigger
+{
+ Oid tgoid;
+ char *tgname;
+ Oid tgfoid;
+ int16 tgtype;
+ char tgenabled;
+ bool tgisinternal;
+ bool tgisclone;
+ Oid tgconstrrelid;
+ Oid tgconstrindid;
+ Oid tgconstraint;
+ bool tgdeferrable;
+ bool tginitdeferred;
+ int16 tgnargs;
+ int16 tgnattr;
+ int16 *tgattr;
+ char **tgargs;
+ char *tgqual;
+ char *tgoldtable;
+ char *tgnewtable;
+} Trigger;
+
+
+ where tgname is the trigger's name,
+ tgnargs is the number of arguments in
+ tgargs, and tgargs is an array of
+ pointers to the arguments specified in the CREATE
+ TRIGGER statement. The other members are for internal use
+ only.
+
tg_trigslot
+ The slot containing tg_trigtuple,
+ or a NULL pointer if there is no such tuple.
+
tg_newslot
+ The slot containing tg_newtuple,
+ or a NULL pointer if there is no such tuple.
+
tg_oldtable
+ A pointer to a structure of type Tuplestorestate
+ containing zero or more rows in the format specified by
+ tg_relation, or a NULL pointer
+ if there is no OLD TABLE transition relation.
+
tg_newtable
+ A pointer to a structure of type Tuplestorestate
+ containing zero or more rows in the format specified by
+ tg_relation, or a NULL pointer
+ if there is no NEW TABLE transition relation.
+
tg_updatedcols
+ For UPDATE triggers, a bitmap set indicating the
+ columns that were updated by the triggering command. Generic trigger
+ functions can use this to optimize actions by not having to deal with
+ columns that were not changed.
+
+ As an example, to determine whether a column with attribute number
+ attnum (1-based) is a member of this bitmap set,
+ call bms_is_member(attnum -
+ FirstLowInvalidHeapAttributeNumber,
+ trigdata->tg_updatedcols)).
+
+ For triggers other than UPDATE triggers, this will
+ be NULL.
+
+
+ To allow queries issued through SPI to reference transition tables, see
+ SPI_register_trigger_data.
+
+ A trigger function must return either a
+ HeapTuple pointer or a NULL pointer
+ (not an SQL null value, that is, do not set isNull true).
+ Be careful to return either
+ tg_trigtuple or tg_newtuple,
+ as appropriate, if you don't want to modify the row being operated on.
+
+ This chapter provides general information about writing trigger functions.
+ Trigger functions can be written in most of the available procedural
+ languages, including
+ PL/pgSQL (Chapter 43),
+ PL/Tcl (Chapter 44),
+ PL/Perl (Chapter 45), and
+ PL/Python (Chapter 46).
+ After reading this chapter, you should consult the chapter for
+ your favorite procedural language to find out the language-specific
+ details of writing a trigger in it.
+
+ It is also possible to write a trigger function in C, although
+ most people find it easier to use one of the procedural languages.
+ It is not currently possible to write a trigger function in the
+ plain SQL function language.
+
F.46. tsm_system_rows —
+ the SYSTEM_ROWS sampling method for TABLESAMPLE #
+ The tsm_system_rows module provides the table sampling method
+ SYSTEM_ROWS, which can be used in
+ the TABLESAMPLE clause of a SELECT
+ command.
+
+ This table sampling method accepts a single integer argument that is the
+ maximum number of rows to read. The resulting sample will always contain
+ exactly that many rows, unless the table does not contain enough rows, in
+ which case the whole table is selected.
+
+ Like the built-in SYSTEM sampling
+ method, SYSTEM_ROWS performs block-level sampling, so
+ that the sample is not completely random but may be subject to clustering
+ effects, especially if only a small number of rows are requested.
+
+ SYSTEM_ROWS does not support
+ the REPEATABLE clause.
+
+ This module is considered “trusted”, that is, it can be
+ installed by non-superusers who have CREATE privilege
+ on the current database.
+
+ Here is an example of selecting a sample of a table with
+ SYSTEM_ROWS. First install the extension:
+
+CREATE EXTENSION tsm_system_rows;
+
+ Then you can use it in a SELECT command, for instance:
+
+
+SELECT * FROM my_table TABLESAMPLE SYSTEM_ROWS(100);
+
+
+ This command will return a sample of 100 rows from the
+ table my_table (unless the table does not have 100
+ visible rows, in which case all its rows are returned).
+
F.47. tsm_system_time —
+ the SYSTEM_TIME sampling method for TABLESAMPLE #
+ The tsm_system_time module provides the table sampling method
+ SYSTEM_TIME, which can be used in
+ the TABLESAMPLE clause of a SELECT
+ command.
+
+ This table sampling method accepts a single floating-point argument that
+ is the maximum number of milliseconds to spend reading the table. This
+ gives you direct control over how long the query takes, at the price that
+ the size of the sample becomes hard to predict. The resulting sample will
+ contain as many rows as could be read in the specified time, unless the
+ whole table has been read first.
+
+ Like the built-in SYSTEM sampling
+ method, SYSTEM_TIME performs block-level sampling, so
+ that the sample is not completely random but may be subject to clustering
+ effects, especially if only a small number of rows are selected.
+
+ SYSTEM_TIME does not support
+ the REPEATABLE clause.
+
+ This module is considered “trusted”, that is, it can be
+ installed by non-superusers who have CREATE privilege
+ on the current database.
+
+ Here is an example of selecting a sample of a table with
+ SYSTEM_TIME. First install the extension:
+
+CREATE EXTENSION tsm_system_time;
+
+ Then you can use it in a SELECT command, for instance:
+
+
+SELECT * FROM my_table TABLESAMPLE SYSTEM_TIME(1000);
+
+
+ This command will return as large a sample of my_table as
+ it can read in 1 second (1000 milliseconds). Of course, if the whole
+ table can be read in under 1 second, all its rows will be returned.
+
1.4. Accessing a Database #
+ Once you have created a database, you can access it by:
+
+
+ Running the PostgreSQL interactive
+ terminal program, called psql, which allows you
+ to interactively enter, edit, and execute
+ SQL commands.
+
+ Using an existing graphical frontend tool like
+ pgAdmin or an office suite with
+ ODBC or JDBC support to create and manipulate a
+ database. These possibilities are not covered in this
+ tutorial.
+
+ Writing a custom application, using one of the several
+ available language bindings. These possibilities are discussed
+ further in Part IV.
+
+
+ You probably want to start up psql to try
+ the examples in this tutorial. It can be activated for the
+ mydb database by typing the command:
+
+$ psql mydb
+
+ If you do not supply the database name then it will default to your
+ user account name. You already discovered this scheme in the
+ previous section using createdb.
+
+ In psql, you will be greeted with the following
+ message:
+
+psql (16.3)
+Type "help" for help.
+
+mydb=>
+
+
+ The last line could also be:
+
+mydb=#
+
+ That would mean you are a database superuser, which is most likely
+ the case if you installed the PostgreSQL instance
+ yourself. Being a superuser means that you are not subject to
+ access controls. For the purposes of this tutorial that is not
+ important.
+
+ If you encounter problems starting psql
+ then go back to the previous section. The diagnostics of
+ createdb and psql are
+ similar, and if the former worked the latter should work as well.
+
+ The last line printed out by psql is the
+ prompt, and it indicates that psql is listening
+ to you and that you can type SQL queries into a
+ work space maintained by psql. Try out these
+ commands:
+
+
+mydb=> SELECT version();
+ version
+------------------------------------------------------------------------------------------
+ PostgreSQL 16.3 on x86_64-pc-linux-gnu, compiled by gcc (Debian 4.9.2-10) 4.9.2, 64-bit
+(1 row)
+
+mydb=> SELECT current_date;
+ date
+------------
+ 2016-01-07
+(1 row)
+
+mydb=> SELECT 2 + 2;
+ ?column?
+----------
+ 4
+(1 row)
+
+
+ The psql program has a number of internal
+ commands that are not SQL commands. They begin with the backslash
+ character, “\”.
+ For example,
+ you can get help on the syntax of various
+ PostgreSQL SQL
+ commands by typing:
+
+mydb=> \h
+
+
+ To get out of psql, type:
+
+mydb=> \q
+
+ and psql will quit and return you to your
+ command shell. (For more internal commands, type
+ \? at the psql prompt.) The
+ full capabilities of psql are documented in
+ psql. In this tutorial we will not use these
+ features explicitly, but you can use them yourself when it is helpful.
+
+ In the previous chapter we have covered the basics of using
+ SQL to store and access your data in
+ PostgreSQL. We will now discuss some
+ more advanced features of SQL that simplify
+ management and prevent loss or corruption of your data. Finally,
+ we will look at some PostgreSQL
+ extensions.
+
+ This chapter will on occasion refer to examples found in Chapter 2 to change or improve them, so it will be
+ useful to have read that chapter. Some examples from
+ this chapter can also be found in
+ advanced.sql in the tutorial directory. This
+ file also contains some sample data to load, which is not
+ repeated here. (Refer to Section 2.1 for
+ how to use the file.)
+
Chapter 3. Advanced Features
2.7. Aggregate Functions #
+ Like most other relational database products,
+ PostgreSQL supports
+ aggregate functions.
+ An aggregate function computes a single result from multiple input rows.
+ For example, there are aggregates to compute the
+ count, sum,
+ avg (average), max (maximum) and
+ min (minimum) over a set of rows.
+
+ As an example, we can find the highest low-temperature reading anywhere
+ with:
+
+
+SELECT max(temp_lo) FROM weather;
+
+
+
+ max
+-----
+ 46
+(1 row)
+
+
+
+
+ If we wanted to know what city (or cities) that reading occurred in,
+ we might try:
+
+
+SELECT city FROM weather WHERE temp_lo = max(temp_lo); WRONG
+
+
+ but this will not work since the aggregate
+ max cannot be used in the
+ WHERE clause. (This restriction exists because
+ the WHERE clause determines which rows will be
+ included in the aggregate calculation; so obviously it has to be evaluated
+ before aggregate functions are computed.)
+ However, as is often the case
+ the query can be restated to accomplish the desired result, here
+ by using a subquery:
+
+
+SELECT city FROM weather
+ WHERE temp_lo = (SELECT max(temp_lo) FROM weather);
+
+
+
+ city
+---------------
+ San Francisco
+(1 row)
+
+
+ This is OK because the subquery is an independent computation
+ that computes its own aggregate separately from what is happening
+ in the outer query.
+
+
+
+
+ Aggregates are also very useful in combination with GROUP
+ BY clauses. For example, we can get the number of readings
+ and the maximum low temperature observed in each city with:
+
+
+SELECT city, count(*), max(temp_lo)
+ FROM weather
+ GROUP BY city;
+
+
+
+ city | count | max
+---------------+-------+-----
+ Hayward | 1 | 37
+ San Francisco | 2 | 46
+(2 rows)
+
+
+ which gives us one output row per city. Each aggregate result is
+ computed over the table rows matching that city.
+ We can filter these grouped
+ rows using HAVING:
+
+
+SELECT city, count(*), max(temp_lo)
+ FROM weather
+ GROUP BY city
+ HAVING max(temp_lo) < 40;
+
+
+
+ city | count | max
+---------+-------+-----
+ Hayward | 1 | 37
+(1 row)
+
+
+ which gives us the same results for only the cities that have all
+ temp_lo values below 40. Finally, if we only care about
+ cities whose
+ names begin with “S”, we might do:
+
+
+SELECT city, count(*), max(temp_lo)
+ FROM weather
+ WHERE city LIKE 'S%' -- (1)
+ GROUP BY city;
+
+
+
+ city | count | max
+---------------+-------+-----
+ San Francisco | 2 | 46
+(1 row)
+
+
(1) |
+ The LIKE operator does pattern matching and
+ is explained in Section 9.7.
+ |
+
+ It is important to understand the interaction between aggregates and
+ SQL's WHERE and HAVING clauses.
+ The fundamental difference between WHERE and
+ HAVING is this: WHERE selects
+ input rows before groups and aggregates are computed (thus, it controls
+ which rows go into the aggregate computation), whereas
+ HAVING selects group rows after groups and
+ aggregates are computed. Thus, the
+ WHERE clause must not contain aggregate functions;
+ it makes no sense to try to use an aggregate to determine which rows
+ will be inputs to the aggregates. On the other hand, the
+ HAVING clause always contains aggregate functions.
+ (Strictly speaking, you are allowed to write a HAVING
+ clause that doesn't use aggregates, but it's seldom useful. The same
+ condition could be used more efficiently at the WHERE
+ stage.)
+
+ In the previous example, we can apply the city name restriction in
+ WHERE, since it needs no aggregate. This is
+ more efficient than adding the restriction to HAVING,
+ because we avoid doing the grouping and aggregate calculations
+ for all rows that fail the WHERE check.
+
+ Another way to select the rows that go into an aggregate
+ computation is to use FILTER, which is a
+ per-aggregate option:
+
+
+SELECT city, count(*) FILTER (WHERE temp_lo < 45), max(temp_lo)
+ FROM weather
+ GROUP BY city;
+
+
+
+ city | count | max
+---------------+-------+-----
+ Hayward | 1 | 37
+ San Francisco | 1 | 46
+(2 rows)
+
+
+ FILTER is much like WHERE,
+ except that it removes rows only from the input of the particular
+ aggregate function that it is attached to.
+ Here, the count aggregate counts only
+ rows with temp_lo below 45; but the
+ max aggregate is still applied to all rows,
+ so it still finds the reading of 46.
+
1.2. Architectural Fundamentals #
+ Before we proceed, you should understand the basic
+ PostgreSQL system architecture.
+ Understanding how the parts of
+ PostgreSQL interact will make this
+ chapter somewhat clearer.
+
+ In database jargon, PostgreSQL uses a
+ client/server model. A PostgreSQL
+ session consists of the following cooperating processes
+ (programs):
+
+
+ A server process, which manages the database files, accepts
+ connections to the database from client applications, and
+ performs database actions on behalf of the clients. The
+ database server program is called
+ postgres.
+
+
+ The user's client (frontend) application that wants to perform
+ database operations. Client applications can be very diverse
+ in nature: a client could be a text-oriented tool, a graphical
+ application, a web server that accesses the database to
+ display web pages, or a specialized database maintenance tool.
+ Some client applications are supplied with the
+ PostgreSQL distribution; most are
+ developed by users.
+
+
+ As is typical of client/server applications, the client and the
+ server can be on different hosts. In that case they communicate
+ over a TCP/IP network connection. You should keep this in mind,
+ because the files that can be accessed on a client machine might
+ not be accessible (or might only be accessible using a different
+ file name) on the database server machine.
+
+ The PostgreSQL server can handle
+ multiple concurrent connections from clients. To achieve this it
+ starts (“forks”) a new process for each connection.
+ From that point on, the client and the new server process
+ communicate without intervention by the original
+ postgres process. Thus, the
+ supervisor server process is always running, waiting for
+ client connections, whereas client and associated server processes
+ come and go. (All of this is of course invisible to the user. We
+ only mention it here for completeness.)
+
+
+
+
+
+
+
+ PostgreSQL is a relational
+ database management system (RDBMS).
+ That means it is a system for managing data stored in
+ relations. Relation is essentially a
+ mathematical term for table. The notion of
+ storing data in tables is so commonplace today that it might
+ seem inherently obvious, but there are a number of other ways of
+ organizing databases. Files and directories on Unix-like
+ operating systems form an example of a hierarchical database. A
+ more modern development is the object-oriented database.
+
+
+
+
+ Each table is a named collection of rows.
+ Each row of a given table has the same set of named
+ columns,
+ and each column is of a specific data type. Whereas columns have
+ a fixed order in each row, it is important to remember that SQL
+ does not guarantee the order of the rows within the table in any
+ way (although they can be explicitly sorted for display).
+
+
+
+
+ Tables are grouped into databases, and a collection of databases
+ managed by a single PostgreSQL server
+ instance constitutes a database cluster.
+
+ PostgreSQL has many features not
+ touched upon in this tutorial introduction, which has been
+ oriented toward newer users of SQL. These
+ features are discussed in more detail in the remainder of this
+ book.
+
+ If you feel you need more introductory material, please visit the PostgreSQL
+ web site
+ for links to more resources.
+
1.3. Creating a Database #
+ The first test to see whether you can access the database server
+ is to try to create a database. A running
+ PostgreSQL server can manage many
+ databases. Typically, a separate database is used for each
+ project or for each user.
+
+ Possibly, your site administrator has already created a database
+ for your use. In that case you can omit this step and skip ahead
+ to the next section.
+
+ To create a new database, in this example named
+ mydb, you use the following command:
+
+$ createdb mydb
+
+ If this produces no response then this step was successful and you can skip over the
+ remainder of this section.
+
+ If you see a message similar to:
+
+createdb: command not found
+
+ then PostgreSQL was not installed properly. Either it was not
+ installed at all or your shell's search path was not set to include it.
+ Try calling the command with an absolute path instead:
+
+$ /usr/local/pgsql/bin/createdb mydb
+
+ The path at your site might be different. Contact your site
+ administrator or check the installation instructions to
+ correct the situation.
+
+ Another response could be this:
+
+createdb: error: connection to server on socket "/tmp/.s.PGSQL.5432" failed: No such file or directory
+ Is the server running locally and accepting connections on that socket?
+
+ This means that the server was not started, or it is not listening
+ where createdb expects to contact it. Again, check the
+ installation instructions or consult the administrator.
+
+ Another response could be this:
+
+createdb: error: connection to server on socket "/tmp/.s.PGSQL.5432" failed: FATAL: role "joe" does not exist
+
+ where your own login name is mentioned. This will happen if the
+ administrator has not created a PostgreSQL user account
+ for you. (PostgreSQL user accounts are distinct from
+ operating system user accounts.) If you are the administrator, see
+ Chapter 22 for help creating accounts. You will need to
+ become the operating system user under which PostgreSQL
+ was installed (usually postgres) to create the first user
+ account. It could also be that you were assigned a
+ PostgreSQL user name that is different from your
+ operating system user name; in that case you need to use the -U
+ switch or set the PGUSER environment variable to specify your
+ PostgreSQL user name.
+
+ If you have a user account but it does not have the privileges required to
+ create a database, you will see the following:
+
+createdb: error: database creation failed: ERROR: permission denied to create database
+
+ Not every user has authorization to create new databases. If
+ PostgreSQL refuses to create databases
+ for you then the site administrator needs to grant you permission
+ to create databases. Consult your site administrator if this
+ occurs. If you installed PostgreSQL
+ yourself then you should log in for the purposes of this tutorial
+ under the user account that you started the server as.
+
+
+
+ You can also create databases with other names.
+ PostgreSQL allows you to create any
+ number of databases at a given site. Database names must have an
+ alphabetic first character and are limited to 63 bytes in
+ length. A convenient choice is to create a database with the same
+ name as your current user name. Many tools assume that database
+ name as the default, so it can save you some typing. To create
+ that database, simply type:
+
+$ createdb
+
+
+ If you do not want to use your database anymore you can remove it.
+ For example, if you are the owner (creator) of the database
+ mydb, you can destroy it using the following
+ command:
+
+$ dropdb mydb
+
+ (For this command, the database name does not default to the user
+ account name. You always need to specify it.) This action
+ physically removes all files associated with the database and
+ cannot be undone, so this should only be done with a great deal of
+ forethought.
+
+ More about createdb and dropdb can
+ be found in createdb and dropdb
+ respectively.
+
+ Rows can be removed from a table using the DELETE
+ command.
+ Suppose you are no longer interested in the weather of Hayward.
+ Then you can do the following to delete those rows from the table:
+
+DELETE FROM weather WHERE city = 'Hayward';
+
+
+ All weather records belonging to Hayward are removed.
+
+
+SELECT * FROM weather;
+
+
+
+ city | temp_lo | temp_hi | prcp | date
+---------------+---------+---------+------+------------
+ San Francisco | 46 | 50 | 0.25 | 1994-11-27
+ San Francisco | 41 | 55 | 0 | 1994-11-29
+(2 rows)
+
+
+ One should be wary of statements of the form
+
+DELETE FROM tablename;
+
+
+ Without a qualification, DELETE will
+ remove all rows from the given table, leaving it
+ empty. The system will not request confirmation before
+ doing this!
+
+ Recall the weather and
+ cities tables from Chapter 2. Consider the following problem: You
+ want to make sure that no one can insert rows in the
+ weather table that do not have a matching
+ entry in the cities table. This is called
+ maintaining the referential integrity of
+ your data. In simplistic database systems this would be
+ implemented (if at all) by first looking at the
+ cities table to check if a matching record
+ exists, and then inserting or rejecting the new
+ weather records. This approach has a
+ number of problems and is very inconvenient, so
+ PostgreSQL can do this for you.
+
+ The new declaration of the tables would look like this:
+
+
+CREATE TABLE cities (
+ name varchar(80) primary key,
+ location point
+);
+
+CREATE TABLE weather (
+ city varchar(80) references cities(name),
+ temp_lo int,
+ temp_hi int,
+ prcp real,
+ date date
+);
+
+
+ Now try inserting an invalid record:
+
+
+INSERT INTO weather VALUES ('Berkeley', 45, 53, 0.0, '1994-11-28');
+
+
+
+ERROR: insert or update on table "weather" violates foreign key constraint "weather_city_fkey"
+DETAIL: Key (city)=(Berkeley) is not present in table "cities".
+
+
+ The behavior of foreign keys can be finely tuned to your
+ application. We will not go beyond this simple example in this
+ tutorial, but just refer you to Chapter 5
+ for more information. Making correct use of
+ foreign keys will definitely improve the quality of your database
+ applications, so you are strongly encouraged to learn about them.
+
+ Inheritance is a concept from object-oriented databases. It opens
+ up interesting new possibilities of database design.
+
+ Let's create two tables: A table cities
+ and a table capitals. Naturally, capitals
+ are also cities, so you want some way to show the capitals
+ implicitly when you list all cities. If you're really clever you
+ might invent some scheme like this:
+
+
+CREATE TABLE capitals (
+ name text,
+ population real,
+ elevation int, -- (in ft)
+ state char(2)
+);
+
+CREATE TABLE non_capitals (
+ name text,
+ population real,
+ elevation int -- (in ft)
+);
+
+CREATE VIEW cities AS
+ SELECT name, population, elevation FROM capitals
+ UNION
+ SELECT name, population, elevation FROM non_capitals;
+
+
+ This works OK as far as querying goes, but it gets ugly when you
+ need to update several rows, for one thing.
+
+ A better solution is this:
+
+
+CREATE TABLE cities (
+ name text,
+ population real,
+ elevation int -- (in ft)
+);
+
+CREATE TABLE capitals (
+ state char(2) UNIQUE NOT NULL
+) INHERITS (cities);
+
+
+ In this case, a row of capitals
+ inherits all columns (name,
+ population, and elevation) from its
+ parent, cities. The
+ type of the column name is
+ text, a native PostgreSQL
+ type for variable length character strings. The
+ capitals table has
+ an additional column, state, which shows its
+ state abbreviation. In
+ PostgreSQL, a table can inherit from
+ zero or more other tables.
+
+ For example, the following query finds the names of all cities,
+ including state capitals, that are located at an elevation
+ over 500 feet:
+
+
+SELECT name, elevation
+ FROM cities
+ WHERE elevation > 500;
+
+
+ which returns:
+
+
+ name | elevation
+-----------+-----------
+ Las Vegas | 2174
+ Mariposa | 1953
+ Madison | 845
+(3 rows)
+
+
+ On the other hand, the following query finds
+ all the cities that are not state capitals and
+ are situated at an elevation over 500 feet:
+
+
+SELECT name, elevation
+ FROM ONLY cities
+ WHERE elevation > 500;
+
+
+
+ name | elevation
+-----------+-----------
+ Las Vegas | 2174
+ Mariposa | 1953
+(2 rows)
+
+
+ Here the ONLY before cities
+ indicates that the query should be run over only the
+ cities table, and not tables below
+ cities in the inheritance hierarchy. Many
+ of the commands that we have already discussed —
+ SELECT, UPDATE, and
+ DELETE — support this ONLY
+ notation.
+
Note
+ Although inheritance is frequently useful, it has not been integrated
+ with unique constraints or foreign keys, which limits its usefulness.
+ See Section 5.10 for more detail.
+
+ Before you can use PostgreSQL you need
+ to install it, of course. It is possible that
+ PostgreSQL is already installed at your
+ site, either because it was included in your operating system
+ distribution or because the system administrator already installed
+ it. If that is the case, you should obtain information from the
+ operating system documentation or your system administrator about
+ how to access PostgreSQL.
+
+ If you are not sure whether PostgreSQL
+ is already available or whether you can use it for your
+ experimentation then you can install it yourself. Doing so is not
+ hard and it can be a good exercise.
+ PostgreSQL can be installed by any
+ unprivileged user; no superuser (root)
+ access is required.
+
+ If you are installing PostgreSQL
+ yourself, then refer to Chapter 17
+ for instructions on installation, and return to
+ this guide when the installation is complete. Be sure to follow
+ closely the section about setting up the appropriate environment
+ variables.
+
+ If your site administrator has not set things up in the default
+ way, you might have some more work to do. For example, if the
+ database server machine is a remote machine, you will need to set
+ the PGHOST environment variable to the name of the
+ database server machine. The environment variable
+ PGPORT might also have to be set. The bottom line is
+ this: if you try to start an application program and it complains
+ that it cannot connect to the database, you should consult your
+ site administrator or, if that is you, the documentation to make
+ sure that your environment is properly set up. If you did not
+ understand the preceding paragraph then read the next section.
+
2.6. Joins Between Tables #
+ Thus far, our queries have only accessed one table at a time.
+ Queries can access multiple tables at once, or access the same
+ table in such a way that multiple rows of the table are being
+ processed at the same time. Queries that access multiple tables
+ (or multiple instances of the same table) at one time are called
+ join queries. They combine rows from one table
+ with rows from a second table, with an expression specifying which rows
+ are to be paired. For example, to return all the weather records together
+ with the location of the associated city, the database needs to compare
+ the city
+ column of each row of the weather table with the
+ name column of all rows in the cities
+ table, and select the pairs of rows where these values match.
+ This would be accomplished by the following query:
+
+
+SELECT * FROM weather JOIN cities ON city = name;
+
+
+
+ city | temp_lo | temp_hi | prcp | date | name | location
+---------------+---------+---------+------+------------+---------------+-----------
+ San Francisco | 46 | 50 | 0.25 | 1994-11-27 | San Francisco | (-194,53)
+ San Francisco | 43 | 57 | 0 | 1994-11-29 | San Francisco | (-194,53)
+(2 rows)
+
+
+
+ Observe two things about the result set:
+
+ There is no result row for the city of Hayward. This is
+ because there is no matching entry in the
+ cities table for Hayward, so the join
+ ignores the unmatched rows in the weather table. We will see
+ shortly how this can be fixed.
+
+ There are two columns containing the city name. This is
+ correct because the lists of columns from the
+ weather and
+ cities tables are concatenated. In
+ practice this is undesirable, though, so you will probably want
+ to list the output columns explicitly rather than using
+ *:
+
+SELECT city, temp_lo, temp_hi, prcp, date, location
+ FROM weather JOIN cities ON city = name;
+
+
+
+ Since the columns all had different names, the parser
+ automatically found which table they belong to. If there
+ were duplicate column names in the two tables you'd need to
+ qualify the column names to show which one you
+ meant, as in:
+
+
+SELECT weather.city, weather.temp_lo, weather.temp_hi,
+ weather.prcp, weather.date, cities.location
+ FROM weather JOIN cities ON weather.city = cities.name;
+
+
+ It is widely considered good style to qualify all column names
+ in a join query, so that the query won't fail if a duplicate
+ column name is later added to one of the tables.
+
+ Join queries of the kind seen thus far can also be written in this
+ form:
+
+
+SELECT *
+ FROM weather, cities
+ WHERE city = name;
+
+
+ This syntax pre-dates the JOIN/ON
+ syntax, which was introduced in SQL-92. The tables are simply listed in
+ the FROM clause, and the comparison expression is added
+ to the WHERE clause. The results from this older
+ implicit syntax and the newer explicit
+ JOIN/ON syntax are identical. But
+ for a reader of the query, the explicit syntax makes its meaning easier to
+ understand: The join condition is introduced by its own key word whereas
+ previously the condition was mixed into the WHERE
+ clause together with other conditions.
+
+ Now we will figure out how we can get the Hayward records back in.
+ What we want the query to do is to scan the
+ weather table and for each row to find the
+ matching cities row(s). If no matching row is
+ found we want some “empty values” to be substituted
+ for the cities table's columns. This kind
+ of query is called an outer join. (The
+ joins we have seen so far are inner joins.)
+ The command looks like this:
+
+
+SELECT *
+ FROM weather LEFT OUTER JOIN cities ON weather.city = cities.name;
+
+
+
+ city | temp_lo | temp_hi | prcp | date | name | location
+---------------+---------+---------+------+------------+---------------+-----------
+ Hayward | 37 | 54 | | 1994-11-29 | |
+ San Francisco | 46 | 50 | 0.25 | 1994-11-27 | San Francisco | (-194,53)
+ San Francisco | 43 | 57 | 0 | 1994-11-29 | San Francisco | (-194,53)
+(3 rows)
+
+
+ This query is called a left outer
+ join because the table mentioned on the left of the
+ join operator will have each of its rows in the output at least
+ once, whereas the table on the right will only have those rows
+ output that match some row of the left table. When outputting a
+ left-table row for which there is no right-table match, empty (null)
+ values are substituted for the right-table columns.
+
Exercise:
+ There are also right outer joins and full outer joins. Try to
+ find out what those do.
+
+ We can also join a table against itself. This is called a
+ self join. As an example, suppose we wish
+ to find all the weather records that are in the temperature range
+ of other weather records. So we need to compare the
+ temp_lo and temp_hi columns of
+ each weather row to the
+ temp_lo and
+ temp_hi columns of all other
+ weather rows. We can do this with the
+ following query:
+
+
+SELECT w1.city, w1.temp_lo AS low, w1.temp_hi AS high,
+ w2.city, w2.temp_lo AS low, w2.temp_hi AS high
+ FROM weather w1 JOIN weather w2
+ ON w1.temp_lo < w2.temp_lo AND w1.temp_hi > w2.temp_hi;
+
+
+
+ city | low | high | city | low | high
+---------------+-----+------+---------------+-----+------
+ San Francisco | 43 | 57 | San Francisco | 46 | 50
+ Hayward | 37 | 54 | San Francisco | 46 | 50
+(2 rows)
+
+
+ Here we have relabeled the weather table as w1 and
+ w2 to be able to distinguish the left and right side
+ of the join. You can also use these kinds of aliases in other
+ queries to save some typing, e.g.:
+
+SELECT *
+ FROM weather w JOIN cities c ON w.city = c.name;
+
+ You will encounter this style of abbreviating quite frequently.
+
2.4. Populating a Table With Rows #
+ The INSERT statement is used to populate a table with
+ rows:
+
+
+INSERT INTO weather VALUES ('San Francisco', 46, 50, 0.25, '1994-11-27');
+
+
+ Note that all data types use rather obvious input formats.
+ Constants that are not simple numeric values usually must be
+ surrounded by single quotes ('), as in the example.
+ The
+ date type is actually quite flexible in what it
+ accepts, but for this tutorial we will stick to the unambiguous
+ format shown here.
+
+ The point type requires a coordinate pair as input,
+ as shown here:
+
+INSERT INTO cities VALUES ('San Francisco', '(-194.0, 53.0)');
+
+
+ The syntax used so far requires you to remember the order of the
+ columns. An alternative syntax allows you to list the columns
+ explicitly:
+
+INSERT INTO weather (city, temp_lo, temp_hi, prcp, date)
+ VALUES ('San Francisco', 43, 57, 0.0, '1994-11-29');
+
+ You can list the columns in a different order if you wish or
+ even omit some columns, e.g., if the precipitation is unknown:
+
+INSERT INTO weather (date, city, temp_hi, temp_lo)
+ VALUES ('1994-11-29', 'Hayward', 54, 37);
+
+ Many developers consider explicitly listing the columns better
+ style than relying on the order implicitly.
+
+ Please enter all the commands shown above so you have some data to
+ work with in the following sections.
+
+
+
+ You could also have used COPY to load large
+ amounts of data from flat-text files. This is usually faster
+ because the COPY command is optimized for this
+ application while allowing less flexibility than
+ INSERT. An example would be:
+
+
+COPY weather FROM '/home/user/weather.txt';
+
+
+ where the file name for the source file must be available on the
+ machine running the backend process, not the client, since the backend process
+ reads the file directly. You can read more about the
+ COPY command in COPY.
+
+
+
+
+ To retrieve data from a table, the table is
+ queried. An SQL
+ SELECT statement is used to do this. The
+ statement is divided into a select list (the part that lists the
+ columns to be returned), a table list (the part that lists the
+ tables from which to retrieve the data), and an optional
+ qualification (the part that specifies any restrictions). For
+ example, to retrieve all the rows of table
+ weather, type:
+
+SELECT * FROM weather;
+
+ Here * is a shorthand for “all columns”.
+
+ So the same result would be had with:
+
+SELECT city, temp_lo, temp_hi, prcp, date FROM weather;
+
+
+ The output should be:
+
+
+ city | temp_lo | temp_hi | prcp | date
+---------------+---------+---------+------+------------
+ San Francisco | 46 | 50 | 0.25 | 1994-11-27
+ San Francisco | 43 | 57 | 0 | 1994-11-29
+ Hayward | 37 | 54 | | 1994-11-29
+(3 rows)
+
+
+ You can write expressions, not just simple column references, in the
+ select list. For example, you can do:
+
+SELECT city, (temp_hi+temp_lo)/2 AS temp_avg, date FROM weather;
+
+ This should give:
+
+ city | temp_avg | date
+---------------+----------+------------
+ San Francisco | 48 | 1994-11-27
+ San Francisco | 50 | 1994-11-29
+ Hayward | 45 | 1994-11-29
+(3 rows)
+
+ Notice how the AS clause is used to relabel the
+ output column. (The AS clause is optional.)
+
+ A query can be “qualified” by adding a WHERE
+ clause that specifies which rows are wanted. The WHERE
+ clause contains a Boolean (truth value) expression, and only rows for
+ which the Boolean expression is true are returned. The usual
+ Boolean operators (AND,
+ OR, and NOT) are allowed in
+ the qualification. For example, the following
+ retrieves the weather of San Francisco on rainy days:
+
+
+SELECT * FROM weather
+ WHERE city = 'San Francisco' AND prcp > 0.0;
+
+ Result:
+
+ city | temp_lo | temp_hi | prcp | date
+---------------+---------+---------+------+------------
+ San Francisco | 46 | 50 | 0.25 | 1994-11-27
+(1 row)
+
+
+
+
+ You can request that the results of a query
+ be returned in sorted order:
+
+
+SELECT * FROM weather
+ ORDER BY city;
+
+
+
+ city | temp_lo | temp_hi | prcp | date
+---------------+---------+---------+------+------------
+ Hayward | 37 | 54 | | 1994-11-29
+ San Francisco | 43 | 57 | 0 | 1994-11-29
+ San Francisco | 46 | 50 | 0.25 | 1994-11-27
+
+
+ In this example, the sort order isn't fully specified, and so you
+ might get the San Francisco rows in either order. But you'd always
+ get the results shown above if you do:
+
+
+SELECT * FROM weather
+ ORDER BY city, temp_lo;
+
+
+
+
+
+ You can request that duplicate rows be removed from the result of
+ a query:
+
+
+SELECT DISTINCT city
+ FROM weather;
+
+
+
+ city
+---------------
+ Hayward
+ San Francisco
+(2 rows)
+
+
+ Here again, the result row ordering might vary.
+ You can ensure consistent results by using DISTINCT and
+ ORDER BY together:
+
+
+
+SELECT DISTINCT city
+ FROM weather
+ ORDER BY city;
+
+
+ This chapter provides an overview of how to use
+ SQL to perform simple operations. This
+ tutorial is only intended to give you an introduction and is in no
+ way a complete tutorial on SQL. Numerous books
+ have been written on SQL, including [melt93] and [date97].
+ You should be aware that some PostgreSQL
+ language features are extensions to the standard.
+
+ In the examples that follow, we assume that you have created a
+ database named mydb, as described in the previous
+ chapter, and have been able to start psql.
+
+ Examples in this manual can also be found in the
+ PostgreSQL source distribution
+ in the directory src/tutorial/. (Binary
+ distributions of PostgreSQL might not
+ provide those files.) To use those
+ files, first change to that directory and run make:
+
+
+$ cd .../src/tutorial
+$ make
+
+
+ This creates the scripts and compiles the C files containing user-defined
+ functions and types. Then, to start the tutorial, do the following:
+
+
+$ psql -s mydb
+
+...
+
+mydb=> \i basics.sql
+
+
+ The \i command reads in commands from the
+ specified file. psql's -s option puts you in
+ single step mode which pauses before sending each statement to the
+ server. The commands used in this section are in the file
+ basics.sql.
+
Chapter 2. The SQL Language
Chapter 1. Getting Started
2.3. Creating a New Table #
+ You can create a new table by specifying the table
+ name, along with all column names and their types:
+
+
+CREATE TABLE weather (
+ city varchar(80),
+ temp_lo int, -- low temperature
+ temp_hi int, -- high temperature
+ prcp real, -- precipitation
+ date date
+);
+
+
+ You can enter this into psql with the line
+ breaks. psql will recognize that the command
+ is not terminated until the semicolon.
+
+ White space (i.e., spaces, tabs, and newlines) can be used freely
+ in SQL commands. That means you can type the command aligned
+ differently than above, or even all on one line. Two dashes
+ (“--”) introduce comments.
+ Whatever follows them is ignored up to the end of the line. SQL
+ is case-insensitive about key words and identifiers, except
+ when identifiers are double-quoted to preserve the case (not done
+ above).
+
+ varchar(80) specifies a data type that can store
+ arbitrary character strings up to 80 characters in length.
+ int is the normal integer type. real is
+ a type for storing single precision floating-point numbers.
+ date should be self-explanatory. (Yes, the column of
+ type date is also named date.
+ This might be convenient or confusing — you choose.)
+
+ PostgreSQL supports the standard
+ SQL types int,
+ smallint, real, double
+ precision, char(N),
+ varchar(N), date,
+ time, timestamp, and
+ interval, as well as other types of general utility
+ and a rich set of geometric types.
+ PostgreSQL can be customized with an
+ arbitrary number of user-defined data types. Consequently, type
+ names are not key words in the syntax, except where required to
+ support special cases in the SQL standard.
+
+ The second example will store cities and their associated
+ geographical location:
+
+CREATE TABLE cities (
+ name varchar(80),
+ location point
+);
+
+ The point type is an example of a
+ PostgreSQL-specific data type.
+
+
+
+ Finally, it should be mentioned that if you don't need a table any
+ longer or want to recreate it differently you can remove it using
+ the following command:
+
+DROP TABLE tablename;
+
+
+ Transactions are a fundamental concept of all database
+ systems. The essential point of a transaction is that it bundles
+ multiple steps into a single, all-or-nothing operation. The intermediate
+ states between the steps are not visible to other concurrent transactions,
+ and if some failure occurs that prevents the transaction from completing,
+ then none of the steps affect the database at all.
+
+ For example, consider a bank database that contains balances for various
+ customer accounts, as well as total deposit balances for branches.
+ Suppose that we want to record a payment of $100.00 from Alice's account
+ to Bob's account. Simplifying outrageously, the SQL commands for this
+ might look like:
+
+
+UPDATE accounts SET balance = balance - 100.00
+ WHERE name = 'Alice';
+UPDATE branches SET balance = balance - 100.00
+ WHERE name = (SELECT branch_name FROM accounts WHERE name = 'Alice');
+UPDATE accounts SET balance = balance + 100.00
+ WHERE name = 'Bob';
+UPDATE branches SET balance = balance + 100.00
+ WHERE name = (SELECT branch_name FROM accounts WHERE name = 'Bob');
+
+
+ The details of these commands are not important here; the important
+ point is that there are several separate updates involved to accomplish
+ this rather simple operation. Our bank's officers will want to be
+ assured that either all these updates happen, or none of them happen.
+ It would certainly not do for a system failure to result in Bob
+ receiving $100.00 that was not debited from Alice. Nor would Alice long
+ remain a happy customer if she was debited without Bob being credited.
+ We need a guarantee that if something goes wrong partway through the
+ operation, none of the steps executed so far will take effect. Grouping
+ the updates into a transaction gives us this guarantee.
+ A transaction is said to be atomic: from the point of
+ view of other transactions, it either happens completely or not at all.
+
+ We also want a
+ guarantee that once a transaction is completed and acknowledged by
+ the database system, it has indeed been permanently recorded
+ and won't be lost even if a crash ensues shortly thereafter.
+ For example, if we are recording a cash withdrawal by Bob,
+ we do not want any chance that the debit to his account will
+ disappear in a crash just after he walks out the bank door.
+ A transactional database guarantees that all the updates made by
+ a transaction are logged in permanent storage (i.e., on disk) before
+ the transaction is reported complete.
+
+ Another important property of transactional databases is closely
+ related to the notion of atomic updates: when multiple transactions
+ are running concurrently, each one should not be able to see the
+ incomplete changes made by others. For example, if one transaction
+ is busy totalling all the branch balances, it would not do for it
+ to include the debit from Alice's branch but not the credit to
+ Bob's branch, nor vice versa. So transactions must be all-or-nothing
+ not only in terms of their permanent effect on the database, but
+ also in terms of their visibility as they happen. The updates made
+ so far by an open transaction are invisible to other transactions
+ until the transaction completes, whereupon all the updates become
+ visible simultaneously.
+
+ In PostgreSQL, a transaction is set up by surrounding
+ the SQL commands of the transaction with
+ BEGIN and COMMIT commands. So our banking
+ transaction would actually look like:
+
+
+BEGIN;
+UPDATE accounts SET balance = balance - 100.00
+ WHERE name = 'Alice';
+-- etc etc
+COMMIT;
+
+
+ If, partway through the transaction, we decide we do not want to
+ commit (perhaps we just noticed that Alice's balance went negative),
+ we can issue the command ROLLBACK instead of
+ COMMIT, and all our updates so far will be canceled.
+
+ PostgreSQL actually treats every SQL statement as being
+ executed within a transaction. If you do not issue a BEGIN
+ command,
+ then each individual statement has an implicit BEGIN and
+ (if successful) COMMIT wrapped around it. A group of
+ statements surrounded by BEGIN and COMMIT
+ is sometimes called a transaction block.
+
Note
+ Some client libraries issue BEGIN and COMMIT
+ commands automatically, so that you might get the effect of transaction
+ blocks without asking. Check the documentation for the interface
+ you are using.
+
+ It's possible to control the statements in a transaction in a more
+ granular fashion through the use of savepoints. Savepoints
+ allow you to selectively discard parts of the transaction, while
+ committing the rest. After defining a savepoint with
+ SAVEPOINT, you can if needed roll back to the savepoint
+ with ROLLBACK TO. All the transaction's database changes
+ between defining the savepoint and rolling back to it are discarded, but
+ changes earlier than the savepoint are kept.
+
+ After rolling back to a savepoint, it continues to be defined, so you can
+ roll back to it several times. Conversely, if you are sure you won't need
+ to roll back to a particular savepoint again, it can be released, so the
+ system can free some resources. Keep in mind that either releasing or
+ rolling back to a savepoint
+ will automatically release all savepoints that were defined after it.
+
+ All this is happening within the transaction block, so none of it
+ is visible to other database sessions. When and if you commit the
+ transaction block, the committed actions become visible as a unit
+ to other sessions, while the rolled-back actions never become visible
+ at all.
+
+ Remembering the bank database, suppose we debit $100.00 from Alice's
+ account, and credit Bob's account, only to find later that we should
+ have credited Wally's account. We could do it using savepoints like
+ this:
+
+
+BEGIN;
+UPDATE accounts SET balance = balance - 100.00
+ WHERE name = 'Alice';
+SAVEPOINT my_savepoint;
+UPDATE accounts SET balance = balance + 100.00
+ WHERE name = 'Bob';
+-- oops ... forget that and use Wally's account
+ROLLBACK TO my_savepoint;
+UPDATE accounts SET balance = balance + 100.00
+ WHERE name = 'Wally';
+COMMIT;
+
+
+ This example is, of course, oversimplified, but there's a lot of control
+ possible in a transaction block through the use of savepoints.
+ Moreover, ROLLBACK TO is the only way to regain control of a
+ transaction block that was put in aborted state by the
+ system due to an error, short of rolling it back completely and starting
+ again.
+
+ You can update existing rows using the
+ UPDATE command.
+ Suppose you discover the temperature readings are
+ all off by 2 degrees after November 28. You can correct the
+ data as follows:
+
+
+UPDATE weather
+ SET temp_hi = temp_hi - 2, temp_lo = temp_lo - 2
+ WHERE date > '1994-11-28';
+
+
+ Look at the new state of the data:
+
+SELECT * FROM weather;
+
+ city | temp_lo | temp_hi | prcp | date
+---------------+---------+---------+------+------------
+ San Francisco | 46 | 50 | 0.25 | 1994-11-27
+ San Francisco | 41 | 55 | 0 | 1994-11-29
+ Hayward | 35 | 52 | | 1994-11-29
+(3 rows)
+
+
+ Refer back to the queries in Section 2.6.
+ Suppose the combined listing of weather records and city location
+ is of particular interest to your application, but you do not want
+ to type the query each time you need it. You can create a
+ view over the query, which gives a name to
+ the query that you can refer to like an ordinary table:
+
+
+CREATE VIEW myview AS
+ SELECT name, temp_lo, temp_hi, prcp, date, location
+ FROM weather, cities
+ WHERE city = name;
+
+SELECT * FROM myview;
+
+
+ Making liberal use of views is a key aspect of good SQL database
+ design. Views allow you to encapsulate the details of the
+ structure of your tables, which might change as your application
+ evolves, behind consistent interfaces.
+
+ Views can be used in almost any place a real table can be used.
+ Building views upon other views is not uncommon.
+
+ A window function performs a calculation across a set of
+ table rows that are somehow related to the current row. This is comparable
+ to the type of calculation that can be done with an aggregate function.
+ However, window functions do not cause rows to become grouped into a single
+ output row like non-window aggregate calls would. Instead, the
+ rows retain their separate identities. Behind the scenes, the window
+ function is able to access more than just the current row of the query
+ result.
+
+ Here is an example that shows how to compare each employee's salary
+ with the average salary in his or her department:
+
+
+SELECT depname, empno, salary, avg(salary) OVER (PARTITION BY depname) FROM empsalary;
+
+
+
+ depname | empno | salary | avg
+-----------+-------+--------+-----------------------
+ develop | 11 | 5200 | 5020.0000000000000000
+ develop | 7 | 4200 | 5020.0000000000000000
+ develop | 9 | 4500 | 5020.0000000000000000
+ develop | 8 | 6000 | 5020.0000000000000000
+ develop | 10 | 5200 | 5020.0000000000000000
+ personnel | 5 | 3500 | 3700.0000000000000000
+ personnel | 2 | 3900 | 3700.0000000000000000
+ sales | 3 | 4800 | 4866.6666666666666667
+ sales | 1 | 5000 | 4866.6666666666666667
+ sales | 4 | 4800 | 4866.6666666666666667
+(10 rows)
+
+
+ The first three output columns come directly from the table
+ empsalary, and there is one output row for each row in the
+ table. The fourth column represents an average taken across all the table
+ rows that have the same depname value as the current row.
+ (This actually is the same function as the non-window avg
+ aggregate, but the OVER clause causes it to be
+ treated as a window function and computed across the window frame.)
+
+ A window function call always contains an OVER clause
+ directly following the window function's name and argument(s). This is what
+ syntactically distinguishes it from a normal function or non-window
+ aggregate. The OVER clause determines exactly how the
+ rows of the query are split up for processing by the window function.
+ The PARTITION BY clause within OVER
+ divides the rows into groups, or partitions, that share the same
+ values of the PARTITION BY expression(s). For each row,
+ the window function is computed across the rows that fall into the
+ same partition as the current row.
+
+ You can also control the order in which rows are processed by
+ window functions using ORDER BY within OVER.
+ (The window ORDER BY does not even have to match the
+ order in which the rows are output.) Here is an example:
+
+
+SELECT depname, empno, salary,
+ rank() OVER (PARTITION BY depname ORDER BY salary DESC)
+FROM empsalary;
+
+
+
+ depname | empno | salary | rank
+-----------+-------+--------+------
+ develop | 8 | 6000 | 1
+ develop | 10 | 5200 | 2
+ develop | 11 | 5200 | 2
+ develop | 9 | 4500 | 4
+ develop | 7 | 4200 | 5
+ personnel | 2 | 3900 | 1
+ personnel | 5 | 3500 | 2
+ sales | 1 | 5000 | 1
+ sales | 4 | 4800 | 2
+ sales | 3 | 4800 | 2
+(10 rows)
+
+
+ As shown here, the rank function produces a numerical rank
+ for each distinct ORDER BY value in the current row's
+ partition, using the order defined by the ORDER BY clause.
+ rank needs no explicit parameter, because its behavior
+ is entirely determined by the OVER clause.
+
+ The rows considered by a window function are those of the “virtual
+ table” produced by the query's FROM clause as filtered by its
+ WHERE, GROUP BY, and HAVING clauses
+ if any. For example, a row removed because it does not meet the
+ WHERE condition is not seen by any window function.
+ A query can contain multiple window functions that slice up the data
+ in different ways using different OVER clauses, but
+ they all act on the same collection of rows defined by this virtual table.
+
+ We already saw that ORDER BY can be omitted if the ordering
+ of rows is not important. It is also possible to omit PARTITION
+ BY, in which case there is a single partition containing all rows.
+
+ There is another important concept associated with window functions:
+ for each row, there is a set of rows within its partition called its
+ window frame. Some window functions act only
+ on the rows of the window frame, rather than of the whole partition.
+ By default, if ORDER BY is supplied then the frame consists of
+ all rows from the start of the partition up through the current row, plus
+ any following rows that are equal to the current row according to the
+ ORDER BY clause. When ORDER BY is omitted the
+ default frame consists of all rows in the partition.
+
+ Here is an example using sum:
+
+SELECT salary, sum(salary) OVER () FROM empsalary;
+
+ salary | sum
+--------+-------
+ 5200 | 47100
+ 5000 | 47100
+ 3500 | 47100
+ 4800 | 47100
+ 3900 | 47100
+ 4200 | 47100
+ 4500 | 47100
+ 4800 | 47100
+ 6000 | 47100
+ 5200 | 47100
+(10 rows)
+
+ Above, since there is no ORDER BY in the OVER
+ clause, the window frame is the same as the partition, which for lack of
+ PARTITION BY is the whole table; in other words each sum is
+ taken over the whole table and so we get the same result for each output
+ row. But if we add an ORDER BY clause, we get very different
+ results:
+
+SELECT salary, sum(salary) OVER (ORDER BY salary) FROM empsalary;
+
+ salary | sum
+--------+-------
+ 3500 | 3500
+ 3900 | 7400
+ 4200 | 11600
+ 4500 | 16100
+ 4800 | 25700
+ 4800 | 25700
+ 5000 | 30700
+ 5200 | 41100
+ 5200 | 41100
+ 6000 | 47100
+(10 rows)
+
+ Here the sum is taken from the first (lowest) salary up through the
+ current one, including any duplicates of the current one (notice the
+ results for the duplicated salaries).
+
+ Window functions are permitted only in the SELECT list
+ and the ORDER BY clause of the query. They are forbidden
+ elsewhere, such as in GROUP BY, HAVING
+ and WHERE clauses. This is because they logically
+ execute after the processing of those clauses. Also, window functions
+ execute after non-window aggregate functions. This means it is valid to
+ include an aggregate function call in the arguments of a window function,
+ but not vice versa.
+
+ If there is a need to filter or group rows after the window calculations
+ are performed, you can use a sub-select. For example:
+
+
+SELECT depname, empno, salary, enroll_date
+FROM
+ (SELECT depname, empno, salary, enroll_date,
+ rank() OVER (PARTITION BY depname ORDER BY salary DESC, empno) AS pos
+ FROM empsalary
+ ) AS ss
+WHERE pos < 3;
+
+
+ The above query only shows the rows from the inner query having
+ rank less than 3.
+
+ When a query involves multiple window functions, it is possible to write
+ out each one with a separate OVER clause, but this is
+ duplicative and error-prone if the same windowing behavior is wanted
+ for several functions. Instead, each windowing behavior can be named
+ in a WINDOW clause and then referenced in OVER.
+ For example:
+
+
+SELECT sum(salary) OVER w, avg(salary) OVER w
+ FROM empsalary
+ WINDOW w AS (PARTITION BY depname ORDER BY salary DESC);
+
+
+ More details about window functions can be found in
+ Section 4.2.8,
+ Section 9.22,
+ Section 7.2.5, and the
+ SELECT reference page.
+
+ Welcome to the PostgreSQL Tutorial. The
+ following few chapters are intended to give a simple introduction
+ to PostgreSQL, relational database
+ concepts, and the SQL language to those who are new to any one of
+ these aspects. We only assume some general knowledge about how to
+ use computers. No particular Unix or programming experience is
+ required. This part is mainly intended to give you some hands-on
+ experience with important aspects of the
+ PostgreSQL system. It makes no attempt
+ to be a complete or thorough treatment of the topics it covers.
+
+ After you have worked through this tutorial you might want to move
+ on to reading Part II to gain a more formal knowledge
+ of the SQL language, or Part IV for
+ information about developing applications for
+ PostgreSQL. Those who set up and
+ manage their own server should also read Part III.
+
74.4. Two-Phase Transactions #
+ PostgreSQL supports a two-phase commit (2PC)
+ protocol that allows multiple distributed systems to work together
+ in a transactional manner. The commands are PREPARE
+ TRANSACTION, COMMIT PREPARED and
+ ROLLBACK PREPARED. Two-phase transactions
+ are intended for use by external transaction management systems.
+ PostgreSQL follows the features and model
+ proposed by the X/Open XA standard, but does not implement some less
+ often used aspects.
+
+ When the user executes PREPARE TRANSACTION, the
+ only possible next commands are COMMIT PREPARED
+ or ROLLBACK PREPARED. In general, this prepared
+ state is intended to be of very short duration, but external
+ availability issues might mean transactions stay in this state
+ for an extended interval. Short-lived prepared
+ transactions are stored only in shared memory and WAL.
+ Transactions that span checkpoints are recorded in the
+ pg_twophase directory. Transactions
+ that are currently prepared can be inspected using pg_prepared_xacts.
+
+ The specific function that is referenced by a function call
+ is determined using the following procedure.
+
Function Type Resolution
+Select the functions to be considered from the
+pg_proc system catalog. If a non-schema-qualified
+function name was used, the functions
+considered are those with the matching name and argument count that are
+visible in the current search path (see Section 5.9.3).
+If a qualified function name was given, only functions in the specified
+schema are considered.
+
+If the search path finds multiple functions of identical argument types,
+only the one appearing earliest in the path is considered. Functions of
+different argument types are considered on an equal footing regardless of
+search path position.
+
+If a function is declared with a VARIADIC array parameter, and
+the call does not use the VARIADIC keyword, then the function
+is treated as if the array parameter were replaced by one or more occurrences
+of its element type, as needed to match the call. After such expansion the
+function might have effective argument types identical to some non-variadic
+function. In that case the function appearing earlier in the search path is
+used, or if the two functions are in the same schema, the non-variadic one is
+preferred.
+
+This creates a security hazard when calling, via qualified name
+ ,
+a variadic function found in a schema that permits untrusted users to create
+objects. A malicious user can take control and execute arbitrary SQL
+functions as though you executed them. Substitute a call bearing
+the VARIADIC keyword, which bypasses this hazard. Calls
+populating VARIADIC "any" parameters often have no
+equivalent formulation containing the VARIADIC keyword. To
+issue those calls safely, the function's schema must permit only trusted users
+to create objects.
+
+Functions that have default values for parameters are considered to match any
+call that omits zero or more of the defaultable parameter positions. If more
+than one such function matches a call, the one appearing earliest in the
+search path is used. If there are two or more such functions in the same
+schema with identical parameter types in the non-defaulted positions (which is
+possible if they have different sets of defaultable parameters), the system
+will not be able to determine which to prefer, and so an “ambiguous
+function call” error will result if no better match to the call can be
+found.
+
+This creates an availability hazard when calling, via qualified
+name, any function found in a
+schema that permits untrusted users to create objects. A malicious user can
+create a function with the name of an existing function, replicating that
+function's parameters and appending novel parameters having default values.
+This precludes new calls to the original function. To forestall this hazard,
+place functions in schemas that permit only trusted users to create objects.
+
+Check for a function accepting exactly the input argument types.
+If one exists (there can be only one exact match in the set of
+functions considered), use it. Lack of an exact match creates a security
+hazard when calling, via qualified
+name, a function found in a
+schema that permits untrusted users to create objects. In such situations,
+cast arguments to force an exact match. (Cases involving unknown
+will never find a match at this step.)
+
+If no exact match is found, see if the function call appears
+to be a special type conversion request. This happens if the function call
+has just one argument and the function name is the same as the (internal)
+name of some data type. Furthermore, the function argument must be either
+an unknown-type literal, or a type that is binary-coercible to the named
+data type, or a type that could be converted to the named data type by
+applying that type's I/O functions (that is, the conversion is either to or
+from one of the standard string types). When these conditions are met,
+the function call is treated as a form of CAST specification.
+
+
+Look for the best match.
+
+Discard candidate functions for which the input types do not match
+and cannot be converted (using an implicit conversion) to match.
+unknown literals are
+assumed to be convertible to anything for this purpose. If only one
+candidate remains, use it; else continue to the next step.
+
+If any input argument is of a domain type, treat it as being of the
+domain's base type for all subsequent steps. This ensures that domains
+act like their base types for purposes of ambiguous-function resolution.
+
+Run through all candidates and keep those with the most exact matches
+on input types. Keep all candidates if none have exact matches.
+If only one candidate remains, use it; else continue to the next step.
+
+Run through all candidates and keep those that accept preferred types (of the
+input data type's type category) at the most positions where type conversion
+will be required.
+Keep all candidates if none accept preferred types.
+If only one candidate remains, use it; else continue to the next step.
+
+If any input arguments are unknown, check the type categories
+accepted
+at those argument positions by the remaining candidates. At each position,
+select the string category if any candidate accepts that category.
+(This bias towards string
+is appropriate since an unknown-type literal looks like a string.)
+Otherwise, if all the remaining candidates accept the same type category,
+select that category; otherwise fail because
+the correct choice cannot be deduced without more clues.
+Now discard candidates that do not accept the selected type category.
+Furthermore, if any candidate accepts a preferred type in that category,
+discard candidates that accept non-preferred types for that argument.
+Keep all candidates if none survive these tests.
+If only one candidate remains, use it; else continue to the next step.
+
+If there are both unknown and known-type arguments, and all
+the known-type arguments have the same type, assume that the
+unknown arguments are also of that type, and check which
+candidates can accept that type at the unknown-argument
+positions. If exactly one candidate passes this test, use it.
+Otherwise, fail.
+
+Note that the “best match” rules are identical for operator and
+function type resolution.
+Some examples follow.
+
Example 10.6. Rounding Function Argument Type Resolution
+There is only one round function that takes two
+arguments; it takes a first argument of type numeric and
+a second argument of type integer.
+So the following query automatically converts
+the first argument of type integer to
+numeric:
+
+
+SELECT round(4, 4);
+
+ round
+--------
+ 4.0000
+(1 row)
+
+
+That query is actually transformed by the parser to:
+
+SELECT round(CAST (4 AS numeric), 4);
+
+
+Since numeric constants with decimal points are initially assigned the
+type numeric, the following query will require no type
+conversion and therefore might be slightly more efficient:
+
+SELECT round(4.0, 4);
+
+
Example 10.7. Variadic Function Resolution
+
+CREATE FUNCTION public.variadic_example(VARIADIC numeric[]) RETURNS int
+ LANGUAGE sql AS 'SELECT 1';
+CREATE FUNCTION
+
+
+This function accepts, but does not require, the VARIADIC keyword. It
+tolerates both integer and numeric arguments:
+
+
+SELECT public.variadic_example(0),
+ public.variadic_example(0.0),
+ public.variadic_example(VARIADIC array[0.0]);
+ variadic_example | variadic_example | variadic_example
+------------------+------------------+------------------
+ 1 | 1 | 1
+(1 row)
+
+
+However, the first and second calls will prefer more-specific functions, if
+available:
+
+
+CREATE FUNCTION public.variadic_example(numeric) RETURNS int
+ LANGUAGE sql AS 'SELECT 2';
+CREATE FUNCTION
+
+CREATE FUNCTION public.variadic_example(int) RETURNS int
+ LANGUAGE sql AS 'SELECT 3';
+CREATE FUNCTION
+
+SELECT public.variadic_example(0),
+ public.variadic_example(0.0),
+ public.variadic_example(VARIADIC array[0.0]);
+ variadic_example | variadic_example | variadic_example
+------------------+------------------+------------------
+ 3 | 2 | 1
+(1 row)
+
+
+Given the default configuration and only the first function existing, the
+first and second calls are insecure. Any user could intercept them by
+creating the second or third function. By matching the argument type exactly
+and using the VARIADIC keyword, the third call is secure.
+
Example 10.8. Substring Function Type Resolution
+There are several substr functions, one of which
+takes types text and integer. If called
+with a string constant of unspecified type, the system chooses the
+candidate function that accepts an argument of the preferred category
+string (namely of type text).
+
+
+SELECT substr('1234', 3);
+
+ substr
+--------
+ 34
+(1 row)
+
+
+If the string is declared to be of type varchar, as might be the case
+if it comes from a table, then the parser will try to convert it to become text:
+
+SELECT substr(varchar '1234', 3);
+
+ substr
+--------
+ 34
+(1 row)
+
+
+This is transformed by the parser to effectively become:
+
+SELECT substr(CAST (varchar '1234' AS text), 3);
+
+
+
Note
+The parser learns from the pg_cast catalog that
+text and varchar
+are binary-compatible, meaning that one can be passed to a function that
+accepts the other without doing any physical conversion. Therefore, no
+type conversion call is really inserted in this case.
+
+
+And, if the function is called with an argument of type integer,
+the parser will try to convert that to text:
+
+SELECT substr(1234, 3);
+ERROR: function substr(integer, integer) does not exist
+HINT: No function matches the given name and argument types. You might need
+to add explicit type casts.
+
+
+This does not work because integer does not have an implicit cast
+to text. An explicit cast will work, however:
+
+SELECT substr(CAST (1234 AS text), 3);
+
+ substr
+--------
+ 34
+(1 row)
+
+
+ The specific operator that is referenced by an operator expression
+ is determined using the following procedure.
+ Note that this procedure is indirectly affected
+ by the precedence of the operators involved, since that will determine
+ which sub-expressions are taken to be the inputs of which operators.
+ See Section 4.1.6 for more information.
+
Operator Type Resolution
+Select the operators to be considered from the
+pg_operator system catalog. If a non-schema-qualified
+operator name was used (the usual case), the operators
+considered are those with the matching name and argument count that are
+visible in the current search path (see Section 5.9.3).
+If a qualified operator name was given, only operators in the specified
+schema are considered.
+
+If the search path finds multiple operators with identical argument types,
+only the one appearing earliest in the path is considered. Operators with
+different argument types are considered on an equal footing regardless of
+search path position.
+
+Check for an operator accepting exactly the input argument types.
+If one exists (there can be only one exact match in the set of
+operators considered), use it. Lack of an exact match creates a security
+hazard when calling, via qualified name
+
+(not typical), any operator found in a schema that permits untrusted users to
+create objects. In such situations, cast arguments to force an exact match.
+
+If one argument of a binary operator invocation is of the unknown type,
+then assume it is the same type as the other argument for this check.
+Invocations involving two unknown inputs, or a prefix operator
+with an unknown input, will never find a match at this step.
+
+If one argument of a binary operator invocation is of the unknown
+type and the other is of a domain type, next check to see if there is an
+operator accepting exactly the domain's base type on both sides; if so, use it.
+
+Look for the best match.
+
+Discard candidate operators for which the input types do not match
+and cannot be converted (using an implicit conversion) to match.
+unknown literals are
+assumed to be convertible to anything for this purpose. If only one
+candidate remains, use it; else continue to the next step.
+
+If any input argument is of a domain type, treat it as being of the
+domain's base type for all subsequent steps. This ensures that domains
+act like their base types for purposes of ambiguous-operator resolution.
+
+Run through all candidates and keep those with the most exact matches
+on input types. Keep all candidates if none have exact matches.
+If only one candidate remains, use it; else continue to the next step.
+
+Run through all candidates and keep those that accept preferred types (of the
+input data type's type category) at the most positions where type conversion
+will be required.
+Keep all candidates if none accept preferred types.
+If only one candidate remains, use it; else continue to the next step.
+
+If any input arguments are unknown, check the type
+categories accepted at those argument positions by the remaining
+candidates. At each position, select the string category
+if any
+candidate accepts that category. (This bias towards string is appropriate
+since an unknown-type literal looks like a string.) Otherwise, if
+all the remaining candidates accept the same type category, select that
+category; otherwise fail because the correct choice cannot be deduced
+without more clues. Now discard
+candidates that do not accept the selected type category. Furthermore,
+if any candidate accepts a preferred type in that category,
+discard candidates that accept non-preferred types for that argument.
+Keep all candidates if none survive these tests.
+If only one candidate remains, use it; else continue to the next step.
+
+If there are both unknown and known-type arguments, and all
+the known-type arguments have the same type, assume that the
+unknown arguments are also of that type, and check which
+candidates can accept that type at the unknown-argument
+positions. If exactly one candidate passes this test, use it.
+Otherwise, fail.
+
+Some examples follow.
+
Example 10.1. Square Root Operator Type Resolution
+There is only one square root operator (prefix |/)
+defined in the standard catalog, and it takes an argument of type
+double precision.
+The scanner assigns an initial type of integer to the argument
+in this query expression:
+
+SELECT |/ 40 AS "square root of 40";
+ square root of 40
+-------------------
+ 6.324555320336759
+(1 row)
+
+
+So the parser does a type conversion on the operand and the query
+is equivalent to:
+
+
+SELECT |/ CAST(40 AS double precision) AS "square root of 40";
+
+
Example 10.2. String Concatenation Operator Type Resolution
+A string-like syntax is used for working with string types and for
+working with complex extension types.
+Strings with unspecified type are matched with likely operator candidates.
+
+An example with one unspecified argument:
+
+SELECT text 'abc' || 'def' AS "text and unknown";
+
+ text and unknown
+------------------
+ abcdef
+(1 row)
+
+
+In this case the parser looks to see if there is an operator taking text
+for both arguments. Since there is, it assumes that the second argument should
+be interpreted as type text.
+
+Here is a concatenation of two values of unspecified types:
+
+SELECT 'abc' || 'def' AS "unspecified";
+
+ unspecified
+-------------
+ abcdef
+(1 row)
+
+
+In this case there is no initial hint for which type to use, since no types
+are specified in the query. So, the parser looks for all candidate operators
+and finds that there are candidates accepting both string-category and
+bit-string-category inputs. Since string category is preferred when available,
+that category is selected, and then the
+preferred type for strings, text, is used as the specific
+type to resolve the unknown-type literals as.
+
Example 10.3. Absolute-Value and Negation Operator Type Resolution
+The PostgreSQL operator catalog has several
+entries for the prefix operator @, all of which implement
+absolute-value operations for various numeric data types. One of these
+entries is for type float8, which is the preferred type in
+the numeric category. Therefore, PostgreSQL
+will use that entry when faced with an unknown input:
+
+SELECT @ '-4.5' AS "abs";
+ abs
+-----
+ 4.5
+(1 row)
+
+Here the system has implicitly resolved the unknown-type literal as type
+float8 before applying the chosen operator. We can verify that
+float8 and not some other type was used:
+
+SELECT @ '-4.5e500' AS "abs";
+
+ERROR: "-4.5e500" is out of range for type double precision
+
+
+On the other hand, the prefix operator ~ (bitwise negation)
+is defined only for integer data types, not for float8. So, if we
+try a similar case with ~, we get:
+
+SELECT ~ '20' AS "negation";
+
+ERROR: operator is not unique: ~ "unknown"
+HINT: Could not choose a best candidate operator. You might need to add
+explicit type casts.
+
+This happens because the system cannot decide which of the several
+possible ~ operators should be preferred. We can help
+it out with an explicit cast:
+
+SELECT ~ CAST('20' AS int8) AS "negation";
+
+ negation
+----------
+ -21
+(1 row)
+
+
Example 10.4. Array Inclusion Operator Type Resolution
+Here is another example of resolving an operator with one known and one
+unknown input:
+
+SELECT array[1,2] <@ '{1,2,3}' as "is subset";
+
+ is subset
+-----------
+ t
+(1 row)
+
+The PostgreSQL operator catalog has several
+entries for the infix operator <@, but the only two that
+could possibly accept an integer array on the left-hand side are
+array inclusion (anyarray <@ anyarray)
+and range inclusion (anyelement <@ anyrange).
+Since none of these polymorphic pseudo-types (see Section 8.21) are considered preferred, the parser cannot
+resolve the ambiguity on that basis.
+However, Step 3.f tells
+it to assume that the unknown-type literal is of the same type as the other
+input, that is, integer array. Now only one of the two operators can match,
+so array inclusion is selected. (Had range inclusion been selected, we would
+have gotten an error, because the string does not have the right format to be
+a range literal.)
+
Example 10.5. Custom Operator on a Domain Type
+Users sometimes try to declare operators applying just to a domain type.
+This is possible but is not nearly as useful as it might seem, because the
+operator resolution rules are designed to select operators applying to the
+domain's base type. As an example consider
+
+CREATE DOMAIN mytext AS text CHECK(...);
+CREATE FUNCTION mytext_eq_text (mytext, text) RETURNS boolean AS ...;
+CREATE OPERATOR = (procedure=mytext_eq_text, leftarg=mytext, rightarg=text);
+CREATE TABLE mytable (val mytext);
+
+SELECT * FROM mytable WHERE val = 'foo';
+
+This query will not use the custom operator. The parser will first see if
+there is a mytext = mytext operator
+(Step 2.a), which there is not;
+then it will consider the domain's base type text, and see if
+there is a text = text operator
+(Step 2.b), which there is;
+so it resolves the unknown-type literal as text and
+uses the text = text operator.
+The only way to get the custom operator to be used is to explicitly cast
+the literal:
+
+SELECT * FROM mytable WHERE val = text 'foo';
+
+so that the mytext = text operator is found
+immediately according to the exact-match rule. If the best-match rules
+are reached, they actively discriminate against operators on domain types.
+If they did not, such an operator would create too many ambiguous-operator
+failures, because the casting rules always consider a domain as castable
+to or from its base type, and so the domain operator would be considered
+usable in all the same cases as a similarly-named operator on the base type.
+
+SQL is a strongly typed language. That is, every data item
+has an associated data type which determines its behavior and allowed usage.
+PostgreSQL has an extensible type system that is
+more general and flexible than other SQL implementations.
+Hence, most type conversion behavior in PostgreSQL
+is governed by general rules rather than by ad hoc
+heuristics. This allows the use of mixed-type expressions even with
+user-defined types.
+
+The PostgreSQL scanner/parser divides lexical
+elements into five fundamental categories: integers, non-integer numbers,
+strings, identifiers, and key words. Constants of most non-numeric types are
+first classified as strings. The SQL language definition
+allows specifying type names with strings, and this mechanism can be used in
+PostgreSQL to start the parser down the correct
+path. For example, the query:
+
+
+SELECT text 'Origin' AS "label", point '(0,0)' AS "value";
+
+ label | value
+--------+-------
+ Origin | (0,0)
+(1 row)
+
+
+has two literal constants, of type text and point.
+If a type is not specified for a string literal, then the placeholder type
+unknown is assigned initially, to be resolved in later
+stages as described below.
+
+There are four fundamental SQL constructs requiring
+distinct type conversion rules in the PostgreSQL
+parser:
+
+
-
+Function calls
+
+Much of the PostgreSQL type system is built around a
+rich set of functions. Functions can have one or more arguments.
+Since PostgreSQL permits function
+overloading, the function name alone does not uniquely identify the function
+to be called; the parser must select the right function based on the data
+types of the supplied arguments.
+
-
+Operators
+
+PostgreSQL allows expressions with
+prefix (one-argument) operators,
+as well as infix (two-argument) operators. Like functions, operators can
+be overloaded, so the same problem of selecting the right operator
+exists.
+
-
+Value Storage
+
+SQL INSERT and UPDATE statements place the results of
+expressions into a table. The expressions in the statement must be matched up
+with, and perhaps converted to, the types of the target columns.
+
-
+
UNION, CASE, and related constructs
+
+Since all query results from a unionized SELECT statement
+must appear in a single set of columns, the types of the results of each
+SELECT clause must be matched up and converted to a uniform set.
+Similarly, the result expressions of a CASE construct must be
+converted to a common type so that the CASE expression as a whole
+has a known output type. Some other constructs, such
+as ARRAY[] and the GREATEST
+and LEAST functions, likewise require determination of a
+common type for several subexpressions.
+
+
+The system catalogs store information about which conversions, or
+casts, exist between which data types, and how to
+perform those conversions. Additional casts can be added by the user
+with the CREATE CAST
+command. (This is usually
+done in conjunction with defining new data types. The set of casts
+between built-in types has been carefully crafted and is best not
+altered.)
+
+An additional heuristic provided by the parser allows improved determination
+of the proper casting behavior among groups of types that have implicit casts.
+Data types are divided into several basic type
+categories, including boolean, numeric,
+string, bitstring, datetime,
+timespan, geometric, network, and
+user-defined. (For a list see Table 53.65;
+but note it is also possible to create custom type categories.) Within each
+category there can be one or more preferred types, which
+are preferred when there is a choice of possible types. With careful selection
+of preferred types and available implicit casts, it is possible to ensure that
+ambiguous expressions (those with multiple candidate parsing solutions) can be
+resolved in a useful way.
+
+All type conversion rules are designed with several principles in mind:
+
+
+Implicit conversions should never have surprising or unpredictable outcomes.
+
+There should be no extra overhead in the parser or executor
+if a query does not need implicit type conversion.
+That is, if a query is well-formed and the types already match, then the query should execute
+without spending extra time in the parser and without introducing unnecessary implicit conversion
+calls in the query.
+
+Additionally, if a query usually requires an implicit conversion for a function, and
+if then the user defines a new function with the correct argument types, the parser
+should use this new function and no longer do implicit conversion to use the old function.
+
+
+ Values to be inserted into a table are converted to the destination
+ column's data type according to the
+ following steps.
+
Value Storage Type Conversion
+Check for an exact match with the target.
+
+Otherwise, try to convert the expression to the target type. This is possible
+if an assignment cast between the two types is registered in the
+pg_cast catalog (see CREATE CAST).
+Alternatively, if the expression is an unknown-type literal, the contents of
+the literal string will be fed to the input conversion routine for the target
+type.
+
+Check to see if there is a sizing cast for the target type. A sizing
+cast is a cast from that type to itself. If one is found in the
+pg_cast catalog, apply it to the expression before storing
+into the destination column. The implementation function for such a cast
+always takes an extra parameter of type integer, which receives
+the destination column's atttypmod value (typically its
+declared length, although the interpretation of atttypmod
+varies for different data types), and it may take a third boolean
+parameter that says whether the cast is explicit or implicit. The cast
+function
+is responsible for applying any length-dependent semantics such as size
+checking or truncation.
+
Example 10.9. character Storage Type Conversion
+For a target column declared as character(20) the following
+statement shows that the stored value is sized correctly:
+
+
+CREATE TABLE vv (v character(20));
+INSERT INTO vv SELECT 'abc' || 'def';
+SELECT v, octet_length(v) FROM vv;
+
+ v | octet_length
+----------------------+--------------
+ abcdef | 20
+(1 row)
+
+
+What has really happened here is that the two unknown literals are resolved
+to text by default, allowing the || operator
+to be resolved as text concatenation. Then the text
+result of the operator is converted to bpchar (“blank-padded
+char”, the internal name of the character data type) to match the target
+column type. (Since the conversion from text to
+bpchar is binary-coercible, this conversion does
+not insert any real function call.) Finally, the sizing function
+bpchar(bpchar, integer, boolean) is found in the system catalog
+and applied to the operator's result and the stored column length. This
+type-specific function performs the required length check and addition of
+padding spaces.
+
10.6. SELECT Output Columns #
+The rules given in the preceding sections will result in assignment
+of non-unknown data types to all expressions in an SQL query,
+except for unspecified-type literals that appear as simple output
+columns of a SELECT command. For example, in
+
+
+SELECT 'Hello World';
+
+
+there is nothing to identify what type the string literal should be
+taken as. In this situation PostgreSQL will fall back
+to resolving the literal's type as text.
+
+When the SELECT is one arm of a UNION
+(or INTERSECT or EXCEPT) construct, or when it
+appears within INSERT ... SELECT, this rule is not applied
+since rules given in preceding sections take precedence. The type of an
+unspecified-type literal can be taken from the other UNION arm
+in the first case, or from the destination column in the second case.
+
+RETURNING lists are treated the same as SELECT
+output lists for this purpose.
+
Note
+ Prior to PostgreSQL 10, this rule did not exist, and
+ unspecified-type literals in a SELECT output list were
+ left as type unknown. That had assorted bad consequences,
+ so it's been changed.
+
10.5. UNION, CASE, and Related Constructs #
+SQL UNION constructs must match up possibly dissimilar
+types to become a single result set. The resolution algorithm is
+applied separately to each output column of a union query. The
+INTERSECT and EXCEPT constructs resolve
+dissimilar types in the same way as UNION.
+Some other constructs, including
+CASE, ARRAY, VALUES,
+and the GREATEST and LEAST
+functions, use the identical
+algorithm to match up their component expressions and select a result
+data type.
+
Type Resolution for UNION, CASE,
+and Related Constructs
+If all inputs are of the same type, and it is not unknown,
+resolve as that type.
+
+If any input is of a domain type, treat it as being of the
+domain's base type for all subsequent steps.
+
+
+If all inputs are of type unknown, resolve as type
+text (the preferred type of the string category).
+Otherwise, unknown inputs are ignored for the purposes
+of the remaining rules.
+
+If the non-unknown inputs are not all of the same type category, fail.
+
+Select the first non-unknown input type as the candidate type,
+then consider each other non-unknown input type, left to right.
+
+If the candidate type can be implicitly converted to the other type,
+but not vice-versa, select the other type as the new candidate type.
+Then continue considering the remaining inputs. If, at any stage of this
+process, a preferred type is selected, stop considering additional
+inputs.
+
+Convert all inputs to the final candidate type. Fail if there is not an
+implicit conversion from a given input type to the candidate type.
+
+Some examples follow.
+
Example 10.10. Type Resolution with Underspecified Types in a Union
+
+SELECT text 'a' AS "text" UNION SELECT 'b';
+
+ text
+------
+ a
+ b
+(2 rows)
+
+Here, the unknown-type literal 'b' will be resolved to type text.
+
Example 10.11. Type Resolution in a Simple Union
+
+SELECT 1.2 AS "numeric" UNION SELECT 1;
+
+ numeric
+---------
+ 1
+ 1.2
+(2 rows)
+
+The literal 1.2 is of type numeric,
+and the integer value 1 can be cast implicitly to
+numeric, so that type is used.
+
Example 10.12. Type Resolution in a Transposed Union
+
+SELECT 1 AS "real" UNION SELECT CAST('2.2' AS REAL);
+
+ real
+------
+ 1
+ 2.2
+(2 rows)
+
+Here, since type real cannot be implicitly cast to integer,
+but integer can be implicitly cast to real, the union
+result type is resolved as real.
+
Example 10.13. Type Resolution in a Nested Union
+
+SELECT NULL UNION SELECT NULL UNION SELECT 1;
+
+ERROR: UNION types text and integer cannot be matched
+
+This failure occurs because PostgreSQL treats
+multiple UNIONs as a nest of pairwise operations;
+that is, this input is the same as
+
+(SELECT NULL UNION SELECT NULL) UNION SELECT 1;
+
+The inner UNION is resolved as emitting
+type text, according to the rules given above. Then the
+outer UNION has inputs of types text
+and integer, leading to the observed error. The problem
+can be fixed by ensuring that the leftmost UNION
+has at least one input of the desired result type.
+
+INTERSECT and EXCEPT operations are
+likewise resolved pairwise. However, the other constructs described in this
+section consider all of their inputs in one resolution step.
+
Chapter 10. Type Conversion
+SQL statements can, intentionally or not, require
+the mixing of different data types in the same expression.
+PostgreSQL has extensive facilities for
+evaluating mixed-type expressions.
+
+In many cases a user does not need
+to understand the details of the type conversion mechanism.
+However, implicit conversions done by PostgreSQL
+can affect the results of a query. When necessary, these results
+can be tailored by using explicit type conversion.
+
+This chapter introduces the PostgreSQL
+type conversion mechanisms and conventions.
+Refer to the relevant sections in Chapter 8 and Chapter 9
+for more information on specific data types and allowed functions and
+operators.
+
F.48. unaccent — a text search dictionary which removes diacritics #
+ unaccent is a text search dictionary that removes accents
+ (diacritic signs) from lexemes.
+ It's a filtering dictionary, which means its output is
+ always passed to the next dictionary (if any), unlike the normal
+ behavior of dictionaries. This allows accent-insensitive processing
+ for full text search.
+
+ The current implementation of unaccent cannot be used as a
+ normalizing dictionary for the thesaurus dictionary.
+
+ This module is considered “trusted”, that is, it can be
+ installed by non-superusers who have CREATE privilege
+ on the current database.
+
+ An unaccent dictionary accepts the following options:
+
+ The rules file has the following format:
+
+ Each line represents one translation rule, consisting of a character with
+ accent followed by a character without accent. The first is translated
+ into the second. For example,
+
+À A
+Á A
+Â A
+Ã A
+Ä A
+Å A
+Æ AE
+
+ The two characters must be separated by whitespace, and any leading or
+ trailing whitespace on a line is ignored.
+
+ Alternatively, if only one character is given on a line, instances of
+ that character are deleted; this is useful in languages where accents
+ are represented by separate characters.
+
+ Actually, each “character” can be any string not containing
+ whitespace, so unaccent dictionaries could be used for
+ other sorts of substring substitutions besides diacritic removal.
+
+ As with other PostgreSQL text search configuration files,
+ the rules file must be stored in UTF-8 encoding. The data is
+ automatically translated into the current database's encoding when
+ loaded. Any lines containing untranslatable characters are silently
+ ignored, so that rules files can contain rules that are not applicable in
+ the current encoding.
+
+ A more complete example, which is directly useful for most European
+ languages, can be found in unaccent.rules, which is installed
+ in $SHAREDIR/tsearch_data/ when the unaccent
+ module is installed. This rules file translates characters with accents
+ to the same characters without accents, and it also expands ligatures
+ into the equivalent series of simple characters (for example, Æ to
+ AE).
+
+ Installing the unaccent extension creates a text
+ search template unaccent and a dictionary unaccent
+ based on it. The unaccent dictionary has the default
+ parameter setting RULES='unaccent', which makes it immediately
+ usable with the standard unaccent.rules file.
+ If you wish, you can alter the parameter, for example
+
+
+mydb=# ALTER TEXT SEARCH DICTIONARY unaccent (RULES='my_rules');
+
+
+ or create new dictionaries based on the template.
+
+ To test the dictionary, you can try:
+
+mydb=# select ts_lexize('unaccent','Hôtel');
+ ts_lexize
+-----------
+ {Hotel}
+(1 row)
+
+
+ Here is an example showing how to insert the
+ unaccent dictionary into a text search configuration:
+
+mydb=# CREATE TEXT SEARCH CONFIGURATION fr ( COPY = french );
+mydb=# ALTER TEXT SEARCH CONFIGURATION fr
+ ALTER MAPPING FOR hword, hword_part, word
+ WITH unaccent, french_stem;
+mydb=# select to_tsvector('fr','Hôtels de la Mer');
+ to_tsvector
+-------------------
+ 'hotel':1 'mer':4
+(1 row)
+
+mydb=# select to_tsvector('fr','Hôtel de la Mer') @@ to_tsquery('fr','Hotels');
+ ?column?
+----------
+ t
+(1 row)
+
+mydb=# select ts_headline('fr','Hôtel de la Mer',to_tsquery('fr','Hotels'));
+ ts_headline
+------------------------
+ <b>Hôtel</b> de la Mer
+(1 row)
+
+
+ The unaccent() function removes accents (diacritic signs) from
+ a given string. Basically, it's a wrapper around
+ unaccent-type dictionaries, but it can be used outside normal
+ text search contexts.
+
+unaccent([dictionary regdictionary, ] string text) returns text
+
+ If the dictionary argument is
+ omitted, the text search dictionary named unaccent and
+ appearing in the same schema as the unaccent()
+ function itself is used.
+
+ For example:
+
+SELECT unaccent('unaccent', 'Hôtel');
+SELECT unaccent('Hôtel');
+
+
D.2. Unsupported Features #
+ The following features defined in SQL:2023 are not
+ implemented in this release of
+ PostgreSQL. In a few cases, equivalent
+ functionality is available.
+
+
+
19.6. Upgrading a PostgreSQL Cluster #
+ This section discusses how to upgrade your database data from one
+ PostgreSQL release to a newer one.
+
+ Current PostgreSQL version numbers consist of a
+ major and a minor version number. For example, in the version number 10.1,
+ the 10 is the major version number and the 1 is the minor version number,
+ meaning this would be the first minor release of the major release 10. For
+ releases before PostgreSQL version 10.0, version
+ numbers consist of three numbers, for example, 9.5.3. In those cases, the
+ major version consists of the first two digit groups of the version number,
+ e.g., 9.5, and the minor version is the third number, e.g., 3, meaning this
+ would be the third minor release of the major release 9.5.
+
+ Minor releases never change the internal storage format and are always
+ compatible with earlier and later minor releases of the same major version
+ number. For example, version 10.1 is compatible with version 10.0 and
+ version 10.6. Similarly, for example, 9.5.3 is compatible with 9.5.0,
+ 9.5.1, and 9.5.6. To update between compatible versions, you simply
+ replace the executables while the server is down and restart the server.
+ The data directory remains unchanged — minor upgrades are that
+ simple.
+
+ For major releases of PostgreSQL, the
+ internal data storage format is subject to change, thus complicating
+ upgrades. The traditional method for moving data to a new major version
+ is to dump and restore the database, though this can be slow. A
+ faster method is pg_upgrade. Replication methods are
+ also available, as discussed below.
+ (If you are using a pre-packaged version
+ of PostgreSQL, it may provide scripts to
+ assist with major version upgrades. Consult the package-level
+ documentation for details.)
+
+ New major versions also typically introduce some user-visible
+ incompatibilities, so application programming changes might be required.
+ All user-visible changes are listed in the release notes (Appendix E); pay particular attention to the section
+ labeled "Migration". Though you can upgrade from one major version
+ to another without upgrading to intervening versions, you should read
+ the major release notes of all intervening versions.
+
+ Cautious users will want to test their client applications on the new
+ version before switching over fully; therefore, it's often a good idea to
+ set up concurrent installations of old and new versions. When
+ testing a PostgreSQL major upgrade, consider the
+ following categories of possible changes:
+
- Administration
+ The capabilities available for administrators to monitor and control
+ the server often change and improve in each major release.
+
- SQL
+ Typically this includes new SQL command capabilities and not changes
+ in behavior, unless specifically mentioned in the release notes.
+
- Library API
+ Typically libraries like libpq only add new
+ functionality, again unless mentioned in the release notes.
+
- System Catalogs
+ System catalog changes usually only affect database management tools.
+
- Server C-language API
+ This involves changes in the backend function API, which is written
+ in the C programming language. Such changes affect code that
+ references backend functions deep inside the server.
+
19.6.1. Upgrading Data via pg_dumpall #
+ One upgrade method is to dump data from one major version of
+ PostgreSQL and restore it in another — to do
+ this, you must use a logical backup tool like
+ pg_dumpall; file system
+ level backup methods will not work. (There are checks in place that prevent
+ you from using a data directory with an incompatible version of
+ PostgreSQL, so no great harm can be done by
+ trying to start the wrong server version on a data directory.)
+
+ It is recommended that you use the pg_dump and
+ pg_dumpall programs from the newer
+ version of
+ PostgreSQL, to take advantage of enhancements
+ that might have been made in these programs. Current releases of the
+ dump programs can read data from any server version back to 9.2.
+
+ These instructions assume that your existing installation is under the
+ /usr/local/pgsql directory, and that the data area is in
+ /usr/local/pgsql/data. Substitute your paths
+ appropriately.
+
+ If making a backup, make sure that your database is not being updated.
+ This does not affect the integrity of the backup, but the changed
+ data would of course not be included. If necessary, edit the
+ permissions in the file /usr/local/pgsql/data/pg_hba.conf
+ (or equivalent) to disallow access from everyone except you.
+ See Chapter 21 for additional information on
+ access control.
+
+
+
+ To back up your database installation, type:
+
+pg_dumpall > outputfile
+
+
+ To make the backup, you can use the pg_dumpall
+ command from the version you are currently running; see Section 26.1.2 for more details. For best
+ results, however, try to use the pg_dumpall
+ command from PostgreSQL 16.3,
+ since this version contains bug fixes and improvements over older
+ versions. While this advice might seem idiosyncratic since you
+ haven't installed the new version yet, it is advisable to follow
+ it if you plan to install the new version in parallel with the
+ old version. In that case you can complete the installation
+ normally and transfer the data later. This will also decrease
+ the downtime.
+
+ Shut down the old server:
+
+pg_ctl stop
+
+ On systems that have PostgreSQL started at boot time,
+ there is probably a start-up file that will accomplish the same thing. For
+ example, on a Red Hat Linux system one
+ might find that this works:
+
+/etc/rc.d/init.d/postgresql stop
+
+ See Chapter 19 for details about starting and
+ stopping the server.
+
+ If restoring from backup, rename or delete the old installation
+ directory if it is not version-specific. It is a good idea to
+ rename the directory, rather than
+ delete it, in case you have trouble and need to revert to it. Keep
+ in mind the directory might consume significant disk space. To rename
+ the directory, use a command like this:
+
+mv /usr/local/pgsql /usr/local/pgsql.old
+
+ (Be sure to move the directory as a single unit so relative paths
+ remain unchanged.)
+
+ Install the new version of PostgreSQL as
+ outlined in Chapter 17.
+
+ Create a new database cluster if needed. Remember that you must
+ execute these commands while logged in to the special database user
+ account (which you already have if you are upgrading).
+
+/usr/local/pgsql/bin/initdb -D /usr/local/pgsql/data
+
+
+ Restore your previous pg_hba.conf and any
+ postgresql.conf modifications.
+
+ Start the database server, again using the special database user
+ account:
+
+/usr/local/pgsql/bin/postgres -D /usr/local/pgsql/data
+
+
+ Finally, restore your data from backup with:
+
+/usr/local/pgsql/bin/psql -d postgres -f outputfile
+
+ using the new psql.
+
+ The least downtime can be achieved by installing the new server in
+ a different directory and running both the old and the new servers
+ in parallel, on different ports. Then you can use something like:
+
+
+pg_dumpall -p 5432 | psql -d postgres -p 5433
+
+ to transfer your data.
+
19.6.2. Upgrading Data via pg_upgrade #
+ The pg_upgrade module allows an installation to
+ be migrated in-place from one major PostgreSQL
+ version to another. Upgrades can be performed in minutes,
+ particularly with --link mode. It requires steps similar to
+ pg_dumpall above, e.g., starting/stopping the server,
+ running initdb. The pg_upgrade documentation outlines the necessary steps.
+
19.6.3. Upgrading Data via Replication #
+ It is also possible to use logical replication methods to create a standby
+ server with the updated version of PostgreSQL.
+ This is possible because logical replication supports
+ replication between different major versions of
+ PostgreSQL. The standby can be on the same computer or
+ a different computer. Once it has synced up with the primary server
+ (running the older version of PostgreSQL), you can
+ switch primaries and make the standby the primary and shut down the older
+ database instance. Such a switch-over results in only several seconds
+ of downtime for an upgrade.
+
+ This method of upgrading can be performed using the built-in logical
+ replication facilities as well as using external logical replication
+ systems such as pglogical,
+ Slony, Londiste, and
+ Bucardo.
+
Chapter 22. Database Roles
+ PostgreSQL manages database access permissions
+ using the concept of roles. A role can be thought of as
+ either a database user, or a group of database users, depending on how
+ the role is set up. Roles can own database objects (for example, tables
+ and functions) and can assign privileges on those objects to other roles to
+ control who has access to which objects. Furthermore, it is possible
+ to grant membership in a role to another role, thus
+ allowing the member role to use privileges assigned to another role.
+
+ The concept of roles subsumes the concepts of “users” and
+ “groups”. In PostgreSQL versions
+ before 8.1, users and groups were distinct kinds of entities, but now
+ there are only roles. Any role can act as a user, a group, or both.
+
+ This chapter describes how to create and manage roles.
+ More information about the effects of role privileges on various
+ database objects can be found in Section 5.7.
+
+ PostgreSQL devises a query
+ plan for each query it receives. Choosing the right
+ plan to match the query structure and the properties of the data
+ is absolutely critical for good performance, so the system includes
+ a complex planner that tries to choose good plans.
+ You can use the EXPLAIN command
+ to see what query plan the planner creates for any query.
+ Plan-reading is an art that requires some experience to master,
+ but this section attempts to cover the basics.
+
+ Examples in this section are drawn from the regression test database
+ after doing a VACUUM ANALYZE, using 9.3 development sources.
+ You should be able to get similar results if you try the examples
+ yourself, but your estimated costs and row counts might vary slightly
+ because ANALYZE's statistics are random samples rather
+ than exact, and because costs are inherently somewhat platform-dependent.
+
+ The examples use EXPLAIN's default “text” output
+ format, which is compact and convenient for humans to read.
+ If you want to feed EXPLAIN's output to a program for further
+ analysis, you should use one of its machine-readable output formats
+ (XML, JSON, or YAML) instead.
+
+ The structure of a query plan is a tree of plan nodes.
+ Nodes at the bottom level of the tree are scan nodes: they return raw rows
+ from a table. There are different types of scan nodes for different
+ table access methods: sequential scans, index scans, and bitmap index
+ scans. There are also non-table row sources, such as VALUES
+ clauses and set-returning functions in FROM, which have their
+ own scan node types.
+ If the query requires joining, aggregation, sorting, or other
+ operations on the raw rows, then there will be additional nodes
+ above the scan nodes to perform these operations. Again,
+ there is usually more than one possible way to do these operations,
+ so different node types can appear here too. The output
+ of EXPLAIN has one line for each node in the plan
+ tree, showing the basic node type plus the cost estimates that the planner
+ made for the execution of that plan node. Additional lines might appear,
+ indented from the node's summary line,
+ to show additional properties of the node.
+ The very first line (the summary line for the topmost
+ node) has the estimated total execution cost for the plan; it is this
+ number that the planner seeks to minimize.
+
+ Here is a trivial example, just to show what the output looks like:
+
+
+EXPLAIN SELECT * FROM tenk1;
+
+ QUERY PLAN
+-------------------------------------------------------------
+ Seq Scan on tenk1 (cost=0.00..458.00 rows=10000 width=244)
+
+
+ Since this query has no WHERE clause, it must scan all the
+ rows of the table, so the planner has chosen to use a simple sequential
+ scan plan. The numbers that are quoted in parentheses are (left
+ to right):
+
+
+ Estimated start-up cost. This is the time expended before the output
+ phase can begin, e.g., time to do the sorting in a sort node.
+
+ Estimated total cost. This is stated on the assumption that the plan
+ node is run to completion, i.e., all available rows are retrieved.
+ In practice a node's parent node might stop short of reading all
+ available rows (see the LIMIT example below).
+
+ Estimated number of rows output by this plan node. Again, the node
+ is assumed to be run to completion.
+
+ Estimated average width of rows output by this plan node (in bytes).
+
+
+ The costs are measured in arbitrary units determined by the planner's
+ cost parameters (see Section 20.7.2).
+ Traditional practice is to measure the costs in units of disk page
+ fetches; that is, seq_page_cost is conventionally
+ set to 1.0 and the other cost parameters are set relative
+ to that. The examples in this section are run with the default cost
+ parameters.
+
+ It's important to understand that the cost of an upper-level node includes
+ the cost of all its child nodes. It's also important to realize that
+ the cost only reflects things that the planner cares about.
+ In particular, the cost does not consider the time spent transmitting
+ result rows to the client, which could be an important
+ factor in the real elapsed time; but the planner ignores it because
+ it cannot change it by altering the plan. (Every correct plan will
+ output the same row set, we trust.)
+
+ The rows value is a little tricky because it is
+ not the number of rows processed or scanned by the
+ plan node, but rather the number emitted by the node. This is often
+ less than the number scanned, as a result of filtering by any
+ WHERE-clause conditions that are being applied at the node.
+ Ideally the top-level rows estimate will approximate the number of rows
+ actually returned, updated, or deleted by the query.
+
+ Returning to our example:
+
+
+EXPLAIN SELECT * FROM tenk1;
+
+ QUERY PLAN
+-------------------------------------------------------------
+ Seq Scan on tenk1 (cost=0.00..458.00 rows=10000 width=244)
+
+
+ These numbers are derived very straightforwardly. If you do:
+
+
+SELECT relpages, reltuples FROM pg_class WHERE relname = 'tenk1';
+
+
+ you will find that tenk1 has 358 disk
+ pages and 10000 rows. The estimated cost is computed as (disk pages read *
+ seq_page_cost) + (rows scanned *
+ cpu_tuple_cost). By default,
+ seq_page_cost is 1.0 and cpu_tuple_cost is 0.01,
+ so the estimated cost is (358 * 1.0) + (10000 * 0.01) = 458.
+
+ Now let's modify the query to add a WHERE condition:
+
+
+EXPLAIN SELECT * FROM tenk1 WHERE unique1 < 7000;
+
+ QUERY PLAN
+------------------------------------------------------------
+ Seq Scan on tenk1 (cost=0.00..483.00 rows=7001 width=244)
+ Filter: (unique1 < 7000)
+
+
+ Notice that the EXPLAIN output shows the WHERE
+ clause being applied as a “filter” condition attached to the Seq
+ Scan plan node. This means that
+ the plan node checks the condition for each row it scans, and outputs
+ only the ones that pass the condition.
+ The estimate of output rows has been reduced because of the
+ WHERE clause.
+ However, the scan will still have to visit all 10000 rows, so the cost
+ hasn't decreased; in fact it has gone up a bit (by 10000 * cpu_operator_cost, to be exact) to reflect the extra CPU
+ time spent checking the WHERE condition.
+
+ The actual number of rows this query would select is 7000, but the rows
+ estimate is only approximate. If you try to duplicate this experiment,
+ you will probably get a slightly different estimate; moreover, it can
+ change after each ANALYZE command, because the
+ statistics produced by ANALYZE are taken from a
+ randomized sample of the table.
+
+ Now, let's make the condition more restrictive:
+
+
+EXPLAIN SELECT * FROM tenk1 WHERE unique1 < 100;
+
+ QUERY PLAN
+------------------------------------------------------------------------------
+ Bitmap Heap Scan on tenk1 (cost=5.07..229.20 rows=101 width=244)
+ Recheck Cond: (unique1 < 100)
+ -> Bitmap Index Scan on tenk1_unique1 (cost=0.00..5.04 rows=101 width=0)
+ Index Cond: (unique1 < 100)
+
+
+ Here the planner has decided to use a two-step plan: the child plan
+ node visits an index to find the locations of rows matching the index
+ condition, and then the upper plan node actually fetches those rows
+ from the table itself. Fetching rows separately is much more
+ expensive than reading them sequentially, but because not all the pages
+ of the table have to be visited, this is still cheaper than a sequential
+ scan. (The reason for using two plan levels is that the upper plan
+ node sorts the row locations identified by the index into physical order
+ before reading them, to minimize the cost of separate fetches.
+ The “bitmap” mentioned in the node names is the mechanism that
+ does the sorting.)
+
+ Now let's add another condition to the WHERE clause:
+
+
+EXPLAIN SELECT * FROM tenk1 WHERE unique1 < 100 AND stringu1 = 'xxx';
+
+ QUERY PLAN
+------------------------------------------------------------------------------
+ Bitmap Heap Scan on tenk1 (cost=5.04..229.43 rows=1 width=244)
+ Recheck Cond: (unique1 < 100)
+ Filter: (stringu1 = 'xxx'::name)
+ -> Bitmap Index Scan on tenk1_unique1 (cost=0.00..5.04 rows=101 width=0)
+ Index Cond: (unique1 < 100)
+
+
+ The added condition stringu1 = 'xxx' reduces the
+ output row count estimate, but not the cost because we still have to visit
+ the same set of rows. Notice that the stringu1 clause
+ cannot be applied as an index condition, since this index is only on
+ the unique1 column. Instead it is applied as a filter on
+ the rows retrieved by the index. Thus the cost has actually gone up
+ slightly to reflect this extra checking.
+
+ In some cases the planner will prefer a “simple” index scan plan:
+
+
+EXPLAIN SELECT * FROM tenk1 WHERE unique1 = 42;
+
+ QUERY PLAN
+-----------------------------------------------------------------------------
+ Index Scan using tenk1_unique1 on tenk1 (cost=0.29..8.30 rows=1 width=244)
+ Index Cond: (unique1 = 42)
+
+
+ In this type of plan the table rows are fetched in index order, which
+ makes them even more expensive to read, but there are so few that the
+ extra cost of sorting the row locations is not worth it. You'll most
+ often see this plan type for queries that fetch just a single row. It's
+ also often used for queries that have an ORDER BY condition
+ that matches the index order, because then no extra sorting step is needed
+ to satisfy the ORDER BY. In this example, adding
+ ORDER BY unique1 would use the same plan because the
+ index already implicitly provides the requested ordering.
+
+ The planner may implement an ORDER BY clause in several
+ ways. The above example shows that such an ordering clause may be
+ implemented implicitly. The planner may also add an explicit
+ sort step:
+
+
+EXPLAIN SELECT * FROM tenk1 ORDER BY unique1;
+ QUERY PLAN
+-------------------------------------------------------------------
+ Sort (cost=1109.39..1134.39 rows=10000 width=244)
+ Sort Key: unique1
+ -> Seq Scan on tenk1 (cost=0.00..445.00 rows=10000 width=244)
+
+
+ If a part of the plan guarantees an ordering on a prefix of the
+ required sort keys, then the planner may instead decide to use an
+ incremental sort step:
+
+
+EXPLAIN SELECT * FROM tenk1 ORDER BY four, ten LIMIT 100;
+ QUERY PLAN
+------------------------------------------------------------------------------------------------------
+ Limit (cost=521.06..538.05 rows=100 width=244)
+ -> Incremental Sort (cost=521.06..2220.95 rows=10000 width=244)
+ Sort Key: four, ten
+ Presorted Key: four
+ -> Index Scan using index_tenk1_on_four on tenk1 (cost=0.29..1510.08 rows=10000 width=244)
+
+
+ Compared to regular sorts, sorting incrementally allows returning tuples
+ before the entire result set has been sorted, which particularly enables
+ optimizations with LIMIT queries. It may also reduce
+ memory usage and the likelihood of spilling sorts to disk, but it comes at
+ the cost of the increased overhead of splitting the result set into multiple
+ sorting batches.
+
+ If there are separate indexes on several of the columns referenced
+ in WHERE, the planner might choose to use an AND or OR
+ combination of the indexes:
+
+
+EXPLAIN SELECT * FROM tenk1 WHERE unique1 < 100 AND unique2 > 9000;
+
+ QUERY PLAN
+-------------------------------------------------------------------------------------
+ Bitmap Heap Scan on tenk1 (cost=25.08..60.21 rows=10 width=244)
+ Recheck Cond: ((unique1 < 100) AND (unique2 > 9000))
+ -> BitmapAnd (cost=25.08..25.08 rows=10 width=0)
+ -> Bitmap Index Scan on tenk1_unique1 (cost=0.00..5.04 rows=101 width=0)
+ Index Cond: (unique1 < 100)
+ -> Bitmap Index Scan on tenk1_unique2 (cost=0.00..19.78 rows=999 width=0)
+ Index Cond: (unique2 > 9000)
+
+
+ But this requires visiting both indexes, so it's not necessarily a win
+ compared to using just one index and treating the other condition as
+ a filter. If you vary the ranges involved you'll see the plan change
+ accordingly.
+
+ Here is an example showing the effects of LIMIT:
+
+
+EXPLAIN SELECT * FROM tenk1 WHERE unique1 < 100 AND unique2 > 9000 LIMIT 2;
+
+ QUERY PLAN
+-------------------------------------------------------------------------------------
+ Limit (cost=0.29..14.48 rows=2 width=244)
+ -> Index Scan using tenk1_unique2 on tenk1 (cost=0.29..71.27 rows=10 width=244)
+ Index Cond: (unique2 > 9000)
+ Filter: (unique1 < 100)
+
+
+ This is the same query as above, but we added a LIMIT so that
+ not all the rows need be retrieved, and the planner changed its mind about
+ what to do. Notice that the total cost and row count of the Index Scan
+ node are shown as if it were run to completion. However, the Limit node
+ is expected to stop after retrieving only a fifth of those rows, so its
+ total cost is only a fifth as much, and that's the actual estimated cost
+ of the query. This plan is preferred over adding a Limit node to the
+ previous plan because the Limit could not avoid paying the startup cost
+ of the bitmap scan, so the total cost would be something over 25 units
+ with that approach.
+
+ Let's try joining two tables, using the columns we have been discussing:
+
+
+EXPLAIN SELECT *
+FROM tenk1 t1, tenk2 t2
+WHERE t1.unique1 < 10 AND t1.unique2 = t2.unique2;
+
+ QUERY PLAN
+--------------------------------------------------------------------------------------
+ Nested Loop (cost=4.65..118.62 rows=10 width=488)
+ -> Bitmap Heap Scan on tenk1 t1 (cost=4.36..39.47 rows=10 width=244)
+ Recheck Cond: (unique1 < 10)
+ -> Bitmap Index Scan on tenk1_unique1 (cost=0.00..4.36 rows=10 width=0)
+ Index Cond: (unique1 < 10)
+ -> Index Scan using tenk2_unique2 on tenk2 t2 (cost=0.29..7.91 rows=1 width=244)
+ Index Cond: (unique2 = t1.unique2)
+
+
+ In this plan, we have a nested-loop join node with two table scans as
+ inputs, or children. The indentation of the node summary lines reflects
+ the plan tree structure. The join's first, or “outer”, child
+ is a bitmap scan similar to those we saw before. Its cost and row count
+ are the same as we'd get from SELECT ... WHERE unique1 < 10
+ because we are
+ applying the WHERE clause unique1 < 10
+ at that node.
+ The t1.unique2 = t2.unique2 clause is not relevant yet,
+ so it doesn't affect the row count of the outer scan. The nested-loop
+ join node will run its second,
+ or “inner” child once for each row obtained from the outer child.
+ Column values from the current outer row can be plugged into the inner
+ scan; here, the t1.unique2 value from the outer row is available,
+ so we get a plan and costs similar to what we saw above for a simple
+ SELECT ... WHERE t2.unique2 = constant case.
+ (The estimated cost is actually a bit lower than what was seen above,
+ as a result of caching that's expected to occur during the repeated
+ index scans on t2.) The
+ costs of the loop node are then set on the basis of the cost of the outer
+ scan, plus one repetition of the inner scan for each outer row (10 * 7.91,
+ here), plus a little CPU time for join processing.
+
+ In this example the join's output row count is the same as the product
+ of the two scans' row counts, but that's not true in all cases because
+ there can be additional WHERE clauses that mention both tables
+ and so can only be applied at the join point, not to either input scan.
+ Here's an example:
+
+
+EXPLAIN SELECT *
+FROM tenk1 t1, tenk2 t2
+WHERE t1.unique1 < 10 AND t2.unique2 < 10 AND t1.hundred < t2.hundred;
+
+ QUERY PLAN
+---------------------------------------------------------------------------------------------
+ Nested Loop (cost=4.65..49.46 rows=33 width=488)
+ Join Filter: (t1.hundred < t2.hundred)
+ -> Bitmap Heap Scan on tenk1 t1 (cost=4.36..39.47 rows=10 width=244)
+ Recheck Cond: (unique1 < 10)
+ -> Bitmap Index Scan on tenk1_unique1 (cost=0.00..4.36 rows=10 width=0)
+ Index Cond: (unique1 < 10)
+ -> Materialize (cost=0.29..8.51 rows=10 width=244)
+ -> Index Scan using tenk2_unique2 on tenk2 t2 (cost=0.29..8.46 rows=10 width=244)
+ Index Cond: (unique2 < 10)
+
+
+ The condition t1.hundred < t2.hundred can't be
+ tested in the tenk2_unique2 index, so it's applied at the
+ join node. This reduces the estimated output row count of the join node,
+ but does not change either input scan.
+
+ Notice that here the planner has chosen to “materialize” the inner
+ relation of the join, by putting a Materialize plan node atop it. This
+ means that the t2 index scan will be done just once, even
+ though the nested-loop join node needs to read that data ten times, once
+ for each row from the outer relation. The Materialize node saves the data
+ in memory as it's read, and then returns the data from memory on each
+ subsequent pass.
+
+ When dealing with outer joins, you might see join plan nodes with both
+ “Join Filter” and plain “Filter” conditions attached.
+ Join Filter conditions come from the outer join's ON clause,
+ so a row that fails the Join Filter condition could still get emitted as
+ a null-extended row. But a plain Filter condition is applied after the
+ outer-join rules and so acts to remove rows unconditionally. In an inner
+ join there is no semantic difference between these types of filters.
+
+ If we change the query's selectivity a bit, we might get a very different
+ join plan:
+
+
+EXPLAIN SELECT *
+FROM tenk1 t1, tenk2 t2
+WHERE t1.unique1 < 100 AND t1.unique2 = t2.unique2;
+
+ QUERY PLAN
+------------------------------------------------------------------------------------------
+ Hash Join (cost=230.47..713.98 rows=101 width=488)
+ Hash Cond: (t2.unique2 = t1.unique2)
+ -> Seq Scan on tenk2 t2 (cost=0.00..445.00 rows=10000 width=244)
+ -> Hash (cost=229.20..229.20 rows=101 width=244)
+ -> Bitmap Heap Scan on tenk1 t1 (cost=5.07..229.20 rows=101 width=244)
+ Recheck Cond: (unique1 < 100)
+ -> Bitmap Index Scan on tenk1_unique1 (cost=0.00..5.04 rows=101 width=0)
+ Index Cond: (unique1 < 100)
+
+
+ Here, the planner has chosen to use a hash join, in which rows of one
+ table are entered into an in-memory hash table, after which the other
+ table is scanned and the hash table is probed for matches to each row.
+ Again note how the indentation reflects the plan structure: the bitmap
+ scan on tenk1 is the input to the Hash node, which constructs
+ the hash table. That's then returned to the Hash Join node, which reads
+ rows from its outer child plan and searches the hash table for each one.
+
+ Another possible type of join is a merge join, illustrated here:
+
+
+EXPLAIN SELECT *
+FROM tenk1 t1, onek t2
+WHERE t1.unique1 < 100 AND t1.unique2 = t2.unique2;
+
+ QUERY PLAN
+------------------------------------------------------------------------------------------
+ Merge Join (cost=198.11..268.19 rows=10 width=488)
+ Merge Cond: (t1.unique2 = t2.unique2)
+ -> Index Scan using tenk1_unique2 on tenk1 t1 (cost=0.29..656.28 rows=101 width=244)
+ Filter: (unique1 < 100)
+ -> Sort (cost=197.83..200.33 rows=1000 width=244)
+ Sort Key: t2.unique2
+ -> Seq Scan on onek t2 (cost=0.00..148.00 rows=1000 width=244)
+
+
+ Merge join requires its input data to be sorted on the join keys. In this
+ plan the tenk1 data is sorted by using an index scan to visit
+ the rows in the correct order, but a sequential scan and sort is preferred
+ for onek, because there are many more rows to be visited in
+ that table.
+ (Sequential-scan-and-sort frequently beats an index scan for sorting many rows,
+ because of the nonsequential disk access required by the index scan.)
+
+ One way to look at variant plans is to force the planner to disregard
+ whatever strategy it thought was the cheapest, using the enable/disable
+ flags described in Section 20.7.1.
+ (This is a crude tool, but useful. See
+ also Section 14.3.)
+ For example, if we're unconvinced that sequential-scan-and-sort is the best way to
+ deal with table onek in the previous example, we could try
+
+
+SET enable_sort = off;
+
+EXPLAIN SELECT *
+FROM tenk1 t1, onek t2
+WHERE t1.unique1 < 100 AND t1.unique2 = t2.unique2;
+
+ QUERY PLAN
+------------------------------------------------------------------------------------------
+ Merge Join (cost=0.56..292.65 rows=10 width=488)
+ Merge Cond: (t1.unique2 = t2.unique2)
+ -> Index Scan using tenk1_unique2 on tenk1 t1 (cost=0.29..656.28 rows=101 width=244)
+ Filter: (unique1 < 100)
+ -> Index Scan using onek_unique2 on onek t2 (cost=0.28..224.79 rows=1000 width=244)
+
+
+ which shows that the planner thinks that sorting onek by
+ index-scanning is about 12% more expensive than sequential-scan-and-sort.
+ Of course, the next question is whether it's right about that.
+ We can investigate that using EXPLAIN ANALYZE, as discussed
+ below.
+
14.1.2. EXPLAIN ANALYZE #
+ It is possible to check the accuracy of the planner's estimates
+ by using EXPLAIN's ANALYZE option. With this
+ option, EXPLAIN actually executes the query, and then displays
+ the true row counts and true run time accumulated within each plan node,
+ along with the same estimates that a plain EXPLAIN
+ shows. For example, we might get a result like this:
+
+
+EXPLAIN ANALYZE SELECT *
+FROM tenk1 t1, tenk2 t2
+WHERE t1.unique1 < 10 AND t1.unique2 = t2.unique2;
+
+ QUERY PLAN
+---------------------------------------------------------------------------------------------------------------------------------
+ Nested Loop (cost=4.65..118.62 rows=10 width=488) (actual time=0.128..0.377 rows=10 loops=1)
+ -> Bitmap Heap Scan on tenk1 t1 (cost=4.36..39.47 rows=10 width=244) (actual time=0.057..0.121 rows=10 loops=1)
+ Recheck Cond: (unique1 < 10)
+ -> Bitmap Index Scan on tenk1_unique1 (cost=0.00..4.36 rows=10 width=0) (actual time=0.024..0.024 rows=10 loops=1)
+ Index Cond: (unique1 < 10)
+ -> Index Scan using tenk2_unique2 on tenk2 t2 (cost=0.29..7.91 rows=1 width=244) (actual time=0.021..0.022 rows=1 loops=10)
+ Index Cond: (unique2 = t1.unique2)
+ Planning time: 0.181 ms
+ Execution time: 0.501 ms
+
+
+ Note that the “actual time” values are in milliseconds of
+ real time, whereas the cost estimates are expressed in
+ arbitrary units; so they are unlikely to match up.
+ The thing that's usually most important to look for is whether the
+ estimated row counts are reasonably close to reality. In this example
+ the estimates were all dead-on, but that's quite unusual in practice.
+
+ In some query plans, it is possible for a subplan node to be executed more
+ than once. For example, the inner index scan will be executed once per
+ outer row in the above nested-loop plan. In such cases, the
+ loops value reports the
+ total number of executions of the node, and the actual time and rows
+ values shown are averages per-execution. This is done to make the numbers
+ comparable with the way that the cost estimates are shown. Multiply by
+ the loops value to get the total time actually spent in
+ the node. In the above example, we spent a total of 0.220 milliseconds
+ executing the index scans on tenk2.
+
+ In some cases EXPLAIN ANALYZE shows additional execution
+ statistics beyond the plan node execution times and row counts.
+ For example, Sort and Hash nodes provide extra information:
+
+
+EXPLAIN ANALYZE SELECT *
+FROM tenk1 t1, tenk2 t2
+WHERE t1.unique1 < 100 AND t1.unique2 = t2.unique2 ORDER BY t1.fivethous;
+
+ QUERY PLAN
+--------------------------------------------------------------------------------------------------------------------------------------------
+ Sort (cost=717.34..717.59 rows=101 width=488) (actual time=7.761..7.774 rows=100 loops=1)
+ Sort Key: t1.fivethous
+ Sort Method: quicksort Memory: 77kB
+ -> Hash Join (cost=230.47..713.98 rows=101 width=488) (actual time=0.711..7.427 rows=100 loops=1)
+ Hash Cond: (t2.unique2 = t1.unique2)
+ -> Seq Scan on tenk2 t2 (cost=0.00..445.00 rows=10000 width=244) (actual time=0.007..2.583 rows=10000 loops=1)
+ -> Hash (cost=229.20..229.20 rows=101 width=244) (actual time=0.659..0.659 rows=100 loops=1)
+ Buckets: 1024 Batches: 1 Memory Usage: 28kB
+ -> Bitmap Heap Scan on tenk1 t1 (cost=5.07..229.20 rows=101 width=244) (actual time=0.080..0.526 rows=100 loops=1)
+ Recheck Cond: (unique1 < 100)
+ -> Bitmap Index Scan on tenk1_unique1 (cost=0.00..5.04 rows=101 width=0) (actual time=0.049..0.049 rows=100 loops=1)
+ Index Cond: (unique1 < 100)
+ Planning time: 0.194 ms
+ Execution time: 8.008 ms
+
+
+ The Sort node shows the sort method used (in particular, whether the sort
+ was in-memory or on-disk) and the amount of memory or disk space needed.
+ The Hash node shows the number of hash buckets and batches as well as the
+ peak amount of memory used for the hash table. (If the number of batches
+ exceeds one, there will also be disk space usage involved, but that is not
+ shown.)
+
+ Another type of extra information is the number of rows removed by a
+ filter condition:
+
+
+EXPLAIN ANALYZE SELECT * FROM tenk1 WHERE ten < 7;
+
+ QUERY PLAN
+---------------------------------------------------------------------------------------------------------
+ Seq Scan on tenk1 (cost=0.00..483.00 rows=7000 width=244) (actual time=0.016..5.107 rows=7000 loops=1)
+ Filter: (ten < 7)
+ Rows Removed by Filter: 3000
+ Planning time: 0.083 ms
+ Execution time: 5.905 ms
+
+
+ These counts can be particularly valuable for filter conditions applied at
+ join nodes. The “Rows Removed” line only appears when at least
+ one scanned row, or potential join pair in the case of a join node,
+ is rejected by the filter condition.
+
+ A case similar to filter conditions occurs with “lossy”
+ index scans. For example, consider this search for polygons containing a
+ specific point:
+
+
+EXPLAIN ANALYZE SELECT * FROM polygon_tbl WHERE f1 @> polygon '(0.5,2.0)';
+
+ QUERY PLAN
+------------------------------------------------------------------------------------------------------
+ Seq Scan on polygon_tbl (cost=0.00..1.05 rows=1 width=32) (actual time=0.044..0.044 rows=0 loops=1)
+ Filter: (f1 @> '((0.5,2))'::polygon)
+ Rows Removed by Filter: 4
+ Planning time: 0.040 ms
+ Execution time: 0.083 ms
+
+
+ The planner thinks (quite correctly) that this sample table is too small
+ to bother with an index scan, so we have a plain sequential scan in which
+ all the rows got rejected by the filter condition. But if we force an
+ index scan to be used, we see:
+
+
+SET enable_seqscan TO off;
+
+EXPLAIN ANALYZE SELECT * FROM polygon_tbl WHERE f1 @> polygon '(0.5,2.0)';
+
+ QUERY PLAN
+--------------------------------------------------------------------------------------------------------------------------
+ Index Scan using gpolygonind on polygon_tbl (cost=0.13..8.15 rows=1 width=32) (actual time=0.062..0.062 rows=0 loops=1)
+ Index Cond: (f1 @> '((0.5,2))'::polygon)
+ Rows Removed by Index Recheck: 1
+ Planning time: 0.034 ms
+ Execution time: 0.144 ms
+
+
+ Here we can see that the index returned one candidate row, which was
+ then rejected by a recheck of the index condition. This happens because a
+ GiST index is “lossy” for polygon containment tests: it actually
+ returns the rows with polygons that overlap the target, and then we have
+ to do the exact containment test on those rows.
+
+ EXPLAIN has a BUFFERS option that can be used with
+ ANALYZE to get even more run time statistics:
+
+
+EXPLAIN (ANALYZE, BUFFERS) SELECT * FROM tenk1 WHERE unique1 < 100 AND unique2 > 9000;
+
+ QUERY PLAN
+---------------------------------------------------------------------------------------------------------------------------------
+ Bitmap Heap Scan on tenk1 (cost=25.08..60.21 rows=10 width=244) (actual time=0.323..0.342 rows=10 loops=1)
+ Recheck Cond: ((unique1 < 100) AND (unique2 > 9000))
+ Buffers: shared hit=15
+ -> BitmapAnd (cost=25.08..25.08 rows=10 width=0) (actual time=0.309..0.309 rows=0 loops=1)
+ Buffers: shared hit=7
+ -> Bitmap Index Scan on tenk1_unique1 (cost=0.00..5.04 rows=101 width=0) (actual time=0.043..0.043 rows=100 loops=1)
+ Index Cond: (unique1 < 100)
+ Buffers: shared hit=2
+ -> Bitmap Index Scan on tenk1_unique2 (cost=0.00..19.78 rows=999 width=0) (actual time=0.227..0.227 rows=999 loops=1)
+ Index Cond: (unique2 > 9000)
+ Buffers: shared hit=5
+ Planning time: 0.088 ms
+ Execution time: 0.423 ms
+
+
+ The numbers provided by BUFFERS help to identify which parts
+ of the query are the most I/O-intensive.
+
+ Keep in mind that because EXPLAIN ANALYZE actually
+ runs the query, any side-effects will happen as usual, even though
+ whatever results the query might output are discarded in favor of
+ printing the EXPLAIN data. If you want to analyze a
+ data-modifying query without changing your tables, you can
+ roll the command back afterwards, for example:
+
+
+BEGIN;
+
+EXPLAIN ANALYZE UPDATE tenk1 SET hundred = hundred + 1 WHERE unique1 < 100;
+
+ QUERY PLAN
+--------------------------------------------------------------------------------------------------------------------------------
+ Update on tenk1 (cost=5.08..230.08 rows=0 width=0) (actual time=3.791..3.792 rows=0 loops=1)
+ -> Bitmap Heap Scan on tenk1 (cost=5.08..230.08 rows=102 width=10) (actual time=0.069..0.513 rows=100 loops=1)
+ Recheck Cond: (unique1 < 100)
+ Heap Blocks: exact=90
+ -> Bitmap Index Scan on tenk1_unique1 (cost=0.00..5.05 rows=102 width=0) (actual time=0.036..0.037 rows=300 loops=1)
+ Index Cond: (unique1 < 100)
+ Planning Time: 0.113 ms
+ Execution Time: 3.850 ms
+
+ROLLBACK;
+
+
+ As seen in this example, when the query is an INSERT,
+ UPDATE, DELETE, or
+ MERGE command, the actual work of
+ applying the table changes is done by a top-level Insert, Update,
+ Delete, or Merge plan node. The plan nodes underneath this node perform
+ the work of locating the old rows and/or computing the new data.
+ So above, we see the same sort of bitmap table scan we've seen already,
+ and its output is fed to an Update node that stores the updated rows.
+ It's worth noting that although the data-modifying node can take a
+ considerable amount of run time (here, it's consuming the lion's share
+ of the time), the planner does not currently add anything to the cost
+ estimates to account for that work. That's because the work to be done is
+ the same for every correct query plan, so it doesn't affect planning
+ decisions.
+
+ When an UPDATE, DELETE, or
+ MERGE command affects an
+ inheritance hierarchy, the output might look like this:
+
+
+EXPLAIN UPDATE parent SET f2 = f2 + 1 WHERE f1 = 101;
+ QUERY PLAN
+------------------------------------------------------------------------------------------------------
+ Update on parent (cost=0.00..24.59 rows=0 width=0)
+ Update on parent parent_1
+ Update on child1 parent_2
+ Update on child2 parent_3
+ Update on child3 parent_4
+ -> Result (cost=0.00..24.59 rows=4 width=14)
+ -> Append (cost=0.00..24.54 rows=4 width=14)
+ -> Seq Scan on parent parent_1 (cost=0.00..0.00 rows=1 width=14)
+ Filter: (f1 = 101)
+ -> Index Scan using child1_pkey on child1 parent_2 (cost=0.15..8.17 rows=1 width=14)
+ Index Cond: (f1 = 101)
+ -> Index Scan using child2_pkey on child2 parent_3 (cost=0.15..8.17 rows=1 width=14)
+ Index Cond: (f1 = 101)
+ -> Index Scan using child3_pkey on child3 parent_4 (cost=0.15..8.17 rows=1 width=14)
+ Index Cond: (f1 = 101)
+
+
+ In this example the Update node needs to consider three child tables as
+ well as the originally-mentioned parent table. So there are four input
+ scanning subplans, one per table. For clarity, the Update node is
+ annotated to show the specific target tables that will be updated, in the
+ same order as the corresponding subplans.
+
+ The Planning time shown by EXPLAIN
+ ANALYZE is the time it took to generate the query plan from the
+ parsed query and optimize it. It does not include parsing or rewriting.
+
+ The Execution time shown by EXPLAIN
+ ANALYZE includes executor start-up and shut-down time, as well
+ as the time to run any triggers that are fired, but it does not include
+ parsing, rewriting, or planning time.
+ Time spent executing BEFORE triggers, if any, is included in
+ the time for the related Insert, Update, or Delete node; but time
+ spent executing AFTER triggers is not counted there because
+ AFTER triggers are fired after completion of the whole plan.
+ The total time spent in each trigger
+ (either BEFORE or AFTER) is also shown separately.
+ Note that deferred constraint triggers will not be executed
+ until end of transaction and are thus not considered at all by
+ EXPLAIN ANALYZE.
+
+ There are two significant ways in which run times measured by
+ EXPLAIN ANALYZE can deviate from normal execution of
+ the same query. First, since no output rows are delivered to the client,
+ network transmission costs and I/O conversion costs are not included.
+ Second, the measurement overhead added by EXPLAIN
+ ANALYZE can be significant, especially on machines with slow
+ gettimeofday() operating-system calls. You can use the
+ pg_test_timing tool to measure the overhead of timing
+ on your system.
+
+ EXPLAIN results should not be extrapolated to situations
+ much different from the one you are actually testing; for example,
+ results on a toy-sized table cannot be assumed to apply to large tables.
+ The planner's cost estimates are not linear and so it might choose
+ a different plan for a larger or smaller table. An extreme example
+ is that on a table that only occupies one disk page, you'll nearly
+ always get a sequential scan plan whether indexes are available or not.
+ The planner realizes that it's going to take one disk page read to
+ process the table in any case, so there's no value in expending additional
+ page reads to look at an index. (We saw this happening in the
+ polygon_tbl example above.)
+
+ There are cases in which the actual and estimated values won't match up
+ well, but nothing is really wrong. One such case occurs when
+ plan node execution is stopped short by a LIMIT or similar
+ effect. For example, in the LIMIT query we used before,
+
+
+EXPLAIN ANALYZE SELECT * FROM tenk1 WHERE unique1 < 100 AND unique2 > 9000 LIMIT 2;
+
+ QUERY PLAN
+-------------------------------------------------------------------------------------------------------------------------------
+ Limit (cost=0.29..14.71 rows=2 width=244) (actual time=0.177..0.249 rows=2 loops=1)
+ -> Index Scan using tenk1_unique2 on tenk1 (cost=0.29..72.42 rows=10 width=244) (actual time=0.174..0.244 rows=2 loops=1)
+ Index Cond: (unique2 > 9000)
+ Filter: (unique1 < 100)
+ Rows Removed by Filter: 287
+ Planning time: 0.096 ms
+ Execution time: 0.336 ms
+
+
+ the estimated cost and row count for the Index Scan node are shown as
+ though it were run to completion. But in reality the Limit node stopped
+ requesting rows after it got two, so the actual row count is only 2 and
+ the run time is less than the cost estimate would suggest. This is not
+ an estimation error, only a discrepancy in the way the estimates and true
+ values are displayed.
+
+ Merge joins also have measurement artifacts that can confuse the unwary.
+ A merge join will stop reading one input if it's exhausted the other input
+ and the next key value in the one input is greater than the last key value
+ of the other input; in such a case there can be no more matches and so no
+ need to scan the rest of the first input. This results in not reading all
+ of one child, with results like those mentioned for LIMIT.
+ Also, if the outer (first) child contains rows with duplicate key values,
+ the inner (second) child is backed up and rescanned for the portion of its
+ rows matching that key value. EXPLAIN ANALYZE counts these
+ repeated emissions of the same inner rows as if they were real additional
+ rows. When there are many outer duplicates, the reported actual row count
+ for the inner child plan node can be significantly larger than the number
+ of rows that are actually in the inner relation.
+
+ BitmapAnd and BitmapOr nodes always report their actual row counts as zero,
+ due to implementation limitations.
+
+ Normally, EXPLAIN will display every plan node
+ created by the planner. However, there are cases where the executor
+ can determine that certain nodes need not be executed because they
+ cannot produce any rows, based on parameter values that were not
+ available at planning time. (Currently this can only happen for child
+ nodes of an Append or MergeAppend node that is scanning a partitioned
+ table.) When this happens, those plan nodes are omitted from
+ the EXPLAIN output and a Subplans
+ Removed: N annotation appears
+ instead.
+
F.49. uuid-ossp — a UUID generator #
+ The uuid-ossp module provides functions to generate universally
+ unique identifiers (UUIDs) using one of several standard algorithms. There
+ are also functions to produce certain special UUID constants.
+ This module is only necessary for special requirements beyond what is
+ available in core PostgreSQL. See Section 9.14 for built-in ways to generate UUIDs.
+
+ This module is considered “trusted”, that is, it can be
+ installed by non-superusers who have CREATE privilege
+ on the current database.
+
F.49.1. uuid-ossp Functions #
+ Table F.34 shows the functions available to
+ generate UUIDs.
+ The relevant standards ITU-T Rec. X.667, ISO/IEC 9834-8:2005, and
+ RFC 4122
+ specify four algorithms for generating UUIDs, identified by the
+ version numbers 1, 3, 4, and 5. (There is no version 2 algorithm.)
+ Each of these algorithms could be suitable for a different set of
+ applications.
+
Table F.34. Functions for UUID Generation
+ Function
+
+
+ Description
+ |
|---|
+
+ uuid_generate_v1 ()
+ → uuid
+
+
+ Generates a version 1 UUID. This involves the MAC
+ address of the computer and a time stamp. Note that UUIDs of this
+ kind reveal the identity of the computer that created the identifier
+ and the time at which it did so, which might make it unsuitable for
+ certain security-sensitive applications.
+ |
+
+ uuid_generate_v1mc ()
+ → uuid
+
+
+ Generates a version 1 UUID, but uses a random multicast
+ MAC address instead of the real MAC address of the computer.
+ |
+
+ uuid_generate_v3 ( namespace uuid, name text )
+ → uuid
+
+
+ Generates a version 3 UUID in the given namespace using
+ the specified input name. The namespace should be one of the special
+ constants produced by the uuid_ns_*() functions
+ shown in Table F.35. (It could be any UUID
+ in theory.) The name is an identifier in the selected namespace.
+
+
+ For example:
+
+
+SELECT uuid_generate_v3(uuid_ns_url(), 'http://www.postgresql.org');
+
+
+ The name parameter will be MD5-hashed, so the cleartext cannot be
+ derived from the generated UUID.
+ The generation of UUIDs by this method has no random or
+ environment-dependent element and is therefore reproducible.
+ |
+ uuid_generate_v4 ()
+ → uuid
+
+
+ Generates a version 4 UUID, which is derived entirely
+ from random numbers.
+ |
+ uuid_generate_v5 ( namespace uuid, name text )
+ → uuid
+
+
+ Generates a version 5 UUID, which works like a version 3
+ UUID except that SHA-1 is used as a hashing method. Version 5 should
+ be preferred over version 3 because SHA-1 is thought to be more secure
+ than MD5.
+ |
Table F.35. Functions Returning UUID Constants
+ Function
+
+
+ Description
+ |
|---|
+ uuid_nil ()
+ → uuid
+
+
+ Returns a “nil” UUID constant, which does not occur as a
+ real UUID.
+ |
+ uuid_ns_dns ()
+ → uuid
+
+
+ Returns a constant designating the DNS namespace for UUIDs.
+ |
+ uuid_ns_url ()
+ → uuid
+
+
+ Returns a constant designating the URL namespace for UUIDs.
+ |
+ uuid_ns_oid ()
+ → uuid
+
+
+ Returns a constant designating the ISO object identifier (OID) namespace for
+ UUIDs. (This pertains to ASN.1 OIDs, which are unrelated to the OIDs
+ used in PostgreSQL.)
+ |
+ uuid_ns_x500 ()
+ → uuid
+
+
+ Returns a constant designating the X.500 distinguished name (DN)
+ namespace for UUIDs.
+ |
F.49.2. Building uuid-ossp #
+ Historically this module depended on the OSSP UUID library, which accounts
+ for the module's name. While the OSSP UUID library can still be found
+ at http://www.ossp.org/pkg/lib/uuid/, it is not well
+ maintained, and is becoming increasingly difficult to port to newer
+ platforms. uuid-ossp can now be built without the OSSP
+ library on some platforms. On FreeBSD and some other BSD-derived
+ platforms, suitable UUID creation functions are included in the
+ core libc library. On Linux, macOS, and some other
+ platforms, suitable functions are provided in the libuuid
+ library, which originally came from the e2fsprogs project
+ (though on modern Linux it is considered part
+ of util-linux-ng). When invoking configure,
+ specify --with-uuid=bsd to use the BSD functions,
+ or --with-uuid=e2fs to
+ use e2fsprogs' libuuid, or
+ --with-uuid=ossp to use the OSSP UUID library.
+ More than one of these libraries might be available on a particular
+ machine, so configure does not automatically choose one.
+
vacuumlo
vacuumlo — remove orphaned large objects from a PostgreSQL database
Synopsis
vacuumlo [option...] dbname...
Description
+ vacuumlo is a simple utility program that will remove any
+ “orphaned” large objects from a
+ PostgreSQL database. An orphaned large object (LO) is
+ considered to be any LO whose OID does not appear in any oid or
+ lo data column of the database.
+
+ If you use this, you may also be interested in the lo_manage
+ trigger in the lo module.
+ lo_manage is useful to try
+ to avoid creating orphaned LOs in the first place.
+
+ All databases named on the command line are processed.
+
Options
+ vacuumlo accepts the following command-line arguments:
+
+
-l limit
--limit=limit
+ Remove no more than limit large objects per
+ transaction (default 1000). Since the server acquires a lock per LO
+ removed, removing too many LOs in one transaction risks exceeding
+ max_locks_per_transaction. Set the limit to
+ zero if you want all removals done in a single transaction.
+
-n
--dry-runDon't remove anything, just show what would be done.
-v
--verboseWrite a lot of progress messages.
-V
--version
+ Print the vacuumlo version and exit.
+
-?
--help
+ Show help about vacuumlo command line
+ arguments, and exit.
+
+
+ vacuumlo also accepts the following command-line
+ arguments for connection parameters:
+
+
-h host
--host=hostDatabase server's host.
-p port
--port=portDatabase server's port.
-U username
--username=usernameUser name to connect as.
-w
--no-password
+ Never issue a password prompt. If the server requires password
+ authentication and a password is not available by other means
+ such as a .pgpass file, the connection
+ attempt will fail. This option can be useful in batch jobs and
+ scripts where no user is present to enter a password.
+
-W
--password
+ Force vacuumlo to prompt for a
+ password before connecting to a database.
+
+ This option is never essential, since
+ vacuumlo will automatically prompt
+ for a password if the server demands password authentication.
+ However, vacuumlo will waste a
+ connection attempt finding out that the server wants a password.
+ In some cases it is worth typing -W to avoid the extra
+ connection attempt.
+
+
Environment
PGHOST
PGPORT
PGUSER
+ Default connection parameters.
+
+ This utility, like most other PostgreSQL utilities,
+ also uses the environment variables supported by libpq
+ (see Section 34.15).
+
+ The environment variable PG_COLOR specifies whether to use
+ color in diagnostic messages. Possible values are
+ always, auto and
+ never.
+
Notes
+ vacuumlo works by the following method:
+ First, vacuumlo builds a temporary table which contains all
+ of the OIDs of the large objects in the selected database. It then scans
+ through all columns in the database that are of type
+ oid or lo, and removes matching entries from the temporary
+ table. (Note: Only types with these names are considered; in particular,
+ domains over them are not considered.) The remaining entries in the
+ temporary table identify orphaned LOs. These are removed.
+
54.3. pg_available_extension_versions #
+ The pg_available_extension_versions view lists the
+ specific extension versions that are available for installation.
+ See also the pg_extension
+ catalog, which shows the extensions currently installed.
+
Table 54.3. pg_available_extension_versions Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ name name
+
+
+ Extension name
+ |
+ version text
+
+
+ Version name
+ |
+ installed bool
+
+
+ True if this version of this extension is currently
+ installed
+ |
+ superuser bool
+
+
+ True if only superusers are allowed to install this extension
+ (but see trusted)
+ |
+ trusted bool
+
+
+ True if the extension can be installed by non-superusers
+ with appropriate privileges
+ |
+ relocatable bool
+
+
+ True if extension can be relocated to another schema
+ |
+ schema name
+
+
+ Name of the schema that the extension must be installed into,
+ or NULL if partially or fully relocatable
+ |
+ requires name[]
+
+
+ Names of prerequisite extensions,
+ or NULL if none
+ |
+ comment text
+
+
+ Comment string from the extension's control file
+ |
+ The pg_available_extension_versions view is
+ read-only.
+
54.2. pg_available_extensions #
+ The pg_available_extensions view lists the
+ extensions that are available for installation.
+ See also the
+ pg_extension
+ catalog, which shows the extensions currently installed.
+
Table 54.2. pg_available_extensions Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ name name
+
+
+ Extension name
+ |
+ default_version text
+
+
+ Name of default version, or NULL if none is
+ specified
+ |
+ installed_version text
+
+
+ Currently installed version of the extension,
+ or NULL if not installed
+ |
+ comment text
+
+
+ Comment string from the extension's control file
+ |
+ The pg_available_extensions view is read-only.
+
54.4. pg_backend_memory_contexts #
+ The view pg_backend_memory_contexts displays all
+ the memory contexts of the server process attached to the current session.
+
+ pg_backend_memory_contexts contains one row
+ for each memory context.
+
Table 54.4. pg_backend_memory_contexts Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ name text
+
+
+ Name of the memory context
+ |
+ ident text
+
+
+ Identification information of the memory context. This field is truncated at 1024 bytes
+ |
+ parent text
+
+
+ Name of the parent of this memory context
+ |
+ level int4
+
+
+ Distance from TopMemoryContext in context tree
+ |
+ total_bytes int8
+
+
+ Total bytes allocated for this memory context
+ |
+ total_nblocks int8
+
+
+ Total number of blocks allocated for this memory context
+ |
+ free_bytes int8
+
+
+ Free space in bytes
+ |
+ free_chunks int8
+
+
+ Total number of free chunks
+ |
+ used_bytes int8
+
+
+ Used space in bytes
+ |
+ By default, the pg_backend_memory_contexts view can be
+ read only by superusers or roles with the privileges of the
+ pg_read_all_stats role.
+
+ The view pg_config describes the
+ compile-time configuration parameters of the currently installed
+ version of PostgreSQL. It is intended, for example, to
+ be used by software packages that want to interface to
+ PostgreSQL to facilitate finding the required header
+ files and libraries. It provides the same basic information as the
+ pg_config PostgreSQL client
+ application.
+
+ By default, the pg_config view can be read
+ only by superusers.
+
Table 54.5. pg_config Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ name text
+
+
+ The parameter name
+ |
+ setting text
+
+
+ The parameter value
+ |
+ The pg_cursors view lists the cursors that
+ are currently available. Cursors can be defined in several ways:
+
+ via the DECLARE
+ statement in SQL
+
+ via the Bind message in the frontend/backend protocol, as
+ described in Section 55.2.3
+
+ via the Server Programming Interface (SPI), as described in
+ Section 47.1
+
+
+ The pg_cursors view displays cursors
+ created by any of these means. Cursors only exist for the duration
+ of the transaction that defines them, unless they have been
+ declared WITH HOLD. Therefore non-holdable
+ cursors are only present in the view until the end of their
+ creating transaction.
+
+
Note
+ Cursors are used internally to implement some of the components
+ of PostgreSQL, such as procedural languages.
+ Therefore, the pg_cursors view might include cursors
+ that have not been explicitly created by the user.
+
+
Table 54.6. pg_cursors Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ name text
+
+
+ The name of the cursor
+ |
+ statement text
+
+
+ The verbatim query string submitted to declare this cursor
+ |
+ is_holdable bool
+
+
+ true if the cursor is holdable (that is, it
+ can be accessed after the transaction that declared the cursor
+ has committed); false otherwise
+ |
+ is_binary bool
+
+
+ true if the cursor was declared
+ BINARY; false
+ otherwise
+ |
+ is_scrollable bool
+
+
+ true if the cursor is scrollable (that is, it
+ allows rows to be retrieved in a nonsequential manner);
+ false otherwise
+ |
+ creation_time timestamptz
+
+
+ The time at which the cursor was declared
+ |
+ The pg_cursors view is read-only.
+
+ The view pg_file_settings provides a summary of
+ the contents of the server's configuration file(s). A row appears in
+ this view for each “name = value” entry appearing in the files,
+ with annotations indicating whether the value could be applied
+ successfully. Additional row(s) may appear for problems not linked to
+ a “name = value” entry, such as syntax errors in the files.
+
+ This view is helpful for checking whether planned changes in the
+ configuration files will work, or for diagnosing a previous failure.
+ Note that this view reports on the current contents of the
+ files, not on what was last applied by the server. (The
+ pg_settings
+ view is usually sufficient to determine that.)
+
+ By default, the pg_file_settings view can be read
+ only by superusers.
+
Table 54.7. pg_file_settings Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ sourcefile text
+
+
+ Full path name of the configuration file
+ |
+ sourceline int4
+
+
+ Line number within the configuration file where the entry appears
+ |
+ seqno int4
+
+
+ Order in which the entries are processed (1..n)
+ |
+ name text
+
+
+ Configuration parameter name
+ |
+ setting text
+
+
+ Value to be assigned to the parameter
+ |
+ applied bool
+
+
+ True if the value can be applied successfully
+ |
+ error text
+
+
+ If not null, an error message indicating why this entry could
+ not be applied
+ |
+ If the configuration file contains syntax errors or invalid parameter
+ names, the server will not attempt to apply any settings from it, and
+ therefore all the applied fields will read as false.
+ In such a case there will be one or more rows with
+ non-null error fields indicating the
+ problem(s). Otherwise, individual settings will be applied if possible.
+ If an individual setting cannot be applied (e.g., invalid value, or the
+ setting cannot be changed after server start) it will have an appropriate
+ message in the error field. Another way that
+ an entry might have applied = false is that it is
+ overridden by a later entry for the same parameter name; this case is not
+ considered an error so nothing appears in
+ the error field.
+
+ See Section 20.1 for more information about the various
+ ways to change run-time parameters.
+
+ The view pg_group exists for backwards
+ compatibility: it emulates a catalog that existed in
+ PostgreSQL before version 8.1.
+ It shows the names and members of all roles that are marked as not
+ rolcanlogin, which is an approximation to the set
+ of roles that are being used as groups.
+
Table 54.8. pg_group Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ groname name
+ (references pg_authid.rolname)
+
+
+ Name of the group
+ |
+ grosysid oid
+ (references pg_authid.oid)
+
+
+ ID of this group
+ |
+ grolist oid[]
+ (references pg_authid.oid)
+
+
+ An array containing the IDs of the roles in this group
+ |
54.9. pg_hba_file_rules #
+ The view pg_hba_file_rules provides a summary of
+ the contents of the client authentication configuration file,
+ pg_hba.conf.
+ A row appears in this view for each
+ non-empty, non-comment line in the file, with annotations indicating
+ whether the rule could be applied successfully.
+
+ This view can be helpful for checking whether planned changes in the
+ authentication configuration file will work, or for diagnosing a previous
+ failure. Note that this view reports on the current contents
+ of the file, not on what was last loaded by the server.
+
+ By default, the pg_hba_file_rules view can be read
+ only by superusers.
+
Table 54.9. pg_hba_file_rules Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ rule_number int4
+
+
+ Number of this rule, if valid, otherwise NULL.
+ This indicates the order in which each rule is considered
+ until a match is found during authentication.
+ |
+ file_name text
+
+
+ Name of the file containing this rule
+ |
+ line_number int4
+
+
+ Line number of this rule in file_name
+ |
+ type text
+
+
+ Type of connection
+ |
+ database text[]
+
+
+ List of database name(s) to which this rule applies
+ |
+ user_name text[]
+
+
+ List of user and group name(s) to which this rule applies
+ |
+ address text
+
+
+ Host name or IP address, or one
+ of all, samehost,
+ or samenet, or null for local connections
+ |
+ netmask text
+
+
+ IP address mask, or null if not applicable
+ |
+ auth_method text
+
+
+ Authentication method
+ |
+ options text[]
+
+
+ Options specified for authentication method, if any
+ |
+ error text
+
+
+ If not null, an error message indicating why this
+ line could not be processed
+ |
+ Usually, a row reflecting an incorrect entry will have values for only
+ the line_number and error fields.
+
+ See Chapter 21 for more information about
+ client authentication configuration.
+
54.10. pg_ident_file_mappings #
+ The view pg_ident_file_mappings provides a summary
+ of the contents of the client user name mapping configuration file,
+ pg_ident.conf.
+ A row appears in this view for each non-empty, non-comment line in the file,
+ with annotations indicating whether the map could be applied successfully.
+
+ This view can be helpful for checking whether planned changes in the
+ authentication configuration file will work, or for diagnosing a previous
+ failure. Note that this view reports on the current
+ contents of the file, not on what was last loaded by the server.
+
+ By default, the pg_ident_file_mappings view can be
+ read only by superusers.
+
Table 54.10. pg_ident_file_mappings Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ map_number int4
+
+
+ Number of this map, in priority order, if valid, otherwise
+ NULL
+ |
+ file_name text
+
+
+ Name of the file containing this map
+ |
+ line_number int4
+
+
+ Line number of this map in file_name
+ |
+ map_name text
+
+
+ Name of the map
+ |
+ sys_name text
+
+
+ Detected user name of the client
+ |
+ pg_username text
+
+
+ Requested PostgreSQL user name
+ |
+ error text
+
+
+ If not NULL, an error message indicating why this
+ line could not be processed
+ |
+ Usually, a row reflecting an incorrect entry will have values for only
+ the line_number and error fields.
+
+ See Chapter 21 for more information about
+ client authentication configuration.
+
+ The view pg_indexes provides access to
+ useful information about each index in the database.
+
Table 54.11. pg_indexes Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ schemaname name
+ (references pg_namespace.nspname)
+
+
+ Name of schema containing table and index
+ |
+ tablename name
+ (references pg_class.relname)
+
+
+ Name of table the index is for
+ |
+ indexname name
+ (references pg_class.relname)
+
+
+ Name of index
+ |
+ tablespace name
+ (references pg_tablespace.spcname)
+
+
+ Name of tablespace containing index (null if default for database)
+ |
+ indexdef text
+
+
+ Index definition (a reconstructed CREATE INDEX
+ command)
+ |
+ The view pg_locks provides access to
+ information about the locks held by active processes within the
+ database server. See Chapter 13 for more discussion
+ of locking.
+
+ pg_locks contains one row per active lockable
+ object, requested lock mode, and relevant process. Thus, the same
+ lockable object might
+ appear many times, if multiple processes are holding or waiting
+ for locks on it. However, an object that currently has no locks on it
+ will not appear at all.
+
+ There are several distinct types of lockable objects:
+ whole relations (e.g., tables), individual pages of relations,
+ individual tuples of relations,
+ transaction IDs (both virtual and permanent IDs),
+ and general database objects (identified by class OID and object OID,
+ in the same way as in pg_description or
+ pg_depend). Also, the right to extend a
+ relation is represented as a separate lockable object, as is the right to
+ update pg_database.datfrozenxid.
+ Also, “advisory” locks can be taken on numbers that have
+ user-defined meanings.
+
Table 54.12. pg_locks Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ locktype text
+
+
+ Type of the lockable object:
+ relation,
+ extend,
+ frozenid,
+ page,
+ tuple,
+ transactionid,
+ virtualxid,
+ spectoken,
+ object,
+ userlock,
+ advisory, or
+ applytransaction.
+ (See also Table 28.11.)
+ |
+ database oid
+ (references pg_database.oid)
+
+
+ OID of the database in which the lock target exists, or
+ zero if the target is a shared object, or
+ null if the target is a transaction ID
+ |
+ relation oid
+ (references pg_class.oid)
+
+
+ OID of the relation targeted by the lock, or null if the target is not
+ a relation or part of a relation
+ |
+ page int4
+
+
+ Page number targeted by the lock within the relation,
+ or null if the target is not a relation page or tuple
+ |
+ tuple int2
+
+
+ Tuple number targeted by the lock within the page,
+ or null if the target is not a tuple
+ |
+ virtualxid text
+
+
+ Virtual ID of the transaction targeted by the lock,
+ or null if the target is not a virtual transaction ID; see
+ Chapter 74
+ |
+ transactionid xid
+
+
+ ID of the transaction targeted by the lock, or null if the target
+ is not a transaction ID; Chapter 74
+ |
+ classid oid
+ (references pg_class.oid)
+
+
+ OID of the system catalog containing the lock target, or null if the
+ target is not a general database object
+ |
+ objid oid
+ (references any OID column)
+
+
+ OID of the lock target within its system catalog, or null if the
+ target is not a general database object
+ |
+ objsubid int2
+
+
+ Column number targeted by the lock (the
+ classid and objid refer to the
+ table itself),
+ or zero if the target is some other general database object,
+ or null if the target is not a general database object
+ |
+ virtualtransaction text
+
+
+ Virtual ID of the transaction that is holding or awaiting this lock
+ |
+ pid int4
+
+
+ Process ID of the server process holding or awaiting this
+ lock, or null if the lock is held by a prepared transaction
+ |
+ mode text
+
+
+ Name of the lock mode held or desired by this process (see Section 13.3.1 and Section 13.2.3)
+ |
+ granted bool
+
+
+ True if lock is held, false if lock is awaited
+ |
+ fastpath bool
+
+
+ True if lock was taken via fast path, false if taken via main
+ lock table
+ |
+ waitstart timestamptz
+
+
+ Time when the server process started waiting for this lock,
+ or null if the lock is held.
+ Note that this can be null for a very short period of time after
+ the wait started even though granted
+ is false.
+ |
+ granted is true in a row representing a lock
+ held by the indicated process. False indicates that this process is
+ currently waiting to acquire this lock, which implies that at least one
+ other process is holding or waiting for a conflicting lock mode on the same
+ lockable object. The waiting process will sleep until the other lock is
+ released (or a deadlock situation is detected). A single process can be
+ waiting to acquire at most one lock at a time.
+
+ Throughout running a transaction, a server process holds an exclusive lock
+ on the transaction's virtual transaction ID. If a permanent ID is assigned
+ to the transaction (which normally happens only if the transaction changes
+ the state of the database), it also holds an exclusive lock on the
+ transaction's permanent transaction ID until it ends. When a process finds
+ it necessary to wait specifically for another transaction to end, it does
+ so by attempting to acquire share lock on the other transaction's ID
+ (either virtual or permanent ID depending on the situation). That will
+ succeed only when the other transaction terminates and releases its locks.
+
+ Although tuples are a lockable type of object,
+ information about row-level locks is stored on disk, not in memory,
+ and therefore row-level locks normally do not appear in this view.
+ If a process is waiting for a
+ row-level lock, it will usually appear in the view as waiting for the
+ permanent transaction ID of the current holder of that row lock.
+
+ A speculative insertion lock consists of a transaction ID and a speculative
+ insertion token. The speculative insertion token is displayed in the
+ objid column.
+
+ Advisory locks can be acquired on keys consisting of either a single
+ bigint value or two integer values.
+ A bigint key is displayed with its
+ high-order half in the classid column, its low-order half
+ in the objid column, and objsubid equal
+ to 1. The original bigint value can be reassembled with the
+ expression (classid::bigint << 32) |
+ objid::bigint. Integer keys are displayed with the
+ first key in the
+ classid column, the second key in the objid
+ column, and objsubid equal to 2. The actual meaning of
+ the keys is up to the user. Advisory locks are local to each database,
+ so the database column is meaningful for an advisory lock.
+
+ Apply transaction locks are used in parallel mode to apply the transaction
+ in logical replication. The remote transaction ID is displayed in the
+ transactionid column. The objsubid
+ displays the lock subtype which is 0 for the lock used to synchronize the
+ set of changes, and 1 for the lock used to wait for the transaction to
+ finish to ensure commit order.
+
+ pg_locks provides a global view of all locks
+ in the database cluster, not only those relevant to the current database.
+ Although its relation column can be joined
+ against pg_class.oid to identify locked
+ relations, this will only work correctly for relations in the current
+ database (those for which the database column
+ is either the current database's OID or zero).
+
+ The pid column can be joined to the
+ pid column of the
+
+ pg_stat_activity
+ view to get more
+ information on the session holding or awaiting each lock,
+ for example
+
+SELECT * FROM pg_locks pl LEFT JOIN pg_stat_activity psa
+ ON pl.pid = psa.pid;
+
+ Also, if you are using prepared transactions, the
+ virtualtransaction column can be joined to the
+ transaction column of the pg_prepared_xacts
+ view to get more information on prepared transactions that hold locks.
+ (A prepared transaction can never be waiting for a lock,
+ but it continues to hold the locks it acquired while running.)
+ For example:
+
+SELECT * FROM pg_locks pl LEFT JOIN pg_prepared_xacts ppx
+ ON pl.virtualtransaction = '-1/' || ppx.transaction;
+
+
+ While it is possible to obtain information about which processes block
+ which other processes by joining pg_locks against
+ itself, this is very difficult to get right in detail. Such a query would
+ have to encode knowledge about which lock modes conflict with which
+ others. Worse, the pg_locks view does not expose
+ information about which processes are ahead of which others in lock wait
+ queues, nor information about which processes are parallel workers running
+ on behalf of which other client sessions. It is better to use
+ the pg_blocking_pids() function
+ (see Table 9.67) to identify which
+ process(es) a waiting process is blocked behind.
+
+ The pg_locks view displays data from both the
+ regular lock manager and the predicate lock manager, which are
+ separate systems; in addition, the regular lock manager subdivides its
+ locks into regular and fast-path locks.
+ This data is not guaranteed to be entirely consistent.
+ When the view is queried,
+ data on fast-path locks (with fastpath = true)
+ is gathered from each backend one at a time, without freezing the state of
+ the entire lock manager, so it is possible for locks to be taken or
+ released while information is gathered. Note, however, that these locks are
+ known not to conflict with any other lock currently in place. After
+ all backends have been queried for fast-path locks, the remainder of the
+ regular lock manager is locked as a unit, and a consistent snapshot of all
+ remaining locks is collected as an atomic action. After unlocking the
+ regular lock manager, the predicate lock manager is similarly locked and all
+ predicate locks are collected as an atomic action. Thus, with the exception
+ of fast-path locks, each lock manager will deliver a consistent set of
+ results, but as we do not lock both lock managers simultaneously, it is
+ possible for locks to be taken or released after we interrogate the regular
+ lock manager and before we interrogate the predicate lock manager.
+
+ Locking the regular and/or predicate lock manager could have some
+ impact on database performance if this view is very frequently accessed.
+ The locks are held only for the minimum amount of time necessary to
+ obtain data from the lock managers, but this does not completely eliminate
+ the possibility of a performance impact.
+
+ The view pg_matviews provides access to
+ useful information about each materialized view in the database.
+
Table 54.13. pg_matviews Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ schemaname name
+ (references pg_namespace.nspname)
+
+
+ Name of schema containing materialized view
+ |
+ matviewname name
+ (references pg_class.relname)
+
+
+ Name of materialized view
+ |
+ matviewowner name
+ (references pg_authid.rolname)
+
+
+ Name of materialized view's owner
+ |
+ tablespace name
+ (references pg_tablespace.spcname)
+
+
+ Name of tablespace containing materialized view (null if default for database)
+ |
+ hasindexes bool
+
+
+ True if materialized view has (or recently had) any indexes
+ |
+ ispopulated bool
+
+
+ True if materialized view is currently populated
+ |
+ definition text
+
+
+ Materialized view definition (a reconstructed SELECT query)
+ |
+ The view pg_policies provides access to
+ useful information about each row-level security policy in the database.
+
Table 54.14. pg_policies Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ schemaname name
+ (references pg_namespace.nspname)
+
+
+ Name of schema containing table policy is on
+ |
+ tablename name
+ (references pg_class.relname)
+
+
+ Name of table policy is on
+ |
+ policyname name
+ (references pg_policy.polname)
+
+
+ Name of policy
+ |
+ permissive text
+
+
+ Is the policy permissive or restrictive?
+ |
+ roles name[]
+
+
+ The roles to which this policy applies
+ |
+ cmd text
+
+
+ The command type to which the policy is applied
+ |
+ qual text
+
+
+ The expression added to the security barrier qualifications for
+ queries that this policy applies to
+ |
+ with_check text
+
+
+ The expression added to the WITH CHECK qualifications for
+ queries that attempt to add rows to this table
+ |
54.15. pg_prepared_statements #
+ The pg_prepared_statements view displays
+ all the prepared statements that are available in the current
+ session. See PREPARE for more information about prepared
+ statements.
+
+ pg_prepared_statements contains one row
+ for each prepared statement. Rows are added to the view when a new
+ prepared statement is created and removed when a prepared statement
+ is released (for example, via the DEALLOCATE command).
+
Table 54.15. pg_prepared_statements Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ name text
+
+
+ The identifier of the prepared statement
+ |
+ statement text
+
+
+ The query string submitted by the client to create this
+ prepared statement. For prepared statements created via SQL,
+ this is the PREPARE statement submitted by
+ the client. For prepared statements created via the
+ frontend/backend protocol, this is the text of the prepared
+ statement itself.
+ |
+ prepare_time timestamptz
+
+
+ The time at which the prepared statement was created
+ |
+ parameter_types regtype[]
+
+
+ The expected parameter types for the prepared statement in the
+ form of an array of regtype. The OID corresponding
+ to an element of this array can be obtained by casting the
+ regtype value to oid.
+ |
+ result_types regtype[]
+
+
+ The types of the columns returned by the prepared statement in the
+ form of an array of regtype. The OID corresponding
+ to an element of this array can be obtained by casting the
+ regtype value to oid.
+ If the prepared statement does not provide a result (e.g., a DML
+ statement), then this field will be null.
+ |
+ from_sql bool
+
+
+ true if the prepared statement was created
+ via the PREPARE SQL command;
+ false if the statement was prepared via the
+ frontend/backend protocol
+ |
+ generic_plans int8
+
+
+ Number of times generic plan was chosen
+ |
+ custom_plans int8
+
+
+ Number of times custom plan was chosen
+ |
+ The pg_prepared_statements view is read-only.
+
54.16. pg_prepared_xacts #
+ The view pg_prepared_xacts displays
+ information about transactions that are currently prepared for two-phase
+ commit (see PREPARE TRANSACTION for details).
+
+ pg_prepared_xacts contains one row per prepared
+ transaction. An entry is removed when the transaction is committed or
+ rolled back.
+
Table 54.16. pg_prepared_xacts Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ transaction xid
+
+
+ Numeric transaction identifier of the prepared transaction
+ |
+ gid text
+
+
+ Global transaction identifier that was assigned to the transaction
+ |
+ prepared timestamptz
+
+
+ Time at which the transaction was prepared for commit
+ |
+ owner name
+ (references pg_authid.rolname)
+
+
+ Name of the user that executed the transaction
+ |
+ database name
+ (references pg_database.datname)
+
+
+ Name of the database in which the transaction was executed
+ |
+ When the pg_prepared_xacts view is accessed, the
+ internal transaction manager data structures are momentarily locked, and
+ a copy is made for the view to display. This ensures that the
+ view produces a consistent set of results, while not blocking
+ normal operations longer than necessary. Nonetheless
+ there could be some impact on database performance if this view is
+ frequently accessed.
+
54.17. pg_publication_tables #
+ The view pg_publication_tables provides
+ information about the mapping between publications and information of
+ tables they contain. Unlike the underlying catalog
+ pg_publication_rel,
+ this view expands publications defined as
+ FOR ALL TABLES
+ and FOR TABLES IN SCHEMA,
+ so for such publications there will be a row for each eligible table.
+
Table 54.17. pg_publication_tables Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ pubname name
+ (references pg_publication.pubname)
+
+
+ Name of publication
+ |
+ schemaname name
+ (references pg_namespace.nspname)
+
+
+ Name of schema containing table
+ |
+ tablename name
+ (references pg_class.relname)
+
+
+ Name of table
+ |
+ attnames name[]
+ (references pg_attribute.attname)
+
+
+ Names of table columns included in the publication. This contains all
+ the columns of the table when the user didn't specify the column list
+ for the table.
+ |
+ rowfilter text
+
+
+ Expression for the table's publication qualifying condition
+ |
54.18. pg_replication_origin_status #
+ The pg_replication_origin_status view
+ contains information about how far replay for a certain origin has
+ progressed. For more on replication origins
+ see Chapter 50.
+
Table 54.18. pg_replication_origin_status Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ local_id oid
+ (references pg_replication_origin.roident)
+
+
+ internal node identifier
+ |
+ external_id text
+ (references pg_replication_origin.roname)
+
+
+ external node identifier
+ |
+ remote_lsn pg_lsn
+
+
+ The origin node's LSN up to which data has been replicated.
+ |
+ local_lsn pg_lsn
+
+
+ This node's LSN at which remote_lsn has
+ been replicated. Used to flush commit records before persisting
+ data to disk when using asynchronous commits.
+ |
54.19. pg_replication_slots #
+ The pg_replication_slots view provides a listing
+ of all replication slots that currently exist on the database cluster,
+ along with their current state.
+
+ For more on replication slots,
+ see Section 27.2.6 and Chapter 49.
+
Table 54.19. pg_replication_slots Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ slot_name name
+
+
+ A unique, cluster-wide identifier for the replication slot
+ |
+ plugin name
+
+
+ The base name of the shared object containing the output plugin this logical slot is using, or null for physical slots.
+ |
+ slot_type text
+
+
+ The slot type: physical or logical
+ |
+ datoid oid
+ (references pg_database.oid)
+
+
+ The OID of the database this slot is associated with, or
+ null. Only logical slots have an associated database.
+ |
+ database name
+ (references pg_database.datname)
+
+
+ The name of the database this slot is associated with, or
+ null. Only logical slots have an associated database.
+ |
+ temporary bool
+
+
+ True if this is a temporary replication slot. Temporary slots are
+ not saved to disk and are automatically dropped on error or when
+ the session has finished.
+ |
+ active bool
+
+
+ True if this slot is currently actively being used
+ |
+ active_pid int4
+
+
+ The process ID of the session using this slot if the slot
+ is currently actively being used. NULL if
+ inactive.
+ |
+ xmin xid
+
+
+ The oldest transaction that this slot needs the database to
+ retain. VACUUM cannot remove tuples deleted
+ by any later transaction.
+ |
+ catalog_xmin xid
+
+
+ The oldest transaction affecting the system catalogs that this
+ slot needs the database to retain. VACUUM cannot
+ remove catalog tuples deleted by any later transaction.
+ |
+ restart_lsn pg_lsn
+
+
+ The address (LSN) of oldest WAL which still
+ might be required by the consumer of this slot and thus won't be
+ automatically removed during checkpoints unless this LSN
+ gets behind more than max_slot_wal_keep_size
+ from the current LSN. NULL
+ if the LSN of this slot has never been reserved.
+ |
+ confirmed_flush_lsn pg_lsn
+
+
+ The address (LSN) up to which the logical
+ slot's consumer has confirmed receiving data. Data corresponding to the
+ transactions committed before this LSN is not
+ available anymore. NULL for physical slots.
+ |
+ wal_status text
+
+
+ Availability of WAL files claimed by this slot.
+ Possible values are:
+ reserved means that the claimed files
+ are within max_wal_size.
extended means
+ that max_wal_size is exceeded but the files are
+ still retained, either by the replication slot or
+ by wal_keep_size.
+
+ unreserved means that the slot no longer
+ retains the required WAL files and some of them are to be removed at
+ the next checkpoint. This state can return
+ to reserved or extended.
+
+ lost means that some required WAL files have
+ been removed and this slot is no longer usable.
+
+ The last two states are seen only when
+ max_slot_wal_keep_size is
+ non-negative. If restart_lsn is NULL, this
+ field is null.
+ |
+ safe_wal_size int8
+
+
+ The number of bytes that can be written to WAL such that this slot
+ is not in danger of getting in state "lost". It is NULL for lost
+ slots, as well as if max_slot_wal_keep_size
+ is -1.
+ |
+ two_phase bool
+
+
+ True if the slot is enabled for decoding prepared transactions. Always
+ false for physical slots.
+ |
+ conflicting bool
+
+
+ True if this logical slot conflicted with recovery (and so is now
+ invalidated). Always NULL for physical slots.
+ |
+ The view pg_roles provides access to
+ information about database roles. This is simply a publicly
+ readable view of
+ pg_authid
+ that blanks out the password field.
+
Table 54.20. pg_roles Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ rolname name
+
+
+ Role name
+ |
+ rolsuper bool
+
+
+ Role has superuser privileges
+ |
+ rolinherit bool
+
+
+ Role automatically inherits privileges of roles it is a
+ member of
+ |
+ rolcreaterole bool
+
+
+ Role can create more roles
+ |
+ rolcreatedb bool
+
+
+ Role can create databases
+ |
+ rolcanlogin bool
+
+
+ Role can log in. That is, this role can be given as the initial
+ session authorization identifier
+ |
+ rolreplication bool
+
+
+ Role is a replication role. A replication role can initiate replication
+ connections and create and drop replication slots.
+ |
+ rolconnlimit int4
+
+
+ For roles that can log in, this sets maximum number of concurrent
+ connections this role can make. -1 means no limit.
+ |
+ rolpassword text
+
+
+ Not the password (always reads as ********)
+ |
+ rolvaliduntil timestamptz
+
+
+ Password expiry time (only used for password authentication);
+ null if no expiration
+ |
+ rolbypassrls bool
+
+
+ Role bypasses every row-level security policy, see
+ Section 5.8 for more information.
+ |
+ rolconfig text[]
+
+
+ Role-specific defaults for run-time configuration variables
+ |
+ oid oid
+ (references pg_authid.oid)
+
+
+ ID of role
+ |
+ The view pg_rules provides access to
+ useful information about query rewrite rules.
+
Table 54.21. pg_rules Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ schemaname name
+ (references pg_namespace.nspname)
+
+
+ Name of schema containing table
+ |
+ tablename name
+ (references pg_class.relname)
+
+
+ Name of table the rule is for
+ |
+ rulename name
+ (references pg_rewrite.rulename)
+
+
+ Name of rule
+ |
+ definition text
+
+
+ Rule definition (a reconstructed creation command)
+ |
+ The pg_rules view excludes the ON SELECT rules
+ of views and materialized views; those can be seen in
+ pg_views and pg_matviews.
+
+ The view pg_seclabels provides information about
+ security labels. It as an easier-to-query version of the
+ pg_seclabel catalog.
+
Table 54.22. pg_seclabels Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ objoid oid
+ (references any OID column)
+
+
+ The OID of the object this security label pertains to
+ |
+ classoid oid
+ (references pg_class.oid)
+
+
+ The OID of the system catalog this object appears in
+ |
+ objsubid int4
+
+
+ For a security label on a table column, this is the column number (the
+ objoid and classoid refer to
+ the table itself). For all other object types, this column is
+ zero.
+ |
+ objtype text
+
+
+ The type of object to which this label applies, as text.
+ |
+ objnamespace oid
+ (references pg_namespace.oid)
+
+
+ The OID of the namespace for this object, if applicable;
+ otherwise NULL.
+ |
+ objname text
+
+
+ The name of the object to which this label applies, as text.
+ |
+ provider text
+ (references pg_seclabel.provider)
+
+
+ The label provider associated with this label.
+ |
+ label text
+ (references pg_seclabel.label)
+
+
+ The security label applied to this object.
+ |
+ The view pg_sequences provides access to
+ useful information about each sequence in the database.
+
Table 54.23. pg_sequences Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ schemaname name
+ (references pg_namespace.nspname)
+
+
+ Name of schema containing sequence
+ |
+ sequencename name
+ (references pg_class.relname)
+
+
+ Name of sequence
+ |
+ sequenceowner name
+ (references pg_authid.rolname)
+
+
+ Name of sequence's owner
+ |
+ data_type regtype
+ (references pg_type.oid)
+
+
+ Data type of the sequence
+ |
+ start_value int8
+
+
+ Start value of the sequence
+ |
+ min_value int8
+
+
+ Minimum value of the sequence
+ |
+ max_value int8
+
+
+ Maximum value of the sequence
+ |
+ increment_by int8
+
+
+ Increment value of the sequence
+ |
+ cycle bool
+
+
+ Whether the sequence cycles
+ |
+ cache_size int8
+
+
+ Cache size of the sequence
+ |
+ last_value int8
+
+
+ The last sequence value written to disk. If caching is used,
+ this value can be greater than the last value handed out from the
+ sequence. Null if the sequence has not been read from yet. Also, if
+ the current user does not have USAGE
+ or SELECT privilege on the sequence, the value is
+ null.
+ |
+ The view pg_settings provides access to
+ run-time parameters of the server. It is essentially an alternative
+ interface to the SHOW
+ and SET commands.
+ It also provides access to some facts about each parameter that are
+ not directly available from SHOW, such as minimum and
+ maximum values.
+
Table 54.24. pg_settings Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ name text
+
+
+ Run-time configuration parameter name
+ |
+ setting text
+
+
+ Current value of the parameter
+ |
+ unit text
+
+
+ Implicit unit of the parameter
+ |
+ category text
+
+
+ Logical group of the parameter
+ |
+ short_desc text
+
+
+ A brief description of the parameter
+ |
+ extra_desc text
+
+
+ Additional, more detailed, description of the parameter
+ |
+ context text
+
+
+ Context required to set the parameter's value (see below)
+ |
+ vartype text
+
+
+ Parameter type (bool, enum,
+ integer, real, or string)
+ |
+ source text
+
+
+ Source of the current parameter value
+ |
+ min_val text
+
+
+ Minimum allowed value of the parameter (null for non-numeric
+ values)
+ |
+ max_val text
+
+
+ Maximum allowed value of the parameter (null for non-numeric
+ values)
+ |
+ enumvals text[]
+
+
+ Allowed values of an enum parameter (null for non-enum
+ values)
+ |
+ boot_val text
+
+
+ Parameter value assumed at server startup if the parameter is
+ not otherwise set
+ |
+ reset_val text
+
+
+ Value that RESET would reset the parameter to
+ in the current session
+ |
+ sourcefile text
+
+
+ Configuration file the current value was set in (null for
+ values set from sources other than configuration files, or when
+ examined by a user who neither is a superuser nor has privileges of
+ pg_read_all_settings); helpful when using
+ include directives in configuration files
+ |
+ sourceline int4
+
+
+ Line number within the configuration file the current value was
+ set at (null for values set from sources other than configuration files,
+ or when examined by a user who neither is a superuser nor has privileges of
+ pg_read_all_settings).
+ |
+ pending_restart bool
+
+
+ true if the value has been changed in the
+ configuration file but needs a restart; or false
+ otherwise.
+ |
+ There are several possible values of context.
+ In order of decreasing difficulty of changing the setting, they are:
+
internal
+ These settings cannot be changed directly; they reflect internally
+ determined values. Some of them may be adjustable by rebuilding the
+ server with different configuration options, or by changing options
+ supplied to initdb.
+
postmaster
+ These settings can only be applied when the server starts, so any change
+ requires restarting the server. Values for these settings are typically
+ stored in the postgresql.conf file, or passed on
+ the command line when starting the server. Of course, settings with any
+ of the lower context types can also be
+ set at server start time.
+
sighup
+ Changes to these settings can be made in
+ postgresql.conf without restarting the server.
+ Send a SIGHUP signal to the postmaster to
+ cause it to re-read postgresql.conf and apply
+ the changes. The postmaster will also forward the
+ SIGHUP signal to its child processes so that
+ they all pick up the new value.
+
superuser-backend
+ Changes to these settings can be made in
+ postgresql.conf without restarting the server.
+ They can also be set for a particular session in the connection request
+ packet (for example, via libpq's PGOPTIONS
+ environment variable), but only if the connecting user is a superuser
+ or has been granted the appropriate SET privilege.
+ However, these settings never change in a session after it is started.
+ If you change them in postgresql.conf, send a
+ SIGHUP signal to the postmaster to cause it to
+ re-read postgresql.conf. The new values will only
+ affect subsequently-launched sessions.
+
backend
+ Changes to these settings can be made in
+ postgresql.conf without restarting the server.
+ They can also be set for a particular session in the connection request
+ packet (for example, via libpq's PGOPTIONS
+ environment variable); any user can make such a change for their session.
+ However, these settings never change in a session after it is started.
+ If you change them in postgresql.conf, send a
+ SIGHUP signal to the postmaster to cause it to
+ re-read postgresql.conf. The new values will only
+ affect subsequently-launched sessions.
+
superuser
+ These settings can be set from postgresql.conf,
+ or within a session via the SET command; but only superusers
+ and users with the appropriate SET privilege
+ can change them via SET. Changes in
+ postgresql.conf will affect existing sessions
+ only if no session-local value has been established with SET.
+
user
+ These settings can be set from postgresql.conf,
+ or within a session via the SET command. Any user is
+ allowed to change their session-local value. Changes in
+ postgresql.conf will affect existing sessions
+ only if no session-local value has been established with SET.
+
+ See Section 20.1 for more information about the various
+ ways to change these parameters.
+
+ This view cannot be inserted into or deleted from, but it can be updated. An
+ UPDATE applied to a row of pg_settings
+ is equivalent to executing the SET command on that named
+ parameter. The change only affects the value used by the current
+ session. If an UPDATE is issued within a transaction
+ that is later aborted, the effects of the UPDATE command
+ disappear when the transaction is rolled back. Once the surrounding
+ transaction is committed, the effects will persist until the end of the
+ session, unless overridden by another UPDATE or
+ SET.
+
+ This view does not
+ display customized options
+ unless the extension module that defines them has been loaded by the
+ backend process executing the query (e.g., via a mention in
+ shared_preload_libraries,
+ a call to a C function in the extension, or the
+ LOAD command).
+ For example, since archive modules
+ are normally loaded only by the archiver process not regular sessions,
+ this view will not display any customized options defined by such modules
+ unless special action is taken to load them into the backend process
+ executing the query.
+
+ The view pg_shadow exists for backwards
+ compatibility: it emulates a catalog that existed in
+ PostgreSQL before version 8.1.
+ It shows properties of all roles that are marked as
+ rolcanlogin in
+ pg_authid.
+
+ The name stems from the fact that this table
+ should not be readable by the public since it contains passwords.
+ pg_user
+ is a publicly readable view on
+ pg_shadow that blanks out the password field.
+
Table 54.25. pg_shadow Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ usename name
+ (references pg_authid.rolname)
+
+
+ User name
+ |
+ usesysid oid
+ (references pg_authid.oid)
+
+
+ ID of this user
+ |
+ usecreatedb bool
+
+
+ User can create databases
+ |
+ usesuper bool
+
+
+ User is a superuser
+ |
+ userepl bool
+
+
+ User can initiate streaming replication and put the system in and
+ out of backup mode.
+ |
+ usebypassrls bool
+
+
+ User bypasses every row-level security policy, see
+ Section 5.8 for more information.
+ |
+ passwd text
+
+
+ Password (possibly encrypted); null if none. See
+ pg_authid
+ for details of how encrypted passwords are stored.
+ |
+ valuntil timestamptz
+
+
+ Password expiry time (only used for password authentication)
+ |
+ useconfig text[]
+
+
+ Session defaults for run-time configuration variables
+ |
54.26. pg_shmem_allocations #
+ The pg_shmem_allocations view shows allocations
+ made from the server's main shared memory segment. This includes both
+ memory allocated by PostgreSQL itself and memory
+ allocated by extensions using the mechanisms detailed in
+ Section 38.10.10.
+
+ Note that this view does not include memory allocated using the dynamic
+ shared memory infrastructure.
+
Table 54.26. pg_shmem_allocations Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ name text
+
+
+ The name of the shared memory allocation. NULL for unused memory
+ and <anonymous> for anonymous
+ allocations.
+ |
+ off int8
+
+
+ The offset at which the allocation starts. NULL for anonymous
+ allocations, since details related to them are not known.
+ |
+ size int8
+
+
+ Size of the allocation in bytes
+ |
+ allocated_size int8
+
+
+ Size of the allocation in bytes including padding. For anonymous
+ allocations, no information about padding is available, so the
+ size and allocated_size columns
+ will always be equal. Padding is not meaningful for free memory, so
+ the columns will be equal in that case also.
+ |
+ Anonymous allocations are allocations that have been made
+ with ShmemAlloc() directly, rather than via
+ ShmemInitStruct() or
+ ShmemInitHash().
+
+ By default, the pg_shmem_allocations view can be
+ read only by superusers or roles with privileges of the
+ pg_read_all_stats role.
+
54.29. pg_stats_ext_exprs #
+ The view pg_stats_ext_exprs provides access to
+ information about all expressions included in extended statistics objects,
+ combining information stored in the pg_statistic_ext
+ and pg_statistic_ext_data
+ catalogs. This view allows access only to rows of
+ pg_statistic_ext and pg_statistic_ext_data
+ that correspond to tables the user owns, and therefore
+ it is safe to allow public read access to this view.
+
+ pg_stats_ext_exprs is also designed to present
+ the information in a more readable format than the underlying catalogs
+ — at the cost that its schema must be extended whenever the structure
+ of statistics in pg_statistic_ext changes.
+
Table 54.29. pg_stats_ext_exprs Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ schemaname name
+ (references pg_namespace.nspname)
+
+
+ Name of schema containing table
+ |
+ tablename name
+ (references pg_class.relname)
+
+
+ Name of table the statistics object is defined on
+ |
+ statistics_schemaname name
+ (references pg_namespace.nspname)
+
+
+ Name of schema containing extended statistics object
+ |
+ statistics_name name
+ (references pg_statistic_ext.stxname)
+
+
+ Name of extended statistics object
+ |
+ statistics_owner name
+ (references pg_authid.rolname)
+
+
+ Owner of the extended statistics object
+ |
+ expr text
+
+
+ Expression included in the extended statistics object
+ |
+ inherited bool
+ (references pg_statistic_ext_data.stxdinherit)
+
+
+ If true, the stats include values from child tables, not just the
+ values in the specified relation
+ |
+ null_frac float4
+
+
+ Fraction of expression entries that are null
+ |
+ avg_width int4
+
+
+ Average width in bytes of expression's entries
+ |
+ n_distinct float4
+
+
+ If greater than zero, the estimated number of distinct values in the
+ expression. If less than zero, the negative of the number of distinct
+ values divided by the number of rows. (The negated form is used when
+ ANALYZE believes that the number of distinct values is
+ likely to increase as the table grows; the positive form is used when
+ the expression seems to have a fixed number of possible values.) For
+ example, -1 indicates a unique expression in which the number of distinct
+ values is the same as the number of rows.
+ |
+ most_common_vals anyarray
+
+
+ A list of the most common values in the expression. (Null if
+ no values seem to be more common than any others.)
+ |
+ most_common_freqs float4[]
+
+
+ A list of the frequencies of the most common values,
+ i.e., number of occurrences of each divided by total number of rows.
+ (Null when most_common_vals is.)
+ |
+ histogram_bounds anyarray
+
+
+ A list of values that divide the expression's values into groups of
+ approximately equal population. The values in
+ most_common_vals, if present, are omitted from this
+ histogram calculation. (This expression is null if the expression data type
+ does not have a < operator or if the
+ most_common_vals list accounts for the entire
+ population.)
+ |
+ correlation float4
+
+
+ Statistical correlation between physical row ordering and
+ logical ordering of the expression values. This ranges from -1 to +1.
+ When the value is near -1 or +1, an index scan on the expression will
+ be estimated to be cheaper than when it is near zero, due to reduction
+ of random access to the disk. (This expression is null if the expression's
+ data type does not have a < operator.)
+ |
+ most_common_elems anyarray
+
+
+ A list of non-null element values most often appearing within values of
+ the expression. (Null for scalar types.)
+ |
+ most_common_elem_freqs float4[]
+
+
+ A list of the frequencies of the most common element values, i.e., the
+ fraction of rows containing at least one instance of the given value.
+ Two or three additional values follow the per-element frequencies;
+ these are the minimum and maximum of the preceding per-element
+ frequencies, and optionally the frequency of null elements.
+ (Null when most_common_elems is.)
+ |
+ elem_count_histogram float4[]
+
+
+ A histogram of the counts of distinct non-null element values within the
+ values of the expression, followed by the average number of distinct
+ non-null elements. (Null for scalar types.)
+ |
+ The maximum number of entries in the array fields can be controlled on a
+ column-by-column basis using the ALTER
+ TABLE SET STATISTICS command, or globally by setting the
+ default_statistics_target run-time parameter.
+
+ The view pg_stats_ext provides access to
+ information about each extended statistics object in the database,
+ combining information stored in the pg_statistic_ext
+ and pg_statistic_ext_data
+ catalogs. This view allows access only to rows of
+ pg_statistic_ext and pg_statistic_ext_data
+ that correspond to tables the user owns, and therefore
+ it is safe to allow public read access to this view.
+
+ pg_stats_ext is also designed to present the
+ information in a more readable format than the underlying catalogs
+ — at the cost that its schema must be extended whenever new types
+ of extended statistics are added to pg_statistic_ext.
+
Table 54.28. pg_stats_ext Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ schemaname name
+ (references pg_namespace.nspname)
+
+
+ Name of schema containing table
+ |
+ tablename name
+ (references pg_class.relname)
+
+
+ Name of table
+ |
+ statistics_schemaname name
+ (references pg_namespace.nspname)
+
+
+ Name of schema containing extended statistics object
+ |
+ statistics_name name
+ (references pg_statistic_ext.stxname)
+
+
+ Name of extended statistics object
+ |
+ statistics_owner name
+ (references pg_authid.rolname)
+
+
+ Owner of the extended statistics object
+ |
+ attnames name[]
+ (references pg_attribute.attname)
+
+
+ Names of the columns included in the extended statistics object
+ |
+ exprs text[]
+
+
+ Expressions included in the extended statistics object
+ |
+ kinds char[]
+
+
+ Types of extended statistics object enabled for this record
+ |
+ inherited bool
+ (references pg_statistic_ext_data.stxdinherit)
+
+
+ If true, the stats include values from child tables, not just the
+ values in the specified relation
+ |
+ n_distinct pg_ndistinct
+
+
+ N-distinct counts for combinations of column values. If greater
+ than zero, the estimated number of distinct values in the combination.
+ If less than zero, the negative of the number of distinct values divided
+ by the number of rows.
+ (The negated form is used when ANALYZE believes that
+ the number of distinct values is likely to increase as the table grows;
+ the positive form is used when the column seems to have a fixed number
+ of possible values.) For example, -1 indicates a unique combination of
+ columns in which the number of distinct combinations is the same as the
+ number of rows.
+ |
+ dependencies pg_dependencies
+
+
+ Functional dependency statistics
+ |
+ most_common_vals text[]
+
+
+ A list of the most common combinations of values in the columns.
+ (Null if no combinations seem to be more common than any others.)
+ |
+ most_common_val_nulls bool[]
+
+
+ A list of NULL flags for the most common combinations of values.
+ (Null when most_common_vals is.)
+ |
+ most_common_freqs float8[]
+
+
+ A list of the frequencies of the most common combinations,
+ i.e., number of occurrences of each divided by total number of rows.
+ (Null when most_common_vals is.)
+ |
+ most_common_base_freqs float8[]
+
+
+ A list of the base frequencies of the most common combinations,
+ i.e., product of per-value frequencies.
+ (Null when most_common_vals is.)
+ |
+ The maximum number of entries in the array fields can be controlled on a
+ column-by-column basis using the ALTER
+ TABLE SET STATISTICS command, or globally by setting the
+ default_statistics_target run-time parameter.
+
+ The view pg_stats provides access to
+ the information stored in the pg_statistic
+ catalog. This view allows access only to rows of
+ pg_statistic that correspond to tables the
+ user has permission to read, and therefore it is safe to allow public
+ read access to this view.
+
+ pg_stats is also designed to present the
+ information in a more readable format than the underlying catalog
+ — at the cost that its schema must be extended whenever new slot types
+ are defined for pg_statistic.
+
Table 54.27. pg_stats Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ schemaname name
+ (references pg_namespace.nspname)
+
+
+ Name of schema containing table
+ |
+ tablename name
+ (references pg_class.relname)
+
+
+ Name of table
+ |
+ attname name
+ (references pg_attribute.attname)
+
+
+ Name of column described by this row
+ |
+ inherited bool
+
+
+ If true, this row includes values from child tables, not just the
+ values in the specified table
+ |
+ null_frac float4
+
+
+ Fraction of column entries that are null
+ |
+ avg_width int4
+
+
+ Average width in bytes of column's entries
+ |
+ n_distinct float4
+
+
+ If greater than zero, the estimated number of distinct values in the
+ column. If less than zero, the negative of the number of distinct
+ values divided by the number of rows. (The negated form is used when
+ ANALYZE believes that the number of distinct values is
+ likely to increase as the table grows; the positive form is used when
+ the column seems to have a fixed number of possible values.) For
+ example, -1 indicates a unique column in which the number of distinct
+ values is the same as the number of rows.
+ |
+ most_common_vals anyarray
+
+
+ A list of the most common values in the column. (Null if
+ no values seem to be more common than any others.)
+ |
+ most_common_freqs float4[]
+
+
+ A list of the frequencies of the most common values,
+ i.e., number of occurrences of each divided by total number of rows.
+ (Null when most_common_vals is.)
+ |
+ histogram_bounds anyarray
+
+
+ A list of values that divide the column's values into groups of
+ approximately equal population. The values in
+ most_common_vals, if present, are omitted from this
+ histogram calculation. (This column is null if the column data type
+ does not have a < operator or if the
+ most_common_vals list accounts for the entire
+ population.)
+ |
+ correlation float4
+
+
+ Statistical correlation between physical row ordering and
+ logical ordering of the column values. This ranges from -1 to +1.
+ When the value is near -1 or +1, an index scan on the column will
+ be estimated to be cheaper than when it is near zero, due to reduction
+ of random access to the disk. (This column is null if the column data
+ type does not have a < operator.)
+ |
+ most_common_elems anyarray
+
+
+ A list of non-null element values most often appearing within values of
+ the column. (Null for scalar types.)
+ |
+ most_common_elem_freqs float4[]
+
+
+ A list of the frequencies of the most common element values, i.e., the
+ fraction of rows containing at least one instance of the given value.
+ Two or three additional values follow the per-element frequencies;
+ these are the minimum and maximum of the preceding per-element
+ frequencies, and optionally the frequency of null elements.
+ (Null when most_common_elems is.)
+ |
+ elem_count_histogram float4[]
+
+
+ A histogram of the counts of distinct non-null element values within the
+ values of the column, followed by the average number of distinct
+ non-null elements. (Null for scalar types.)
+ |
+ The maximum number of entries in the array fields can be controlled on a
+ column-by-column basis using the ALTER
+ TABLE SET STATISTICS
+ command, or globally by setting the
+ default_statistics_target run-time parameter.
+
+ The view pg_tables provides access to
+ useful information about each table in the database.
+
Table 54.30. pg_tables Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ schemaname name
+ (references pg_namespace.nspname)
+
+
+ Name of schema containing table
+ |
+ tablename name
+ (references pg_class.relname)
+
+
+ Name of table
+ |
+ tableowner name
+ (references pg_authid.rolname)
+
+
+ Name of table's owner
+ |
+ tablespace name
+ (references pg_tablespace.spcname)
+
+
+ Name of tablespace containing table (null if default for database)
+ |
+ hasindexes bool
+ (references pg_class.relhasindex)
+
+
+ True if table has (or recently had) any indexes
+ |
+ hasrules bool
+ (references pg_class.relhasrules)
+
+
+ True if table has (or once had) rules
+ |
+ hastriggers bool
+ (references pg_class.relhastriggers)
+
+
+ True if table has (or once had) triggers
+ |
+ rowsecurity bool
+ (references pg_class.relrowsecurity)
+
+
+ True if row security is enabled on the table
+ |
54.31. pg_timezone_abbrevs #
+ The view pg_timezone_abbrevs provides a list
+ of time zone abbreviations that are currently recognized by the datetime
+ input routines. The contents of this view change when the
+ timezone_abbreviations run-time parameter is modified.
+
Table 54.31. pg_timezone_abbrevs Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ abbrev text
+
+
+ Time zone abbreviation
+ |
+ utc_offset interval
+
+
+ Offset from UTC (positive means east of Greenwich)
+ |
+ is_dst bool
+
+
+ True if this is a daylight-savings abbreviation
+ |
+ While most timezone abbreviations represent fixed offsets from UTC,
+ there are some that have historically varied in value
+ (see Section B.4 for more information).
+ In such cases this view presents their current meaning.
+
54.32. pg_timezone_names #
+ The view pg_timezone_names provides a list
+ of time zone names that are recognized by SET TIMEZONE,
+ along with their associated abbreviations, UTC offsets,
+ and daylight-savings status. (Technically,
+ PostgreSQL does not use UTC because leap
+ seconds are not handled.)
+ Unlike the abbreviations shown in pg_timezone_abbrevs, many of these names imply a set of daylight-savings transition
+ date rules. Therefore, the associated information changes across local DST
+ boundaries. The displayed information is computed based on the current
+ value of CURRENT_TIMESTAMP.
+
Table 54.32. pg_timezone_names Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ name text
+
+
+ Time zone name
+ |
+ abbrev text
+
+
+ Time zone abbreviation
+ |
+ utc_offset interval
+
+
+ Offset from UTC (positive means east of Greenwich)
+ |
+ is_dst bool
+
+
+ True if currently observing daylight savings
+ |
54.34. pg_user_mappings #
+ The view pg_user_mappings provides access
+ to information about user mappings. This is essentially a publicly
+ readable view of
+ pg_user_mapping
+ that leaves out the options field if the user has no rights to use
+ it.
+
Table 54.34. pg_user_mappings Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ umid oid
+ (references pg_user_mapping.oid)
+
+
+ OID of the user mapping
+ |
+ srvid oid
+ (references pg_foreign_server.oid)
+
+
+ The OID of the foreign server that contains this mapping
+ |
+ srvname name
+ (references pg_foreign_server.srvname)
+
+
+ Name of the foreign server
+ |
+ umuser oid
+ (references pg_authid.oid)
+
+
+ OID of the local role being mapped, or zero if the user mapping is public
+ |
+ usename name
+
+
+ Name of the local user to be mapped
+ |
+ umoptions text[]
+
+
+ User mapping specific options, as “keyword=value” strings
+ |
+ To protect password information stored as a user mapping option,
+ the umoptions column will read as null
+ unless one of the following applies:
+
+ current user is the user being mapped, and owns the server or
+ holds USAGE privilege on it
+
+ current user is the server owner and mapping is for PUBLIC
+
+ current user is a superuser
+
+
+ The view pg_user provides access to
+ information about database users. This is simply a publicly
+ readable view of
+ pg_shadow
+ that blanks out the password field.
+
Table 54.33. pg_user Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ usename name
+
+
+ User name
+ |
+ usesysid oid
+
+
+ ID of this user
+ |
+ usecreatedb bool
+
+
+ User can create databases
+ |
+ usesuper bool
+
+
+ User is a superuser
+ |
+ userepl bool
+
+
+ User can initiate streaming replication and put the system in and
+ out of backup mode.
+ |
+ usebypassrls bool
+
+
+ User bypasses every row-level security policy, see
+ Section 5.8 for more information.
+ |
+ passwd text
+
+
+ Not the password (always reads as ********)
+ |
+ valuntil timestamptz
+
+
+ Password expiry time (only used for password authentication)
+ |
+ useconfig text[]
+
+
+ Session defaults for run-time configuration variables
+ |
+ The view pg_views provides access to
+ useful information about each view in the database.
+
Table 54.35. pg_views Columns
+ Column Type
+
+
+ Description
+ |
|---|
+ schemaname name
+ (references pg_namespace.nspname)
+
+
+ Name of schema containing view
+ |
+ viewname name
+ (references pg_class.relname)
+
+
+ Name of view
+ |
+ viewowner name
+ (references pg_authid.rolname)
+
+
+ Name of view's owner
+ |
+ definition text
+
+
+ View definition (a reconstructed SELECT query)
+ |
+ Table 54.1 lists the system views.
+ More detailed documentation of each catalog follows below.
+ Except where noted, all the views described here are read-only.
+
+ In addition to the system catalogs, PostgreSQL
+ provides a number of built-in views. Some system views provide convenient
+ access to some commonly used queries on the system catalogs. Other views
+ provide access to internal server state.
+
+ The information schema (Chapter 37) provides
+ an alternative set of views which overlap the functionality of the system
+ views. Since the information schema is SQL-standard whereas the views
+ described here are PostgreSQL-specific,
+ it's usually better to use the information schema if it provides all
+ the information you need.
+
+ Table 54.1 lists the system views described here.
+ More detailed documentation of each view follows below.
+ There are some additional views that provide access to accumulated
+ statistics; they are described in
+ Table 28.2.
+
30.4. Asynchronous Commit #
+ Asynchronous commit is an option that allows transactions
+ to complete more quickly, at the cost that the most recent transactions may
+ be lost if the database should crash. In many applications this is an
+ acceptable trade-off.
+
+ As described in the previous section, transaction commit is normally
+ synchronous: the server waits for the transaction's
+ WAL records to be flushed to permanent storage
+ before returning a success indication to the client. The client is
+ therefore guaranteed that a transaction reported to be committed will
+ be preserved, even in the event of a server crash immediately after.
+ However, for short transactions this delay is a major component of the
+ total transaction time. Selecting asynchronous commit mode means that
+ the server returns success as soon as the transaction is logically
+ completed, before the WAL records it generated have
+ actually made their way to disk. This can provide a significant boost
+ in throughput for small transactions.
+
+ Asynchronous commit introduces the risk of data loss. There is a short
+ time window between the report of transaction completion to the client
+ and the time that the transaction is truly committed (that is, it is
+ guaranteed not to be lost if the server crashes). Thus asynchronous
+ commit should not be used if the client will take external actions
+ relying on the assumption that the transaction will be remembered.
+ As an example, a bank would certainly not use asynchronous commit for
+ a transaction recording an ATM's dispensing of cash. But in many
+ scenarios, such as event logging, there is no need for a strong
+ guarantee of this kind.
+
+ The risk that is taken by using asynchronous commit is of data loss,
+ not data corruption. If the database should crash, it will recover
+ by replaying WAL up to the last record that was
+ flushed. The database will therefore be restored to a self-consistent
+ state, but any transactions that were not yet flushed to disk will
+ not be reflected in that state. The net effect is therefore loss of
+ the last few transactions. Because the transactions are replayed in
+ commit order, no inconsistency can be introduced — for example,
+ if transaction B made changes relying on the effects of a previous
+ transaction A, it is not possible for A's effects to be lost while B's
+ effects are preserved.
+
+ The user can select the commit mode of each transaction, so that
+ it is possible to have both synchronous and asynchronous commit
+ transactions running concurrently. This allows flexible trade-offs
+ between performance and certainty of transaction durability.
+ The commit mode is controlled by the user-settable parameter
+ synchronous_commit, which can be changed in any of
+ the ways that a configuration parameter can be set. The mode used for
+ any one transaction depends on the value of
+ synchronous_commit when transaction commit begins.
+
+ Certain utility commands, for instance DROP TABLE, are
+ forced to commit synchronously regardless of the setting of
+ synchronous_commit. This is to ensure consistency
+ between the server's file system and the logical state of the database.
+ The commands supporting two-phase commit, such as PREPARE
+ TRANSACTION, are also always synchronous.
+
+ If the database crashes during the risk window between an
+ asynchronous commit and the writing of the transaction's
+ WAL records,
+ then changes made during that transaction will be lost.
+ The duration of the
+ risk window is limited because a background process (the “WAL
+ writer”) flushes unwritten WAL records to disk
+ every wal_writer_delay milliseconds.
+ The actual maximum duration of the risk window is three times
+ wal_writer_delay because the WAL writer is
+ designed to favor writing whole pages at a time during busy periods.
+
Caution
+ An immediate-mode shutdown is equivalent to a server crash, and will
+ therefore cause loss of any unflushed asynchronous commits.
+
+ Asynchronous commit provides behavior different from setting
+ fsync = off.
+ fsync is a server-wide
+ setting that will alter the behavior of all transactions. It disables
+ all logic within PostgreSQL that attempts to synchronize
+ writes to different portions of the database, and therefore a system
+ crash (that is, a hardware or operating system crash, not a failure of
+ PostgreSQL itself) could result in arbitrarily bad
+ corruption of the database state. In many scenarios, asynchronous
+ commit provides most of the performance improvement that could be
+ obtained by turning off fsync, but without the risk
+ of data corruption.
+
+ commit_delay also sounds very similar to
+ asynchronous commit, but it is actually a synchronous commit method
+ (in fact, commit_delay is ignored during an
+ asynchronous commit). commit_delay causes a delay
+ just before a transaction flushes WAL to disk, in
+ the hope that a single flush executed by one such transaction can also
+ serve other transactions committing at about the same time. The
+ setting can be thought of as a way of increasing the time window in
+ which transactions can join a group about to participate in a single
+ flush, to amortize the cost of the flush among multiple transactions.
+
30.5. WAL Configuration #
+ There are several WAL-related configuration parameters that
+ affect database performance. This section explains their use.
+ Consult Chapter 20 for general information about
+ setting server configuration parameters.
+
+ Checkpoints
+ are points in the sequence of transactions at which it is guaranteed
+ that the heap and index data files have been updated with all
+ information written before that checkpoint. At checkpoint time, all
+ dirty data pages are flushed to disk and a special checkpoint record is
+ written to the WAL file. (The change records were previously flushed
+ to the WAL files.)
+ In the event of a crash, the crash recovery procedure looks at the latest
+ checkpoint record to determine the point in the WAL (known as the redo
+ record) from which it should start the REDO operation. Any changes made to
+ data files before that point are guaranteed to be already on disk.
+ Hence, after a checkpoint, WAL segments preceding the one containing
+ the redo record are no longer needed and can be recycled or removed. (When
+ WAL archiving is being done, the WAL segments must be
+ archived before being recycled or removed.)
+
+ The checkpoint requirement of flushing all dirty data pages to disk
+ can cause a significant I/O load. For this reason, checkpoint
+ activity is throttled so that I/O begins at checkpoint start and completes
+ before the next checkpoint is due to start; this minimizes performance
+ degradation during checkpoints.
+
+ The server's checkpointer process automatically performs
+ a checkpoint every so often. A checkpoint is begun every checkpoint_timeout seconds, or if
+ max_wal_size is about to be exceeded,
+ whichever comes first.
+ The default settings are 5 minutes and 1 GB, respectively.
+ If no WAL has been written since the previous checkpoint, new checkpoints
+ will be skipped even if checkpoint_timeout has passed.
+ (If WAL archiving is being used and you want to put a lower limit on how
+ often files are archived in order to bound potential data loss, you should
+ adjust the archive_timeout parameter rather than the
+ checkpoint parameters.)
+ It is also possible to force a checkpoint by using the SQL
+ command CHECKPOINT.
+
+ Reducing checkpoint_timeout and/or
+ max_wal_size causes checkpoints to occur
+ more often. This allows faster after-crash recovery, since less work
+ will need to be redone. However, one must balance this against the
+ increased cost of flushing dirty data pages more often. If
+ full_page_writes is set (as is the default), there is
+ another factor to consider. To ensure data page consistency,
+ the first modification of a data page after each checkpoint results in
+ logging the entire page content. In that case,
+ a smaller checkpoint interval increases the volume of output to the WAL,
+ partially negating the goal of using a smaller interval,
+ and in any case causing more disk I/O.
+
+ Checkpoints are fairly expensive, first because they require writing
+ out all currently dirty buffers, and second because they result in
+ extra subsequent WAL traffic as discussed above. It is therefore
+ wise to set the checkpointing parameters high enough so that checkpoints
+ don't happen too often. As a simple sanity check on your checkpointing
+ parameters, you can set the checkpoint_warning
+ parameter. If checkpoints happen closer together than
+ checkpoint_warning seconds,
+ a message will be output to the server log recommending increasing
+ max_wal_size. Occasional appearance of such
+ a message is not cause for alarm, but if it appears often then the
+ checkpoint control parameters should be increased. Bulk operations such
+ as large COPY transfers might cause a number of such warnings
+ to appear if you have not set max_wal_size high
+ enough.
+
+ To avoid flooding the I/O system with a burst of page writes,
+ writing dirty buffers during a checkpoint is spread over a period of time.
+ That period is controlled by
+ checkpoint_completion_target, which is
+ given as a fraction of the checkpoint interval (configured by using
+ checkpoint_timeout).
+ The I/O rate is adjusted so that the checkpoint finishes when the
+ given fraction of
+ checkpoint_timeout seconds have elapsed, or before
+ max_wal_size is exceeded, whichever is sooner.
+ With the default value of 0.9,
+ PostgreSQL can be expected to complete each checkpoint
+ a bit before the next scheduled checkpoint (at around 90% of the last checkpoint's
+ duration). This spreads out the I/O as much as possible so that the checkpoint
+ I/O load is consistent throughout the checkpoint interval. The disadvantage of
+ this is that prolonging checkpoints affects recovery time, because more WAL
+ segments will need to be kept around for possible use in recovery. A user
+ concerned about the amount of time required to recover might wish to reduce
+ checkpoint_timeout so that checkpoints occur more frequently
+ but still spread the I/O across the checkpoint interval. Alternatively,
+ checkpoint_completion_target could be reduced, but this would
+ result in times of more intense I/O (during the checkpoint) and times of less I/O
+ (after the checkpoint completed but before the next scheduled checkpoint) and
+ therefore is not recommended.
+ Although checkpoint_completion_target could be set as high as
+ 1.0, it is typically recommended to set it to no higher than 0.9 (the default)
+ since checkpoints include some other activities besides writing dirty buffers.
+ A setting of 1.0 is quite likely to result in checkpoints not being
+ completed on time, which would result in performance loss due to
+ unexpected variation in the number of WAL segments needed.
+
+ On Linux and POSIX platforms checkpoint_flush_after
+ allows to force the OS that pages written by the checkpoint should be
+ flushed to disk after a configurable number of bytes. Otherwise, these
+ pages may be kept in the OS's page cache, inducing a stall when
+ fsync is issued at the end of a checkpoint. This setting will
+ often help to reduce transaction latency, but it also can have an adverse
+ effect on performance; particularly for workloads that are bigger than
+ shared_buffers, but smaller than the OS's page cache.
+
+ The number of WAL segment files in pg_wal directory depends on
+ min_wal_size, max_wal_size and
+ the amount of WAL generated in previous checkpoint cycles. When old WAL
+ segment files are no longer needed, they are removed or recycled (that is,
+ renamed to become future segments in the numbered sequence). If, due to a
+ short-term peak of WAL output rate, max_wal_size is
+ exceeded, the unneeded segment files will be removed until the system
+ gets back under this limit. Below that limit, the system recycles enough
+ WAL files to cover the estimated need until the next checkpoint, and
+ removes the rest. The estimate is based on a moving average of the number
+ of WAL files used in previous checkpoint cycles. The moving average
+ is increased immediately if the actual usage exceeds the estimate, so it
+ accommodates peak usage rather than average usage to some extent.
+ min_wal_size puts a minimum on the amount of WAL files
+ recycled for future usage; that much WAL is always recycled for future use,
+ even if the system is idle and the WAL usage estimate suggests that little
+ WAL is needed.
+
+ Independently of max_wal_size,
+ the most recent wal_keep_size megabytes of
+ WAL files plus one additional WAL file are
+ kept at all times. Also, if WAL archiving is used, old segments cannot be
+ removed or recycled until they are archived. If WAL archiving cannot keep up
+ with the pace that WAL is generated, or if archive_command
+ or archive_library
+ fails repeatedly, old WAL files will accumulate in pg_wal
+ until the situation is resolved. A slow or failed standby server that
+ uses a replication slot will have the same effect (see
+ Section 27.2.6).
+
+ In archive recovery or standby mode, the server periodically performs
+ restartpoints,
+ which are similar to checkpoints in normal operation: the server forces
+ all its state to disk, updates the pg_control file to
+ indicate that the already-processed WAL data need not be scanned again,
+ and then recycles any old WAL segment files in the pg_wal
+ directory.
+ Restartpoints can't be performed more frequently than checkpoints on the
+ primary because restartpoints can only be performed at checkpoint records.
+ A restartpoint is triggered when a checkpoint record is reached if at
+ least checkpoint_timeout seconds have passed since the last
+ restartpoint, or if WAL size is about to exceed
+ max_wal_size. However, because of limitations on when a
+ restartpoint can be performed, max_wal_size is often exceeded
+ during recovery, by up to one checkpoint cycle's worth of WAL.
+ (max_wal_size is never a hard limit anyway, so you should
+ always leave plenty of headroom to avoid running out of disk space.)
+
+ There are two commonly used internal WAL functions:
+ XLogInsertRecord and XLogFlush.
+ XLogInsertRecord is used to place a new record into
+ the WAL buffers in shared memory. If there is no
+ space for the new record, XLogInsertRecord will have
+ to write (move to kernel cache) a few filled WAL
+ buffers. This is undesirable because XLogInsertRecord
+ is used on every database low level modification (for example, row
+ insertion) at a time when an exclusive lock is held on affected
+ data pages, so the operation needs to be as fast as possible. What
+ is worse, writing WAL buffers might also force the
+ creation of a new WAL segment, which takes even more
+ time. Normally, WAL buffers should be written
+ and flushed by an XLogFlush request, which is
+ made, for the most part, at transaction commit time to ensure that
+ transaction records are flushed to permanent storage. On systems
+ with high WAL output, XLogFlush requests might
+ not occur often enough to prevent XLogInsertRecord
+ from having to do writes. On such systems
+ one should increase the number of WAL buffers by
+ modifying the wal_buffers parameter. When
+ full_page_writes is set and the system is very busy,
+ setting wal_buffers higher will help smooth response times
+ during the period immediately following each checkpoint.
+
+ The commit_delay parameter defines for how many
+ microseconds a group commit leader process will sleep after acquiring a
+ lock within XLogFlush, while group commit
+ followers queue up behind the leader. This delay allows other server
+ processes to add their commit records to the WAL buffers so that all of
+ them will be flushed by the leader's eventual sync operation. No sleep
+ will occur if fsync is not enabled, or if fewer
+ than commit_siblings other sessions are currently
+ in active transactions; this avoids sleeping when it's unlikely that
+ any other session will commit soon. Note that on some platforms, the
+ resolution of a sleep request is ten milliseconds, so that any nonzero
+ commit_delay setting between 1 and 10000
+ microseconds would have the same effect. Note also that on some
+ platforms, sleep operations may take slightly longer than requested by
+ the parameter.
+
+ Since the purpose of commit_delay is to allow the
+ cost of each flush operation to be amortized across concurrently
+ committing transactions (potentially at the expense of transaction
+ latency), it is necessary to quantify that cost before the setting can
+ be chosen intelligently. The higher that cost is, the more effective
+ commit_delay is expected to be in increasing
+ transaction throughput, up to a point. The pg_test_fsync program can be used to measure the average time
+ in microseconds that a single WAL flush operation takes. A value of
+ half of the average time the program reports it takes to flush after a
+ single 8kB write operation is often the most effective setting for
+ commit_delay, so this value is recommended as the
+ starting point to use when optimizing for a particular workload. While
+ tuning commit_delay is particularly useful when the
+ WAL is stored on high-latency rotating disks, benefits can be
+ significant even on storage media with very fast sync times, such as
+ solid-state drives or RAID arrays with a battery-backed write cache;
+ but this should definitely be tested against a representative workload.
+ Higher values of commit_siblings should be used in
+ such cases, whereas smaller commit_siblings values
+ are often helpful on higher latency media. Note that it is quite
+ possible that a setting of commit_delay that is too
+ high can increase transaction latency by so much that total transaction
+ throughput suffers.
+
+ When commit_delay is set to zero (the default), it
+ is still possible for a form of group commit to occur, but each group
+ will consist only of sessions that reach the point where they need to
+ flush their commit records during the window in which the previous
+ flush operation (if any) is occurring. At higher client counts a
+ “gangway effect” tends to occur, so that the effects of group
+ commit become significant even when commit_delay is
+ zero, and thus explicitly setting commit_delay tends
+ to help less. Setting commit_delay can only help
+ when (1) there are some concurrently committing transactions, and (2)
+ throughput is limited to some degree by commit rate; but with high
+ rotational latency this setting can be effective in increasing
+ transaction throughput with as few as two clients (that is, a single
+ committing client with one sibling transaction).
+
+ The wal_sync_method parameter determines how
+ PostgreSQL will ask the kernel to force
+ WAL updates out to disk.
+ All the options should be the same in terms of reliability, with
+ the exception of fsync_writethrough, which can sometimes
+ force a flush of the disk cache even when other options do not do so.
+ However, it's quite platform-specific which one will be the fastest.
+ You can test the speeds of different options using the pg_test_fsync program.
+ Note that this parameter is irrelevant if fsync
+ has been turned off.
+
+ Enabling the wal_debug configuration parameter
+ (provided that PostgreSQL has been
+ compiled with support for it) will result in each
+ XLogInsertRecord and XLogFlush
+ WAL call being logged to the server log. This
+ option might be replaced by a more general mechanism in the future.
+
+ There are two internal functions to write WAL data to disk:
+ XLogWrite and issue_xlog_fsync.
+ When track_wal_io_timing is enabled, the total
+ amounts of time XLogWrite writes and
+ issue_xlog_fsync syncs WAL data to disk are counted as
+ wal_write_time and wal_sync_time in
+ pg_stat_wal, respectively.
+ XLogWrite is normally called by
+ XLogInsertRecord (when there is no space for the new
+ record in WAL buffers), XLogFlush and the WAL writer,
+ to write WAL buffers to disk and call issue_xlog_fsync.
+ issue_xlog_fsync is normally called by
+ XLogWrite to sync WAL files to disk.
+ If wal_sync_method is either
+ open_datasync or open_sync,
+ a write operation in XLogWrite guarantees to sync written
+ WAL data to disk and issue_xlog_fsync does nothing.
+ If wal_sync_method is either fdatasync,
+ fsync, or fsync_writethrough,
+ the write operation moves WAL buffers to kernel cache and
+ issue_xlog_fsync syncs them to disk. Regardless
+ of the setting of track_wal_io_timing, the number
+ of times XLogWrite writes and
+ issue_xlog_fsync syncs WAL data to disk are also
+ counted as wal_write and wal_sync
+ in pg_stat_wal, respectively.
+
+ The recovery_prefetch parameter can be used to reduce
+ I/O wait times during recovery by instructing the kernel to initiate reads
+ of disk blocks that will soon be needed but are not currently in
+ PostgreSQL's buffer pool.
+ The maintenance_io_concurrency and
+ wal_decode_buffer_size settings limit prefetching
+ concurrency and distance, respectively. By default, it is set to
+ try, which enables the feature on systems where
+ posix_fadvise is available.
+
+ WAL is automatically enabled; no action is
+ required from the administrator except ensuring that the
+ disk-space requirements for the WAL files are met,
+ and that any necessary tuning is done (see Section 30.5).
+
+ WAL records are appended to the WAL
+ files as each new record is written. The insert position is described by
+ a Log Sequence Number (LSN) that is a byte offset into
+ the WAL, increasing monotonically with each new record.
+ LSN values are returned as the datatype
+ pg_lsn. Values can be
+ compared to calculate the volume of WAL data that
+ separates them, so they are used to measure the progress of replication
+ and recovery.
+
+ WAL files are stored in the directory
+ pg_wal under the data directory, as a set of
+ segment files, normally each 16 MB in size (but the size can be changed
+ by altering the --wal-segsize initdb option). Each segment is
+ divided into pages, normally 8 kB each (this size can be changed via the
+ --with-wal-blocksize configure option). The WAL record headers
+ are described in access/xlogrecord.h; the record
+ content is dependent on the type of event that is being logged. Segment
+ files are given ever-increasing numbers as names, starting at
+ 000000010000000000000001. The numbers do not wrap,
+ but it will take a very, very long time to exhaust the
+ available stock of numbers.
+
+ It is advantageous if the WAL is located on a different disk from the
+ main database files. This can be achieved by moving the
+ pg_wal directory to another location (while the server
+ is shut down, of course) and creating a symbolic link from the
+ original location in the main data directory to the new location.
+
+ The aim of WAL is to ensure that the log is
+ written before database records are altered, but this can be subverted by
+ disk drives that falsely report a
+ successful write to the kernel,
+ when in fact they have only cached the data and not yet stored it
+ on the disk. A power failure in such a situation might lead to
+ irrecoverable data corruption. Administrators should try to ensure
+ that disks holding PostgreSQL's
+ WAL files do not make such false reports.
+ (See Section 30.1.)
+
+ After a checkpoint has been made and the WAL flushed, the
+ checkpoint's position is saved in the file
+ pg_control. Therefore, at the start of recovery,
+ the server first reads pg_control and
+ then the checkpoint record; then it performs the REDO operation by
+ scanning forward from the WAL location indicated in the checkpoint
+ record. Because the entire content of data pages is saved in the
+ WAL on the first page modification after a checkpoint (assuming
+ full_page_writes is not disabled), all pages
+ changed since the checkpoint will be restored to a consistent
+ state.
+
+ To deal with the case where pg_control is
+ corrupt, we should support the possibility of scanning existing WAL
+ segments in reverse order — newest to oldest — in order to find the
+ latest checkpoint. This has not been implemented yet.
+ pg_control is small enough (less than one disk page)
+ that it is not subject to partial-write problems, and as of this writing
+ there have been no reports of database failures due solely to the inability
+ to read pg_control itself. So while it is
+ theoretically a weak spot, pg_control does not
+ seem to be a problem in practice.
+
30.3. Write-Ahead Logging (WAL) #
+ Write-Ahead Logging (WAL)
+ is a standard method for ensuring data integrity. A detailed
+ description can be found in most (if not all) books about
+ transaction processing. Briefly, WAL's central
+ concept is that changes to data files (where tables and indexes
+ reside) must be written only after those changes have been logged,
+ that is, after WAL records describing the changes have been flushed
+ to permanent storage. If we follow this procedure, we do not need
+ to flush data pages to disk on every transaction commit, because we
+ know that in the event of a crash we will be able to recover the
+ database using the log: any changes that have not been applied to
+ the data pages can be redone from the WAL records. (This is
+ roll-forward recovery, also known as REDO.)
+
Tip
+ Because WAL restores database file
+ contents after a crash, journaled file systems are not necessary for
+ reliable storage of the data files or WAL files. In fact, journaling
+ overhead can reduce performance, especially if journaling
+ causes file system data to be flushed
+ to disk. Fortunately, data flushing during journaling can
+ often be disabled with a file system mount option, e.g.,
+ data=writeback on a Linux ext3 file system.
+ Journaled file systems do improve boot speed after a crash.
+
+ Using WAL results in a
+ significantly reduced number of disk writes, because only the WAL
+ file needs to be flushed to disk to guarantee that a transaction is
+ committed, rather than every data file changed by the transaction.
+ The WAL file is written sequentially,
+ and so the cost of syncing the WAL is much less than the cost of
+ flushing the data pages. This is especially true for servers
+ handling many small transactions touching different parts of the data
+ store. Furthermore, when the server is processing many small concurrent
+ transactions, one fsync of the WAL file may
+ suffice to commit many transactions.
+
+ WAL also makes it possible to support on-line
+ backup and point-in-time recovery, as described in Section 26.3. By archiving the WAL data we can support
+ reverting to any time instant covered by the available WAL data:
+ we simply install a prior physical backup of the database, and
+ replay the WAL just as far as the desired time. What's more,
+ the physical backup doesn't have to be an instantaneous snapshot
+ of the database state — if it is made over some period of time,
+ then replaying the WAL for that period will fix any internal
+ inconsistencies.
+
+ Reliability is an important property of any serious database
+ system, and PostgreSQL does everything possible to
+ guarantee reliable operation. One aspect of reliable operation is
+ that all data recorded by a committed transaction should be stored
+ in a nonvolatile area that is safe from power loss, operating
+ system failure, and hardware failure (except failure of the
+ nonvolatile area itself, of course). Successfully writing the data
+ to the computer's permanent storage (disk drive or equivalent)
+ ordinarily meets this requirement. In fact, even if a computer is
+ fatally damaged, if the disk drives survive they can be moved to
+ another computer with similar hardware and all committed
+ transactions will remain intact.
+
+ While forcing data to the disk platters periodically might seem like
+ a simple operation, it is not. Because disk drives are dramatically
+ slower than main memory and CPUs, several layers of caching exist
+ between the computer's main memory and the disk platters.
+ First, there is the operating system's buffer cache, which caches
+ frequently requested disk blocks and combines disk writes. Fortunately,
+ all operating systems give applications a way to force writes from
+ the buffer cache to disk, and PostgreSQL uses those
+ features. (See the wal_sync_method parameter
+ to adjust how this is done.)
+
+ Next, there might be a cache in the disk drive controller; this is
+ particularly common on RAID controller cards. Some of
+ these caches are write-through, meaning writes are sent
+ to the drive as soon as they arrive. Others are
+ write-back, meaning data is sent to the drive at
+ some later time. Such caches can be a reliability hazard because the
+ memory in the disk controller cache is volatile, and will lose its
+ contents in a power failure. Better controller cards have
+ battery-backup units (BBUs), meaning
+ the card has a battery that
+ maintains power to the cache in case of system power loss. After power
+ is restored the data will be written to the disk drives.
+
+ And finally, most disk drives have caches. Some are write-through
+ while some are write-back, and the same concerns about data loss
+ exist for write-back drive caches as for disk controller
+ caches. Consumer-grade IDE and SATA drives are particularly likely
+ to have write-back caches that will not survive a power failure. Many
+ solid-state drives (SSD) also have volatile write-back caches.
+
+ These caches can typically be disabled; however, the method for doing
+ this varies by operating system and drive type:
+
+ On Linux, IDE and SATA drives can be queried using
+ hdparm -I; write caching is enabled if there is
+ a * next to Write cache. hdparm -W 0
+ can be used to turn off write caching. SCSI drives can be queried
+ using sdparm.
+ Use sdparm --get=WCE to check
+ whether the write cache is enabled and sdparm --clear=WCE
+ to disable it.
+
+ On FreeBSD, IDE drives can be queried using
+ camcontrol identify and write caching turned off using
+ hw.ata.wc=0 in /boot/loader.conf;
+ SCSI drives can be queried using camcontrol identify,
+ and the write cache both queried and changed using
+ sdparm when available.
+
+ On Solaris, the disk write cache is controlled by
+ format -e.
+ (The Solaris ZFS file system is safe with disk write-cache
+ enabled because it issues its own disk cache flush commands.)
+
+ On Windows, if wal_sync_method is
+ open_datasync (the default), write caching can be disabled
+ by unchecking My Computer\Open\disk drive\Properties\Hardware\Properties\Policies\Enable write caching on the disk.
+ Alternatively, set wal_sync_method to
+ fdatasync (NTFS only), fsync or
+ fsync_writethrough, which prevent
+ write caching.
+
+ On macOS, write caching can be prevented by
+ setting wal_sync_method to fsync_writethrough.
+
+ Recent SATA drives (those following ATAPI-6 or later)
+ offer a drive cache flush command (FLUSH CACHE EXT),
+ while SCSI drives have long supported a similar command
+ SYNCHRONIZE CACHE. These commands are not directly
+ accessible to PostgreSQL, but some file systems
+ (e.g., ZFS, ext4) can use them to flush
+ data to the platters on write-back-enabled drives. Unfortunately, such
+ file systems behave suboptimally when combined with battery-backup unit
+ (BBU) disk controllers. In such setups, the synchronize
+ command forces all data from the controller cache to the disks,
+ eliminating much of the benefit of the BBU. You can run the
+ pg_test_fsync program to see
+ if you are affected. If you are affected, the performance benefits
+ of the BBU can be regained by turning off write barriers in
+ the file system or reconfiguring the disk controller, if that is
+ an option. If write barriers are turned off, make sure the battery
+ remains functional; a faulty battery can potentially lead to data loss.
+ Hopefully file system and disk controller designers will eventually
+ address this suboptimal behavior.
+
+ When the operating system sends a write request to the storage hardware,
+ there is little it can do to make sure the data has arrived at a truly
+ non-volatile storage area. Rather, it is the
+ administrator's responsibility to make certain that all storage components
+ ensure integrity for both data and file-system metadata.
+ Avoid disk controllers that have non-battery-backed write caches.
+ At the drive level, disable write-back caching if the
+ drive cannot guarantee the data will be written before shutdown.
+ If you use SSDs, be aware that many of these do not honor cache flush
+ commands by default.
+ You can test for reliable I/O subsystem behavior using diskchecker.pl.
+
+ Another risk of data loss is posed by the disk platter write
+ operations themselves. Disk platters are divided into sectors,
+ commonly 512 bytes each. Every physical read or write operation
+ processes a whole sector.
+ When a write request arrives at the drive, it might be for some multiple
+ of 512 bytes (PostgreSQL typically writes 8192 bytes, or
+ 16 sectors, at a time), and the process of writing could fail due
+ to power loss at any time, meaning some of the 512-byte sectors were
+ written while others were not. To guard against such failures,
+ PostgreSQL periodically writes full page images to
+ permanent WAL storage before modifying the actual page on
+ disk. By doing this, during crash recovery PostgreSQL can
+ restore partially-written pages from WAL. If you have file-system software
+ that prevents partial page writes (e.g., ZFS), you can turn off
+ this page imaging by turning off the full_page_writes parameter. Battery-Backed Unit
+ (BBU) disk controllers do not prevent partial page writes unless
+ they guarantee that data is written to the BBU as full (8kB) pages.
+
+ PostgreSQL also protects against some kinds of data corruption
+ on storage devices that may occur because of hardware errors or media failure over time,
+ such as reading/writing garbage data.
+
+ Each individual record in a WAL file is protected by a CRC-32 (32-bit) check
+ that allows us to tell if record contents are correct. The CRC value
+ is set when we write each WAL record and checked during crash recovery,
+ archive recovery and replication.
+
+ Data pages are not currently checksummed by default, though full page images
+ recorded in WAL records will be protected; see initdb
+ for details about enabling data checksums.
+
+ Internal data structures such as pg_xact, pg_subtrans, pg_multixact,
+ pg_serial, pg_notify, pg_stat, pg_snapshots are not directly
+ checksummed, nor are pages protected by full page writes. However, where
+ such data structures are persistent, WAL records are written that allow
+ recent changes to be accurately rebuilt at crash recovery and those
+ WAL records are protected as discussed above.
+
+ Individual state files in pg_twophase are protected by CRC-32.
+
+ Temporary data files used in larger SQL queries for sorts,
+ materializations and intermediate results are not currently checksummed,
+ nor will WAL records be written for changes to those files.
+
+
+ PostgreSQL does not protect against correctable memory errors
+ and it is assumed you will operate using RAM that uses industry standard
+ Error Correcting Codes (ECC) or better protection.
+
Chapter 30. Reliability and the Write-Ahead Log
+ This chapter explains how to control the reliability of
+ PostgreSQL, including details about the
+ Write-Ahead Log.
+
+ If the primary server fails then the standby server should begin
+ failover procedures.
+
+ If the standby server fails then no failover need take place. If the
+ standby server can be restarted, even some time later, then the recovery
+ process can also be restarted immediately, taking advantage of
+ restartable recovery. If the standby server cannot be restarted, then a
+ full new standby server instance should be created.
+
+ If the primary server fails and the standby server becomes the
+ new primary, and then the old primary restarts, you must have
+ a mechanism for informing the old primary that it is no longer the primary. This is
+ sometimes known as STONITH (Shoot The Other Node In The Head), which is
+ necessary to avoid situations where both systems think they are the
+ primary, which will lead to confusion and ultimately data loss.
+
+ Many failover systems use just two systems, the primary and the standby,
+ connected by some kind of heartbeat mechanism to continually verify the
+ connectivity between the two and the viability of the primary. It is
+ also possible to use a third system (called a witness server) to prevent
+ some cases of inappropriate failover, but the additional complexity
+ might not be worthwhile unless it is set up with sufficient care and
+ rigorous testing.
+
+ PostgreSQL does not provide the system
+ software required to identify a failure on the primary and notify
+ the standby database server. Many such tools exist and are well
+ integrated with the operating system facilities required for
+ successful failover, such as IP address migration.
+
+ Once failover to the standby occurs, there is only a
+ single server in operation. This is known as a degenerate state.
+ The former standby is now the primary, but the former primary is down
+ and might stay down. To return to normal operation, a standby server
+ must be recreated,
+ either on the former primary system when it comes up, or on a third,
+ possibly new, system. The pg_rewind utility can be
+ used to speed up this process on large clusters.
+ Once complete, the primary and standby can be
+ considered to have switched roles. Some people choose to use a third
+ server to provide backup for the new primary until the new standby
+ server is recreated,
+ though clearly this complicates the system configuration and
+ operational processes.
+
+ So, switching from primary to standby server can be fast but requires
+ some time to re-prepare the failover cluster. Regular switching from
+ primary to standby is useful, since it allows regular downtime on
+ each system for maintenance. This also serves as a test of the
+ failover mechanism to ensure that it will really work when you need it.
+ Written administration procedures are advised.
+
+ To trigger failover of a log-shipping standby server, run
+ pg_ctl promote or call pg_promote().
+ If you're setting up reporting servers that are only used to offload
+ read-only queries from the primary, not for high availability purposes,
+ you don't need to promote.
+
27.2. Log-Shipping Standby Servers #
+ Continuous archiving can be used to create a high
+ availability (HA) cluster configuration with one or more
+ standby servers ready to take over operations if the
+ primary server fails. This capability is widely referred to as
+ warm standby or log shipping.
+
+ The primary and standby server work together to provide this capability,
+ though the servers are only loosely coupled. The primary server operates
+ in continuous archiving mode, while each standby server operates in
+ continuous recovery mode, reading the WAL files from the primary. No
+ changes to the database tables are required to enable this capability,
+ so it offers low administration overhead compared to some other
+ replication solutions. This configuration also has relatively low
+ performance impact on the primary server.
+
+ Directly moving WAL records from one database server to another
+ is typically described as log shipping. PostgreSQL
+ implements file-based log shipping by transferring WAL records
+ one file (WAL segment) at a time. WAL files (16MB) can be
+ shipped easily and cheaply over any distance, whether it be to an
+ adjacent system, another system at the same site, or another system on
+ the far side of the globe. The bandwidth required for this technique
+ varies according to the transaction rate of the primary server.
+ Record-based log shipping is more granular and streams WAL changes
+ incrementally over a network connection (see Section 27.2.5).
+
+ It should be noted that log shipping is asynchronous, i.e., the WAL
+ records are shipped after transaction commit. As a result, there is a
+ window for data loss should the primary server suffer a catastrophic
+ failure; transactions not yet shipped will be lost. The size of the
+ data loss window in file-based log shipping can be limited by use of the
+ archive_timeout parameter, which can be set as low
+ as a few seconds. However such a low setting will
+ substantially increase the bandwidth required for file shipping.
+ Streaming replication (see Section 27.2.5)
+ allows a much smaller window of data loss.
+
+ Recovery performance is sufficiently good that the standby will
+ typically be only moments away from full
+ availability once it has been activated. As a result, this is called
+ a warm standby configuration which offers high
+ availability. Restoring a server from an archived base backup and
+ rollforward will take considerably longer, so that technique only
+ offers a solution for disaster recovery, not high availability.
+ A standby server can also be used for read-only queries, in which case
+ it is called a hot standby server. See
+ Section 27.4 for more information.
+
+ It is usually wise to create the primary and standby servers
+ so that they are as similar as possible, at least from the
+ perspective of the database server. In particular, the path names
+ associated with tablespaces will be passed across unmodified, so both
+ primary and standby servers must have the same mount paths for
+ tablespaces if that feature is used. Keep in mind that if
+ CREATE TABLESPACE
+ is executed on the primary, any new mount point needed for it must
+ be created on the primary and all standby servers before the command
+ is executed. Hardware need not be exactly the same, but experience shows
+ that maintaining two identical systems is easier than maintaining two
+ dissimilar ones over the lifetime of the application and system.
+ In any case the hardware architecture must be the same — shipping
+ from, say, a 32-bit to a 64-bit system will not work.
+
+ In general, log shipping between servers running different major
+ PostgreSQL release
+ levels is not possible. It is the policy of the PostgreSQL Global
+ Development Group not to make changes to disk formats during minor release
+ upgrades, so it is likely that running different minor release levels
+ on primary and standby servers will work successfully. However, no
+ formal support for that is offered and you are advised to keep primary
+ and standby servers at the same release level as much as possible.
+ When updating to a new minor release, the safest policy is to update
+ the standby servers first — a new minor release is more likely
+ to be able to read WAL files from a previous minor release than vice
+ versa.
+
27.2.2. Standby Server Operation #
+ A server enters standby mode if a
+
+ standby.signal
+
+ file exists in the data directory when the server is started.
+
+ In standby mode, the server continuously applies WAL received from the
+ primary server. The standby server can read WAL from a WAL archive
+ (see restore_command) or directly from the primary
+ over a TCP connection (streaming replication). The standby server will
+ also attempt to restore any WAL found in the standby cluster's
+ pg_wal directory. That typically happens after a server
+ restart, when the standby replays again WAL that was streamed from the
+ primary before the restart, but you can also manually copy files to
+ pg_wal at any time to have them replayed.
+
+ At startup, the standby begins by restoring all WAL available in the
+ archive location, calling restore_command. Once it
+ reaches the end of WAL available there and restore_command
+ fails, it tries to restore any WAL available in the pg_wal directory.
+ If that fails, and streaming replication has been configured, the
+ standby tries to connect to the primary server and start streaming WAL
+ from the last valid record found in archive or pg_wal. If that fails
+ or streaming replication is not configured, or if the connection is
+ later disconnected, the standby goes back to step 1 and tries to
+ restore the file from the archive again. This loop of retries from the
+ archive, pg_wal, and via streaming replication goes on until the server
+ is stopped or is promoted.
+
+ Standby mode is exited and the server switches to normal operation
+ when pg_ctl promote is run, or
+ pg_promote() is called. Before failover,
+ any WAL immediately available in the archive or in pg_wal
+ will be restored, but no attempt is made to connect to the primary.
+
27.2.3. Preparing the Primary for Standby Servers #
+ Set up continuous archiving on the primary to an archive directory
+ accessible from the standby, as described
+ in Section 26.3. The archive location should be
+ accessible from the standby even when the primary is down, i.e., it should
+ reside on the standby server itself or another trusted server, not on
+ the primary server.
+
+ If you want to use streaming replication, set up authentication on the
+ primary server to allow replication connections from the standby
+ server(s); that is, create a role and provide a suitable entry or
+ entries in pg_hba.conf with the database field set to
+ replication. Also ensure max_wal_senders is set
+ to a sufficiently large value in the configuration file of the primary
+ server. If replication slots will be used,
+ ensure that max_replication_slots is set sufficiently
+ high as well.
+
+ Take a base backup as described in Section 26.3.2
+ to bootstrap the standby server.
+
27.2.4. Setting Up a Standby Server #
+ To set up the standby server, restore the base backup taken from primary
+ server (see Section 26.3.4). Create a file
+ standby.signal
+ in the standby's cluster data
+ directory. Set restore_command to a simple command to copy files from
+ the WAL archive. If you plan to have multiple standby servers for high
+ availability purposes, make sure that recovery_target_timeline is set to
+ latest (the default), to make the standby server follow the timeline change
+ that occurs at failover to another standby.
+
Note
+ restore_command should return immediately
+ if the file does not exist; the server will retry the command again if
+ necessary.
+
+ If you want to use streaming replication, fill in
+ primary_conninfo with a libpq connection string, including
+ the host name (or IP address) and any additional details needed to
+ connect to the primary server. If the primary needs a password for
+ authentication, the password needs to be specified in
+ primary_conninfo as well.
+
+ If you're setting up the standby server for high availability purposes,
+ set up WAL archiving, connections and authentication like the primary
+ server, because the standby server will work as a primary server after
+ failover.
+
+ If you're using a WAL archive, its size can be minimized using the archive_cleanup_command parameter to remove files that are no
+ longer required by the standby server.
+ The pg_archivecleanup utility is designed specifically to
+ be used with archive_cleanup_command in typical single-standby
+ configurations, see pg_archivecleanup.
+ Note however, that if you're using the archive for backup purposes, you
+ need to retain files needed to recover from at least the latest base
+ backup, even if they're no longer needed by the standby.
+
+ A simple example of configuration is:
+
+primary_conninfo = 'host=192.168.1.50 port=5432 user=foo password=foopass options=''-c wal_sender_timeout=5000'''
+restore_command = 'cp /path/to/archive/%f %p'
+archive_cleanup_command = 'pg_archivecleanup /path/to/archive %r'
+
+
+ You can have any number of standby servers, but if you use streaming
+ replication, make sure you set max_wal_senders high enough in
+ the primary to allow them to be connected simultaneously.
+
27.2.5. Streaming Replication #
+ Streaming replication allows a standby server to stay more up-to-date
+ than is possible with file-based log shipping. The standby connects
+ to the primary, which streams WAL records to the standby as they're
+ generated, without waiting for the WAL file to be filled.
+
+ Streaming replication is asynchronous by default
+ (see Section 27.2.8), in which case there is
+ a small delay between committing a transaction in the primary and the
+ changes becoming visible in the standby. This delay is however much
+ smaller than with file-based log shipping, typically under one second
+ assuming the standby is powerful enough to keep up with the load. With
+ streaming replication, archive_timeout is not required to
+ reduce the data loss window.
+
+ If you use streaming replication without file-based continuous
+ archiving, the server might recycle old WAL segments before the standby
+ has received them. If this occurs, the standby will need to be
+ reinitialized from a new base backup. You can avoid this by setting
+ wal_keep_size to a value large enough to ensure that
+ WAL segments are not recycled too early, or by configuring a replication
+ slot for the standby. If you set up a WAL archive that's accessible from
+ the standby, these solutions are not required, since the standby can
+ always use the archive to catch up provided it retains enough segments.
+
+ To use streaming replication, set up a file-based log-shipping standby
+ server as described in Section 27.2. The step that
+ turns a file-based log-shipping standby into streaming replication
+ standby is setting the primary_conninfo setting
+ to point to the primary server. Set
+ listen_addresses and authentication options
+ (see pg_hba.conf) on the primary so that the standby server
+ can connect to the replication pseudo-database on the primary
+ server (see Section 27.2.5.1).
+
+ On systems that support the keepalive socket option, setting
+ tcp_keepalives_idle,
+ tcp_keepalives_interval and
+ tcp_keepalives_count helps the primary promptly
+ notice a broken connection.
+
+ Set the maximum number of concurrent connections from the standby servers
+ (see max_wal_senders for details).
+
+ When the standby is started and primary_conninfo is set
+ correctly, the standby will connect to the primary after replaying all
+ WAL files available in the archive. If the connection is established
+ successfully, you will see a walreceiver in the standby, and
+ a corresponding walsender process in the primary.
+
27.2.5.1. Authentication #
+ It is very important that the access privileges for replication be set up
+ so that only trusted users can read the WAL stream, because it is
+ easy to extract privileged information from it. Standby servers must
+ authenticate to the primary as an account that has the
+ REPLICATION privilege or a superuser. It is
+ recommended to create a dedicated user account with
+ REPLICATION and LOGIN
+ privileges for replication. While REPLICATION
+ privilege gives very high permissions, it does not allow the user to
+ modify any data on the primary system, which the
+ SUPERUSER privilege does.
+
+ Client authentication for replication is controlled by a
+ pg_hba.conf record specifying replication in the
+ database field. For example, if the standby is running on
+ host IP 192.168.1.100 and the account name for replication
+ is foo, the administrator can add the following line to the
+ pg_hba.conf file on the primary:
+
+
+# Allow the user "foo" from host 192.168.1.100 to connect to the primary
+# as a replication standby if the user's password is correctly supplied.
+#
+# TYPE DATABASE USER ADDRESS METHOD
+host replication foo 192.168.1.100/32 md5
+
+
+ The host name and port number of the primary, connection user name,
+ and password are specified in the primary_conninfo.
+ The password can also be set in the ~/.pgpass file on the
+ standby (specify replication in the database
+ field).
+ For example, if the primary is running on host IP 192.168.1.50,
+ port 5432, the account name for replication is
+ foo, and the password is foopass, the administrator
+ can add the following line to the postgresql.conf file on the
+ standby:
+
+
+# The standby connects to the primary that is running on host 192.168.1.50
+# and port 5432 as the user "foo" whose password is "foopass".
+primary_conninfo = 'host=192.168.1.50 port=5432 user=foo password=foopass'
+
+
+ An important health indicator of streaming replication is the amount
+ of WAL records generated in the primary, but not yet applied in the
+ standby. You can calculate this lag by comparing the current WAL write
+ location on the primary with the last WAL location received by the
+ standby. These locations can be retrieved using
+ pg_current_wal_lsn on the primary and
+ pg_last_wal_receive_lsn on the standby,
+ respectively (see Table 9.91 and
+ Table 9.92 for details).
+ The last WAL receive location in the standby is also displayed in the
+ process status of the WAL receiver process, displayed using the
+ ps command (see Section 28.1 for details).
+
+ You can retrieve a list of WAL sender processes via the
+
+ pg_stat_replication view. Large differences between
+ pg_current_wal_lsn and the view's sent_lsn field
+ might indicate that the primary server is under heavy load, while
+ differences between sent_lsn and
+ pg_last_wal_receive_lsn on the standby might indicate
+ network delay, or that the standby is under heavy load.
+
+ On a hot standby, the status of the WAL receiver process can be retrieved
+ via the
+ pg_stat_wal_receiver view. A large
+ difference between pg_last_wal_replay_lsn and the
+ view's flushed_lsn indicates that WAL is being
+ received faster than it can be replayed.
+
27.2.6. Replication Slots #
+ Replication slots provide an automated way to ensure that the primary does
+ not remove WAL segments until they have been received by all standbys,
+ and that the primary does not remove rows which could cause a
+ recovery conflict even when the
+ standby is disconnected.
+
+ In lieu of using replication slots, it is possible to prevent the removal
+ of old WAL segments using wal_keep_size, or by
+ storing the segments in an archive using
+ archive_command or archive_library.
+ However, these methods often result in retaining more WAL segments than
+ required, whereas replication slots retain only the number of segments
+ known to be needed. On the other hand, replication slots can retain so
+ many WAL segments that they fill up the space allocated
+ for pg_wal;
+ max_slot_wal_keep_size limits the size of WAL files
+ retained by replication slots.
+
+ Similarly, hot_standby_feedback on its own, without
+ also using a replication slot, provides protection against relevant rows
+ being removed by vacuum, but provides no protection during any time period
+ when the standby is not connected. Replication slots overcome these
+ disadvantages.
+
27.2.6.1. Querying and Manipulating Replication Slots #
+ Each replication slot has a name, which can contain lower-case letters,
+ numbers, and the underscore character.
+
+ Existing replication slots and their state can be seen in the
+ pg_replication_slots
+ view.
+
+ Slots can be created and dropped either via the streaming replication
+ protocol (see Section 55.4) or via SQL
+ functions (see Section 9.27.6).
+
27.2.6.2. Configuration Example #
+ You can create a replication slot like this:
+
+postgres=# SELECT * FROM pg_create_physical_replication_slot('node_a_slot');
+ slot_name | lsn
+-------------+-----
+ node_a_slot |
+
+postgres=# SELECT slot_name, slot_type, active FROM pg_replication_slots;
+ slot_name | slot_type | active
+-------------+-----------+--------
+ node_a_slot | physical | f
+(1 row)
+
+ To configure the standby to use this slot, primary_slot_name
+ should be configured on the standby. Here is a simple example:
+
+primary_conninfo = 'host=192.168.1.50 port=5432 user=foo password=foopass'
+primary_slot_name = 'node_a_slot'
+
+
27.2.7. Cascading Replication #
+ The cascading replication feature allows a standby server to accept replication
+ connections and stream WAL records to other standbys, acting as a relay.
+ This can be used to reduce the number of direct connections to the primary
+ and also to minimize inter-site bandwidth overheads.
+
+ A standby acting as both a receiver and a sender is known as a cascading
+ standby. Standbys that are more directly connected to the primary are known
+ as upstream servers, while those standby servers further away are downstream
+ servers. Cascading replication does not place limits on the number or
+ arrangement of downstream servers, though each standby connects to only
+ one upstream server which eventually links to a single primary server.
+
+ A cascading standby sends not only WAL records received from the
+ primary but also those restored from the archive. So even if the replication
+ connection in some upstream connection is terminated, streaming replication
+ continues downstream for as long as new WAL records are available.
+
+ Cascading replication is currently asynchronous. Synchronous replication
+ (see Section 27.2.8) settings have no effect on
+ cascading replication at present.
+
+ Hot standby feedback propagates upstream, whatever the cascaded arrangement.
+
+ If an upstream standby server is promoted to become the new primary, downstream
+ servers will continue to stream from the new primary if
+ recovery_target_timeline is set to 'latest' (the default).
+
+ To use cascading replication, set up the cascading standby so that it can
+ accept replication connections (that is, set
+ max_wal_senders and hot_standby,
+ and configure
+ host-based authentication).
+ You will also need to set primary_conninfo in the downstream
+ standby to point to the cascading standby.
+
27.2.8. Synchronous Replication #
+ PostgreSQL streaming replication is asynchronous by
+ default. If the primary server
+ crashes then some transactions that were committed may not have been
+ replicated to the standby server, causing data loss. The amount
+ of data loss is proportional to the replication delay at the time of
+ failover.
+
+ Synchronous replication offers the ability to confirm that all changes
+ made by a transaction have been transferred to one or more synchronous
+ standby servers. This extends that standard level of durability
+ offered by a transaction commit. This level of protection is referred
+ to as 2-safe replication in computer science theory, and group-1-safe
+ (group-safe and 1-safe) when synchronous_commit is set to
+ remote_write.
+
+ When requesting synchronous replication, each commit of a
+ write transaction will wait until confirmation is
+ received that the commit has been written to the write-ahead log on disk
+ of both the primary and standby server. The only possibility that data
+ can be lost is if both the primary and the standby suffer crashes at the
+ same time. This can provide a much higher level of durability, though only
+ if the sysadmin is cautious about the placement and management of the two
+ servers. Waiting for confirmation increases the user's confidence that the
+ changes will not be lost in the event of server crashes but it also
+ necessarily increases the response time for the requesting transaction.
+ The minimum wait time is the round-trip time between primary and standby.
+
+ Read-only transactions and transaction rollbacks need not wait for
+ replies from standby servers. Subtransaction commits do not wait for
+ responses from standby servers, only top-level commits. Long
+ running actions such as data loading or index building do not wait
+ until the very final commit message. All two-phase commit actions
+ require commit waits, including both prepare and commit.
+
+ A synchronous standby can be a physical replication standby or a logical
+ replication subscriber. It can also be any other physical or logical WAL
+ replication stream consumer that knows how to send the appropriate
+ feedback messages. Besides the built-in physical and logical replication
+ systems, this includes special programs such
+ as pg_receivewal and pg_recvlogical
+ as well as some third-party replication systems and custom programs.
+ Check the respective documentation for details on synchronous replication
+ support.
+
27.2.8.1. Basic Configuration #
+ Once streaming replication has been configured, configuring synchronous
+ replication requires only one additional configuration step:
+ synchronous_standby_names must be set to
+ a non-empty value. synchronous_commit must also be set to
+ on, but since this is the default value, typically no change is
+ required. (See Section 20.5.1 and
+ Section 20.6.2.)
+ This configuration will cause each commit to wait for
+ confirmation that the standby has written the commit record to durable
+ storage.
+ synchronous_commit can be set by individual
+ users, so it can be configured in the configuration file, for particular
+ users or databases, or dynamically by applications, in order to control
+ the durability guarantee on a per-transaction basis.
+
+ After a commit record has been written to disk on the primary, the
+ WAL record is then sent to the standby. The standby sends reply
+ messages each time a new batch of WAL data is written to disk, unless
+ wal_receiver_status_interval is set to zero on the standby.
+ In the case that synchronous_commit is set to
+ remote_apply, the standby sends reply messages when the commit
+ record is replayed, making the transaction visible.
+ If the standby is chosen as a synchronous standby, according to the setting
+ of synchronous_standby_names on the primary, the reply
+ messages from that standby will be considered along with those from other
+ synchronous standbys to decide when to release transactions waiting for
+ confirmation that the commit record has been received. These parameters
+ allow the administrator to specify which standby servers should be
+ synchronous standbys. Note that the configuration of synchronous
+ replication is mainly on the primary. Named standbys must be directly
+ connected to the primary; the primary knows nothing about downstream
+ standby servers using cascaded replication.
+
+ Setting synchronous_commit to remote_write will
+ cause each commit to wait for confirmation that the standby has received
+ the commit record and written it out to its own operating system, but not
+ for the data to be flushed to disk on the standby. This
+ setting provides a weaker guarantee of durability than on
+ does: the standby could lose the data in the event of an operating system
+ crash, though not a PostgreSQL crash.
+ However, it's a useful setting in practice
+ because it can decrease the response time for the transaction.
+ Data loss could only occur if both the primary and the standby crash and
+ the database of the primary gets corrupted at the same time.
+
+ Setting synchronous_commit to remote_apply will
+ cause each commit to wait until the current synchronous standbys report
+ that they have replayed the transaction, making it visible to user
+ queries. In simple cases, this allows for load balancing with causal
+ consistency.
+
+ Users will stop waiting if a fast shutdown is requested. However, as
+ when using asynchronous replication, the server will not fully
+ shutdown until all outstanding WAL records are transferred to the currently
+ connected standby servers.
+
27.2.8.2. Multiple Synchronous Standbys #
+ Synchronous replication supports one or more synchronous standby servers;
+ transactions will wait until all the standby servers which are considered
+ as synchronous confirm receipt of their data. The number of synchronous
+ standbys that transactions must wait for replies from is specified in
+ synchronous_standby_names. This parameter also specifies
+ a list of standby names and the method (FIRST and
+ ANY) to choose synchronous standbys from the listed ones.
+
+ The method FIRST specifies a priority-based synchronous
+ replication and makes transaction commits wait until their WAL records are
+ replicated to the requested number of synchronous standbys chosen based on
+ their priorities. The standbys whose names appear earlier in the list are
+ given higher priority and will be considered as synchronous. Other standby
+ servers appearing later in this list represent potential synchronous
+ standbys. If any of the current synchronous standbys disconnects for
+ whatever reason, it will be replaced immediately with the
+ next-highest-priority standby.
+
+ An example of synchronous_standby_names for
+ a priority-based multiple synchronous standbys is:
+
+synchronous_standby_names = 'FIRST 2 (s1, s2, s3)'
+
+ In this example, if four standby servers s1, s2,
+ s3 and s4 are running, the two standbys
+ s1 and s2 will be chosen as synchronous standbys
+ because their names appear early in the list of standby names.
+ s3 is a potential synchronous standby and will take over
+ the role of synchronous standby when either of s1 or
+ s2 fails. s4 is an asynchronous standby since
+ its name is not in the list.
+
+ The method ANY specifies a quorum-based synchronous
+ replication and makes transaction commits wait until their WAL records
+ are replicated to at least the requested number of
+ synchronous standbys in the list.
+
+ An example of synchronous_standby_names for
+ a quorum-based multiple synchronous standbys is:
+
+synchronous_standby_names = 'ANY 2 (s1, s2, s3)'
+
+ In this example, if four standby servers s1, s2,
+ s3 and s4 are running, transaction commits will
+ wait for replies from at least any two standbys of s1,
+ s2 and s3. s4 is an asynchronous
+ standby since its name is not in the list.
+
+ The synchronous states of standby servers can be viewed using
+ the pg_stat_replication view.
+
27.2.8.4. Planning for High Availability #
+ synchronous_standby_names specifies the number and
+ names of synchronous standbys that transaction commits made when
+ synchronous_commit is set to on,
+ remote_apply or remote_write will wait for
+ responses from. Such transaction commits may never be completed
+ if any one of the synchronous standbys should crash.
+
+ The best solution for high availability is to ensure you keep as many
+ synchronous standbys as requested. This can be achieved by naming multiple
+ potential synchronous standbys using synchronous_standby_names.
+
+ In a priority-based synchronous replication, the standbys whose names
+ appear earlier in the list will be used as synchronous standbys.
+ Standbys listed after these will take over the role of synchronous standby
+ if one of current ones should fail.
+
+ In a quorum-based synchronous replication, all the standbys appearing
+ in the list will be used as candidates for synchronous standbys.
+ Even if one of them should fail, the other standbys will keep performing
+ the role of candidates of synchronous standby.
+
+ When a standby first attaches to the primary, it will not yet be properly
+ synchronized. This is described as catchup mode. Once
+ the lag between standby and primary reaches zero for the first time
+ we move to real-time streaming state.
+ The catch-up duration may be long immediately after the standby has
+ been created. If the standby is shut down, then the catch-up period
+ will increase according to the length of time the standby has been down.
+ The standby is only able to become a synchronous standby
+ once it has reached streaming state.
+ This state can be viewed using
+ the pg_stat_replication view.
+
+ If primary restarts while commits are waiting for acknowledgment, those
+ waiting transactions will be marked fully committed once the primary
+ database recovers.
+ There is no way to be certain that all standbys have received all
+ outstanding WAL data at time of the crash of the primary. Some
+ transactions may not show as committed on the standby, even though
+ they show as committed on the primary. The guarantee we offer is that
+ the application will not receive explicit acknowledgment of the
+ successful commit of a transaction until the WAL data is known to be
+ safely received by all the synchronous standbys.
+
+ If you really cannot keep as many synchronous standbys as requested
+ then you should decrease the number of synchronous standbys that
+ transaction commits must wait for responses from
+ in synchronous_standby_names (or disable it) and
+ reload the configuration file on the primary server.
+
+ If the primary is isolated from remaining standby servers you should
+ fail over to the best candidate of those other remaining standby servers.
+
+ If you need to re-create a standby server while transactions are
+ waiting, make sure that the commands pg_backup_start() and
+ pg_backup_stop() are run in a session with
+ synchronous_commit = off, otherwise those
+ requests will wait forever for the standby to appear.
+
27.2.9. Continuous Archiving in Standby #
+ When continuous WAL archiving is used in a standby, there are two
+ different scenarios: the WAL archive can be shared between the primary
+ and the standby, or the standby can have its own WAL archive. When
+ the standby has its own WAL archive, set archive_mode
+ to always, and the standby will call the archive
+ command for every WAL segment it receives, whether it's by restoring
+ from the archive or by streaming replication. The shared archive can
+ be handled similarly, but the archive_command or archive_library must
+ test if the file being archived exists already, and if the existing file
+ has identical contents. This requires more care in the
+ archive_command or archive_library, as it must
+ be careful to not overwrite an existing file with different contents,
+ but return success if the exactly same file is archived twice. And
+ all that must be done free of race conditions, if two servers attempt
+ to archive the same file at the same time.
+
+ If archive_mode is set to on, the
+ archiver is not enabled during recovery or standby mode. If the standby
+ server is promoted, it will start archiving after the promotion, but
+ will not archive any WAL or timeline history files that
+ it did not generate itself. To get a complete
+ series of WAL files in the archive, you must ensure that all WAL is
+ archived, before it reaches the standby. This is inherently true with
+ file-based log shipping, as the standby can only restore files that
+ are found in the archive, but not if streaming replication is enabled.
+ When a server is not in recovery mode, there is no difference between
+ on and always modes.
+
15.2. When Can Parallel Query Be Used? #
+ There are several settings that can cause the query planner not to
+ generate a parallel query plan under any circumstances. In order for
+ any parallel query plans whatsoever to be generated, the following
+ settings must be configured as indicated.
+
+ In addition, the system must not be running in single-user mode. Since
+ the entire database system is running as a single process in this situation,
+ no background workers will be available.
+
+ Even when it is in general possible for parallel query plans to be
+ generated, the planner will not generate them for a given query
+ if any of the following are true:
+
+ The query writes any data or locks any database rows. If a query
+ contains a data-modifying operation either at the top level or within
+ a CTE, no parallel plans for that query will be generated. As an
+ exception, the following commands, which create a new table and populate
+ it, can use a parallel plan for the underlying SELECT
+ part of the query:
+
+
+
+ The query might be suspended during execution. In any situation in
+ which the system thinks that partial or incremental execution might
+ occur, no parallel plan is generated. For example, a cursor created
+ using DECLARE CURSOR will never use
+ a parallel plan. Similarly, a PL/pgSQL loop of the form
+ FOR x IN query LOOP .. END LOOP will never use a
+ parallel plan, because the parallel query system is unable to verify
+ that the code in the loop is safe to execute while parallel query is
+ active.
+
+ The query uses any function marked PARALLEL UNSAFE.
+ Most system-defined functions are PARALLEL SAFE,
+ but user-defined functions are marked PARALLEL
+ UNSAFE by default. See the discussion of
+ Section 15.4.
+
+ The query is running inside of another query that is already parallel.
+ For example, if a function called by a parallel query issues an SQL
+ query itself, that query will never use a parallel plan. This is a
+ limitation of the current implementation, but it may not be desirable
+ to remove this limitation, since it could result in a single query
+ using a very large number of processes.
+
+ Even when parallel query plan is generated for a particular query, there
+ are several circumstances under which it will be impossible to execute
+ that plan in parallel at execution time. If this occurs, the leader
+ will execute the portion of the plan below the Gather
+ node entirely by itself, almost as if the Gather node were
+ not present. This will happen if any of the following conditions are met:
+
+ No background workers can be obtained because of the limitation that
+ the total number of background workers cannot exceed
+ max_worker_processes.
+
+ No background workers can be obtained because of the limitation that
+ the total number of background workers launched for purposes of
+ parallel query cannot exceed max_parallel_workers.
+
+ The client sends an Execute message with a non-zero fetch count.
+ See the discussion of the
+ extended query protocol.
+ Since libpq currently provides no way to
+ send such a message, this can only occur when using a client that
+ does not rely on libpq. If this is a frequent
+ occurrence, it may be a good idea to set
+ max_parallel_workers_per_gather to zero in
+ sessions where it is likely, so as to avoid generating query plans
+ that may be suboptimal when run serially.
+
74.2. Transactions and Locking #
+ The transaction IDs of currently executing transactions are shown in
+ pg_locks
+ in columns virtualxid and
+ transactionid. Read-only transactions
+ will have virtualxids but NULL
+ transactionids, while both columns will be
+ set in read-write transactions.
+
+ Some lock types wait on virtualxid,
+ while other types wait on transactionid.
+ Row-level read and write locks are recorded directly in the locked
+ rows and can be inspected using the pgrowlocks
+ extension. Row-level read locks might also require the assignment
+ of multixact IDs (mxid; see Section 25.1.5.1).
+
38.12. User-Defined Aggregates #
+ Aggregate functions in PostgreSQL
+ are defined in terms of state values
+ and state transition functions.
+ That is, an aggregate operates using a state value that is updated
+ as each successive input row is processed.
+ To define a new aggregate
+ function, one selects a data type for the state value,
+ an initial value for the state, and a state transition
+ function. The state transition function takes the previous state
+ value and the aggregate's input value(s) for the current row, and
+ returns a new state value.
+ A final function
+ can also be specified, in case the desired result of the aggregate
+ is different from the data that needs to be kept in the running
+ state value. The final function takes the ending state value
+ and returns whatever is wanted as the aggregate result.
+ In principle, the transition and final functions are just ordinary
+ functions that could also be used outside the context of the
+ aggregate. (In practice, it's often helpful for performance reasons
+ to create specialized transition functions that can only work when
+ called as part of an aggregate.)
+
+ Thus, in addition to the argument and result data types seen by a user
+ of the aggregate, there is an internal state-value data type that
+ might be different from both the argument and result types.
+
+ If we define an aggregate that does not use a final function,
+ we have an aggregate that computes a running function of
+ the column values from each row. sum is an
+ example of this kind of aggregate. sum starts at
+ zero and always adds the current row's value to
+ its running total. For example, if we want to make a sum
+ aggregate to work on a data type for complex numbers,
+ we only need the addition function for that data type.
+ The aggregate definition would be:
+
+
+CREATE AGGREGATE sum (complex)
+(
+ sfunc = complex_add,
+ stype = complex,
+ initcond = '(0,0)'
+);
+
+
+ which we might use like this:
+
+
+SELECT sum(a) FROM test_complex;
+
+ sum
+-----------
+ (34,53.9)
+
+
+ (Notice that we are relying on function overloading: there is more than
+ one aggregate named sum, but
+ PostgreSQL can figure out which kind
+ of sum applies to a column of type complex.)
+
+ The above definition of sum will return zero
+ (the initial state value) if there are no nonnull input values.
+ Perhaps we want to return null in that case instead — the SQL standard
+ expects sum to behave that way. We can do this simply by
+ omitting the initcond phrase, so that the initial state
+ value is null. Ordinarily this would mean that the sfunc
+ would need to check for a null state-value input. But for
+ sum and some other simple aggregates like
+ max and min,
+ it is sufficient to insert the first nonnull input value into
+ the state variable and then start applying the transition function
+ at the second nonnull input value. PostgreSQL
+ will do that automatically if the initial state value is null and
+ the transition function is marked “strict” (i.e., not to be called
+ for null inputs).
+
+ Another bit of default behavior for a “strict” transition function
+ is that the previous state value is retained unchanged whenever a
+ null input value is encountered. Thus, null values are ignored. If you
+ need some other behavior for null inputs, do not declare your
+ transition function as strict; instead code it to test for null inputs and
+ do whatever is needed.
+
+ avg (average) is a more complex example of an aggregate.
+ It requires
+ two pieces of running state: the sum of the inputs and the count
+ of the number of inputs. The final result is obtained by dividing
+ these quantities. Average is typically implemented by using an
+ array as the state value. For example,
+ the built-in implementation of avg(float8)
+ looks like:
+
+
+CREATE AGGREGATE avg (float8)
+(
+ sfunc = float8_accum,
+ stype = float8[],
+ finalfunc = float8_avg,
+ initcond = '{0,0,0}'
+);
+
+
Note
+ float8_accum requires a three-element array, not just
+ two elements, because it accumulates the sum of squares as well as
+ the sum and count of the inputs. This is so that it can be used for
+ some other aggregates as well as avg.
+
+ Aggregate function calls in SQL allow DISTINCT
+ and ORDER BY options that control which rows are fed
+ to the aggregate's transition function and in what order. These
+ options are implemented behind the scenes and are not the concern
+ of the aggregate's support functions.
+
+ For further details see the
+ CREATE AGGREGATE
+ command.
+
38.12.1. Moving-Aggregate Mode #
+ Aggregate functions can optionally support moving-aggregate
+ mode, which allows substantially faster execution of aggregate
+ functions within windows with moving frame starting points.
+ (See Section 3.5
+ and Section 4.2.8 for information about use of
+ aggregate functions as window functions.)
+ The basic idea is that in addition to a normal “forward”
+ transition function, the aggregate provides an inverse
+ transition function, which allows rows to be removed from the
+ aggregate's running state value when they exit the window frame.
+ For example a sum aggregate, which uses addition as the
+ forward transition function, would use subtraction as the inverse
+ transition function. Without an inverse transition function, the window
+ function mechanism must recalculate the aggregate from scratch each time
+ the frame starting point moves, resulting in run time proportional to the
+ number of input rows times the average frame length. With an inverse
+ transition function, the run time is only proportional to the number of
+ input rows.
+
+ The inverse transition function is passed the current state value and the
+ aggregate input value(s) for the earliest row included in the current
+ state. It must reconstruct what the state value would have been if the
+ given input row had never been aggregated, but only the rows following
+ it. This sometimes requires that the forward transition function keep
+ more state than is needed for plain aggregation mode. Therefore, the
+ moving-aggregate mode uses a completely separate implementation from the
+ plain mode: it has its own state data type, its own forward transition
+ function, and its own final function if needed. These can be the same as
+ the plain mode's data type and functions, if there is no need for extra
+ state.
+
+ As an example, we could extend the sum aggregate given above
+ to support moving-aggregate mode like this:
+
+
+CREATE AGGREGATE sum (complex)
+(
+ sfunc = complex_add,
+ stype = complex,
+ initcond = '(0,0)',
+ msfunc = complex_add,
+ minvfunc = complex_sub,
+ mstype = complex,
+ minitcond = '(0,0)'
+);
+
+
+ The parameters whose names begin with m define the
+ moving-aggregate implementation. Except for the inverse transition
+ function minvfunc, they correspond to the plain-aggregate
+ parameters without m.
+
+ The forward transition function for moving-aggregate mode is not allowed
+ to return null as the new state value. If the inverse transition
+ function returns null, this is taken as an indication that the inverse
+ function cannot reverse the state calculation for this particular input,
+ and so the aggregate calculation will be redone from scratch for the
+ current frame starting position. This convention allows moving-aggregate
+ mode to be used in situations where there are some infrequent cases that
+ are impractical to reverse out of the running state value. The inverse
+ transition function can “punt” on these cases, and yet still come
+ out ahead so long as it can work for most cases. As an example, an
+ aggregate working with floating-point numbers might choose to punt when
+ a NaN (not a number) input has to be removed from the running
+ state value.
+
+ When writing moving-aggregate support functions, it is important to be
+ sure that the inverse transition function can reconstruct the correct
+ state value exactly. Otherwise there might be user-visible differences
+ in results depending on whether the moving-aggregate mode is used.
+ An example of an aggregate for which adding an inverse transition
+ function seems easy at first, yet where this requirement cannot be met
+ is sum over float4 or float8 inputs. A
+ naive declaration of sum(float8) could be
+
+
+CREATE AGGREGATE unsafe_sum (float8)
+(
+ stype = float8,
+ sfunc = float8pl,
+ mstype = float8,
+ msfunc = float8pl,
+ minvfunc = float8mi
+);
+
+
+ This aggregate, however, can give wildly different results than it would
+ have without the inverse transition function. For example, consider
+
+
+SELECT
+ unsafe_sum(x) OVER (ORDER BY n ROWS BETWEEN CURRENT ROW AND 1 FOLLOWING)
+FROM (VALUES (1, 1.0e20::float8),
+ (2, 1.0::float8)) AS v (n,x);
+
+
+ This query returns 0 as its second result, rather than the
+ expected answer of 1. The cause is the limited precision of
+ floating-point values: adding 1 to 1e20 results
+ in 1e20 again, and so subtracting 1e20 from that
+ yields 0, not 1. Note that this is a limitation
+ of floating-point arithmetic in general, not a limitation
+ of PostgreSQL.
+
38.12.2. Polymorphic and Variadic Aggregates #
+ Aggregate functions can use polymorphic
+ state transition functions or final functions, so that the same functions
+ can be used to implement multiple aggregates.
+ See Section 38.2.5
+ for an explanation of polymorphic functions.
+ Going a step further, the aggregate function itself can be specified
+ with polymorphic input type(s) and state type, allowing a single
+ aggregate definition to serve for multiple input data types.
+ Here is an example of a polymorphic aggregate:
+
+
+CREATE AGGREGATE array_accum (anycompatible)
+(
+ sfunc = array_append,
+ stype = anycompatiblearray,
+ initcond = '{}'
+);
+
+
+ Here, the actual state type for any given aggregate call is the array type
+ having the actual input type as elements. The behavior of the aggregate
+ is to concatenate all the inputs into an array of that type.
+ (Note: the built-in aggregate array_agg provides similar
+ functionality, with better performance than this definition would have.)
+
+ Here's the output using two different actual data types as arguments:
+
+
+SELECT attrelid::regclass, array_accum(attname)
+ FROM pg_attribute
+ WHERE attnum > 0 AND attrelid = 'pg_tablespace'::regclass
+ GROUP BY attrelid;
+
+ attrelid | array_accum
+---------------+---------------------------------------
+ pg_tablespace | {spcname,spcowner,spcacl,spcoptions}
+(1 row)
+
+SELECT attrelid::regclass, array_accum(atttypid::regtype)
+ FROM pg_attribute
+ WHERE attnum > 0 AND attrelid = 'pg_tablespace'::regclass
+ GROUP BY attrelid;
+
+ attrelid | array_accum
+---------------+---------------------------
+ pg_tablespace | {name,oid,aclitem[],text[]}
+(1 row)
+
+
+ Ordinarily, an aggregate function with a polymorphic result type has a
+ polymorphic state type, as in the above example. This is necessary
+ because otherwise the final function cannot be declared sensibly: it
+ would need to have a polymorphic result type but no polymorphic argument
+ type, which CREATE FUNCTION will reject on the grounds that
+ the result type cannot be deduced from a call. But sometimes it is
+ inconvenient to use a polymorphic state type. The most common case is
+ where the aggregate support functions are to be written in C and the
+ state type should be declared as internal because there is
+ no SQL-level equivalent for it. To address this case, it is possible to
+ declare the final function as taking extra “dummy” arguments
+ that match the input arguments of the aggregate. Such dummy arguments
+ are always passed as null values since no specific value is available when the
+ final function is called. Their only use is to allow a polymorphic
+ final function's result type to be connected to the aggregate's input
+ type(s). For example, the definition of the built-in
+ aggregate array_agg is equivalent to
+
+
+CREATE FUNCTION array_agg_transfn(internal, anynonarray)
+ RETURNS internal ...;
+CREATE FUNCTION array_agg_finalfn(internal, anynonarray)
+ RETURNS anyarray ...;
+
+CREATE AGGREGATE array_agg (anynonarray)
+(
+ sfunc = array_agg_transfn,
+ stype = internal,
+ finalfunc = array_agg_finalfn,
+ finalfunc_extra
+);
+
+
+ Here, the finalfunc_extra option specifies that the final
+ function receives, in addition to the state value, extra dummy
+ argument(s) corresponding to the aggregate's input argument(s).
+ The extra anynonarray argument allows the declaration
+ of array_agg_finalfn to be valid.
+
+ An aggregate function can be made to accept a varying number of arguments
+ by declaring its last argument as a VARIADIC array, in much
+ the same fashion as for regular functions; see
+ Section 38.5.6. The aggregate's transition
+ function(s) must have the same array type as their last argument. The
+ transition function(s) typically would also be marked VARIADIC,
+ but this is not strictly required.
+
Note
+ Variadic aggregates are easily misused in connection with
+ the ORDER BY option (see Section 4.2.7),
+ since the parser cannot tell whether the wrong number of actual arguments
+ have been given in such a combination. Keep in mind that everything to
+ the right of ORDER BY is a sort key, not an argument to the
+ aggregate. For example, in
+
+SELECT myaggregate(a ORDER BY a, b, c) FROM ...
+
+ the parser will see this as a single aggregate function argument and
+ three sort keys. However, the user might have intended
+
+SELECT myaggregate(a, b, c ORDER BY a) FROM ...
+
+ If myaggregate is variadic, both these calls could be
+ perfectly valid.
+
+ For the same reason, it's wise to think twice before creating aggregate
+ functions with the same names and different numbers of regular arguments.
+
38.12.3. Ordered-Set Aggregates #
+ The aggregates we have been describing so far are “normal”
+ aggregates. PostgreSQL also
+ supports ordered-set aggregates, which differ from
+ normal aggregates in two key ways. First, in addition to ordinary
+ aggregated arguments that are evaluated once per input row, an
+ ordered-set aggregate can have “direct” arguments that are
+ evaluated only once per aggregation operation. Second, the syntax
+ for the ordinary aggregated arguments specifies a sort ordering
+ for them explicitly. An ordered-set aggregate is usually
+ used to implement a computation that depends on a specific row
+ ordering, for instance rank or percentile, so that the sort ordering
+ is a required aspect of any call. For example, the built-in
+ definition of percentile_disc is equivalent to:
+
+
+CREATE FUNCTION ordered_set_transition(internal, anyelement)
+ RETURNS internal ...;
+CREATE FUNCTION percentile_disc_final(internal, float8, anyelement)
+ RETURNS anyelement ...;
+
+CREATE AGGREGATE percentile_disc (float8 ORDER BY anyelement)
+(
+ sfunc = ordered_set_transition,
+ stype = internal,
+ finalfunc = percentile_disc_final,
+ finalfunc_extra
+);
+
+
+ This aggregate takes a float8 direct argument (the percentile
+ fraction) and an aggregated input that can be of any sortable data type.
+ It could be used to obtain a median household income like this:
+
+
+SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY income) FROM households;
+ percentile_disc
+-----------------
+ 50489
+
+
+ Here, 0.5 is a direct argument; it would make no sense
+ for the percentile fraction to be a value varying across rows.
+
+ Unlike the case for normal aggregates, the sorting of input rows for
+ an ordered-set aggregate is not done behind the scenes,
+ but is the responsibility of the aggregate's support functions.
+ The typical implementation approach is to keep a reference to
+ a “tuplesort” object in the aggregate's state value, feed the
+ incoming rows into that object, and then complete the sorting and
+ read out the data in the final function. This design allows the
+ final function to perform special operations such as injecting
+ additional “hypothetical” rows into the data to be sorted.
+ While normal aggregates can often be implemented with support
+ functions written in PL/pgSQL or another
+ PL language, ordered-set aggregates generally have to be written in
+ C, since their state values aren't definable as any SQL data type.
+ (In the above example, notice that the state value is declared as
+ type internal — this is typical.)
+ Also, because the final function performs the sort, it is not possible
+ to continue adding input rows by executing the transition function again
+ later. This means the final function is not READ_ONLY;
+ it must be declared in CREATE AGGREGATE
+ as READ_WRITE, or as SHAREABLE if
+ it's possible for additional final-function calls to make use of the
+ already-sorted state.
+
+ The state transition function for an ordered-set aggregate receives
+ the current state value plus the aggregated input values for
+ each row, and returns the updated state value. This is the
+ same definition as for normal aggregates, but note that the direct
+ arguments (if any) are not provided. The final function receives
+ the last state value, the values of the direct arguments if any,
+ and (if finalfunc_extra is specified) null values
+ corresponding to the aggregated input(s). As with normal
+ aggregates, finalfunc_extra is only really useful if the
+ aggregate is polymorphic; then the extra dummy argument(s) are needed
+ to connect the final function's result type to the aggregate's input
+ type(s).
+
+ Currently, ordered-set aggregates cannot be used as window functions,
+ and therefore there is no need for them to support moving-aggregate mode.
+
38.12.4. Partial Aggregation #
+ Optionally, an aggregate function can support partial
+ aggregation. The idea of partial aggregation is to run the aggregate's
+ state transition function over different subsets of the input data
+ independently, and then to combine the state values resulting from those
+ subsets to produce the same state value that would have resulted from
+ scanning all the input in a single operation. This mode can be used for
+ parallel aggregation by having different worker processes scan different
+ portions of a table. Each worker produces a partial state value, and at
+ the end those state values are combined to produce a final state value.
+ (In the future this mode might also be used for purposes such as combining
+ aggregations over local and remote tables; but that is not implemented
+ yet.)
+
+ To support partial aggregation, the aggregate definition must provide
+ a combine function, which takes two values of the
+ aggregate's state type (representing the results of aggregating over two
+ subsets of the input rows) and produces a new value of the state type,
+ representing what the state would have been after aggregating over the
+ combination of those sets of rows. It is unspecified what the relative
+ order of the input rows from the two sets would have been. This means
+ that it's usually impossible to define a useful combine function for
+ aggregates that are sensitive to input row order.
+
+ As simple examples, MAX and MIN aggregates can be
+ made to support partial aggregation by specifying the combine function as
+ the same greater-of-two or lesser-of-two comparison function that is used
+ as their transition function. SUM aggregates just need an
+ addition function as combine function. (Again, this is the same as their
+ transition function, unless the state value is wider than the input data
+ type.)
+
+ The combine function is treated much like a transition function that
+ happens to take a value of the state type, not of the underlying input
+ type, as its second argument. In particular, the rules for dealing
+ with null values and strict functions are similar. Also, if the aggregate
+ definition specifies a non-null initcond, keep in mind that
+ that will be used not only as the initial state for each partial
+ aggregation run, but also as the initial state for the combine function,
+ which will be called to combine each partial result into that state.
+
+ If the aggregate's state type is declared as internal, it is
+ the combine function's responsibility that its result is allocated in
+ the correct memory context for aggregate state values. This means in
+ particular that when the first input is NULL it's invalid
+ to simply return the second input, as that value will be in the wrong
+ context and will not have sufficient lifespan.
+
+ When the aggregate's state type is declared as internal, it is
+ usually also appropriate for the aggregate definition to provide a
+ serialization function and a deserialization
+ function, which allow such a state value to be copied from one process
+ to another. Without these functions, parallel aggregation cannot be
+ performed, and future applications such as local/remote aggregation will
+ probably not work either.
+
+ A serialization function must take a single argument of
+ type internal and return a result of type bytea, which
+ represents the state value packaged up into a flat blob of bytes.
+ Conversely, a deserialization function reverses that conversion. It must
+ take two arguments of types bytea and internal, and
+ return a result of type internal. (The second argument is unused
+ and is always zero, but it is required for type-safety reasons.) The
+ result of the deserialization function should simply be allocated in the
+ current memory context, as unlike the combine function's result, it is not
+ long-lived.
+
+ Worth noting also is that for an aggregate to be executed in parallel,
+ the aggregate itself must be marked PARALLEL SAFE. The
+ parallel-safety markings on its support functions are not consulted.
+
38.12.5. Support Functions for Aggregates #
+ A function written in C can detect that it is being called as an
+ aggregate support function by calling
+ AggCheckCallContext, for example:
+
+if (AggCheckCallContext(fcinfo, NULL))
+
+ One reason for checking this is that when it is true, the first input
+ must be a temporary state value and can therefore safely be modified
+ in-place rather than allocating a new copy.
+ See int8inc() for an example.
+ (While aggregate transition functions are always allowed to modify
+ the transition value in-place, aggregate final functions are generally
+ discouraged from doing so; if they do so, the behavior must be declared
+ when creating the aggregate. See CREATE AGGREGATE
+ for more detail.)
+
+ The second argument of AggCheckCallContext can be used to
+ retrieve the memory context in which aggregate state values are being kept.
+ This is useful for transition functions that wish to use “expanded”
+ objects (see Section 38.13.1) as their state values.
+ On first call, the transition function should return an expanded object
+ whose memory context is a child of the aggregate state context, and then
+ keep returning the same expanded object on subsequent calls. See
+ array_append() for an example. (array_append()
+ is not the transition function of any built-in aggregate, but it is written
+ to behave efficiently when used as transition function of a custom
+ aggregate.)
+
+ Another support routine available to aggregate functions written in C
+ is AggGetAggref, which returns the Aggref
+ parse node that defines the aggregate call. This is mainly useful
+ for ordered-set aggregates, which can inspect the substructure of
+ the Aggref node to find out what sort ordering they are
+ supposed to implement. Examples can be found
+ in orderedsetaggs.c in the PostgreSQL
+ source code.
+
38.10. C-Language Functions #
+ User-defined functions can be written in C (or a language that can
+ be made compatible with C, such as C++). Such functions are
+ compiled into dynamically loadable objects (also called shared
+ libraries) and are loaded by the server on demand. The dynamic
+ loading feature is what distinguishes “C language” functions
+ from “internal” functions — the actual coding conventions
+ are essentially the same for both. (Hence, the standard internal
+ function library is a rich source of coding examples for user-defined
+ C functions.)
+
+ Currently only one calling convention is used for C functions
+ (“version 1”). Support for that calling convention is
+ indicated by writing a PG_FUNCTION_INFO_V1() macro
+ call for the function, as illustrated below.
+
38.10.1. Dynamic Loading #
+ The first time a user-defined function in a particular
+ loadable object file is called in a session,
+ the dynamic loader loads that object file into memory so that the
+ function can be called. The CREATE FUNCTION
+ for a user-defined C function must therefore specify two pieces of
+ information for the function: the name of the loadable
+ object file, and the C name (link symbol) of the specific function to call
+ within that object file. If the C name is not explicitly specified then
+ it is assumed to be the same as the SQL function name.
+
+ The following algorithm is used to locate the shared object file
+ based on the name given in the CREATE FUNCTION
+ command:
+
+
+ If the name is an absolute path, the given file is loaded.
+
+ If the name starts with the string $libdir,
+ that part is replaced by the PostgreSQL package
+ library directory
+ name, which is determined at build time.
+
+ If the name does not contain a directory part, the file is
+ searched for in the path specified by the configuration variable
+ dynamic_library_path.
+
+ Otherwise (the file was not found in the path, or it contains a
+ non-absolute directory part), the dynamic loader will try to
+ take the name as given, which will most likely fail. (It is
+ unreliable to depend on the current working directory.)
+
+
+ If this sequence does not work, the platform-specific shared
+ library file name extension (often .so) is
+ appended to the given name and this sequence is tried again. If
+ that fails as well, the load will fail.
+
+ It is recommended to locate shared libraries either relative to
+ $libdir or through the dynamic library path.
+ This simplifies version upgrades if the new installation is at a
+ different location. The actual directory that
+ $libdir stands for can be found out with the
+ command pg_config --pkglibdir.
+
+ The user ID the PostgreSQL server runs
+ as must be able to traverse the path to the file you intend to
+ load. Making the file or a higher-level directory not readable
+ and/or not executable by the postgres
+ user is a common mistake.
+
+ In any case, the file name that is given in the
+ CREATE FUNCTION command is recorded literally
+ in the system catalogs, so if the file needs to be loaded again
+ the same procedure is applied.
+
Note
+ PostgreSQL will not compile a C function
+ automatically. The object file must be compiled before it is referenced
+ in a CREATE
+ FUNCTION command. See Section 38.10.5 for additional
+ information.
+
+ To ensure that a dynamically loaded object file is not loaded into an
+ incompatible server, PostgreSQL checks that the
+ file contains a “magic block” with the appropriate contents.
+ This allows the server to detect obvious incompatibilities, such as code
+ compiled for a different major version of
+ PostgreSQL. To include a magic block,
+ write this in one (and only one) of the module source files, after having
+ included the header fmgr.h:
+
+
+PG_MODULE_MAGIC;
+
+
+ After it is used for the first time, a dynamically loaded object
+ file is retained in memory. Future calls in the same session to
+ the function(s) in that file will only incur the small overhead of
+ a symbol table lookup. If you need to force a reload of an object
+ file, for example after recompiling it, begin a fresh session.
+
+ Optionally, a dynamically loaded file can contain an initialization
+ function. If the file includes a function named
+ _PG_init, that function will be called immediately after
+ loading the file. The function receives no parameters and should
+ return void. There is presently no way to unload a dynamically loaded file.
+
38.10.2. Base Types in C-Language Functions #
+ To know how to write C-language functions, you need to know how
+ PostgreSQL internally represents base
+ data types and how they can be passed to and from functions.
+ Internally, PostgreSQL regards a base
+ type as a “blob of memory”. The user-defined
+ functions that you define over a type in turn define the way that
+ PostgreSQL can operate on it. That
+ is, PostgreSQL will only store and
+ retrieve the data from disk and use your user-defined functions
+ to input, process, and output the data.
+
+ Base types can have one of three internal formats:
+
+
+ pass by value, fixed-length
+
+ pass by reference, fixed-length
+
+ pass by reference, variable-length
+
+
+ By-value types can only be 1, 2, or 4 bytes in length
+ (also 8 bytes, if sizeof(Datum) is 8 on your machine).
+ You should be careful to define your types such that they will be the
+ same size (in bytes) on all architectures. For example, the
+ long type is dangerous because it is 4 bytes on some
+ machines and 8 bytes on others, whereas int type is 4 bytes
+ on most Unix machines. A reasonable implementation of the
+ int4 type on Unix machines might be:
+
+
+/* 4-byte integer, passed by value */
+typedef int int4;
+
+
+ (The actual PostgreSQL C code calls this type int32, because
+ it is a convention in C that intXX
+ means XX bits. Note
+ therefore also that the C type int8 is 1 byte in size. The
+ SQL type int8 is called int64 in C. See also
+ Table 38.2.)
+
+ On the other hand, fixed-length types of any size can
+ be passed by-reference. For example, here is a sample
+ implementation of a PostgreSQL type:
+
+
+/* 16-byte structure, passed by reference */
+typedef struct
+{
+ double x, y;
+} Point;
+
+
+ Only pointers to such types can be used when passing
+ them in and out of PostgreSQL functions.
+ To return a value of such a type, allocate the right amount of
+ memory with palloc, fill in the allocated memory,
+ and return a pointer to it. (Also, if you just want to return the
+ same value as one of your input arguments that's of the same data type,
+ you can skip the extra palloc and just return the
+ pointer to the input value.)
+
+ Finally, all variable-length types must also be passed
+ by reference. All variable-length types must begin
+ with an opaque length field of exactly 4 bytes, which will be set
+ by SET_VARSIZE; never set this field directly! All data to
+ be stored within that type must be located in the memory
+ immediately following that length field. The
+ length field contains the total length of the structure,
+ that is, it includes the size of the length field
+ itself.
+
+ Another important point is to avoid leaving any uninitialized bits
+ within data type values; for example, take care to zero out any
+ alignment padding bytes that might be present in structs. Without
+ this, logically-equivalent constants of your data type might be
+ seen as unequal by the planner, leading to inefficient (though not
+ incorrect) plans.
+
Warning
+ Never modify the contents of a pass-by-reference input
+ value. If you do so you are likely to corrupt on-disk data, since
+ the pointer you are given might point directly into a disk buffer.
+ The sole exception to this rule is explained in
+ Section 38.12.
+
+ As an example, we can define the type text as
+ follows:
+
+
+typedef struct {
+ int32 length;
+ char data[FLEXIBLE_ARRAY_MEMBER];
+} text;
+
+
+ The [FLEXIBLE_ARRAY_MEMBER] notation means that the actual
+ length of the data part is not specified by this declaration.
+
+ When manipulating
+ variable-length types, we must be careful to allocate
+ the correct amount of memory and set the length field correctly.
+ For example, if we wanted to store 40 bytes in a text
+ structure, we might use a code fragment like this:
+
+
+#include "postgres.h"
+...
+char buffer[40]; /* our source data */
+...
+text *destination = (text *) palloc(VARHDRSZ + 40);
+SET_VARSIZE(destination, VARHDRSZ + 40);
+memcpy(destination->data, buffer, 40);
+...
+
+
+
+ VARHDRSZ is the same as sizeof(int32), but
+ it's considered good style to use the macro VARHDRSZ
+ to refer to the size of the overhead for a variable-length type.
+ Also, the length field must be set using the
+ SET_VARSIZE macro, not by simple assignment.
+
+ Table 38.2 shows the C types
+ corresponding to many of the built-in SQL data types
+ of PostgreSQL.
+ The “Defined In” column gives the header file that
+ needs to be included to get the type definition. (The actual
+ definition might be in a different file that is included by the
+ listed file. It is recommended that users stick to the defined
+ interface.) Note that you should always include
+ postgres.h first in any source file of server
+ code, because it declares a number of things that you will need
+ anyway, and because including other headers first can cause
+ portability issues.
+
Table 38.2. Equivalent C Types for Built-in SQL Types
|
+ SQL Type
+ |
+ C Type
+ |
+ Defined In
+ |
|---|
boolean | bool | postgres.h (maybe compiler built-in) |
box | BOX* | utils/geo_decls.h |
bytea | bytea* | postgres.h |
"char" | char | (compiler built-in) |
character | BpChar* | postgres.h |
cid | CommandId | postgres.h |
date | DateADT | utils/date.h |
float4 (real) | float4 | postgres.h |
float8 (double precision) | float8 | postgres.h |
int2 (smallint) | int16 | postgres.h |
int4 (integer) | int32 | postgres.h |
int8 (bigint) | int64 | postgres.h |
interval | Interval* | datatype/timestamp.h |
lseg | LSEG* | utils/geo_decls.h |
name | Name | postgres.h |
numeric | Numeric | utils/numeric.h |
oid | Oid | postgres.h |
oidvector | oidvector* | postgres.h |
path | PATH* | utils/geo_decls.h |
point | POINT* | utils/geo_decls.h |
regproc | RegProcedure | postgres.h |
text | text* | postgres.h |
tid | ItemPointer | storage/itemptr.h |
time | TimeADT | utils/date.h |
time with time zone | TimeTzADT | utils/date.h |
timestamp | Timestamp | datatype/timestamp.h |
timestamp with time zone | TimestampTz | datatype/timestamp.h |
varchar | VarChar* | postgres.h |
xid | TransactionId | postgres.h |
+ Now that we've gone over all of the possible structures
+ for base types, we can show some examples of real functions.
+
38.10.3. Version 1 Calling Conventions #
+ The version-1 calling convention relies on macros to suppress most
+ of the complexity of passing arguments and results. The C declaration
+ of a version-1 function is always:
+
+Datum funcname(PG_FUNCTION_ARGS)
+
+ In addition, the macro call:
+
+PG_FUNCTION_INFO_V1(funcname);
+
+ must appear in the same source file. (Conventionally, it's
+ written just before the function itself.) This macro call is not
+ needed for internal-language functions, since
+ PostgreSQL assumes that all internal functions
+ use the version-1 convention. It is, however, required for
+ dynamically-loaded functions.
+
+ In a version-1 function, each actual argument is fetched using a
+ PG_GETARG_xxx()
+ macro that corresponds to the argument's data type. (In non-strict
+ functions there needs to be a previous check about argument null-ness
+ using PG_ARGISNULL(); see below.)
+ The result is returned using a
+ PG_RETURN_xxx()
+ macro for the return type.
+ PG_GETARG_xxx()
+ takes as its argument the number of the function argument to
+ fetch, where the count starts at 0.
+ PG_RETURN_xxx()
+ takes as its argument the actual value to return.
+
+ Here are some examples using the version-1 calling convention:
+
+#include "postgres.h"
+#include <string.h>
+#include "fmgr.h"
+#include "utils/geo_decls.h"
+#include "varatt.h"
+
+PG_MODULE_MAGIC;
+
+/* by value */
+
+PG_FUNCTION_INFO_V1(add_one);
+
+Datum
+add_one(PG_FUNCTION_ARGS)
+{
+ int32 arg = PG_GETARG_INT32(0);
+
+ PG_RETURN_INT32(arg + 1);
+}
+
+/* by reference, fixed length */
+
+PG_FUNCTION_INFO_V1(add_one_float8);
+
+Datum
+add_one_float8(PG_FUNCTION_ARGS)
+{
+ /* The macros for FLOAT8 hide its pass-by-reference nature. */
+ float8 arg = PG_GETARG_FLOAT8(0);
+
+ PG_RETURN_FLOAT8(arg + 1.0);
+}
+
+PG_FUNCTION_INFO_V1(makepoint);
+
+Datum
+makepoint(PG_FUNCTION_ARGS)
+{
+ /* Here, the pass-by-reference nature of Point is not hidden. */
+ Point *pointx = PG_GETARG_POINT_P(0);
+ Point *pointy = PG_GETARG_POINT_P(1);
+ Point *new_point = (Point *) palloc(sizeof(Point));
+
+ new_point->x = pointx->x;
+ new_point->y = pointy->y;
+
+ PG_RETURN_POINT_P(new_point);
+}
+
+/* by reference, variable length */
+
+PG_FUNCTION_INFO_V1(copytext);
+
+Datum
+copytext(PG_FUNCTION_ARGS)
+{
+ text *t = PG_GETARG_TEXT_PP(0);
+
+ /*
+ * VARSIZE_ANY_EXHDR is the size of the struct in bytes, minus the
+ * VARHDRSZ or VARHDRSZ_SHORT of its header. Construct the copy with a
+ * full-length header.
+ */
+ text *new_t = (text *) palloc(VARSIZE_ANY_EXHDR(t) + VARHDRSZ);
+ SET_VARSIZE(new_t, VARSIZE_ANY_EXHDR(t) + VARHDRSZ);
+
+ /*
+ * VARDATA is a pointer to the data region of the new struct. The source
+ * could be a short datum, so retrieve its data through VARDATA_ANY.
+ */
+ memcpy(VARDATA(new_t), /* destination */
+ VARDATA_ANY(t), /* source */
+ VARSIZE_ANY_EXHDR(t)); /* how many bytes */
+ PG_RETURN_TEXT_P(new_t);
+}
+
+PG_FUNCTION_INFO_V1(concat_text);
+
+Datum
+concat_text(PG_FUNCTION_ARGS)
+{
+ text *arg1 = PG_GETARG_TEXT_PP(0);
+ text *arg2 = PG_GETARG_TEXT_PP(1);
+ int32 arg1_size = VARSIZE_ANY_EXHDR(arg1);
+ int32 arg2_size = VARSIZE_ANY_EXHDR(arg2);
+ int32 new_text_size = arg1_size + arg2_size + VARHDRSZ;
+ text *new_text = (text *) palloc(new_text_size);
+
+ SET_VARSIZE(new_text, new_text_size);
+ memcpy(VARDATA(new_text), VARDATA_ANY(arg1), arg1_size);
+ memcpy(VARDATA(new_text) + arg1_size, VARDATA_ANY(arg2), arg2_size);
+ PG_RETURN_TEXT_P(new_text);
+}
+
+
+ Supposing that the above code has been prepared in file
+ funcs.c and compiled into a shared object,
+ we could define the functions to PostgreSQL
+ with commands like this:
+
+CREATE FUNCTION add_one(integer) RETURNS integer
+ AS 'DIRECTORY/funcs', 'add_one'
+ LANGUAGE C STRICT;
+
+-- note overloading of SQL function name "add_one"
+CREATE FUNCTION add_one(double precision) RETURNS double precision
+ AS 'DIRECTORY/funcs', 'add_one_float8'
+ LANGUAGE C STRICT;
+
+CREATE FUNCTION makepoint(point, point) RETURNS point
+ AS 'DIRECTORY/funcs', 'makepoint'
+ LANGUAGE C STRICT;
+
+CREATE FUNCTION copytext(text) RETURNS text
+ AS 'DIRECTORY/funcs', 'copytext'
+ LANGUAGE C STRICT;
+
+CREATE FUNCTION concat_text(text, text) RETURNS text
+ AS 'DIRECTORY/funcs', 'concat_text'
+ LANGUAGE C STRICT;
+
+ Here, DIRECTORY stands for the
+ directory of the shared library file (for instance the
+ PostgreSQL tutorial directory, which
+ contains the code for the examples used in this section).
+ (Better style would be to use just 'funcs' in the
+ AS clause, after having added
+ DIRECTORY to the search path. In any
+ case, we can omit the system-specific extension for a shared
+ library, commonly .so.)
+
+ Notice that we have specified the functions as “strict”,
+ meaning that
+ the system should automatically assume a null result if any input
+ value is null. By doing this, we avoid having to check for null inputs
+ in the function code. Without this, we'd have to check for null values
+ explicitly, using PG_ARGISNULL().
+
+ The macro PG_ARGISNULL(n)
+ allows a function to test whether each input is null. (Of course, doing
+ this is only necessary in functions not declared “strict”.)
+ As with the
+ PG_GETARG_xxx() macros,
+ the input arguments are counted beginning at zero. Note that one
+ should refrain from executing
+ PG_GETARG_xxx() until
+ one has verified that the argument isn't null.
+ To return a null result, execute PG_RETURN_NULL();
+ this works in both strict and nonstrict functions.
+
+ At first glance, the version-1 coding conventions might appear
+ to be just pointless obscurantism, compared to using
+ plain C calling conventions. They do however allow
+ us to deal with NULLable arguments/return values,
+ and “toasted” (compressed or out-of-line) values.
+
+ Other options provided by the version-1 interface are two
+ variants of the
+ PG_GETARG_xxx()
+ macros. The first of these,
+ PG_GETARG_xxx_COPY(),
+ guarantees to return a copy of the specified argument that is
+ safe for writing into. (The normal macros will sometimes return a
+ pointer to a value that is physically stored in a table, which
+ must not be written to. Using the
+ PG_GETARG_xxx_COPY()
+ macros guarantees a writable result.)
+ The second variant consists of the
+ PG_GETARG_xxx_SLICE()
+ macros which take three arguments. The first is the number of the
+ function argument (as above). The second and third are the offset and
+ length of the segment to be returned. Offsets are counted from
+ zero, and a negative length requests that the remainder of the
+ value be returned. These macros provide more efficient access to
+ parts of large values in the case where they have storage type
+ “external”. (The storage type of a column can be specified using
+ ALTER TABLE tablename ALTER
+ COLUMN colname SET STORAGE
+ storagetype. storagetype is one of
+ plain, external, extended,
+ or main.)
+
+ Finally, the version-1 function call conventions make it possible
+ to return set results (Section 38.10.8) and
+ implement trigger functions (Chapter 39) and
+ procedural-language call handlers (Chapter 58). For more details
+ see src/backend/utils/fmgr/README in the
+ source distribution.
+
+ Before we turn to the more advanced topics, we should discuss
+ some coding rules for PostgreSQL
+ C-language functions. While it might be possible to load functions
+ written in languages other than C into
+ PostgreSQL, this is usually difficult
+ (when it is possible at all) because other languages, such as
+ C++, FORTRAN, or Pascal often do not follow the same calling
+ convention as C. That is, other languages do not pass argument
+ and return values between functions in the same way. For this
+ reason, we will assume that your C-language functions are
+ actually written in C.
+
+ The basic rules for writing and building C functions are as follows:
+
+
+ Use pg_config
+ --includedir-server
+ to find out where the PostgreSQL server header
+ files are installed on your system (or the system that your
+ users will be running on).
+
+ Compiling and linking your code so that it can be dynamically
+ loaded into PostgreSQL always
+ requires special flags. See Section 38.10.5 for a
+ detailed explanation of how to do it for your particular
+ operating system.
+
+ Remember to define a “magic block” for your shared library,
+ as described in Section 38.10.1.
+
+ When allocating memory, use the
+ PostgreSQL functions
+ palloc and pfree
+ instead of the corresponding C library functions
+ malloc and free.
+ The memory allocated by palloc will be
+ freed automatically at the end of each transaction, preventing
+ memory leaks.
+
+ Always zero the bytes of your structures using memset
+ (or allocate them with palloc0 in the first place).
+ Even if you assign to each field of your structure, there might be
+ alignment padding (holes in the structure) that contain
+ garbage values. Without this, it's difficult to
+ support hash indexes or hash joins, as you must pick out only
+ the significant bits of your data structure to compute a hash.
+ The planner also sometimes relies on comparing constants via
+ bitwise equality, so you can get undesirable planning results if
+ logically-equivalent values aren't bitwise equal.
+
+ Most of the internal PostgreSQL
+ types are declared in postgres.h, while
+ the function manager interfaces
+ (PG_FUNCTION_ARGS, etc.) are in
+ fmgr.h, so you will need to include at
+ least these two files. For portability reasons it's best to
+ include postgres.h first,
+ before any other system or user header files. Including
+ postgres.h will also include
+ elog.h and palloc.h
+ for you.
+
+ Symbol names defined within object files must not conflict
+ with each other or with symbols defined in the
+ PostgreSQL server executable. You
+ will have to rename your functions or variables if you get
+ error messages to this effect.
+
+
38.10.5. Compiling and Linking Dynamically-Loaded Functions #
+ Before you are able to use your
+ PostgreSQL extension functions written in
+ C, they must be compiled and linked in a special way to produce a
+ file that can be dynamically loaded by the server. To be precise, a
+ shared library needs to be
+ created.
+
+
+ For information beyond what is contained in this section
+ you should read the documentation of your
+ operating system, in particular the manual pages for the C compiler,
+ cc, and the link editor, ld.
+ In addition, the PostgreSQL source code
+ contains several working examples in the
+ contrib directory. If you rely on these
+ examples you will make your modules dependent on the availability
+ of the PostgreSQL source code, however.
+
+ Creating shared libraries is generally analogous to linking
+ executables: first the source files are compiled into object files,
+ then the object files are linked together. The object files need to
+ be created as position-independent code
+ (PIC), which
+ conceptually means that they can be placed at an arbitrary location
+ in memory when they are loaded by the executable. (Object files
+ intended for executables are usually not compiled that way.) The
+ command to link a shared library contains special flags to
+ distinguish it from linking an executable (at least in theory
+ — on some systems the practice is much uglier).
+
+ In the following examples we assume that your source code is in a
+ file foo.c and we will create a shared library
+ foo.so. The intermediate object file will be
+ called foo.o unless otherwise noted. A shared
+ library can contain more than one object file, but we only use one
+ here.
+
-
+ FreeBSD
+
+
+ The compiler flag to create PIC is
+ -fPIC. To create shared libraries the compiler
+ flag is -shared.
+
+gcc -fPIC -c foo.c
+gcc -shared -o foo.so foo.o
+
+ This is applicable as of version 3.0 of
+ FreeBSD.
+
-
+ Linux
+
+
+ The compiler flag to create PIC is
+ -fPIC.
+ The compiler flag to create a shared library is
+ -shared. A complete example looks like this:
+
+cc -fPIC -c foo.c
+cc -shared -o foo.so foo.o
+
+
-
+ macOS
+
+
+ Here is an example. It assumes the developer tools are installed.
+
+cc -c foo.c
+cc -bundle -flat_namespace -undefined suppress -o foo.so foo.o
+
+
-
+ NetBSD
+
+
+ The compiler flag to create PIC is
+ -fPIC. For ELF systems, the
+ compiler with the flag -shared is used to link
+ shared libraries. On the older non-ELF systems, ld
+ -Bshareable is used.
+
+gcc -fPIC -c foo.c
+gcc -shared -o foo.so foo.o
+
+
-
+ OpenBSD
+
+
+ The compiler flag to create PIC is
+ -fPIC. ld -Bshareable is
+ used to link shared libraries.
+
+gcc -fPIC -c foo.c
+ld -Bshareable -o foo.so foo.o
+
+
-
+ Solaris
+
+
+ The compiler flag to create PIC is
+ -KPIC with the Sun compiler and
+ -fPIC with GCC. To
+ link shared libraries, the compiler option is
+ -G with either compiler or alternatively
+ -shared with GCC.
+
+cc -KPIC -c foo.c
+cc -G -o foo.so foo.o
+
+ or
+
+gcc -fPIC -c foo.c
+gcc -G -o foo.so foo.o
+
+
Tip
+ If this is too complicated for you, you should consider using
+
+ GNU Libtool,
+ which hides the platform differences behind a uniform interface.
+
+ The resulting shared library file can then be loaded into
+ PostgreSQL. When specifying the file name
+ to the CREATE FUNCTION command, one must give it
+ the name of the shared library file, not the intermediate object file.
+ Note that the system's standard shared-library extension (usually
+ .so or .sl) can be omitted from
+ the CREATE FUNCTION command, and normally should
+ be omitted for best portability.
+
+ Refer back to Section 38.10.1 about where the
+ server expects to find the shared library files.
+
38.10.6. Composite-Type Arguments #
+ Composite types do not have a fixed layout like C structures.
+ Instances of a composite type can contain null fields. In
+ addition, composite types that are part of an inheritance
+ hierarchy can have different fields than other members of the
+ same inheritance hierarchy. Therefore,
+ PostgreSQL provides a function
+ interface for accessing fields of composite types from C.
+
+ Suppose we want to write a function to answer the query:
+
+
+SELECT name, c_overpaid(emp, 1500) AS overpaid
+ FROM emp
+ WHERE name = 'Bill' OR name = 'Sam';
+
+
+ Using the version-1 calling conventions, we can define
+ c_overpaid as:
+
+
+#include "postgres.h"
+#include "executor/executor.h" /* for GetAttributeByName() */
+
+PG_MODULE_MAGIC;
+
+PG_FUNCTION_INFO_V1(c_overpaid);
+
+Datum
+c_overpaid(PG_FUNCTION_ARGS)
+{
+ HeapTupleHeader t = PG_GETARG_HEAPTUPLEHEADER(0);
+ int32 limit = PG_GETARG_INT32(1);
+ bool isnull;
+ Datum salary;
+
+ salary = GetAttributeByName(t, "salary", &isnull);
+ if (isnull)
+ PG_RETURN_BOOL(false);
+ /* Alternatively, we might prefer to do PG_RETURN_NULL() for null salary. */
+
+ PG_RETURN_BOOL(DatumGetInt32(salary) > limit);
+}
+
+
+
+ GetAttributeByName is the
+ PostgreSQL system function that
+ returns attributes out of the specified row. It has
+ three arguments: the argument of type HeapTupleHeader passed
+ into
+ the function, the name of the desired attribute, and a
+ return parameter that tells whether the attribute
+ is null. GetAttributeByName returns a Datum
+ value that you can convert to the proper data type by using the
+ appropriate DatumGetXXX()
+ function. Note that the return value is meaningless if the null flag is
+ set; always check the null flag before trying to do anything with the
+ result.
+
+ There is also GetAttributeByNum, which selects
+ the target attribute by column number instead of name.
+
+ The following command declares the function
+ c_overpaid in SQL:
+
+
+CREATE FUNCTION c_overpaid(emp, integer) RETURNS boolean
+ AS 'DIRECTORY/funcs', 'c_overpaid'
+ LANGUAGE C STRICT;
+
+
+ Notice we have used STRICT so that we did not have to
+ check whether the input arguments were NULL.
+
38.10.7. Returning Rows (Composite Types) #
+ To return a row or composite-type value from a C-language
+ function, you can use a special API that provides macros and
+ functions to hide most of the complexity of building composite
+ data types. To use this API, the source file must include:
+
+#include "funcapi.h"
+
+
+ There are two ways you can build a composite data value (henceforth
+ a “tuple”): you can build it from an array of Datum values,
+ or from an array of C strings that can be passed to the input
+ conversion functions of the tuple's column data types. In either
+ case, you first need to obtain or construct a TupleDesc
+ descriptor for the tuple structure. When working with Datums, you
+ pass the TupleDesc to BlessTupleDesc,
+ and then call heap_form_tuple for each row. When working
+ with C strings, you pass the TupleDesc to
+ TupleDescGetAttInMetadata, and then call
+ BuildTupleFromCStrings for each row. In the case of a
+ function returning a set of tuples, the setup steps can all be done
+ once during the first call of the function.
+
+ Several helper functions are available for setting up the needed
+ TupleDesc. The recommended way to do this in most
+ functions returning composite values is to call:
+
+TypeFuncClass get_call_result_type(FunctionCallInfo fcinfo,
+ Oid *resultTypeId,
+ TupleDesc *resultTupleDesc)
+
+ passing the same fcinfo struct passed to the calling function
+ itself. (This of course requires that you use the version-1
+ calling conventions.) resultTypeId can be specified
+ as NULL or as the address of a local variable to receive the
+ function's result type OID. resultTupleDesc should be the
+ address of a local TupleDesc variable. Check that the
+ result is TYPEFUNC_COMPOSITE; if so,
+ resultTupleDesc has been filled with the needed
+ TupleDesc. (If it is not, you can report an error along
+ the lines of “function returning record called in context that
+ cannot accept type record”.)
+
Tip
+ get_call_result_type can resolve the actual type of a
+ polymorphic function result; so it is useful in functions that return
+ scalar polymorphic results, not only functions that return composites.
+ The resultTypeId output is primarily useful for functions
+ returning polymorphic scalars.
+
Note
+ get_call_result_type has a sibling
+ get_expr_result_type, which can be used to resolve the
+ expected output type for a function call represented by an expression
+ tree. This can be used when trying to determine the result type from
+ outside the function itself. There is also
+ get_func_result_type, which can be used when only the
+ function's OID is available. However these functions are not able
+ to deal with functions declared to return record, and
+ get_func_result_type cannot resolve polymorphic types,
+ so you should preferentially use get_call_result_type.
+
+ Older, now-deprecated functions for obtaining
+ TupleDescs are:
+
+TupleDesc RelationNameGetTupleDesc(const char *relname)
+
+ to get a TupleDesc for the row type of a named relation,
+ and:
+
+TupleDesc TypeGetTupleDesc(Oid typeoid, List *colaliases)
+
+ to get a TupleDesc based on a type OID. This can
+ be used to get a TupleDesc for a base or
+ composite type. It will not work for a function that returns
+ record, however, and it cannot resolve polymorphic
+ types.
+
+ Once you have a TupleDesc, call:
+
+TupleDesc BlessTupleDesc(TupleDesc tupdesc)
+
+ if you plan to work with Datums, or:
+
+AttInMetadata *TupleDescGetAttInMetadata(TupleDesc tupdesc)
+
+ if you plan to work with C strings. If you are writing a function
+ returning set, you can save the results of these functions in the
+ FuncCallContext structure — use the
+ tuple_desc or attinmeta field
+ respectively.
+
+ When working with Datums, use:
+
+HeapTuple heap_form_tuple(TupleDesc tupdesc, Datum *values, bool *isnull)
+
+ to build a HeapTuple given user data in Datum form.
+
+ When working with C strings, use:
+
+HeapTuple BuildTupleFromCStrings(AttInMetadata *attinmeta, char **values)
+
+ to build a HeapTuple given user data
+ in C string form. values is an array of C strings,
+ one for each attribute of the return row. Each C string should be in
+ the form expected by the input function of the attribute data
+ type. In order to return a null value for one of the attributes,
+ the corresponding pointer in the values array
+ should be set to NULL. This function will need to
+ be called again for each row you return.
+
+ Once you have built a tuple to return from your function, it
+ must be converted into a Datum. Use:
+
+HeapTupleGetDatum(HeapTuple tuple)
+
+ to convert a HeapTuple into a valid Datum. This
+ Datum can be returned directly if you intend to return
+ just a single row, or it can be used as the current return value
+ in a set-returning function.
+
+ An example appears in the next section.
+
38.10.8. Returning Sets #
+ C-language functions have two options for returning sets (multiple
+ rows). In one method, called ValuePerCall
+ mode, a set-returning function is called repeatedly (passing the same
+ arguments each time) and it returns one new row on each call, until
+ it has no more rows to return and signals that by returning NULL.
+ The set-returning function (SRF) must therefore
+ save enough state across calls to remember what it was doing and
+ return the correct next item on each call.
+ In the other method, called Materialize mode,
+ an SRF fills and returns a tuplestore object containing its
+ entire result; then only one call occurs for the whole result, and
+ no inter-call state is needed.
+
+ When using ValuePerCall mode, it is important to remember that the
+ query is not guaranteed to be run to completion; that is, due to
+ options such as LIMIT, the executor might stop
+ making calls to the set-returning function before all rows have been
+ fetched. This means it is not safe to perform cleanup activities in
+ the last call, because that might not ever happen. It's recommended
+ to use Materialize mode for functions that need access to external
+ resources, such as file descriptors.
+
+ The remainder of this section documents a set of helper macros that
+ are commonly used (though not required to be used) for SRFs using
+ ValuePerCall mode. Additional details about Materialize mode can be
+ found in src/backend/utils/fmgr/README. Also,
+ the contrib modules in
+ the PostgreSQL source distribution contain
+ many examples of SRFs using both ValuePerCall and Materialize mode.
+
+ To use the ValuePerCall support macros described here,
+ include funcapi.h. These macros work with a
+ structure FuncCallContext that contains the
+ state that needs to be saved across calls. Within the calling
+ SRF, fcinfo->flinfo->fn_extra is used to
+ hold a pointer to FuncCallContext across
+ calls. The macros automatically fill that field on first use,
+ and expect to find the same pointer there on subsequent uses.
+
+typedef struct FuncCallContext
+{
+ /*
+ * Number of times we've been called before
+ *
+ * call_cntr is initialized to 0 for you by SRF_FIRSTCALL_INIT(), and
+ * incremented for you every time SRF_RETURN_NEXT() is called.
+ */
+ uint64 call_cntr;
+
+ /*
+ * OPTIONAL maximum number of calls
+ *
+ * max_calls is here for convenience only and setting it is optional.
+ * If not set, you must provide alternative means to know when the
+ * function is done.
+ */
+ uint64 max_calls;
+
+ /*
+ * OPTIONAL pointer to miscellaneous user-provided context information
+ *
+ * user_fctx is for use as a pointer to your own data to retain
+ * arbitrary context information between calls of your function.
+ */
+ void *user_fctx;
+
+ /*
+ * OPTIONAL pointer to struct containing attribute type input metadata
+ *
+ * attinmeta is for use when returning tuples (i.e., composite data types)
+ * and is not used when returning base data types. It is only needed
+ * if you intend to use BuildTupleFromCStrings() to create the return
+ * tuple.
+ */
+ AttInMetadata *attinmeta;
+
+ /*
+ * memory context used for structures that must live for multiple calls
+ *
+ * multi_call_memory_ctx is set by SRF_FIRSTCALL_INIT() for you, and used
+ * by SRF_RETURN_DONE() for cleanup. It is the most appropriate memory
+ * context for any memory that is to be reused across multiple calls
+ * of the SRF.
+ */
+ MemoryContext multi_call_memory_ctx;
+
+ /*
+ * OPTIONAL pointer to struct containing tuple description
+ *
+ * tuple_desc is for use when returning tuples (i.e., composite data types)
+ * and is only needed if you are going to build the tuples with
+ * heap_form_tuple() rather than with BuildTupleFromCStrings(). Note that
+ * the TupleDesc pointer stored here should usually have been run through
+ * BlessTupleDesc() first.
+ */
+ TupleDesc tuple_desc;
+
+} FuncCallContext;
+
+
+ The macros to be used by an SRF using this
+ infrastructure are:
+
+SRF_IS_FIRSTCALL()
+
+ Use this to determine if your function is being called for the first or a
+ subsequent time. On the first call (only), call:
+
+SRF_FIRSTCALL_INIT()
+
+ to initialize the FuncCallContext. On every function call,
+ including the first, call:
+
+SRF_PERCALL_SETUP()
+
+ to set up for using the FuncCallContext.
+
+ If your function has data to return in the current call, use:
+
+SRF_RETURN_NEXT(funcctx, result)
+
+ to return it to the caller. (result must be of type
+ Datum, either a single value or a tuple prepared as
+ described above.) Finally, when your function is finished
+ returning data, use:
+
+SRF_RETURN_DONE(funcctx)
+
+ to clean up and end the SRF.
+
+ The memory context that is current when the SRF is called is
+ a transient context that will be cleared between calls. This means
+ that you do not need to call pfree on everything
+ you allocated using palloc; it will go away anyway. However, if you want to allocate
+ any data structures to live across calls, you need to put them somewhere
+ else. The memory context referenced by
+ multi_call_memory_ctx is a suitable location for any
+ data that needs to survive until the SRF is finished running. In most
+ cases, this means that you should switch into
+ multi_call_memory_ctx while doing the
+ first-call setup.
+ Use funcctx->user_fctx to hold a pointer to
+ any such cross-call data structures.
+ (Data you allocate
+ in multi_call_memory_ctx will go away
+ automatically when the query ends, so it is not necessary to free
+ that data manually, either.)
+
Warning
+ While the actual arguments to the function remain unchanged between
+ calls, if you detoast the argument values (which is normally done
+ transparently by the
+ PG_GETARG_xxx macro)
+ in the transient context then the detoasted copies will be freed on
+ each cycle. Accordingly, if you keep references to such values in
+ your user_fctx, you must either copy them into the
+ multi_call_memory_ctx after detoasting, or ensure
+ that you detoast the values only in that context.
+
+ A complete pseudo-code example looks like the following:
+
+Datum
+my_set_returning_function(PG_FUNCTION_ARGS)
+{
+ FuncCallContext *funcctx;
+ Datum result;
+ further declarations as needed
+
+ if (SRF_IS_FIRSTCALL())
+ {
+ MemoryContext oldcontext;
+
+ funcctx = SRF_FIRSTCALL_INIT();
+ oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
+ /* One-time setup code appears here: */
+ user code
+ if returning composite
+ build TupleDesc, and perhaps AttInMetadata
+ endif returning composite
+ user code
+ MemoryContextSwitchTo(oldcontext);
+ }
+
+ /* Each-time setup code appears here: */
+ user code
+ funcctx = SRF_PERCALL_SETUP();
+ user code
+
+ /* this is just one way we might test whether we are done: */
+ if (funcctx->call_cntr < funcctx->max_calls)
+ {
+ /* Here we want to return another item: */
+ user code
+ obtain result Datum
+ SRF_RETURN_NEXT(funcctx, result);
+ }
+ else
+ {
+ /* Here we are done returning items, so just report that fact. */
+ /* (Resist the temptation to put cleanup code here.) */
+ SRF_RETURN_DONE(funcctx);
+ }
+}
+
+
+ A complete example of a simple SRF returning a composite type
+ looks like:
+
+PG_FUNCTION_INFO_V1(retcomposite);
+
+Datum
+retcomposite(PG_FUNCTION_ARGS)
+{
+ FuncCallContext *funcctx;
+ int call_cntr;
+ int max_calls;
+ TupleDesc tupdesc;
+ AttInMetadata *attinmeta;
+
+ /* stuff done only on the first call of the function */
+ if (SRF_IS_FIRSTCALL())
+ {
+ MemoryContext oldcontext;
+
+ /* create a function context for cross-call persistence */
+ funcctx = SRF_FIRSTCALL_INIT();
+
+ /* switch to memory context appropriate for multiple function calls */
+ oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
+
+ /* total number of tuples to be returned */
+ funcctx->max_calls = PG_GETARG_INT32(0);
+
+ /* Build a tuple descriptor for our result type */
+ if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
+ ereport(ERROR,
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("function returning record called in context "
+ "that cannot accept type record")));
+
+ /*
+ * generate attribute metadata needed later to produce tuples from raw
+ * C strings
+ */
+ attinmeta = TupleDescGetAttInMetadata(tupdesc);
+ funcctx->attinmeta = attinmeta;
+
+ MemoryContextSwitchTo(oldcontext);
+ }
+
+ /* stuff done on every call of the function */
+ funcctx = SRF_PERCALL_SETUP();
+
+ call_cntr = funcctx->call_cntr;
+ max_calls = funcctx->max_calls;
+ attinmeta = funcctx->attinmeta;
+
+ if (call_cntr < max_calls) /* do when there is more left to send */
+ {
+ char **values;
+ HeapTuple tuple;
+ Datum result;
+
+ /*
+ * Prepare a values array for building the returned tuple.
+ * This should be an array of C strings which will
+ * be processed later by the type input functions.
+ */
+ values = (char **) palloc(3 * sizeof(char *));
+ values[0] = (char *) palloc(16 * sizeof(char));
+ values[1] = (char *) palloc(16 * sizeof(char));
+ values[2] = (char *) palloc(16 * sizeof(char));
+
+ snprintf(values[0], 16, "%d", 1 * PG_GETARG_INT32(1));
+ snprintf(values[1], 16, "%d", 2 * PG_GETARG_INT32(1));
+ snprintf(values[2], 16, "%d", 3 * PG_GETARG_INT32(1));
+
+ /* build a tuple */
+ tuple = BuildTupleFromCStrings(attinmeta, values);
+
+ /* make the tuple into a datum */
+ result = HeapTupleGetDatum(tuple);
+
+ /* clean up (this is not really necessary) */
+ pfree(values[0]);
+ pfree(values[1]);
+ pfree(values[2]);
+ pfree(values);
+
+ SRF_RETURN_NEXT(funcctx, result);
+ }
+ else /* do when there is no more left */
+ {
+ SRF_RETURN_DONE(funcctx);
+ }
+}
+
+
+
+ One way to declare this function in SQL is:
+
+CREATE TYPE __retcomposite AS (f1 integer, f2 integer, f3 integer);
+
+CREATE OR REPLACE FUNCTION retcomposite(integer, integer)
+ RETURNS SETOF __retcomposite
+ AS 'filename', 'retcomposite'
+ LANGUAGE C IMMUTABLE STRICT;
+
+ A different way is to use OUT parameters:
+
+CREATE OR REPLACE FUNCTION retcomposite(IN integer, IN integer,
+ OUT f1 integer, OUT f2 integer, OUT f3 integer)
+ RETURNS SETOF record
+ AS 'filename', 'retcomposite'
+ LANGUAGE C IMMUTABLE STRICT;
+
+ Notice that in this method the output type of the function is formally
+ an anonymous record type.
+
38.10.9. Polymorphic Arguments and Return Types #
+ C-language functions can be declared to accept and
+ return the polymorphic types described in Section 38.2.5.
+ When a function's arguments or return types
+ are defined as polymorphic types, the function author cannot know
+ in advance what data type it will be called with, or
+ need to return. There are two routines provided in fmgr.h
+ to allow a version-1 C function to discover the actual data types
+ of its arguments and the type it is expected to return. The routines are
+ called get_fn_expr_rettype(FmgrInfo *flinfo) and
+ get_fn_expr_argtype(FmgrInfo *flinfo, int argnum).
+ They return the result or argument type OID, or InvalidOid if the
+ information is not available.
+ The structure flinfo is normally accessed as
+ fcinfo->flinfo. The parameter argnum
+ is zero based. get_call_result_type can also be used
+ as an alternative to get_fn_expr_rettype.
+ There is also get_fn_expr_variadic, which can be used to
+ find out whether variadic arguments have been merged into an array.
+ This is primarily useful for VARIADIC "any" functions,
+ since such merging will always have occurred for variadic functions
+ taking ordinary array types.
+
+ For example, suppose we want to write a function to accept a single
+ element of any type, and return a one-dimensional array of that type:
+
+
+PG_FUNCTION_INFO_V1(make_array);
+Datum
+make_array(PG_FUNCTION_ARGS)
+{
+ ArrayType *result;
+ Oid element_type = get_fn_expr_argtype(fcinfo->flinfo, 0);
+ Datum element;
+ bool isnull;
+ int16 typlen;
+ bool typbyval;
+ char typalign;
+ int ndims;
+ int dims[MAXDIM];
+ int lbs[MAXDIM];
+
+ if (!OidIsValid(element_type))
+ elog(ERROR, "could not determine data type of input");
+
+ /* get the provided element, being careful in case it's NULL */
+ isnull = PG_ARGISNULL(0);
+ if (isnull)
+ element = (Datum) 0;
+ else
+ element = PG_GETARG_DATUM(0);
+
+ /* we have one dimension */
+ ndims = 1;
+ /* and one element */
+ dims[0] = 1;
+ /* and lower bound is 1 */
+ lbs[0] = 1;
+
+ /* get required info about the element type */
+ get_typlenbyvalalign(element_type, &typlen, &typbyval, &typalign);
+
+ /* now build the array */
+ result = construct_md_array(&element, &isnull, ndims, dims, lbs,
+ element_type, typlen, typbyval, typalign);
+
+ PG_RETURN_ARRAYTYPE_P(result);
+}
+
+
+ The following command declares the function
+ make_array in SQL:
+
+
+CREATE FUNCTION make_array(anyelement) RETURNS anyarray
+ AS 'DIRECTORY/funcs', 'make_array'
+ LANGUAGE C IMMUTABLE;
+
+
+ There is a variant of polymorphism that is only available to C-language
+ functions: they can be declared to take parameters of type
+ "any". (Note that this type name must be double-quoted,
+ since it's also an SQL reserved word.) This works like
+ anyelement except that it does not constrain different
+ "any" arguments to be the same type, nor do they help
+ determine the function's result type. A C-language function can also
+ declare its final parameter to be VARIADIC "any". This will
+ match one or more actual arguments of any type (not necessarily the same
+ type). These arguments will not be gathered into an array
+ as happens with normal variadic functions; they will just be passed to
+ the function separately. The PG_NARGS() macro and the
+ methods described above must be used to determine the number of actual
+ arguments and their types when using this feature. Also, users of such
+ a function might wish to use the VARIADIC keyword in their
+ function call, with the expectation that the function would treat the
+ array elements as separate arguments. The function itself must implement
+ that behavior if wanted, after using get_fn_expr_variadic to
+ detect that the actual argument was marked with VARIADIC.
+
38.10.10. Shared Memory and LWLocks #
+ Add-ins can reserve LWLocks and an allocation of shared memory on server
+ startup. The add-in's shared library must be preloaded by specifying
+ it in
+ shared_preload_libraries.
+ The shared library should register a shmem_request_hook
+ in its _PG_init function. This
+ shmem_request_hook can reserve LWLocks or shared memory.
+ Shared memory is reserved by calling:
+
+void RequestAddinShmemSpace(int size)
+
+ from your shmem_request_hook.
+
+ LWLocks are reserved by calling:
+
+void RequestNamedLWLockTranche(const char *tranche_name, int num_lwlocks)
+
+ from your shmem_request_hook. This will ensure that an array of
+ num_lwlocks LWLocks is available under the name
+ tranche_name. Use GetNamedLWLockTranche
+ to get a pointer to this array.
+
+ An example of a shmem_request_hook can be found in
+ contrib/pg_stat_statements/pg_stat_statements.c in the
+ PostgreSQL source tree.
+
+ To avoid possible race-conditions, each backend should use the LWLock
+ AddinShmemInitLock when connecting to and initializing
+ its allocation of shared memory, as shown here:
+
+static mystruct *ptr = NULL;
+
+if (!ptr)
+{
+ bool found;
+
+ LWLockAcquire(AddinShmemInitLock, LW_EXCLUSIVE);
+ ptr = ShmemInitStruct("my struct name", size, &found);
+ if (!found)
+ {
+ initialize contents of shmem area;
+ acquire any requested LWLocks using:
+ ptr->locks = GetNamedLWLockTranche("my tranche name");
+ }
+ LWLockRelease(AddinShmemInitLock);
+}
+
+
38.10.11. Using C++ for Extensibility #
+ Although the PostgreSQL backend is written in
+ C, it is possible to write extensions in C++ if these guidelines are
+ followed:
+
+
+ All functions accessed by the backend must present a C interface
+ to the backend; these C functions can then call C++ functions.
+ For example, extern C linkage is required for
+ backend-accessed functions. This is also necessary for any
+ functions that are passed as pointers between the backend and
+ C++ code.
+
+ Free memory using the appropriate deallocation method. For example,
+ most backend memory is allocated using palloc(), so use
+ pfree() to free it. Using C++
+ delete in such cases will fail.
+
+ Prevent exceptions from propagating into the C code (use a catch-all
+ block at the top level of all extern C functions). This
+ is necessary even if the C++ code does not explicitly throw any
+ exceptions, because events like out-of-memory can still throw
+ exceptions. Any exceptions must be caught and appropriate errors
+ passed back to the C interface. If possible, compile C++ with
+ -fno-exceptions to eliminate exceptions entirely; in such
+ cases, you must check for failures in your C++ code, e.g., check for
+ NULL returned by new().
+
+ If calling backend functions from C++ code, be sure that the
+ C++ call stack contains only plain old data structures
+ (POD). This is necessary because backend errors
+ generate a distant longjmp() that does not properly
+ unroll a C++ call stack with non-POD objects.
+
+
+ In summary, it is best to place C++ code behind a wall of
+ extern C functions that interface to the backend,
+ and avoid exception, memory, and call stack leakage.
+
38.9. Internal Functions #
+ Internal functions are functions written in C that have been statically
+ linked into the PostgreSQL server.
+ The “body” of the function definition
+ specifies the C-language name of the function, which need not be the
+ same as the name being declared for SQL use.
+ (For reasons of backward compatibility, an empty body
+ is accepted as meaning that the C-language function name is the
+ same as the SQL name.)
+
+ Normally, all internal functions present in the
+ server are declared during the initialization of the database cluster
+ (see Section 19.2),
+ but a user could use CREATE FUNCTION
+ to create additional alias names for an internal function.
+ Internal functions are declared in CREATE FUNCTION
+ with language name internal. For instance, to
+ create an alias for the sqrt function:
+
+CREATE FUNCTION square_root(double precision) RETURNS double precision
+ AS 'dsqrt'
+ LANGUAGE internal
+ STRICT;
+
+ (Most internal functions expect to be declared “strict”.)
+
Note
+ Not all “predefined” functions are
+ “internal” in the above sense. Some predefined
+ functions are written in SQL.
+
38.11. Function Optimization Information #
+ By default, a function is just a “black box” that the
+ database system knows very little about the behavior of. However,
+ that means that queries using the function may be executed much less
+ efficiently than they could be. It is possible to supply additional
+ knowledge that helps the planner optimize function calls.
+
+ Some basic facts can be supplied by declarative annotations provided in
+ the CREATE FUNCTION command. Most important of
+ these is the function's volatility
+ category (IMMUTABLE, STABLE,
+ or VOLATILE); one should always be careful to
+ specify this correctly when defining a function.
+ The parallel safety property (PARALLEL
+ UNSAFE, PARALLEL RESTRICTED, or
+ PARALLEL SAFE) must also be specified if you hope
+ to use the function in parallelized queries.
+ It can also be useful to specify the function's estimated execution
+ cost, and/or the number of rows a set-returning function is estimated
+ to return. However, the declarative way of specifying those two
+ facts only allows specifying a constant value, which is often
+ inadequate.
+
+ It is also possible to attach a planner support
+ function to an SQL-callable function (called
+ its target function), and thereby provide
+ knowledge about the target function that is too complex to be
+ represented declaratively. Planner support functions have to be
+ written in C (although their target functions might not be), so this is
+ an advanced feature that relatively few people will use.
+
+ A planner support function must have the SQL signature
+
+supportfn(internal) returns internal
+
+ It is attached to its target function by specifying
+ the SUPPORT clause when creating the target function.
+
+ The details of the API for planner support functions can be found in
+ file src/include/nodes/supportnodes.h in the
+ PostgreSQL source code. Here we provide
+ just an overview of what planner support functions can do.
+ The set of possible requests to a support function is extensible,
+ so more things might be possible in future versions.
+
+ Some function calls can be simplified during planning based on
+ properties specific to the function. For example,
+ int4mul(n, 1) could be simplified to
+ just n. This type of transformation can be
+ performed by a planner support function, by having it implement
+ the SupportRequestSimplify request type.
+ The support function will be called for each instance of its target
+ function found in a query parse tree. If it finds that the particular
+ call can be simplified into some other form, it can build and return a
+ parse tree representing that expression. This will automatically work
+ for operators based on the function, too — in the example just
+ given, n * 1 would also be simplified to
+ n.
+ (But note that this is just an example; this particular
+ optimization is not actually performed by
+ standard PostgreSQL.)
+ We make no guarantee that PostgreSQL will
+ never call the target function in cases that the support function could
+ simplify. Ensure rigorous equivalence between the simplified
+ expression and an actual execution of the target function.
+
+ For target functions that return boolean, it is often useful to estimate
+ the fraction of rows that will be selected by a WHERE clause using that
+ function. This can be done by a support function that implements
+ the SupportRequestSelectivity request type.
+
+ If the target function's run time is highly dependent on its inputs,
+ it may be useful to provide a non-constant cost estimate for it.
+ This can be done by a support function that implements
+ the SupportRequestCost request type.
+
+ For target functions that return sets, it is often useful to provide
+ a non-constant estimate for the number of rows that will be returned.
+ This can be done by a support function that implements
+ the SupportRequestRows request type.
+
+ For target functions that return boolean, it may be possible to
+ convert a function call appearing in WHERE into an indexable operator
+ clause or clauses. The converted clauses might be exactly equivalent
+ to the function's condition, or they could be somewhat weaker (that is,
+ they might accept some values that the function condition does not).
+ In the latter case the index condition is said to
+ be lossy; it can still be used to scan an index,
+ but the function call will have to be executed for each row returned by
+ the index to see if it really passes the WHERE condition or not.
+ To create such conditions, the support function must implement
+ the SupportRequestIndexCondition request type.
+
38.6. Function Overloading #
+ More than one function can be defined with the same SQL name, so long
+ as the arguments they take are different. In other words,
+ function names can be overloaded. Whether or not
+ you use it, this capability entails security precautions when calling
+ functions in databases where some users mistrust other users; see
+ Section 10.3. When a query is executed, the server
+ will determine which function to call from the data types and the number
+ of the provided arguments. Overloading can also be used to simulate
+ functions with a variable number of arguments, up to a finite maximum
+ number.
+
+ When creating a family of overloaded functions, one should be
+ careful not to create ambiguities. For instance, given the
+ functions:
+
+CREATE FUNCTION test(int, real) RETURNS ...
+CREATE FUNCTION test(smallint, double precision) RETURNS ...
+
+ it is not immediately clear which function would be called with
+ some trivial input like test(1, 1.5). The
+ currently implemented resolution rules are described in
+ Chapter 10, but it is unwise to design a system that subtly
+ relies on this behavior.
+
+ A function that takes a single argument of a composite type should
+ generally not have the same name as any attribute (field) of that type.
+ Recall that attribute(table)table.attributeschema.func(table)
+
+ Another possible conflict is between variadic and non-variadic functions.
+ For instance, it is possible to create both foo(numeric) and
+ foo(VARIADIC numeric[]). In this case it is unclear which one
+ should be matched to a call providing a single numeric argument, such as
+ foo(10.1). The rule is that the function appearing
+ earlier in the search path is used, or if the two functions are in the
+ same schema, the non-variadic one is preferred.
+
+ When overloading C-language functions, there is an additional
+ constraint: The C name of each function in the family of
+ overloaded functions must be different from the C names of all
+ other functions, either internal or dynamically loaded. If this
+ rule is violated, the behavior is not portable. You might get a
+ run-time linker error, or one of the functions will get called
+ (usually the internal one). The alternative form of the
+ AS clause for the SQL CREATE
+ FUNCTION command decouples the SQL function name from
+ the function name in the C source code. For instance:
+
+CREATE FUNCTION test(int) RETURNS int
+ AS 'filename', 'test_1arg'
+ LANGUAGE C;
+CREATE FUNCTION test(int, int) RETURNS int
+ AS 'filename', 'test_2arg'
+ LANGUAGE C;
+
+ The names of the C functions here reflect one of many possible conventions.
+
38.8. Procedural Language Functions #
+ PostgreSQL allows user-defined functions
+ to be written in other languages besides SQL and C. These other
+ languages are generically called procedural
+ languages (PLs).
+ Procedural languages aren't built into the
+ PostgreSQL server; they are offered
+ by loadable modules.
+ See Chapter 42 and following chapters for more
+ information.
+
38.5. Query Language (SQL) Functions #
+ SQL functions execute an arbitrary list of SQL statements, returning
+ the result of the last query in the list.
+ In the simple (non-set)
+ case, the first row of the last query's result will be returned.
+ (Bear in mind that “the first row” of a multirow
+ result is not well-defined unless you use ORDER BY.)
+ If the last query happens
+ to return no rows at all, the null value will be returned.
+
+ Alternatively, an SQL function can be declared to return a set (that is,
+ multiple rows) by specifying the function's return type as SETOF
+ sometype, or equivalently by declaring it as
+ RETURNS TABLE(columns). In this case
+ all rows of the last query's result are returned. Further details appear
+ below.
+
+ The body of an SQL function must be a list of SQL
+ statements separated by semicolons. A semicolon after the last
+ statement is optional. Unless the function is declared to return
+ void, the last statement must be a SELECT,
+ or an INSERT, UPDATE, or DELETE
+ that has a RETURNING clause.
+
+ Any collection of commands in the SQL
+ language can be packaged together and defined as a function.
+ Besides SELECT queries, the commands can include data
+ modification queries (INSERT,
+ UPDATE, DELETE, and
+ MERGE), as well as
+ other SQL commands. (You cannot use transaction control commands, e.g.,
+ COMMIT, SAVEPOINT, and some utility
+ commands, e.g., VACUUM, in SQL functions.)
+ However, the final command
+ must be a SELECT or have a RETURNING
+ clause that returns whatever is
+ specified as the function's return type. Alternatively, if you
+ want to define an SQL function that performs actions but has no
+ useful value to return, you can define it as returning void.
+ For example, this function removes rows with negative salaries from
+ the emp table:
+
+
+CREATE FUNCTION clean_emp() RETURNS void AS '
+ DELETE FROM emp
+ WHERE salary < 0;
+' LANGUAGE SQL;
+
+SELECT clean_emp();
+
+ clean_emp
+-----------
+
+(1 row)
+
+
+ You can also write this as a procedure, thus avoiding the issue of the
+ return type. For example:
+
+CREATE PROCEDURE clean_emp() AS '
+ DELETE FROM emp
+ WHERE salary < 0;
+' LANGUAGE SQL;
+
+CALL clean_emp();
+
+ In simple cases like this, the difference between a function returning
+ void and a procedure is mostly stylistic. However,
+ procedures offer additional functionality such as transaction control
+ that is not available in functions. Also, procedures are SQL standard
+ whereas returning void is a PostgreSQL extension.
+
Note
+ The entire body of an SQL function is parsed before any of it is
+ executed. While an SQL function can contain commands that alter
+ the system catalogs (e.g., CREATE TABLE), the effects
+ of such commands will not be visible during parse analysis of
+ later commands in the function. Thus, for example,
+ CREATE TABLE foo (...); INSERT INTO foo VALUES(...);
+ will not work as desired if packaged up into a single SQL function,
+ since foo won't exist yet when the INSERT
+ command is parsed. It's recommended to use PL/pgSQL
+ instead of an SQL function in this type of situation.
+
+ The syntax of the CREATE FUNCTION command requires
+ the function body to be written as a string constant. It is usually
+ most convenient to use dollar quoting (see Section 4.1.2.4) for the string constant.
+ If you choose to use regular single-quoted string constant syntax,
+ you must double single quote marks (') and backslashes
+ (\) (assuming escape string syntax) in the body of
+ the function (see Section 4.1.2.1).
+
38.5.1. Arguments for SQL Functions #
+ Arguments of an SQL function can be referenced in the function
+ body using either names or numbers. Examples of both methods appear
+ below.
+
+ To use a name, declare the function argument as having a name, and
+ then just write that name in the function body. If the argument name
+ is the same as any column name in the current SQL command within the
+ function, the column name will take precedence. To override this,
+ qualify the argument name with the name of the function itself, that is
+ function_name.argument_name
+ In the older numeric approach, arguments are referenced using the syntax
+ $n: $1 refers to the first input
+ argument, $2 to the second, and so on. This will work
+ whether or not the particular argument was declared with a name.
+
+ If an argument is of a composite type, then the dot notation,
+ e.g., argname.fieldname$1.fieldname, can be used to access attributes of the
+ argument. Again, you might need to qualify the argument's name with the
+ function name to make the form with an argument name unambiguous.
+
+ SQL function arguments can only be used as data values,
+ not as identifiers. Thus for example this is reasonable:
+
+INSERT INTO mytable VALUES ($1);
+
+but this will not work:
+
+INSERT INTO $1 VALUES (42);
+
+
Note
+ The ability to use names to reference SQL function arguments was added
+ in PostgreSQL 9.2. Functions to be used in
+ older servers must use the $n notation.
+
38.5.2. SQL Functions on Base Types #
+ The simplest possible SQL function has no arguments and
+ simply returns a base type, such as integer:
+
+
+CREATE FUNCTION one() RETURNS integer AS $$
+ SELECT 1 AS result;
+$$ LANGUAGE SQL;
+
+-- Alternative syntax for string literal:
+CREATE FUNCTION one() RETURNS integer AS '
+ SELECT 1 AS result;
+' LANGUAGE SQL;
+
+SELECT one();
+
+ one
+-----
+ 1
+
+
+ Notice that we defined a column alias within the function body for the result of the function
+ (with the name result), but this column alias is not visible
+ outside the function. Hence, the result is labeled one
+ instead of result.
+
+ It is almost as easy to define SQL functions
+ that take base types as arguments:
+
+
+CREATE FUNCTION add_em(x integer, y integer) RETURNS integer AS $$
+ SELECT x + y;
+$$ LANGUAGE SQL;
+
+SELECT add_em(1, 2) AS answer;
+
+ answer
+--------
+ 3
+
+
+ Alternatively, we could dispense with names for the arguments and
+ use numbers:
+
+
+CREATE FUNCTION add_em(integer, integer) RETURNS integer AS $$
+ SELECT $1 + $2;
+$$ LANGUAGE SQL;
+
+SELECT add_em(1, 2) AS answer;
+
+ answer
+--------
+ 3
+
+
+ Here is a more useful function, which might be used to debit a
+ bank account:
+
+
+CREATE FUNCTION tf1 (accountno integer, debit numeric) RETURNS numeric AS $$
+ UPDATE bank
+ SET balance = balance - debit
+ WHERE accountno = tf1.accountno;
+ SELECT 1;
+$$ LANGUAGE SQL;
+
+
+ A user could execute this function to debit account 17 by $100.00 as
+ follows:
+
+
+SELECT tf1(17, 100.0);
+
+
+ In this example, we chose the name accountno for the first
+ argument, but this is the same as the name of a column in the
+ bank table. Within the UPDATE command,
+ accountno refers to the column bank.accountno,
+ so tf1.accountno must be used to refer to the argument.
+ We could of course avoid this by using a different name for the argument.
+
+ In practice one would probably like a more useful result from the
+ function than a constant 1, so a more likely definition
+ is:
+
+
+CREATE FUNCTION tf1 (accountno integer, debit numeric) RETURNS numeric AS $$
+ UPDATE bank
+ SET balance = balance - debit
+ WHERE accountno = tf1.accountno;
+ SELECT balance FROM bank WHERE accountno = tf1.accountno;
+$$ LANGUAGE SQL;
+
+
+ which adjusts the balance and returns the new balance.
+ The same thing could be done in one command using RETURNING:
+
+
+CREATE FUNCTION tf1 (accountno integer, debit numeric) RETURNS numeric AS $$
+ UPDATE bank
+ SET balance = balance - debit
+ WHERE accountno = tf1.accountno
+ RETURNING balance;
+$$ LANGUAGE SQL;
+
+
+ If the final SELECT or RETURNING
+ clause in an SQL function does not return exactly
+ the function's declared result
+ type, PostgreSQL will automatically cast
+ the value to the required type, if that is possible with an implicit
+ or assignment cast. Otherwise, you must write an explicit cast.
+ For example, suppose we wanted the
+ previous add_em function to return
+ type float8 instead. It's sufficient to write
+
+
+CREATE FUNCTION add_em(integer, integer) RETURNS float8 AS $$
+ SELECT $1 + $2;
+$$ LANGUAGE SQL;
+
+
+ since the integer sum can be implicitly cast
+ to float8.
+ (See Chapter 10 or CREATE CAST
+ for more about casts.)
+
38.5.3. SQL Functions on Composite Types #
+ When writing functions with arguments of composite types, we must not
+ only specify which argument we want but also the desired attribute
+ (field) of that argument. For example, suppose that
+ emp is a table containing employee data, and therefore
+ also the name of the composite type of each row of the table. Here
+ is a function double_salary that computes what someone's
+ salary would be if it were doubled:
+
+
+CREATE TABLE emp (
+ name text,
+ salary numeric,
+ age integer,
+ cubicle point
+);
+
+INSERT INTO emp VALUES ('Bill', 4200, 45, '(2,1)');
+
+CREATE FUNCTION double_salary(emp) RETURNS numeric AS $$
+ SELECT $1.salary * 2 AS salary;
+$$ LANGUAGE SQL;
+
+SELECT name, double_salary(emp.*) AS dream
+ FROM emp
+ WHERE emp.cubicle ~= point '(2,1)';
+
+ name | dream
+------+-------
+ Bill | 8400
+
+
+ Notice the use of the syntax $1.salary
+ to select one field of the argument row value. Also notice
+ how the calling SELECT command
+ uses table_name.* to select
+ the entire current row of a table as a composite value. The table
+ row can alternatively be referenced using just the table name,
+ like this:
+
+SELECT name, double_salary(emp) AS dream
+ FROM emp
+ WHERE emp.cubicle ~= point '(2,1)';
+
+ but this usage is deprecated since it's easy to get confused.
+ (See Section 8.16.5 for details about these
+ two notations for the composite value of a table row.)
+
+ Sometimes it is handy to construct a composite argument value
+ on-the-fly. This can be done with the ROW construct.
+ For example, we could adjust the data being passed to the function:
+
+SELECT name, double_salary(ROW(name, salary*1.1, age, cubicle)) AS dream
+ FROM emp;
+
+
+ It is also possible to build a function that returns a composite type.
+ This is an example of a function
+ that returns a single emp row:
+
+
+CREATE FUNCTION new_emp() RETURNS emp AS $$
+ SELECT text 'None' AS name,
+ 1000.0 AS salary,
+ 25 AS age,
+ point '(2,2)' AS cubicle;
+$$ LANGUAGE SQL;
+
+
+ In this example we have specified each of the attributes
+ with a constant value, but any computation
+ could have been substituted for these constants.
+
+ Note two important things about defining the function:
+
+
+ The select list order in the query must be exactly the same as
+ that in which the columns appear in the composite type.
+ (Naming the columns, as we did above,
+ is irrelevant to the system.)
+
+ We must ensure each expression's type can be cast to that of
+ the corresponding column of the composite type.
+ Otherwise we'll get errors like this:
+
+
+ERROR: return type mismatch in function declared to return emp
+DETAIL: Final statement returns text instead of point at column 4.
+
+
+ As with the base-type case, the system will not insert explicit
+ casts automatically, only implicit or assignment casts.
+
+
+ A different way to define the same function is:
+
+
+CREATE FUNCTION new_emp() RETURNS emp AS $$
+ SELECT ROW('None', 1000.0, 25, '(2,2)')::emp;
+$$ LANGUAGE SQL;
+
+
+ Here we wrote a SELECT that returns just a single
+ column of the correct composite type. This isn't really better
+ in this situation, but it is a handy alternative in some cases
+ — for example, if we need to compute the result by calling
+ another function that returns the desired composite value.
+ Another example is that if we are trying to write a function that
+ returns a domain over composite, rather than a plain composite type,
+ it is always necessary to write it as returning a single column,
+ since there is no way to cause a coercion of the whole row result.
+
+ We could call this function directly either by using it in
+ a value expression:
+
+
+SELECT new_emp();
+
+ new_emp
+--------------------------
+ (None,1000.0,25,"(2,2)")
+
+
+ or by calling it as a table function:
+
+
+SELECT * FROM new_emp();
+
+ name | salary | age | cubicle
+------+--------+-----+---------
+ None | 1000.0 | 25 | (2,2)
+
+
+ The second way is described more fully in Section 38.5.8.
+
+ When you use a function that returns a composite type,
+ you might want only one field (attribute) from its result.
+ You can do that with syntax like this:
+
+
+SELECT (new_emp()).name;
+
+ name
+------
+ None
+
+
+ The extra parentheses are needed to keep the parser from getting
+ confused. If you try to do it without them, you get something like this:
+
+
+SELECT new_emp().name;
+ERROR: syntax error at or near "."
+LINE 1: SELECT new_emp().name;
+ ^
+
+
+ Another option is to use functional notation for extracting an attribute:
+
+
+SELECT name(new_emp());
+
+ name
+------
+ None
+
+
+ As explained in Section 8.16.5, the field notation and
+ functional notation are equivalent.
+
+ Another way to use a function returning a composite type is to pass the
+ result to another function that accepts the correct row type as input:
+
+
+CREATE FUNCTION getname(emp) RETURNS text AS $$
+ SELECT $1.name;
+$$ LANGUAGE SQL;
+
+SELECT getname(new_emp());
+ getname
+---------
+ None
+(1 row)
+
+
38.5.4. SQL Functions with Output Parameters #
+ An alternative way of describing a function's results is to define it
+ with output parameters, as in this example:
+
+
+CREATE FUNCTION add_em (IN x int, IN y int, OUT sum int)
+AS 'SELECT x + y'
+LANGUAGE SQL;
+
+SELECT add_em(3,7);
+ add_em
+--------
+ 10
+(1 row)
+
+
+ This is not essentially different from the version of add_em
+ shown in Section 38.5.2. The real value of
+ output parameters is that they provide a convenient way of defining
+ functions that return several columns. For example,
+
+
+CREATE FUNCTION sum_n_product (x int, y int, OUT sum int, OUT product int)
+AS 'SELECT x + y, x * y'
+LANGUAGE SQL;
+
+ SELECT * FROM sum_n_product(11,42);
+ sum | product
+-----+---------
+ 53 | 462
+(1 row)
+
+
+ What has essentially happened here is that we have created an anonymous
+ composite type for the result of the function. The above example has
+ the same end result as
+
+
+CREATE TYPE sum_prod AS (sum int, product int);
+
+CREATE FUNCTION sum_n_product (int, int) RETURNS sum_prod
+AS 'SELECT $1 + $2, $1 * $2'
+LANGUAGE SQL;
+
+
+ but not having to bother with the separate composite type definition
+ is often handy. Notice that the names attached to the output parameters
+ are not just decoration, but determine the column names of the anonymous
+ composite type. (If you omit a name for an output parameter, the
+ system will choose a name on its own.)
+
+ Notice that output parameters are not included in the calling argument
+ list when invoking such a function from SQL. This is because
+ PostgreSQL considers only the input
+ parameters to define the function's calling signature. That means
+ also that only the input parameters matter when referencing the function
+ for purposes such as dropping it. We could drop the above function
+ with either of
+
+
+DROP FUNCTION sum_n_product (x int, y int, OUT sum int, OUT product int);
+DROP FUNCTION sum_n_product (int, int);
+
+
+ Parameters can be marked as IN (the default),
+ OUT, INOUT, or VARIADIC.
+ An INOUT
+ parameter serves as both an input parameter (part of the calling
+ argument list) and an output parameter (part of the result record type).
+ VARIADIC parameters are input parameters, but are treated
+ specially as described below.
+
38.5.5. SQL Procedures with Output Parameters #
+ Output parameters are also supported in procedures, but they work a bit
+ differently from functions. In CALL commands,
+ output parameters must be included in the argument list.
+ For example, the bank account debiting routine from earlier could be
+ written like this:
+
+CREATE PROCEDURE tp1 (accountno integer, debit numeric, OUT new_balance numeric) AS $$
+ UPDATE bank
+ SET balance = balance - debit
+ WHERE accountno = tp1.accountno
+ RETURNING balance;
+$$ LANGUAGE SQL;
+
+ To call this procedure, an argument matching the OUT
+ parameter must be included. It's customary to write
+ NULL:
+
+CALL tp1(17, 100.0, NULL);
+
+ If you write something else, it must be an expression that is implicitly
+ coercible to the declared type of the parameter, just as for input
+ parameters. Note however that such an expression will not be evaluated.
+
+ When calling a procedure from PL/pgSQL,
+ instead of writing NULL you must write a variable
+ that will receive the procedure's output. See Section 43.6.3 for details.
+
38.5.6. SQL Functions with Variable Numbers of Arguments #
+ SQL functions can be declared to accept
+ variable numbers of arguments, so long as all the “optional”
+ arguments are of the same data type. The optional arguments will be
+ passed to the function as an array. The function is declared by
+ marking the last parameter as VARIADIC; this parameter
+ must be declared as being of an array type. For example:
+
+
+CREATE FUNCTION mleast(VARIADIC arr numeric[]) RETURNS numeric AS $$
+ SELECT min($1[i]) FROM generate_subscripts($1, 1) g(i);
+$$ LANGUAGE SQL;
+
+SELECT mleast(10, -1, 5, 4.4);
+ mleast
+--------
+ -1
+(1 row)
+
+
+ Effectively, all the actual arguments at or beyond the
+ VARIADIC position are gathered up into a one-dimensional
+ array, as if you had written
+
+
+SELECT mleast(ARRAY[10, -1, 5, 4.4]); -- doesn't work
+
+
+ You can't actually write that, though — or at least, it will
+ not match this function definition. A parameter marked
+ VARIADIC matches one or more occurrences of its element
+ type, not of its own type.
+
+ Sometimes it is useful to be able to pass an already-constructed array
+ to a variadic function; this is particularly handy when one variadic
+ function wants to pass on its array parameter to another one. Also,
+ this is the only secure way to call a variadic function found in a schema
+ that permits untrusted users to create objects; see
+ Section 10.3. You can do this by
+ specifying VARIADIC in the call:
+
+
+SELECT mleast(VARIADIC ARRAY[10, -1, 5, 4.4]);
+
+
+ This prevents expansion of the function's variadic parameter into its
+ element type, thereby allowing the array argument value to match
+ normally. VARIADIC can only be attached to the last
+ actual argument of a function call.
+
+ Specifying VARIADIC in the call is also the only way to
+ pass an empty array to a variadic function, for example:
+
+
+SELECT mleast(VARIADIC ARRAY[]::numeric[]);
+
+
+ Simply writing SELECT mleast() does not work because a
+ variadic parameter must match at least one actual argument.
+ (You could define a second function also named mleast,
+ with no parameters, if you wanted to allow such calls.)
+
+ The array element parameters generated from a variadic parameter are
+ treated as not having any names of their own. This means it is not
+ possible to call a variadic function using named arguments (Section 4.3), except when you specify
+ VARIADIC. For example, this will work:
+
+
+SELECT mleast(VARIADIC arr => ARRAY[10, -1, 5, 4.4]);
+
+
+ but not these:
+
+
+SELECT mleast(arr => 10);
+SELECT mleast(arr => ARRAY[10, -1, 5, 4.4]);
+
+
38.5.7. SQL Functions with Default Values for Arguments #
+ Functions can be declared with default values for some or all input
+ arguments. The default values are inserted whenever the function is
+ called with insufficiently many actual arguments. Since arguments
+ can only be omitted from the end of the actual argument list, all
+ parameters after a parameter with a default value have to have
+ default values as well. (Although the use of named argument notation
+ could allow this restriction to be relaxed, it's still enforced so that
+ positional argument notation works sensibly.) Whether or not you use it,
+ this capability creates a need for precautions when calling functions in
+ databases where some users mistrust other users; see
+ Section 10.3.
+
+ For example:
+
+CREATE FUNCTION foo(a int, b int DEFAULT 2, c int DEFAULT 3)
+RETURNS int
+LANGUAGE SQL
+AS $$
+ SELECT $1 + $2 + $3;
+$$;
+
+SELECT foo(10, 20, 30);
+ foo
+-----
+ 60
+(1 row)
+
+SELECT foo(10, 20);
+ foo
+-----
+ 33
+(1 row)
+
+SELECT foo(10);
+ foo
+-----
+ 15
+(1 row)
+
+SELECT foo(); -- fails since there is no default for the first argument
+ERROR: function foo() does not exist
+
+ The = sign can also be used in place of the
+ key word DEFAULT.
+
38.5.8. SQL Functions as Table Sources #
+ All SQL functions can be used in the FROM clause of a query,
+ but it is particularly useful for functions returning composite types.
+ If the function is defined to return a base type, the table function
+ produces a one-column table. If the function is defined to return
+ a composite type, the table function produces a column for each attribute
+ of the composite type.
+
+ Here is an example:
+
+
+CREATE TABLE foo (fooid int, foosubid int, fooname text);
+INSERT INTO foo VALUES (1, 1, 'Joe');
+INSERT INTO foo VALUES (1, 2, 'Ed');
+INSERT INTO foo VALUES (2, 1, 'Mary');
+
+CREATE FUNCTION getfoo(int) RETURNS foo AS $$
+ SELECT * FROM foo WHERE fooid = $1;
+$$ LANGUAGE SQL;
+
+SELECT *, upper(fooname) FROM getfoo(1) AS t1;
+
+ fooid | foosubid | fooname | upper
+-------+----------+---------+-------
+ 1 | 1 | Joe | JOE
+(1 row)
+
+
+ As the example shows, we can work with the columns of the function's
+ result just the same as if they were columns of a regular table.
+
+ Note that we only got one row out of the function. This is because
+ we did not use SETOF. That is described in the next section.
+
38.5.9. SQL Functions Returning Sets #
+ When an SQL function is declared as returning SETOF
+ sometype, the function's final
+ query is executed to completion, and each row it
+ outputs is returned as an element of the result set.
+
+ This feature is normally used when calling the function in the FROM
+ clause. In this case each row returned by the function becomes
+ a row of the table seen by the query. For example, assume that
+ table foo has the same contents as above, and we say:
+
+
+CREATE FUNCTION getfoo(int) RETURNS SETOF foo AS $$
+ SELECT * FROM foo WHERE fooid = $1;
+$$ LANGUAGE SQL;
+
+SELECT * FROM getfoo(1) AS t1;
+
+
+ Then we would get:
+
+ fooid | foosubid | fooname
+-------+----------+---------
+ 1 | 1 | Joe
+ 1 | 2 | Ed
+(2 rows)
+
+
+ It is also possible to return multiple rows with the columns defined by
+ output parameters, like this:
+
+
+CREATE TABLE tab (y int, z int);
+INSERT INTO tab VALUES (1, 2), (3, 4), (5, 6), (7, 8);
+
+CREATE FUNCTION sum_n_product_with_tab (x int, OUT sum int, OUT product int)
+RETURNS SETOF record
+AS $$
+ SELECT $1 + tab.y, $1 * tab.y FROM tab;
+$$ LANGUAGE SQL;
+
+SELECT * FROM sum_n_product_with_tab(10);
+ sum | product
+-----+---------
+ 11 | 10
+ 13 | 30
+ 15 | 50
+ 17 | 70
+(4 rows)
+
+
+ The key point here is that you must write RETURNS SETOF record
+ to indicate that the function returns multiple rows instead of just one.
+ If there is only one output parameter, write that parameter's type
+ instead of record.
+
+ It is frequently useful to construct a query's result by invoking a
+ set-returning function multiple times, with the parameters for each
+ invocation coming from successive rows of a table or subquery. The
+ preferred way to do this is to use the LATERAL key word,
+ which is described in Section 7.2.1.5.
+ Here is an example using a set-returning function to enumerate
+ elements of a tree structure:
+
+
+SELECT * FROM nodes;
+ name | parent
+-----------+--------
+ Top |
+ Child1 | Top
+ Child2 | Top
+ Child3 | Top
+ SubChild1 | Child1
+ SubChild2 | Child1
+(6 rows)
+
+CREATE FUNCTION listchildren(text) RETURNS SETOF text AS $$
+ SELECT name FROM nodes WHERE parent = $1
+$$ LANGUAGE SQL STABLE;
+
+SELECT * FROM listchildren('Top');
+ listchildren
+--------------
+ Child1
+ Child2
+ Child3
+(3 rows)
+
+SELECT name, child FROM nodes, LATERAL listchildren(name) AS child;
+ name | child
+--------+-----------
+ Top | Child1
+ Top | Child2
+ Top | Child3
+ Child1 | SubChild1
+ Child1 | SubChild2
+(5 rows)
+
+
+ This example does not do anything that we couldn't have done with a
+ simple join, but in more complex calculations the option to put
+ some of the work into a function can be quite convenient.
+
+ Functions returning sets can also be called in the select list
+ of a query. For each row that the query
+ generates by itself, the set-returning function is invoked, and an output
+ row is generated for each element of the function's result set.
+ The previous example could also be done with queries like
+ these:
+
+
+SELECT listchildren('Top');
+ listchildren
+--------------
+ Child1
+ Child2
+ Child3
+(3 rows)
+
+SELECT name, listchildren(name) FROM nodes;
+ name | listchildren
+--------+--------------
+ Top | Child1
+ Top | Child2
+ Top | Child3
+ Child1 | SubChild1
+ Child1 | SubChild2
+(5 rows)
+
+
+ In the last SELECT,
+ notice that no output row appears for Child2, Child3, etc.
+ This happens because listchildren returns an empty set
+ for those arguments, so no result rows are generated. This is the same
+ behavior as we got from an inner join to the function result when using
+ the LATERAL syntax.
+
+ PostgreSQL's behavior for a set-returning function in a
+ query's select list is almost exactly the same as if the set-returning
+ function had been written in a LATERAL FROM-clause item
+ instead. For example,
+
+SELECT x, generate_series(1,5) AS g FROM tab;
+
+ is almost equivalent to
+
+SELECT x, g FROM tab, LATERAL generate_series(1,5) AS g;
+
+ It would be exactly the same, except that in this specific example,
+ the planner could choose to put g on the outside of the
+ nested-loop join, since g has no actual lateral dependency
+ on tab. That would result in a different output row
+ order. Set-returning functions in the select list are always evaluated
+ as though they are on the inside of a nested-loop join with the rest of
+ the FROM clause, so that the function(s) are run to
+ completion before the next row from the FROM clause is
+ considered.
+
+ If there is more than one set-returning function in the query's select
+ list, the behavior is similar to what you get from putting the functions
+ into a single LATERAL ROWS FROM( ... ) FROM-clause
+ item. For each row from the underlying query, there is an output row
+ using the first result from each function, then an output row using the
+ second result, and so on. If some of the set-returning functions
+ produce fewer outputs than others, null values are substituted for the
+ missing data, so that the total number of rows emitted for one
+ underlying row is the same as for the set-returning function that
+ produced the most outputs. Thus the set-returning functions
+ run “in lockstep” until they are all exhausted, and then
+ execution continues with the next underlying row.
+
+ Set-returning functions can be nested in a select list, although that is
+ not allowed in FROM-clause items. In such cases, each level
+ of nesting is treated separately, as though it were
+ a separate LATERAL ROWS FROM( ... ) item. For example, in
+
+SELECT srf1(srf2(x), srf3(y)), srf4(srf5(z)) FROM tab;
+
+ the set-returning functions srf2, srf3,
+ and srf5 would be run in lockstep for each row
+ of tab, and then srf1 and srf4
+ would be applied in lockstep to each row produced by the lower
+ functions.
+
+ Set-returning functions cannot be used within conditional-evaluation
+ constructs, such as CASE or COALESCE. For
+ example, consider
+
+SELECT x, CASE WHEN x > 0 THEN generate_series(1, 5) ELSE 0 END FROM tab;
+
+ It might seem that this should produce five repetitions of input rows
+ that have x > 0, and a single repetition of those that do
+ not; but actually, because generate_series(1, 5) would be
+ run in an implicit LATERAL FROM item before
+ the CASE expression is ever evaluated, it would produce five
+ repetitions of every input row. To reduce confusion, such cases produce
+ a parse-time error instead.
+
Note
+ If a function's last command is INSERT, UPDATE,
+ or DELETE with RETURNING, that command will
+ always be executed to completion, even if the function is not declared
+ with SETOF or the calling query does not fetch all the
+ result rows. Any extra rows produced by the RETURNING
+ clause are silently dropped, but the commanded table modifications
+ still happen (and are all completed before returning from the function).
+
Note
+ Before PostgreSQL 10, putting more than one
+ set-returning function in the same select list did not behave very
+ sensibly unless they always produced equal numbers of rows. Otherwise,
+ what you got was a number of output rows equal to the least common
+ multiple of the numbers of rows produced by the set-returning
+ functions. Also, nested set-returning functions did not work as
+ described above; instead, a set-returning function could have at most
+ one set-returning argument, and each nest of set-returning functions
+ was run independently. Also, conditional execution (set-returning
+ functions inside CASE etc.) was previously allowed,
+ complicating things even more.
+ Use of the LATERAL syntax is recommended when writing
+ queries that need to work in older PostgreSQL versions,
+ because that will give consistent results across different versions.
+ If you have a query that is relying on conditional execution of a
+ set-returning function, you may be able to fix it by moving the
+ conditional test into a custom set-returning function. For example,
+
+SELECT x, CASE WHEN y > 0 THEN generate_series(1, z) ELSE 5 END FROM tab;
+
+ could become
+
+CREATE FUNCTION case_generate_series(cond bool, start int, fin int, els int)
+ RETURNS SETOF int AS $$
+BEGIN
+ IF cond THEN
+ RETURN QUERY SELECT generate_series(start, fin);
+ ELSE
+ RETURN QUERY SELECT els;
+ END IF;
+END$$ LANGUAGE plpgsql;
+
+SELECT x, case_generate_series(y > 0, 1, z, 5) FROM tab;
+
+ This formulation will work the same in all versions
+ of PostgreSQL.
+
38.5.10. SQL Functions Returning TABLE #
+ There is another way to declare a function as returning a set,
+ which is to use the syntax
+ RETURNS TABLE(columns).
+ This is equivalent to using one or more OUT parameters plus
+ marking the function as returning SETOF record (or
+ SETOF a single output parameter's type, as appropriate).
+ This notation is specified in recent versions of the SQL standard, and
+ thus may be more portable than using SETOF.
+
+ For example, the preceding sum-and-product example could also be
+ done this way:
+
+
+CREATE FUNCTION sum_n_product_with_tab (x int)
+RETURNS TABLE(sum int, product int) AS $$
+ SELECT $1 + tab.y, $1 * tab.y FROM tab;
+$$ LANGUAGE SQL;
+
+
+ It is not allowed to use explicit OUT or INOUT
+ parameters with the RETURNS TABLE notation — you must
+ put all the output columns in the TABLE list.
+
38.5.11. Polymorphic SQL Functions #
+ SQL functions can be declared to accept and
+ return the polymorphic types described in Section 38.2.5. Here is a polymorphic
+ function make_array that builds up an array
+ from two arbitrary data type elements:
+
+CREATE FUNCTION make_array(anyelement, anyelement) RETURNS anyarray AS $$
+ SELECT ARRAY[$1, $2];
+$$ LANGUAGE SQL;
+
+SELECT make_array(1, 2) AS intarray, make_array('a'::text, 'b') AS textarray;
+ intarray | textarray
+----------+-----------
+ {1,2} | {a,b}
+(1 row)
+
+
+ Notice the use of the typecast 'a'::text
+ to specify that the argument is of type text. This is
+ required if the argument is just a string literal, since otherwise
+ it would be treated as type
+ unknown, and array of unknown is not a valid
+ type.
+ Without the typecast, you will get errors like this:
+
+ERROR: could not determine polymorphic type because input has type unknown
+
+
+ With make_array declared as above, you must
+ provide two arguments that are of exactly the same data type; the
+ system will not attempt to resolve any type differences. Thus for
+ example this does not work:
+
+SELECT make_array(1, 2.5) AS numericarray;
+ERROR: function make_array(integer, numeric) does not exist
+
+ An alternative approach is to use the “common” family of
+ polymorphic types, which allows the system to try to identify a
+ suitable common type:
+
+CREATE FUNCTION make_array2(anycompatible, anycompatible)
+RETURNS anycompatiblearray AS $$
+ SELECT ARRAY[$1, $2];
+$$ LANGUAGE SQL;
+
+SELECT make_array2(1, 2.5) AS numericarray;
+ numericarray
+--------------
+ {1,2.5}
+(1 row)
+
+ Because the rules for common type resolution default to choosing
+ type text when all inputs are of unknown types, this
+ also works:
+
+SELECT make_array2('a', 'b') AS textarray;
+ textarray
+-----------
+ {a,b}
+(1 row)
+
+
+ It is permitted to have polymorphic arguments with a fixed
+ return type, but the converse is not. For example:
+
+CREATE FUNCTION is_greater(anyelement, anyelement) RETURNS boolean AS $$
+ SELECT $1 > $2;
+$$ LANGUAGE SQL;
+
+SELECT is_greater(1, 2);
+ is_greater
+------------
+ f
+(1 row)
+
+CREATE FUNCTION invalid_func() RETURNS anyelement AS $$
+ SELECT 1;
+$$ LANGUAGE SQL;
+ERROR: cannot determine result data type
+DETAIL: A result of type anyelement requires at least one input of type anyelement, anyarray, anynonarray, anyenum, or anyrange.
+
+
+ Polymorphism can be used with functions that have output arguments.
+ For example:
+
+CREATE FUNCTION dup (f1 anyelement, OUT f2 anyelement, OUT f3 anyarray)
+AS 'select $1, array[$1,$1]' LANGUAGE SQL;
+
+SELECT * FROM dup(22);
+ f2 | f3
+----+---------
+ 22 | {22,22}
+(1 row)
+
+
+ Polymorphism can also be used with variadic functions.
+ For example:
+
+CREATE FUNCTION anyleast (VARIADIC anyarray) RETURNS anyelement AS $$
+ SELECT min($1[i]) FROM generate_subscripts($1, 1) g(i);
+$$ LANGUAGE SQL;
+
+SELECT anyleast(10, -1, 5, 4);
+ anyleast
+----------
+ -1
+(1 row)
+
+SELECT anyleast('abc'::text, 'def');
+ anyleast
+----------
+ abc
+(1 row)
+
+CREATE FUNCTION concat_values(text, VARIADIC anyarray) RETURNS text AS $$
+ SELECT array_to_string($2, $1);
+$$ LANGUAGE SQL;
+
+SELECT concat_values('|', 1, 4, 2);
+ concat_values
+---------------
+ 1|4|2
+(1 row)
+
+
38.5.12. SQL Functions with Collations #
+ When an SQL function has one or more parameters of collatable data types,
+ a collation is identified for each function call depending on the
+ collations assigned to the actual arguments, as described in Section 24.2. If a collation is successfully identified
+ (i.e., there are no conflicts of implicit collations among the arguments)
+ then all the collatable parameters are treated as having that collation
+ implicitly. This will affect the behavior of collation-sensitive
+ operations within the function. For example, using the
+ anyleast function described above, the result of
+
+SELECT anyleast('abc'::text, 'ABC');
+
+ will depend on the database's default collation. In C locale
+ the result will be ABC, but in many other locales it will
+ be abc. The collation to use can be forced by adding
+ a COLLATE clause to any of the arguments, for example
+
+SELECT anyleast('abc'::text, 'ABC' COLLATE "C");
+
+ Alternatively, if you wish a function to operate with a particular
+ collation regardless of what it is called with, insert
+ COLLATE clauses as needed in the function definition.
+ This version of anyleast would always use en_US
+ locale to compare strings:
+
+CREATE FUNCTION anyleast (VARIADIC anyarray) RETURNS anyelement AS $$
+ SELECT min($1[i] COLLATE "en_US") FROM generate_subscripts($1, 1) g(i);
+$$ LANGUAGE SQL;
+
+ But note that this will throw an error if applied to a non-collatable
+ data type.
+
+ If no common collation can be identified among the actual arguments,
+ then an SQL function treats its parameters as having their data types'
+ default collation (which is usually the database's default collation,
+ but could be different for parameters of domain types).
+
+ The behavior of collatable parameters can be thought of as a limited
+ form of polymorphism, applicable only to textual data types.
+
38.7. Function Volatility Categories #
+ Every function has a volatility classification, with
+ the possibilities being VOLATILE, STABLE, or
+ IMMUTABLE. VOLATILE is the default if the
+ CREATE FUNCTION
+ command does not specify a category. The volatility category is a
+ promise to the optimizer about the behavior of the function:
+
+
+ A VOLATILE function can do anything, including modifying
+ the database. It can return different results on successive calls with
+ the same arguments. The optimizer makes no assumptions about the
+ behavior of such functions. A query using a volatile function will
+ re-evaluate the function at every row where its value is needed.
+
+ A STABLE function cannot modify the database and is
+ guaranteed to return the same results given the same arguments
+ for all rows within a single statement. This category allows the
+ optimizer to optimize multiple calls of the function to a single
+ call. In particular, it is safe to use an expression containing
+ such a function in an index scan condition. (Since an index scan
+ will evaluate the comparison value only once, not once at each
+ row, it is not valid to use a VOLATILE function in an
+ index scan condition.)
+
+ An IMMUTABLE function cannot modify the database and is
+ guaranteed to return the same results given the same arguments forever.
+ This category allows the optimizer to pre-evaluate the function when
+ a query calls it with constant arguments. For example, a query like
+ SELECT ... WHERE x = 2 + 2 can be simplified on sight to
+ SELECT ... WHERE x = 4, because the function underlying
+ the integer addition operator is marked IMMUTABLE.
+
+
+ For best optimization results, you should label your functions with the
+ strictest volatility category that is valid for them.
+
+ Any function with side-effects must be labeled
+ VOLATILE, so that calls to it cannot be optimized away.
+ Even a function with no side-effects needs to be labeled
+ VOLATILE if its value can change within a single query;
+ some examples are random(), currval(),
+ timeofday().
+
+ Another important example is that the current_timestamp
+ family of functions qualify as STABLE, since their values do
+ not change within a transaction.
+
+ There is relatively little difference between STABLE and
+ IMMUTABLE categories when considering simple interactive
+ queries that are planned and immediately executed: it doesn't matter
+ a lot whether a function is executed once during planning or once during
+ query execution startup. But there is a big difference if the plan is
+ saved and reused later. Labeling a function IMMUTABLE when
+ it really isn't might allow it to be prematurely folded to a constant during
+ planning, resulting in a stale value being re-used during subsequent uses
+ of the plan. This is a hazard when using prepared statements or when
+ using function languages that cache plans (such as
+ PL/pgSQL).
+
+ For functions written in SQL or in any of the standard procedural
+ languages, there is a second important property determined by the
+ volatility category, namely the visibility of any data changes that have
+ been made by the SQL command that is calling the function. A
+ VOLATILE function will see such changes, a STABLE
+ or IMMUTABLE function will not. This behavior is implemented
+ using the snapshotting behavior of MVCC (see Chapter 13):
+ STABLE and IMMUTABLE functions use a snapshot
+ established as of the start of the calling query, whereas
+ VOLATILE functions obtain a fresh snapshot at the start of
+ each query they execute.
+
Note
+ Functions written in C can manage snapshots however they want, but it's
+ usually a good idea to make C functions work this way too.
+
+ Because of this snapshotting behavior,
+ a function containing only SELECT commands can safely be
+ marked STABLE, even if it selects from tables that might be
+ undergoing modifications by concurrent queries.
+ PostgreSQL will execute all commands of a
+ STABLE function using the snapshot established for the
+ calling query, and so it will see a fixed view of the database throughout
+ that query.
+
+ The same snapshotting behavior is used for SELECT commands
+ within IMMUTABLE functions. It is generally unwise to select
+ from database tables within an IMMUTABLE function at all,
+ since the immutability will be broken if the table contents ever change.
+ However, PostgreSQL does not enforce that you
+ do not do that.
+
+ A common error is to label a function IMMUTABLE when its
+ results depend on a configuration parameter. For example, a function
+ that manipulates timestamps might well have results that depend on the
+ TimeZone setting. For safety, such functions should
+ be labeled STABLE instead.
+
Note
+ PostgreSQL requires that STABLE
+ and IMMUTABLE functions contain no SQL commands other
+ than SELECT to prevent data modification.
+ (This is not a completely bulletproof test, since such functions could
+ still call VOLATILE functions that modify the database.
+ If you do that, you will find that the STABLE or
+ IMMUTABLE function does not notice the database changes
+ applied by the called function, since they are hidden from its snapshot.)
+
38.3. User-Defined Functions #
+ PostgreSQL provides four kinds of
+ functions:
+
+
+ query language functions (functions written in
+ SQL) (Section 38.5)
+
+ procedural language functions (functions written in, for
+ example, PL/pgSQL or PL/Tcl)
+ (Section 38.8)
+
+ internal functions (Section 38.9)
+
+ C-language functions (Section 38.10)
+
+
+ Every kind
+ of function can take base types, composite types, or
+ combinations of these as arguments (parameters). In addition,
+ every kind of function can return a base type or
+ a composite type. Functions can also be defined to return
+ sets of base or composite values.
+
+ Many kinds of functions can take or return certain pseudo-types
+ (such as polymorphic types), but the available facilities vary.
+ Consult the description of each kind of function for more details.
+
+ It's easiest to define SQL
+ functions, so we'll start by discussing those.
+ Most of the concepts presented for SQL functions
+ will carry over to the other types of functions.
+
+ Throughout this chapter, it can be useful to look at the reference
+ page of the CREATE
+ FUNCTION command to
+ understand the examples better. Some examples from this chapter
+ can be found in funcs.sql and
+ funcs.c in the src/tutorial
+ directory in the PostgreSQL source
+ distribution.
+
38.16. Interfacing Extensions to Indexes #
+ The procedures described thus far let you define new types, new
+ functions, and new operators. However, we cannot yet define an
+ index on a column of a new data type. To do this, we must define an
+ operator class for the new data type. Later in this
+ section, we will illustrate this concept in an example: a new
+ operator class for the B-tree index method that stores and sorts
+ complex numbers in ascending absolute value order.
+
+ Operator classes can be grouped into operator families
+ to show the relationships between semantically compatible classes.
+ When only a single data type is involved, an operator class is sufficient,
+ so we'll focus on that case first and then return to operator families.
+
38.16.1. Index Methods and Operator Classes #
+ The pg_am table contains one row for every
+ index method (internally known as access method). Support for
+ regular access to tables is built into
+ PostgreSQL, but all index methods are
+ described in pg_am. It is possible to add a
+ new index access method by writing the necessary code and
+ then creating an entry in pg_am — but that is
+ beyond the scope of this chapter (see Chapter 64).
+
+ The routines for an index method do not directly know anything
+ about the data types that the index method will operate on.
+ Instead, an operator
+ class
+ identifies the set of operations that the index method needs to use
+ to work with a particular data type. Operator classes are so
+ called because one thing they specify is the set of
+ WHERE-clause operators that can be used with an index
+ (i.e., can be converted into an index-scan qualification). An
+ operator class can also specify some support
+ function that are needed by the internal operations of the
+ index method, but do not directly correspond to any
+ WHERE-clause operator that can be used with the index.
+
+ It is possible to define multiple operator classes for the same
+ data type and index method. By doing this, multiple
+ sets of indexing semantics can be defined for a single data type.
+ For example, a B-tree index requires a sort ordering to be defined
+ for each data type it works on.
+ It might be useful for a complex-number data type
+ to have one B-tree operator class that sorts the data by complex
+ absolute value, another that sorts by real part, and so on.
+ Typically, one of the operator classes will be deemed most commonly
+ useful and will be marked as the default operator class for that
+ data type and index method.
+
+ The same operator class name
+ can be used for several different index methods (for example, both B-tree
+ and hash index methods have operator classes named
+ int4_ops), but each such class is an independent
+ entity and must be defined separately.
+
38.16.2. Index Method Strategies #
+ The operators associated with an operator class are identified by
+ “strategy numbers”, which serve to identify the semantics of
+ each operator within the context of its operator class.
+ For example, B-trees impose a strict ordering on keys, lesser to greater,
+ and so operators like “less than” and “greater than or equal
+ to” are interesting with respect to a B-tree.
+ Because
+ PostgreSQL allows the user to define operators,
+ PostgreSQL cannot look at the name of an operator
+ (e.g., < or >=) and tell what kind of
+ comparison it is. Instead, the index method defines a set of
+ “strategies”, which can be thought of as generalized operators.
+ Each operator class specifies which actual operator corresponds to each
+ strategy for a particular data type and interpretation of the index
+ semantics.
+
+ The B-tree index method defines five strategies, shown in Table 38.3.
+
Table 38.3. B-Tree Strategies
| Operation | Strategy Number |
|---|
| less than | 1 |
| less than or equal | 2 |
| equal | 3 |
| greater than or equal | 4 |
| greater than | 5 |
+ Hash indexes support only equality comparisons, and so they use only one
+ strategy, shown in Table 38.4.
+
Table 38.4. Hash Strategies
| Operation | Strategy Number |
|---|
| equal | 1 |
+ GiST indexes are more flexible: they do not have a fixed set of
+ strategies at all. Instead, the “consistency” support routine
+ of each particular GiST operator class interprets the strategy numbers
+ however it likes. As an example, several of the built-in GiST index
+ operator classes index two-dimensional geometric objects, providing
+ the “R-tree” strategies shown in
+ Table 38.5. Four of these are true
+ two-dimensional tests (overlaps, same, contains, contained by);
+ four of them consider only the X direction; and the other four
+ provide the same tests in the Y direction.
+
Table 38.5. GiST Two-Dimensional “R-tree” Strategies
| Operation | Strategy Number |
|---|
| strictly left of | 1 |
| does not extend to right of | 2 |
| overlaps | 3 |
| does not extend to left of | 4 |
| strictly right of | 5 |
| same | 6 |
| contains | 7 |
| contained by | 8 |
| does not extend above | 9 |
| strictly below | 10 |
| strictly above | 11 |
| does not extend below | 12 |
+ SP-GiST indexes are similar to GiST indexes in flexibility: they don't have
+ a fixed set of strategies. Instead the support routines of each operator
+ class interpret the strategy numbers according to the operator class's
+ definition. As an example, the strategy numbers used by the built-in
+ operator classes for points are shown in Table 38.6.
+
Table 38.6. SP-GiST Point Strategies
| Operation | Strategy Number |
|---|
| strictly left of | 1 |
| strictly right of | 5 |
| same | 6 |
| contained by | 8 |
| strictly below | 10 |
| strictly above | 11 |
+ GIN indexes are similar to GiST and SP-GiST indexes, in that they don't
+ have a fixed set of strategies either. Instead the support routines of
+ each operator class interpret the strategy numbers according to the
+ operator class's definition. As an example, the strategy numbers used by
+ the built-in operator class for arrays are shown in
+ Table 38.7.
+
Table 38.7. GIN Array Strategies
| Operation | Strategy Number |
|---|
| overlap | 1 |
| contains | 2 |
| is contained by | 3 |
| equal | 4 |
+ BRIN indexes are similar to GiST, SP-GiST and GIN indexes in that they
+ don't have a fixed set of strategies either. Instead the support routines
+ of each operator class interpret the strategy numbers according to the
+ operator class's definition. As an example, the strategy numbers used by
+ the built-in Minmax operator classes are shown in
+ Table 38.8.
+
Table 38.8. BRIN Minmax Strategies
| Operation | Strategy Number |
|---|
| less than | 1 |
| less than or equal | 2 |
| equal | 3 |
| greater than or equal | 4 |
| greater than | 5 |
+ Notice that all the operators listed above return Boolean values. In
+ practice, all operators defined as index method search operators must
+ return type boolean, since they must appear at the top
+ level of a WHERE clause to be used with an index.
+ (Some index access methods also support ordering operators,
+ which typically don't return Boolean values; that feature is discussed
+ in Section 38.16.7.)
+
38.16.3. Index Method Support Routines #
+ Strategies aren't usually enough information for the system to figure
+ out how to use an index. In practice, the index methods require
+ additional support routines in order to work. For example, the B-tree
+ index method must be able to compare two keys and determine whether one
+ is greater than, equal to, or less than the other. Similarly, the
+ hash index method must be able to compute hash codes for key values.
+ These operations do not correspond to operators used in qualifications in
+ SQL commands; they are administrative routines used by
+ the index methods, internally.
+
+ Just as with strategies, the operator class identifies which specific
+ functions should play each of these roles for a given data type and
+ semantic interpretation. The index method defines the set
+ of functions it needs, and the operator class identifies the correct
+ functions to use by assigning them to the “support function numbers”
+ specified by the index method.
+
+ Additionally, some opclasses allow users to specify parameters which
+ control their behavior. Each builtin index access method has an optional
+ options support function, which defines a set of
+ opclass-specific parameters.
+
+ B-trees require a comparison support function,
+ and allow four additional support functions to be
+ supplied at the operator class author's option, as shown in Table 38.9.
+ The requirements for these support functions are explained further in
+ Section 67.3.
+
Table 38.9. B-Tree Support Functions
| Function | Support Number |
|---|
|
+ Compare two keys and return an integer less than zero, zero, or
+ greater than zero, indicating whether the first key is less than,
+ equal to, or greater than the second
+ | 1 |
|
+ Return the addresses of C-callable sort support function(s)
+ (optional)
+ | 2 |
|
+ Compare a test value to a base value plus/minus an offset, and return
+ true or false according to the comparison result (optional)
+ | 3 |
|
+ Determine if it is safe for indexes that use the operator
+ class to apply the btree deduplication optimization (optional)
+ | 4 |
|
+ Define options that are specific to this operator class
+ (optional)
+ | 5 |
+ Hash indexes require one support function, and allow two additional ones to
+ be supplied at the operator class author's option, as shown in Table 38.10.
+
Table 38.10. Hash Support Functions
| Function | Support Number |
|---|
| Compute the 32-bit hash value for a key | 1 |
|
+ Compute the 64-bit hash value for a key given a 64-bit salt; if
+ the salt is 0, the low 32 bits of the result must match the value
+ that would have been computed by function 1
+ (optional)
+ | 2 |
|
+ Define options that are specific to this operator class
+ (optional)
+ | 3 |
+ GiST indexes have eleven support functions, six of which are optional,
+ as shown in Table 38.11.
+ (For more information see Chapter 68.)
+
Table 38.11. GiST Support Functions
| Function | Description | Support Number |
|---|
consistent | determine whether key satisfies the
+ query qualifier | 1 |
union | compute union of a set of keys | 2 |
compress | compute a compressed representation of a key or value
+ to be indexed (optional) | 3 |
decompress | compute a decompressed representation of a
+ compressed key (optional) | 4 |
penalty | compute penalty for inserting new key into subtree
+ with given subtree's key | 5 |
picksplit | determine which entries of a page are to be moved
+ to the new page and compute the union keys for resulting pages | 6 |
same | compare two keys and return true if they are equal | 7 |
distance | determine distance from key to query value (optional) | 8 |
fetch | compute original representation of a compressed key for
+ index-only scans (optional) | 9 |
options | define options that are specific to this operator class
+ (optional) | 10 |
sortsupport | provide a sort comparator to be used in fast index builds
+ (optional) | 11 |
+ SP-GiST indexes have six support functions, one of which is optional, as
+ shown in Table 38.12.
+ (For more information see Chapter 69.)
+
Table 38.12. SP-GiST Support Functions
| Function | Description | Support Number |
|---|
config | provide basic information about the operator class | 1 |
choose | determine how to insert a new value into an inner tuple | 2 |
picksplit | determine how to partition a set of values | 3 |
inner_consistent | determine which sub-partitions need to be searched for a
+ query | 4 |
leaf_consistent | determine whether key satisfies the
+ query qualifier | 5 |
options | define options that are specific to this operator class
+ (optional) | 6 |
+ GIN indexes have seven support functions, four of which are optional,
+ as shown in Table 38.13.
+ (For more information see Chapter 70.)
+
Table 38.13. GIN Support Functions
| Function | Description | Support Number |
|---|
compare |
+ compare two keys and return an integer less than zero, zero,
+ or greater than zero, indicating whether the first key is less than,
+ equal to, or greater than the second
+ | 1 |
extractValue | extract keys from a value to be indexed | 2 |
extractQuery | extract keys from a query condition | 3 |
consistent |
+ determine whether value matches query condition (Boolean variant)
+ (optional if support function 6 is present)
+ | 4 |
comparePartial |
+ compare partial key from
+ query and key from index, and return an integer less than zero, zero,
+ or greater than zero, indicating whether GIN should ignore this index
+ entry, treat the entry as a match, or stop the index scan (optional)
+ | 5 |
triConsistent |
+ determine whether value matches query condition (ternary variant)
+ (optional if support function 4 is present)
+ | 6 |
options |
+ define options that are specific to this operator class
+ (optional)
+ | 7 |
+ BRIN indexes have five basic support functions, one of which is optional,
+ as shown in Table 38.14. Some versions of
+ the basic functions require additional support functions to be provided.
+ (For more information see Section 71.3.)
+
Table 38.14. BRIN Support Functions
| Function | Description | Support Number |
|---|
opcInfo |
+ return internal information describing the indexed columns'
+ summary data
+ | 1 |
add_value | add a new value to an existing summary index tuple | 2 |
consistent | determine whether value matches query condition | 3 |
union |
+ compute union of two summary tuples
+ | 4 |
options |
+ define options that are specific to this operator class
+ (optional)
+ | 5 |
+ Unlike search operators, support functions return whichever data
+ type the particular index method expects; for example in the case
+ of the comparison function for B-trees, a signed integer. The number
+ and types of the arguments to each support function are likewise
+ dependent on the index method. For B-tree and hash the comparison and
+ hashing support functions take the same input data types as do the
+ operators included in the operator class, but this is not the case for
+ most GiST, SP-GiST, GIN, and BRIN support functions.
+
+ Now that we have seen the ideas, here is the promised example of
+ creating a new operator class.
+ (You can find a working copy of this example in
+ src/tutorial/complex.c and
+ src/tutorial/complex.sql in the source
+ distribution.)
+ The operator class encapsulates
+ operators that sort complex numbers in absolute value order, so we
+ choose the name complex_abs_ops. First, we need
+ a set of operators. The procedure for defining operators was
+ discussed in Section 38.14. For an operator class on
+ B-trees, the operators we require are:
+
+
- absolute-value less-than (strategy 1)
- absolute-value less-than-or-equal (strategy 2)
- absolute-value equal (strategy 3)
- absolute-value greater-than-or-equal (strategy 4)
- absolute-value greater-than (strategy 5)
+
+ The least error-prone way to define a related set of comparison operators
+ is to write the B-tree comparison support function first, and then write the
+ other functions as one-line wrappers around the support function. This
+ reduces the odds of getting inconsistent results for corner cases.
+ Following this approach, we first write:
+
+
+#define Mag(c) ((c)->x*(c)->x + (c)->y*(c)->y)
+
+static int
+complex_abs_cmp_internal(Complex *a, Complex *b)
+{
+ double amag = Mag(a),
+ bmag = Mag(b);
+
+ if (amag < bmag)
+ return -1;
+ if (amag > bmag)
+ return 1;
+ return 0;
+}
+
+
+
+ Now the less-than function looks like:
+
+
+PG_FUNCTION_INFO_V1(complex_abs_lt);
+
+Datum
+complex_abs_lt(PG_FUNCTION_ARGS)
+{
+ Complex *a = (Complex *) PG_GETARG_POINTER(0);
+ Complex *b = (Complex *) PG_GETARG_POINTER(1);
+
+ PG_RETURN_BOOL(complex_abs_cmp_internal(a, b) < 0);
+}
+
+
+
+ The other four functions differ only in how they compare the internal
+ function's result to zero.
+
+ Next we declare the functions and the operators based on the functions
+ to SQL:
+
+
+CREATE FUNCTION complex_abs_lt(complex, complex) RETURNS bool
+ AS 'filename', 'complex_abs_lt'
+ LANGUAGE C IMMUTABLE STRICT;
+
+CREATE OPERATOR < (
+ leftarg = complex, rightarg = complex, procedure = complex_abs_lt,
+ commutator = > , negator = >= ,
+ restrict = scalarltsel, join = scalarltjoinsel
+);
+
+ It is important to specify the correct commutator and negator operators,
+ as well as suitable restriction and join selectivity
+ functions, otherwise the optimizer will be unable to make effective
+ use of the index.
+
+ Other things worth noting are happening here:
+
+
+ There can only be one operator named, say, =
+ and taking type complex for both operands. In this
+ case we don't have any other operator = for
+ complex, but if we were building a practical data
+ type we'd probably want = to be the ordinary
+ equality operation for complex numbers (and not the equality of
+ the absolute values). In that case, we'd need to use some other
+ operator name for complex_abs_eq.
+
+ Although PostgreSQL can cope with
+ functions having the same SQL name as long as they have different
+ argument data types, C can only cope with one global function
+ having a given name. So we shouldn't name the C function
+ something simple like abs_eq. Usually it's
+ a good practice to include the data type name in the C function
+ name, so as not to conflict with functions for other data types.
+
+ We could have made the SQL name
+ of the function abs_eq, relying on
+ PostgreSQL to distinguish it by
+ argument data types from any other SQL function of the same name.
+ To keep the example simple, we make the function have the same
+ names at the C level and SQL level.
+
+
+ The next step is the registration of the support routine required
+ by B-trees. The example C code that implements this is in the same
+ file that contains the operator functions. This is how we declare
+ the function:
+
+
+CREATE FUNCTION complex_abs_cmp(complex, complex)
+ RETURNS integer
+ AS 'filename'
+ LANGUAGE C IMMUTABLE STRICT;
+
+
+ Now that we have the required operators and support routine,
+ we can finally create the operator class:
+
+
+CREATE OPERATOR CLASS complex_abs_ops
+ DEFAULT FOR TYPE complex USING btree AS
+ OPERATOR 1 < ,
+ OPERATOR 2 <= ,
+ OPERATOR 3 = ,
+ OPERATOR 4 >= ,
+ OPERATOR 5 > ,
+ FUNCTION 1 complex_abs_cmp(complex, complex);
+
+
+
+ And we're done! It should now be possible to create
+ and use B-tree indexes on complex columns.
+
+ We could have written the operator entries more verbosely, as in:
+
+ OPERATOR 1 < (complex, complex) ,
+
+ but there is no need to do so when the operators take the same data type
+ we are defining the operator class for.
+
+ The above example assumes that you want to make this new operator class the
+ default B-tree operator class for the complex data type.
+ If you don't, just leave out the word DEFAULT.
+
38.16.5. Operator Classes and Operator Families #
+ So far we have implicitly assumed that an operator class deals with
+ only one data type. While there certainly can be only one data type in
+ a particular index column, it is often useful to index operations that
+ compare an indexed column to a value of a different data type. Also,
+ if there is use for a cross-data-type operator in connection with an
+ operator class, it is often the case that the other data type has a
+ related operator class of its own. It is helpful to make the connections
+ between related classes explicit, because this can aid the planner in
+ optimizing SQL queries (particularly for B-tree operator classes, since
+ the planner contains a great deal of knowledge about how to work with them).
+
+ To handle these needs, PostgreSQL
+ uses the concept of an operator
+ family.
+ An operator family contains one or more operator classes, and can also
+ contain indexable operators and corresponding support functions that
+ belong to the family as a whole but not to any single class within the
+ family. We say that such operators and functions are “loose”
+ within the family, as opposed to being bound into a specific class.
+ Typically each operator class contains single-data-type operators
+ while cross-data-type operators are loose in the family.
+
+ All the operators and functions in an operator family must have compatible
+ semantics, where the compatibility requirements are set by the index
+ method. You might therefore wonder why bother to single out particular
+ subsets of the family as operator classes; and indeed for many purposes
+ the class divisions are irrelevant and the family is the only interesting
+ grouping. The reason for defining operator classes is that they specify
+ how much of the family is needed to support any particular index.
+ If there is an index using an operator class, then that operator class
+ cannot be dropped without dropping the index — but other parts of
+ the operator family, namely other operator classes and loose operators,
+ could be dropped. Thus, an operator class should be specified to contain
+ the minimum set of operators and functions that are reasonably needed
+ to work with an index on a specific data type, and then related but
+ non-essential operators can be added as loose members of the operator
+ family.
+
+ As an example, PostgreSQL has a built-in
+ B-tree operator family integer_ops, which includes operator
+ classes int8_ops, int4_ops, and
+ int2_ops for indexes on bigint (int8),
+ integer (int4), and smallint (int2)
+ columns respectively. The family also contains cross-data-type comparison
+ operators allowing any two of these types to be compared, so that an index
+ on one of these types can be searched using a comparison value of another
+ type. The family could be duplicated by these definitions:
+
+
+CREATE OPERATOR FAMILY integer_ops USING btree;
+
+CREATE OPERATOR CLASS int8_ops
+DEFAULT FOR TYPE int8 USING btree FAMILY integer_ops AS
+ -- standard int8 comparisons
+ OPERATOR 1 < ,
+ OPERATOR 2 <= ,
+ OPERATOR 3 = ,
+ OPERATOR 4 >= ,
+ OPERATOR 5 > ,
+ FUNCTION 1 btint8cmp(int8, int8) ,
+ FUNCTION 2 btint8sortsupport(internal) ,
+ FUNCTION 3 in_range(int8, int8, int8, boolean, boolean) ,
+ FUNCTION 4 btequalimage(oid) ;
+
+CREATE OPERATOR CLASS int4_ops
+DEFAULT FOR TYPE int4 USING btree FAMILY integer_ops AS
+ -- standard int4 comparisons
+ OPERATOR 1 < ,
+ OPERATOR 2 <= ,
+ OPERATOR 3 = ,
+ OPERATOR 4 >= ,
+ OPERATOR 5 > ,
+ FUNCTION 1 btint4cmp(int4, int4) ,
+ FUNCTION 2 btint4sortsupport(internal) ,
+ FUNCTION 3 in_range(int4, int4, int4, boolean, boolean) ,
+ FUNCTION 4 btequalimage(oid) ;
+
+CREATE OPERATOR CLASS int2_ops
+DEFAULT FOR TYPE int2 USING btree FAMILY integer_ops AS
+ -- standard int2 comparisons
+ OPERATOR 1 < ,
+ OPERATOR 2 <= ,
+ OPERATOR 3 = ,
+ OPERATOR 4 >= ,
+ OPERATOR 5 > ,
+ FUNCTION 1 btint2cmp(int2, int2) ,
+ FUNCTION 2 btint2sortsupport(internal) ,
+ FUNCTION 3 in_range(int2, int2, int2, boolean, boolean) ,
+ FUNCTION 4 btequalimage(oid) ;
+
+ALTER OPERATOR FAMILY integer_ops USING btree ADD
+ -- cross-type comparisons int8 vs int2
+ OPERATOR 1 < (int8, int2) ,
+ OPERATOR 2 <= (int8, int2) ,
+ OPERATOR 3 = (int8, int2) ,
+ OPERATOR 4 >= (int8, int2) ,
+ OPERATOR 5 > (int8, int2) ,
+ FUNCTION 1 btint82cmp(int8, int2) ,
+
+ -- cross-type comparisons int8 vs int4
+ OPERATOR 1 < (int8, int4) ,
+ OPERATOR 2 <= (int8, int4) ,
+ OPERATOR 3 = (int8, int4) ,
+ OPERATOR 4 >= (int8, int4) ,
+ OPERATOR 5 > (int8, int4) ,
+ FUNCTION 1 btint84cmp(int8, int4) ,
+
+ -- cross-type comparisons int4 vs int2
+ OPERATOR 1 < (int4, int2) ,
+ OPERATOR 2 <= (int4, int2) ,
+ OPERATOR 3 = (int4, int2) ,
+ OPERATOR 4 >= (int4, int2) ,
+ OPERATOR 5 > (int4, int2) ,
+ FUNCTION 1 btint42cmp(int4, int2) ,
+
+ -- cross-type comparisons int4 vs int8
+ OPERATOR 1 < (int4, int8) ,
+ OPERATOR 2 <= (int4, int8) ,
+ OPERATOR 3 = (int4, int8) ,
+ OPERATOR 4 >= (int4, int8) ,
+ OPERATOR 5 > (int4, int8) ,
+ FUNCTION 1 btint48cmp(int4, int8) ,
+
+ -- cross-type comparisons int2 vs int8
+ OPERATOR 1 < (int2, int8) ,
+ OPERATOR 2 <= (int2, int8) ,
+ OPERATOR 3 = (int2, int8) ,
+ OPERATOR 4 >= (int2, int8) ,
+ OPERATOR 5 > (int2, int8) ,
+ FUNCTION 1 btint28cmp(int2, int8) ,
+
+ -- cross-type comparisons int2 vs int4
+ OPERATOR 1 < (int2, int4) ,
+ OPERATOR 2 <= (int2, int4) ,
+ OPERATOR 3 = (int2, int4) ,
+ OPERATOR 4 >= (int2, int4) ,
+ OPERATOR 5 > (int2, int4) ,
+ FUNCTION 1 btint24cmp(int2, int4) ,
+
+ -- cross-type in_range functions
+ FUNCTION 3 in_range(int4, int4, int8, boolean, boolean) ,
+ FUNCTION 3 in_range(int4, int4, int2, boolean, boolean) ,
+ FUNCTION 3 in_range(int2, int2, int8, boolean, boolean) ,
+ FUNCTION 3 in_range(int2, int2, int4, boolean, boolean) ;
+
+
+
+ Notice that this definition “overloads” the operator strategy and
+ support function numbers: each number occurs multiple times within the
+ family. This is allowed so long as each instance of a
+ particular number has distinct input data types. The instances that have
+ both input types equal to an operator class's input type are the
+ primary operators and support functions for that operator class,
+ and in most cases should be declared as part of the operator class rather
+ than as loose members of the family.
+
+ In a B-tree operator family, all the operators in the family must sort
+ compatibly, as is specified in detail in Section 67.2.
+ For each
+ operator in the family there must be a support function having the same
+ two input data types as the operator. It is recommended that a family be
+ complete, i.e., for each combination of data types, all operators are
+ included. Each operator class should include just the non-cross-type
+ operators and support function for its data type.
+
+ To build a multiple-data-type hash operator family, compatible hash
+ support functions must be created for each data type supported by the
+ family. Here compatibility means that the functions are guaranteed to
+ return the same hash code for any two values that are considered equal
+ by the family's equality operators, even when the values are of different
+ types. This is usually difficult to accomplish when the types have
+ different physical representations, but it can be done in some cases.
+ Furthermore, casting a value from one data type represented in the operator
+ family to another data type also represented in the operator family via
+ an implicit or binary coercion cast must not change the computed hash value.
+ Notice that there is only one support function per data type, not one
+ per equality operator. It is recommended that a family be complete, i.e.,
+ provide an equality operator for each combination of data types.
+ Each operator class should include just the non-cross-type equality
+ operator and the support function for its data type.
+
+ GiST, SP-GiST, and GIN indexes do not have any explicit notion of
+ cross-data-type operations. The set of operators supported is just
+ whatever the primary support functions for a given operator class can
+ handle.
+
+ In BRIN, the requirements depends on the framework that provides the
+ operator classes. For operator classes based on minmax,
+ the behavior required is the same as for B-tree operator families:
+ all the operators in the family must sort compatibly, and casts must
+ not change the associated sort ordering.
+
Note
+ Prior to PostgreSQL 8.3, there was no concept
+ of operator families, and so any cross-data-type operators intended to be
+ used with an index had to be bound directly into the index's operator
+ class. While this approach still works, it is deprecated because it
+ makes an index's dependencies too broad, and because the planner can
+ handle cross-data-type comparisons more effectively when both data types
+ have operators in the same operator family.
+
38.16.6. System Dependencies on Operator Classes #
+ PostgreSQL uses operator classes to infer the
+ properties of operators in more ways than just whether they can be used
+ with indexes. Therefore, you might want to create operator classes
+ even if you have no intention of indexing any columns of your data type.
+
+ In particular, there are SQL features such as ORDER BY and
+ DISTINCT that require comparison and sorting of values.
+ To implement these features on a user-defined data type,
+ PostgreSQL looks for the default B-tree operator
+ class for the data type. The “equals” member of this operator
+ class defines the system's notion of equality of values for
+ GROUP BY and DISTINCT, and the sort ordering
+ imposed by the operator class defines the default ORDER BY
+ ordering.
+
+ If there is no default B-tree operator class for a data type, the system
+ will look for a default hash operator class. But since that kind of
+ operator class only provides equality, it is only able to support grouping
+ not sorting.
+
+ When there is no default operator class for a data type, you will get
+ errors like “could not identify an ordering operator” if you
+ try to use these SQL features with the data type.
+
Note
+ In PostgreSQL versions before 7.4,
+ sorting and grouping operations would implicitly use operators named
+ =, <, and >. The new
+ behavior of relying on default operator classes avoids having to make
+ any assumption about the behavior of operators with particular names.
+
+ Sorting by a non-default B-tree operator class is possible by specifying
+ the class's less-than operator in a USING option,
+ for example
+
+SELECT * FROM mytable ORDER BY somecol USING ~<~;
+
+ Alternatively, specifying the class's greater-than operator
+ in USING selects a descending-order sort.
+
+ Comparison of arrays of a user-defined type also relies on the semantics
+ defined by the type's default B-tree operator class. If there is no
+ default B-tree operator class, but there is a default hash operator class,
+ then array equality is supported, but not ordering comparisons.
+
+ Another SQL feature that requires even more data-type-specific knowledge
+ is the RANGE offset
+ PRECEDING/FOLLOWING framing option
+ for window functions (see Section 4.2.8).
+ For a query such as
+
+SELECT sum(x) OVER (ORDER BY x RANGE BETWEEN 5 PRECEDING AND 10 FOLLOWING)
+ FROM mytable;
+
+ it is not sufficient to know how to order by x;
+ the database must also understand how to “subtract 5” or
+ “add 10” to the current row's value of x
+ to identify the bounds of the current window frame. Comparing the
+ resulting bounds to other rows' values of x is
+ possible using the comparison operators provided by the B-tree operator
+ class that defines the ORDER BY ordering — but
+ addition and subtraction operators are not part of the operator class, so
+ which ones should be used? Hard-wiring that choice would be undesirable,
+ because different sort orders (different B-tree operator classes) might
+ need different behavior. Therefore, a B-tree operator class can specify
+ an in_range support function that encapsulates the
+ addition and subtraction behaviors that make sense for its sort order.
+ It can even provide more than one in_range support function, in case
+ there is more than one data type that makes sense to use as the offset
+ in RANGE clauses.
+ If the B-tree operator class associated with the window's ORDER
+ BY clause does not have a matching in_range support function,
+ the RANGE offset
+ PRECEDING/FOLLOWING
+ option is not supported.
+
+ Another important point is that an equality operator that
+ appears in a hash operator family is a candidate for hash joins,
+ hash aggregation, and related optimizations. The hash operator family
+ is essential here since it identifies the hash function(s) to use.
+
38.16.7. Ordering Operators #
+ Some index access methods (currently, only GiST and SP-GiST) support the concept of
+ ordering operators. What we have been discussing so far
+ are search operators. A search operator is one for which
+ the index can be searched to find all rows satisfying
+ WHERE
+ indexed_column
+ operator
+ constant.
+ Note that nothing is promised about the order in which the matching rows
+ will be returned. In contrast, an ordering operator does not restrict the
+ set of rows that can be returned, but instead determines their order.
+ An ordering operator is one for which the index can be scanned to return
+ rows in the order represented by
+ ORDER BY
+ indexed_column
+ operator
+ constant.
+ The reason for defining ordering operators that way is that it supports
+ nearest-neighbor searches, if the operator is one that measures distance.
+ For example, a query like
+
+SELECT * FROM places ORDER BY location <-> point '(101,456)' LIMIT 10;
+
+
+ finds the ten places closest to a given target point. A GiST index
+ on the location column can do this efficiently because
+ <-> is an ordering operator.
+
+ While search operators have to return Boolean results, ordering operators
+ usually return some other type, such as float or numeric for distances.
+ This type is normally not the same as the data type being indexed.
+ To avoid hard-wiring assumptions about the behavior of different data
+ types, the definition of an ordering operator is required to name
+ a B-tree operator family that specifies the sort ordering of the result
+ data type. As was stated in the previous section, B-tree operator families
+ define PostgreSQL's notion of ordering, so
+ this is a natural representation. Since the point <->
+ operator returns float8, it could be specified in an operator
+ class creation command like this:
+
+OPERATOR 15 <-> (point, point) FOR ORDER BY float_ops
+
+
+ where float_ops is the built-in operator family that includes
+ operations on float8. This declaration states that the index
+ is able to return rows in order of increasing values of the
+ <-> operator.
+
38.16.8. Special Features of Operator Classes #
+ There are two special features of operator classes that we have
+ not discussed yet, mainly because they are not useful
+ with the most commonly used index methods.
+
+ Normally, declaring an operator as a member of an operator class
+ (or family) means that the index method can retrieve exactly the set of rows
+ that satisfy a WHERE condition using the operator. For example:
+
+SELECT * FROM table WHERE integer_column < 4;
+
+ can be satisfied exactly by a B-tree index on the integer column.
+ But there are cases where an index is useful as an inexact guide to
+ the matching rows. For example, if a GiST index stores only bounding boxes
+ for geometric objects, then it cannot exactly satisfy a WHERE
+ condition that tests overlap between nonrectangular objects such as
+ polygons. Yet we could use the index to find objects whose bounding
+ box overlaps the bounding box of the target object, and then do the
+ exact overlap test only on the objects found by the index. If this
+ scenario applies, the index is said to be “lossy” for the
+ operator. Lossy index searches are implemented by having the index
+ method return a recheck flag when a row might or might
+ not really satisfy the query condition. The core system will then
+ test the original query condition on the retrieved row to see whether
+ it should be returned as a valid match. This approach works if
+ the index is guaranteed to return all the required rows, plus perhaps
+ some additional rows, which can be eliminated by performing the original
+ operator invocation. The index methods that support lossy searches
+ (currently, GiST, SP-GiST and GIN) allow the support functions of individual
+ operator classes to set the recheck flag, and so this is essentially an
+ operator-class feature.
+
+ Consider again the situation where we are storing in the index only
+ the bounding box of a complex object such as a polygon. In this
+ case there's not much value in storing the whole polygon in the index
+ entry — we might as well store just a simpler object of type
+ box. This situation is expressed by the STORAGE
+ option in CREATE OPERATOR CLASS: we'd write something like:
+
+
+CREATE OPERATOR CLASS polygon_ops
+ DEFAULT FOR TYPE polygon USING gist AS
+ ...
+ STORAGE box;
+
+
+ At present, only the GiST, SP-GiST, GIN and BRIN index methods support a
+ STORAGE type that's different from the column data type.
+ The GiST compress and decompress support
+ routines must deal with data-type conversion when STORAGE
+ is used. SP-GiST likewise requires a compress
+ support function to convert to the storage type, when that is different;
+ if an SP-GiST opclass also supports retrieving data, the reverse
+ conversion must be handled by the consistent function.
+ In GIN, the STORAGE type identifies the type of
+ the “key” values, which normally is different from the type
+ of the indexed column — for example, an operator class for
+ integer-array columns might have keys that are just integers. The
+ GIN extractValue and extractQuery support
+ routines are responsible for extracting keys from indexed values.
+ BRIN is similar to GIN: the STORAGE type identifies the
+ type of the stored summary values, and operator classes' support
+ procedures are responsible for interpreting the summary values
+ correctly.
+
F.50. xml2 — XPath querying and XSLT functionality #
+ The xml2 module provides XPath querying and
+ XSLT functionality.
+
F.50.1. Deprecation Notice #
+ From PostgreSQL 8.3 on, there is XML-related
+ functionality based on the SQL/XML standard in the core server.
+ That functionality covers XML syntax checking and XPath queries,
+ which is what this module does, and more, but the API is
+ not at all compatible. It is planned that this module will be
+ removed in a future version of PostgreSQL in favor of the newer standard API, so
+ you are encouraged to try converting your applications. If you
+ find that some of the functionality of this module is not
+ available in an adequate form with the newer API, please explain
+ your issue to <pgsql-hackers@lists.postgresql.org> so that the deficiency
+ can be addressed.
+
F.50.2. Description of Functions #
+ Table F.36 shows the functions provided by this module.
+ These functions provide straightforward XML parsing and XPath queries.
+
Table F.36. xml2 Functions
+ Function
+
+
+ Description
+ |
|---|
+ xml_valid ( document text )
+ → boolean
+
+
+ Parses the given document and returns true if the
+ document is well-formed XML. (Note: this is an alias for the standard
+ PostgreSQL function xml_is_well_formed(). The
+ name xml_valid() is technically incorrect since validity
+ and well-formedness have different meanings in XML.)
+ |
+ xpath_string ( document text, query text )
+ → text
+
+
+ Evaluates the XPath query on the supplied document, and
+ casts the result to text.
+ |
+ xpath_number ( document text, query text )
+ → real
+
+
+ Evaluates the XPath query on the supplied document, and
+ casts the result to real.
+ |
+ xpath_bool ( document text, query text )
+ → boolean
+
+
+ Evaluates the XPath query on the supplied document, and
+ casts the result to boolean.
+ |
+ xpath_nodeset ( document text, query text, toptag text, itemtag text )
+ → text
+
+
+ Evaluates the query on the document and wraps the result in XML
+ tags. If the result is multivalued, the output will look like:
+
+<toptag>
+<itemtag>Value 1 which could be an XML fragment</itemtag>
+<itemtag>Value 2....</itemtag>
+</toptag>
+
+ If either toptag
+ or itemtag is an empty string, the relevant tag
+ is omitted.
+ |
+ xpath_nodeset ( document text, query text, itemtag text )
+ → text
+
+
+ Like xpath_nodeset(document, query, toptag, itemtag) but result omits toptag.
+ |
+ xpath_nodeset ( document text, query text )
+ → text
+
+
+ Like xpath_nodeset(document, query, toptag, itemtag) but result omits both tags.
+ |
+ xpath_list ( document text, query text, separator text )
+ → text
+
+
+ Evaluates the query on the document and returns multiple values
+ separated by the specified separator, for example Value
+ 1,Value 2,Value 3 if separator
+ is ,.
+ |
+ xpath_list ( document text, query text )
+ → text
+
+
+ This is a wrapper for the above function that uses ,
+ as the separator.
+ |
+xpath_table(text key, text document, text relation, text xpaths, text criteria) returns setof record
+
+ xpath_table is a table function that evaluates a set of XPath
+ queries on each of a set of documents and returns the results as a
+ table. The primary key field from the original document table is returned
+ as the first column of the result so that the result set
+ can readily be used in joins. The parameters are described in
+ Table F.37.
+
Table F.37. xpath_table Parameters
| Parameter | Description |
|---|
key |
+
+ the name of the “key” field — this is just a field to be used as
+ the first column of the output table, i.e., it identifies the record from
+ which each output row came (see note below about multiple values)
+
+ |
document |
+
+ the name of the field containing the XML document
+
+ |
relation |
+
+ the name of the table or view containing the documents
+
+ |
xpaths |
+
+ one or more XPath expressions, separated by |
+
+ |
criteria |
+
+ the contents of the WHERE clause. This cannot be omitted, so use
+ true or 1=1 if you want to
+ process all the rows in the relation
+
+ |
+ These parameters (except the XPath strings) are just substituted
+ into a plain SQL SELECT statement, so you have some flexibility — the
+ statement is
+
+
+ SELECT <key>, <document> FROM <relation> WHERE <criteria>
+
+
+ so those parameters can be anything valid in those particular
+ locations. The result from this SELECT needs to return exactly two
+ columns (which it will unless you try to list multiple fields for key
+ or document). Beware that this simplistic approach requires that you
+ validate any user-supplied values to avoid SQL injection attacks.
+
+ The function has to be used in a FROM expression, with an
+ AS clause to specify the output columns; for example
+
+SELECT * FROM
+xpath_table('article_id',
+ 'article_xml',
+ 'articles',
+ '/article/author|/article/pages|/article/title',
+ 'date_entered > ''2003-01-01'' ')
+AS t(article_id integer, author text, page_count integer, title text);
+
+ The AS clause defines the names and types of the columns in the
+ output table. The first is the “key” field and the rest correspond
+ to the XPath queries.
+ If there are more XPath queries than result columns,
+ the extra queries will be ignored. If there are more result columns
+ than XPath queries, the extra columns will be NULL.
+
+ Notice that this example defines the page_count result
+ column as an integer. The function deals internally with string
+ representations, so when you say you want an integer in the output, it will
+ take the string representation of the XPath result and use PostgreSQL input
+ functions to transform it into an integer (or whatever type the AS
+ clause requests). An error will result if it can't do this — for
+ example if the result is empty — so you may wish to just stick to
+ text as the column type if you think your data has any problems.
+
+ The calling SELECT statement doesn't necessarily have to be
+ just SELECT * — it can reference the output
+ columns by name or join them to other tables. The function produces a
+ virtual table with which you can perform any operation you wish (e.g.,
+ aggregation, joining, sorting etc.). So we could also have:
+
+SELECT t.title, p.fullname, p.email
+FROM xpath_table('article_id', 'article_xml', 'articles',
+ '/article/title|/article/author/@id',
+ 'xpath_string(article_xml,''/article/@date'') > ''2003-03-20'' ')
+ AS t(article_id integer, title text, author_id integer),
+ tblPeopleInfo AS p
+WHERE t.author_id = p.person_id;
+
+ as a more complicated example. Of course, you could wrap all
+ of this in a view for convenience.
+
F.50.3.1. Multivalued Results #
+ The xpath_table function assumes that the results of each XPath query
+ might be multivalued, so the number of rows returned by the function
+ may not be the same as the number of input documents. The first row
+ returned contains the first result from each query, the second row the
+ second result from each query. If one of the queries has fewer values
+ than the others, null values will be returned instead.
+
+ In some cases, a user will know that a given XPath query will return
+ only a single result (perhaps a unique document identifier) — if used
+ alongside an XPath query returning multiple results, the single-valued
+ result will appear only on the first row of the result. The solution
+ to this is to use the key field as part of a join against a simpler
+ XPath query. As an example:
+
+
+CREATE TABLE test (
+ id int PRIMARY KEY,
+ xml text
+);
+
+INSERT INTO test VALUES (1, '<doc num="C1">
+<line num="L1"><a>1</a><b>2</b><c>3</c></line>
+<line num="L2"><a>11</a><b>22</b><c>33</c></line>
+</doc>');
+
+INSERT INTO test VALUES (2, '<doc num="C2">
+<line num="L1"><a>111</a><b>222</b><c>333</c></line>
+<line num="L2"><a>111</a><b>222</b><c>333</c></line>
+</doc>');
+
+SELECT * FROM
+ xpath_table('id','xml','test',
+ '/doc/@num|/doc/line/@num|/doc/line/a|/doc/line/b|/doc/line/c',
+ 'true')
+ AS t(id int, doc_num varchar(10), line_num varchar(10), val1 int, val2 int, val3 int)
+WHERE id = 1 ORDER BY doc_num, line_num
+
+ id | doc_num | line_num | val1 | val2 | val3
+----+---------+----------+------+------+------
+ 1 | C1 | L1 | 1 | 2 | 3
+ 1 | | L2 | 11 | 22 | 33
+
+
+ To get doc_num on every line, the solution is to use two invocations
+ of xpath_table and join the results:
+
+
+SELECT t.*,i.doc_num FROM
+ xpath_table('id', 'xml', 'test',
+ '/doc/line/@num|/doc/line/a|/doc/line/b|/doc/line/c',
+ 'true')
+ AS t(id int, line_num varchar(10), val1 int, val2 int, val3 int),
+ xpath_table('id', 'xml', 'test', '/doc/@num', 'true')
+ AS i(id int, doc_num varchar(10))
+WHERE i.id=t.id AND i.id=1
+ORDER BY doc_num, line_num;
+
+ id | line_num | val1 | val2 | val3 | doc_num
+----+----------+------+------+------+---------
+ 1 | L1 | 1 | 2 | 3 | C1
+ 1 | L2 | 11 | 22 | 33 | C1
+(2 rows)
+
+
+ The following functions are available if libxslt is installed:
+
+xslt_process(text document, text stylesheet, text paramlist) returns text
+
+ This function applies the XSL stylesheet to the document and returns
+ the transformed result. The paramlist is a list of parameter
+ assignments to be used in the transformation, specified in the form
+ a=1,b=2. Note that the
+ parameter parsing is very simple-minded: parameter values cannot
+ contain commas!
+
+ There is also a two-parameter version of xslt_process which
+ does not pass any parameters to the transformation.
+
+ John Gray <jgray@azuli.co.uk>
+
+ Development of this module was sponsored by Torchbox Ltd. (www.torchbox.com).
+ It has the same BSD license as PostgreSQL.
+
38.15. Operator Optimization Information #
+ A PostgreSQL operator definition can include
+ several optional clauses that tell the system useful things about how
+ the operator behaves. These clauses should be provided whenever
+ appropriate, because they can make for considerable speedups in execution
+ of queries that use the operator. But if you provide them, you must be
+ sure that they are right! Incorrect use of an optimization clause can
+ result in slow queries, subtly wrong output, or other Bad Things.
+ You can always leave out an optimization clause if you are not sure
+ about it; the only consequence is that queries might run slower than
+ they need to.
+
+ Additional optimization clauses might be added in future versions of
+ PostgreSQL. The ones described here are all
+ the ones that release 16.3 understands.
+
+ It is also possible to attach a planner support function to the function
+ that underlies an operator, providing another way of telling the system
+ about the behavior of the operator.
+ See Section 38.11 for more information.
+
+ The COMMUTATOR clause, if provided, names an operator that is the
+ commutator of the operator being defined. We say that operator A is the
+ commutator of operator B if (x A y) equals (y B x) for all possible input
+ values x, y. Notice that B is also the commutator of A. For example,
+ operators < and > for a particular data type are usually each others'
+ commutators, and operator + is usually commutative with itself.
+ But operator - is usually not commutative with anything.
+
+ The left operand type of a commutable operator is the same as the
+ right operand type of its commutator, and vice versa. So the name of
+ the commutator operator is all that PostgreSQL
+ needs to be given to look up the commutator, and that's all that needs to
+ be provided in the COMMUTATOR clause.
+
+ It's critical to provide commutator information for operators that
+ will be used in indexes and join clauses, because this allows the
+ query optimizer to “flip around” such a clause to the forms
+ needed for different plan types. For example, consider a query with
+ a WHERE clause like tab1.x = tab2.y, where tab1.x
+ and tab2.y are of a user-defined type, and suppose that
+ tab2.y is indexed. The optimizer cannot generate an
+ index scan unless it can determine how to flip the clause around to
+ tab2.y = tab1.x, because the index-scan machinery expects
+ to see the indexed column on the left of the operator it is given.
+ PostgreSQL will not simply
+ assume that this is a valid transformation — the creator of the
+ = operator must specify that it is valid, by marking the
+ operator with commutator information.
+
+ When you are defining a self-commutative operator, you just do it.
+ When you are defining a pair of commutative operators, things are
+ a little trickier: how can the first one to be defined refer to the
+ other one, which you haven't defined yet? There are two solutions
+ to this problem:
+
+
+ One way is to omit the COMMUTATOR clause in the first operator that
+ you define, and then provide one in the second operator's definition.
+ Since PostgreSQL knows that commutative
+ operators come in pairs, when it sees the second definition it will
+ automatically go back and fill in the missing COMMUTATOR clause in
+ the first definition.
+
+ The other, more straightforward way is just to include COMMUTATOR clauses
+ in both definitions. When PostgreSQL processes
+ the first definition and realizes that COMMUTATOR refers to a nonexistent
+ operator, the system will make a dummy entry for that operator in the
+ system catalog. This dummy entry will have valid data only
+ for the operator name, left and right operand types, and result type,
+ since that's all that PostgreSQL can deduce
+ at this point. The first operator's catalog entry will link to this
+ dummy entry. Later, when you define the second operator, the system
+ updates the dummy entry with the additional information from the second
+ definition. If you try to use the dummy operator before it's been filled
+ in, you'll just get an error message.
+
+
+ The NEGATOR clause, if provided, names an operator that is the
+ negator of the operator being defined. We say that operator A
+ is the negator of operator B if both return Boolean results and
+ (x A y) equals NOT (x B y) for all possible inputs x, y.
+ Notice that B is also the negator of A.
+ For example, < and >= are a negator pair for most data types.
+ An operator can never validly be its own negator.
+
+ Unlike commutators, a pair of unary operators could validly be marked
+ as each other's negators; that would mean (A x) equals NOT (B x)
+ for all x.
+
+ An operator's negator must have the same left and/or right operand types
+ as the operator to be defined, so just as with COMMUTATOR, only the operator
+ name need be given in the NEGATOR clause.
+
+ Providing a negator is very helpful to the query optimizer since
+ it allows expressions like NOT (x = y) to be simplified into
+ x <> y. This comes up more often than you might think, because
+ NOT operations can be inserted as a consequence of other rearrangements.
+
+ Pairs of negator operators can be defined using the same methods
+ explained above for commutator pairs.
+
+ The RESTRICT clause, if provided, names a restriction selectivity
+ estimation function for the operator. (Note that this is a function
+ name, not an operator name.) RESTRICT clauses only make sense for
+ binary operators that return boolean. The idea behind a restriction
+ selectivity estimator is to guess what fraction of the rows in a
+ table will satisfy a WHERE-clause condition of the form:
+
+column OP constant
+
+ for the current operator and a particular constant value.
+ This assists the optimizer by
+ giving it some idea of how many rows will be eliminated by WHERE
+ clauses that have this form. (What happens if the constant is on
+ the left, you might be wondering? Well, that's one of the things that
+ COMMUTATOR is for...)
+
+ Writing new restriction selectivity estimation functions is far beyond
+ the scope of this chapter, but fortunately you can usually just use
+ one of the system's standard estimators for many of your own operators.
+ These are the standard restriction estimators:
+
eqsel for = |
neqsel for <> |
scalarltsel for < |
scalarlesel for <= |
scalargtsel for > |
scalargesel for >= |
+
+ You can frequently get away with using either eqsel or neqsel for
+ operators that have very high or very low selectivity, even if they
+ aren't really equality or inequality. For example, the
+ approximate-equality geometric operators use eqsel on the assumption that
+ they'll usually only match a small fraction of the entries in a table.
+
+ You can use scalarltsel, scalarlesel,
+ scalargtsel and scalargesel for comparisons on
+ data types that have some sensible means of being converted into numeric
+ scalars for range comparisons. If possible, add the data type to those
+ understood by the function convert_to_scalar() in
+ src/backend/utils/adt/selfuncs.c.
+ (Eventually, this function should be replaced by per-data-type functions
+ identified through a column of the pg_type system catalog; but that hasn't happened
+ yet.) If you do not do this, things will still work, but the optimizer's
+ estimates won't be as good as they could be.
+
+ Another useful built-in selectivity estimation function
+ is matchingsel, which will work for almost any
+ binary operator, if standard MCV and/or histogram statistics are
+ collected for the input data type(s). Its default estimate is set to
+ twice the default estimate used in eqsel, making
+ it most suitable for comparison operators that are somewhat less
+ strict than equality. (Or you could call the
+ underlying generic_restriction_selectivity
+ function, providing a different default estimate.)
+
+ There are additional selectivity estimation functions designed for geometric
+ operators in src/backend/utils/adt/geo_selfuncs.c: areasel, positionsel,
+ and contsel. At this writing these are just stubs, but you might want
+ to use them (or even better, improve them) anyway.
+
+ The JOIN clause, if provided, names a join selectivity
+ estimation function for the operator. (Note that this is a function
+ name, not an operator name.) JOIN clauses only make sense for
+ binary operators that return boolean. The idea behind a join
+ selectivity estimator is to guess what fraction of the rows in a
+ pair of tables will satisfy a WHERE-clause condition of the form:
+
+table1.column1 OP table2.column2
+
+ for the current operator. As with the RESTRICT clause, this helps
+ the optimizer very substantially by letting it figure out which
+ of several possible join sequences is likely to take the least work.
+
+ As before, this chapter will make no attempt to explain how to write
+ a join selectivity estimator function, but will just suggest that
+ you use one of the standard estimators if one is applicable:
+
eqjoinsel for = |
neqjoinsel for <> |
scalarltjoinsel for < |
scalarlejoinsel for <= |
scalargtjoinsel for > |
scalargejoinsel for >= |
matchingjoinsel for generic matching operators |
areajoinsel for 2D area-based comparisons |
positionjoinsel for 2D position-based comparisons |
contjoinsel for 2D containment-based comparisons |
+
+ The HASHES clause, if present, tells the system that
+ it is permissible to use the hash join method for a join based on this
+ operator. HASHES only makes sense for a binary operator that
+ returns boolean, and in practice the operator must represent
+ equality for some data type or pair of data types.
+
+ The assumption underlying hash join is that the join operator can
+ only return true for pairs of left and right values that hash to the
+ same hash code. If two values get put in different hash buckets, the
+ join will never compare them at all, implicitly assuming that the
+ result of the join operator must be false. So it never makes sense
+ to specify HASHES for operators that do not represent
+ some form of equality. In most cases it is only practical to support
+ hashing for operators that take the same data type on both sides.
+ However, sometimes it is possible to design compatible hash functions
+ for two or more data types; that is, functions that will generate the
+ same hash codes for “equal” values, even though the values
+ have different representations. For example, it's fairly simple
+ to arrange this property when hashing integers of different widths.
+
+ To be marked HASHES, the join operator must appear
+ in a hash index operator family. This is not enforced when you create
+ the operator, since of course the referencing operator family couldn't
+ exist yet. But attempts to use the operator in hash joins will fail
+ at run time if no such operator family exists. The system needs the
+ operator family to find the data-type-specific hash function(s) for the
+ operator's input data type(s). Of course, you must also create suitable
+ hash functions before you can create the operator family.
+
+ Care should be exercised when preparing a hash function, because there
+ are machine-dependent ways in which it might fail to do the right thing.
+ For example, if your data type is a structure in which there might be
+ uninteresting pad bits, you cannot simply pass the whole structure to
+ hash_any. (Unless you write your other operators and
+ functions to ensure that the unused bits are always zero, which is the
+ recommended strategy.)
+ Another example is that on machines that meet the IEEE
+ floating-point standard, negative zero and positive zero are different
+ values (different bit patterns) but they are defined to compare equal.
+ If a float value might contain negative zero then extra steps are needed
+ to ensure it generates the same hash value as positive zero.
+
+ A hash-joinable operator must have a commutator (itself if the two
+ operand data types are the same, or a related equality operator
+ if they are different) that appears in the same operator family.
+ If this is not the case, planner errors might occur when the operator
+ is used. Also, it is a good idea (but not strictly required) for
+ a hash operator family that supports multiple data types to provide
+ equality operators for every combination of the data types; this
+ allows better optimization.
+
Note
+ The function underlying a hash-joinable operator must be marked
+ immutable or stable. If it is volatile, the system will never
+ attempt to use the operator for a hash join.
+
Note
+ If a hash-joinable operator has an underlying function that is marked
+ strict, the
+ function must also be complete: that is, it should return true or
+ false, never null, for any two nonnull inputs. If this rule is
+ not followed, hash-optimization of IN operations might
+ generate wrong results. (Specifically, IN might return
+ false where the correct answer according to the standard would be null;
+ or it might yield an error complaining that it wasn't prepared for a
+ null result.)
+
+ The MERGES clause, if present, tells the system that
+ it is permissible to use the merge-join method for a join based on this
+ operator. MERGES only makes sense for a binary operator that
+ returns boolean, and in practice the operator must represent
+ equality for some data type or pair of data types.
+
+ Merge join is based on the idea of sorting the left- and right-hand tables
+ into order and then scanning them in parallel. So, both data types must
+ be capable of being fully ordered, and the join operator must be one
+ that can only succeed for pairs of values that fall at the
+ “same place”
+ in the sort order. In practice this means that the join operator must
+ behave like equality. But it is possible to merge-join two
+ distinct data types so long as they are logically compatible. For
+ example, the smallint-versus-integer
+ equality operator is merge-joinable.
+ We only need sorting operators that will bring both data types into a
+ logically compatible sequence.
+
+ To be marked MERGES, the join operator must appear
+ as an equality member of a btree index operator family.
+ This is not enforced when you create
+ the operator, since of course the referencing operator family couldn't
+ exist yet. But the operator will not actually be used for merge joins
+ unless a matching operator family can be found. The
+ MERGES flag thus acts as a hint to the planner that
+ it's worth looking for a matching operator family.
+
+ A merge-joinable operator must have a commutator (itself if the two
+ operand data types are the same, or a related equality operator
+ if they are different) that appears in the same operator family.
+ If this is not the case, planner errors might occur when the operator
+ is used. Also, it is a good idea (but not strictly required) for
+ a btree operator family that supports multiple data types to provide
+ equality operators for every combination of the data types; this
+ allows better optimization.
+
Note
+ The function underlying a merge-joinable operator must be marked
+ immutable or stable. If it is volatile, the system will never
+ attempt to use the operator for a merge join.
+
38.14. User-Defined Operators #
+ Every operator is “syntactic sugar” for a call to an
+ underlying function that does the real work; so you must
+ first create the underlying function before you can create
+ the operator. However, an operator is not merely
+ syntactic sugar, because it carries additional information
+ that helps the query planner optimize queries that use the
+ operator. The next section will be devoted to explaining
+ that additional information.
+
+ PostgreSQL supports prefix
+ and infix operators. Operators can be
+ overloaded;
+ that is, the same operator name can be used for different operators
+ that have different numbers and types of operands. When a query is
+ executed, the system determines the operator to call from the
+ number and types of the provided operands.
+
+ Here is an example of creating an operator for adding two complex
+ numbers. We assume we've already created the definition of type
+ complex (see Section 38.13). First we need a
+ function that does the work, then we can define the operator:
+
+
+CREATE FUNCTION complex_add(complex, complex)
+ RETURNS complex
+ AS 'filename', 'complex_add'
+ LANGUAGE C IMMUTABLE STRICT;
+
+CREATE OPERATOR + (
+ leftarg = complex,
+ rightarg = complex,
+ function = complex_add,
+ commutator = +
+);
+
+
+ Now we could execute a query like this:
+
+
+SELECT (a + b) AS c FROM test_complex;
+
+ c
+-----------------
+ (5.2,6.05)
+ (133.42,144.95)
+
+
+ We've shown how to create a binary operator here. To create a prefix
+ operator, just omit the leftarg.
+ The function
+ clause and the argument clauses are the only required items in
+ CREATE OPERATOR. The commutator
+ clause shown in the example is an optional hint to the query
+ optimizer. Further details about commutator and other
+ optimizer hints appear in the next section.
+
42.1. Installing Procedural Languages #
+ A procedural language must be “installed” into each
+ database where it is to be used. But procedural languages installed in
+ the database template1 are automatically available in all
+ subsequently created databases, since their entries in
+ template1 will be copied by CREATE DATABASE.
+ So the database administrator can
+ decide which languages are available in which databases and can make
+ some languages available by default if desired.
+
+ For the languages supplied with the standard distribution, it is
+ only necessary to execute CREATE EXTENSION
+ language_name to install the language into the
+ current database.
+ The manual procedure described below is only recommended for
+ installing languages that have not been packaged as extensions.
+
Manual Procedural Language Installation
+ A procedural language is installed in a database in five steps,
+ which must be carried out by a database superuser. In most cases
+ the required SQL commands should be packaged as the installation script
+ of an “extension”, so that CREATE EXTENSION can be
+ used to execute them.
+
+ The shared object for the language handler must be compiled and
+ installed into an appropriate library directory. This works in the same
+ way as building and installing modules with regular user-defined C
+ functions does; see Section 38.10.5. Often, the language
+ handler will depend on an external library that provides the actual
+ programming language engine; if so, that must be installed as well.
+
+ The handler must be declared with the command
+
+CREATE FUNCTION handler_function_name()
+ RETURNS language_handler
+ AS 'path-to-shared-object'
+ LANGUAGE C;
+
+ The special return type of language_handler tells
+ the database system that this function does not return one of
+ the defined SQL data types and is not directly usable
+ in SQL statements.
+
+ Optionally, the language handler can provide an “inline”
+ handler function that executes anonymous code blocks
+ (DO commands)
+ written in this language. If an inline handler function
+ is provided by the language, declare it with a command like
+
+CREATE FUNCTION inline_function_name(internal)
+ RETURNS void
+ AS 'path-to-shared-object'
+ LANGUAGE C;
+
+
+ Optionally, the language handler can provide a “validator”
+ function that checks a function definition for correctness without
+ actually executing it. The validator function is called by
+ CREATE FUNCTION if it exists. If a validator function
+ is provided by the language, declare it with a command like
+
+CREATE FUNCTION validator_function_name(oid)
+ RETURNS void
+ AS 'path-to-shared-object'
+ LANGUAGE C STRICT;
+
+
+ Finally, the PL must be declared with the command
+
+CREATE [TRUSTED] LANGUAGE language_name
+ HANDLER handler_function_name
+ [INLINE inline_function_name]
+ [VALIDATOR validator_function_name] ;
+
+ The optional key word TRUSTED specifies that
+ the language does not grant access to data that the user would
+ not otherwise have. Trusted languages are designed for ordinary
+ database users (those without superuser privilege) and allows them
+ to safely create functions and
+ procedures. Since PL functions are executed inside the database
+ server, the TRUSTED flag should only be given
+ for languages that do not allow access to database server
+ internals or the file system. The languages
+ PL/pgSQL,
+ PL/Tcl, and
+ PL/Perl
+ are considered trusted; the languages
+ PL/TclU,
+ PL/PerlU, and
+ PL/PythonU
+ are designed to provide unlimited functionality and should
+ not be marked trusted.
+
+ Example 42.1 shows how the manual
+ installation procedure would work with the language
+ PL/Perl.
+
Example 42.1. Manual Installation of PL/Perl
+ The following command tells the database server where to find the
+ shared object for the PL/Perl language's call
+ handler function:
+
+
+CREATE FUNCTION plperl_call_handler() RETURNS language_handler AS
+ '$libdir/plperl' LANGUAGE C;
+
+
+ PL/Perl has an inline handler function
+ and a validator function, so we declare those too:
+
+
+CREATE FUNCTION plperl_inline_handler(internal) RETURNS void AS
+ '$libdir/plperl' LANGUAGE C STRICT;
+
+CREATE FUNCTION plperl_validator(oid) RETURNS void AS
+ '$libdir/plperl' LANGUAGE C STRICT;
+
+
+ The command:
+
+CREATE TRUSTED LANGUAGE plperl
+ HANDLER plperl_call_handler
+ INLINE plperl_inline_handler
+ VALIDATOR plperl_validator;
+
+ then defines that the previously declared functions
+ should be invoked for functions and procedures where the
+ language attribute is plperl.
+
+ In a default PostgreSQL installation,
+ the handler for the PL/pgSQL language
+ is built and installed into the “library”
+ directory; furthermore, the PL/pgSQL language
+ itself is installed in all databases.
+ If Tcl support is configured in, the handlers for
+ PL/Tcl and PL/TclU are built and installed
+ in the library directory, but the language itself is not installed in any
+ database by default.
+ Likewise, the PL/Perl and PL/PerlU
+ handlers are built and installed if Perl support is configured, and the
+ PL/PythonU handler is installed if Python support is
+ configured, but these languages are not installed by default.
+
Chapter 42. Procedural Languages
+ PostgreSQL allows user-defined functions
+ to be written in other languages besides SQL and C. These other
+ languages are generically called procedural
+ languages (PLs). For a function
+ written in a procedural language, the database server has
+ no built-in knowledge about how to interpret the function's source
+ text. Instead, the task is passed to a special handler that knows
+ the details of the language. The handler could either do all the
+ work of parsing, syntax analysis, execution, etc. itself, or it
+ could serve as “glue” between
+ PostgreSQL and an existing implementation
+ of a programming language. The handler itself is a
+ C language function compiled into a shared object and
+ loaded on demand, just like any other C function.
+
+ There are currently four procedural languages available in the
+ standard PostgreSQL distribution:
+ PL/pgSQL (Chapter 43),
+ PL/Tcl (Chapter 44),
+ PL/Perl (Chapter 45), and
+ PL/Python (Chapter 46).
+ There are additional procedural languages available that are not
+ included in the core distribution. Appendix H
+ has information about finding them. In addition other languages can
+ be defined by users; the basics of developing a new procedural
+ language are covered in Chapter 58.
+
38.4. User-Defined Procedures #
+ A procedure is a database object similar to a function.
+ The key differences are:
+
+
+ Procedures are defined with
+ the CREATE
+ PROCEDURE command, not CREATE
+ FUNCTION.
+
+ Procedures do not return a function value; hence CREATE
+ PROCEDURE lacks a RETURNS clause.
+ However, procedures can instead return data to their callers via
+ output parameters.
+
+ While a function is called as part of a query or DML command, a
+ procedure is called in isolation using
+ the CALL command.
+
+ A procedure can commit or roll back transactions during its
+ execution (then automatically beginning a new transaction), so long
+ as the invoking CALL command is not part of an
+ explicit transaction block. A function cannot do that.
+
+ Certain function attributes, such as strictness, don't apply to
+ procedures. Those attributes control how the function is
+ used in a query, which isn't relevant to procedures.
+
+
+ The explanations in the following sections about how to define
+ user-defined functions apply to procedures as well, except for the
+ points made above.
+
+ Collectively, functions and procedures are also known
+ as routines.
+ There are commands such as ALTER ROUTINE
+ and DROP ROUTINE that can operate on functions and
+ procedures without having to know which kind it is. Note, however, that
+ there is no CREATE ROUTINE command.
+
38.13. User-Defined Types #
+ As described in Section 38.2,
+ PostgreSQL can be extended to support new
+ data types. This section describes how to define new base types,
+ which are data types defined below the level of the SQL
+ language. Creating a new base type requires implementing functions
+ to operate on the type in a low-level language, usually C.
+
+ The examples in this section can be found in
+ complex.sql and complex.c
+ in the src/tutorial directory of the source distribution.
+ See the README file in that directory for instructions
+ about running the examples.
+
+
+
+ A user-defined type must always have input and output functions.
+ These functions determine how the type appears in strings (for input
+ by the user and output to the user) and how the type is organized in
+ memory. The input function takes a null-terminated character string
+ as its argument and returns the internal (in memory) representation
+ of the type. The output function takes the internal representation
+ of the type as argument and returns a null-terminated character
+ string. If we want to do anything more with the type than merely
+ store it, we must provide additional functions to implement whatever
+ operations we'd like to have for the type.
+
+ Suppose we want to define a type complex that represents
+ complex numbers. A natural way to represent a complex number in
+ memory would be the following C structure:
+
+
+typedef struct Complex {
+ double x;
+ double y;
+} Complex;
+
+
+ We will need to make this a pass-by-reference type, since it's too
+ large to fit into a single Datum value.
+
+ As the external string representation of the type, we choose a
+ string of the form (x,y).
+
+ The input and output functions are usually not hard to write,
+ especially the output function. But when defining the external
+ string representation of the type, remember that you must eventually
+ write a complete and robust parser for that representation as your
+ input function. For instance:
+
+
+PG_FUNCTION_INFO_V1(complex_in);
+
+Datum
+complex_in(PG_FUNCTION_ARGS)
+{
+ char *str = PG_GETARG_CSTRING(0);
+ double x,
+ y;
+ Complex *result;
+
+ if (sscanf(str, " ( %lf , %lf )", &x, &y) != 2)
+ ereport(ERROR,
+ (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
+ errmsg("invalid input syntax for type %s: \"%s\"",
+ "complex", str)));
+
+ result = (Complex *) palloc(sizeof(Complex));
+ result->x = x;
+ result->y = y;
+ PG_RETURN_POINTER(result);
+}
+
+
+
+ The output function can simply be:
+
+
+PG_FUNCTION_INFO_V1(complex_out);
+
+Datum
+complex_out(PG_FUNCTION_ARGS)
+{
+ Complex *complex = (Complex *) PG_GETARG_POINTER(0);
+ char *result;
+
+ result = psprintf("(%g,%g)", complex->x, complex->y);
+ PG_RETURN_CSTRING(result);
+}
+
+
+
+ You should be careful to make the input and output functions inverses of
+ each other. If you do not, you will have severe problems when you
+ need to dump your data into a file and then read it back in. This
+ is a particularly common problem when floating-point numbers are
+ involved.
+
+ Optionally, a user-defined type can provide binary input and output
+ routines. Binary I/O is normally faster but less portable than textual
+ I/O. As with textual I/O, it is up to you to define exactly what the
+ external binary representation is. Most of the built-in data types
+ try to provide a machine-independent binary representation. For
+ complex, we will piggy-back on the binary I/O converters
+ for type float8:
+
+
+PG_FUNCTION_INFO_V1(complex_recv);
+
+Datum
+complex_recv(PG_FUNCTION_ARGS)
+{
+ StringInfo buf = (StringInfo) PG_GETARG_POINTER(0);
+ Complex *result;
+
+ result = (Complex *) palloc(sizeof(Complex));
+ result->x = pq_getmsgfloat8(buf);
+ result->y = pq_getmsgfloat8(buf);
+ PG_RETURN_POINTER(result);
+}
+
+PG_FUNCTION_INFO_V1(complex_send);
+
+Datum
+complex_send(PG_FUNCTION_ARGS)
+{
+ Complex *complex = (Complex *) PG_GETARG_POINTER(0);
+ StringInfoData buf;
+
+ pq_begintypsend(&buf);
+ pq_sendfloat8(&buf, complex->x);
+ pq_sendfloat8(&buf, complex->y);
+ PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
+}
+
+
+
+ Once we have written the I/O functions and compiled them into a shared
+ library, we can define the complex type in SQL.
+ First we declare it as a shell type:
+
+
+CREATE TYPE complex;
+
+
+ This serves as a placeholder that allows us to reference the type while
+ defining its I/O functions. Now we can define the I/O functions:
+
+
+CREATE FUNCTION complex_in(cstring)
+ RETURNS complex
+ AS 'filename'
+ LANGUAGE C IMMUTABLE STRICT;
+
+CREATE FUNCTION complex_out(complex)
+ RETURNS cstring
+ AS 'filename'
+ LANGUAGE C IMMUTABLE STRICT;
+
+CREATE FUNCTION complex_recv(internal)
+ RETURNS complex
+ AS 'filename'
+ LANGUAGE C IMMUTABLE STRICT;
+
+CREATE FUNCTION complex_send(complex)
+ RETURNS bytea
+ AS 'filename'
+ LANGUAGE C IMMUTABLE STRICT;
+
+
+ Finally, we can provide the full definition of the data type:
+
+CREATE TYPE complex (
+ internallength = 16,
+ input = complex_in,
+ output = complex_out,
+ receive = complex_recv,
+ send = complex_send,
+ alignment = double
+);
+
+
+
+ When you define a new base type,
+ PostgreSQL automatically provides support
+ for arrays of that type. The array type typically
+ has the same name as the base type with the underscore character
+ (_) prepended.
+
+ Once the data type exists, we can declare additional functions to
+ provide useful operations on the data type. Operators can then be
+ defined atop the functions, and if needed, operator classes can be
+ created to support indexing of the data type. These additional
+ layers are discussed in following sections.
+
+ If the internal representation of the data type is variable-length, the
+ internal representation must follow the standard layout for variable-length
+ data: the first four bytes must be a char[4] field which is
+ never accessed directly (customarily named vl_len_). You
+ must use the SET_VARSIZE() macro to store the total
+ size of the datum (including the length field itself) in this field
+ and VARSIZE() to retrieve it. (These macros exist
+ because the length field may be encoded depending on platform.)
+
+ For further details see the description of the
+ CREATE TYPE command.
+
38.13.1. TOAST Considerations #
+ If the values of your data type vary in size (in internal form), it's
+ usually desirable to make the data type TOAST-able (see Section 73.2). You should do this even if the values are always
+ too small to be compressed or stored externally, because
+ TOAST can save space on small data too, by reducing header
+ overhead.
+
+ To support TOAST storage, the C functions operating on the data
+ type must always be careful to unpack any toasted values they are handed
+ by using PG_DETOAST_DATUM. (This detail is customarily hidden
+ by defining type-specific GETARG_DATATYPE_P macros.)
+ Then, when running the CREATE TYPE command, specify the
+ internal length as variable and select some appropriate storage
+ option other than plain.
+
+ If data alignment is unimportant (either just for a specific function or
+ because the data type specifies byte alignment anyway) then it's possible
+ to avoid some of the overhead of PG_DETOAST_DATUM. You can use
+ PG_DETOAST_DATUM_PACKED instead (customarily hidden by
+ defining a GETARG_DATATYPE_PP macro) and using the macros
+ VARSIZE_ANY_EXHDR and VARDATA_ANY to access
+ a potentially-packed datum.
+ Again, the data returned by these macros is not aligned even if the data
+ type definition specifies an alignment. If the alignment is important you
+ must go through the regular PG_DETOAST_DATUM interface.
+
Note
+ Older code frequently declares vl_len_ as an
+ int32 field instead of char[4]. This is OK as long as
+ the struct definition has other fields that have at least int32
+ alignment. But it is dangerous to use such a struct definition when
+ working with a potentially unaligned datum; the compiler may take it as
+ license to assume the datum actually is aligned, leading to core dumps on
+ architectures that are strict about alignment.
+
+ Another feature that's enabled by TOAST support is the
+ possibility of having an expanded in-memory data
+ representation that is more convenient to work with than the format that
+ is stored on disk. The regular or “flat” varlena storage format
+ is ultimately just a blob of bytes; it cannot for example contain
+ pointers, since it may get copied to other locations in memory.
+ For complex data types, the flat format may be quite expensive to work
+ with, so PostgreSQL provides a way to “expand”
+ the flat format into a representation that is more suited to computation,
+ and then pass that format in-memory between functions of the data type.
+
+ To use expanded storage, a data type must define an expanded format that
+ follows the rules given in src/include/utils/expandeddatum.h,
+ and provide functions to “expand” a flat varlena value into
+ expanded format and “flatten” the expanded format back to the
+ regular varlena representation. Then ensure that all C functions for
+ the data type can accept either representation, possibly by converting
+ one into the other immediately upon receipt. This does not require fixing
+ all existing functions for the data type at once, because the standard
+ PG_DETOAST_DATUM macro is defined to convert expanded inputs
+ into regular flat format. Therefore, existing functions that work with
+ the flat varlena format will continue to work, though slightly
+ inefficiently, with expanded inputs; they need not be converted until and
+ unless better performance is important.
+
+ C functions that know how to work with an expanded representation
+ typically fall into two categories: those that can only handle expanded
+ format, and those that can handle either expanded or flat varlena inputs.
+ The former are easier to write but may be less efficient overall, because
+ converting a flat input to expanded form for use by a single function may
+ cost more than is saved by operating on the expanded format.
+ When only expanded format need be handled, conversion of flat inputs to
+ expanded form can be hidden inside an argument-fetching macro, so that
+ the function appears no more complex than one working with traditional
+ varlena input.
+ To handle both types of input, write an argument-fetching function that
+ will detoast external, short-header, and compressed varlena inputs, but
+ not expanded inputs. Such a function can be defined as returning a
+ pointer to a union of the flat varlena format and the expanded format.
+ Callers can use the VARATT_IS_EXPANDED_HEADER() macro to
+ determine which format they received.
+
+ The TOAST infrastructure not only allows regular varlena
+ values to be distinguished from expanded values, but also
+ distinguishes “read-write” and “read-only” pointers to
+ expanded values. C functions that only need to examine an expanded
+ value, or will only change it in safe and non-semantically-visible ways,
+ need not care which type of pointer they receive. C functions that
+ produce a modified version of an input value are allowed to modify an
+ expanded input value in-place if they receive a read-write pointer, but
+ must not modify the input if they receive a read-only pointer; in that
+ case they have to copy the value first, producing a new value to modify.
+ A C function that has constructed a new expanded value should always
+ return a read-write pointer to it. Also, a C function that is modifying
+ a read-write expanded value in-place should take care to leave the value
+ in a sane state if it fails partway through.
+
+ For examples of working with expanded values, see the standard array
+ infrastructure, particularly
+ src/backend/utils/adt/array_expanded.c.
+
corepack
+
+[](https://slack-invite.openjsf.org/)
+
+Corepack is a zero-runtime-dependency Node.js script that acts as a bridge
+between Node.js projects and the package managers they are intended to be used
+with during development. In practical terms, **Corepack lets you use Yarn, npm,
+and pnpm without having to install them**.
+
+## How to Install
+
+### Default Installs
+
+Corepack is distributed with Node.js from version 14.19.0 up to (but not including) 25.0.0.
+Run `corepack enable` to install the required Yarn and pnpm binaries on your path.
+
+### Manual Installs
+
+