rdelaage
/
postgresql
mirror of https://git.postgresql.org/git/postgresql.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
postgresql/src/include/catalog/pg_proc.dat

10105 lines
505 KiB
Plaintext
Raw Normal View History

Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
#----------------------------------------------------------------------
#
# pg_proc.dat
Improve consistency of comments in system catalog headers. Use the term "system catalog" rather than "system relation" in assorted places where it's clearly referring to a table rather than, say, an index. Use more natural word order in the header boilerplate, improve some of the one-liner catalog descriptions, and fix assorted random deviations from the normal boilerplate. All purely neatnik-ism, but why not. John Naylor, some additional cleanup by me Discussion: https://postgr.es/m/CAJVSVGUeJmFB3h-NJ18P32NPa+kzC165nm7GSoGHfPaN80Wxcw@mail.gmail.com
2018-04-19 23:14:09 +02:00
# Initial contents of the pg_proc system catalog.
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
#
# Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
# Portions Copyright (c) 1994, Regents of the University of California
#
# src/include/catalog/pg_proc.dat
#
#----------------------------------------------------------------------
[
# Note: every entry in pg_proc.dat is expected to have a 'descr' comment,
# except for functions that implement pg_operator.dat operators and don't
# have a good reason to be called directly rather than via the operator.
# (If you do expect such a function to be used directly, you should
# duplicate the operator's comment.) initdb will supply suitable default
# comments for functions referenced by pg_operator.
# Try to follow the style of existing functions' comments.
# Some recommended conventions:
# "I/O" for typinput, typoutput, typreceive, typsend functions
# "I/O typmod" for typmodin, typmodout functions
# "aggregate transition function" for aggtransfn functions, unless
# they are reasonably useful in their own right
# "aggregate final function" for aggfinalfn functions (likewise)
# "convert srctypename to desttypename" for cast functions
# "less-equal-greater" for B-tree comparison functions
Clarify handling of special-case values in bootstrap catalog data. I (tgl) originally coded the special case for pg_proc.pronargs as though it were a kind of default value. It seems better though to treat computable columns as an independent concern: this makes the code clearer, and probably a bit faster too since we needn't do work inside the per-column loop. Improve related comments, as well, in the expectation that there might be more cases like this in future. John Naylor, some additional comment-hacking by me Discussion: https://postgr.es/m/CAJVSVGW-D7OobzU=dybVT2JqZAx-4X1yvBJdavBmqQL05Q6CLw@mail.gmail.com
2018-04-28 21:27:16 +02:00
# Note: pronargs is computed when this file is read, so it does not need
# to be specified in entries here. See AddDefaultValues() in Catalog.pm.
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
# Once upon a time these entries were ordered by OID. Lately it's often
# been the custom to insert new entries adjacent to related older entries.
# Try to do one or the other though, don't just insert entries at random.
# OIDS 1 - 99
{ oid => '1242', descr => 'I/O',
proname => 'boolin', prorettype => 'bool', proargtypes => 'cstring',
prosrc => 'boolin' },
{ oid => '1243', descr => 'I/O',
proname => 'boolout', prorettype => 'cstring', proargtypes => 'bool',
prosrc => 'boolout' },
{ oid => '1244', descr => 'I/O',
proname => 'byteain', prorettype => 'bytea', proargtypes => 'cstring',
prosrc => 'byteain' },
{ oid => '31', descr => 'I/O',
proname => 'byteaout', prorettype => 'cstring', proargtypes => 'bytea',
prosrc => 'byteaout' },
{ oid => '1245', descr => 'I/O',
proname => 'charin', prorettype => 'char', proargtypes => 'cstring',
prosrc => 'charin' },
{ oid => '33', descr => 'I/O',
proname => 'charout', prorettype => 'cstring', proargtypes => 'char',
prosrc => 'charout' },
{ oid => '34', descr => 'I/O',
proname => 'namein', prorettype => 'name', proargtypes => 'cstring',
prosrc => 'namein' },
{ oid => '35', descr => 'I/O',
proname => 'nameout', prorettype => 'cstring', proargtypes => 'name',
prosrc => 'nameout' },
{ oid => '38', descr => 'I/O',
proname => 'int2in', prorettype => 'int2', proargtypes => 'cstring',
prosrc => 'int2in' },
{ oid => '39', descr => 'I/O',
proname => 'int2out', prorettype => 'cstring', proargtypes => 'int2',
prosrc => 'int2out' },
{ oid => '40', descr => 'I/O',
proname => 'int2vectorin', prorettype => 'int2vector',
proargtypes => 'cstring', prosrc => 'int2vectorin' },
{ oid => '41', descr => 'I/O',
proname => 'int2vectorout', prorettype => 'cstring',
proargtypes => 'int2vector', prosrc => 'int2vectorout' },
{ oid => '42', descr => 'I/O',
proname => 'int4in', prorettype => 'int4', proargtypes => 'cstring',
prosrc => 'int4in' },
{ oid => '43', descr => 'I/O',
proname => 'int4out', prorettype => 'cstring', proargtypes => 'int4',
prosrc => 'int4out' },
{ oid => '44', descr => 'I/O',
proname => 'regprocin', provolatile => 's', prorettype => 'regproc',
proargtypes => 'cstring', prosrc => 'regprocin' },
{ oid => '45', descr => 'I/O',
proname => 'regprocout', provolatile => 's', prorettype => 'cstring',
proargtypes => 'regproc', prosrc => 'regprocout' },
{ oid => '3494', descr => 'convert proname to regproc',
proname => 'to_regproc', provolatile => 's', prorettype => 'regproc',
proargtypes => 'text', prosrc => 'to_regproc' },
{ oid => '3479', descr => 'convert proname to regprocedure',
proname => 'to_regprocedure', provolatile => 's',
prorettype => 'regprocedure', proargtypes => 'text',
prosrc => 'to_regprocedure' },
{ oid => '46', descr => 'I/O',
proname => 'textin', prorettype => 'text', proargtypes => 'cstring',
prosrc => 'textin' },
{ oid => '47', descr => 'I/O',
proname => 'textout', prorettype => 'cstring', proargtypes => 'text',
prosrc => 'textout' },
{ oid => '48', descr => 'I/O',
proname => 'tidin', prorettype => 'tid', proargtypes => 'cstring',
prosrc => 'tidin' },
{ oid => '49', descr => 'I/O',
proname => 'tidout', prorettype => 'cstring', proargtypes => 'tid',
prosrc => 'tidout' },
{ oid => '50', descr => 'I/O',
proname => 'xidin', prorettype => 'xid', proargtypes => 'cstring',
prosrc => 'xidin' },
{ oid => '51', descr => 'I/O',
proname => 'xidout', prorettype => 'cstring', proargtypes => 'xid',
prosrc => 'xidout' },
{ oid => '52', descr => 'I/O',
proname => 'cidin', prorettype => 'cid', proargtypes => 'cstring',
prosrc => 'cidin' },
{ oid => '53', descr => 'I/O',
proname => 'cidout', prorettype => 'cstring', proargtypes => 'cid',
prosrc => 'cidout' },
{ oid => '54', descr => 'I/O',
proname => 'oidvectorin', prorettype => 'oidvector', proargtypes => 'cstring',
prosrc => 'oidvectorin' },
{ oid => '55', descr => 'I/O',
proname => 'oidvectorout', prorettype => 'cstring',
proargtypes => 'oidvector', prosrc => 'oidvectorout' },
{ oid => '56',
proname => 'boollt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'bool bool', prosrc => 'boollt' },
{ oid => '57',
proname => 'boolgt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'bool bool', prosrc => 'boolgt' },
{ oid => '60',
proname => 'booleq', proleakproof => 't', prorettype => 'bool',
proargtypes => 'bool bool', prosrc => 'booleq' },
{ oid => '61',
proname => 'chareq', proleakproof => 't', prorettype => 'bool',
proargtypes => 'char char', prosrc => 'chareq' },
{ oid => '62',
proname => 'nameeq', proleakproof => 't', prorettype => 'bool',
proargtypes => 'name name', prosrc => 'nameeq' },
{ oid => '63',
proname => 'int2eq', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int2 int2', prosrc => 'int2eq' },
{ oid => '64',
proname => 'int2lt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int2 int2', prosrc => 'int2lt' },
{ oid => '65',
proname => 'int4eq', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int4 int4', prosrc => 'int4eq' },
{ oid => '66',
proname => 'int4lt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int4 int4', prosrc => 'int4lt' },
{ oid => '67',
proname => 'texteq', proleakproof => 't', prorettype => 'bool',
proargtypes => 'text text', prosrc => 'texteq' },
{ oid => '3696',
proname => 'starts_with', proleakproof => 't', prorettype => 'bool',
proargtypes => 'text text', prosrc => 'text_starts_with' },
{ oid => '68',
proname => 'xideq', proleakproof => 't', prorettype => 'bool',
proargtypes => 'xid xid', prosrc => 'xideq' },
{ oid => '3308',
proname => 'xidneq', proleakproof => 't', prorettype => 'bool',
proargtypes => 'xid xid', prosrc => 'xidneq' },
{ oid => '69',
proname => 'cideq', proleakproof => 't', prorettype => 'bool',
proargtypes => 'cid cid', prosrc => 'cideq' },
{ oid => '70',
proname => 'charne', proleakproof => 't', prorettype => 'bool',
proargtypes => 'char char', prosrc => 'charne' },
{ oid => '1246',
proname => 'charlt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'char char', prosrc => 'charlt' },
{ oid => '72',
proname => 'charle', proleakproof => 't', prorettype => 'bool',
proargtypes => 'char char', prosrc => 'charle' },
{ oid => '73',
proname => 'chargt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'char char', prosrc => 'chargt' },
{ oid => '74',
proname => 'charge', proleakproof => 't', prorettype => 'bool',
proargtypes => 'char char', prosrc => 'charge' },
{ oid => '77', descr => 'convert char to int4',
proname => 'int4', prorettype => 'int4', proargtypes => 'char',
prosrc => 'chartoi4' },
{ oid => '78', descr => 'convert int4 to char',
proname => 'char', prorettype => 'char', proargtypes => 'int4',
prosrc => 'i4tochar' },
{ oid => '79',
proname => 'nameregexeq', prorettype => 'bool', proargtypes => 'name text',
prosrc => 'nameregexeq' },
{ oid => '1252',
proname => 'nameregexne', prorettype => 'bool', proargtypes => 'name text',
prosrc => 'nameregexne' },
{ oid => '1254',
proname => 'textregexeq', prorettype => 'bool', proargtypes => 'text text',
prosrc => 'textregexeq' },
{ oid => '1256',
proname => 'textregexne', prorettype => 'bool', proargtypes => 'text text',
prosrc => 'textregexne' },
{ oid => '1257', descr => 'length',
proname => 'textlen', prorettype => 'int4', proargtypes => 'text',
prosrc => 'textlen' },
{ oid => '1258',
proname => 'textcat', prorettype => 'text', proargtypes => 'text text',
prosrc => 'textcat' },
{ oid => '84',
proname => 'boolne', proleakproof => 't', prorettype => 'bool',
proargtypes => 'bool bool', prosrc => 'boolne' },
{ oid => '89', descr => 'PostgreSQL version string',
proname => 'version', provolatile => 's', prorettype => 'text',
proargtypes => '', prosrc => 'pgsql_version' },
{ oid => '86', descr => 'I/O',
proname => 'pg_ddl_command_in', prorettype => 'pg_ddl_command',
proargtypes => 'cstring', prosrc => 'pg_ddl_command_in' },
{ oid => '87', descr => 'I/O',
proname => 'pg_ddl_command_out', prorettype => 'cstring',
proargtypes => 'pg_ddl_command', prosrc => 'pg_ddl_command_out' },
{ oid => '88', descr => 'I/O',
proname => 'pg_ddl_command_recv', prorettype => 'pg_ddl_command',
proargtypes => 'internal', prosrc => 'pg_ddl_command_recv' },
{ oid => '90', descr => 'I/O',
proname => 'pg_ddl_command_send', prorettype => 'bytea',
proargtypes => 'pg_ddl_command', prosrc => 'pg_ddl_command_send' },
# OIDS 100 - 199
{ oid => '101', descr => 'restriction selectivity of = and related operators',
proname => 'eqsel', provolatile => 's', prorettype => 'float8',
proargtypes => 'internal oid internal int4', prosrc => 'eqsel' },
{ oid => '102',
descr => 'restriction selectivity of <> and related operators',
proname => 'neqsel', provolatile => 's', prorettype => 'float8',
proargtypes => 'internal oid internal int4', prosrc => 'neqsel' },
{ oid => '103',
descr => 'restriction selectivity of < and related operators on scalar datatypes',
proname => 'scalarltsel', provolatile => 's', prorettype => 'float8',
proargtypes => 'internal oid internal int4', prosrc => 'scalarltsel' },
{ oid => '104',
descr => 'restriction selectivity of > and related operators on scalar datatypes',
proname => 'scalargtsel', provolatile => 's', prorettype => 'float8',
proargtypes => 'internal oid internal int4', prosrc => 'scalargtsel' },
{ oid => '105', descr => 'join selectivity of = and related operators',
proname => 'eqjoinsel', provolatile => 's', prorettype => 'float8',
proargtypes => 'internal oid internal int2 internal', prosrc => 'eqjoinsel' },
{ oid => '106', descr => 'join selectivity of <> and related operators',
proname => 'neqjoinsel', provolatile => 's', prorettype => 'float8',
proargtypes => 'internal oid internal int2 internal',
prosrc => 'neqjoinsel' },
{ oid => '107',
descr => 'join selectivity of < and related operators on scalar datatypes',
proname => 'scalarltjoinsel', provolatile => 's', prorettype => 'float8',
proargtypes => 'internal oid internal int2 internal',
prosrc => 'scalarltjoinsel' },
{ oid => '108',
descr => 'join selectivity of > and related operators on scalar datatypes',
proname => 'scalargtjoinsel', provolatile => 's', prorettype => 'float8',
proargtypes => 'internal oid internal int2 internal',
prosrc => 'scalargtjoinsel' },
{ oid => '336',
descr => 'restriction selectivity of <= and related operators on scalar datatypes',
proname => 'scalarlesel', provolatile => 's', prorettype => 'float8',
proargtypes => 'internal oid internal int4', prosrc => 'scalarlesel' },
{ oid => '337',
descr => 'restriction selectivity of >= and related operators on scalar datatypes',
proname => 'scalargesel', provolatile => 's', prorettype => 'float8',
proargtypes => 'internal oid internal int4', prosrc => 'scalargesel' },
{ oid => '386',
descr => 'join selectivity of <= and related operators on scalar datatypes',
proname => 'scalarlejoinsel', provolatile => 's', prorettype => 'float8',
proargtypes => 'internal oid internal int2 internal',
prosrc => 'scalarlejoinsel' },
{ oid => '398',
descr => 'join selectivity of >= and related operators on scalar datatypes',
proname => 'scalargejoinsel', provolatile => 's', prorettype => 'float8',
proargtypes => 'internal oid internal int2 internal',
prosrc => 'scalargejoinsel' },
{ oid => '109', descr => 'I/O',
proname => 'unknownin', prorettype => 'unknown', proargtypes => 'cstring',
prosrc => 'unknownin' },
{ oid => '110', descr => 'I/O',
proname => 'unknownout', prorettype => 'cstring', proargtypes => 'unknown',
prosrc => 'unknownout' },
{ oid => '111',
proname => 'numeric_fac', prorettype => 'numeric', proargtypes => 'int8',
prosrc => 'numeric_fac' },
{ oid => '115',
proname => 'box_above_eq', prorettype => 'bool', proargtypes => 'box box',
prosrc => 'box_above_eq' },
{ oid => '116',
proname => 'box_below_eq', prorettype => 'bool', proargtypes => 'box box',
prosrc => 'box_below_eq' },
{ oid => '117', descr => 'I/O',
proname => 'point_in', prorettype => 'point', proargtypes => 'cstring',
prosrc => 'point_in' },
{ oid => '118', descr => 'I/O',
proname => 'point_out', prorettype => 'cstring', proargtypes => 'point',
prosrc => 'point_out' },
{ oid => '119', descr => 'I/O',
proname => 'lseg_in', prorettype => 'lseg', proargtypes => 'cstring',
prosrc => 'lseg_in' },
{ oid => '120', descr => 'I/O',
proname => 'lseg_out', prorettype => 'cstring', proargtypes => 'lseg',
prosrc => 'lseg_out' },
{ oid => '121', descr => 'I/O',
proname => 'path_in', prorettype => 'path', proargtypes => 'cstring',
prosrc => 'path_in' },
{ oid => '122', descr => 'I/O',
proname => 'path_out', prorettype => 'cstring', proargtypes => 'path',
prosrc => 'path_out' },
{ oid => '123', descr => 'I/O',
proname => 'box_in', prorettype => 'box', proargtypes => 'cstring',
prosrc => 'box_in' },
{ oid => '124', descr => 'I/O',
proname => 'box_out', prorettype => 'cstring', proargtypes => 'box',
prosrc => 'box_out' },
{ oid => '125',
proname => 'box_overlap', prorettype => 'bool', proargtypes => 'box box',
prosrc => 'box_overlap' },
{ oid => '126',
proname => 'box_ge', prorettype => 'bool', proargtypes => 'box box',
prosrc => 'box_ge' },
{ oid => '127',
proname => 'box_gt', prorettype => 'bool', proargtypes => 'box box',
prosrc => 'box_gt' },
{ oid => '128',
proname => 'box_eq', prorettype => 'bool', proargtypes => 'box box',
prosrc => 'box_eq' },
{ oid => '129',
proname => 'box_lt', prorettype => 'bool', proargtypes => 'box box',
prosrc => 'box_lt' },
{ oid => '130',
proname => 'box_le', prorettype => 'bool', proargtypes => 'box box',
prosrc => 'box_le' },
{ oid => '131',
proname => 'point_above', prorettype => 'bool', proargtypes => 'point point',
prosrc => 'point_above' },
{ oid => '132',
proname => 'point_left', prorettype => 'bool', proargtypes => 'point point',
prosrc => 'point_left' },
{ oid => '133',
proname => 'point_right', prorettype => 'bool', proargtypes => 'point point',
prosrc => 'point_right' },
{ oid => '134',
proname => 'point_below', prorettype => 'bool', proargtypes => 'point point',
prosrc => 'point_below' },
{ oid => '135',
proname => 'point_eq', prorettype => 'bool', proargtypes => 'point point',
prosrc => 'point_eq' },
{ oid => '136',
proname => 'on_pb', prorettype => 'bool', proargtypes => 'point box',
prosrc => 'on_pb' },
{ oid => '137',
proname => 'on_ppath', prorettype => 'bool', proargtypes => 'point path',
prosrc => 'on_ppath' },
{ oid => '138',
proname => 'box_center', prorettype => 'point', proargtypes => 'box',
prosrc => 'box_center' },
{ oid => '139',
descr => 'restriction selectivity for area-comparison operators',
proname => 'areasel', provolatile => 's', prorettype => 'float8',
proargtypes => 'internal oid internal int4', prosrc => 'areasel' },
{ oid => '140', descr => 'join selectivity for area-comparison operators',
proname => 'areajoinsel', provolatile => 's', prorettype => 'float8',
proargtypes => 'internal oid internal int2 internal',
prosrc => 'areajoinsel' },
{ oid => '141',
proname => 'int4mul', prorettype => 'int4', proargtypes => 'int4 int4',
prosrc => 'int4mul' },
{ oid => '144',
proname => 'int4ne', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int4 int4', prosrc => 'int4ne' },
{ oid => '145',
proname => 'int2ne', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int2 int2', prosrc => 'int2ne' },
{ oid => '146',
proname => 'int2gt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int2 int2', prosrc => 'int2gt' },
{ oid => '147',
proname => 'int4gt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int4 int4', prosrc => 'int4gt' },
{ oid => '148',
proname => 'int2le', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int2 int2', prosrc => 'int2le' },
{ oid => '149',
proname => 'int4le', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int4 int4', prosrc => 'int4le' },
{ oid => '150',
proname => 'int4ge', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int4 int4', prosrc => 'int4ge' },
{ oid => '151',
proname => 'int2ge', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int2 int2', prosrc => 'int2ge' },
{ oid => '152',
proname => 'int2mul', prorettype => 'int2', proargtypes => 'int2 int2',
prosrc => 'int2mul' },
{ oid => '153',
proname => 'int2div', prorettype => 'int2', proargtypes => 'int2 int2',
prosrc => 'int2div' },
{ oid => '154',
proname => 'int4div', prorettype => 'int4', proargtypes => 'int4 int4',
prosrc => 'int4div' },
{ oid => '155',
proname => 'int2mod', prorettype => 'int2', proargtypes => 'int2 int2',
prosrc => 'int2mod' },
{ oid => '156',
proname => 'int4mod', prorettype => 'int4', proargtypes => 'int4 int4',
prosrc => 'int4mod' },
{ oid => '157',
proname => 'textne', proleakproof => 't', prorettype => 'bool',
proargtypes => 'text text', prosrc => 'textne' },
{ oid => '158',
proname => 'int24eq', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int2 int4', prosrc => 'int24eq' },
{ oid => '159',
proname => 'int42eq', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int4 int2', prosrc => 'int42eq' },
{ oid => '160',
proname => 'int24lt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int2 int4', prosrc => 'int24lt' },
{ oid => '161',
proname => 'int42lt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int4 int2', prosrc => 'int42lt' },
{ oid => '162',
proname => 'int24gt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int2 int4', prosrc => 'int24gt' },
{ oid => '163',
proname => 'int42gt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int4 int2', prosrc => 'int42gt' },
{ oid => '164',
proname => 'int24ne', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int2 int4', prosrc => 'int24ne' },
{ oid => '165',
proname => 'int42ne', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int4 int2', prosrc => 'int42ne' },
{ oid => '166',
proname => 'int24le', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int2 int4', prosrc => 'int24le' },
{ oid => '167',
proname => 'int42le', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int4 int2', prosrc => 'int42le' },
{ oid => '168',
proname => 'int24ge', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int2 int4', prosrc => 'int24ge' },
{ oid => '169',
proname => 'int42ge', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int4 int2', prosrc => 'int42ge' },
{ oid => '170',
proname => 'int24mul', prorettype => 'int4', proargtypes => 'int2 int4',
prosrc => 'int24mul' },
{ oid => '171',
proname => 'int42mul', prorettype => 'int4', proargtypes => 'int4 int2',
prosrc => 'int42mul' },
{ oid => '172',
proname => 'int24div', prorettype => 'int4', proargtypes => 'int2 int4',
prosrc => 'int24div' },
{ oid => '173',
proname => 'int42div', prorettype => 'int4', proargtypes => 'int4 int2',
prosrc => 'int42div' },
{ oid => '176',
proname => 'int2pl', prorettype => 'int2', proargtypes => 'int2 int2',
prosrc => 'int2pl' },
{ oid => '177',
proname => 'int4pl', prorettype => 'int4', proargtypes => 'int4 int4',
prosrc => 'int4pl' },
{ oid => '178',
proname => 'int24pl', prorettype => 'int4', proargtypes => 'int2 int4',
prosrc => 'int24pl' },
{ oid => '179',
proname => 'int42pl', prorettype => 'int4', proargtypes => 'int4 int2',
prosrc => 'int42pl' },
{ oid => '180',
proname => 'int2mi', prorettype => 'int2', proargtypes => 'int2 int2',
prosrc => 'int2mi' },
{ oid => '181',
proname => 'int4mi', prorettype => 'int4', proargtypes => 'int4 int4',
prosrc => 'int4mi' },
{ oid => '182',
proname => 'int24mi', prorettype => 'int4', proargtypes => 'int2 int4',
prosrc => 'int24mi' },
{ oid => '183',
proname => 'int42mi', prorettype => 'int4', proargtypes => 'int4 int2',
prosrc => 'int42mi' },
{ oid => '184',
proname => 'oideq', proleakproof => 't', prorettype => 'bool',
proargtypes => 'oid oid', prosrc => 'oideq' },
{ oid => '185',
proname => 'oidne', proleakproof => 't', prorettype => 'bool',
proargtypes => 'oid oid', prosrc => 'oidne' },
{ oid => '186',
proname => 'box_same', prorettype => 'bool', proargtypes => 'box box',
prosrc => 'box_same' },
{ oid => '187',
proname => 'box_contain', prorettype => 'bool', proargtypes => 'box box',
prosrc => 'box_contain' },
{ oid => '188',
proname => 'box_left', prorettype => 'bool', proargtypes => 'box box',
prosrc => 'box_left' },
{ oid => '189',
proname => 'box_overleft', prorettype => 'bool', proargtypes => 'box box',
prosrc => 'box_overleft' },
{ oid => '190',
proname => 'box_overright', prorettype => 'bool', proargtypes => 'box box',
prosrc => 'box_overright' },
{ oid => '191',
proname => 'box_right', prorettype => 'bool', proargtypes => 'box box',
prosrc => 'box_right' },
{ oid => '192',
proname => 'box_contained', prorettype => 'bool', proargtypes => 'box box',
prosrc => 'box_contained' },
{ oid => '193',
proname => 'box_contain_pt', prorettype => 'bool', proargtypes => 'box point',
prosrc => 'box_contain_pt' },
{ oid => '195', descr => 'I/O',
proname => 'pg_node_tree_in', prorettype => 'pg_node_tree',
proargtypes => 'cstring', prosrc => 'pg_node_tree_in' },
{ oid => '196', descr => 'I/O',
proname => 'pg_node_tree_out', prorettype => 'cstring',
proargtypes => 'pg_node_tree', prosrc => 'pg_node_tree_out' },
{ oid => '197', descr => 'I/O',
proname => 'pg_node_tree_recv', provolatile => 's',
prorettype => 'pg_node_tree', proargtypes => 'internal',
prosrc => 'pg_node_tree_recv' },
{ oid => '198', descr => 'I/O',
proname => 'pg_node_tree_send', provolatile => 's', prorettype => 'bytea',
proargtypes => 'pg_node_tree', prosrc => 'pg_node_tree_send' },
# OIDS 200 - 299
{ oid => '200', descr => 'I/O',
proname => 'float4in', prorettype => 'float4', proargtypes => 'cstring',
prosrc => 'float4in' },
{ oid => '201', descr => 'I/O',
proname => 'float4out', prorettype => 'cstring', proargtypes => 'float4',
prosrc => 'float4out' },
{ oid => '202',
proname => 'float4mul', prorettype => 'float4',
proargtypes => 'float4 float4', prosrc => 'float4mul' },
{ oid => '203',
proname => 'float4div', prorettype => 'float4',
proargtypes => 'float4 float4', prosrc => 'float4div' },
{ oid => '204',
proname => 'float4pl', prorettype => 'float4', proargtypes => 'float4 float4',
prosrc => 'float4pl' },
{ oid => '205',
proname => 'float4mi', prorettype => 'float4', proargtypes => 'float4 float4',
prosrc => 'float4mi' },
{ oid => '206',
proname => 'float4um', prorettype => 'float4', proargtypes => 'float4',
prosrc => 'float4um' },
{ oid => '207',
proname => 'float4abs', prorettype => 'float4', proargtypes => 'float4',
prosrc => 'float4abs' },
{ oid => '208', descr => 'aggregate transition function',
proname => 'float4_accum', prorettype => '_float8',
proargtypes => '_float8 float4', prosrc => 'float4_accum' },
{ oid => '209', descr => 'larger of two',
proname => 'float4larger', prorettype => 'float4',
proargtypes => 'float4 float4', prosrc => 'float4larger' },
{ oid => '211', descr => 'smaller of two',
proname => 'float4smaller', prorettype => 'float4',
proargtypes => 'float4 float4', prosrc => 'float4smaller' },
{ oid => '212',
proname => 'int4um', prorettype => 'int4', proargtypes => 'int4',
prosrc => 'int4um' },
{ oid => '213',
proname => 'int2um', prorettype => 'int2', proargtypes => 'int2',
prosrc => 'int2um' },
{ oid => '214', descr => 'I/O',
proname => 'float8in', prorettype => 'float8', proargtypes => 'cstring',
prosrc => 'float8in' },
{ oid => '215', descr => 'I/O',
proname => 'float8out', prorettype => 'cstring', proargtypes => 'float8',
prosrc => 'float8out' },
{ oid => '216',
proname => 'float8mul', prorettype => 'float8',
proargtypes => 'float8 float8', prosrc => 'float8mul' },
{ oid => '217',
proname => 'float8div', prorettype => 'float8',
proargtypes => 'float8 float8', prosrc => 'float8div' },
{ oid => '218',
proname => 'float8pl', prorettype => 'float8', proargtypes => 'float8 float8',
prosrc => 'float8pl' },
{ oid => '219',
proname => 'float8mi', prorettype => 'float8', proargtypes => 'float8 float8',
prosrc => 'float8mi' },
{ oid => '220',
proname => 'float8um', prorettype => 'float8', proargtypes => 'float8',
prosrc => 'float8um' },
{ oid => '221',
proname => 'float8abs', prorettype => 'float8', proargtypes => 'float8',
prosrc => 'float8abs' },
{ oid => '222', descr => 'aggregate transition function',
proname => 'float8_accum', prorettype => '_float8',
proargtypes => '_float8 float8', prosrc => 'float8_accum' },
{ oid => '276', descr => 'aggregate combine function',
proname => 'float8_combine', prorettype => '_float8',
proargtypes => '_float8 _float8', prosrc => 'float8_combine' },
{ oid => '223', descr => 'larger of two',
proname => 'float8larger', prorettype => 'float8',
proargtypes => 'float8 float8', prosrc => 'float8larger' },
{ oid => '224', descr => 'smaller of two',
proname => 'float8smaller', prorettype => 'float8',
proargtypes => 'float8 float8', prosrc => 'float8smaller' },
{ oid => '225',
proname => 'lseg_center', prorettype => 'point', proargtypes => 'lseg',
prosrc => 'lseg_center' },
{ oid => '226',
proname => 'path_center', prorettype => 'point', proargtypes => 'path',
prosrc => 'path_center' },
{ oid => '227',
proname => 'poly_center', prorettype => 'point', proargtypes => 'polygon',
prosrc => 'poly_center' },
{ oid => '228', descr => 'round to nearest integer',
proname => 'dround', prorettype => 'float8', proargtypes => 'float8',
prosrc => 'dround' },
{ oid => '229', descr => 'truncate to integer',
proname => 'dtrunc', prorettype => 'float8', proargtypes => 'float8',
prosrc => 'dtrunc' },
{ oid => '2308', descr => 'nearest integer >= value',
proname => 'ceil', prorettype => 'float8', proargtypes => 'float8',
prosrc => 'dceil' },
{ oid => '2320', descr => 'nearest integer >= value',
proname => 'ceiling', prorettype => 'float8', proargtypes => 'float8',
prosrc => 'dceil' },
{ oid => '2309', descr => 'nearest integer <= value',
proname => 'floor', prorettype => 'float8', proargtypes => 'float8',
prosrc => 'dfloor' },
{ oid => '2310', descr => 'sign of value',
proname => 'sign', prorettype => 'float8', proargtypes => 'float8',
prosrc => 'dsign' },
{ oid => '230',
proname => 'dsqrt', prorettype => 'float8', proargtypes => 'float8',
prosrc => 'dsqrt' },
{ oid => '231',
proname => 'dcbrt', prorettype => 'float8', proargtypes => 'float8',
prosrc => 'dcbrt' },
{ oid => '232',
proname => 'dpow', prorettype => 'float8', proargtypes => 'float8 float8',
prosrc => 'dpow' },
{ oid => '233', descr => 'natural exponential (e^x)',
proname => 'dexp', prorettype => 'float8', proargtypes => 'float8',
prosrc => 'dexp' },
{ oid => '234', descr => 'natural logarithm',
proname => 'dlog1', prorettype => 'float8', proargtypes => 'float8',
prosrc => 'dlog1' },
{ oid => '235', descr => 'convert int2 to float8',
proname => 'float8', prorettype => 'float8', proargtypes => 'int2',
prosrc => 'i2tod' },
{ oid => '236', descr => 'convert int2 to float4',
proname => 'float4', prorettype => 'float4', proargtypes => 'int2',
prosrc => 'i2tof' },
{ oid => '237', descr => 'convert float8 to int2',
proname => 'int2', prorettype => 'int2', proargtypes => 'float8',
prosrc => 'dtoi2' },
{ oid => '238', descr => 'convert float4 to int2',
proname => 'int2', prorettype => 'int2', proargtypes => 'float4',
prosrc => 'ftoi2' },
{ oid => '239',
proname => 'line_distance', prorettype => 'float8',
proargtypes => 'line line', prosrc => 'line_distance' },
Add text-vs-name cross-type operators, and unify name_ops with text_ops. Now that name comparison has effectively the same behavior as text comparison, we might as well merge the name_ops opfamily into text_ops, allowing cross-type comparisons to be processed without forcing a datatype coercion first. We need do little more than add cross-type operators to make the opfamily complete, and fix one or two places in the planner that assumed text_ops was a single-datatype opfamily. I chose to unify hash name_ops into hash text_ops as well, since the types have compatible hashing semantics. This allows marking the new cross-type equality operators as oprcanhash. (Note: this doesn't remove the name_ops opclasses, so there's no breakage of index definitions. Those opclasses are just reparented into the text_ops opfamily.) Discussion: https://postgr.es/m/15938.1544377821@sss.pgh.pa.us
2018-12-19 23:46:07 +01:00
{ oid => '240',
proname => 'nameeqtext', proleakproof => 't', prorettype => 'bool',
proargtypes => 'name text', prosrc => 'nameeqtext' },
{ oid => '241',
proname => 'namelttext', proleakproof => 't', prorettype => 'bool',
proargtypes => 'name text', prosrc => 'namelttext' },
{ oid => '242',
proname => 'nameletext', proleakproof => 't', prorettype => 'bool',
proargtypes => 'name text', prosrc => 'nameletext' },
{ oid => '243',
proname => 'namegetext', proleakproof => 't', prorettype => 'bool',
proargtypes => 'name text', prosrc => 'namegetext' },
{ oid => '244',
proname => 'namegttext', proleakproof => 't', prorettype => 'bool',
proargtypes => 'name text', prosrc => 'namegttext' },
{ oid => '245',
proname => 'namenetext', proleakproof => 't', prorettype => 'bool',
proargtypes => 'name text', prosrc => 'namenetext' },
{ oid => '246', descr => 'less-equal-greater',
proname => 'btnametextcmp', proleakproof => 't', prorettype => 'int4',
proargtypes => 'name text', prosrc => 'btnametextcmp' },
{ oid => '247',
proname => 'texteqname', proleakproof => 't', prorettype => 'bool',
proargtypes => 'text name', prosrc => 'texteqname' },
{ oid => '248',
proname => 'textltname', proleakproof => 't', prorettype => 'bool',
proargtypes => 'text name', prosrc => 'textltname' },
{ oid => '249',
proname => 'textlename', proleakproof => 't', prorettype => 'bool',
proargtypes => 'text name', prosrc => 'textlename' },
{ oid => '250',
proname => 'textgename', proleakproof => 't', prorettype => 'bool',
proargtypes => 'text name', prosrc => 'textgename' },
{ oid => '251',
proname => 'textgtname', proleakproof => 't', prorettype => 'bool',
proargtypes => 'text name', prosrc => 'textgtname' },
{ oid => '252',
proname => 'textnename', proleakproof => 't', prorettype => 'bool',
proargtypes => 'text name', prosrc => 'textnename' },
{ oid => '253', descr => 'less-equal-greater',
proname => 'bttextnamecmp', proleakproof => 't', prorettype => 'int4',
proargtypes => 'text name', prosrc => 'bttextnamecmp' },
Avoid producing over-length specific_name outputs in information_schema. information_schema output columns that are declared as being type sql_identifier are supposed to conform to the implementation's rules for valid identifiers, in particular the identifier length limit. Several places potentially violated this limit by concatenating a function's name and OID. (The OID is added to ensure name uniqueness within a schema, since the spec doesn't expect function name overloading.) Simply truncating the concatenation result to fit in "name" won't do, since losing part of the OID might wind up giving non-unique results. Instead, let's truncate the function name as necessary. The most practical way to do that is to do it in a C function; the information_schema.sql script doesn't have easy access to the value of NAMEDATALEN, nor does it have an easy way to truncate on the basis of resulting byte-length rather than number of characters. (There are still a couple of places that cast concatenation results to sql_identifier, but as far as I can see they are guaranteed not to produce over-length strings, at least with the normal value of NAMEDATALEN.) Discussion: https://postgr.es/m/23817.1545283477@sss.pgh.pa.us
2018-12-20 21:58:58 +01:00
{ oid => '266', descr => 'concatenate name and oid',
proname => 'nameconcatoid', prorettype => 'name', proargtypes => 'name oid',
prosrc => 'nameconcatoid' },
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
{ oid => '274',
descr => 'current date and time - increments during transactions',
proname => 'timeofday', provolatile => 'v', prorettype => 'text',
proargtypes => '', prosrc => 'timeofday' },
{ oid => '277',
proname => 'inter_sl', prorettype => 'bool', proargtypes => 'lseg line',
prosrc => 'inter_sl' },
{ oid => '278',
proname => 'inter_lb', prorettype => 'bool', proargtypes => 'line box',
prosrc => 'inter_lb' },
{ oid => '279',
proname => 'float48mul', prorettype => 'float8',
proargtypes => 'float4 float8', prosrc => 'float48mul' },
{ oid => '280',
proname => 'float48div', prorettype => 'float8',
proargtypes => 'float4 float8', prosrc => 'float48div' },
{ oid => '281',
proname => 'float48pl', prorettype => 'float8',
proargtypes => 'float4 float8', prosrc => 'float48pl' },
{ oid => '282',
proname => 'float48mi', prorettype => 'float8',
proargtypes => 'float4 float8', prosrc => 'float48mi' },
{ oid => '283',
proname => 'float84mul', prorettype => 'float8',
proargtypes => 'float8 float4', prosrc => 'float84mul' },
{ oid => '284',
proname => 'float84div', prorettype => 'float8',
proargtypes => 'float8 float4', prosrc => 'float84div' },
{ oid => '285',
proname => 'float84pl', prorettype => 'float8',
proargtypes => 'float8 float4', prosrc => 'float84pl' },
{ oid => '286',
proname => 'float84mi', prorettype => 'float8',
proargtypes => 'float8 float4', prosrc => 'float84mi' },
{ oid => '287',
proname => 'float4eq', proleakproof => 't', prorettype => 'bool',
proargtypes => 'float4 float4', prosrc => 'float4eq' },
{ oid => '288',
proname => 'float4ne', proleakproof => 't', prorettype => 'bool',
proargtypes => 'float4 float4', prosrc => 'float4ne' },
{ oid => '289',
proname => 'float4lt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'float4 float4', prosrc => 'float4lt' },
{ oid => '290',
proname => 'float4le', proleakproof => 't', prorettype => 'bool',
proargtypes => 'float4 float4', prosrc => 'float4le' },
{ oid => '291',
proname => 'float4gt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'float4 float4', prosrc => 'float4gt' },
{ oid => '292',
proname => 'float4ge', proleakproof => 't', prorettype => 'bool',
proargtypes => 'float4 float4', prosrc => 'float4ge' },
{ oid => '293',
proname => 'float8eq', proleakproof => 't', prorettype => 'bool',
proargtypes => 'float8 float8', prosrc => 'float8eq' },
{ oid => '294',
proname => 'float8ne', proleakproof => 't', prorettype => 'bool',
proargtypes => 'float8 float8', prosrc => 'float8ne' },
{ oid => '295',
proname => 'float8lt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'float8 float8', prosrc => 'float8lt' },
{ oid => '296',
proname => 'float8le', proleakproof => 't', prorettype => 'bool',
proargtypes => 'float8 float8', prosrc => 'float8le' },
{ oid => '297',
proname => 'float8gt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'float8 float8', prosrc => 'float8gt' },
{ oid => '298',
proname => 'float8ge', proleakproof => 't', prorettype => 'bool',
proargtypes => 'float8 float8', prosrc => 'float8ge' },
{ oid => '299',
proname => 'float48eq', proleakproof => 't', prorettype => 'bool',
proargtypes => 'float4 float8', prosrc => 'float48eq' },
# OIDS 300 - 399
{ oid => '300',
proname => 'float48ne', proleakproof => 't', prorettype => 'bool',
proargtypes => 'float4 float8', prosrc => 'float48ne' },
{ oid => '301',
proname => 'float48lt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'float4 float8', prosrc => 'float48lt' },
{ oid => '302',
proname => 'float48le', proleakproof => 't', prorettype => 'bool',
proargtypes => 'float4 float8', prosrc => 'float48le' },
{ oid => '303',
proname => 'float48gt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'float4 float8', prosrc => 'float48gt' },
{ oid => '304',
proname => 'float48ge', proleakproof => 't', prorettype => 'bool',
proargtypes => 'float4 float8', prosrc => 'float48ge' },
{ oid => '305',
proname => 'float84eq', proleakproof => 't', prorettype => 'bool',
proargtypes => 'float8 float4', prosrc => 'float84eq' },
{ oid => '306',
proname => 'float84ne', proleakproof => 't', prorettype => 'bool',
proargtypes => 'float8 float4', prosrc => 'float84ne' },
{ oid => '307',
proname => 'float84lt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'float8 float4', prosrc => 'float84lt' },
{ oid => '308',
proname => 'float84le', proleakproof => 't', prorettype => 'bool',
proargtypes => 'float8 float4', prosrc => 'float84le' },
{ oid => '309',
proname => 'float84gt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'float8 float4', prosrc => 'float84gt' },
{ oid => '310',
proname => 'float84ge', proleakproof => 't', prorettype => 'bool',
proargtypes => 'float8 float4', prosrc => 'float84ge' },
{ oid => '320', descr => 'bucket number of operand in equal-width histogram',
proname => 'width_bucket', prorettype => 'int4',
proargtypes => 'float8 float8 float8 int4', prosrc => 'width_bucket_float8' },
{ oid => '311', descr => 'convert float4 to float8',
proname => 'float8', prorettype => 'float8', proargtypes => 'float4',
prosrc => 'ftod' },
{ oid => '312', descr => 'convert float8 to float4',
proname => 'float4', prorettype => 'float4', proargtypes => 'float8',
prosrc => 'dtof' },
{ oid => '313', descr => 'convert int2 to int4',
proname => 'int4', prorettype => 'int4', proargtypes => 'int2',
prosrc => 'i2toi4' },
{ oid => '314', descr => 'convert int4 to int2',
proname => 'int2', prorettype => 'int2', proargtypes => 'int4',
prosrc => 'i4toi2' },
{ oid => '316', descr => 'convert int4 to float8',
proname => 'float8', prorettype => 'float8', proargtypes => 'int4',
prosrc => 'i4tod' },
{ oid => '317', descr => 'convert float8 to int4',
proname => 'int4', prorettype => 'int4', proargtypes => 'float8',
prosrc => 'dtoi4' },
{ oid => '318', descr => 'convert int4 to float4',
proname => 'float4', prorettype => 'float4', proargtypes => 'int4',
prosrc => 'i4tof' },
{ oid => '319', descr => 'convert float4 to int4',
proname => 'int4', prorettype => 'int4', proargtypes => 'float4',
prosrc => 'ftoi4' },
# Index access method handlers
{ oid => '330', descr => 'btree index access method handler',
proname => 'bthandler', provolatile => 'v', prorettype => 'index_am_handler',
proargtypes => 'internal', prosrc => 'bthandler' },
{ oid => '331', descr => 'hash index access method handler',
proname => 'hashhandler', provolatile => 'v',
prorettype => 'index_am_handler', proargtypes => 'internal',
prosrc => 'hashhandler' },
{ oid => '332', descr => 'gist index access method handler',
proname => 'gisthandler', provolatile => 'v',
prorettype => 'index_am_handler', proargtypes => 'internal',
prosrc => 'gisthandler' },
{ oid => '333', descr => 'gin index access method handler',
proname => 'ginhandler', provolatile => 'v', prorettype => 'index_am_handler',
proargtypes => 'internal', prosrc => 'ginhandler' },
{ oid => '334', descr => 'spgist index access method handler',
proname => 'spghandler', provolatile => 'v', prorettype => 'index_am_handler',
proargtypes => 'internal', prosrc => 'spghandler' },
{ oid => '335', descr => 'brin index access method handler',
proname => 'brinhandler', provolatile => 'v',
prorettype => 'index_am_handler', proargtypes => 'internal',
prosrc => 'brinhandler' },
{ oid => '3952', descr => 'brin: standalone scan new table pages',
proname => 'brin_summarize_new_values', provolatile => 'v',
proparallel => 'u', prorettype => 'int4', proargtypes => 'regclass',
prosrc => 'brin_summarize_new_values' },
{ oid => '3999', descr => 'brin: standalone scan new table pages',
proname => 'brin_summarize_range', provolatile => 'v', proparallel => 'u',
prorettype => 'int4', proargtypes => 'regclass int8',
prosrc => 'brin_summarize_range' },
{ oid => '4014', descr => 'brin: desummarize page range',
proname => 'brin_desummarize_range', provolatile => 'v', proparallel => 'u',
prorettype => 'void', proargtypes => 'regclass int8',
prosrc => 'brin_desummarize_range' },
{ oid => '338', descr => 'validate an operator class',
proname => 'amvalidate', provolatile => 'v', prorettype => 'bool',
proargtypes => 'oid', prosrc => 'amvalidate' },
{ oid => '636', descr => 'test property of an index access method',
proname => 'pg_indexam_has_property', provolatile => 's',
prorettype => 'bool', proargtypes => 'oid text',
prosrc => 'pg_indexam_has_property' },
{ oid => '637', descr => 'test property of an index',
proname => 'pg_index_has_property', provolatile => 's', prorettype => 'bool',
proargtypes => 'regclass text', prosrc => 'pg_index_has_property' },
{ oid => '638', descr => 'test property of an index column',
proname => 'pg_index_column_has_property', provolatile => 's',
prorettype => 'bool', proargtypes => 'regclass int4 text',
prosrc => 'pg_index_column_has_property' },
{ oid => '339',
proname => 'poly_same', prorettype => 'bool',
proargtypes => 'polygon polygon', prosrc => 'poly_same' },
{ oid => '340',
proname => 'poly_contain', prorettype => 'bool',
proargtypes => 'polygon polygon', prosrc => 'poly_contain' },
{ oid => '341',
proname => 'poly_left', prorettype => 'bool',
proargtypes => 'polygon polygon', prosrc => 'poly_left' },
{ oid => '342',
proname => 'poly_overleft', prorettype => 'bool',
proargtypes => 'polygon polygon', prosrc => 'poly_overleft' },
{ oid => '343',
proname => 'poly_overright', prorettype => 'bool',
proargtypes => 'polygon polygon', prosrc => 'poly_overright' },
{ oid => '344',
proname => 'poly_right', prorettype => 'bool',
proargtypes => 'polygon polygon', prosrc => 'poly_right' },
{ oid => '345',
proname => 'poly_contained', prorettype => 'bool',
proargtypes => 'polygon polygon', prosrc => 'poly_contained' },
{ oid => '346',
proname => 'poly_overlap', prorettype => 'bool',
proargtypes => 'polygon polygon', prosrc => 'poly_overlap' },
{ oid => '347', descr => 'I/O',
proname => 'poly_in', prorettype => 'polygon', proargtypes => 'cstring',
prosrc => 'poly_in' },
{ oid => '348', descr => 'I/O',
proname => 'poly_out', prorettype => 'cstring', proargtypes => 'polygon',
prosrc => 'poly_out' },
{ oid => '350', descr => 'less-equal-greater',
Mark built-in btree comparison functions as leakproof where it's safe. Generally, if the comparison operators for a datatype or pair of datatypes are leakproof, the corresponding btree comparison support function can be considered so as well. But we had not originally worried about marking support functions as leakproof, reasoning that they'd not likely be used in queries so the marking wouldn't matter. It turns out there's at least one place where it does matter: calc_arraycontsel() finds the target datatype's default btree comparison function and tries to use that to estimate selectivity, but it will be blocked in some cases if the function isn't leakproof. This leads to unnecessarily poor selectivity estimates and bad plans, as seen in bug #15251. Hence, run around and apply proleakproof markings where the corresponding btree comparison operators are leakproof. (I did eyeball each function to verify that it wasn't doing anything surprising, too.) This isn't a full solution to bug #15251, and it's not back-patchable because of the need for a catversion bump. A more useful response probably is to consider whether we can check permissions on the parent table instead of the child. However, this change will help in some cases where that won't, and it's easy enough to do in HEAD, so let's do so. Discussion: https://postgr.es/m/3876.1531261875@sss.pgh.pa.us
2018-07-12 00:47:31 +02:00
proname => 'btint2cmp', proleakproof => 't', prorettype => 'int4',
proargtypes => 'int2 int2', prosrc => 'btint2cmp' },
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
{ oid => '3129', descr => 'sort support',
proname => 'btint2sortsupport', prorettype => 'void',
proargtypes => 'internal', prosrc => 'btint2sortsupport' },
{ oid => '351', descr => 'less-equal-greater',
Mark built-in btree comparison functions as leakproof where it's safe. Generally, if the comparison operators for a datatype or pair of datatypes are leakproof, the corresponding btree comparison support function can be considered so as well. But we had not originally worried about marking support functions as leakproof, reasoning that they'd not likely be used in queries so the marking wouldn't matter. It turns out there's at least one place where it does matter: calc_arraycontsel() finds the target datatype's default btree comparison function and tries to use that to estimate selectivity, but it will be blocked in some cases if the function isn't leakproof. This leads to unnecessarily poor selectivity estimates and bad plans, as seen in bug #15251. Hence, run around and apply proleakproof markings where the corresponding btree comparison operators are leakproof. (I did eyeball each function to verify that it wasn't doing anything surprising, too.) This isn't a full solution to bug #15251, and it's not back-patchable because of the need for a catversion bump. A more useful response probably is to consider whether we can check permissions on the parent table instead of the child. However, this change will help in some cases where that won't, and it's easy enough to do in HEAD, so let's do so. Discussion: https://postgr.es/m/3876.1531261875@sss.pgh.pa.us
2018-07-12 00:47:31 +02:00
proname => 'btint4cmp', proleakproof => 't', prorettype => 'int4',
proargtypes => 'int4 int4', prosrc => 'btint4cmp' },
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
{ oid => '3130', descr => 'sort support',
proname => 'btint4sortsupport', prorettype => 'void',
proargtypes => 'internal', prosrc => 'btint4sortsupport' },
{ oid => '842', descr => 'less-equal-greater',
Mark built-in btree comparison functions as leakproof where it's safe. Generally, if the comparison operators for a datatype or pair of datatypes are leakproof, the corresponding btree comparison support function can be considered so as well. But we had not originally worried about marking support functions as leakproof, reasoning that they'd not likely be used in queries so the marking wouldn't matter. It turns out there's at least one place where it does matter: calc_arraycontsel() finds the target datatype's default btree comparison function and tries to use that to estimate selectivity, but it will be blocked in some cases if the function isn't leakproof. This leads to unnecessarily poor selectivity estimates and bad plans, as seen in bug #15251. Hence, run around and apply proleakproof markings where the corresponding btree comparison operators are leakproof. (I did eyeball each function to verify that it wasn't doing anything surprising, too.) This isn't a full solution to bug #15251, and it's not back-patchable because of the need for a catversion bump. A more useful response probably is to consider whether we can check permissions on the parent table instead of the child. However, this change will help in some cases where that won't, and it's easy enough to do in HEAD, so let's do so. Discussion: https://postgr.es/m/3876.1531261875@sss.pgh.pa.us
2018-07-12 00:47:31 +02:00
proname => 'btint8cmp', proleakproof => 't', prorettype => 'int4',
proargtypes => 'int8 int8', prosrc => 'btint8cmp' },
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
{ oid => '3131', descr => 'sort support',
proname => 'btint8sortsupport', prorettype => 'void',
proargtypes => 'internal', prosrc => 'btint8sortsupport' },
{ oid => '354', descr => 'less-equal-greater',
Mark built-in btree comparison functions as leakproof where it's safe. Generally, if the comparison operators for a datatype or pair of datatypes are leakproof, the corresponding btree comparison support function can be considered so as well. But we had not originally worried about marking support functions as leakproof, reasoning that they'd not likely be used in queries so the marking wouldn't matter. It turns out there's at least one place where it does matter: calc_arraycontsel() finds the target datatype's default btree comparison function and tries to use that to estimate selectivity, but it will be blocked in some cases if the function isn't leakproof. This leads to unnecessarily poor selectivity estimates and bad plans, as seen in bug #15251. Hence, run around and apply proleakproof markings where the corresponding btree comparison operators are leakproof. (I did eyeball each function to verify that it wasn't doing anything surprising, too.) This isn't a full solution to bug #15251, and it's not back-patchable because of the need for a catversion bump. A more useful response probably is to consider whether we can check permissions on the parent table instead of the child. However, this change will help in some cases where that won't, and it's easy enough to do in HEAD, so let's do so. Discussion: https://postgr.es/m/3876.1531261875@sss.pgh.pa.us
2018-07-12 00:47:31 +02:00
proname => 'btfloat4cmp', proleakproof => 't', prorettype => 'int4',
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
proargtypes => 'float4 float4', prosrc => 'btfloat4cmp' },
{ oid => '3132', descr => 'sort support',
proname => 'btfloat4sortsupport', prorettype => 'void',
proargtypes => 'internal', prosrc => 'btfloat4sortsupport' },
{ oid => '355', descr => 'less-equal-greater',
Mark built-in btree comparison functions as leakproof where it's safe. Generally, if the comparison operators for a datatype or pair of datatypes are leakproof, the corresponding btree comparison support function can be considered so as well. But we had not originally worried about marking support functions as leakproof, reasoning that they'd not likely be used in queries so the marking wouldn't matter. It turns out there's at least one place where it does matter: calc_arraycontsel() finds the target datatype's default btree comparison function and tries to use that to estimate selectivity, but it will be blocked in some cases if the function isn't leakproof. This leads to unnecessarily poor selectivity estimates and bad plans, as seen in bug #15251. Hence, run around and apply proleakproof markings where the corresponding btree comparison operators are leakproof. (I did eyeball each function to verify that it wasn't doing anything surprising, too.) This isn't a full solution to bug #15251, and it's not back-patchable because of the need for a catversion bump. A more useful response probably is to consider whether we can check permissions on the parent table instead of the child. However, this change will help in some cases where that won't, and it's easy enough to do in HEAD, so let's do so. Discussion: https://postgr.es/m/3876.1531261875@sss.pgh.pa.us
2018-07-12 00:47:31 +02:00
proname => 'btfloat8cmp', proleakproof => 't', prorettype => 'int4',
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
proargtypes => 'float8 float8', prosrc => 'btfloat8cmp' },
{ oid => '3133', descr => 'sort support',
proname => 'btfloat8sortsupport', prorettype => 'void',
proargtypes => 'internal', prosrc => 'btfloat8sortsupport' },
{ oid => '356', descr => 'less-equal-greater',
Mark built-in btree comparison functions as leakproof where it's safe. Generally, if the comparison operators for a datatype or pair of datatypes are leakproof, the corresponding btree comparison support function can be considered so as well. But we had not originally worried about marking support functions as leakproof, reasoning that they'd not likely be used in queries so the marking wouldn't matter. It turns out there's at least one place where it does matter: calc_arraycontsel() finds the target datatype's default btree comparison function and tries to use that to estimate selectivity, but it will be blocked in some cases if the function isn't leakproof. This leads to unnecessarily poor selectivity estimates and bad plans, as seen in bug #15251. Hence, run around and apply proleakproof markings where the corresponding btree comparison operators are leakproof. (I did eyeball each function to verify that it wasn't doing anything surprising, too.) This isn't a full solution to bug #15251, and it's not back-patchable because of the need for a catversion bump. A more useful response probably is to consider whether we can check permissions on the parent table instead of the child. However, this change will help in some cases where that won't, and it's easy enough to do in HEAD, so let's do so. Discussion: https://postgr.es/m/3876.1531261875@sss.pgh.pa.us
2018-07-12 00:47:31 +02:00
proname => 'btoidcmp', proleakproof => 't', prorettype => 'int4',
proargtypes => 'oid oid', prosrc => 'btoidcmp' },
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
{ oid => '3134', descr => 'sort support',
proname => 'btoidsortsupport', prorettype => 'void',
proargtypes => 'internal', prosrc => 'btoidsortsupport' },
{ oid => '404', descr => 'less-equal-greater',
proname => 'btoidvectorcmp', prorettype => 'int4',
proargtypes => 'oidvector oidvector', prosrc => 'btoidvectorcmp' },
{ oid => '358', descr => 'less-equal-greater',
Mark built-in btree comparison functions as leakproof where it's safe. Generally, if the comparison operators for a datatype or pair of datatypes are leakproof, the corresponding btree comparison support function can be considered so as well. But we had not originally worried about marking support functions as leakproof, reasoning that they'd not likely be used in queries so the marking wouldn't matter. It turns out there's at least one place where it does matter: calc_arraycontsel() finds the target datatype's default btree comparison function and tries to use that to estimate selectivity, but it will be blocked in some cases if the function isn't leakproof. This leads to unnecessarily poor selectivity estimates and bad plans, as seen in bug #15251. Hence, run around and apply proleakproof markings where the corresponding btree comparison operators are leakproof. (I did eyeball each function to verify that it wasn't doing anything surprising, too.) This isn't a full solution to bug #15251, and it's not back-patchable because of the need for a catversion bump. A more useful response probably is to consider whether we can check permissions on the parent table instead of the child. However, this change will help in some cases where that won't, and it's easy enough to do in HEAD, so let's do so. Discussion: https://postgr.es/m/3876.1531261875@sss.pgh.pa.us
2018-07-12 00:47:31 +02:00
proname => 'btcharcmp', proleakproof => 't', prorettype => 'int4',
proargtypes => 'char char', prosrc => 'btcharcmp' },
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
{ oid => '359', descr => 'less-equal-greater',
Mark built-in btree comparison functions as leakproof where it's safe. Generally, if the comparison operators for a datatype or pair of datatypes are leakproof, the corresponding btree comparison support function can be considered so as well. But we had not originally worried about marking support functions as leakproof, reasoning that they'd not likely be used in queries so the marking wouldn't matter. It turns out there's at least one place where it does matter: calc_arraycontsel() finds the target datatype's default btree comparison function and tries to use that to estimate selectivity, but it will be blocked in some cases if the function isn't leakproof. This leads to unnecessarily poor selectivity estimates and bad plans, as seen in bug #15251. Hence, run around and apply proleakproof markings where the corresponding btree comparison operators are leakproof. (I did eyeball each function to verify that it wasn't doing anything surprising, too.) This isn't a full solution to bug #15251, and it's not back-patchable because of the need for a catversion bump. A more useful response probably is to consider whether we can check permissions on the parent table instead of the child. However, this change will help in some cases where that won't, and it's easy enough to do in HEAD, so let's do so. Discussion: https://postgr.es/m/3876.1531261875@sss.pgh.pa.us
2018-07-12 00:47:31 +02:00
proname => 'btnamecmp', proleakproof => 't', prorettype => 'int4',
proargtypes => 'name name', prosrc => 'btnamecmp' },
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
{ oid => '3135', descr => 'sort support',
proname => 'btnamesortsupport', prorettype => 'void',
proargtypes => 'internal', prosrc => 'btnamesortsupport' },
{ oid => '360', descr => 'less-equal-greater',
proname => 'bttextcmp', prorettype => 'int4', proargtypes => 'text text',
prosrc => 'bttextcmp' },
{ oid => '3255', descr => 'sort support',
proname => 'bttextsortsupport', prorettype => 'void',
proargtypes => 'internal', prosrc => 'bttextsortsupport' },
{ oid => '377', descr => 'less-equal-greater',
Mark built-in btree comparison functions as leakproof where it's safe. Generally, if the comparison operators for a datatype or pair of datatypes are leakproof, the corresponding btree comparison support function can be considered so as well. But we had not originally worried about marking support functions as leakproof, reasoning that they'd not likely be used in queries so the marking wouldn't matter. It turns out there's at least one place where it does matter: calc_arraycontsel() finds the target datatype's default btree comparison function and tries to use that to estimate selectivity, but it will be blocked in some cases if the function isn't leakproof. This leads to unnecessarily poor selectivity estimates and bad plans, as seen in bug #15251. Hence, run around and apply proleakproof markings where the corresponding btree comparison operators are leakproof. (I did eyeball each function to verify that it wasn't doing anything surprising, too.) This isn't a full solution to bug #15251, and it's not back-patchable because of the need for a catversion bump. A more useful response probably is to consider whether we can check permissions on the parent table instead of the child. However, this change will help in some cases where that won't, and it's easy enough to do in HEAD, so let's do so. Discussion: https://postgr.es/m/3876.1531261875@sss.pgh.pa.us
2018-07-12 00:47:31 +02:00
proname => 'cash_cmp', proleakproof => 't', prorettype => 'int4',
proargtypes => 'money money', prosrc => 'cash_cmp' },
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
{ oid => '382', descr => 'less-equal-greater',
proname => 'btarraycmp', prorettype => 'int4',
proargtypes => 'anyarray anyarray', prosrc => 'btarraycmp' },
{ oid => '4126', descr => 'window RANGE support',
proname => 'in_range', prorettype => 'bool',
proargtypes => 'int8 int8 int8 bool bool', prosrc => 'in_range_int8_int8' },
{ oid => '4127', descr => 'window RANGE support',
proname => 'in_range', prorettype => 'bool',
proargtypes => 'int4 int4 int8 bool bool', prosrc => 'in_range_int4_int8' },
{ oid => '4128', descr => 'window RANGE support',
proname => 'in_range', prorettype => 'bool',
proargtypes => 'int4 int4 int4 bool bool', prosrc => 'in_range_int4_int4' },
{ oid => '4129', descr => 'window RANGE support',
proname => 'in_range', prorettype => 'bool',
proargtypes => 'int4 int4 int2 bool bool', prosrc => 'in_range_int4_int2' },
{ oid => '4130', descr => 'window RANGE support',
proname => 'in_range', prorettype => 'bool',
proargtypes => 'int2 int2 int8 bool bool', prosrc => 'in_range_int2_int8' },
{ oid => '4131', descr => 'window RANGE support',
proname => 'in_range', prorettype => 'bool',
proargtypes => 'int2 int2 int4 bool bool', prosrc => 'in_range_int2_int4' },
{ oid => '4132', descr => 'window RANGE support',
proname => 'in_range', prorettype => 'bool',
proargtypes => 'int2 int2 int2 bool bool', prosrc => 'in_range_int2_int2' },
{ oid => '4139', descr => 'window RANGE support',
proname => 'in_range', prorettype => 'bool',
proargtypes => 'float8 float8 float8 bool bool',
prosrc => 'in_range_float8_float8' },
{ oid => '4140', descr => 'window RANGE support',
proname => 'in_range', prorettype => 'bool',
proargtypes => 'float4 float4 float8 bool bool',
prosrc => 'in_range_float4_float8' },
{ oid => '4141', descr => 'window RANGE support',
proname => 'in_range', prorettype => 'bool',
proargtypes => 'numeric numeric numeric bool bool',
prosrc => 'in_range_numeric_numeric' },
{ oid => '361',
proname => 'lseg_distance', prorettype => 'float8',
proargtypes => 'lseg lseg', prosrc => 'lseg_distance' },
{ oid => '362',
proname => 'lseg_interpt', prorettype => 'point', proargtypes => 'lseg lseg',
prosrc => 'lseg_interpt' },
{ oid => '363',
proname => 'dist_ps', prorettype => 'float8', proargtypes => 'point lseg',
prosrc => 'dist_ps' },
{ oid => '364',
proname => 'dist_pb', prorettype => 'float8', proargtypes => 'point box',
prosrc => 'dist_pb' },
{ oid => '365',
proname => 'dist_sb', prorettype => 'float8', proargtypes => 'lseg box',
prosrc => 'dist_sb' },
{ oid => '366',
proname => 'close_ps', prorettype => 'point', proargtypes => 'point lseg',
prosrc => 'close_ps' },
{ oid => '367',
proname => 'close_pb', prorettype => 'point', proargtypes => 'point box',
prosrc => 'close_pb' },
{ oid => '368',
proname => 'close_sb', prorettype => 'point', proargtypes => 'lseg box',
prosrc => 'close_sb' },
{ oid => '369',
proname => 'on_ps', prorettype => 'bool', proargtypes => 'point lseg',
prosrc => 'on_ps' },
{ oid => '370',
proname => 'path_distance', prorettype => 'float8',
proargtypes => 'path path', prosrc => 'path_distance' },
{ oid => '371',
proname => 'dist_ppath', prorettype => 'float8', proargtypes => 'point path',
prosrc => 'dist_ppath' },
{ oid => '372',
proname => 'on_sb', prorettype => 'bool', proargtypes => 'lseg box',
prosrc => 'on_sb' },
{ oid => '373',
proname => 'inter_sb', prorettype => 'bool', proargtypes => 'lseg box',
prosrc => 'inter_sb' },
# OIDS 400 - 499
{ oid => '401', descr => 'convert char(n) to text',
proname => 'text', prorettype => 'text', proargtypes => 'bpchar',
prosrc => 'rtrim1' },
{ oid => '406', descr => 'convert name to text',
proname => 'text', prorettype => 'text', proargtypes => 'name',
prosrc => 'name_text' },
{ oid => '407', descr => 'convert text to name',
proname => 'name', prorettype => 'name', proargtypes => 'text',
prosrc => 'text_name' },
{ oid => '408', descr => 'convert name to char(n)',
proname => 'bpchar', prorettype => 'bpchar', proargtypes => 'name',
prosrc => 'name_bpchar' },
{ oid => '409', descr => 'convert char(n) to name',
proname => 'name', prorettype => 'name', proargtypes => 'bpchar',
prosrc => 'bpchar_name' },
{ oid => '449', descr => 'hash',
proname => 'hashint2', prorettype => 'int4', proargtypes => 'int2',
prosrc => 'hashint2' },
{ oid => '441', descr => 'hash',
proname => 'hashint2extended', prorettype => 'int8',
proargtypes => 'int2 int8', prosrc => 'hashint2extended' },
{ oid => '450', descr => 'hash',
proname => 'hashint4', prorettype => 'int4', proargtypes => 'int4',
prosrc => 'hashint4' },
{ oid => '425', descr => 'hash',
proname => 'hashint4extended', prorettype => 'int8',
proargtypes => 'int4 int8', prosrc => 'hashint4extended' },
{ oid => '949', descr => 'hash',
proname => 'hashint8', prorettype => 'int4', proargtypes => 'int8',
prosrc => 'hashint8' },
{ oid => '442', descr => 'hash',
proname => 'hashint8extended', prorettype => 'int8',
proargtypes => 'int8 int8', prosrc => 'hashint8extended' },
{ oid => '451', descr => 'hash',
proname => 'hashfloat4', prorettype => 'int4', proargtypes => 'float4',
prosrc => 'hashfloat4' },
{ oid => '443', descr => 'hash',
proname => 'hashfloat4extended', prorettype => 'int8',
proargtypes => 'float4 int8', prosrc => 'hashfloat4extended' },
{ oid => '452', descr => 'hash',
proname => 'hashfloat8', prorettype => 'int4', proargtypes => 'float8',
prosrc => 'hashfloat8' },
{ oid => '444', descr => 'hash',
proname => 'hashfloat8extended', prorettype => 'int8',
proargtypes => 'float8 int8', prosrc => 'hashfloat8extended' },
{ oid => '453', descr => 'hash',
proname => 'hashoid', prorettype => 'int4', proargtypes => 'oid',
prosrc => 'hashoid' },
{ oid => '445', descr => 'hash',
proname => 'hashoidextended', prorettype => 'int8', proargtypes => 'oid int8',
prosrc => 'hashoidextended' },
{ oid => '454', descr => 'hash',
proname => 'hashchar', prorettype => 'int4', proargtypes => 'char',
prosrc => 'hashchar' },
{ oid => '446', descr => 'hash',
proname => 'hashcharextended', prorettype => 'int8',
proargtypes => 'char int8', prosrc => 'hashcharextended' },
{ oid => '455', descr => 'hash',
proname => 'hashname', prorettype => 'int4', proargtypes => 'name',
prosrc => 'hashname' },
{ oid => '447', descr => 'hash',
proname => 'hashnameextended', prorettype => 'int8',
proargtypes => 'name int8', prosrc => 'hashnameextended' },
{ oid => '400', descr => 'hash',
proname => 'hashtext', prorettype => 'int4', proargtypes => 'text',
prosrc => 'hashtext' },
{ oid => '448', descr => 'hash',
proname => 'hashtextextended', prorettype => 'int8',
proargtypes => 'text int8', prosrc => 'hashtextextended' },
{ oid => '456', descr => 'hash',
proname => 'hashvarlena', prorettype => 'int4', proargtypes => 'internal',
prosrc => 'hashvarlena' },
{ oid => '772', descr => 'hash',
proname => 'hashvarlenaextended', prorettype => 'int8',
proargtypes => 'internal int8', prosrc => 'hashvarlenaextended' },
{ oid => '457', descr => 'hash',
proname => 'hashoidvector', prorettype => 'int4', proargtypes => 'oidvector',
prosrc => 'hashoidvector' },
{ oid => '776', descr => 'hash',
proname => 'hashoidvectorextended', prorettype => 'int8',
proargtypes => 'oidvector int8', prosrc => 'hashoidvectorextended' },
{ oid => '329', descr => 'hash',
proname => 'hash_aclitem', prorettype => 'int4', proargtypes => 'aclitem',
prosrc => 'hash_aclitem' },
{ oid => '777', descr => 'hash',
proname => 'hash_aclitem_extended', prorettype => 'int8',
proargtypes => 'aclitem int8', prosrc => 'hash_aclitem_extended' },
{ oid => '399', descr => 'hash',
proname => 'hashmacaddr', prorettype => 'int4', proargtypes => 'macaddr',
prosrc => 'hashmacaddr' },
{ oid => '778', descr => 'hash',
proname => 'hashmacaddrextended', prorettype => 'int8',
proargtypes => 'macaddr int8', prosrc => 'hashmacaddrextended' },
{ oid => '422', descr => 'hash',
proname => 'hashinet', prorettype => 'int4', proargtypes => 'inet',
prosrc => 'hashinet' },
{ oid => '779', descr => 'hash',
proname => 'hashinetextended', prorettype => 'int8',
proargtypes => 'inet int8', prosrc => 'hashinetextended' },
{ oid => '432', descr => 'hash',
proname => 'hash_numeric', prorettype => 'int4', proargtypes => 'numeric',
prosrc => 'hash_numeric' },
{ oid => '780', descr => 'hash',
proname => 'hash_numeric_extended', prorettype => 'int8',
proargtypes => 'numeric int8', prosrc => 'hash_numeric_extended' },
{ oid => '328', descr => 'hash',
proname => 'hashmacaddr8', prorettype => 'int4', proargtypes => 'macaddr8',
prosrc => 'hashmacaddr8' },
{ oid => '781', descr => 'hash',
proname => 'hashmacaddr8extended', prorettype => 'int8',
proargtypes => 'macaddr8 int8', prosrc => 'hashmacaddr8extended' },
{ oid => '438', descr => 'count the number of NULL arguments',
proname => 'num_nulls', provariadic => 'any', proisstrict => 'f',
prorettype => 'int4', proargtypes => 'any', proallargtypes => '{any}',
proargmodes => '{v}', prosrc => 'pg_num_nulls' },
{ oid => '440', descr => 'count the number of non-NULL arguments',
proname => 'num_nonnulls', provariadic => 'any', proisstrict => 'f',
prorettype => 'int4', proargtypes => 'any', proallargtypes => '{any}',
proargmodes => '{v}', prosrc => 'pg_num_nonnulls' },
{ oid => '458', descr => 'larger of two',
proname => 'text_larger', prorettype => 'text', proargtypes => 'text text',
prosrc => 'text_larger' },
{ oid => '459', descr => 'smaller of two',
proname => 'text_smaller', prorettype => 'text', proargtypes => 'text text',
prosrc => 'text_smaller' },
{ oid => '460', descr => 'I/O',
proname => 'int8in', prorettype => 'int8', proargtypes => 'cstring',
prosrc => 'int8in' },
{ oid => '461', descr => 'I/O',
proname => 'int8out', prorettype => 'cstring', proargtypes => 'int8',
prosrc => 'int8out' },
{ oid => '462',
proname => 'int8um', prorettype => 'int8', proargtypes => 'int8',
prosrc => 'int8um' },
{ oid => '463',
proname => 'int8pl', prorettype => 'int8', proargtypes => 'int8 int8',
prosrc => 'int8pl' },
{ oid => '464',
proname => 'int8mi', prorettype => 'int8', proargtypes => 'int8 int8',
prosrc => 'int8mi' },
{ oid => '465',
proname => 'int8mul', prorettype => 'int8', proargtypes => 'int8 int8',
prosrc => 'int8mul' },
{ oid => '466',
proname => 'int8div', prorettype => 'int8', proargtypes => 'int8 int8',
prosrc => 'int8div' },
{ oid => '467',
proname => 'int8eq', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int8 int8', prosrc => 'int8eq' },
{ oid => '468',
proname => 'int8ne', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int8 int8', prosrc => 'int8ne' },
{ oid => '469',
proname => 'int8lt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int8 int8', prosrc => 'int8lt' },
{ oid => '470',
proname => 'int8gt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int8 int8', prosrc => 'int8gt' },
{ oid => '471',
proname => 'int8le', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int8 int8', prosrc => 'int8le' },
{ oid => '472',
proname => 'int8ge', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int8 int8', prosrc => 'int8ge' },
{ oid => '474',
proname => 'int84eq', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int8 int4', prosrc => 'int84eq' },
{ oid => '475',
proname => 'int84ne', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int8 int4', prosrc => 'int84ne' },
{ oid => '476',
proname => 'int84lt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int8 int4', prosrc => 'int84lt' },
{ oid => '477',
proname => 'int84gt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int8 int4', prosrc => 'int84gt' },
{ oid => '478',
proname => 'int84le', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int8 int4', prosrc => 'int84le' },
{ oid => '479',
proname => 'int84ge', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int8 int4', prosrc => 'int84ge' },
{ oid => '480', descr => 'convert int8 to int4',
proname => 'int4', prorettype => 'int4', proargtypes => 'int8',
prosrc => 'int84' },
{ oid => '481', descr => 'convert int4 to int8',
proname => 'int8', prorettype => 'int8', proargtypes => 'int4',
prosrc => 'int48' },
{ oid => '482', descr => 'convert int8 to float8',
proname => 'float8', prorettype => 'float8', proargtypes => 'int8',
prosrc => 'i8tod' },
{ oid => '483', descr => 'convert float8 to int8',
proname => 'int8', prorettype => 'int8', proargtypes => 'float8',
prosrc => 'dtoi8' },
# OIDS 500 - 599
# OIDS 600 - 699
{ oid => '626', descr => 'hash',
proname => 'hash_array', prorettype => 'int4', proargtypes => 'anyarray',
prosrc => 'hash_array' },
{ oid => '782', descr => 'hash',
proname => 'hash_array_extended', prorettype => 'int8',
proargtypes => 'anyarray int8', prosrc => 'hash_array_extended' },
{ oid => '652', descr => 'convert int8 to float4',
proname => 'float4', prorettype => 'float4', proargtypes => 'int8',
prosrc => 'i8tof' },
{ oid => '653', descr => 'convert float4 to int8',
proname => 'int8', prorettype => 'int8', proargtypes => 'float4',
prosrc => 'ftoi8' },
{ oid => '714', descr => 'convert int8 to int2',
proname => 'int2', prorettype => 'int2', proargtypes => 'int8',
prosrc => 'int82' },
{ oid => '754', descr => 'convert int2 to int8',
proname => 'int8', prorettype => 'int8', proargtypes => 'int2',
prosrc => 'int28' },
{ oid => '655',
proname => 'namelt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'name name', prosrc => 'namelt' },
{ oid => '656',
proname => 'namele', proleakproof => 't', prorettype => 'bool',
proargtypes => 'name name', prosrc => 'namele' },
{ oid => '657',
proname => 'namegt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'name name', prosrc => 'namegt' },
{ oid => '658',
proname => 'namege', proleakproof => 't', prorettype => 'bool',
proargtypes => 'name name', prosrc => 'namege' },
{ oid => '659',
proname => 'namene', proleakproof => 't', prorettype => 'bool',
proargtypes => 'name name', prosrc => 'namene' },
{ oid => '668', descr => 'adjust char() to typmod length',
proname => 'bpchar', prorettype => 'bpchar',
proargtypes => 'bpchar int4 bool', prosrc => 'bpchar' },
{ oid => '3097', descr => 'transform a varchar length coercion',
proname => 'varchar_transform', prorettype => 'internal',
proargtypes => 'internal', prosrc => 'varchar_transform' },
{ oid => '669', descr => 'adjust varchar() to typmod length',
proname => 'varchar', protransform => 'varchar_transform',
prorettype => 'varchar', proargtypes => 'varchar int4 bool',
prosrc => 'varchar' },
{ oid => '619',
proname => 'oidvectorne', prorettype => 'bool',
proargtypes => 'oidvector oidvector', prosrc => 'oidvectorne' },
{ oid => '677',
proname => 'oidvectorlt', prorettype => 'bool',
proargtypes => 'oidvector oidvector', prosrc => 'oidvectorlt' },
{ oid => '678',
proname => 'oidvectorle', prorettype => 'bool',
proargtypes => 'oidvector oidvector', prosrc => 'oidvectorle' },
{ oid => '679',
proname => 'oidvectoreq', prorettype => 'bool',
proargtypes => 'oidvector oidvector', prosrc => 'oidvectoreq' },
{ oid => '680',
proname => 'oidvectorge', prorettype => 'bool',
proargtypes => 'oidvector oidvector', prosrc => 'oidvectorge' },
{ oid => '681',
proname => 'oidvectorgt', prorettype => 'bool',
proargtypes => 'oidvector oidvector', prosrc => 'oidvectorgt' },
# OIDS 700 - 799
{ oid => '710', descr => 'deprecated, use current_user instead',
proname => 'getpgusername', provolatile => 's', prorettype => 'name',
proargtypes => '', prosrc => 'current_user' },
{ oid => '716',
proname => 'oidlt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'oid oid', prosrc => 'oidlt' },
{ oid => '717',
proname => 'oidle', proleakproof => 't', prorettype => 'bool',
proargtypes => 'oid oid', prosrc => 'oidle' },
{ oid => '720', descr => 'octet length',
proname => 'octet_length', prorettype => 'int4', proargtypes => 'bytea',
prosrc => 'byteaoctetlen' },
{ oid => '721', descr => 'get byte',
proname => 'get_byte', prorettype => 'int4', proargtypes => 'bytea int4',
prosrc => 'byteaGetByte' },
{ oid => '722', descr => 'set byte',
proname => 'set_byte', prorettype => 'bytea',
proargtypes => 'bytea int4 int4', prosrc => 'byteaSetByte' },
{ oid => '723', descr => 'get bit',
proname => 'get_bit', prorettype => 'int4', proargtypes => 'bytea int4',
prosrc => 'byteaGetBit' },
{ oid => '724', descr => 'set bit',
proname => 'set_bit', prorettype => 'bytea', proargtypes => 'bytea int4 int4',
prosrc => 'byteaSetBit' },
{ oid => '749', descr => 'substitute portion of string',
proname => 'overlay', prorettype => 'bytea',
proargtypes => 'bytea bytea int4 int4', prosrc => 'byteaoverlay' },
{ oid => '752', descr => 'substitute portion of string',
proname => 'overlay', prorettype => 'bytea',
proargtypes => 'bytea bytea int4', prosrc => 'byteaoverlay_no_len' },
{ oid => '725',
proname => 'dist_pl', prorettype => 'float8', proargtypes => 'point line',
prosrc => 'dist_pl' },
{ oid => '726',
proname => 'dist_lb', prorettype => 'float8', proargtypes => 'line box',
prosrc => 'dist_lb' },
{ oid => '727',
proname => 'dist_sl', prorettype => 'float8', proargtypes => 'lseg line',
prosrc => 'dist_sl' },
{ oid => '728',
proname => 'dist_cpoly', prorettype => 'float8',
proargtypes => 'circle polygon', prosrc => 'dist_cpoly' },
{ oid => '729',
proname => 'poly_distance', prorettype => 'float8',
proargtypes => 'polygon polygon', prosrc => 'poly_distance' },
{ oid => '3275',
proname => 'dist_ppoly', prorettype => 'float8',
proargtypes => 'point polygon', prosrc => 'dist_ppoly' },
{ oid => '3292',
proname => 'dist_polyp', prorettype => 'float8',
proargtypes => 'polygon point', prosrc => 'dist_polyp' },
{ oid => '3290',
proname => 'dist_cpoint', prorettype => 'float8',
proargtypes => 'circle point', prosrc => 'dist_cpoint' },
{ oid => '740',
proname => 'text_lt', prorettype => 'bool', proargtypes => 'text text',
prosrc => 'text_lt' },
{ oid => '741',
proname => 'text_le', prorettype => 'bool', proargtypes => 'text text',
prosrc => 'text_le' },
{ oid => '742',
proname => 'text_gt', prorettype => 'bool', proargtypes => 'text text',
prosrc => 'text_gt' },
{ oid => '743',
proname => 'text_ge', prorettype => 'bool', proargtypes => 'text text',
prosrc => 'text_ge' },
{ oid => '745', descr => 'current user name',
proname => 'current_user', provolatile => 's', prorettype => 'name',
proargtypes => '', prosrc => 'current_user' },
{ oid => '746', descr => 'session user name',
proname => 'session_user', provolatile => 's', prorettype => 'name',
proargtypes => '', prosrc => 'session_user' },
{ oid => '744',
proname => 'array_eq', prorettype => 'bool',
proargtypes => 'anyarray anyarray', prosrc => 'array_eq' },
{ oid => '390',
proname => 'array_ne', prorettype => 'bool',
proargtypes => 'anyarray anyarray', prosrc => 'array_ne' },
{ oid => '391',
proname => 'array_lt', prorettype => 'bool',
proargtypes => 'anyarray anyarray', prosrc => 'array_lt' },
{ oid => '392',
proname => 'array_gt', prorettype => 'bool',
proargtypes => 'anyarray anyarray', prosrc => 'array_gt' },
{ oid => '393',
proname => 'array_le', prorettype => 'bool',
proargtypes => 'anyarray anyarray', prosrc => 'array_le' },
{ oid => '396',
proname => 'array_ge', prorettype => 'bool',
proargtypes => 'anyarray anyarray', prosrc => 'array_ge' },
{ oid => '747', descr => 'array dimensions',
proname => 'array_dims', prorettype => 'text', proargtypes => 'anyarray',
prosrc => 'array_dims' },
{ oid => '748', descr => 'number of array dimensions',
proname => 'array_ndims', prorettype => 'int4', proargtypes => 'anyarray',
prosrc => 'array_ndims' },
{ oid => '750', descr => 'I/O',
proname => 'array_in', provolatile => 's', prorettype => 'anyarray',
proargtypes => 'cstring oid int4', prosrc => 'array_in' },
{ oid => '751', descr => 'I/O',
proname => 'array_out', provolatile => 's', prorettype => 'cstring',
proargtypes => 'anyarray', prosrc => 'array_out' },
{ oid => '2091', descr => 'array lower dimension',
proname => 'array_lower', prorettype => 'int4',
proargtypes => 'anyarray int4', prosrc => 'array_lower' },
{ oid => '2092', descr => 'array upper dimension',
proname => 'array_upper', prorettype => 'int4',
proargtypes => 'anyarray int4', prosrc => 'array_upper' },
{ oid => '2176', descr => 'array length',
proname => 'array_length', prorettype => 'int4',
proargtypes => 'anyarray int4', prosrc => 'array_length' },
{ oid => '3179', descr => 'array cardinality',
proname => 'cardinality', prorettype => 'int4', proargtypes => 'anyarray',
prosrc => 'array_cardinality' },
{ oid => '378', descr => 'append element onto end of array',
proname => 'array_append', proisstrict => 'f', prorettype => 'anyarray',
proargtypes => 'anyarray anyelement', prosrc => 'array_append' },
{ oid => '379', descr => 'prepend element onto front of array',
proname => 'array_prepend', proisstrict => 'f', prorettype => 'anyarray',
proargtypes => 'anyelement anyarray', prosrc => 'array_prepend' },
{ oid => '383',
proname => 'array_cat', proisstrict => 'f', prorettype => 'anyarray',
proargtypes => 'anyarray anyarray', prosrc => 'array_cat' },
{ oid => '394', descr => 'split delimited text into text[]',
proname => 'string_to_array', proisstrict => 'f', prorettype => '_text',
proargtypes => 'text text', prosrc => 'text_to_array' },
{ oid => '395',
descr => 'concatenate array elements, using delimiter, into text',
proname => 'array_to_string', provolatile => 's', prorettype => 'text',
proargtypes => 'anyarray text', prosrc => 'array_to_text' },
{ oid => '376', descr => 'split delimited text into text[], with null string',
proname => 'string_to_array', proisstrict => 'f', prorettype => '_text',
proargtypes => 'text text text', prosrc => 'text_to_array_null' },
{ oid => '384',
descr => 'concatenate array elements, using delimiter and null string, into text',
proname => 'array_to_string', proisstrict => 'f', provolatile => 's',
prorettype => 'text', proargtypes => 'anyarray text text',
prosrc => 'array_to_text_null' },
{ oid => '515', descr => 'larger of two',
proname => 'array_larger', prorettype => 'anyarray',
proargtypes => 'anyarray anyarray', prosrc => 'array_larger' },
{ oid => '516', descr => 'smaller of two',
proname => 'array_smaller', prorettype => 'anyarray',
proargtypes => 'anyarray anyarray', prosrc => 'array_smaller' },
{ oid => '3277', descr => 'returns an offset of value in array',
proname => 'array_position', proisstrict => 'f', prorettype => 'int4',
proargtypes => 'anyarray anyelement', prosrc => 'array_position' },
{ oid => '3278',
descr => 'returns an offset of value in array with start index',
proname => 'array_position', proisstrict => 'f', prorettype => 'int4',
proargtypes => 'anyarray anyelement int4', prosrc => 'array_position_start' },
{ oid => '3279',
descr => 'returns an array of offsets of some value in array',
proname => 'array_positions', proisstrict => 'f', prorettype => '_int4',
proargtypes => 'anyarray anyelement', prosrc => 'array_positions' },
{ oid => '1191', descr => 'array subscripts generator',
proname => 'generate_subscripts', prorows => '1000', proretset => 't',
prorettype => 'int4', proargtypes => 'anyarray int4 bool',
prosrc => 'generate_subscripts' },
{ oid => '1192', descr => 'array subscripts generator',
proname => 'generate_subscripts', prorows => '1000', proretset => 't',
prorettype => 'int4', proargtypes => 'anyarray int4',
prosrc => 'generate_subscripts_nodir' },
{ oid => '1193', descr => 'array constructor with value',
proname => 'array_fill', proisstrict => 'f', prorettype => 'anyarray',
proargtypes => 'anyelement _int4', prosrc => 'array_fill' },
{ oid => '1286', descr => 'array constructor with value',
proname => 'array_fill', proisstrict => 'f', prorettype => 'anyarray',
proargtypes => 'anyelement _int4 _int4',
prosrc => 'array_fill_with_lower_bounds' },
{ oid => '2331', descr => 'expand array to set of rows',
proname => 'unnest', prorows => '100', proretset => 't',
prorettype => 'anyelement', proargtypes => 'anyarray',
prosrc => 'array_unnest' },
{ oid => '3167',
descr => 'remove any occurrences of an element from an array',
proname => 'array_remove', proisstrict => 'f', prorettype => 'anyarray',
proargtypes => 'anyarray anyelement', prosrc => 'array_remove' },
{ oid => '3168', descr => 'replace any occurrences of an element in an array',
proname => 'array_replace', proisstrict => 'f', prorettype => 'anyarray',
proargtypes => 'anyarray anyelement anyelement', prosrc => 'array_replace' },
{ oid => '2333', descr => 'aggregate transition function',
proname => 'array_agg_transfn', proisstrict => 'f', prorettype => 'internal',
proargtypes => 'internal anynonarray', prosrc => 'array_agg_transfn' },
{ oid => '2334', descr => 'aggregate final function',
proname => 'array_agg_finalfn', proisstrict => 'f', prorettype => 'anyarray',
proargtypes => 'internal anynonarray', prosrc => 'array_agg_finalfn' },
{ oid => '2335', descr => 'concatenate aggregate input into an array',
proname => 'array_agg', prokind => 'a', proisstrict => 'f',
prorettype => 'anyarray', proargtypes => 'anynonarray',
prosrc => 'aggregate_dummy' },
{ oid => '4051', descr => 'aggregate transition function',
proname => 'array_agg_array_transfn', proisstrict => 'f',
prorettype => 'internal', proargtypes => 'internal anyarray',
prosrc => 'array_agg_array_transfn' },
{ oid => '4052', descr => 'aggregate final function',
proname => 'array_agg_array_finalfn', proisstrict => 'f',
prorettype => 'anyarray', proargtypes => 'internal anyarray',
prosrc => 'array_agg_array_finalfn' },
{ oid => '4053', descr => 'concatenate aggregate input into an array',
proname => 'array_agg', prokind => 'a', proisstrict => 'f',
prorettype => 'anyarray', proargtypes => 'anyarray',
prosrc => 'aggregate_dummy' },
{ oid => '3218',
descr => 'bucket number of operand given a sorted array of bucket lower bounds',
proname => 'width_bucket', prorettype => 'int4',
proargtypes => 'anyelement anyarray', prosrc => 'width_bucket_array' },
{ oid => '3816', descr => 'array typanalyze',
proname => 'array_typanalyze', provolatile => 's', prorettype => 'bool',
proargtypes => 'internal', prosrc => 'array_typanalyze' },
{ oid => '3817',
descr => 'restriction selectivity for array-containment operators',
proname => 'arraycontsel', provolatile => 's', prorettype => 'float8',
proargtypes => 'internal oid internal int4', prosrc => 'arraycontsel' },
{ oid => '3818', descr => 'join selectivity for array-containment operators',
proname => 'arraycontjoinsel', provolatile => 's', prorettype => 'float8',
proargtypes => 'internal oid internal int2 internal',
prosrc => 'arraycontjoinsel' },
{ oid => '760', descr => 'I/O',
proname => 'smgrin', provolatile => 's', prorettype => 'smgr',
proargtypes => 'cstring', prosrc => 'smgrin' },
{ oid => '761', descr => 'I/O',
proname => 'smgrout', provolatile => 's', prorettype => 'cstring',
proargtypes => 'smgr', prosrc => 'smgrout' },
{ oid => '762', descr => 'storage manager',
proname => 'smgreq', prorettype => 'bool', proargtypes => 'smgr smgr',
prosrc => 'smgreq' },
{ oid => '763', descr => 'storage manager',
proname => 'smgrne', prorettype => 'bool', proargtypes => 'smgr smgr',
prosrc => 'smgrne' },
{ oid => '764', descr => 'large object import',
proname => 'lo_import', provolatile => 'v', proparallel => 'u',
prorettype => 'oid', proargtypes => 'text', prosrc => 'be_lo_import' },
{ oid => '767', descr => 'large object import',
proname => 'lo_import', provolatile => 'v', proparallel => 'u',
prorettype => 'oid', proargtypes => 'text oid',
prosrc => 'be_lo_import_with_oid' },
{ oid => '765', descr => 'large object export',
proname => 'lo_export', provolatile => 'v', proparallel => 'u',
prorettype => 'int4', proargtypes => 'oid text', prosrc => 'be_lo_export' },
{ oid => '766', descr => 'increment',
proname => 'int4inc', prorettype => 'int4', proargtypes => 'int4',
prosrc => 'int4inc' },
{ oid => '768', descr => 'larger of two',
proname => 'int4larger', prorettype => 'int4', proargtypes => 'int4 int4',
prosrc => 'int4larger' },
{ oid => '769', descr => 'smaller of two',
proname => 'int4smaller', prorettype => 'int4', proargtypes => 'int4 int4',
prosrc => 'int4smaller' },
{ oid => '770', descr => 'larger of two',
proname => 'int2larger', prorettype => 'int2', proargtypes => 'int2 int2',
prosrc => 'int2larger' },
{ oid => '771', descr => 'smaller of two',
proname => 'int2smaller', prorettype => 'int2', proargtypes => 'int2 int2',
prosrc => 'int2smaller' },
# OIDS 800 - 899
{ oid => '846',
proname => 'cash_mul_flt4', prorettype => 'money',
proargtypes => 'money float4', prosrc => 'cash_mul_flt4' },
{ oid => '847',
proname => 'cash_div_flt4', prorettype => 'money',
proargtypes => 'money float4', prosrc => 'cash_div_flt4' },
{ oid => '848',
proname => 'flt4_mul_cash', prorettype => 'money',
proargtypes => 'float4 money', prosrc => 'flt4_mul_cash' },
{ oid => '849', descr => 'position of substring',
proname => 'position', prorettype => 'int4', proargtypes => 'text text',
prosrc => 'textpos' },
{ oid => '850',
proname => 'textlike', prorettype => 'bool', proargtypes => 'text text',
prosrc => 'textlike' },
{ oid => '851',
proname => 'textnlike', prorettype => 'bool', proargtypes => 'text text',
prosrc => 'textnlike' },
{ oid => '852',
proname => 'int48eq', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int4 int8', prosrc => 'int48eq' },
{ oid => '853',
proname => 'int48ne', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int4 int8', prosrc => 'int48ne' },
{ oid => '854',
proname => 'int48lt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int4 int8', prosrc => 'int48lt' },
{ oid => '855',
proname => 'int48gt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int4 int8', prosrc => 'int48gt' },
{ oid => '856',
proname => 'int48le', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int4 int8', prosrc => 'int48le' },
{ oid => '857',
proname => 'int48ge', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int4 int8', prosrc => 'int48ge' },
{ oid => '858',
proname => 'namelike', prorettype => 'bool', proargtypes => 'name text',
prosrc => 'namelike' },
{ oid => '859',
proname => 'namenlike', prorettype => 'bool', proargtypes => 'name text',
prosrc => 'namenlike' },
{ oid => '860', descr => 'convert char to char(n)',
proname => 'bpchar', prorettype => 'bpchar', proargtypes => 'char',
prosrc => 'char_bpchar' },
{ oid => '861', descr => 'name of the current database',
proname => 'current_database', provolatile => 's', prorettype => 'name',
proargtypes => '', prosrc => 'current_database' },
{ oid => '817', descr => 'get the currently executing query',
proname => 'current_query', proisstrict => 'f', provolatile => 'v',
proparallel => 'r', prorettype => 'text', proargtypes => '',
prosrc => 'current_query' },
{ oid => '3399',
proname => 'int8_mul_cash', prorettype => 'money',
proargtypes => 'int8 money', prosrc => 'int8_mul_cash' },
{ oid => '862',
proname => 'int4_mul_cash', prorettype => 'money',
proargtypes => 'int4 money', prosrc => 'int4_mul_cash' },
{ oid => '863',
proname => 'int2_mul_cash', prorettype => 'money',
proargtypes => 'int2 money', prosrc => 'int2_mul_cash' },
{ oid => '3344',
proname => 'cash_mul_int8', prorettype => 'money',
proargtypes => 'money int8', prosrc => 'cash_mul_int8' },
{ oid => '3345',
proname => 'cash_div_int8', prorettype => 'money',
proargtypes => 'money int8', prosrc => 'cash_div_int8' },
{ oid => '864',
proname => 'cash_mul_int4', prorettype => 'money',
proargtypes => 'money int4', prosrc => 'cash_mul_int4' },
{ oid => '865',
proname => 'cash_div_int4', prorettype => 'money',
proargtypes => 'money int4', prosrc => 'cash_div_int4' },
{ oid => '866',
proname => 'cash_mul_int2', prorettype => 'money',
proargtypes => 'money int2', prosrc => 'cash_mul_int2' },
{ oid => '867',
proname => 'cash_div_int2', prorettype => 'money',
proargtypes => 'money int2', prosrc => 'cash_div_int2' },
{ oid => '886', descr => 'I/O',
proname => 'cash_in', provolatile => 's', prorettype => 'money',
proargtypes => 'cstring', prosrc => 'cash_in' },
{ oid => '887', descr => 'I/O',
proname => 'cash_out', provolatile => 's', prorettype => 'cstring',
proargtypes => 'money', prosrc => 'cash_out' },
{ oid => '888',
proname => 'cash_eq', proleakproof => 't', prorettype => 'bool',
proargtypes => 'money money', prosrc => 'cash_eq' },
{ oid => '889',
proname => 'cash_ne', proleakproof => 't', prorettype => 'bool',
proargtypes => 'money money', prosrc => 'cash_ne' },
{ oid => '890',
proname => 'cash_lt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'money money', prosrc => 'cash_lt' },
{ oid => '891',
proname => 'cash_le', proleakproof => 't', prorettype => 'bool',
proargtypes => 'money money', prosrc => 'cash_le' },
{ oid => '892',
proname => 'cash_gt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'money money', prosrc => 'cash_gt' },
{ oid => '893',
proname => 'cash_ge', proleakproof => 't', prorettype => 'bool',
proargtypes => 'money money', prosrc => 'cash_ge' },
{ oid => '894',
proname => 'cash_pl', prorettype => 'money', proargtypes => 'money money',
prosrc => 'cash_pl' },
{ oid => '895',
proname => 'cash_mi', prorettype => 'money', proargtypes => 'money money',
prosrc => 'cash_mi' },
{ oid => '896',
proname => 'cash_mul_flt8', prorettype => 'money',
proargtypes => 'money float8', prosrc => 'cash_mul_flt8' },
{ oid => '897',
proname => 'cash_div_flt8', prorettype => 'money',
proargtypes => 'money float8', prosrc => 'cash_div_flt8' },
{ oid => '898', descr => 'larger of two',
proname => 'cashlarger', prorettype => 'money', proargtypes => 'money money',
prosrc => 'cashlarger' },
{ oid => '899', descr => 'smaller of two',
proname => 'cashsmaller', prorettype => 'money', proargtypes => 'money money',
prosrc => 'cashsmaller' },
{ oid => '919',
proname => 'flt8_mul_cash', prorettype => 'money',
proargtypes => 'float8 money', prosrc => 'flt8_mul_cash' },
{ oid => '935', descr => 'output money amount as words',
proname => 'cash_words', prorettype => 'text', proargtypes => 'money',
prosrc => 'cash_words' },
{ oid => '3822',
proname => 'cash_div_cash', prorettype => 'float8',
proargtypes => 'money money', prosrc => 'cash_div_cash' },
{ oid => '3823', descr => 'convert money to numeric',
proname => 'numeric', provolatile => 's', prorettype => 'numeric',
proargtypes => 'money', prosrc => 'cash_numeric' },
{ oid => '3824', descr => 'convert numeric to money',
proname => 'money', provolatile => 's', prorettype => 'money',
proargtypes => 'numeric', prosrc => 'numeric_cash' },
{ oid => '3811', descr => 'convert int4 to money',
proname => 'money', provolatile => 's', prorettype => 'money',
proargtypes => 'int4', prosrc => 'int4_cash' },
{ oid => '3812', descr => 'convert int8 to money',
proname => 'money', provolatile => 's', prorettype => 'money',
proargtypes => 'int8', prosrc => 'int8_cash' },
# OIDS 900 - 999
{ oid => '940', descr => 'modulus',
proname => 'mod', prorettype => 'int2', proargtypes => 'int2 int2',
prosrc => 'int2mod' },
{ oid => '941', descr => 'modulus',
proname => 'mod', prorettype => 'int4', proargtypes => 'int4 int4',
prosrc => 'int4mod' },
{ oid => '945',
proname => 'int8mod', prorettype => 'int8', proargtypes => 'int8 int8',
prosrc => 'int8mod' },
{ oid => '947', descr => 'modulus',
proname => 'mod', prorettype => 'int8', proargtypes => 'int8 int8',
prosrc => 'int8mod' },
{ oid => '944', descr => 'convert text to char',
proname => 'char', prorettype => 'char', proargtypes => 'text',
prosrc => 'text_char' },
{ oid => '946', descr => 'convert char to text',
proname => 'text', prorettype => 'text', proargtypes => 'char',
prosrc => 'char_text' },
{ oid => '952', descr => 'large object open',
proname => 'lo_open', provolatile => 'v', proparallel => 'u',
prorettype => 'int4', proargtypes => 'oid int4', prosrc => 'be_lo_open' },
{ oid => '953', descr => 'large object close',
proname => 'lo_close', provolatile => 'v', proparallel => 'u',
prorettype => 'int4', proargtypes => 'int4', prosrc => 'be_lo_close' },
{ oid => '954', descr => 'large object read',
proname => 'loread', provolatile => 'v', proparallel => 'u',
prorettype => 'bytea', proargtypes => 'int4 int4', prosrc => 'be_loread' },
{ oid => '955', descr => 'large object write',
proname => 'lowrite', provolatile => 'v', proparallel => 'u',
prorettype => 'int4', proargtypes => 'int4 bytea', prosrc => 'be_lowrite' },
{ oid => '956', descr => 'large object seek',
proname => 'lo_lseek', provolatile => 'v', proparallel => 'u',
prorettype => 'int4', proargtypes => 'int4 int4 int4',
prosrc => 'be_lo_lseek' },
{ oid => '3170', descr => 'large object seek (64 bit)',
proname => 'lo_lseek64', provolatile => 'v', proparallel => 'u',
prorettype => 'int8', proargtypes => 'int4 int8 int4',
prosrc => 'be_lo_lseek64' },
{ oid => '957', descr => 'large object create',
proname => 'lo_creat', provolatile => 'v', proparallel => 'u',
prorettype => 'oid', proargtypes => 'int4', prosrc => 'be_lo_creat' },
{ oid => '715', descr => 'large object create',
proname => 'lo_create', provolatile => 'v', proparallel => 'u',
prorettype => 'oid', proargtypes => 'oid', prosrc => 'be_lo_create' },
{ oid => '958', descr => 'large object position',
proname => 'lo_tell', provolatile => 'v', proparallel => 'u',
prorettype => 'int4', proargtypes => 'int4', prosrc => 'be_lo_tell' },
{ oid => '3171', descr => 'large object position (64 bit)',
proname => 'lo_tell64', provolatile => 'v', proparallel => 'u',
prorettype => 'int8', proargtypes => 'int4', prosrc => 'be_lo_tell64' },
{ oid => '1004', descr => 'truncate large object',
proname => 'lo_truncate', provolatile => 'v', proparallel => 'u',
prorettype => 'int4', proargtypes => 'int4 int4',
prosrc => 'be_lo_truncate' },
{ oid => '3172', descr => 'truncate large object (64 bit)',
proname => 'lo_truncate64', provolatile => 'v', proparallel => 'u',
prorettype => 'int4', proargtypes => 'int4 int8',
prosrc => 'be_lo_truncate64' },
{ oid => '3457', descr => 'create new large object with given content',
proname => 'lo_from_bytea', provolatile => 'v', proparallel => 'u',
prorettype => 'oid', proargtypes => 'oid bytea',
prosrc => 'be_lo_from_bytea' },
{ oid => '3458', descr => 'read entire large object',
proname => 'lo_get', provolatile => 'v', proparallel => 'u',
prorettype => 'bytea', proargtypes => 'oid', prosrc => 'be_lo_get' },
{ oid => '3459', descr => 'read large object from offset for length',
proname => 'lo_get', provolatile => 'v', proparallel => 'u',
prorettype => 'bytea', proargtypes => 'oid int8 int4',
prosrc => 'be_lo_get_fragment' },
{ oid => '3460', descr => 'write data at offset',
proname => 'lo_put', provolatile => 'v', proparallel => 'u',
prorettype => 'void', proargtypes => 'oid int8 bytea',
prosrc => 'be_lo_put' },
{ oid => '959',
proname => 'on_pl', prorettype => 'bool', proargtypes => 'point line',
prosrc => 'on_pl' },
{ oid => '960',
proname => 'on_sl', prorettype => 'bool', proargtypes => 'lseg line',
prosrc => 'on_sl' },
{ oid => '961',
proname => 'close_pl', prorettype => 'point', proargtypes => 'point line',
prosrc => 'close_pl' },
{ oid => '962',
proname => 'close_sl', prorettype => 'point', proargtypes => 'lseg line',
prosrc => 'close_sl' },
{ oid => '963',
proname => 'close_lb', prorettype => 'point', proargtypes => 'line box',
prosrc => 'close_lb' },
{ oid => '964', descr => 'large object unlink (delete)',
proname => 'lo_unlink', provolatile => 'v', proparallel => 'u',
prorettype => 'int4', proargtypes => 'oid', prosrc => 'be_lo_unlink' },
{ oid => '973',
proname => 'path_inter', prorettype => 'bool', proargtypes => 'path path',
prosrc => 'path_inter' },
{ oid => '975', descr => 'box area',
proname => 'area', prorettype => 'float8', proargtypes => 'box',
prosrc => 'box_area' },
{ oid => '976', descr => 'box width',
proname => 'width', prorettype => 'float8', proargtypes => 'box',
prosrc => 'box_width' },
{ oid => '977', descr => 'box height',
proname => 'height', prorettype => 'float8', proargtypes => 'box',
prosrc => 'box_height' },
{ oid => '978',
proname => 'box_distance', prorettype => 'float8', proargtypes => 'box box',
prosrc => 'box_distance' },
{ oid => '979', descr => 'area of a closed path',
proname => 'area', prorettype => 'float8', proargtypes => 'path',
prosrc => 'path_area' },
{ oid => '980',
proname => 'box_intersect', prorettype => 'box', proargtypes => 'box box',
prosrc => 'box_intersect' },
{ oid => '4067', descr => 'bounding box of two boxes',
proname => 'bound_box', prorettype => 'box', proargtypes => 'box box',
prosrc => 'boxes_bound_box' },
{ oid => '981', descr => 'box diagonal',
proname => 'diagonal', prorettype => 'lseg', proargtypes => 'box',
prosrc => 'box_diagonal' },
{ oid => '982',
proname => 'path_n_lt', prorettype => 'bool', proargtypes => 'path path',
prosrc => 'path_n_lt' },
{ oid => '983',
proname => 'path_n_gt', prorettype => 'bool', proargtypes => 'path path',
prosrc => 'path_n_gt' },
{ oid => '984',
proname => 'path_n_eq', prorettype => 'bool', proargtypes => 'path path',
prosrc => 'path_n_eq' },
{ oid => '985',
proname => 'path_n_le', prorettype => 'bool', proargtypes => 'path path',
prosrc => 'path_n_le' },
{ oid => '986',
proname => 'path_n_ge', prorettype => 'bool', proargtypes => 'path path',
prosrc => 'path_n_ge' },
{ oid => '987',
proname => 'path_length', prorettype => 'float8', proargtypes => 'path',
prosrc => 'path_length' },
{ oid => '988',
proname => 'point_ne', prorettype => 'bool', proargtypes => 'point point',
prosrc => 'point_ne' },
{ oid => '989',
proname => 'point_vert', prorettype => 'bool', proargtypes => 'point point',
prosrc => 'point_vert' },
{ oid => '990',
proname => 'point_horiz', prorettype => 'bool', proargtypes => 'point point',
prosrc => 'point_horiz' },
{ oid => '991',
proname => 'point_distance', prorettype => 'float8',
proargtypes => 'point point', prosrc => 'point_distance' },
{ oid => '992', descr => 'slope between points',
proname => 'slope', prorettype => 'float8', proargtypes => 'point point',
prosrc => 'point_slope' },
{ oid => '993', descr => 'convert points to line segment',
proname => 'lseg', prorettype => 'lseg', proargtypes => 'point point',
prosrc => 'lseg_construct' },
{ oid => '994',
proname => 'lseg_intersect', prorettype => 'bool', proargtypes => 'lseg lseg',
prosrc => 'lseg_intersect' },
{ oid => '995',
proname => 'lseg_parallel', prorettype => 'bool', proargtypes => 'lseg lseg',
prosrc => 'lseg_parallel' },
{ oid => '996',
proname => 'lseg_perp', prorettype => 'bool', proargtypes => 'lseg lseg',
prosrc => 'lseg_perp' },
{ oid => '997',
proname => 'lseg_vertical', prorettype => 'bool', proargtypes => 'lseg',
prosrc => 'lseg_vertical' },
{ oid => '998',
proname => 'lseg_horizontal', prorettype => 'bool', proargtypes => 'lseg',
prosrc => 'lseg_horizontal' },
{ oid => '999',
proname => 'lseg_eq', proleakproof => 't', prorettype => 'bool',
proargtypes => 'lseg lseg', prosrc => 'lseg_eq' },
# OIDS 1000 - 1999
{ oid => '3994', descr => 'transform a time zone adjustment',
proname => 'timestamp_izone_transform', prorettype => 'internal',
proargtypes => 'internal', prosrc => 'timestamp_izone_transform' },
{ oid => '1026', descr => 'adjust timestamp to new time zone',
proname => 'timezone', protransform => 'timestamp_izone_transform',
prorettype => 'timestamp', proargtypes => 'interval timestamptz',
prosrc => 'timestamptz_izone' },
{ oid => '1031', descr => 'I/O',
proname => 'aclitemin', provolatile => 's', prorettype => 'aclitem',
proargtypes => 'cstring', prosrc => 'aclitemin' },
{ oid => '1032', descr => 'I/O',
proname => 'aclitemout', provolatile => 's', prorettype => 'cstring',
proargtypes => 'aclitem', prosrc => 'aclitemout' },
{ oid => '1035', descr => 'add/update ACL item',
proname => 'aclinsert', prorettype => '_aclitem',
proargtypes => '_aclitem aclitem', prosrc => 'aclinsert' },
{ oid => '1036', descr => 'remove ACL item',
proname => 'aclremove', prorettype => '_aclitem',
proargtypes => '_aclitem aclitem', prosrc => 'aclremove' },
{ oid => '1037', descr => 'contains',
proname => 'aclcontains', prorettype => 'bool',
proargtypes => '_aclitem aclitem', prosrc => 'aclcontains' },
{ oid => '1062',
proname => 'aclitemeq', prorettype => 'bool',
proargtypes => 'aclitem aclitem', prosrc => 'aclitem_eq' },
{ oid => '1365', descr => 'make ACL item',
proname => 'makeaclitem', prorettype => 'aclitem',
proargtypes => 'oid oid text bool', prosrc => 'makeaclitem' },
Propagate xactStartTimestamp and stmtStartTimestamp to parallel workers. Previously, a worker process would establish values for these based on its own start time. In v10 and up, this can trivially be shown to cause misbehavior of transaction_timestamp(), timestamp_in(), and related functions which are (perhaps unwisely?) marked parallel-safe. It seems likely that other behaviors might diverge from what happens in the parent as well. It's not as trivial to demonstrate problems in 9.6 or 9.5, but I'm sure it's still possible, so back-patch to all branches containing parallel worker infrastructure. In HEAD only, mark now() and statement_timestamp() as parallel-safe (other affected functions already were). While in theory we could still squeeze that change into v11, it doesn't seem important enough to force a last-minute catversion bump. Konstantin Knizhnik, whacked around a bit by me Discussion: https://postgr.es/m/6406dbd2-5d37-4cb6-6eb2-9c44172c7e7c@postgrespro.ru
2018-10-06 18:00:09 +02:00
{ oid => '3943',
descr => 'show hardwired default privileges, primarily for use by the information schema',
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
proname => 'acldefault', prorettype => '_aclitem', proargtypes => 'char oid',
prosrc => 'acldefault_sql' },
{ oid => '1689',
Document aclitem functions and operators aclitem functions and operators have been heretofore undocumented. Fix that. While at it, ensure the non-operator aclitem functions have pg_description strings. Does not seem worthwhile to back-patch. Author: Fabien Coelho, with pg_description from John Naylor, and significant refactoring and editorialization by me. Reviewed by: Tom Lane Discussion: https://postgr.es/m/flat/alpine.DEB.2.21.1808010825490.18204%40lancre
2018-09-24 16:14:57 +02:00
descr => 'convert ACL item array to table, primarily for use by information schema',
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
proname => 'aclexplode', prorows => '10', proretset => 't',
provolatile => 's', prorettype => 'record', proargtypes => '_aclitem',
proallargtypes => '{_aclitem,oid,oid,text,bool}',
proargmodes => '{i,o,o,o,o}',
proargnames => '{acl,grantor,grantee,privilege_type,is_grantable}',
prosrc => 'aclexplode' },
{ oid => '1044', descr => 'I/O',
proname => 'bpcharin', prorettype => 'bpchar',
proargtypes => 'cstring oid int4', prosrc => 'bpcharin' },
{ oid => '1045', descr => 'I/O',
proname => 'bpcharout', prorettype => 'cstring', proargtypes => 'bpchar',
prosrc => 'bpcharout' },
{ oid => '2913', descr => 'I/O typmod',
proname => 'bpchartypmodin', prorettype => 'int4', proargtypes => '_cstring',
prosrc => 'bpchartypmodin' },
{ oid => '2914', descr => 'I/O typmod',
proname => 'bpchartypmodout', prorettype => 'cstring', proargtypes => 'int4',
prosrc => 'bpchartypmodout' },
{ oid => '1046', descr => 'I/O',
proname => 'varcharin', prorettype => 'varchar',
proargtypes => 'cstring oid int4', prosrc => 'varcharin' },
{ oid => '1047', descr => 'I/O',
proname => 'varcharout', prorettype => 'cstring', proargtypes => 'varchar',
prosrc => 'varcharout' },
{ oid => '2915', descr => 'I/O typmod',
proname => 'varchartypmodin', prorettype => 'int4', proargtypes => '_cstring',
prosrc => 'varchartypmodin' },
{ oid => '2916', descr => 'I/O typmod',
proname => 'varchartypmodout', prorettype => 'cstring', proargtypes => 'int4',
prosrc => 'varchartypmodout' },
{ oid => '1048',
proname => 'bpchareq', proleakproof => 't', prorettype => 'bool',
proargtypes => 'bpchar bpchar', prosrc => 'bpchareq' },
{ oid => '1049',
proname => 'bpcharlt', prorettype => 'bool', proargtypes => 'bpchar bpchar',
prosrc => 'bpcharlt' },
{ oid => '1050',
proname => 'bpcharle', prorettype => 'bool', proargtypes => 'bpchar bpchar',
prosrc => 'bpcharle' },
{ oid => '1051',
proname => 'bpchargt', prorettype => 'bool', proargtypes => 'bpchar bpchar',
prosrc => 'bpchargt' },
{ oid => '1052',
proname => 'bpcharge', prorettype => 'bool', proargtypes => 'bpchar bpchar',
prosrc => 'bpcharge' },
{ oid => '1053',
proname => 'bpcharne', proleakproof => 't', prorettype => 'bool',
proargtypes => 'bpchar bpchar', prosrc => 'bpcharne' },
{ oid => '1063', descr => 'larger of two',
proname => 'bpchar_larger', prorettype => 'bpchar',
proargtypes => 'bpchar bpchar', prosrc => 'bpchar_larger' },
{ oid => '1064', descr => 'smaller of two',
proname => 'bpchar_smaller', prorettype => 'bpchar',
proargtypes => 'bpchar bpchar', prosrc => 'bpchar_smaller' },
{ oid => '1078', descr => 'less-equal-greater',
proname => 'bpcharcmp', prorettype => 'int4', proargtypes => 'bpchar bpchar',
prosrc => 'bpcharcmp' },
{ oid => '3328', descr => 'sort support',
proname => 'bpchar_sortsupport', prorettype => 'void',
proargtypes => 'internal', prosrc => 'bpchar_sortsupport' },
{ oid => '1080', descr => 'hash',
proname => 'hashbpchar', prorettype => 'int4', proargtypes => 'bpchar',
prosrc => 'hashbpchar' },
{ oid => '972', descr => 'hash',
proname => 'hashbpcharextended', prorettype => 'int8',
proargtypes => 'bpchar int8', prosrc => 'hashbpcharextended' },
{ oid => '1081', descr => 'format a type oid and atttypmod to canonical SQL',
proname => 'format_type', proisstrict => 'f', provolatile => 's',
prorettype => 'text', proargtypes => 'oid int4', prosrc => 'format_type' },
{ oid => '1084', descr => 'I/O',
proname => 'date_in', provolatile => 's', prorettype => 'date',
proargtypes => 'cstring', prosrc => 'date_in' },
{ oid => '1085', descr => 'I/O',
proname => 'date_out', provolatile => 's', prorettype => 'cstring',
proargtypes => 'date', prosrc => 'date_out' },
{ oid => '1086',
proname => 'date_eq', proleakproof => 't', prorettype => 'bool',
proargtypes => 'date date', prosrc => 'date_eq' },
{ oid => '1087',
proname => 'date_lt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'date date', prosrc => 'date_lt' },
{ oid => '1088',
proname => 'date_le', proleakproof => 't', prorettype => 'bool',
proargtypes => 'date date', prosrc => 'date_le' },
{ oid => '1089',
proname => 'date_gt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'date date', prosrc => 'date_gt' },
{ oid => '1090',
proname => 'date_ge', proleakproof => 't', prorettype => 'bool',
proargtypes => 'date date', prosrc => 'date_ge' },
{ oid => '1091',
proname => 'date_ne', proleakproof => 't', prorettype => 'bool',
proargtypes => 'date date', prosrc => 'date_ne' },
{ oid => '1092', descr => 'less-equal-greater',
Mark built-in btree comparison functions as leakproof where it's safe. Generally, if the comparison operators for a datatype or pair of datatypes are leakproof, the corresponding btree comparison support function can be considered so as well. But we had not originally worried about marking support functions as leakproof, reasoning that they'd not likely be used in queries so the marking wouldn't matter. It turns out there's at least one place where it does matter: calc_arraycontsel() finds the target datatype's default btree comparison function and tries to use that to estimate selectivity, but it will be blocked in some cases if the function isn't leakproof. This leads to unnecessarily poor selectivity estimates and bad plans, as seen in bug #15251. Hence, run around and apply proleakproof markings where the corresponding btree comparison operators are leakproof. (I did eyeball each function to verify that it wasn't doing anything surprising, too.) This isn't a full solution to bug #15251, and it's not back-patchable because of the need for a catversion bump. A more useful response probably is to consider whether we can check permissions on the parent table instead of the child. However, this change will help in some cases where that won't, and it's easy enough to do in HEAD, so let's do so. Discussion: https://postgr.es/m/3876.1531261875@sss.pgh.pa.us
2018-07-12 00:47:31 +02:00
proname => 'date_cmp', proleakproof => 't', prorettype => 'int4',
proargtypes => 'date date', prosrc => 'date_cmp' },
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
{ oid => '3136', descr => 'sort support',
proname => 'date_sortsupport', prorettype => 'void',
proargtypes => 'internal', prosrc => 'date_sortsupport' },
{ oid => '4133', descr => 'window RANGE support',
proname => 'in_range', prorettype => 'bool',
proargtypes => 'date date interval bool bool',
prosrc => 'in_range_date_interval' },
# OIDS 1100 - 1199
{ oid => '1102',
proname => 'time_lt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'time time', prosrc => 'time_lt' },
{ oid => '1103',
proname => 'time_le', proleakproof => 't', prorettype => 'bool',
proargtypes => 'time time', prosrc => 'time_le' },
{ oid => '1104',
proname => 'time_gt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'time time', prosrc => 'time_gt' },
{ oid => '1105',
proname => 'time_ge', proleakproof => 't', prorettype => 'bool',
proargtypes => 'time time', prosrc => 'time_ge' },
{ oid => '1106',
proname => 'time_ne', proleakproof => 't', prorettype => 'bool',
proargtypes => 'time time', prosrc => 'time_ne' },
{ oid => '1107', descr => 'less-equal-greater',
Mark built-in btree comparison functions as leakproof where it's safe. Generally, if the comparison operators for a datatype or pair of datatypes are leakproof, the corresponding btree comparison support function can be considered so as well. But we had not originally worried about marking support functions as leakproof, reasoning that they'd not likely be used in queries so the marking wouldn't matter. It turns out there's at least one place where it does matter: calc_arraycontsel() finds the target datatype's default btree comparison function and tries to use that to estimate selectivity, but it will be blocked in some cases if the function isn't leakproof. This leads to unnecessarily poor selectivity estimates and bad plans, as seen in bug #15251. Hence, run around and apply proleakproof markings where the corresponding btree comparison operators are leakproof. (I did eyeball each function to verify that it wasn't doing anything surprising, too.) This isn't a full solution to bug #15251, and it's not back-patchable because of the need for a catversion bump. A more useful response probably is to consider whether we can check permissions on the parent table instead of the child. However, this change will help in some cases where that won't, and it's easy enough to do in HEAD, so let's do so. Discussion: https://postgr.es/m/3876.1531261875@sss.pgh.pa.us
2018-07-12 00:47:31 +02:00
proname => 'time_cmp', proleakproof => 't', prorettype => 'int4',
proargtypes => 'time time', prosrc => 'time_cmp' },
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
{ oid => '1138', descr => 'larger of two',
proname => 'date_larger', prorettype => 'date', proargtypes => 'date date',
prosrc => 'date_larger' },
{ oid => '1139', descr => 'smaller of two',
proname => 'date_smaller', prorettype => 'date', proargtypes => 'date date',
prosrc => 'date_smaller' },
{ oid => '1140',
proname => 'date_mi', prorettype => 'int4', proargtypes => 'date date',
prosrc => 'date_mi' },
{ oid => '1141',
proname => 'date_pli', prorettype => 'date', proargtypes => 'date int4',
prosrc => 'date_pli' },
{ oid => '1142',
proname => 'date_mii', prorettype => 'date', proargtypes => 'date int4',
prosrc => 'date_mii' },
{ oid => '1143', descr => 'I/O',
proname => 'time_in', provolatile => 's', prorettype => 'time',
proargtypes => 'cstring oid int4', prosrc => 'time_in' },
{ oid => '1144', descr => 'I/O',
proname => 'time_out', prorettype => 'cstring', proargtypes => 'time',
prosrc => 'time_out' },
{ oid => '2909', descr => 'I/O typmod',
proname => 'timetypmodin', prorettype => 'int4', proargtypes => '_cstring',
prosrc => 'timetypmodin' },
{ oid => '2910', descr => 'I/O typmod',
proname => 'timetypmodout', prorettype => 'cstring', proargtypes => 'int4',
prosrc => 'timetypmodout' },
{ oid => '1145',
proname => 'time_eq', proleakproof => 't', prorettype => 'bool',
proargtypes => 'time time', prosrc => 'time_eq' },
{ oid => '1146',
proname => 'circle_add_pt', prorettype => 'circle',
proargtypes => 'circle point', prosrc => 'circle_add_pt' },
{ oid => '1147',
proname => 'circle_sub_pt', prorettype => 'circle',
proargtypes => 'circle point', prosrc => 'circle_sub_pt' },
{ oid => '1148',
proname => 'circle_mul_pt', prorettype => 'circle',
proargtypes => 'circle point', prosrc => 'circle_mul_pt' },
{ oid => '1149',
proname => 'circle_div_pt', prorettype => 'circle',
proargtypes => 'circle point', prosrc => 'circle_div_pt' },
{ oid => '1150', descr => 'I/O',
proname => 'timestamptz_in', provolatile => 's', prorettype => 'timestamptz',
proargtypes => 'cstring oid int4', prosrc => 'timestamptz_in' },
{ oid => '1151', descr => 'I/O',
proname => 'timestamptz_out', provolatile => 's', prorettype => 'cstring',
proargtypes => 'timestamptz', prosrc => 'timestamptz_out' },
{ oid => '2907', descr => 'I/O typmod',
proname => 'timestamptztypmodin', prorettype => 'int4',
proargtypes => '_cstring', prosrc => 'timestamptztypmodin' },
{ oid => '2908', descr => 'I/O typmod',
proname => 'timestamptztypmodout', prorettype => 'cstring',
proargtypes => 'int4', prosrc => 'timestamptztypmodout' },
{ oid => '1152',
proname => 'timestamptz_eq', proleakproof => 't', prorettype => 'bool',
proargtypes => 'timestamptz timestamptz', prosrc => 'timestamp_eq' },
{ oid => '1153',
proname => 'timestamptz_ne', proleakproof => 't', prorettype => 'bool',
proargtypes => 'timestamptz timestamptz', prosrc => 'timestamp_ne' },
{ oid => '1154',
proname => 'timestamptz_lt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'timestamptz timestamptz', prosrc => 'timestamp_lt' },
{ oid => '1155',
proname => 'timestamptz_le', proleakproof => 't', prorettype => 'bool',
proargtypes => 'timestamptz timestamptz', prosrc => 'timestamp_le' },
{ oid => '1156',
proname => 'timestamptz_ge', proleakproof => 't', prorettype => 'bool',
proargtypes => 'timestamptz timestamptz', prosrc => 'timestamp_ge' },
{ oid => '1157',
proname => 'timestamptz_gt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'timestamptz timestamptz', prosrc => 'timestamp_gt' },
{ oid => '1158', descr => 'convert UNIX epoch to timestamptz',
proname => 'to_timestamp', prorettype => 'timestamptz',
proargtypes => 'float8', prosrc => 'float8_timestamptz' },
{ oid => '3995', descr => 'transform a time zone adjustment',
proname => 'timestamp_zone_transform', prorettype => 'internal',
proargtypes => 'internal', prosrc => 'timestamp_zone_transform' },
{ oid => '1159', descr => 'adjust timestamp to new time zone',
proname => 'timezone', protransform => 'timestamp_zone_transform',
prorettype => 'timestamp', proargtypes => 'text timestamptz',
prosrc => 'timestamptz_zone' },
{ oid => '1160', descr => 'I/O',
proname => 'interval_in', provolatile => 's', prorettype => 'interval',
proargtypes => 'cstring oid int4', prosrc => 'interval_in' },
{ oid => '1161', descr => 'I/O',
proname => 'interval_out', prorettype => 'cstring', proargtypes => 'interval',
prosrc => 'interval_out' },
{ oid => '2903', descr => 'I/O typmod',
proname => 'intervaltypmodin', prorettype => 'int4',
proargtypes => '_cstring', prosrc => 'intervaltypmodin' },
{ oid => '2904', descr => 'I/O typmod',
proname => 'intervaltypmodout', prorettype => 'cstring',
proargtypes => 'int4', prosrc => 'intervaltypmodout' },
{ oid => '1162',
proname => 'interval_eq', proleakproof => 't', prorettype => 'bool',
proargtypes => 'interval interval', prosrc => 'interval_eq' },
{ oid => '1163',
proname => 'interval_ne', proleakproof => 't', prorettype => 'bool',
proargtypes => 'interval interval', prosrc => 'interval_ne' },
{ oid => '1164',
proname => 'interval_lt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'interval interval', prosrc => 'interval_lt' },
{ oid => '1165',
proname => 'interval_le', proleakproof => 't', prorettype => 'bool',
proargtypes => 'interval interval', prosrc => 'interval_le' },
{ oid => '1166',
proname => 'interval_ge', proleakproof => 't', prorettype => 'bool',
proargtypes => 'interval interval', prosrc => 'interval_ge' },
{ oid => '1167',
proname => 'interval_gt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'interval interval', prosrc => 'interval_gt' },
{ oid => '1168',
proname => 'interval_um', prorettype => 'interval', proargtypes => 'interval',
prosrc => 'interval_um' },
{ oid => '1169',
proname => 'interval_pl', prorettype => 'interval',
proargtypes => 'interval interval', prosrc => 'interval_pl' },
{ oid => '1170',
proname => 'interval_mi', prorettype => 'interval',
proargtypes => 'interval interval', prosrc => 'interval_mi' },
{ oid => '1171', descr => 'extract field from timestamp with time zone',
proname => 'date_part', provolatile => 's', prorettype => 'float8',
proargtypes => 'text timestamptz', prosrc => 'timestamptz_part' },
{ oid => '1172', descr => 'extract field from interval',
proname => 'date_part', prorettype => 'float8',
proargtypes => 'text interval', prosrc => 'interval_part' },
{ oid => '1174', descr => 'convert date to timestamp with time zone',
proname => 'timestamptz', provolatile => 's', prorettype => 'timestamptz',
proargtypes => 'date', prosrc => 'date_timestamptz' },
{ oid => '2711',
descr => 'promote groups of 24 hours to numbers of days and promote groups of 30 days to numbers of months',
proname => 'justify_interval', prorettype => 'interval',
proargtypes => 'interval', prosrc => 'interval_justify_interval' },
{ oid => '1175', descr => 'promote groups of 24 hours to numbers of days',
proname => 'justify_hours', prorettype => 'interval',
proargtypes => 'interval', prosrc => 'interval_justify_hours' },
{ oid => '1295', descr => 'promote groups of 30 days to numbers of months',
proname => 'justify_days', prorettype => 'interval',
proargtypes => 'interval', prosrc => 'interval_justify_days' },
{ oid => '1176', descr => 'convert date and time to timestamp with time zone',
proname => 'timestamptz', prolang => '14', provolatile => 's',
prorettype => 'timestamptz', proargtypes => 'date time',
prosrc => 'select cast(($1 + $2) as timestamp with time zone)' },
{ oid => '1178', descr => 'convert timestamp with time zone to date',
proname => 'date', provolatile => 's', prorettype => 'date',
proargtypes => 'timestamptz', prosrc => 'timestamptz_date' },
{ oid => '1181',
descr => 'age of a transaction ID, in transactions before current transaction',
proname => 'age', provolatile => 's', proparallel => 'r',
prorettype => 'int4', proargtypes => 'xid', prosrc => 'xid_age' },
{ oid => '3939',
descr => 'age of a multi-transaction ID, in multi-transactions before current multi-transaction',
proname => 'mxid_age', provolatile => 's', prorettype => 'int4',
proargtypes => 'xid', prosrc => 'mxid_age' },
{ oid => '1188',
proname => 'timestamptz_mi', prorettype => 'interval',
proargtypes => 'timestamptz timestamptz', prosrc => 'timestamp_mi' },
{ oid => '1189',
proname => 'timestamptz_pl_interval', provolatile => 's',
prorettype => 'timestamptz', proargtypes => 'timestamptz interval',
prosrc => 'timestamptz_pl_interval' },
{ oid => '1190',
proname => 'timestamptz_mi_interval', provolatile => 's',
prorettype => 'timestamptz', proargtypes => 'timestamptz interval',
prosrc => 'timestamptz_mi_interval' },
{ oid => '1195', descr => 'smaller of two',
proname => 'timestamptz_smaller', prorettype => 'timestamptz',
proargtypes => 'timestamptz timestamptz', prosrc => 'timestamp_smaller' },
{ oid => '1196', descr => 'larger of two',
proname => 'timestamptz_larger', prorettype => 'timestamptz',
proargtypes => 'timestamptz timestamptz', prosrc => 'timestamp_larger' },
{ oid => '1197', descr => 'smaller of two',
proname => 'interval_smaller', prorettype => 'interval',
proargtypes => 'interval interval', prosrc => 'interval_smaller' },
{ oid => '1198', descr => 'larger of two',
proname => 'interval_larger', prorettype => 'interval',
proargtypes => 'interval interval', prosrc => 'interval_larger' },
{ oid => '1199', descr => 'date difference preserving months and years',
proname => 'age', prorettype => 'interval',
proargtypes => 'timestamptz timestamptz', prosrc => 'timestamptz_age' },
# OIDS 1200 - 1299
{ oid => '3918', descr => 'transform an interval length coercion',
proname => 'interval_transform', prorettype => 'internal',
proargtypes => 'internal', prosrc => 'interval_transform' },
{ oid => '1200', descr => 'adjust interval precision',
proname => 'interval', protransform => 'interval_transform',
prorettype => 'interval', proargtypes => 'interval int4',
prosrc => 'interval_scale' },
{ oid => '1215', descr => 'get description for object id and catalog name',
proname => 'obj_description', prolang => '14', procost => '100',
provolatile => 's', prorettype => 'text', proargtypes => 'oid name',
prosrc => 'select description from pg_catalog.pg_description where objoid = $1 and classoid = (select oid from pg_catalog.pg_class where relname = $2 and relnamespace = PGNSP) and objsubid = 0' },
{ oid => '1216', descr => 'get description for table column',
proname => 'col_description', prolang => '14', procost => '100',
provolatile => 's', prorettype => 'text', proargtypes => 'oid int4',
Rationalize handling of single and double quotes in bootstrap data. Change things around so that proper quoting of values interpolated into the BKI data by initdb is the responsibility of initdb, not something we half-heartedly handle by putting double quotes into the raw BKI data. (Note: experimentation shows that it still doesn't work to put a double quote into the initial superuser username, but that's the fault of inadequate quoting while interpolating the name into SQL scripts; the BKI aspect of it works fine now.) Having done that, we can remove the special-case handling of values that look like "something" from genbki.pl, and instead teach it to escape double --- and single --- quotes properly. This removes the nowhere-documented need to treat those specially in the BKI source data; whatever you write will be passed through unchanged into the inserted data value, modulo Perl's rules about single-quoted strings. Add documentation explaining the (pre-existing) handling of backslashes in the BKI data. Per an earlier discussion with John Naylor. Discussion: https://postgr.es/m/CAJVSVGUNao=-Q2-vAN3PYcdF5tnL5JAHwGwzZGuYHtq+Mk_9ng@mail.gmail.com
2018-04-18 01:53:50 +02:00
prosrc => 'select description from pg_catalog.pg_description where objoid = $1 and classoid = \'pg_catalog.pg_class\'::pg_catalog.regclass and objsubid = $2' },
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
{ oid => '1993',
descr => 'get description for object id and shared catalog name',
proname => 'shobj_description', prolang => '14', procost => '100',
provolatile => 's', prorettype => 'text', proargtypes => 'oid name',
prosrc => 'select description from pg_catalog.pg_shdescription where objoid = $1 and classoid = (select oid from pg_catalog.pg_class where relname = $2 and relnamespace = PGNSP)' },
{ oid => '1217',
descr => 'truncate timestamp with time zone to specified units',
proname => 'date_trunc', provolatile => 's', prorettype => 'timestamptz',
proargtypes => 'text timestamptz', prosrc => 'timestamptz_trunc' },
Add a timezone-specific variant of date_trunc(). date_trunc(field, timestamptz, zone_name) performs truncation using the named time zone as reference, rather than working in the session time zone as is the default behavior. It's equivalent to date_trunc(field, timestamptz at time zone zone_name) at time zone zone_name but it's faster, easier to type, and arguably easier to understand. Vik Fearing and Tom Lane Discussion: https://postgr.es/m/6249ffc4-2b22-4c1b-4e7d-7af84fedd7c6@2ndquadrant.com
2018-11-14 21:41:07 +01:00
{ oid => '1284',
descr => 'truncate timestamp with time zone to specified units in specified time zone',
proname => 'date_trunc', provolatile => 's', prorettype => 'timestamptz',
proargtypes => 'text timestamptz text', prosrc => 'timestamptz_trunc_zone' },
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
{ oid => '1218', descr => 'truncate interval to specified units',
proname => 'date_trunc', prorettype => 'interval',
proargtypes => 'text interval', prosrc => 'interval_trunc' },
{ oid => '1219', descr => 'increment',
proname => 'int8inc', prorettype => 'int8', proargtypes => 'int8',
prosrc => 'int8inc' },
{ oid => '3546', descr => 'decrement',
proname => 'int8dec', prorettype => 'int8', proargtypes => 'int8',
prosrc => 'int8dec' },
{ oid => '2804', descr => 'increment, ignores second argument',
proname => 'int8inc_any', prorettype => 'int8', proargtypes => 'int8 any',
prosrc => 'int8inc_any' },
{ oid => '3547', descr => 'decrement, ignores second argument',
proname => 'int8dec_any', prorettype => 'int8', proargtypes => 'int8 any',
prosrc => 'int8dec_any' },
{ oid => '1230',
proname => 'int8abs', prorettype => 'int8', proargtypes => 'int8',
prosrc => 'int8abs' },
{ oid => '1236', descr => 'larger of two',
proname => 'int8larger', prorettype => 'int8', proargtypes => 'int8 int8',
prosrc => 'int8larger' },
{ oid => '1237', descr => 'smaller of two',
proname => 'int8smaller', prorettype => 'int8', proargtypes => 'int8 int8',
prosrc => 'int8smaller' },
{ oid => '1238',
proname => 'texticregexeq', prorettype => 'bool', proargtypes => 'text text',
prosrc => 'texticregexeq' },
{ oid => '1239',
proname => 'texticregexne', prorettype => 'bool', proargtypes => 'text text',
prosrc => 'texticregexne' },
{ oid => '1240',
proname => 'nameicregexeq', prorettype => 'bool', proargtypes => 'name text',
prosrc => 'nameicregexeq' },
{ oid => '1241',
proname => 'nameicregexne', prorettype => 'bool', proargtypes => 'name text',
prosrc => 'nameicregexne' },
{ oid => '1251',
proname => 'int4abs', prorettype => 'int4', proargtypes => 'int4',
prosrc => 'int4abs' },
{ oid => '1253',
proname => 'int2abs', prorettype => 'int2', proargtypes => 'int2',
prosrc => 'int2abs' },
{ oid => '1271', descr => 'intervals overlap?',
proname => 'overlaps', proisstrict => 'f', prorettype => 'bool',
proargtypes => 'timetz timetz timetz timetz', prosrc => 'overlaps_timetz' },
{ oid => '1272',
proname => 'datetime_pl', prorettype => 'timestamp',
proargtypes => 'date time', prosrc => 'datetime_timestamp' },
{ oid => '1273', descr => 'extract field from time with time zone',
proname => 'date_part', prorettype => 'float8', proargtypes => 'text timetz',
prosrc => 'timetz_part' },
{ oid => '1274',
proname => 'int84pl', prorettype => 'int8', proargtypes => 'int8 int4',
prosrc => 'int84pl' },
{ oid => '1275',
proname => 'int84mi', prorettype => 'int8', proargtypes => 'int8 int4',
prosrc => 'int84mi' },
{ oid => '1276',
proname => 'int84mul', prorettype => 'int8', proargtypes => 'int8 int4',
prosrc => 'int84mul' },
{ oid => '1277',
proname => 'int84div', prorettype => 'int8', proargtypes => 'int8 int4',
prosrc => 'int84div' },
{ oid => '1278',
proname => 'int48pl', prorettype => 'int8', proargtypes => 'int4 int8',
prosrc => 'int48pl' },
{ oid => '1279',
proname => 'int48mi', prorettype => 'int8', proargtypes => 'int4 int8',
prosrc => 'int48mi' },
{ oid => '1280',
proname => 'int48mul', prorettype => 'int8', proargtypes => 'int4 int8',
prosrc => 'int48mul' },
{ oid => '1281',
proname => 'int48div', prorettype => 'int8', proargtypes => 'int4 int8',
prosrc => 'int48div' },
{ oid => '837',
proname => 'int82pl', prorettype => 'int8', proargtypes => 'int8 int2',
prosrc => 'int82pl' },
{ oid => '838',
proname => 'int82mi', prorettype => 'int8', proargtypes => 'int8 int2',
prosrc => 'int82mi' },
{ oid => '839',
proname => 'int82mul', prorettype => 'int8', proargtypes => 'int8 int2',
prosrc => 'int82mul' },
{ oid => '840',
proname => 'int82div', prorettype => 'int8', proargtypes => 'int8 int2',
prosrc => 'int82div' },
{ oid => '841',
proname => 'int28pl', prorettype => 'int8', proargtypes => 'int2 int8',
prosrc => 'int28pl' },
{ oid => '942',
proname => 'int28mi', prorettype => 'int8', proargtypes => 'int2 int8',
prosrc => 'int28mi' },
{ oid => '943',
proname => 'int28mul', prorettype => 'int8', proargtypes => 'int2 int8',
prosrc => 'int28mul' },
{ oid => '948',
proname => 'int28div', prorettype => 'int8', proargtypes => 'int2 int8',
prosrc => 'int28div' },
{ oid => '1287', descr => 'convert int8 to oid',
proname => 'oid', prorettype => 'oid', proargtypes => 'int8',
prosrc => 'i8tooid' },
{ oid => '1288', descr => 'convert oid to int8',
proname => 'int8', prorettype => 'int8', proargtypes => 'oid',
prosrc => 'oidtoi8' },
{ oid => '1291',
descr => 'trigger to suppress updates when new and old records match',
proname => 'suppress_redundant_updates_trigger', provolatile => 'v',
prorettype => 'trigger', proargtypes => '',
prosrc => 'suppress_redundant_updates_trigger' },
{ oid => '1292',
proname => 'tideq', proleakproof => 't', prorettype => 'bool',
proargtypes => 'tid tid', prosrc => 'tideq' },
{ oid => '1293', descr => 'latest tid of a tuple',
proname => 'currtid', provolatile => 'v', proparallel => 'u',
prorettype => 'tid', proargtypes => 'oid tid', prosrc => 'currtid_byreloid' },
{ oid => '1294', descr => 'latest tid of a tuple',
proname => 'currtid2', provolatile => 'v', proparallel => 'u',
prorettype => 'tid', proargtypes => 'text tid',
prosrc => 'currtid_byrelname' },
{ oid => '1265',
proname => 'tidne', proleakproof => 't', prorettype => 'bool',
proargtypes => 'tid tid', prosrc => 'tidne' },
{ oid => '2790',
proname => 'tidgt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'tid tid', prosrc => 'tidgt' },
{ oid => '2791',
proname => 'tidlt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'tid tid', prosrc => 'tidlt' },
{ oid => '2792',
proname => 'tidge', proleakproof => 't', prorettype => 'bool',
proargtypes => 'tid tid', prosrc => 'tidge' },
{ oid => '2793',
proname => 'tidle', proleakproof => 't', prorettype => 'bool',
proargtypes => 'tid tid', prosrc => 'tidle' },
{ oid => '2794', descr => 'less-equal-greater',
Mark built-in btree comparison functions as leakproof where it's safe. Generally, if the comparison operators for a datatype or pair of datatypes are leakproof, the corresponding btree comparison support function can be considered so as well. But we had not originally worried about marking support functions as leakproof, reasoning that they'd not likely be used in queries so the marking wouldn't matter. It turns out there's at least one place where it does matter: calc_arraycontsel() finds the target datatype's default btree comparison function and tries to use that to estimate selectivity, but it will be blocked in some cases if the function isn't leakproof. This leads to unnecessarily poor selectivity estimates and bad plans, as seen in bug #15251. Hence, run around and apply proleakproof markings where the corresponding btree comparison operators are leakproof. (I did eyeball each function to verify that it wasn't doing anything surprising, too.) This isn't a full solution to bug #15251, and it's not back-patchable because of the need for a catversion bump. A more useful response probably is to consider whether we can check permissions on the parent table instead of the child. However, this change will help in some cases where that won't, and it's easy enough to do in HEAD, so let's do so. Discussion: https://postgr.es/m/3876.1531261875@sss.pgh.pa.us
2018-07-12 00:47:31 +02:00
proname => 'bttidcmp', proleakproof => 't', prorettype => 'int4',
proargtypes => 'tid tid', prosrc => 'bttidcmp' },
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
{ oid => '2795', descr => 'larger of two',
proname => 'tidlarger', prorettype => 'tid', proargtypes => 'tid tid',
prosrc => 'tidlarger' },
{ oid => '2796', descr => 'smaller of two',
proname => 'tidsmaller', prorettype => 'tid', proargtypes => 'tid tid',
prosrc => 'tidsmaller' },
Add a hash opclass for type "tid". Up to now we've not worried much about joins where the join key is a relation's CTID column, reasoning that storing a table's CTIDs in some other table would be pretty useless. However, there are use-cases for this sort of query involving self-joins, so that argument doesn't really hold water. With larger relations, a merge or hash join is desirable. We had a btree opclass for type "tid", allowing merge joins on CTID, but no hash opclass so that hash joins weren't possible. Add the missing infrastructure. This also potentially enables hash aggregation on "tid", though the use-cases for that aren't too clear. Discussion: https://postgr.es/m/1853.1545453106@sss.pgh.pa.us
2018-12-30 21:40:04 +01:00
{ oid => '2233', descr => 'hash',
proname => 'hashtid', prorettype => 'int4', proargtypes => 'tid',
prosrc => 'hashtid' },
{ oid => '2234', descr => 'hash',
proname => 'hashtidextended', prorettype => 'int8', proargtypes => 'tid int8',
prosrc => 'hashtidextended' },
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
{ oid => '1296',
proname => 'timedate_pl', prolang => '14', prorettype => 'timestamp',
proargtypes => 'time date', prosrc => 'select ($2 + $1)' },
{ oid => '1297',
proname => 'datetimetz_pl', prorettype => 'timestamptz',
proargtypes => 'date timetz', prosrc => 'datetimetz_timestamptz' },
{ oid => '1298',
proname => 'timetzdate_pl', prolang => '14', prorettype => 'timestamptz',
proargtypes => 'timetz date', prosrc => 'select ($2 + $1)' },
{ oid => '1299', descr => 'current transaction time',
Propagate xactStartTimestamp and stmtStartTimestamp to parallel workers. Previously, a worker process would establish values for these based on its own start time. In v10 and up, this can trivially be shown to cause misbehavior of transaction_timestamp(), timestamp_in(), and related functions which are (perhaps unwisely?) marked parallel-safe. It seems likely that other behaviors might diverge from what happens in the parent as well. It's not as trivial to demonstrate problems in 9.6 or 9.5, but I'm sure it's still possible, so back-patch to all branches containing parallel worker infrastructure. In HEAD only, mark now() and statement_timestamp() as parallel-safe (other affected functions already were). While in theory we could still squeeze that change into v11, it doesn't seem important enough to force a last-minute catversion bump. Konstantin Knizhnik, whacked around a bit by me Discussion: https://postgr.es/m/6406dbd2-5d37-4cb6-6eb2-9c44172c7e7c@postgrespro.ru
2018-10-06 18:00:09 +02:00
proname => 'now', provolatile => 's', prorettype => 'timestamptz',
proargtypes => '', prosrc => 'now' },
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
{ oid => '2647', descr => 'current transaction time',
proname => 'transaction_timestamp', provolatile => 's',
prorettype => 'timestamptz', proargtypes => '', prosrc => 'now' },
{ oid => '2648', descr => 'current statement time',
Propagate xactStartTimestamp and stmtStartTimestamp to parallel workers. Previously, a worker process would establish values for these based on its own start time. In v10 and up, this can trivially be shown to cause misbehavior of transaction_timestamp(), timestamp_in(), and related functions which are (perhaps unwisely?) marked parallel-safe. It seems likely that other behaviors might diverge from what happens in the parent as well. It's not as trivial to demonstrate problems in 9.6 or 9.5, but I'm sure it's still possible, so back-patch to all branches containing parallel worker infrastructure. In HEAD only, mark now() and statement_timestamp() as parallel-safe (other affected functions already were). While in theory we could still squeeze that change into v11, it doesn't seem important enough to force a last-minute catversion bump. Konstantin Knizhnik, whacked around a bit by me Discussion: https://postgr.es/m/6406dbd2-5d37-4cb6-6eb2-9c44172c7e7c@postgrespro.ru
2018-10-06 18:00:09 +02:00
proname => 'statement_timestamp', provolatile => 's',
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
prorettype => 'timestamptz', proargtypes => '',
prosrc => 'statement_timestamp' },
{ oid => '2649', descr => 'current clock time',
proname => 'clock_timestamp', provolatile => 'v', prorettype => 'timestamptz',
proargtypes => '', prosrc => 'clock_timestamp' },
# OIDS 1300 - 1399
{ oid => '1300',
descr => 'restriction selectivity for position-comparison operators',
proname => 'positionsel', provolatile => 's', prorettype => 'float8',
proargtypes => 'internal oid internal int4', prosrc => 'positionsel' },
{ oid => '1301',
descr => 'join selectivity for position-comparison operators',
proname => 'positionjoinsel', provolatile => 's', prorettype => 'float8',
proargtypes => 'internal oid internal int2 internal',
prosrc => 'positionjoinsel' },
{ oid => '1302',
descr => 'restriction selectivity for containment comparison operators',
proname => 'contsel', provolatile => 's', prorettype => 'float8',
proargtypes => 'internal oid internal int4', prosrc => 'contsel' },
{ oid => '1303',
descr => 'join selectivity for containment comparison operators',
proname => 'contjoinsel', provolatile => 's', prorettype => 'float8',
proargtypes => 'internal oid internal int2 internal',
prosrc => 'contjoinsel' },
{ oid => '1304', descr => 'intervals overlap?',
proname => 'overlaps', proisstrict => 'f', prorettype => 'bool',
proargtypes => 'timestamptz timestamptz timestamptz timestamptz',
prosrc => 'overlaps_timestamp' },
{ oid => '1305', descr => 'intervals overlap?',
proname => 'overlaps', prolang => '14', proisstrict => 'f',
provolatile => 's', prorettype => 'bool',
proargtypes => 'timestamptz interval timestamptz interval',
prosrc => 'select ($1, ($1 + $2)) overlaps ($3, ($3 + $4))' },
{ oid => '1306', descr => 'intervals overlap?',
proname => 'overlaps', prolang => '14', proisstrict => 'f',
provolatile => 's', prorettype => 'bool',
proargtypes => 'timestamptz timestamptz timestamptz interval',
prosrc => 'select ($1, $2) overlaps ($3, ($3 + $4))' },
{ oid => '1307', descr => 'intervals overlap?',
proname => 'overlaps', prolang => '14', proisstrict => 'f',
provolatile => 's', prorettype => 'bool',
proargtypes => 'timestamptz interval timestamptz timestamptz',
prosrc => 'select ($1, ($1 + $2)) overlaps ($3, $4)' },
{ oid => '1308', descr => 'intervals overlap?',
proname => 'overlaps', proisstrict => 'f', prorettype => 'bool',
proargtypes => 'time time time time', prosrc => 'overlaps_time' },
{ oid => '1309', descr => 'intervals overlap?',
proname => 'overlaps', prolang => '14', proisstrict => 'f',
prorettype => 'bool', proargtypes => 'time interval time interval',
prosrc => 'select ($1, ($1 + $2)) overlaps ($3, ($3 + $4))' },
{ oid => '1310', descr => 'intervals overlap?',
proname => 'overlaps', prolang => '14', proisstrict => 'f',
prorettype => 'bool', proargtypes => 'time time time interval',
prosrc => 'select ($1, $2) overlaps ($3, ($3 + $4))' },
{ oid => '1311', descr => 'intervals overlap?',
proname => 'overlaps', prolang => '14', proisstrict => 'f',
prorettype => 'bool', proargtypes => 'time interval time time',
prosrc => 'select ($1, ($1 + $2)) overlaps ($3, $4)' },
{ oid => '1312', descr => 'I/O',
proname => 'timestamp_in', provolatile => 's', prorettype => 'timestamp',
proargtypes => 'cstring oid int4', prosrc => 'timestamp_in' },
{ oid => '1313', descr => 'I/O',
proname => 'timestamp_out', provolatile => 's', prorettype => 'cstring',
proargtypes => 'timestamp', prosrc => 'timestamp_out' },
{ oid => '2905', descr => 'I/O typmod',
proname => 'timestamptypmodin', prorettype => 'int4',
proargtypes => '_cstring', prosrc => 'timestamptypmodin' },
{ oid => '2906', descr => 'I/O typmod',
proname => 'timestamptypmodout', prorettype => 'cstring',
proargtypes => 'int4', prosrc => 'timestamptypmodout' },
{ oid => '1314', descr => 'less-equal-greater',
Mark built-in btree comparison functions as leakproof where it's safe. Generally, if the comparison operators for a datatype or pair of datatypes are leakproof, the corresponding btree comparison support function can be considered so as well. But we had not originally worried about marking support functions as leakproof, reasoning that they'd not likely be used in queries so the marking wouldn't matter. It turns out there's at least one place where it does matter: calc_arraycontsel() finds the target datatype's default btree comparison function and tries to use that to estimate selectivity, but it will be blocked in some cases if the function isn't leakproof. This leads to unnecessarily poor selectivity estimates and bad plans, as seen in bug #15251. Hence, run around and apply proleakproof markings where the corresponding btree comparison operators are leakproof. (I did eyeball each function to verify that it wasn't doing anything surprising, too.) This isn't a full solution to bug #15251, and it's not back-patchable because of the need for a catversion bump. A more useful response probably is to consider whether we can check permissions on the parent table instead of the child. However, this change will help in some cases where that won't, and it's easy enough to do in HEAD, so let's do so. Discussion: https://postgr.es/m/3876.1531261875@sss.pgh.pa.us
2018-07-12 00:47:31 +02:00
proname => 'timestamptz_cmp', proleakproof => 't', prorettype => 'int4',
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
proargtypes => 'timestamptz timestamptz', prosrc => 'timestamp_cmp' },
{ oid => '1315', descr => 'less-equal-greater',
Mark built-in btree comparison functions as leakproof where it's safe. Generally, if the comparison operators for a datatype or pair of datatypes are leakproof, the corresponding btree comparison support function can be considered so as well. But we had not originally worried about marking support functions as leakproof, reasoning that they'd not likely be used in queries so the marking wouldn't matter. It turns out there's at least one place where it does matter: calc_arraycontsel() finds the target datatype's default btree comparison function and tries to use that to estimate selectivity, but it will be blocked in some cases if the function isn't leakproof. This leads to unnecessarily poor selectivity estimates and bad plans, as seen in bug #15251. Hence, run around and apply proleakproof markings where the corresponding btree comparison operators are leakproof. (I did eyeball each function to verify that it wasn't doing anything surprising, too.) This isn't a full solution to bug #15251, and it's not back-patchable because of the need for a catversion bump. A more useful response probably is to consider whether we can check permissions on the parent table instead of the child. However, this change will help in some cases where that won't, and it's easy enough to do in HEAD, so let's do so. Discussion: https://postgr.es/m/3876.1531261875@sss.pgh.pa.us
2018-07-12 00:47:31 +02:00
proname => 'interval_cmp', proleakproof => 't', prorettype => 'int4',
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
proargtypes => 'interval interval', prosrc => 'interval_cmp' },
{ oid => '1316', descr => 'convert timestamp to time',
proname => 'time', prorettype => 'time', proargtypes => 'timestamp',
prosrc => 'timestamp_time' },
{ oid => '1317', descr => 'length',
proname => 'length', prorettype => 'int4', proargtypes => 'text',
prosrc => 'textlen' },
{ oid => '1318', descr => 'character length',
proname => 'length', prorettype => 'int4', proargtypes => 'bpchar',
prosrc => 'bpcharlen' },
{ oid => '1319',
proname => 'xideqint4', proleakproof => 't', prorettype => 'bool',
proargtypes => 'xid int4', prosrc => 'xideq' },
{ oid => '3309',
proname => 'xidneqint4', proleakproof => 't', prorettype => 'bool',
proargtypes => 'xid int4', prosrc => 'xidneq' },
{ oid => '1326',
proname => 'interval_div', prorettype => 'interval',
proargtypes => 'interval float8', prosrc => 'interval_div' },
{ oid => '1339', descr => 'base 10 logarithm',
proname => 'dlog10', prorettype => 'float8', proargtypes => 'float8',
prosrc => 'dlog10' },
{ oid => '1340', descr => 'base 10 logarithm',
proname => 'log', prorettype => 'float8', proargtypes => 'float8',
prosrc => 'dlog10' },
{ oid => '1341', descr => 'natural logarithm',
proname => 'ln', prorettype => 'float8', proargtypes => 'float8',
prosrc => 'dlog1' },
{ oid => '1342', descr => 'round to nearest integer',
proname => 'round', prorettype => 'float8', proargtypes => 'float8',
prosrc => 'dround' },
{ oid => '1343', descr => 'truncate to integer',
proname => 'trunc', prorettype => 'float8', proargtypes => 'float8',
prosrc => 'dtrunc' },
{ oid => '1344', descr => 'square root',
proname => 'sqrt', prorettype => 'float8', proargtypes => 'float8',
prosrc => 'dsqrt' },
{ oid => '1345', descr => 'cube root',
proname => 'cbrt', prorettype => 'float8', proargtypes => 'float8',
prosrc => 'dcbrt' },
{ oid => '1346', descr => 'exponentiation',
proname => 'pow', prorettype => 'float8', proargtypes => 'float8 float8',
prosrc => 'dpow' },
{ oid => '1368', descr => 'exponentiation',
proname => 'power', prorettype => 'float8', proargtypes => 'float8 float8',
prosrc => 'dpow' },
{ oid => '1347', descr => 'natural exponential (e^x)',
proname => 'exp', prorettype => 'float8', proargtypes => 'float8',
prosrc => 'dexp' },
# This form of obj_description is now deprecated, since it will fail if
# OIDs are not unique across system catalogs. Use the other form instead.
{ oid => '1348', descr => 'deprecated, use two-argument form instead',
proname => 'obj_description', prolang => '14', procost => '100',
provolatile => 's', prorettype => 'text', proargtypes => 'oid',
prosrc => 'select description from pg_catalog.pg_description where objoid = $1 and objsubid = 0' },
{ oid => '1349', descr => 'print type names of oidvector field',
proname => 'oidvectortypes', provolatile => 's', prorettype => 'text',
proargtypes => 'oidvector', prosrc => 'oidvectortypes' },
{ oid => '1350', descr => 'I/O',
proname => 'timetz_in', provolatile => 's', prorettype => 'timetz',
proargtypes => 'cstring oid int4', prosrc => 'timetz_in' },
{ oid => '1351', descr => 'I/O',
proname => 'timetz_out', prorettype => 'cstring', proargtypes => 'timetz',
prosrc => 'timetz_out' },
{ oid => '2911', descr => 'I/O typmod',
proname => 'timetztypmodin', prorettype => 'int4', proargtypes => '_cstring',
prosrc => 'timetztypmodin' },
{ oid => '2912', descr => 'I/O typmod',
proname => 'timetztypmodout', prorettype => 'cstring', proargtypes => 'int4',
prosrc => 'timetztypmodout' },
{ oid => '1352',
proname => 'timetz_eq', proleakproof => 't', prorettype => 'bool',
proargtypes => 'timetz timetz', prosrc => 'timetz_eq' },
{ oid => '1353',
proname => 'timetz_ne', proleakproof => 't', prorettype => 'bool',
proargtypes => 'timetz timetz', prosrc => 'timetz_ne' },
{ oid => '1354',
proname => 'timetz_lt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'timetz timetz', prosrc => 'timetz_lt' },
{ oid => '1355',
proname => 'timetz_le', proleakproof => 't', prorettype => 'bool',
proargtypes => 'timetz timetz', prosrc => 'timetz_le' },
{ oid => '1356',
proname => 'timetz_ge', proleakproof => 't', prorettype => 'bool',
proargtypes => 'timetz timetz', prosrc => 'timetz_ge' },
{ oid => '1357',
proname => 'timetz_gt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'timetz timetz', prosrc => 'timetz_gt' },
{ oid => '1358', descr => 'less-equal-greater',
Mark built-in btree comparison functions as leakproof where it's safe. Generally, if the comparison operators for a datatype or pair of datatypes are leakproof, the corresponding btree comparison support function can be considered so as well. But we had not originally worried about marking support functions as leakproof, reasoning that they'd not likely be used in queries so the marking wouldn't matter. It turns out there's at least one place where it does matter: calc_arraycontsel() finds the target datatype's default btree comparison function and tries to use that to estimate selectivity, but it will be blocked in some cases if the function isn't leakproof. This leads to unnecessarily poor selectivity estimates and bad plans, as seen in bug #15251. Hence, run around and apply proleakproof markings where the corresponding btree comparison operators are leakproof. (I did eyeball each function to verify that it wasn't doing anything surprising, too.) This isn't a full solution to bug #15251, and it's not back-patchable because of the need for a catversion bump. A more useful response probably is to consider whether we can check permissions on the parent table instead of the child. However, this change will help in some cases where that won't, and it's easy enough to do in HEAD, so let's do so. Discussion: https://postgr.es/m/3876.1531261875@sss.pgh.pa.us
2018-07-12 00:47:31 +02:00
proname => 'timetz_cmp', proleakproof => 't', prorettype => 'int4',
proargtypes => 'timetz timetz', prosrc => 'timetz_cmp' },
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
{ oid => '1359',
descr => 'convert date and time with time zone to timestamp with time zone',
proname => 'timestamptz', prorettype => 'timestamptz',
proargtypes => 'date timetz', prosrc => 'datetimetz_timestamptz' },
{ oid => '1367', descr => 'character length',
proname => 'character_length', prorettype => 'int4', proargtypes => 'bpchar',
prosrc => 'bpcharlen' },
{ oid => '1369', descr => 'character length',
proname => 'character_length', prorettype => 'int4', proargtypes => 'text',
prosrc => 'textlen' },
{ oid => '1370', descr => 'convert time to interval',
proname => 'interval', prorettype => 'interval', proargtypes => 'time',
prosrc => 'time_interval' },
{ oid => '1372', descr => 'character length',
proname => 'char_length', prorettype => 'int4', proargtypes => 'bpchar',
prosrc => 'bpcharlen' },
{ oid => '1374', descr => 'octet length',
proname => 'octet_length', prorettype => 'int4', proargtypes => 'text',
prosrc => 'textoctetlen' },
{ oid => '1375', descr => 'octet length',
proname => 'octet_length', prorettype => 'int4', proargtypes => 'bpchar',
prosrc => 'bpcharoctetlen' },
{ oid => '1377', descr => 'larger of two',
proname => 'time_larger', prorettype => 'time', proargtypes => 'time time',
prosrc => 'time_larger' },
{ oid => '1378', descr => 'smaller of two',
proname => 'time_smaller', prorettype => 'time', proargtypes => 'time time',
prosrc => 'time_smaller' },
{ oid => '1379', descr => 'larger of two',
proname => 'timetz_larger', prorettype => 'timetz',
proargtypes => 'timetz timetz', prosrc => 'timetz_larger' },
{ oid => '1380', descr => 'smaller of two',
proname => 'timetz_smaller', prorettype => 'timetz',
proargtypes => 'timetz timetz', prosrc => 'timetz_smaller' },
{ oid => '1381', descr => 'character length',
proname => 'char_length', prorettype => 'int4', proargtypes => 'text',
prosrc => 'textlen' },
{ oid => '1384', descr => 'extract field from date',
proname => 'date_part', prolang => '14', prorettype => 'float8',
proargtypes => 'text date',
prosrc => 'select pg_catalog.date_part($1, cast($2 as timestamp without time zone))' },
{ oid => '1385', descr => 'extract field from time',
proname => 'date_part', prorettype => 'float8', proargtypes => 'text time',
prosrc => 'time_part' },
{ oid => '1386',
descr => 'date difference from today preserving months and years',
proname => 'age', prolang => '14', provolatile => 's',
prorettype => 'interval', proargtypes => 'timestamptz',
prosrc => 'select pg_catalog.age(cast(current_date as timestamp with time zone), $1)' },
{ oid => '1388',
descr => 'convert timestamp with time zone to time with time zone',
proname => 'timetz', provolatile => 's', prorettype => 'timetz',
proargtypes => 'timestamptz', prosrc => 'timestamptz_timetz' },
{ oid => '1373', descr => 'finite date?',
proname => 'isfinite', prorettype => 'bool', proargtypes => 'date',
prosrc => 'date_finite' },
{ oid => '1389', descr => 'finite timestamp?',
proname => 'isfinite', prorettype => 'bool', proargtypes => 'timestamptz',
prosrc => 'timestamp_finite' },
{ oid => '1390', descr => 'finite interval?',
proname => 'isfinite', prorettype => 'bool', proargtypes => 'interval',
prosrc => 'interval_finite' },
{ oid => '1376', descr => 'factorial',
proname => 'factorial', prorettype => 'numeric', proargtypes => 'int8',
prosrc => 'numeric_fac' },
{ oid => '1394', descr => 'absolute value',
proname => 'abs', prorettype => 'float4', proargtypes => 'float4',
prosrc => 'float4abs' },
{ oid => '1395', descr => 'absolute value',
proname => 'abs', prorettype => 'float8', proargtypes => 'float8',
prosrc => 'float8abs' },
{ oid => '1396', descr => 'absolute value',
proname => 'abs', prorettype => 'int8', proargtypes => 'int8',
prosrc => 'int8abs' },
{ oid => '1397', descr => 'absolute value',
proname => 'abs', prorettype => 'int4', proargtypes => 'int4',
prosrc => 'int4abs' },
{ oid => '1398', descr => 'absolute value',
proname => 'abs', prorettype => 'int2', proargtypes => 'int2',
prosrc => 'int2abs' },
# OIDS 1400 - 1499
{ oid => '1400', descr => 'convert varchar to name',
proname => 'name', prorettype => 'name', proargtypes => 'varchar',
prosrc => 'text_name' },
{ oid => '1401', descr => 'convert name to varchar',
proname => 'varchar', prorettype => 'varchar', proargtypes => 'name',
prosrc => 'name_text' },
{ oid => '1402', descr => 'current schema name',
proname => 'current_schema', provolatile => 's', prorettype => 'name',
proargtypes => '', prosrc => 'current_schema' },
{ oid => '1403', descr => 'current schema search list',
proname => 'current_schemas', provolatile => 's', prorettype => '_name',
proargtypes => 'bool', prosrc => 'current_schemas' },
{ oid => '1404', descr => 'substitute portion of string',
proname => 'overlay', prorettype => 'text',
proargtypes => 'text text int4 int4', prosrc => 'textoverlay' },
{ oid => '1405', descr => 'substitute portion of string',
proname => 'overlay', prorettype => 'text', proargtypes => 'text text int4',
prosrc => 'textoverlay_no_len' },
{ oid => '1406', descr => 'vertically aligned',
proname => 'isvertical', prorettype => 'bool', proargtypes => 'point point',
prosrc => 'point_vert' },
{ oid => '1407', descr => 'horizontally aligned',
proname => 'ishorizontal', prorettype => 'bool', proargtypes => 'point point',
prosrc => 'point_horiz' },
{ oid => '1408', descr => 'parallel',
proname => 'isparallel', prorettype => 'bool', proargtypes => 'lseg lseg',
prosrc => 'lseg_parallel' },
{ oid => '1409', descr => 'perpendicular',
proname => 'isperp', prorettype => 'bool', proargtypes => 'lseg lseg',
prosrc => 'lseg_perp' },
{ oid => '1410', descr => 'vertical',
proname => 'isvertical', prorettype => 'bool', proargtypes => 'lseg',
prosrc => 'lseg_vertical' },
{ oid => '1411', descr => 'horizontal',
proname => 'ishorizontal', prorettype => 'bool', proargtypes => 'lseg',
prosrc => 'lseg_horizontal' },
{ oid => '1412', descr => 'parallel',
proname => 'isparallel', prorettype => 'bool', proargtypes => 'line line',
prosrc => 'line_parallel' },
{ oid => '1413', descr => 'perpendicular',
proname => 'isperp', prorettype => 'bool', proargtypes => 'line line',
prosrc => 'line_perp' },
{ oid => '1414', descr => 'vertical',
proname => 'isvertical', prorettype => 'bool', proargtypes => 'line',
prosrc => 'line_vertical' },
{ oid => '1415', descr => 'horizontal',
proname => 'ishorizontal', prorettype => 'bool', proargtypes => 'line',
prosrc => 'line_horizontal' },
{ oid => '1416', descr => 'center of',
proname => 'point', prorettype => 'point', proargtypes => 'circle',
prosrc => 'circle_center' },
{ oid => '1419', descr => 'convert interval to time',
proname => 'time', prorettype => 'time', proargtypes => 'interval',
prosrc => 'interval_time' },
{ oid => '1421', descr => 'convert points to box',
proname => 'box', prorettype => 'box', proargtypes => 'point point',
prosrc => 'points_box' },
{ oid => '1422',
proname => 'box_add', prorettype => 'box', proargtypes => 'box point',
prosrc => 'box_add' },
{ oid => '1423',
proname => 'box_sub', prorettype => 'box', proargtypes => 'box point',
prosrc => 'box_sub' },
{ oid => '1424',
proname => 'box_mul', prorettype => 'box', proargtypes => 'box point',
prosrc => 'box_mul' },
{ oid => '1425',
proname => 'box_div', prorettype => 'box', proargtypes => 'box point',
prosrc => 'box_div' },
{ oid => '1426',
proname => 'path_contain_pt', prolang => '14', prorettype => 'bool',
proargtypes => 'path point', prosrc => 'select pg_catalog.on_ppath($2, $1)' },
{ oid => '1428',
proname => 'poly_contain_pt', prorettype => 'bool',
proargtypes => 'polygon point', prosrc => 'poly_contain_pt' },
{ oid => '1429',
proname => 'pt_contained_poly', prorettype => 'bool',
proargtypes => 'point polygon', prosrc => 'pt_contained_poly' },
{ oid => '1430', descr => 'path closed?',
proname => 'isclosed', prorettype => 'bool', proargtypes => 'path',
prosrc => 'path_isclosed' },
{ oid => '1431', descr => 'path open?',
proname => 'isopen', prorettype => 'bool', proargtypes => 'path',
prosrc => 'path_isopen' },
{ oid => '1432',
proname => 'path_npoints', prorettype => 'int4', proargtypes => 'path',
prosrc => 'path_npoints' },
# pclose and popen might better be named close and open, but that crashes initdb.
# - thomas 97/04/20
{ oid => '1433', descr => 'close path',
proname => 'pclose', prorettype => 'path', proargtypes => 'path',
prosrc => 'path_close' },
{ oid => '1434', descr => 'open path',
proname => 'popen', prorettype => 'path', proargtypes => 'path',
prosrc => 'path_open' },
{ oid => '1435',
proname => 'path_add', prorettype => 'path', proargtypes => 'path path',
prosrc => 'path_add' },
{ oid => '1436',
proname => 'path_add_pt', prorettype => 'path', proargtypes => 'path point',
prosrc => 'path_add_pt' },
{ oid => '1437',
proname => 'path_sub_pt', prorettype => 'path', proargtypes => 'path point',
prosrc => 'path_sub_pt' },
{ oid => '1438',
proname => 'path_mul_pt', prorettype => 'path', proargtypes => 'path point',
prosrc => 'path_mul_pt' },
{ oid => '1439',
proname => 'path_div_pt', prorettype => 'path', proargtypes => 'path point',
prosrc => 'path_div_pt' },
{ oid => '1440', descr => 'convert x, y to point',
proname => 'point', prorettype => 'point', proargtypes => 'float8 float8',
prosrc => 'construct_point' },
{ oid => '1441',
proname => 'point_add', prorettype => 'point', proargtypes => 'point point',
prosrc => 'point_add' },
{ oid => '1442',
proname => 'point_sub', prorettype => 'point', proargtypes => 'point point',
prosrc => 'point_sub' },
{ oid => '1443',
proname => 'point_mul', prorettype => 'point', proargtypes => 'point point',
prosrc => 'point_mul' },
{ oid => '1444',
proname => 'point_div', prorettype => 'point', proargtypes => 'point point',
prosrc => 'point_div' },
{ oid => '1445',
proname => 'poly_npoints', prorettype => 'int4', proargtypes => 'polygon',
prosrc => 'poly_npoints' },
{ oid => '1446', descr => 'convert polygon to bounding box',
proname => 'box', prorettype => 'box', proargtypes => 'polygon',
prosrc => 'poly_box' },
{ oid => '1447', descr => 'convert polygon to path',
proname => 'path', prorettype => 'path', proargtypes => 'polygon',
prosrc => 'poly_path' },
{ oid => '1448', descr => 'convert box to polygon',
proname => 'polygon', prorettype => 'polygon', proargtypes => 'box',
prosrc => 'box_poly' },
{ oid => '1449', descr => 'convert path to polygon',
proname => 'polygon', prorettype => 'polygon', proargtypes => 'path',
prosrc => 'path_poly' },
{ oid => '1450', descr => 'I/O',
proname => 'circle_in', prorettype => 'circle', proargtypes => 'cstring',
prosrc => 'circle_in' },
{ oid => '1451', descr => 'I/O',
proname => 'circle_out', prorettype => 'cstring', proargtypes => 'circle',
prosrc => 'circle_out' },
{ oid => '1452',
proname => 'circle_same', prorettype => 'bool',
proargtypes => 'circle circle', prosrc => 'circle_same' },
{ oid => '1453',
proname => 'circle_contain', prorettype => 'bool',
proargtypes => 'circle circle', prosrc => 'circle_contain' },
{ oid => '1454',
proname => 'circle_left', prorettype => 'bool',
proargtypes => 'circle circle', prosrc => 'circle_left' },
{ oid => '1455',
proname => 'circle_overleft', prorettype => 'bool',
proargtypes => 'circle circle', prosrc => 'circle_overleft' },
{ oid => '1456',
proname => 'circle_overright', prorettype => 'bool',
proargtypes => 'circle circle', prosrc => 'circle_overright' },
{ oid => '1457',
proname => 'circle_right', prorettype => 'bool',
proargtypes => 'circle circle', prosrc => 'circle_right' },
{ oid => '1458',
proname => 'circle_contained', prorettype => 'bool',
proargtypes => 'circle circle', prosrc => 'circle_contained' },
{ oid => '1459',
proname => 'circle_overlap', prorettype => 'bool',
proargtypes => 'circle circle', prosrc => 'circle_overlap' },
{ oid => '1460',
proname => 'circle_below', prorettype => 'bool',
proargtypes => 'circle circle', prosrc => 'circle_below' },
{ oid => '1461',
proname => 'circle_above', prorettype => 'bool',
proargtypes => 'circle circle', prosrc => 'circle_above' },
{ oid => '1462',
proname => 'circle_eq', proleakproof => 't', prorettype => 'bool',
proargtypes => 'circle circle', prosrc => 'circle_eq' },
{ oid => '1463',
proname => 'circle_ne', proleakproof => 't', prorettype => 'bool',
proargtypes => 'circle circle', prosrc => 'circle_ne' },
{ oid => '1464',
proname => 'circle_lt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'circle circle', prosrc => 'circle_lt' },
{ oid => '1465',
proname => 'circle_gt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'circle circle', prosrc => 'circle_gt' },
{ oid => '1466',
proname => 'circle_le', proleakproof => 't', prorettype => 'bool',
proargtypes => 'circle circle', prosrc => 'circle_le' },
{ oid => '1467',
proname => 'circle_ge', proleakproof => 't', prorettype => 'bool',
proargtypes => 'circle circle', prosrc => 'circle_ge' },
{ oid => '1468', descr => 'area of circle',
proname => 'area', prorettype => 'float8', proargtypes => 'circle',
prosrc => 'circle_area' },
{ oid => '1469', descr => 'diameter of circle',
proname => 'diameter', prorettype => 'float8', proargtypes => 'circle',
prosrc => 'circle_diameter' },
{ oid => '1470', descr => 'radius of circle',
proname => 'radius', prorettype => 'float8', proargtypes => 'circle',
prosrc => 'circle_radius' },
{ oid => '1471',
proname => 'circle_distance', prorettype => 'float8',
proargtypes => 'circle circle', prosrc => 'circle_distance' },
{ oid => '1472',
proname => 'circle_center', prorettype => 'point', proargtypes => 'circle',
prosrc => 'circle_center' },
{ oid => '1473', descr => 'convert point and radius to circle',
proname => 'circle', prorettype => 'circle', proargtypes => 'point float8',
prosrc => 'cr_circle' },
{ oid => '1474', descr => 'convert polygon to circle',
proname => 'circle', prorettype => 'circle', proargtypes => 'polygon',
prosrc => 'poly_circle' },
{ oid => '1475', descr => 'convert vertex count and circle to polygon',
proname => 'polygon', prorettype => 'polygon', proargtypes => 'int4 circle',
prosrc => 'circle_poly' },
{ oid => '1476',
proname => 'dist_pc', prorettype => 'float8', proargtypes => 'point circle',
prosrc => 'dist_pc' },
{ oid => '1477',
proname => 'circle_contain_pt', prorettype => 'bool',
proargtypes => 'circle point', prosrc => 'circle_contain_pt' },
{ oid => '1478',
proname => 'pt_contained_circle', prorettype => 'bool',
proargtypes => 'point circle', prosrc => 'pt_contained_circle' },
{ oid => '4091', descr => 'convert point to empty box',
proname => 'box', prorettype => 'box', proargtypes => 'point',
prosrc => 'point_box' },
{ oid => '1479', descr => 'convert box to circle',
proname => 'circle', prorettype => 'circle', proargtypes => 'box',
prosrc => 'box_circle' },
{ oid => '1480', descr => 'convert circle to box',
proname => 'box', prorettype => 'box', proargtypes => 'circle',
prosrc => 'circle_box' },
{ oid => '1482',
proname => 'lseg_ne', proleakproof => 't', prorettype => 'bool',
proargtypes => 'lseg lseg', prosrc => 'lseg_ne' },
{ oid => '1483',
proname => 'lseg_lt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'lseg lseg', prosrc => 'lseg_lt' },
{ oid => '1484',
proname => 'lseg_le', proleakproof => 't', prorettype => 'bool',
proargtypes => 'lseg lseg', prosrc => 'lseg_le' },
{ oid => '1485',
proname => 'lseg_gt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'lseg lseg', prosrc => 'lseg_gt' },
{ oid => '1486',
proname => 'lseg_ge', proleakproof => 't', prorettype => 'bool',
proargtypes => 'lseg lseg', prosrc => 'lseg_ge' },
{ oid => '1487',
proname => 'lseg_length', prorettype => 'float8', proargtypes => 'lseg',
prosrc => 'lseg_length' },
{ oid => '1488',
proname => 'close_ls', prorettype => 'point', proargtypes => 'line lseg',
prosrc => 'close_ls' },
{ oid => '1489',
proname => 'close_lseg', prorettype => 'point', proargtypes => 'lseg lseg',
prosrc => 'close_lseg' },
{ oid => '1490', descr => 'I/O',
proname => 'line_in', prorettype => 'line', proargtypes => 'cstring',
prosrc => 'line_in' },
{ oid => '1491', descr => 'I/O',
proname => 'line_out', prorettype => 'cstring', proargtypes => 'line',
prosrc => 'line_out' },
{ oid => '1492',
proname => 'line_eq', prorettype => 'bool', proargtypes => 'line line',
prosrc => 'line_eq' },
{ oid => '1493', descr => 'construct line from points',
proname => 'line', prorettype => 'line', proargtypes => 'point point',
prosrc => 'line_construct_pp' },
{ oid => '1494',
proname => 'line_interpt', prorettype => 'point', proargtypes => 'line line',
prosrc => 'line_interpt' },
{ oid => '1495',
proname => 'line_intersect', prorettype => 'bool', proargtypes => 'line line',
prosrc => 'line_intersect' },
{ oid => '1496',
proname => 'line_parallel', prorettype => 'bool', proargtypes => 'line line',
prosrc => 'line_parallel' },
{ oid => '1497',
proname => 'line_perp', prorettype => 'bool', proargtypes => 'line line',
prosrc => 'line_perp' },
{ oid => '1498',
proname => 'line_vertical', prorettype => 'bool', proargtypes => 'line',
prosrc => 'line_vertical' },
{ oid => '1499',
proname => 'line_horizontal', prorettype => 'bool', proargtypes => 'line',
prosrc => 'line_horizontal' },
# OIDS 1500 - 1599
{ oid => '1530', descr => 'distance between endpoints',
proname => 'length', prorettype => 'float8', proargtypes => 'lseg',
prosrc => 'lseg_length' },
{ oid => '1531', descr => 'sum of path segments',
proname => 'length', prorettype => 'float8', proargtypes => 'path',
prosrc => 'path_length' },
{ oid => '1532', descr => 'center of',
proname => 'point', prorettype => 'point', proargtypes => 'lseg',
prosrc => 'lseg_center' },
{ oid => '1533', descr => 'center of',
proname => 'point', prorettype => 'point', proargtypes => 'path',
prosrc => 'path_center' },
{ oid => '1534', descr => 'center of',
proname => 'point', prorettype => 'point', proargtypes => 'box',
prosrc => 'box_center' },
{ oid => '1540', descr => 'center of',
proname => 'point', prorettype => 'point', proargtypes => 'polygon',
prosrc => 'poly_center' },
{ oid => '1541', descr => 'diagonal of',
proname => 'lseg', prorettype => 'lseg', proargtypes => 'box',
prosrc => 'box_diagonal' },
{ oid => '1542', descr => 'center of',
proname => 'center', prorettype => 'point', proargtypes => 'box',
prosrc => 'box_center' },
{ oid => '1543', descr => 'center of',
proname => 'center', prorettype => 'point', proargtypes => 'circle',
prosrc => 'circle_center' },
{ oid => '1544', descr => 'convert circle to 12-vertex polygon',
proname => 'polygon', prolang => '14', prorettype => 'polygon',
proargtypes => 'circle', prosrc => 'select pg_catalog.polygon(12, $1)' },
{ oid => '1545', descr => 'number of points',
proname => 'npoints', prorettype => 'int4', proargtypes => 'path',
prosrc => 'path_npoints' },
{ oid => '1556', descr => 'number of points',
proname => 'npoints', prorettype => 'int4', proargtypes => 'polygon',
prosrc => 'poly_npoints' },
{ oid => '1564', descr => 'I/O',
proname => 'bit_in', prorettype => 'bit', proargtypes => 'cstring oid int4',
prosrc => 'bit_in' },
{ oid => '1565', descr => 'I/O',
proname => 'bit_out', prorettype => 'cstring', proargtypes => 'bit',
prosrc => 'bit_out' },
{ oid => '2919', descr => 'I/O typmod',
proname => 'bittypmodin', prorettype => 'int4', proargtypes => '_cstring',
prosrc => 'bittypmodin' },
{ oid => '2920', descr => 'I/O typmod',
proname => 'bittypmodout', prorettype => 'cstring', proargtypes => 'int4',
prosrc => 'bittypmodout' },
{ oid => '1569', descr => 'matches LIKE expression',
proname => 'like', prorettype => 'bool', proargtypes => 'text text',
prosrc => 'textlike' },
{ oid => '1570', descr => 'does not match LIKE expression',
proname => 'notlike', prorettype => 'bool', proargtypes => 'text text',
prosrc => 'textnlike' },
{ oid => '1571', descr => 'matches LIKE expression',
proname => 'like', prorettype => 'bool', proargtypes => 'name text',
prosrc => 'namelike' },
{ oid => '1572', descr => 'does not match LIKE expression',
proname => 'notlike', prorettype => 'bool', proargtypes => 'name text',
prosrc => 'namenlike' },
# SEQUENCE functions
{ oid => '1574', descr => 'sequence next value',
proname => 'nextval', provolatile => 'v', proparallel => 'u',
prorettype => 'int8', proargtypes => 'regclass', prosrc => 'nextval_oid' },
{ oid => '1575', descr => 'sequence current value',
proname => 'currval', provolatile => 'v', proparallel => 'u',
prorettype => 'int8', proargtypes => 'regclass', prosrc => 'currval_oid' },
{ oid => '1576', descr => 'set sequence value',
proname => 'setval', provolatile => 'v', proparallel => 'u',
prorettype => 'int8', proargtypes => 'regclass int8',
prosrc => 'setval_oid' },
{ oid => '1765', descr => 'set sequence value and is_called status',
proname => 'setval', provolatile => 'v', proparallel => 'u',
prorettype => 'int8', proargtypes => 'regclass int8 bool',
prosrc => 'setval3_oid' },
{ oid => '3078',
descr => 'sequence parameters, for use by information schema',
proname => 'pg_sequence_parameters', provolatile => 's',
prorettype => 'record', proargtypes => 'oid',
proallargtypes => '{oid,int8,int8,int8,int8,bool,int8,oid}',
proargmodes => '{i,o,o,o,o,o,o,o}',
proargnames => '{sequence_oid,start_value,minimum_value,maximum_value,increment,cycle_option,cache_size,data_type}',
prosrc => 'pg_sequence_parameters' },
{ oid => '4032', descr => 'sequence last value',
proname => 'pg_sequence_last_value', provolatile => 'v', proparallel => 'u',
prorettype => 'int8', proargtypes => 'regclass',
prosrc => 'pg_sequence_last_value' },
Remove WITH OIDS support, change oid catalog column visibility. Previously tables declared WITH OIDS, including a significant fraction of the catalog tables, stored the oid column not as a normal column, but as part of the tuple header. This special column was not shown by default, which was somewhat odd, as it's often (consider e.g. pg_class.oid) one of the more important parts of a row. Neither pg_dump nor COPY included the contents of the oid column by default. The fact that the oid column was not an ordinary column necessitated a significant amount of special case code to support oid columns. That already was painful for the existing, but upcoming work aiming to make table storage pluggable, would have required expanding and duplicating that "specialness" significantly. WITH OIDS has been deprecated since 2005 (commit ff02d0a05280e0). Remove it. Removing includes: - CREATE TABLE and ALTER TABLE syntax for declaring the table to be WITH OIDS has been removed (WITH (oids[ = true]) will error out) - pg_dump does not support dumping tables declared WITH OIDS and will issue a warning when dumping one (and ignore the oid column). - restoring an pg_dump archive with pg_restore will warn when restoring a table with oid contents (and ignore the oid column) - COPY will refuse to load binary dump that includes oids. - pg_upgrade will error out when encountering tables declared WITH OIDS, they have to be altered to remove the oid column first. - Functionality to access the oid of the last inserted row (like plpgsql's RESULT_OID, spi's SPI_lastoid, ...) has been removed. The syntax for declaring a table WITHOUT OIDS (or WITH (oids = false) for CREATE TABLE) is still supported. While that requires a bit of support code, it seems unnecessary to break applications / dumps that do not use oids, and are explicit about not using them. The biggest user of WITH OID columns was postgres' catalog. This commit changes all 'magic' oid columns to be columns that are normally declared and stored. To reduce unnecessary query breakage all the newly added columns are still named 'oid', even if a table's column naming scheme would indicate 'reloid' or such. This obviously requires adapting a lot code, mostly replacing oid access via HeapTupleGetOid() with access to the underlying Form_pg_*->oid column. The bootstrap process now assigns oids for all oid columns in genbki.pl that do not have an explicit value (starting at the largest oid previously used), only oids assigned later by oids will be above FirstBootstrapObjectId. As the oid column now is a normal column the special bootstrap syntax for oids has been removed. Oids are not automatically assigned during insertion anymore, all backend code explicitly assigns oids with GetNewOidWithIndex(). For the rare case that insertions into the catalog via SQL are called for the new pg_nextoid() function can be used (which only works on catalog tables). The fact that oid columns on system tables are now normal columns means that they will be included in the set of columns expanded by * (i.e. SELECT * FROM pg_class will now include the table's oid, previously it did not). It'd not technically be hard to hide oid column by default, but that'd mean confusing behavior would either have to be carried forward forever, or it'd cause breakage down the line. While it's not unlikely that further adjustments are needed, the scope/invasiveness of the patch makes it worthwhile to get merge this now. It's painful to maintain externally, too complicated to commit after the code code freeze, and a dependency of a number of other patches. Catversion bump, for obvious reasons. Author: Andres Freund, with contributions by John Naylor Discussion: https://postgr.es/m/20180930034810.ywp2c7awz7opzcfr@alap3.anarazel.de
2018-11-21 00:36:57 +01:00
{ oid => '275', descr => 'return the next oid for a system table',
proname => 'pg_nextoid', provolatile => 'v', proparallel => 'u',
prorettype => 'oid', proargtypes => 'regclass name regclass',
prosrc => 'pg_nextoid' },
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
{ oid => '1579', descr => 'I/O',
proname => 'varbit_in', prorettype => 'varbit',
proargtypes => 'cstring oid int4', prosrc => 'varbit_in' },
{ oid => '1580', descr => 'I/O',
proname => 'varbit_out', prorettype => 'cstring', proargtypes => 'varbit',
prosrc => 'varbit_out' },
{ oid => '2902', descr => 'I/O typmod',
proname => 'varbittypmodin', prorettype => 'int4', proargtypes => '_cstring',
prosrc => 'varbittypmodin' },
{ oid => '2921', descr => 'I/O typmod',
proname => 'varbittypmodout', prorettype => 'cstring', proargtypes => 'int4',
prosrc => 'varbittypmodout' },
{ oid => '1581',
proname => 'biteq', proleakproof => 't', prorettype => 'bool',
proargtypes => 'bit bit', prosrc => 'biteq' },
{ oid => '1582',
proname => 'bitne', proleakproof => 't', prorettype => 'bool',
proargtypes => 'bit bit', prosrc => 'bitne' },
{ oid => '1592',
proname => 'bitge', proleakproof => 't', prorettype => 'bool',
proargtypes => 'bit bit', prosrc => 'bitge' },
{ oid => '1593',
proname => 'bitgt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'bit bit', prosrc => 'bitgt' },
{ oid => '1594',
proname => 'bitle', proleakproof => 't', prorettype => 'bool',
proargtypes => 'bit bit', prosrc => 'bitle' },
{ oid => '1595',
proname => 'bitlt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'bit bit', prosrc => 'bitlt' },
{ oid => '1596', descr => 'less-equal-greater',
Mark built-in btree comparison functions as leakproof where it's safe. Generally, if the comparison operators for a datatype or pair of datatypes are leakproof, the corresponding btree comparison support function can be considered so as well. But we had not originally worried about marking support functions as leakproof, reasoning that they'd not likely be used in queries so the marking wouldn't matter. It turns out there's at least one place where it does matter: calc_arraycontsel() finds the target datatype's default btree comparison function and tries to use that to estimate selectivity, but it will be blocked in some cases if the function isn't leakproof. This leads to unnecessarily poor selectivity estimates and bad plans, as seen in bug #15251. Hence, run around and apply proleakproof markings where the corresponding btree comparison operators are leakproof. (I did eyeball each function to verify that it wasn't doing anything surprising, too.) This isn't a full solution to bug #15251, and it's not back-patchable because of the need for a catversion bump. A more useful response probably is to consider whether we can check permissions on the parent table instead of the child. However, this change will help in some cases where that won't, and it's easy enough to do in HEAD, so let's do so. Discussion: https://postgr.es/m/3876.1531261875@sss.pgh.pa.us
2018-07-12 00:47:31 +02:00
proname => 'bitcmp', proleakproof => 't', prorettype => 'int4',
proargtypes => 'bit bit', prosrc => 'bitcmp' },
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
{ oid => '1598', descr => 'random value',
proname => 'random', provolatile => 'v', proparallel => 'r',
prorettype => 'float8', proargtypes => '', prosrc => 'drandom' },
{ oid => '1599', descr => 'set random seed',
proname => 'setseed', provolatile => 'v', proparallel => 'r',
prorettype => 'void', proargtypes => 'float8', prosrc => 'setseed' },
# OIDS 1600 - 1699
{ oid => '1600', descr => 'arcsine',
proname => 'asin', prorettype => 'float8', proargtypes => 'float8',
prosrc => 'dasin' },
{ oid => '1601', descr => 'arccosine',
proname => 'acos', prorettype => 'float8', proargtypes => 'float8',
prosrc => 'dacos' },
{ oid => '1602', descr => 'arctangent',
proname => 'atan', prorettype => 'float8', proargtypes => 'float8',
prosrc => 'datan' },
{ oid => '1603', descr => 'arctangent, two arguments',
proname => 'atan2', prorettype => 'float8', proargtypes => 'float8 float8',
prosrc => 'datan2' },
{ oid => '1604', descr => 'sine',
proname => 'sin', prorettype => 'float8', proargtypes => 'float8',
prosrc => 'dsin' },
{ oid => '1605', descr => 'cosine',
proname => 'cos', prorettype => 'float8', proargtypes => 'float8',
prosrc => 'dcos' },
{ oid => '1606', descr => 'tangent',
proname => 'tan', prorettype => 'float8', proargtypes => 'float8',
prosrc => 'dtan' },
{ oid => '1607', descr => 'cotangent',
proname => 'cot', prorettype => 'float8', proargtypes => 'float8',
prosrc => 'dcot' },
{ oid => '2731', descr => 'arcsine, degrees',
proname => 'asind', prorettype => 'float8', proargtypes => 'float8',
prosrc => 'dasind' },
{ oid => '2732', descr => 'arccosine, degrees',
proname => 'acosd', prorettype => 'float8', proargtypes => 'float8',
prosrc => 'dacosd' },
{ oid => '2733', descr => 'arctangent, degrees',
proname => 'atand', prorettype => 'float8', proargtypes => 'float8',
prosrc => 'datand' },
{ oid => '2734', descr => 'arctangent, two arguments, degrees',
proname => 'atan2d', prorettype => 'float8', proargtypes => 'float8 float8',
prosrc => 'datan2d' },
{ oid => '2735', descr => 'sine, degrees',
proname => 'sind', prorettype => 'float8', proargtypes => 'float8',
prosrc => 'dsind' },
{ oid => '2736', descr => 'cosine, degrees',
proname => 'cosd', prorettype => 'float8', proargtypes => 'float8',
prosrc => 'dcosd' },
{ oid => '2737', descr => 'tangent, degrees',
proname => 'tand', prorettype => 'float8', proargtypes => 'float8',
prosrc => 'dtand' },
{ oid => '2738', descr => 'cotangent, degrees',
proname => 'cotd', prorettype => 'float8', proargtypes => 'float8',
prosrc => 'dcotd' },
{ oid => '1608', descr => 'radians to degrees',
proname => 'degrees', prorettype => 'float8', proargtypes => 'float8',
prosrc => 'degrees' },
{ oid => '1609', descr => 'degrees to radians',
proname => 'radians', prorettype => 'float8', proargtypes => 'float8',
prosrc => 'radians' },
{ oid => '1610', descr => 'PI',
proname => 'pi', prorettype => 'float8', proargtypes => '', prosrc => 'dpi' },
{ oid => '1618',
proname => 'interval_mul', prorettype => 'interval',
proargtypes => 'interval float8', prosrc => 'interval_mul' },
{ oid => '1620', descr => 'convert first char to int4',
proname => 'ascii', prorettype => 'int4', proargtypes => 'text',
prosrc => 'ascii' },
{ oid => '1621', descr => 'convert int4 to char',
proname => 'chr', prorettype => 'text', proargtypes => 'int4',
prosrc => 'chr' },
{ oid => '1622', descr => 'replicate string n times',
proname => 'repeat', prorettype => 'text', proargtypes => 'text int4',
prosrc => 'repeat' },
{ oid => '1623', descr => 'convert SQL99 regexp pattern to POSIX style',
proname => 'similar_escape', proisstrict => 'f', prorettype => 'text',
proargtypes => 'text text', prosrc => 'similar_escape' },
{ oid => '1624',
proname => 'mul_d_interval', prorettype => 'interval',
proargtypes => 'float8 interval', prosrc => 'mul_d_interval' },
{ oid => '1631',
proname => 'bpcharlike', prorettype => 'bool', proargtypes => 'bpchar text',
prosrc => 'textlike' },
{ oid => '1632',
proname => 'bpcharnlike', prorettype => 'bool', proargtypes => 'bpchar text',
prosrc => 'textnlike' },
{ oid => '1633',
proname => 'texticlike', prorettype => 'bool', proargtypes => 'text text',
prosrc => 'texticlike' },
{ oid => '1634',
proname => 'texticnlike', prorettype => 'bool', proargtypes => 'text text',
prosrc => 'texticnlike' },
{ oid => '1635',
proname => 'nameiclike', prorettype => 'bool', proargtypes => 'name text',
prosrc => 'nameiclike' },
{ oid => '1636',
proname => 'nameicnlike', prorettype => 'bool', proargtypes => 'name text',
prosrc => 'nameicnlike' },
{ oid => '1637', descr => 'convert LIKE pattern to use backslash escapes',
proname => 'like_escape', prorettype => 'text', proargtypes => 'text text',
prosrc => 'like_escape' },
{ oid => '1656',
proname => 'bpcharicregexeq', prorettype => 'bool',
proargtypes => 'bpchar text', prosrc => 'texticregexeq' },
{ oid => '1657',
proname => 'bpcharicregexne', prorettype => 'bool',
proargtypes => 'bpchar text', prosrc => 'texticregexne' },
{ oid => '1658',
proname => 'bpcharregexeq', prorettype => 'bool',
proargtypes => 'bpchar text', prosrc => 'textregexeq' },
{ oid => '1659',
proname => 'bpcharregexne', prorettype => 'bool',
proargtypes => 'bpchar text', prosrc => 'textregexne' },
{ oid => '1660',
proname => 'bpchariclike', prorettype => 'bool', proargtypes => 'bpchar text',
prosrc => 'texticlike' },
{ oid => '1661',
proname => 'bpcharicnlike', prorettype => 'bool',
proargtypes => 'bpchar text', prosrc => 'texticnlike' },
# Oracle Compatibility Related Functions - By Edmund Mergl <E.Mergl@bawue.de>
{ oid => '868', descr => 'position of substring',
proname => 'strpos', prorettype => 'int4', proargtypes => 'text text',
prosrc => 'textpos' },
{ oid => '870', descr => 'lowercase',
proname => 'lower', prorettype => 'text', proargtypes => 'text',
prosrc => 'lower' },
{ oid => '871', descr => 'uppercase',
proname => 'upper', prorettype => 'text', proargtypes => 'text',
prosrc => 'upper' },
{ oid => '872', descr => 'capitalize each word',
proname => 'initcap', prorettype => 'text', proargtypes => 'text',
prosrc => 'initcap' },
{ oid => '873', descr => 'left-pad string to length',
proname => 'lpad', prorettype => 'text', proargtypes => 'text int4 text',
prosrc => 'lpad' },
{ oid => '874', descr => 'right-pad string to length',
proname => 'rpad', prorettype => 'text', proargtypes => 'text int4 text',
prosrc => 'rpad' },
{ oid => '875', descr => 'trim selected characters from left end of string',
proname => 'ltrim', prorettype => 'text', proargtypes => 'text text',
prosrc => 'ltrim' },
{ oid => '876', descr => 'trim selected characters from right end of string',
proname => 'rtrim', prorettype => 'text', proargtypes => 'text text',
prosrc => 'rtrim' },
{ oid => '877', descr => 'extract portion of string',
proname => 'substr', prorettype => 'text', proargtypes => 'text int4 int4',
prosrc => 'text_substr' },
{ oid => '878', descr => 'map a set of characters appearing in string',
proname => 'translate', prorettype => 'text', proargtypes => 'text text text',
prosrc => 'translate' },
{ oid => '879', descr => 'left-pad string to length',
proname => 'lpad', prolang => '14', prorettype => 'text',
proargtypes => 'text int4',
Rationalize handling of single and double quotes in bootstrap data. Change things around so that proper quoting of values interpolated into the BKI data by initdb is the responsibility of initdb, not something we half-heartedly handle by putting double quotes into the raw BKI data. (Note: experimentation shows that it still doesn't work to put a double quote into the initial superuser username, but that's the fault of inadequate quoting while interpolating the name into SQL scripts; the BKI aspect of it works fine now.) Having done that, we can remove the special-case handling of values that look like "something" from genbki.pl, and instead teach it to escape double --- and single --- quotes properly. This removes the nowhere-documented need to treat those specially in the BKI source data; whatever you write will be passed through unchanged into the inserted data value, modulo Perl's rules about single-quoted strings. Add documentation explaining the (pre-existing) handling of backslashes in the BKI data. Per an earlier discussion with John Naylor. Discussion: https://postgr.es/m/CAJVSVGUNao=-Q2-vAN3PYcdF5tnL5JAHwGwzZGuYHtq+Mk_9ng@mail.gmail.com
2018-04-18 01:53:50 +02:00
prosrc => 'select pg_catalog.lpad($1, $2, \' \')' },
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
{ oid => '880', descr => 'right-pad string to length',
proname => 'rpad', prolang => '14', prorettype => 'text',
proargtypes => 'text int4',
Rationalize handling of single and double quotes in bootstrap data. Change things around so that proper quoting of values interpolated into the BKI data by initdb is the responsibility of initdb, not something we half-heartedly handle by putting double quotes into the raw BKI data. (Note: experimentation shows that it still doesn't work to put a double quote into the initial superuser username, but that's the fault of inadequate quoting while interpolating the name into SQL scripts; the BKI aspect of it works fine now.) Having done that, we can remove the special-case handling of values that look like "something" from genbki.pl, and instead teach it to escape double --- and single --- quotes properly. This removes the nowhere-documented need to treat those specially in the BKI source data; whatever you write will be passed through unchanged into the inserted data value, modulo Perl's rules about single-quoted strings. Add documentation explaining the (pre-existing) handling of backslashes in the BKI data. Per an earlier discussion with John Naylor. Discussion: https://postgr.es/m/CAJVSVGUNao=-Q2-vAN3PYcdF5tnL5JAHwGwzZGuYHtq+Mk_9ng@mail.gmail.com
2018-04-18 01:53:50 +02:00
prosrc => 'select pg_catalog.rpad($1, $2, \' \')' },
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
{ oid => '881', descr => 'trim spaces from left end of string',
proname => 'ltrim', prorettype => 'text', proargtypes => 'text',
prosrc => 'ltrim1' },
{ oid => '882', descr => 'trim spaces from right end of string',
proname => 'rtrim', prorettype => 'text', proargtypes => 'text',
prosrc => 'rtrim1' },
{ oid => '883', descr => 'extract portion of string',
proname => 'substr', prorettype => 'text', proargtypes => 'text int4',
prosrc => 'text_substr_no_len' },
{ oid => '884', descr => 'trim selected characters from both ends of string',
proname => 'btrim', prorettype => 'text', proargtypes => 'text text',
prosrc => 'btrim' },
{ oid => '885', descr => 'trim spaces from both ends of string',
proname => 'btrim', prorettype => 'text', proargtypes => 'text',
prosrc => 'btrim1' },
{ oid => '936', descr => 'extract portion of string',
proname => 'substring', prorettype => 'text', proargtypes => 'text int4 int4',
prosrc => 'text_substr' },
{ oid => '937', descr => 'extract portion of string',
proname => 'substring', prorettype => 'text', proargtypes => 'text int4',
prosrc => 'text_substr_no_len' },
{ oid => '2087',
descr => 'replace all occurrences in string of old_substr with new_substr',
proname => 'replace', prorettype => 'text', proargtypes => 'text text text',
prosrc => 'replace_text' },
{ oid => '2284', descr => 'replace text using regexp',
proname => 'regexp_replace', prorettype => 'text',
proargtypes => 'text text text', prosrc => 'textregexreplace_noopt' },
{ oid => '2285', descr => 'replace text using regexp',
proname => 'regexp_replace', prorettype => 'text',
proargtypes => 'text text text text', prosrc => 'textregexreplace' },
{ oid => '3396', descr => 'find first match for regexp',
proname => 'regexp_match', prorettype => '_text', proargtypes => 'text text',
prosrc => 'regexp_match_no_flags' },
{ oid => '3397', descr => 'find first match for regexp',
proname => 'regexp_match', prorettype => '_text',
proargtypes => 'text text text', prosrc => 'regexp_match' },
{ oid => '2763', descr => 'find match(es) for regexp',
proname => 'regexp_matches', prorows => '1', proretset => 't',
prorettype => '_text', proargtypes => 'text text',
prosrc => 'regexp_matches_no_flags' },
{ oid => '2764', descr => 'find match(es) for regexp',
proname => 'regexp_matches', prorows => '10', proretset => 't',
prorettype => '_text', proargtypes => 'text text text',
prosrc => 'regexp_matches' },
{ oid => '2088', descr => 'split string by field_sep and return field_num',
proname => 'split_part', prorettype => 'text',
proargtypes => 'text text int4', prosrc => 'split_text' },
{ oid => '2765', descr => 'split string by pattern',
proname => 'regexp_split_to_table', prorows => '1000', proretset => 't',
prorettype => 'text', proargtypes => 'text text',
prosrc => 'regexp_split_to_table_no_flags' },
{ oid => '2766', descr => 'split string by pattern',
proname => 'regexp_split_to_table', prorows => '1000', proretset => 't',
prorettype => 'text', proargtypes => 'text text text',
prosrc => 'regexp_split_to_table' },
{ oid => '2767', descr => 'split string by pattern',
proname => 'regexp_split_to_array', prorettype => '_text',
proargtypes => 'text text', prosrc => 'regexp_split_to_array_no_flags' },
{ oid => '2768', descr => 'split string by pattern',
proname => 'regexp_split_to_array', prorettype => '_text',
proargtypes => 'text text text', prosrc => 'regexp_split_to_array' },
{ oid => '2089', descr => 'convert int4 number to hex',
proname => 'to_hex', prorettype => 'text', proargtypes => 'int4',
prosrc => 'to_hex32' },
{ oid => '2090', descr => 'convert int8 number to hex',
proname => 'to_hex', prorettype => 'text', proargtypes => 'int8',
prosrc => 'to_hex64' },
# for character set encoding support
# return database encoding name
{ oid => '1039', descr => 'encoding name of current database',
proname => 'getdatabaseencoding', provolatile => 's', prorettype => 'name',
proargtypes => '', prosrc => 'getdatabaseencoding' },
# return client encoding name i.e. session encoding
{ oid => '810', descr => 'encoding name of current database',
proname => 'pg_client_encoding', provolatile => 's', prorettype => 'name',
proargtypes => '', prosrc => 'pg_client_encoding' },
{ oid => '1713', descr => 'length of string in specified encoding',
proname => 'length', provolatile => 's', prorettype => 'int4',
proargtypes => 'bytea name', prosrc => 'length_in_encoding' },
{ oid => '1714',
descr => 'convert string with specified source encoding name',
proname => 'convert_from', provolatile => 's', prorettype => 'text',
proargtypes => 'bytea name', prosrc => 'pg_convert_from' },
{ oid => '1717',
descr => 'convert string with specified destination encoding name',
proname => 'convert_to', provolatile => 's', prorettype => 'bytea',
proargtypes => 'text name', prosrc => 'pg_convert_to' },
{ oid => '1813', descr => 'convert string with specified encoding names',
proname => 'convert', provolatile => 's', prorettype => 'bytea',
proargtypes => 'bytea name name', prosrc => 'pg_convert' },
{ oid => '1264', descr => 'convert encoding name to encoding id',
proname => 'pg_char_to_encoding', provolatile => 's', prorettype => 'int4',
proargtypes => 'name', prosrc => 'PG_char_to_encoding' },
{ oid => '1597', descr => 'convert encoding id to encoding name',
proname => 'pg_encoding_to_char', provolatile => 's', prorettype => 'name',
proargtypes => 'int4', prosrc => 'PG_encoding_to_char' },
{ oid => '2319',
descr => 'maximum octet length of a character in given encoding',
proname => 'pg_encoding_max_length', prorettype => 'int4',
proargtypes => 'int4', prosrc => 'pg_encoding_max_length_sql' },
{ oid => '1638',
proname => 'oidgt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'oid oid', prosrc => 'oidgt' },
{ oid => '1639',
proname => 'oidge', proleakproof => 't', prorettype => 'bool',
proargtypes => 'oid oid', prosrc => 'oidge' },
# System-view support functions
{ oid => '1573', descr => 'source text of a rule',
proname => 'pg_get_ruledef', provolatile => 's', prorettype => 'text',
proargtypes => 'oid', prosrc => 'pg_get_ruledef' },
{ oid => '1640', descr => 'select statement of a view',
proname => 'pg_get_viewdef', provolatile => 's', proparallel => 'r',
prorettype => 'text', proargtypes => 'text',
prosrc => 'pg_get_viewdef_name' },
{ oid => '1641', descr => 'select statement of a view',
proname => 'pg_get_viewdef', provolatile => 's', proparallel => 'r',
prorettype => 'text', proargtypes => 'oid', prosrc => 'pg_get_viewdef' },
{ oid => '1642', descr => 'role name by OID (with fallback)',
proname => 'pg_get_userbyid', provolatile => 's', prorettype => 'name',
proargtypes => 'oid', prosrc => 'pg_get_userbyid' },
{ oid => '1643', descr => 'index description',
proname => 'pg_get_indexdef', provolatile => 's', prorettype => 'text',
proargtypes => 'oid', prosrc => 'pg_get_indexdef' },
{ oid => '3415', descr => 'extended statistics object description',
proname => 'pg_get_statisticsobjdef', provolatile => 's',
prorettype => 'text', proargtypes => 'oid',
prosrc => 'pg_get_statisticsobjdef' },
{ oid => '3352', descr => 'partition key description',
proname => 'pg_get_partkeydef', provolatile => 's', prorettype => 'text',
proargtypes => 'oid', prosrc => 'pg_get_partkeydef' },
{ oid => '3408', descr => 'partition constraint description',
proname => 'pg_get_partition_constraintdef', provolatile => 's',
prorettype => 'text', proargtypes => 'oid',
prosrc => 'pg_get_partition_constraintdef' },
{ oid => '1662', descr => 'trigger description',
proname => 'pg_get_triggerdef', provolatile => 's', prorettype => 'text',
proargtypes => 'oid', prosrc => 'pg_get_triggerdef' },
{ oid => '1387', descr => 'constraint description',
proname => 'pg_get_constraintdef', provolatile => 's', prorettype => 'text',
proargtypes => 'oid', prosrc => 'pg_get_constraintdef' },
{ oid => '1716', descr => 'deparse an encoded expression',
proname => 'pg_get_expr', provolatile => 's', prorettype => 'text',
proargtypes => 'pg_node_tree oid', prosrc => 'pg_get_expr' },
{ oid => '1665', descr => 'name of sequence for a serial column',
proname => 'pg_get_serial_sequence', provolatile => 's', prorettype => 'text',
proargtypes => 'text text', prosrc => 'pg_get_serial_sequence' },
{ oid => '2098', descr => 'definition of a function',
proname => 'pg_get_functiondef', provolatile => 's', prorettype => 'text',
proargtypes => 'oid', prosrc => 'pg_get_functiondef' },
{ oid => '2162', descr => 'argument list of a function',
proname => 'pg_get_function_arguments', provolatile => 's',
prorettype => 'text', proargtypes => 'oid',
prosrc => 'pg_get_function_arguments' },
{ oid => '2232', descr => 'identity argument list of a function',
proname => 'pg_get_function_identity_arguments', provolatile => 's',
prorettype => 'text', proargtypes => 'oid',
prosrc => 'pg_get_function_identity_arguments' },
{ oid => '2165', descr => 'result type of a function',
proname => 'pg_get_function_result', provolatile => 's', prorettype => 'text',
proargtypes => 'oid', prosrc => 'pg_get_function_result' },
{ oid => '3808', descr => 'function argument default',
proname => 'pg_get_function_arg_default', provolatile => 's',
prorettype => 'text', proargtypes => 'oid int4',
prosrc => 'pg_get_function_arg_default' },
{ oid => '1686', descr => 'list of SQL keywords',
proname => 'pg_get_keywords', procost => '10', prorows => '400',
proretset => 't', provolatile => 's', prorettype => 'record',
proargtypes => '', proallargtypes => '{text,char,text}',
proargmodes => '{o,o,o}', proargnames => '{word,catcode,catdesc}',
prosrc => 'pg_get_keywords' },
{ oid => '2289', descr => 'convert generic options array to name/value table',
proname => 'pg_options_to_table', prorows => '3', proretset => 't',
provolatile => 's', prorettype => 'record', proargtypes => '_text',
proallargtypes => '{_text,text,text}', proargmodes => '{i,o,o}',
proargnames => '{options_array,option_name,option_value}',
prosrc => 'pg_options_to_table' },
{ oid => '1619', descr => 'type of the argument',
proname => 'pg_typeof', proisstrict => 'f', provolatile => 's',
prorettype => 'regtype', proargtypes => 'any', prosrc => 'pg_typeof' },
{ oid => '3162',
descr => 'collation of the argument; implementation of the COLLATION FOR expression',
proname => 'pg_collation_for', proisstrict => 'f', provolatile => 's',
prorettype => 'text', proargtypes => 'any', prosrc => 'pg_collation_for' },
{ oid => '3842', descr => 'is a relation insertable/updatable/deletable',
proname => 'pg_relation_is_updatable', procost => '10', provolatile => 's',
prorettype => 'int4', proargtypes => 'regclass bool',
prosrc => 'pg_relation_is_updatable' },
{ oid => '3843', descr => 'is a column updatable',
proname => 'pg_column_is_updatable', procost => '10', provolatile => 's',
prorettype => 'bool', proargtypes => 'regclass int2 bool',
prosrc => 'pg_column_is_updatable' },
{ oid => '6120', descr => 'oid of replica identity index if any',
proname => 'pg_get_replica_identity_index', procost => '10',
provolatile => 's', prorettype => 'regclass', proargtypes => 'regclass',
prosrc => 'pg_get_replica_identity_index' },
# Deferrable unique constraint trigger
{ oid => '1250', descr => 'deferred UNIQUE constraint check',
proname => 'unique_key_recheck', provolatile => 'v', prorettype => 'trigger',
proargtypes => '', prosrc => 'unique_key_recheck' },
# Generic referential integrity constraint triggers
{ oid => '1644', descr => 'referential integrity FOREIGN KEY ... REFERENCES',
proname => 'RI_FKey_check_ins', provolatile => 'v', prorettype => 'trigger',
proargtypes => '', prosrc => 'RI_FKey_check_ins' },
{ oid => '1645', descr => 'referential integrity FOREIGN KEY ... REFERENCES',
proname => 'RI_FKey_check_upd', provolatile => 'v', prorettype => 'trigger',
proargtypes => '', prosrc => 'RI_FKey_check_upd' },
{ oid => '1646', descr => 'referential integrity ON DELETE CASCADE',
proname => 'RI_FKey_cascade_del', provolatile => 'v', prorettype => 'trigger',
proargtypes => '', prosrc => 'RI_FKey_cascade_del' },
{ oid => '1647', descr => 'referential integrity ON UPDATE CASCADE',
proname => 'RI_FKey_cascade_upd', provolatile => 'v', prorettype => 'trigger',
proargtypes => '', prosrc => 'RI_FKey_cascade_upd' },
{ oid => '1648', descr => 'referential integrity ON DELETE RESTRICT',
proname => 'RI_FKey_restrict_del', provolatile => 'v',
prorettype => 'trigger', proargtypes => '',
prosrc => 'RI_FKey_restrict_del' },
{ oid => '1649', descr => 'referential integrity ON UPDATE RESTRICT',
proname => 'RI_FKey_restrict_upd', provolatile => 'v',
prorettype => 'trigger', proargtypes => '',
prosrc => 'RI_FKey_restrict_upd' },
{ oid => '1650', descr => 'referential integrity ON DELETE SET NULL',
proname => 'RI_FKey_setnull_del', provolatile => 'v', prorettype => 'trigger',
proargtypes => '', prosrc => 'RI_FKey_setnull_del' },
{ oid => '1651', descr => 'referential integrity ON UPDATE SET NULL',
proname => 'RI_FKey_setnull_upd', provolatile => 'v', prorettype => 'trigger',
proargtypes => '', prosrc => 'RI_FKey_setnull_upd' },
{ oid => '1652', descr => 'referential integrity ON DELETE SET DEFAULT',
proname => 'RI_FKey_setdefault_del', provolatile => 'v',
prorettype => 'trigger', proargtypes => '',
prosrc => 'RI_FKey_setdefault_del' },
{ oid => '1653', descr => 'referential integrity ON UPDATE SET DEFAULT',
proname => 'RI_FKey_setdefault_upd', provolatile => 'v',
prorettype => 'trigger', proargtypes => '',
prosrc => 'RI_FKey_setdefault_upd' },
{ oid => '1654', descr => 'referential integrity ON DELETE NO ACTION',
proname => 'RI_FKey_noaction_del', provolatile => 'v',
prorettype => 'trigger', proargtypes => '',
prosrc => 'RI_FKey_noaction_del' },
{ oid => '1655', descr => 'referential integrity ON UPDATE NO ACTION',
proname => 'RI_FKey_noaction_upd', provolatile => 'v',
prorettype => 'trigger', proargtypes => '',
prosrc => 'RI_FKey_noaction_upd' },
{ oid => '1666',
proname => 'varbiteq', proleakproof => 't', prorettype => 'bool',
proargtypes => 'varbit varbit', prosrc => 'biteq' },
{ oid => '1667',
proname => 'varbitne', proleakproof => 't', prorettype => 'bool',
proargtypes => 'varbit varbit', prosrc => 'bitne' },
{ oid => '1668',
proname => 'varbitge', proleakproof => 't', prorettype => 'bool',
proargtypes => 'varbit varbit', prosrc => 'bitge' },
{ oid => '1669',
proname => 'varbitgt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'varbit varbit', prosrc => 'bitgt' },
{ oid => '1670',
proname => 'varbitle', proleakproof => 't', prorettype => 'bool',
proargtypes => 'varbit varbit', prosrc => 'bitle' },
{ oid => '1671',
proname => 'varbitlt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'varbit varbit', prosrc => 'bitlt' },
{ oid => '1672', descr => 'less-equal-greater',
Mark built-in btree comparison functions as leakproof where it's safe. Generally, if the comparison operators for a datatype or pair of datatypes are leakproof, the corresponding btree comparison support function can be considered so as well. But we had not originally worried about marking support functions as leakproof, reasoning that they'd not likely be used in queries so the marking wouldn't matter. It turns out there's at least one place where it does matter: calc_arraycontsel() finds the target datatype's default btree comparison function and tries to use that to estimate selectivity, but it will be blocked in some cases if the function isn't leakproof. This leads to unnecessarily poor selectivity estimates and bad plans, as seen in bug #15251. Hence, run around and apply proleakproof markings where the corresponding btree comparison operators are leakproof. (I did eyeball each function to verify that it wasn't doing anything surprising, too.) This isn't a full solution to bug #15251, and it's not back-patchable because of the need for a catversion bump. A more useful response probably is to consider whether we can check permissions on the parent table instead of the child. However, this change will help in some cases where that won't, and it's easy enough to do in HEAD, so let's do so. Discussion: https://postgr.es/m/3876.1531261875@sss.pgh.pa.us
2018-07-12 00:47:31 +02:00
proname => 'varbitcmp', proleakproof => 't', prorettype => 'int4',
proargtypes => 'varbit varbit', prosrc => 'bitcmp' },
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
# avoid the C names bitand and bitor, since they are C++ keywords
{ oid => '1673',
proname => 'bitand', prorettype => 'bit', proargtypes => 'bit bit',
prosrc => 'bit_and' },
{ oid => '1674',
proname => 'bitor', prorettype => 'bit', proargtypes => 'bit bit',
prosrc => 'bit_or' },
{ oid => '1675',
proname => 'bitxor', prorettype => 'bit', proargtypes => 'bit bit',
prosrc => 'bitxor' },
{ oid => '1676',
proname => 'bitnot', prorettype => 'bit', proargtypes => 'bit',
prosrc => 'bitnot' },
{ oid => '1677',
proname => 'bitshiftleft', prorettype => 'bit', proargtypes => 'bit int4',
prosrc => 'bitshiftleft' },
{ oid => '1678',
proname => 'bitshiftright', prorettype => 'bit', proargtypes => 'bit int4',
prosrc => 'bitshiftright' },
{ oid => '1679',
proname => 'bitcat', prorettype => 'varbit', proargtypes => 'varbit varbit',
prosrc => 'bitcat' },
{ oid => '1680', descr => 'extract portion of bitstring',
proname => 'substring', prorettype => 'bit', proargtypes => 'bit int4 int4',
prosrc => 'bitsubstr' },
{ oid => '1681', descr => 'bitstring length',
proname => 'length', prorettype => 'int4', proargtypes => 'bit',
prosrc => 'bitlength' },
{ oid => '1682', descr => 'octet length',
proname => 'octet_length', prorettype => 'int4', proargtypes => 'bit',
prosrc => 'bitoctetlength' },
{ oid => '1683', descr => 'convert int4 to bitstring',
proname => 'bit', prorettype => 'bit', proargtypes => 'int4 int4',
prosrc => 'bitfromint4' },
{ oid => '1684', descr => 'convert bitstring to int4',
proname => 'int4', prorettype => 'int4', proargtypes => 'bit',
prosrc => 'bittoint4' },
{ oid => '1685', descr => 'adjust bit() to typmod length',
proname => 'bit', prorettype => 'bit', proargtypes => 'bit int4 bool',
prosrc => 'bit' },
{ oid => '3158', descr => 'transform a varbit length coercion',
proname => 'varbit_transform', prorettype => 'internal',
proargtypes => 'internal', prosrc => 'varbit_transform' },
{ oid => '1687', descr => 'adjust varbit() to typmod length',
proname => 'varbit', protransform => 'varbit_transform',
prorettype => 'varbit', proargtypes => 'varbit int4 bool',
prosrc => 'varbit' },
{ oid => '1698', descr => 'position of sub-bitstring',
proname => 'position', prorettype => 'int4', proargtypes => 'bit bit',
prosrc => 'bitposition' },
{ oid => '1699', descr => 'extract portion of bitstring',
proname => 'substring', prorettype => 'bit', proargtypes => 'bit int4',
prosrc => 'bitsubstr_no_len' },
{ oid => '3030', descr => 'substitute portion of bitstring',
proname => 'overlay', prorettype => 'bit', proargtypes => 'bit bit int4 int4',
prosrc => 'bitoverlay' },
{ oid => '3031', descr => 'substitute portion of bitstring',
proname => 'overlay', prorettype => 'bit', proargtypes => 'bit bit int4',
prosrc => 'bitoverlay_no_len' },
{ oid => '3032', descr => 'get bit',
proname => 'get_bit', prorettype => 'int4', proargtypes => 'bit int4',
prosrc => 'bitgetbit' },
{ oid => '3033', descr => 'set bit',
proname => 'set_bit', prorettype => 'bit', proargtypes => 'bit int4 int4',
prosrc => 'bitsetbit' },
# for macaddr type support
{ oid => '436', descr => 'I/O',
proname => 'macaddr_in', prorettype => 'macaddr', proargtypes => 'cstring',
prosrc => 'macaddr_in' },
{ oid => '437', descr => 'I/O',
proname => 'macaddr_out', prorettype => 'cstring', proargtypes => 'macaddr',
prosrc => 'macaddr_out' },
{ oid => '753', descr => 'MACADDR manufacturer fields',
proname => 'trunc', prorettype => 'macaddr', proargtypes => 'macaddr',
prosrc => 'macaddr_trunc' },
{ oid => '830',
proname => 'macaddr_eq', proleakproof => 't', prorettype => 'bool',
proargtypes => 'macaddr macaddr', prosrc => 'macaddr_eq' },
{ oid => '831',
proname => 'macaddr_lt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'macaddr macaddr', prosrc => 'macaddr_lt' },
{ oid => '832',
proname => 'macaddr_le', proleakproof => 't', prorettype => 'bool',
proargtypes => 'macaddr macaddr', prosrc => 'macaddr_le' },
{ oid => '833',
proname => 'macaddr_gt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'macaddr macaddr', prosrc => 'macaddr_gt' },
{ oid => '834',
proname => 'macaddr_ge', proleakproof => 't', prorettype => 'bool',
proargtypes => 'macaddr macaddr', prosrc => 'macaddr_ge' },
{ oid => '835',
proname => 'macaddr_ne', proleakproof => 't', prorettype => 'bool',
proargtypes => 'macaddr macaddr', prosrc => 'macaddr_ne' },
{ oid => '836', descr => 'less-equal-greater',
Mark built-in btree comparison functions as leakproof where it's safe. Generally, if the comparison operators for a datatype or pair of datatypes are leakproof, the corresponding btree comparison support function can be considered so as well. But we had not originally worried about marking support functions as leakproof, reasoning that they'd not likely be used in queries so the marking wouldn't matter. It turns out there's at least one place where it does matter: calc_arraycontsel() finds the target datatype's default btree comparison function and tries to use that to estimate selectivity, but it will be blocked in some cases if the function isn't leakproof. This leads to unnecessarily poor selectivity estimates and bad plans, as seen in bug #15251. Hence, run around and apply proleakproof markings where the corresponding btree comparison operators are leakproof. (I did eyeball each function to verify that it wasn't doing anything surprising, too.) This isn't a full solution to bug #15251, and it's not back-patchable because of the need for a catversion bump. A more useful response probably is to consider whether we can check permissions on the parent table instead of the child. However, this change will help in some cases where that won't, and it's easy enough to do in HEAD, so let's do so. Discussion: https://postgr.es/m/3876.1531261875@sss.pgh.pa.us
2018-07-12 00:47:31 +02:00
proname => 'macaddr_cmp', proleakproof => 't', prorettype => 'int4',
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
proargtypes => 'macaddr macaddr', prosrc => 'macaddr_cmp' },
{ oid => '3144',
proname => 'macaddr_not', prorettype => 'macaddr', proargtypes => 'macaddr',
prosrc => 'macaddr_not' },
{ oid => '3145',
proname => 'macaddr_and', prorettype => 'macaddr',
proargtypes => 'macaddr macaddr', prosrc => 'macaddr_and' },
{ oid => '3146',
proname => 'macaddr_or', prorettype => 'macaddr',
proargtypes => 'macaddr macaddr', prosrc => 'macaddr_or' },
{ oid => '3359', descr => 'sort support',
proname => 'macaddr_sortsupport', prorettype => 'void',
proargtypes => 'internal', prosrc => 'macaddr_sortsupport' },
# for macaddr8 type support
{ oid => '4110', descr => 'I/O',
proname => 'macaddr8_in', prorettype => 'macaddr8', proargtypes => 'cstring',
prosrc => 'macaddr8_in' },
{ oid => '4111', descr => 'I/O',
proname => 'macaddr8_out', prorettype => 'cstring', proargtypes => 'macaddr8',
prosrc => 'macaddr8_out' },
{ oid => '4112', descr => 'MACADDR8 manufacturer fields',
proname => 'trunc', prorettype => 'macaddr8', proargtypes => 'macaddr8',
prosrc => 'macaddr8_trunc' },
{ oid => '4113',
proname => 'macaddr8_eq', proleakproof => 't', prorettype => 'bool',
proargtypes => 'macaddr8 macaddr8', prosrc => 'macaddr8_eq' },
{ oid => '4114',
proname => 'macaddr8_lt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'macaddr8 macaddr8', prosrc => 'macaddr8_lt' },
{ oid => '4115',
proname => 'macaddr8_le', proleakproof => 't', prorettype => 'bool',
proargtypes => 'macaddr8 macaddr8', prosrc => 'macaddr8_le' },
{ oid => '4116',
proname => 'macaddr8_gt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'macaddr8 macaddr8', prosrc => 'macaddr8_gt' },
{ oid => '4117',
proname => 'macaddr8_ge', proleakproof => 't', prorettype => 'bool',
proargtypes => 'macaddr8 macaddr8', prosrc => 'macaddr8_ge' },
{ oid => '4118',
proname => 'macaddr8_ne', proleakproof => 't', prorettype => 'bool',
proargtypes => 'macaddr8 macaddr8', prosrc => 'macaddr8_ne' },
{ oid => '4119', descr => 'less-equal-greater',
Mark built-in btree comparison functions as leakproof where it's safe. Generally, if the comparison operators for a datatype or pair of datatypes are leakproof, the corresponding btree comparison support function can be considered so as well. But we had not originally worried about marking support functions as leakproof, reasoning that they'd not likely be used in queries so the marking wouldn't matter. It turns out there's at least one place where it does matter: calc_arraycontsel() finds the target datatype's default btree comparison function and tries to use that to estimate selectivity, but it will be blocked in some cases if the function isn't leakproof. This leads to unnecessarily poor selectivity estimates and bad plans, as seen in bug #15251. Hence, run around and apply proleakproof markings where the corresponding btree comparison operators are leakproof. (I did eyeball each function to verify that it wasn't doing anything surprising, too.) This isn't a full solution to bug #15251, and it's not back-patchable because of the need for a catversion bump. A more useful response probably is to consider whether we can check permissions on the parent table instead of the child. However, this change will help in some cases where that won't, and it's easy enough to do in HEAD, so let's do so. Discussion: https://postgr.es/m/3876.1531261875@sss.pgh.pa.us
2018-07-12 00:47:31 +02:00
proname => 'macaddr8_cmp', proleakproof => 't', prorettype => 'int4',
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
proargtypes => 'macaddr8 macaddr8', prosrc => 'macaddr8_cmp' },
{ oid => '4120',
proname => 'macaddr8_not', prorettype => 'macaddr8',
proargtypes => 'macaddr8', prosrc => 'macaddr8_not' },
{ oid => '4121',
proname => 'macaddr8_and', prorettype => 'macaddr8',
proargtypes => 'macaddr8 macaddr8', prosrc => 'macaddr8_and' },
{ oid => '4122',
proname => 'macaddr8_or', prorettype => 'macaddr8',
proargtypes => 'macaddr8 macaddr8', prosrc => 'macaddr8_or' },
{ oid => '4123', descr => 'convert macaddr to macaddr8',
proname => 'macaddr8', prorettype => 'macaddr8', proargtypes => 'macaddr',
prosrc => 'macaddrtomacaddr8' },
{ oid => '4124', descr => 'convert macaddr8 to macaddr',
proname => 'macaddr', prorettype => 'macaddr', proargtypes => 'macaddr8',
prosrc => 'macaddr8tomacaddr' },
{ oid => '4125', descr => 'set 7th bit in macaddr8',
proname => 'macaddr8_set7bit', prorettype => 'macaddr8',
proargtypes => 'macaddr8', prosrc => 'macaddr8_set7bit' },
# for inet type support
{ oid => '910', descr => 'I/O',
proname => 'inet_in', prorettype => 'inet', proargtypes => 'cstring',
prosrc => 'inet_in' },
{ oid => '911', descr => 'I/O',
proname => 'inet_out', prorettype => 'cstring', proargtypes => 'inet',
prosrc => 'inet_out' },
# for cidr type support
{ oid => '1267', descr => 'I/O',
proname => 'cidr_in', prorettype => 'cidr', proargtypes => 'cstring',
prosrc => 'cidr_in' },
{ oid => '1427', descr => 'I/O',
proname => 'cidr_out', prorettype => 'cstring', proargtypes => 'cidr',
prosrc => 'cidr_out' },
# these are used for both inet and cidr
{ oid => '920',
proname => 'network_eq', proleakproof => 't', prorettype => 'bool',
proargtypes => 'inet inet', prosrc => 'network_eq' },
{ oid => '921',
proname => 'network_lt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'inet inet', prosrc => 'network_lt' },
{ oid => '922',
proname => 'network_le', proleakproof => 't', prorettype => 'bool',
proargtypes => 'inet inet', prosrc => 'network_le' },
{ oid => '923',
proname => 'network_gt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'inet inet', prosrc => 'network_gt' },
{ oid => '924',
proname => 'network_ge', proleakproof => 't', prorettype => 'bool',
proargtypes => 'inet inet', prosrc => 'network_ge' },
{ oid => '925',
proname => 'network_ne', proleakproof => 't', prorettype => 'bool',
proargtypes => 'inet inet', prosrc => 'network_ne' },
{ oid => '3562', descr => 'larger of two',
proname => 'network_larger', prorettype => 'inet', proargtypes => 'inet inet',
prosrc => 'network_larger' },
{ oid => '3563', descr => 'smaller of two',
proname => 'network_smaller', prorettype => 'inet',
proargtypes => 'inet inet', prosrc => 'network_smaller' },
{ oid => '926', descr => 'less-equal-greater',
Mark built-in btree comparison functions as leakproof where it's safe. Generally, if the comparison operators for a datatype or pair of datatypes are leakproof, the corresponding btree comparison support function can be considered so as well. But we had not originally worried about marking support functions as leakproof, reasoning that they'd not likely be used in queries so the marking wouldn't matter. It turns out there's at least one place where it does matter: calc_arraycontsel() finds the target datatype's default btree comparison function and tries to use that to estimate selectivity, but it will be blocked in some cases if the function isn't leakproof. This leads to unnecessarily poor selectivity estimates and bad plans, as seen in bug #15251. Hence, run around and apply proleakproof markings where the corresponding btree comparison operators are leakproof. (I did eyeball each function to verify that it wasn't doing anything surprising, too.) This isn't a full solution to bug #15251, and it's not back-patchable because of the need for a catversion bump. A more useful response probably is to consider whether we can check permissions on the parent table instead of the child. However, this change will help in some cases where that won't, and it's easy enough to do in HEAD, so let's do so. Discussion: https://postgr.es/m/3876.1531261875@sss.pgh.pa.us
2018-07-12 00:47:31 +02:00
proname => 'network_cmp', proleakproof => 't', prorettype => 'int4',
proargtypes => 'inet inet', prosrc => 'network_cmp' },
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
{ oid => '927',
proname => 'network_sub', prorettype => 'bool', proargtypes => 'inet inet',
prosrc => 'network_sub' },
{ oid => '928',
proname => 'network_subeq', prorettype => 'bool', proargtypes => 'inet inet',
prosrc => 'network_subeq' },
{ oid => '929',
proname => 'network_sup', prorettype => 'bool', proargtypes => 'inet inet',
prosrc => 'network_sup' },
{ oid => '930',
proname => 'network_supeq', prorettype => 'bool', proargtypes => 'inet inet',
prosrc => 'network_supeq' },
{ oid => '3551',
proname => 'network_overlap', prorettype => 'bool',
proargtypes => 'inet inet', prosrc => 'network_overlap' },
# inet/cidr functions
{ oid => '598', descr => 'abbreviated display of inet value',
proname => 'abbrev', prorettype => 'text', proargtypes => 'inet',
prosrc => 'inet_abbrev' },
{ oid => '599', descr => 'abbreviated display of cidr value',
proname => 'abbrev', prorettype => 'text', proargtypes => 'cidr',
prosrc => 'cidr_abbrev' },
{ oid => '605', descr => 'change netmask of inet',
proname => 'set_masklen', prorettype => 'inet', proargtypes => 'inet int4',
prosrc => 'inet_set_masklen' },
{ oid => '635', descr => 'change netmask of cidr',
proname => 'set_masklen', prorettype => 'cidr', proargtypes => 'cidr int4',
prosrc => 'cidr_set_masklen' },
{ oid => '711', descr => 'address family (4 for IPv4, 6 for IPv6)',
proname => 'family', prorettype => 'int4', proargtypes => 'inet',
prosrc => 'network_family' },
{ oid => '683', descr => 'network part of address',
proname => 'network', prorettype => 'cidr', proargtypes => 'inet',
prosrc => 'network_network' },
{ oid => '696', descr => 'netmask of address',
proname => 'netmask', prorettype => 'inet', proargtypes => 'inet',
prosrc => 'network_netmask' },
{ oid => '697', descr => 'netmask length',
proname => 'masklen', prorettype => 'int4', proargtypes => 'inet',
prosrc => 'network_masklen' },
{ oid => '698', descr => 'broadcast address of network',
proname => 'broadcast', prorettype => 'inet', proargtypes => 'inet',
prosrc => 'network_broadcast' },
{ oid => '699', descr => 'show address octets only',
proname => 'host', prorettype => 'text', proargtypes => 'inet',
prosrc => 'network_host' },
{ oid => '730', descr => 'show all parts of inet/cidr value',
proname => 'text', prorettype => 'text', proargtypes => 'inet',
prosrc => 'network_show' },
{ oid => '1362', descr => 'hostmask of address',
proname => 'hostmask', prorettype => 'inet', proargtypes => 'inet',
prosrc => 'network_hostmask' },
{ oid => '1715', descr => 'convert inet to cidr',
proname => 'cidr', prorettype => 'cidr', proargtypes => 'inet',
prosrc => 'inet_to_cidr' },
{ oid => '2196', descr => 'inet address of the client',
proname => 'inet_client_addr', proisstrict => 'f', provolatile => 's',
proparallel => 'r', prorettype => 'inet', proargtypes => '',
prosrc => 'inet_client_addr' },
{ oid => '2197', descr => 'client\'s port number for this connection',
proname => 'inet_client_port', proisstrict => 'f', provolatile => 's',
proparallel => 'r', prorettype => 'int4', proargtypes => '',
prosrc => 'inet_client_port' },
{ oid => '2198', descr => 'inet address of the server',
proname => 'inet_server_addr', proisstrict => 'f', provolatile => 's',
prorettype => 'inet', proargtypes => '', prosrc => 'inet_server_addr' },
{ oid => '2199', descr => 'server\'s port number for this connection',
proname => 'inet_server_port', proisstrict => 'f', provolatile => 's',
prorettype => 'int4', proargtypes => '', prosrc => 'inet_server_port' },
{ oid => '2627',
proname => 'inetnot', prorettype => 'inet', proargtypes => 'inet',
prosrc => 'inetnot' },
{ oid => '2628',
proname => 'inetand', prorettype => 'inet', proargtypes => 'inet inet',
prosrc => 'inetand' },
{ oid => '2629',
proname => 'inetor', prorettype => 'inet', proargtypes => 'inet inet',
prosrc => 'inetor' },
{ oid => '2630',
proname => 'inetpl', prorettype => 'inet', proargtypes => 'inet int8',
prosrc => 'inetpl' },
{ oid => '2631',
proname => 'int8pl_inet', prolang => '14', prorettype => 'inet',
proargtypes => 'int8 inet', prosrc => 'select $2 + $1' },
{ oid => '2632',
proname => 'inetmi_int8', prorettype => 'inet', proargtypes => 'inet int8',
prosrc => 'inetmi_int8' },
{ oid => '2633',
proname => 'inetmi', prorettype => 'int8', proargtypes => 'inet inet',
prosrc => 'inetmi' },
{ oid => '4071', descr => 'are the addresses from the same family?',
proname => 'inet_same_family', prorettype => 'bool',
proargtypes => 'inet inet', prosrc => 'inet_same_family' },
{ oid => '4063',
descr => 'the smallest network which includes both of the given networks',
proname => 'inet_merge', prorettype => 'cidr', proargtypes => 'inet inet',
prosrc => 'inet_merge' },
# GiST support for inet and cidr
{ oid => '3553', descr => 'GiST support',
proname => 'inet_gist_consistent', prorettype => 'bool',
proargtypes => 'internal inet int2 oid internal',
prosrc => 'inet_gist_consistent' },
{ oid => '3554', descr => 'GiST support',
proname => 'inet_gist_union', prorettype => 'inet',
proargtypes => 'internal internal', prosrc => 'inet_gist_union' },
{ oid => '3555', descr => 'GiST support',
proname => 'inet_gist_compress', prorettype => 'internal',
proargtypes => 'internal', prosrc => 'inet_gist_compress' },
{ oid => '3573', descr => 'GiST support',
proname => 'inet_gist_fetch', prorettype => 'internal',
proargtypes => 'internal', prosrc => 'inet_gist_fetch' },
{ oid => '3557', descr => 'GiST support',
proname => 'inet_gist_penalty', prorettype => 'internal',
proargtypes => 'internal internal internal', prosrc => 'inet_gist_penalty' },
{ oid => '3558', descr => 'GiST support',
proname => 'inet_gist_picksplit', prorettype => 'internal',
proargtypes => 'internal internal', prosrc => 'inet_gist_picksplit' },
{ oid => '3559', descr => 'GiST support',
proname => 'inet_gist_same', prorettype => 'internal',
proargtypes => 'inet inet internal', prosrc => 'inet_gist_same' },
# SP-GiST support for inet and cidr
{ oid => '3795', descr => 'SP-GiST support',
proname => 'inet_spg_config', prorettype => 'void',
proargtypes => 'internal internal', prosrc => 'inet_spg_config' },
{ oid => '3796', descr => 'SP-GiST support',
proname => 'inet_spg_choose', prorettype => 'void',
proargtypes => 'internal internal', prosrc => 'inet_spg_choose' },
{ oid => '3797', descr => 'SP-GiST support',
proname => 'inet_spg_picksplit', prorettype => 'void',
proargtypes => 'internal internal', prosrc => 'inet_spg_picksplit' },
{ oid => '3798', descr => 'SP-GiST support',
proname => 'inet_spg_inner_consistent', prorettype => 'void',
proargtypes => 'internal internal', prosrc => 'inet_spg_inner_consistent' },
{ oid => '3799', descr => 'SP-GiST support',
proname => 'inet_spg_leaf_consistent', prorettype => 'bool',
proargtypes => 'internal internal', prosrc => 'inet_spg_leaf_consistent' },
# Selectivity estimation for inet and cidr
{ oid => '3560', descr => 'restriction selectivity for network operators',
proname => 'networksel', provolatile => 's', prorettype => 'float8',
proargtypes => 'internal oid internal int4', prosrc => 'networksel' },
{ oid => '3561', descr => 'join selectivity for network operators',
proname => 'networkjoinsel', provolatile => 's', prorettype => 'float8',
proargtypes => 'internal oid internal int2 internal',
prosrc => 'networkjoinsel' },
{ oid => '1690',
proname => 'time_mi_time', prorettype => 'interval',
proargtypes => 'time time', prosrc => 'time_mi_time' },
{ oid => '1691',
proname => 'boolle', proleakproof => 't', prorettype => 'bool',
proargtypes => 'bool bool', prosrc => 'boolle' },
{ oid => '1692',
proname => 'boolge', proleakproof => 't', prorettype => 'bool',
proargtypes => 'bool bool', prosrc => 'boolge' },
{ oid => '1693', descr => 'less-equal-greater',
Mark built-in btree comparison functions as leakproof where it's safe. Generally, if the comparison operators for a datatype or pair of datatypes are leakproof, the corresponding btree comparison support function can be considered so as well. But we had not originally worried about marking support functions as leakproof, reasoning that they'd not likely be used in queries so the marking wouldn't matter. It turns out there's at least one place where it does matter: calc_arraycontsel() finds the target datatype's default btree comparison function and tries to use that to estimate selectivity, but it will be blocked in some cases if the function isn't leakproof. This leads to unnecessarily poor selectivity estimates and bad plans, as seen in bug #15251. Hence, run around and apply proleakproof markings where the corresponding btree comparison operators are leakproof. (I did eyeball each function to verify that it wasn't doing anything surprising, too.) This isn't a full solution to bug #15251, and it's not back-patchable because of the need for a catversion bump. A more useful response probably is to consider whether we can check permissions on the parent table instead of the child. However, this change will help in some cases where that won't, and it's easy enough to do in HEAD, so let's do so. Discussion: https://postgr.es/m/3876.1531261875@sss.pgh.pa.us
2018-07-12 00:47:31 +02:00
proname => 'btboolcmp', proleakproof => 't', prorettype => 'int4',
proargtypes => 'bool bool', prosrc => 'btboolcmp' },
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
{ oid => '1688', descr => 'hash',
proname => 'time_hash', prorettype => 'int4', proargtypes => 'time',
prosrc => 'time_hash' },
{ oid => '3409', descr => 'hash',
proname => 'time_hash_extended', prorettype => 'int8',
proargtypes => 'time int8', prosrc => 'time_hash_extended' },
{ oid => '1696', descr => 'hash',
proname => 'timetz_hash', prorettype => 'int4', proargtypes => 'timetz',
prosrc => 'timetz_hash' },
{ oid => '3410', descr => 'hash',
proname => 'timetz_hash_extended', prorettype => 'int8',
proargtypes => 'timetz int8', prosrc => 'timetz_hash_extended' },
{ oid => '1697', descr => 'hash',
proname => 'interval_hash', prorettype => 'int4', proargtypes => 'interval',
prosrc => 'interval_hash' },
{ oid => '3418', descr => 'hash',
proname => 'interval_hash_extended', prorettype => 'int8',
proargtypes => 'interval int8', prosrc => 'interval_hash_extended' },
# OID's 1700 - 1799 NUMERIC data type
{ oid => '1701', descr => 'I/O',
proname => 'numeric_in', prorettype => 'numeric',
proargtypes => 'cstring oid int4', prosrc => 'numeric_in' },
{ oid => '1702', descr => 'I/O',
proname => 'numeric_out', prorettype => 'cstring', proargtypes => 'numeric',
prosrc => 'numeric_out' },
{ oid => '2917', descr => 'I/O typmod',
proname => 'numerictypmodin', prorettype => 'int4', proargtypes => '_cstring',
prosrc => 'numerictypmodin' },
{ oid => '2918', descr => 'I/O typmod',
proname => 'numerictypmodout', prorettype => 'cstring', proargtypes => 'int4',
prosrc => 'numerictypmodout' },
{ oid => '3157', descr => 'transform a numeric length coercion',
proname => 'numeric_transform', prorettype => 'internal',
proargtypes => 'internal', prosrc => 'numeric_transform' },
{ oid => '1703', descr => 'adjust numeric to typmod precision/scale',
proname => 'numeric', protransform => 'numeric_transform',
prorettype => 'numeric', proargtypes => 'numeric int4', prosrc => 'numeric' },
{ oid => '1704',
proname => 'numeric_abs', prorettype => 'numeric', proargtypes => 'numeric',
prosrc => 'numeric_abs' },
{ oid => '1705', descr => 'absolute value',
proname => 'abs', prorettype => 'numeric', proargtypes => 'numeric',
prosrc => 'numeric_abs' },
{ oid => '1706', descr => 'sign of value',
proname => 'sign', prorettype => 'numeric', proargtypes => 'numeric',
prosrc => 'numeric_sign' },
{ oid => '1707', descr => 'value rounded to \'scale\'',
proname => 'round', prorettype => 'numeric', proargtypes => 'numeric int4',
prosrc => 'numeric_round' },
{ oid => '1708', descr => 'value rounded to \'scale\' of zero',
proname => 'round', prolang => '14', prorettype => 'numeric',
proargtypes => 'numeric', prosrc => 'select pg_catalog.round($1,0)' },
{ oid => '1709', descr => 'value truncated to \'scale\'',
proname => 'trunc', prorettype => 'numeric', proargtypes => 'numeric int4',
prosrc => 'numeric_trunc' },
{ oid => '1710', descr => 'value truncated to \'scale\' of zero',
proname => 'trunc', prolang => '14', prorettype => 'numeric',
proargtypes => 'numeric', prosrc => 'select pg_catalog.trunc($1,0)' },
{ oid => '1711', descr => 'nearest integer >= value',
proname => 'ceil', prorettype => 'numeric', proargtypes => 'numeric',
prosrc => 'numeric_ceil' },
{ oid => '2167', descr => 'nearest integer >= value',
proname => 'ceiling', prorettype => 'numeric', proargtypes => 'numeric',
prosrc => 'numeric_ceil' },
{ oid => '1712', descr => 'nearest integer <= value',
proname => 'floor', prorettype => 'numeric', proargtypes => 'numeric',
prosrc => 'numeric_floor' },
{ oid => '1718',
proname => 'numeric_eq', prorettype => 'bool',
proargtypes => 'numeric numeric', prosrc => 'numeric_eq' },
{ oid => '1719',
proname => 'numeric_ne', prorettype => 'bool',
proargtypes => 'numeric numeric', prosrc => 'numeric_ne' },
{ oid => '1720',
proname => 'numeric_gt', prorettype => 'bool',
proargtypes => 'numeric numeric', prosrc => 'numeric_gt' },
{ oid => '1721',
proname => 'numeric_ge', prorettype => 'bool',
proargtypes => 'numeric numeric', prosrc => 'numeric_ge' },
{ oid => '1722',
proname => 'numeric_lt', prorettype => 'bool',
proargtypes => 'numeric numeric', prosrc => 'numeric_lt' },
{ oid => '1723',
proname => 'numeric_le', prorettype => 'bool',
proargtypes => 'numeric numeric', prosrc => 'numeric_le' },
{ oid => '1724',
proname => 'numeric_add', prorettype => 'numeric',
proargtypes => 'numeric numeric', prosrc => 'numeric_add' },
{ oid => '1725',
proname => 'numeric_sub', prorettype => 'numeric',
proargtypes => 'numeric numeric', prosrc => 'numeric_sub' },
{ oid => '1726',
proname => 'numeric_mul', prorettype => 'numeric',
proargtypes => 'numeric numeric', prosrc => 'numeric_mul' },
{ oid => '1727',
proname => 'numeric_div', prorettype => 'numeric',
proargtypes => 'numeric numeric', prosrc => 'numeric_div' },
{ oid => '1728', descr => 'modulus',
proname => 'mod', prorettype => 'numeric', proargtypes => 'numeric numeric',
prosrc => 'numeric_mod' },
{ oid => '1729',
proname => 'numeric_mod', prorettype => 'numeric',
proargtypes => 'numeric numeric', prosrc => 'numeric_mod' },
{ oid => '1730', descr => 'square root',
proname => 'sqrt', prorettype => 'numeric', proargtypes => 'numeric',
prosrc => 'numeric_sqrt' },
{ oid => '1731', descr => 'square root',
proname => 'numeric_sqrt', prorettype => 'numeric', proargtypes => 'numeric',
prosrc => 'numeric_sqrt' },
{ oid => '1732', descr => 'natural exponential (e^x)',
proname => 'exp', prorettype => 'numeric', proargtypes => 'numeric',
prosrc => 'numeric_exp' },
{ oid => '1733', descr => 'natural exponential (e^x)',
proname => 'numeric_exp', prorettype => 'numeric', proargtypes => 'numeric',
prosrc => 'numeric_exp' },
{ oid => '1734', descr => 'natural logarithm',
proname => 'ln', prorettype => 'numeric', proargtypes => 'numeric',
prosrc => 'numeric_ln' },
{ oid => '1735', descr => 'natural logarithm',
proname => 'numeric_ln', prorettype => 'numeric', proargtypes => 'numeric',
prosrc => 'numeric_ln' },
{ oid => '1736', descr => 'logarithm base m of n',
proname => 'log', prorettype => 'numeric', proargtypes => 'numeric numeric',
prosrc => 'numeric_log' },
{ oid => '1737', descr => 'logarithm base m of n',
proname => 'numeric_log', prorettype => 'numeric',
proargtypes => 'numeric numeric', prosrc => 'numeric_log' },
{ oid => '1738', descr => 'exponentiation',
proname => 'pow', prorettype => 'numeric', proargtypes => 'numeric numeric',
prosrc => 'numeric_power' },
{ oid => '2169', descr => 'exponentiation',
proname => 'power', prorettype => 'numeric', proargtypes => 'numeric numeric',
prosrc => 'numeric_power' },
{ oid => '1739',
proname => 'numeric_power', prorettype => 'numeric',
proargtypes => 'numeric numeric', prosrc => 'numeric_power' },
{ oid => '3281', descr => 'number of decimal digits in the fractional part',
proname => 'scale', prorettype => 'int4', proargtypes => 'numeric',
prosrc => 'numeric_scale' },
{ oid => '1740', descr => 'convert int4 to numeric',
proname => 'numeric', prorettype => 'numeric', proargtypes => 'int4',
prosrc => 'int4_numeric' },
{ oid => '1741', descr => 'base 10 logarithm',
proname => 'log', prolang => '14', prorettype => 'numeric',
proargtypes => 'numeric', prosrc => 'select pg_catalog.log(10, $1)' },
{ oid => '1742', descr => 'convert float4 to numeric',
proname => 'numeric', prorettype => 'numeric', proargtypes => 'float4',
prosrc => 'float4_numeric' },
{ oid => '1743', descr => 'convert float8 to numeric',
proname => 'numeric', prorettype => 'numeric', proargtypes => 'float8',
prosrc => 'float8_numeric' },
{ oid => '1744', descr => 'convert numeric to int4',
proname => 'int4', prorettype => 'int4', proargtypes => 'numeric',
prosrc => 'numeric_int4' },
{ oid => '1745', descr => 'convert numeric to float4',
proname => 'float4', prorettype => 'float4', proargtypes => 'numeric',
prosrc => 'numeric_float4' },
{ oid => '1746', descr => 'convert numeric to float8',
proname => 'float8', prorettype => 'float8', proargtypes => 'numeric',
prosrc => 'numeric_float8' },
{ oid => '1973', descr => 'trunc(x/y)',
proname => 'div', prorettype => 'numeric', proargtypes => 'numeric numeric',
prosrc => 'numeric_div_trunc' },
{ oid => '1980', descr => 'trunc(x/y)',
proname => 'numeric_div_trunc', prorettype => 'numeric',
proargtypes => 'numeric numeric', prosrc => 'numeric_div_trunc' },
{ oid => '2170', descr => 'bucket number of operand in equal-width histogram',
proname => 'width_bucket', prorettype => 'int4',
proargtypes => 'numeric numeric numeric int4',
prosrc => 'width_bucket_numeric' },
{ oid => '1747',
proname => 'time_pl_interval', prorettype => 'time',
proargtypes => 'time interval', prosrc => 'time_pl_interval' },
{ oid => '1748',
proname => 'time_mi_interval', prorettype => 'time',
proargtypes => 'time interval', prosrc => 'time_mi_interval' },
{ oid => '1749',
proname => 'timetz_pl_interval', prorettype => 'timetz',
proargtypes => 'timetz interval', prosrc => 'timetz_pl_interval' },
{ oid => '1750',
proname => 'timetz_mi_interval', prorettype => 'timetz',
proargtypes => 'timetz interval', prosrc => 'timetz_mi_interval' },
{ oid => '1764', descr => 'increment by one',
proname => 'numeric_inc', prorettype => 'numeric', proargtypes => 'numeric',
prosrc => 'numeric_inc' },
{ oid => '1766', descr => 'smaller of two',
proname => 'numeric_smaller', prorettype => 'numeric',
proargtypes => 'numeric numeric', prosrc => 'numeric_smaller' },
{ oid => '1767', descr => 'larger of two',
proname => 'numeric_larger', prorettype => 'numeric',
proargtypes => 'numeric numeric', prosrc => 'numeric_larger' },
{ oid => '1769', descr => 'less-equal-greater',
proname => 'numeric_cmp', prorettype => 'int4',
proargtypes => 'numeric numeric', prosrc => 'numeric_cmp' },
{ oid => '3283', descr => 'sort support',
proname => 'numeric_sortsupport', prorettype => 'void',
proargtypes => 'internal', prosrc => 'numeric_sortsupport' },
{ oid => '1771',
proname => 'numeric_uminus', prorettype => 'numeric',
proargtypes => 'numeric', prosrc => 'numeric_uminus' },
{ oid => '1779', descr => 'convert numeric to int8',
proname => 'int8', prorettype => 'int8', proargtypes => 'numeric',
prosrc => 'numeric_int8' },
{ oid => '1781', descr => 'convert int8 to numeric',
proname => 'numeric', prorettype => 'numeric', proargtypes => 'int8',
prosrc => 'int8_numeric' },
{ oid => '1782', descr => 'convert int2 to numeric',
proname => 'numeric', prorettype => 'numeric', proargtypes => 'int2',
prosrc => 'int2_numeric' },
{ oid => '1783', descr => 'convert numeric to int2',
proname => 'int2', prorettype => 'int2', proargtypes => 'numeric',
prosrc => 'numeric_int2' },
{ oid => '3556', descr => 'convert jsonb to boolean',
proname => 'bool', prorettype => 'bool', proargtypes => 'jsonb',
prosrc => 'jsonb_bool' },
{ oid => '3449', descr => 'convert jsonb to numeric',
proname => 'numeric', prorettype => 'numeric', proargtypes => 'jsonb',
prosrc => 'jsonb_numeric' },
{ oid => '3450', descr => 'convert jsonb to int2',
proname => 'int2', prorettype => 'int2', proargtypes => 'jsonb',
prosrc => 'jsonb_int2' },
{ oid => '3451', descr => 'convert jsonb to int4',
proname => 'int4', prorettype => 'int4', proargtypes => 'jsonb',
prosrc => 'jsonb_int4' },
{ oid => '3452', descr => 'convert jsonb to int8',
proname => 'int8', prorettype => 'int8', proargtypes => 'jsonb',
prosrc => 'jsonb_int8' },
{ oid => '3453', descr => 'convert jsonb to float4',
proname => 'float4', prorettype => 'float4', proargtypes => 'jsonb',
prosrc => 'jsonb_float4' },
{ oid => '2580', descr => 'convert jsonb to float8',
proname => 'float8', prorettype => 'float8', proargtypes => 'jsonb',
prosrc => 'jsonb_float8' },
# formatting
{ oid => '1770', descr => 'format timestamp with time zone to text',
proname => 'to_char', provolatile => 's', prorettype => 'text',
proargtypes => 'timestamptz text', prosrc => 'timestamptz_to_char' },
{ oid => '1772', descr => 'format numeric to text',
proname => 'to_char', provolatile => 's', prorettype => 'text',
proargtypes => 'numeric text', prosrc => 'numeric_to_char' },
{ oid => '1773', descr => 'format int4 to text',
proname => 'to_char', provolatile => 's', prorettype => 'text',
proargtypes => 'int4 text', prosrc => 'int4_to_char' },
{ oid => '1774', descr => 'format int8 to text',
proname => 'to_char', provolatile => 's', prorettype => 'text',
proargtypes => 'int8 text', prosrc => 'int8_to_char' },
{ oid => '1775', descr => 'format float4 to text',
proname => 'to_char', provolatile => 's', prorettype => 'text',
proargtypes => 'float4 text', prosrc => 'float4_to_char' },
{ oid => '1776', descr => 'format float8 to text',
proname => 'to_char', provolatile => 's', prorettype => 'text',
proargtypes => 'float8 text', prosrc => 'float8_to_char' },
{ oid => '1777', descr => 'convert text to numeric',
proname => 'to_number', provolatile => 's', prorettype => 'numeric',
proargtypes => 'text text', prosrc => 'numeric_to_number' },
{ oid => '1778', descr => 'convert text to timestamp with time zone',
proname => 'to_timestamp', provolatile => 's', prorettype => 'timestamptz',
proargtypes => 'text text', prosrc => 'to_timestamp' },
{ oid => '1780', descr => 'convert text to date',
proname => 'to_date', provolatile => 's', prorettype => 'date',
proargtypes => 'text text', prosrc => 'to_date' },
{ oid => '1768', descr => 'format interval to text',
proname => 'to_char', provolatile => 's', prorettype => 'text',
proargtypes => 'interval text', prosrc => 'interval_to_char' },
{ oid => '1282', descr => 'quote an identifier for usage in a querystring',
proname => 'quote_ident', prorettype => 'text', proargtypes => 'text',
prosrc => 'quote_ident' },
{ oid => '1283', descr => 'quote a literal for usage in a querystring',
proname => 'quote_literal', prorettype => 'text', proargtypes => 'text',
prosrc => 'quote_literal' },
{ oid => '1285', descr => 'quote a data value for usage in a querystring',
proname => 'quote_literal', prolang => '14', provolatile => 's',
prorettype => 'text', proargtypes => 'anyelement',
prosrc => 'select pg_catalog.quote_literal($1::pg_catalog.text)' },
{ oid => '1289',
descr => 'quote a possibly-null literal for usage in a querystring',
proname => 'quote_nullable', proisstrict => 'f', prorettype => 'text',
proargtypes => 'text', prosrc => 'quote_nullable' },
{ oid => '1290',
descr => 'quote a possibly-null data value for usage in a querystring',
proname => 'quote_nullable', prolang => '14', proisstrict => 'f',
provolatile => 's', prorettype => 'text', proargtypes => 'anyelement',
prosrc => 'select pg_catalog.quote_nullable($1::pg_catalog.text)' },
{ oid => '1798', descr => 'I/O',
proname => 'oidin', prorettype => 'oid', proargtypes => 'cstring',
prosrc => 'oidin' },
{ oid => '1799', descr => 'I/O',
proname => 'oidout', prorettype => 'cstring', proargtypes => 'oid',
prosrc => 'oidout' },
{ oid => '3058', descr => 'concatenate values',
proname => 'concat', provariadic => 'any', proisstrict => 'f',
provolatile => 's', prorettype => 'text', proargtypes => 'any',
proallargtypes => '{any}', proargmodes => '{v}', prosrc => 'text_concat' },
{ oid => '3059', descr => 'concatenate values with separators',
proname => 'concat_ws', provariadic => 'any', proisstrict => 'f',
provolatile => 's', prorettype => 'text', proargtypes => 'text any',
proallargtypes => '{text,any}', proargmodes => '{i,v}',
prosrc => 'text_concat_ws' },
{ oid => '3060', descr => 'extract the first n characters',
proname => 'left', prorettype => 'text', proargtypes => 'text int4',
prosrc => 'text_left' },
{ oid => '3061', descr => 'extract the last n characters',
proname => 'right', prorettype => 'text', proargtypes => 'text int4',
prosrc => 'text_right' },
{ oid => '3062', descr => 'reverse text',
proname => 'reverse', prorettype => 'text', proargtypes => 'text',
prosrc => 'text_reverse' },
{ oid => '3539', descr => 'format text message',
proname => 'format', provariadic => 'any', proisstrict => 'f',
provolatile => 's', prorettype => 'text', proargtypes => 'text any',
proallargtypes => '{text,any}', proargmodes => '{i,v}',
prosrc => 'text_format' },
{ oid => '3540', descr => 'format text message',
proname => 'format', proisstrict => 'f', provolatile => 's',
prorettype => 'text', proargtypes => 'text', prosrc => 'text_format_nv' },
{ oid => '1810', descr => 'length in bits',
proname => 'bit_length', prolang => '14', prorettype => 'int4',
proargtypes => 'bytea', prosrc => 'select pg_catalog.octet_length($1) * 8' },
{ oid => '1811', descr => 'length in bits',
proname => 'bit_length', prolang => '14', prorettype => 'int4',
proargtypes => 'text', prosrc => 'select pg_catalog.octet_length($1) * 8' },
{ oid => '1812', descr => 'length in bits',
proname => 'bit_length', prolang => '14', prorettype => 'int4',
proargtypes => 'bit', prosrc => 'select pg_catalog.length($1)' },
# Selectivity estimators for LIKE and related operators
{ oid => '1814', descr => 'restriction selectivity of ILIKE',
proname => 'iclikesel', provolatile => 's', prorettype => 'float8',
proargtypes => 'internal oid internal int4', prosrc => 'iclikesel' },
{ oid => '1815', descr => 'restriction selectivity of NOT ILIKE',
proname => 'icnlikesel', provolatile => 's', prorettype => 'float8',
proargtypes => 'internal oid internal int4', prosrc => 'icnlikesel' },
{ oid => '1816', descr => 'join selectivity of ILIKE',
proname => 'iclikejoinsel', provolatile => 's', prorettype => 'float8',
proargtypes => 'internal oid internal int2 internal',
prosrc => 'iclikejoinsel' },
{ oid => '1817', descr => 'join selectivity of NOT ILIKE',
proname => 'icnlikejoinsel', provolatile => 's', prorettype => 'float8',
proargtypes => 'internal oid internal int2 internal',
prosrc => 'icnlikejoinsel' },
{ oid => '1818', descr => 'restriction selectivity of regex match',
proname => 'regexeqsel', provolatile => 's', prorettype => 'float8',
proargtypes => 'internal oid internal int4', prosrc => 'regexeqsel' },
{ oid => '1819', descr => 'restriction selectivity of LIKE',
proname => 'likesel', provolatile => 's', prorettype => 'float8',
proargtypes => 'internal oid internal int4', prosrc => 'likesel' },
{ oid => '1820',
descr => 'restriction selectivity of case-insensitive regex match',
proname => 'icregexeqsel', provolatile => 's', prorettype => 'float8',
proargtypes => 'internal oid internal int4', prosrc => 'icregexeqsel' },
{ oid => '1821', descr => 'restriction selectivity of regex non-match',
proname => 'regexnesel', provolatile => 's', prorettype => 'float8',
proargtypes => 'internal oid internal int4', prosrc => 'regexnesel' },
{ oid => '1822', descr => 'restriction selectivity of NOT LIKE',
proname => 'nlikesel', provolatile => 's', prorettype => 'float8',
proargtypes => 'internal oid internal int4', prosrc => 'nlikesel' },
{ oid => '1823',
descr => 'restriction selectivity of case-insensitive regex non-match',
proname => 'icregexnesel', provolatile => 's', prorettype => 'float8',
proargtypes => 'internal oid internal int4', prosrc => 'icregexnesel' },
{ oid => '1824', descr => 'join selectivity of regex match',
proname => 'regexeqjoinsel', provolatile => 's', prorettype => 'float8',
proargtypes => 'internal oid internal int2 internal',
prosrc => 'regexeqjoinsel' },
{ oid => '1825', descr => 'join selectivity of LIKE',
proname => 'likejoinsel', provolatile => 's', prorettype => 'float8',
proargtypes => 'internal oid internal int2 internal',
prosrc => 'likejoinsel' },
{ oid => '1826', descr => 'join selectivity of case-insensitive regex match',
proname => 'icregexeqjoinsel', provolatile => 's', prorettype => 'float8',
proargtypes => 'internal oid internal int2 internal',
prosrc => 'icregexeqjoinsel' },
{ oid => '1827', descr => 'join selectivity of regex non-match',
proname => 'regexnejoinsel', provolatile => 's', prorettype => 'float8',
proargtypes => 'internal oid internal int2 internal',
prosrc => 'regexnejoinsel' },
{ oid => '1828', descr => 'join selectivity of NOT LIKE',
proname => 'nlikejoinsel', provolatile => 's', prorettype => 'float8',
proargtypes => 'internal oid internal int2 internal',
prosrc => 'nlikejoinsel' },
{ oid => '1829',
descr => 'join selectivity of case-insensitive regex non-match',
proname => 'icregexnejoinsel', provolatile => 's', prorettype => 'float8',
proargtypes => 'internal oid internal int2 internal',
prosrc => 'icregexnejoinsel' },
{ oid => '3437', descr => 'restriction selectivity of exact prefix',
proname => 'prefixsel', provolatile => 's', prorettype => 'float8',
proargtypes => 'internal oid internal int4', prosrc => 'prefixsel' },
{ oid => '3438', descr => 'join selectivity of exact prefix',
proname => 'prefixjoinsel', provolatile => 's', prorettype => 'float8',
proargtypes => 'internal oid internal int2 internal',
prosrc => 'prefixjoinsel' },
# Aggregate-related functions
{ oid => '1830', descr => 'aggregate final function',
proname => 'float8_avg', prorettype => 'float8', proargtypes => '_float8',
prosrc => 'float8_avg' },
{ oid => '2512', descr => 'aggregate final function',
proname => 'float8_var_pop', prorettype => 'float8', proargtypes => '_float8',
prosrc => 'float8_var_pop' },
{ oid => '1831', descr => 'aggregate final function',
proname => 'float8_var_samp', prorettype => 'float8',
proargtypes => '_float8', prosrc => 'float8_var_samp' },
{ oid => '2513', descr => 'aggregate final function',
proname => 'float8_stddev_pop', prorettype => 'float8',
proargtypes => '_float8', prosrc => 'float8_stddev_pop' },
{ oid => '1832', descr => 'aggregate final function',
proname => 'float8_stddev_samp', prorettype => 'float8',
proargtypes => '_float8', prosrc => 'float8_stddev_samp' },
{ oid => '1833', descr => 'aggregate transition function',
proname => 'numeric_accum', proisstrict => 'f', prorettype => 'internal',
proargtypes => 'internal numeric', prosrc => 'numeric_accum' },
{ oid => '3341', descr => 'aggregate combine function',
proname => 'numeric_combine', proisstrict => 'f', prorettype => 'internal',
proargtypes => 'internal internal', prosrc => 'numeric_combine' },
{ oid => '2858', descr => 'aggregate transition function',
proname => 'numeric_avg_accum', proisstrict => 'f', prorettype => 'internal',
proargtypes => 'internal numeric', prosrc => 'numeric_avg_accum' },
{ oid => '3337', descr => 'aggregate combine function',
proname => 'numeric_avg_combine', proisstrict => 'f',
prorettype => 'internal', proargtypes => 'internal internal',
prosrc => 'numeric_avg_combine' },
{ oid => '2740', descr => 'aggregate serial function',
proname => 'numeric_avg_serialize', prorettype => 'bytea',
proargtypes => 'internal', prosrc => 'numeric_avg_serialize' },
{ oid => '2741', descr => 'aggregate deserial function',
proname => 'numeric_avg_deserialize', prorettype => 'internal',
proargtypes => 'bytea internal', prosrc => 'numeric_avg_deserialize' },
{ oid => '3335', descr => 'aggregate serial function',
proname => 'numeric_serialize', prorettype => 'bytea',
proargtypes => 'internal', prosrc => 'numeric_serialize' },
{ oid => '3336', descr => 'aggregate deserial function',
proname => 'numeric_deserialize', prorettype => 'internal',
proargtypes => 'bytea internal', prosrc => 'numeric_deserialize' },
{ oid => '3548', descr => 'aggregate transition function',
proname => 'numeric_accum_inv', proisstrict => 'f', prorettype => 'internal',
proargtypes => 'internal numeric', prosrc => 'numeric_accum_inv' },
{ oid => '1834', descr => 'aggregate transition function',
proname => 'int2_accum', proisstrict => 'f', prorettype => 'internal',
proargtypes => 'internal int2', prosrc => 'int2_accum' },
{ oid => '1835', descr => 'aggregate transition function',
proname => 'int4_accum', proisstrict => 'f', prorettype => 'internal',
proargtypes => 'internal int4', prosrc => 'int4_accum' },
{ oid => '1836', descr => 'aggregate transition function',
proname => 'int8_accum', proisstrict => 'f', prorettype => 'internal',
proargtypes => 'internal int8', prosrc => 'int8_accum' },
{ oid => '3338', descr => 'aggregate combine function',
proname => 'numeric_poly_combine', proisstrict => 'f',
prorettype => 'internal', proargtypes => 'internal internal',
prosrc => 'numeric_poly_combine' },
{ oid => '3339', descr => 'aggregate serial function',
proname => 'numeric_poly_serialize', prorettype => 'bytea',
proargtypes => 'internal', prosrc => 'numeric_poly_serialize' },
{ oid => '3340', descr => 'aggregate deserial function',
proname => 'numeric_poly_deserialize', prorettype => 'internal',
proargtypes => 'bytea internal', prosrc => 'numeric_poly_deserialize' },
{ oid => '2746', descr => 'aggregate transition function',
proname => 'int8_avg_accum', proisstrict => 'f', prorettype => 'internal',
proargtypes => 'internal int8', prosrc => 'int8_avg_accum' },
{ oid => '3567', descr => 'aggregate transition function',
proname => 'int2_accum_inv', proisstrict => 'f', prorettype => 'internal',
proargtypes => 'internal int2', prosrc => 'int2_accum_inv' },
{ oid => '3568', descr => 'aggregate transition function',
proname => 'int4_accum_inv', proisstrict => 'f', prorettype => 'internal',
proargtypes => 'internal int4', prosrc => 'int4_accum_inv' },
{ oid => '3569', descr => 'aggregate transition function',
proname => 'int8_accum_inv', proisstrict => 'f', prorettype => 'internal',
proargtypes => 'internal int8', prosrc => 'int8_accum_inv' },
{ oid => '3387', descr => 'aggregate transition function',
proname => 'int8_avg_accum_inv', proisstrict => 'f', prorettype => 'internal',
proargtypes => 'internal int8', prosrc => 'int8_avg_accum_inv' },
{ oid => '2785', descr => 'aggregate combine function',
proname => 'int8_avg_combine', proisstrict => 'f', prorettype => 'internal',
proargtypes => 'internal internal', prosrc => 'int8_avg_combine' },
{ oid => '2786', descr => 'aggregate serial function',
proname => 'int8_avg_serialize', prorettype => 'bytea',
proargtypes => 'internal', prosrc => 'int8_avg_serialize' },
{ oid => '2787', descr => 'aggregate deserial function',
proname => 'int8_avg_deserialize', prorettype => 'internal',
proargtypes => 'bytea internal', prosrc => 'int8_avg_deserialize' },
{ oid => '3324', descr => 'aggregate combine function',
proname => 'int4_avg_combine', prorettype => '_int8',
proargtypes => '_int8 _int8', prosrc => 'int4_avg_combine' },
{ oid => '3178', descr => 'aggregate final function',
proname => 'numeric_sum', proisstrict => 'f', prorettype => 'numeric',
proargtypes => 'internal', prosrc => 'numeric_sum' },
{ oid => '1837', descr => 'aggregate final function',
proname => 'numeric_avg', proisstrict => 'f', prorettype => 'numeric',
proargtypes => 'internal', prosrc => 'numeric_avg' },
{ oid => '2514', descr => 'aggregate final function',
proname => 'numeric_var_pop', proisstrict => 'f', prorettype => 'numeric',
proargtypes => 'internal', prosrc => 'numeric_var_pop' },
{ oid => '1838', descr => 'aggregate final function',
proname => 'numeric_var_samp', proisstrict => 'f', prorettype => 'numeric',
proargtypes => 'internal', prosrc => 'numeric_var_samp' },
{ oid => '2596', descr => 'aggregate final function',
proname => 'numeric_stddev_pop', proisstrict => 'f', prorettype => 'numeric',
proargtypes => 'internal', prosrc => 'numeric_stddev_pop' },
{ oid => '1839', descr => 'aggregate final function',
proname => 'numeric_stddev_samp', proisstrict => 'f', prorettype => 'numeric',
proargtypes => 'internal', prosrc => 'numeric_stddev_samp' },
{ oid => '1840', descr => 'aggregate transition function',
proname => 'int2_sum', proisstrict => 'f', prorettype => 'int8',
proargtypes => 'int8 int2', prosrc => 'int2_sum' },
{ oid => '1841', descr => 'aggregate transition function',
proname => 'int4_sum', proisstrict => 'f', prorettype => 'int8',
proargtypes => 'int8 int4', prosrc => 'int4_sum' },
{ oid => '1842', descr => 'aggregate transition function',
proname => 'int8_sum', proisstrict => 'f', prorettype => 'numeric',
proargtypes => 'numeric int8', prosrc => 'int8_sum' },
{ oid => '3388', descr => 'aggregate final function',
proname => 'numeric_poly_sum', proisstrict => 'f', prorettype => 'numeric',
proargtypes => 'internal', prosrc => 'numeric_poly_sum' },
{ oid => '3389', descr => 'aggregate final function',
proname => 'numeric_poly_avg', proisstrict => 'f', prorettype => 'numeric',
proargtypes => 'internal', prosrc => 'numeric_poly_avg' },
{ oid => '3390', descr => 'aggregate final function',
proname => 'numeric_poly_var_pop', proisstrict => 'f',
prorettype => 'numeric', proargtypes => 'internal',
prosrc => 'numeric_poly_var_pop' },
{ oid => '3391', descr => 'aggregate final function',
proname => 'numeric_poly_var_samp', proisstrict => 'f',
prorettype => 'numeric', proargtypes => 'internal',
prosrc => 'numeric_poly_var_samp' },
{ oid => '3392', descr => 'aggregate final function',
proname => 'numeric_poly_stddev_pop', proisstrict => 'f',
prorettype => 'numeric', proargtypes => 'internal',
prosrc => 'numeric_poly_stddev_pop' },
{ oid => '3393', descr => 'aggregate final function',
proname => 'numeric_poly_stddev_samp', proisstrict => 'f',
prorettype => 'numeric', proargtypes => 'internal',
prosrc => 'numeric_poly_stddev_samp' },
{ oid => '1843', descr => 'aggregate transition function',
proname => 'interval_accum', prorettype => '_interval',
proargtypes => '_interval interval', prosrc => 'interval_accum' },
{ oid => '3325', descr => 'aggregate combine function',
proname => 'interval_combine', prorettype => '_interval',
proargtypes => '_interval _interval', prosrc => 'interval_combine' },
{ oid => '3549', descr => 'aggregate transition function',
proname => 'interval_accum_inv', prorettype => '_interval',
proargtypes => '_interval interval', prosrc => 'interval_accum_inv' },
{ oid => '1844', descr => 'aggregate final function',
proname => 'interval_avg', prorettype => 'interval',
proargtypes => '_interval', prosrc => 'interval_avg' },
{ oid => '1962', descr => 'aggregate transition function',
proname => 'int2_avg_accum', prorettype => '_int8',
proargtypes => '_int8 int2', prosrc => 'int2_avg_accum' },
{ oid => '1963', descr => 'aggregate transition function',
proname => 'int4_avg_accum', prorettype => '_int8',
proargtypes => '_int8 int4', prosrc => 'int4_avg_accum' },
{ oid => '3570', descr => 'aggregate transition function',
proname => 'int2_avg_accum_inv', prorettype => '_int8',
proargtypes => '_int8 int2', prosrc => 'int2_avg_accum_inv' },
{ oid => '3571', descr => 'aggregate transition function',
proname => 'int4_avg_accum_inv', prorettype => '_int8',
proargtypes => '_int8 int4', prosrc => 'int4_avg_accum_inv' },
{ oid => '1964', descr => 'aggregate final function',
proname => 'int8_avg', prorettype => 'numeric', proargtypes => '_int8',
prosrc => 'int8_avg' },
{ oid => '3572', descr => 'aggregate final function',
proname => 'int2int4_sum', prorettype => 'int8', proargtypes => '_int8',
prosrc => 'int2int4_sum' },
{ oid => '2805', descr => 'aggregate transition function',
proname => 'int8inc_float8_float8', prorettype => 'int8',
proargtypes => 'int8 float8 float8', prosrc => 'int8inc_float8_float8' },
{ oid => '2806', descr => 'aggregate transition function',
proname => 'float8_regr_accum', prorettype => '_float8',
proargtypes => '_float8 float8 float8', prosrc => 'float8_regr_accum' },
{ oid => '3342', descr => 'aggregate combine function',
proname => 'float8_regr_combine', prorettype => '_float8',
proargtypes => '_float8 _float8', prosrc => 'float8_regr_combine' },
{ oid => '2807', descr => 'aggregate final function',
proname => 'float8_regr_sxx', prorettype => 'float8',
proargtypes => '_float8', prosrc => 'float8_regr_sxx' },
{ oid => '2808', descr => 'aggregate final function',
proname => 'float8_regr_syy', prorettype => 'float8',
proargtypes => '_float8', prosrc => 'float8_regr_syy' },
{ oid => '2809', descr => 'aggregate final function',
proname => 'float8_regr_sxy', prorettype => 'float8',
proargtypes => '_float8', prosrc => 'float8_regr_sxy' },
{ oid => '2810', descr => 'aggregate final function',
proname => 'float8_regr_avgx', prorettype => 'float8',
proargtypes => '_float8', prosrc => 'float8_regr_avgx' },
{ oid => '2811', descr => 'aggregate final function',
proname => 'float8_regr_avgy', prorettype => 'float8',
proargtypes => '_float8', prosrc => 'float8_regr_avgy' },
{ oid => '2812', descr => 'aggregate final function',
proname => 'float8_regr_r2', prorettype => 'float8', proargtypes => '_float8',
prosrc => 'float8_regr_r2' },
{ oid => '2813', descr => 'aggregate final function',
proname => 'float8_regr_slope', prorettype => 'float8',
proargtypes => '_float8', prosrc => 'float8_regr_slope' },
{ oid => '2814', descr => 'aggregate final function',
proname => 'float8_regr_intercept', prorettype => 'float8',
proargtypes => '_float8', prosrc => 'float8_regr_intercept' },
{ oid => '2815', descr => 'aggregate final function',
proname => 'float8_covar_pop', prorettype => 'float8',
proargtypes => '_float8', prosrc => 'float8_covar_pop' },
{ oid => '2816', descr => 'aggregate final function',
proname => 'float8_covar_samp', prorettype => 'float8',
proargtypes => '_float8', prosrc => 'float8_covar_samp' },
{ oid => '2817', descr => 'aggregate final function',
proname => 'float8_corr', prorettype => 'float8', proargtypes => '_float8',
prosrc => 'float8_corr' },
{ oid => '3535', descr => 'aggregate transition function',
proname => 'string_agg_transfn', proisstrict => 'f', prorettype => 'internal',
proargtypes => 'internal text text', prosrc => 'string_agg_transfn' },
{ oid => '3536', descr => 'aggregate final function',
proname => 'string_agg_finalfn', proisstrict => 'f', prorettype => 'text',
proargtypes => 'internal', prosrc => 'string_agg_finalfn' },
{ oid => '3538', descr => 'concatenate aggregate input into a string',
proname => 'string_agg', prokind => 'a', proisstrict => 'f',
prorettype => 'text', proargtypes => 'text text',
prosrc => 'aggregate_dummy' },
{ oid => '3543', descr => 'aggregate transition function',
proname => 'bytea_string_agg_transfn', proisstrict => 'f',
prorettype => 'internal', proargtypes => 'internal bytea bytea',
prosrc => 'bytea_string_agg_transfn' },
{ oid => '3544', descr => 'aggregate final function',
proname => 'bytea_string_agg_finalfn', proisstrict => 'f',
prorettype => 'bytea', proargtypes => 'internal',
prosrc => 'bytea_string_agg_finalfn' },
{ oid => '3545', descr => 'concatenate aggregate input into a bytea',
proname => 'string_agg', prokind => 'a', proisstrict => 'f',
prorettype => 'bytea', proargtypes => 'bytea bytea',
prosrc => 'aggregate_dummy' },
# To ASCII conversion
{ oid => '1845', descr => 'encode text from DB encoding to ASCII text',
proname => 'to_ascii', prorettype => 'text', proargtypes => 'text',
prosrc => 'to_ascii_default' },
{ oid => '1846', descr => 'encode text from encoding to ASCII text',
proname => 'to_ascii', prorettype => 'text', proargtypes => 'text int4',
prosrc => 'to_ascii_enc' },
{ oid => '1847', descr => 'encode text from encoding to ASCII text',
proname => 'to_ascii', prorettype => 'text', proargtypes => 'text name',
prosrc => 'to_ascii_encname' },
{ oid => '1848',
proname => 'interval_pl_time', prolang => '14', prorettype => 'time',
proargtypes => 'interval time', prosrc => 'select $2 + $1' },
{ oid => '1850',
proname => 'int28eq', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int2 int8', prosrc => 'int28eq' },
{ oid => '1851',
proname => 'int28ne', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int2 int8', prosrc => 'int28ne' },
{ oid => '1852',
proname => 'int28lt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int2 int8', prosrc => 'int28lt' },
{ oid => '1853',
proname => 'int28gt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int2 int8', prosrc => 'int28gt' },
{ oid => '1854',
proname => 'int28le', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int2 int8', prosrc => 'int28le' },
{ oid => '1855',
proname => 'int28ge', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int2 int8', prosrc => 'int28ge' },
{ oid => '1856',
proname => 'int82eq', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int8 int2', prosrc => 'int82eq' },
{ oid => '1857',
proname => 'int82ne', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int8 int2', prosrc => 'int82ne' },
{ oid => '1858',
proname => 'int82lt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int8 int2', prosrc => 'int82lt' },
{ oid => '1859',
proname => 'int82gt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int8 int2', prosrc => 'int82gt' },
{ oid => '1860',
proname => 'int82le', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int8 int2', prosrc => 'int82le' },
{ oid => '1861',
proname => 'int82ge', proleakproof => 't', prorettype => 'bool',
proargtypes => 'int8 int2', prosrc => 'int82ge' },
{ oid => '1892',
proname => 'int2and', prorettype => 'int2', proargtypes => 'int2 int2',
prosrc => 'int2and' },
{ oid => '1893',
proname => 'int2or', prorettype => 'int2', proargtypes => 'int2 int2',
prosrc => 'int2or' },
{ oid => '1894',
proname => 'int2xor', prorettype => 'int2', proargtypes => 'int2 int2',
prosrc => 'int2xor' },
{ oid => '1895',
proname => 'int2not', prorettype => 'int2', proargtypes => 'int2',
prosrc => 'int2not' },
{ oid => '1896',
proname => 'int2shl', prorettype => 'int2', proargtypes => 'int2 int4',
prosrc => 'int2shl' },
{ oid => '1897',
proname => 'int2shr', prorettype => 'int2', proargtypes => 'int2 int4',
prosrc => 'int2shr' },
{ oid => '1898',
proname => 'int4and', prorettype => 'int4', proargtypes => 'int4 int4',
prosrc => 'int4and' },
{ oid => '1899',
proname => 'int4or', prorettype => 'int4', proargtypes => 'int4 int4',
prosrc => 'int4or' },
{ oid => '1900',
proname => 'int4xor', prorettype => 'int4', proargtypes => 'int4 int4',
prosrc => 'int4xor' },
{ oid => '1901',
proname => 'int4not', prorettype => 'int4', proargtypes => 'int4',
prosrc => 'int4not' },
{ oid => '1902',
proname => 'int4shl', prorettype => 'int4', proargtypes => 'int4 int4',
prosrc => 'int4shl' },
{ oid => '1903',
proname => 'int4shr', prorettype => 'int4', proargtypes => 'int4 int4',
prosrc => 'int4shr' },
{ oid => '1904',
proname => 'int8and', prorettype => 'int8', proargtypes => 'int8 int8',
prosrc => 'int8and' },
{ oid => '1905',
proname => 'int8or', prorettype => 'int8', proargtypes => 'int8 int8',
prosrc => 'int8or' },
{ oid => '1906',
proname => 'int8xor', prorettype => 'int8', proargtypes => 'int8 int8',
prosrc => 'int8xor' },
{ oid => '1907',
proname => 'int8not', prorettype => 'int8', proargtypes => 'int8',
prosrc => 'int8not' },
{ oid => '1908',
proname => 'int8shl', prorettype => 'int8', proargtypes => 'int8 int4',
prosrc => 'int8shl' },
{ oid => '1909',
proname => 'int8shr', prorettype => 'int8', proargtypes => 'int8 int4',
prosrc => 'int8shr' },
{ oid => '1910',
proname => 'int8up', prorettype => 'int8', proargtypes => 'int8',
prosrc => 'int8up' },
{ oid => '1911',
proname => 'int2up', prorettype => 'int2', proargtypes => 'int2',
prosrc => 'int2up' },
{ oid => '1912',
proname => 'int4up', prorettype => 'int4', proargtypes => 'int4',
prosrc => 'int4up' },
{ oid => '1913',
proname => 'float4up', prorettype => 'float4', proargtypes => 'float4',
prosrc => 'float4up' },
{ oid => '1914',
proname => 'float8up', prorettype => 'float8', proargtypes => 'float8',
prosrc => 'float8up' },
{ oid => '1915',
proname => 'numeric_uplus', prorettype => 'numeric', proargtypes => 'numeric',
prosrc => 'numeric_uplus' },
{ oid => '1922', descr => 'user privilege on relation by username, rel name',
proname => 'has_table_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'name text text', prosrc => 'has_table_privilege_name_name' },
{ oid => '1923', descr => 'user privilege on relation by username, rel oid',
proname => 'has_table_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'name oid text', prosrc => 'has_table_privilege_name_id' },
{ oid => '1924', descr => 'user privilege on relation by user oid, rel name',
proname => 'has_table_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'oid text text', prosrc => 'has_table_privilege_id_name' },
{ oid => '1925', descr => 'user privilege on relation by user oid, rel oid',
proname => 'has_table_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'oid oid text', prosrc => 'has_table_privilege_id_id' },
{ oid => '1926', descr => 'current user privilege on relation by rel name',
proname => 'has_table_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'text text', prosrc => 'has_table_privilege_name' },
{ oid => '1927', descr => 'current user privilege on relation by rel oid',
proname => 'has_table_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'oid text', prosrc => 'has_table_privilege_id' },
{ oid => '2181', descr => 'user privilege on sequence by username, seq name',
proname => 'has_sequence_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'name text text',
prosrc => 'has_sequence_privilege_name_name' },
{ oid => '2182', descr => 'user privilege on sequence by username, seq oid',
proname => 'has_sequence_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'name oid text', prosrc => 'has_sequence_privilege_name_id' },
{ oid => '2183', descr => 'user privilege on sequence by user oid, seq name',
proname => 'has_sequence_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'oid text text', prosrc => 'has_sequence_privilege_id_name' },
{ oid => '2184', descr => 'user privilege on sequence by user oid, seq oid',
proname => 'has_sequence_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'oid oid text', prosrc => 'has_sequence_privilege_id_id' },
{ oid => '2185', descr => 'current user privilege on sequence by seq name',
proname => 'has_sequence_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'text text', prosrc => 'has_sequence_privilege_name' },
{ oid => '2186', descr => 'current user privilege on sequence by seq oid',
proname => 'has_sequence_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'oid text', prosrc => 'has_sequence_privilege_id' },
{ oid => '3012',
descr => 'user privilege on column by username, rel name, col name',
proname => 'has_column_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'name text text text',
prosrc => 'has_column_privilege_name_name_name' },
{ oid => '3013',
descr => 'user privilege on column by username, rel name, col attnum',
proname => 'has_column_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'name text int2 text',
prosrc => 'has_column_privilege_name_name_attnum' },
{ oid => '3014',
descr => 'user privilege on column by username, rel oid, col name',
proname => 'has_column_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'name oid text text',
prosrc => 'has_column_privilege_name_id_name' },
{ oid => '3015',
descr => 'user privilege on column by username, rel oid, col attnum',
proname => 'has_column_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'name oid int2 text',
prosrc => 'has_column_privilege_name_id_attnum' },
{ oid => '3016',
descr => 'user privilege on column by user oid, rel name, col name',
proname => 'has_column_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'oid text text text',
prosrc => 'has_column_privilege_id_name_name' },
{ oid => '3017',
descr => 'user privilege on column by user oid, rel name, col attnum',
proname => 'has_column_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'oid text int2 text',
prosrc => 'has_column_privilege_id_name_attnum' },
{ oid => '3018',
descr => 'user privilege on column by user oid, rel oid, col name',
proname => 'has_column_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'oid oid text text',
prosrc => 'has_column_privilege_id_id_name' },
{ oid => '3019',
descr => 'user privilege on column by user oid, rel oid, col attnum',
proname => 'has_column_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'oid oid int2 text',
prosrc => 'has_column_privilege_id_id_attnum' },
{ oid => '3020',
descr => 'current user privilege on column by rel name, col name',
proname => 'has_column_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'text text text', prosrc => 'has_column_privilege_name_name' },
{ oid => '3021',
descr => 'current user privilege on column by rel name, col attnum',
proname => 'has_column_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'text int2 text',
prosrc => 'has_column_privilege_name_attnum' },
{ oid => '3022',
descr => 'current user privilege on column by rel oid, col name',
proname => 'has_column_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'oid text text', prosrc => 'has_column_privilege_id_name' },
{ oid => '3023',
descr => 'current user privilege on column by rel oid, col attnum',
proname => 'has_column_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'oid int2 text', prosrc => 'has_column_privilege_id_attnum' },
{ oid => '3024',
descr => 'user privilege on any column by username, rel name',
proname => 'has_any_column_privilege', procost => '10', provolatile => 's',
prorettype => 'bool', proargtypes => 'name text text',
prosrc => 'has_any_column_privilege_name_name' },
{ oid => '3025', descr => 'user privilege on any column by username, rel oid',
proname => 'has_any_column_privilege', procost => '10', provolatile => 's',
prorettype => 'bool', proargtypes => 'name oid text',
prosrc => 'has_any_column_privilege_name_id' },
{ oid => '3026',
descr => 'user privilege on any column by user oid, rel name',
proname => 'has_any_column_privilege', procost => '10', provolatile => 's',
prorettype => 'bool', proargtypes => 'oid text text',
prosrc => 'has_any_column_privilege_id_name' },
{ oid => '3027', descr => 'user privilege on any column by user oid, rel oid',
proname => 'has_any_column_privilege', procost => '10', provolatile => 's',
prorettype => 'bool', proargtypes => 'oid oid text',
prosrc => 'has_any_column_privilege_id_id' },
{ oid => '3028', descr => 'current user privilege on any column by rel name',
proname => 'has_any_column_privilege', procost => '10', provolatile => 's',
prorettype => 'bool', proargtypes => 'text text',
prosrc => 'has_any_column_privilege_name' },
{ oid => '3029', descr => 'current user privilege on any column by rel oid',
proname => 'has_any_column_privilege', procost => '10', provolatile => 's',
prorettype => 'bool', proargtypes => 'oid text',
prosrc => 'has_any_column_privilege_id' },
{ oid => '3355', descr => 'I/O',
proname => 'pg_ndistinct_in', prorettype => 'pg_ndistinct',
proargtypes => 'cstring', prosrc => 'pg_ndistinct_in' },
{ oid => '3356', descr => 'I/O',
proname => 'pg_ndistinct_out', prorettype => 'cstring',
proargtypes => 'pg_ndistinct', prosrc => 'pg_ndistinct_out' },
{ oid => '3357', descr => 'I/O',
proname => 'pg_ndistinct_recv', provolatile => 's',
prorettype => 'pg_ndistinct', proargtypes => 'internal',
prosrc => 'pg_ndistinct_recv' },
{ oid => '3358', descr => 'I/O',
proname => 'pg_ndistinct_send', provolatile => 's', prorettype => 'bytea',
proargtypes => 'pg_ndistinct', prosrc => 'pg_ndistinct_send' },
{ oid => '3404', descr => 'I/O',
proname => 'pg_dependencies_in', prorettype => 'pg_dependencies',
proargtypes => 'cstring', prosrc => 'pg_dependencies_in' },
{ oid => '3405', descr => 'I/O',
proname => 'pg_dependencies_out', prorettype => 'cstring',
proargtypes => 'pg_dependencies', prosrc => 'pg_dependencies_out' },
{ oid => '3406', descr => 'I/O',
proname => 'pg_dependencies_recv', provolatile => 's',
prorettype => 'pg_dependencies', proargtypes => 'internal',
prosrc => 'pg_dependencies_recv' },
{ oid => '3407', descr => 'I/O',
proname => 'pg_dependencies_send', provolatile => 's', prorettype => 'bytea',
proargtypes => 'pg_dependencies', prosrc => 'pg_dependencies_send' },
{ oid => '1928', descr => 'statistics: number of scans done for table/index',
proname => 'pg_stat_get_numscans', provolatile => 's', proparallel => 'r',
prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_numscans' },
{ oid => '1929', descr => 'statistics: number of tuples read by seqscan',
proname => 'pg_stat_get_tuples_returned', provolatile => 's',
proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_tuples_returned' },
{ oid => '1930', descr => 'statistics: number of tuples fetched by idxscan',
proname => 'pg_stat_get_tuples_fetched', provolatile => 's',
proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_tuples_fetched' },
{ oid => '1931', descr => 'statistics: number of tuples inserted',
proname => 'pg_stat_get_tuples_inserted', provolatile => 's',
proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_tuples_inserted' },
{ oid => '1932', descr => 'statistics: number of tuples updated',
proname => 'pg_stat_get_tuples_updated', provolatile => 's',
proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_tuples_updated' },
{ oid => '1933', descr => 'statistics: number of tuples deleted',
proname => 'pg_stat_get_tuples_deleted', provolatile => 's',
proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_tuples_deleted' },
{ oid => '1972', descr => 'statistics: number of tuples hot updated',
proname => 'pg_stat_get_tuples_hot_updated', provolatile => 's',
proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_tuples_hot_updated' },
{ oid => '2878', descr => 'statistics: number of live tuples',
proname => 'pg_stat_get_live_tuples', provolatile => 's', proparallel => 'r',
prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_live_tuples' },
{ oid => '2879', descr => 'statistics: number of dead tuples',
proname => 'pg_stat_get_dead_tuples', provolatile => 's', proparallel => 'r',
prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_dead_tuples' },
{ oid => '3177',
descr => 'statistics: number of tuples changed since last analyze',
proname => 'pg_stat_get_mod_since_analyze', provolatile => 's',
proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_mod_since_analyze' },
{ oid => '1934', descr => 'statistics: number of blocks fetched',
proname => 'pg_stat_get_blocks_fetched', provolatile => 's',
proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_blocks_fetched' },
{ oid => '1935', descr => 'statistics: number of blocks found in cache',
proname => 'pg_stat_get_blocks_hit', provolatile => 's', proparallel => 'r',
prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_blocks_hit' },
{ oid => '2781', descr => 'statistics: last manual vacuum time for a table',
proname => 'pg_stat_get_last_vacuum_time', provolatile => 's',
proparallel => 'r', prorettype => 'timestamptz', proargtypes => 'oid',
prosrc => 'pg_stat_get_last_vacuum_time' },
{ oid => '2782', descr => 'statistics: last auto vacuum time for a table',
proname => 'pg_stat_get_last_autovacuum_time', provolatile => 's',
proparallel => 'r', prorettype => 'timestamptz', proargtypes => 'oid',
prosrc => 'pg_stat_get_last_autovacuum_time' },
{ oid => '2783', descr => 'statistics: last manual analyze time for a table',
proname => 'pg_stat_get_last_analyze_time', provolatile => 's',
proparallel => 'r', prorettype => 'timestamptz', proargtypes => 'oid',
prosrc => 'pg_stat_get_last_analyze_time' },
{ oid => '2784', descr => 'statistics: last auto analyze time for a table',
proname => 'pg_stat_get_last_autoanalyze_time', provolatile => 's',
proparallel => 'r', prorettype => 'timestamptz', proargtypes => 'oid',
prosrc => 'pg_stat_get_last_autoanalyze_time' },
{ oid => '3054', descr => 'statistics: number of manual vacuums for a table',
proname => 'pg_stat_get_vacuum_count', provolatile => 's', proparallel => 'r',
prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_vacuum_count' },
{ oid => '3055', descr => 'statistics: number of auto vacuums for a table',
proname => 'pg_stat_get_autovacuum_count', provolatile => 's',
proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_autovacuum_count' },
{ oid => '3056', descr => 'statistics: number of manual analyzes for a table',
proname => 'pg_stat_get_analyze_count', provolatile => 's',
proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_analyze_count' },
{ oid => '3057', descr => 'statistics: number of auto analyzes for a table',
proname => 'pg_stat_get_autoanalyze_count', provolatile => 's',
proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_autoanalyze_count' },
{ oid => '1936', descr => 'statistics: currently active backend IDs',
proname => 'pg_stat_get_backend_idset', prorows => '100', proretset => 't',
provolatile => 's', proparallel => 'r', prorettype => 'int4',
proargtypes => '', prosrc => 'pg_stat_get_backend_idset' },
{ oid => '2022',
descr => 'statistics: information about currently active backends',
proname => 'pg_stat_get_activity', prorows => '100', proisstrict => 'f',
proretset => 't', provolatile => 's', proparallel => 'r',
prorettype => 'record', proargtypes => 'int4',
proallargtypes => '{int4,oid,int4,oid,text,text,text,text,text,timestamptz,timestamptz,timestamptz,timestamptz,inet,text,int4,xid,xid,text,bool,text,text,int4,bool,text}',
proargmodes => '{i,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o}',
proargnames => '{pid,datid,pid,usesysid,application_name,state,query,wait_event_type,wait_event,xact_start,query_start,backend_start,state_change,client_addr,client_hostname,client_port,backend_xid,backend_xmin,backend_type,ssl,sslversion,sslcipher,sslbits,sslcompression,sslclientdn}',
prosrc => 'pg_stat_get_activity' },
{ oid => '3318',
descr => 'statistics: information about progress of backends running maintenance command',
proname => 'pg_stat_get_progress_info', prorows => '100', proretset => 't',
provolatile => 's', proparallel => 'r', prorettype => 'record',
proargtypes => 'text',
proallargtypes => '{text,int4,oid,oid,int8,int8,int8,int8,int8,int8,int8,int8,int8,int8}',
proargmodes => '{i,o,o,o,o,o,o,o,o,o,o,o,o,o}',
proargnames => '{cmdtype,pid,datid,relid,param1,param2,param3,param4,param5,param6,param7,param8,param9,param10}',
prosrc => 'pg_stat_get_progress_info' },
{ oid => '3099',
descr => 'statistics: information about currently active replication',
proname => 'pg_stat_get_wal_senders', prorows => '10', proisstrict => 'f',
proretset => 't', provolatile => 's', proparallel => 'r',
prorettype => 'record', proargtypes => '',
Add timestamp of last received message from standby to pg_stat_replication The timestamp generated by the standby at message transmission has been included in the protocol since its introduction for both the status update message and hot standby feedback message, but it has never appeared in pg_stat_replication. Seeing this timestamp does not matter much with a cluster which has a lot of activity, but on a mostly-idle cluster, this makes monitoring able to react faster than the configured timeouts. Author: MyungKyu LIM Reviewed-by: Michael Paquier, Masahiko Sawada Discussion: https://postgr.es/m/1657809367.407321.1533027417725.JavaMail.jboss@ep2ml404
2018-12-09 08:35:06 +01:00
proallargtypes => '{int4,text,pg_lsn,pg_lsn,pg_lsn,pg_lsn,interval,interval,interval,int4,text,timestamptz}',
proargmodes => '{o,o,o,o,o,o,o,o,o,o,o,o}',
proargnames => '{pid,state,sent_lsn,write_lsn,flush_lsn,replay_lsn,write_lag,flush_lag,replay_lag,sync_priority,sync_state,reply_time}',
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
prosrc => 'pg_stat_get_wal_senders' },
{ oid => '3317', descr => 'statistics: information about WAL receiver',
proname => 'pg_stat_get_wal_receiver', proisstrict => 'f', provolatile => 's',
proparallel => 'r', prorettype => 'record', proargtypes => '',
proallargtypes => '{int4,text,pg_lsn,int4,pg_lsn,int4,timestamptz,timestamptz,pg_lsn,timestamptz,text,text,int4,text}',
proargmodes => '{o,o,o,o,o,o,o,o,o,o,o,o,o,o}',
proargnames => '{pid,status,receive_start_lsn,receive_start_tli,received_lsn,received_tli,last_msg_send_time,last_msg_receipt_time,latest_end_lsn,latest_end_time,slot_name,sender_host,sender_port,conninfo}',
prosrc => 'pg_stat_get_wal_receiver' },
{ oid => '6118', descr => 'statistics: information about subscription',
proname => 'pg_stat_get_subscription', proisstrict => 'f', provolatile => 's',
proparallel => 'r', prorettype => 'record', proargtypes => 'oid',
proallargtypes => '{oid,oid,oid,int4,pg_lsn,timestamptz,timestamptz,pg_lsn,timestamptz}',
proargmodes => '{i,o,o,o,o,o,o,o,o}',
proargnames => '{subid,subid,relid,pid,received_lsn,last_msg_send_time,last_msg_receipt_time,latest_end_lsn,latest_end_time}',
prosrc => 'pg_stat_get_subscription' },
{ oid => '2026', descr => 'statistics: current backend PID',
proname => 'pg_backend_pid', provolatile => 's', proparallel => 'r',
prorettype => 'int4', proargtypes => '', prosrc => 'pg_backend_pid' },
{ oid => '1937', descr => 'statistics: PID of backend',
proname => 'pg_stat_get_backend_pid', provolatile => 's', proparallel => 'r',
prorettype => 'int4', proargtypes => 'int4',
prosrc => 'pg_stat_get_backend_pid' },
{ oid => '1938', descr => 'statistics: database ID of backend',
proname => 'pg_stat_get_backend_dbid', provolatile => 's', proparallel => 'r',
prorettype => 'oid', proargtypes => 'int4',
prosrc => 'pg_stat_get_backend_dbid' },
{ oid => '1939', descr => 'statistics: user ID of backend',
proname => 'pg_stat_get_backend_userid', provolatile => 's',
proparallel => 'r', prorettype => 'oid', proargtypes => 'int4',
prosrc => 'pg_stat_get_backend_userid' },
{ oid => '1940', descr => 'statistics: current query of backend',
proname => 'pg_stat_get_backend_activity', provolatile => 's',
proparallel => 'r', prorettype => 'text', proargtypes => 'int4',
prosrc => 'pg_stat_get_backend_activity' },
{ oid => '2788',
descr => 'statistics: wait event type on which backend is currently waiting',
proname => 'pg_stat_get_backend_wait_event_type', provolatile => 's',
proparallel => 'r', prorettype => 'text', proargtypes => 'int4',
prosrc => 'pg_stat_get_backend_wait_event_type' },
{ oid => '2853',
descr => 'statistics: wait event on which backend is currently waiting',
proname => 'pg_stat_get_backend_wait_event', provolatile => 's',
proparallel => 'r', prorettype => 'text', proargtypes => 'int4',
prosrc => 'pg_stat_get_backend_wait_event' },
{ oid => '2094',
descr => 'statistics: start time for current query of backend',
proname => 'pg_stat_get_backend_activity_start', provolatile => 's',
proparallel => 'r', prorettype => 'timestamptz', proargtypes => 'int4',
prosrc => 'pg_stat_get_backend_activity_start' },
{ oid => '2857',
descr => 'statistics: start time for backend\'s current transaction',
proname => 'pg_stat_get_backend_xact_start', provolatile => 's',
proparallel => 'r', prorettype => 'timestamptz', proargtypes => 'int4',
prosrc => 'pg_stat_get_backend_xact_start' },
{ oid => '1391',
descr => 'statistics: start time for current backend session',
proname => 'pg_stat_get_backend_start', provolatile => 's',
proparallel => 'r', prorettype => 'timestamptz', proargtypes => 'int4',
prosrc => 'pg_stat_get_backend_start' },
{ oid => '1392',
descr => 'statistics: address of client connected to backend',
proname => 'pg_stat_get_backend_client_addr', provolatile => 's',
proparallel => 'r', prorettype => 'inet', proargtypes => 'int4',
prosrc => 'pg_stat_get_backend_client_addr' },
{ oid => '1393',
descr => 'statistics: port number of client connected to backend',
proname => 'pg_stat_get_backend_client_port', provolatile => 's',
proparallel => 'r', prorettype => 'int4', proargtypes => 'int4',
prosrc => 'pg_stat_get_backend_client_port' },
{ oid => '1941', descr => 'statistics: number of backends in database',
proname => 'pg_stat_get_db_numbackends', provolatile => 's',
proparallel => 'r', prorettype => 'int4', proargtypes => 'oid',
prosrc => 'pg_stat_get_db_numbackends' },
{ oid => '1942', descr => 'statistics: transactions committed',
proname => 'pg_stat_get_db_xact_commit', provolatile => 's',
proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_db_xact_commit' },
{ oid => '1943', descr => 'statistics: transactions rolled back',
proname => 'pg_stat_get_db_xact_rollback', provolatile => 's',
proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_db_xact_rollback' },
{ oid => '1944', descr => 'statistics: blocks fetched for database',
proname => 'pg_stat_get_db_blocks_fetched', provolatile => 's',
proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_db_blocks_fetched' },
{ oid => '1945', descr => 'statistics: blocks found in cache for database',
proname => 'pg_stat_get_db_blocks_hit', provolatile => 's',
proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_db_blocks_hit' },
{ oid => '2758', descr => 'statistics: tuples returned for database',
proname => 'pg_stat_get_db_tuples_returned', provolatile => 's',
proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_db_tuples_returned' },
{ oid => '2759', descr => 'statistics: tuples fetched for database',
proname => 'pg_stat_get_db_tuples_fetched', provolatile => 's',
proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_db_tuples_fetched' },
{ oid => '2760', descr => 'statistics: tuples inserted in database',
proname => 'pg_stat_get_db_tuples_inserted', provolatile => 's',
proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_db_tuples_inserted' },
{ oid => '2761', descr => 'statistics: tuples updated in database',
proname => 'pg_stat_get_db_tuples_updated', provolatile => 's',
proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_db_tuples_updated' },
{ oid => '2762', descr => 'statistics: tuples deleted in database',
proname => 'pg_stat_get_db_tuples_deleted', provolatile => 's',
proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_db_tuples_deleted' },
{ oid => '3065',
descr => 'statistics: recovery conflicts in database caused by drop tablespace',
proname => 'pg_stat_get_db_conflict_tablespace', provolatile => 's',
proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_db_conflict_tablespace' },
{ oid => '3066',
descr => 'statistics: recovery conflicts in database caused by relation lock',
proname => 'pg_stat_get_db_conflict_lock', provolatile => 's',
proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_db_conflict_lock' },
{ oid => '3067',
descr => 'statistics: recovery conflicts in database caused by snapshot expiry',
proname => 'pg_stat_get_db_conflict_snapshot', provolatile => 's',
proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_db_conflict_snapshot' },
{ oid => '3068',
descr => 'statistics: recovery conflicts in database caused by shared buffer pin',
proname => 'pg_stat_get_db_conflict_bufferpin', provolatile => 's',
proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_db_conflict_bufferpin' },
{ oid => '3069',
descr => 'statistics: recovery conflicts in database caused by buffer deadlock',
proname => 'pg_stat_get_db_conflict_startup_deadlock', provolatile => 's',
proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_db_conflict_startup_deadlock' },
{ oid => '3070', descr => 'statistics: recovery conflicts in database',
proname => 'pg_stat_get_db_conflict_all', provolatile => 's',
proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_db_conflict_all' },
{ oid => '3152', descr => 'statistics: deadlocks detected in database',
proname => 'pg_stat_get_db_deadlocks', provolatile => 's', proparallel => 'r',
prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_db_deadlocks' },
{ oid => '3074', descr => 'statistics: last reset for a database',
proname => 'pg_stat_get_db_stat_reset_time', provolatile => 's',
proparallel => 'r', prorettype => 'timestamptz', proargtypes => 'oid',
prosrc => 'pg_stat_get_db_stat_reset_time' },
{ oid => '3150', descr => 'statistics: number of temporary files written',
proname => 'pg_stat_get_db_temp_files', provolatile => 's',
proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_db_temp_files' },
{ oid => '3151',
descr => 'statistics: number of bytes in temporary files written',
proname => 'pg_stat_get_db_temp_bytes', provolatile => 's',
proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_db_temp_bytes' },
{ oid => '2844', descr => 'statistics: block read time, in milliseconds',
proname => 'pg_stat_get_db_blk_read_time', provolatile => 's',
proparallel => 'r', prorettype => 'float8', proargtypes => 'oid',
prosrc => 'pg_stat_get_db_blk_read_time' },
{ oid => '2845', descr => 'statistics: block write time, in milliseconds',
proname => 'pg_stat_get_db_blk_write_time', provolatile => 's',
proparallel => 'r', prorettype => 'float8', proargtypes => 'oid',
prosrc => 'pg_stat_get_db_blk_write_time' },
{ oid => '3195', descr => 'statistics: information about WAL archiver',
proname => 'pg_stat_get_archiver', proisstrict => 'f', provolatile => 's',
proparallel => 'r', prorettype => 'record', proargtypes => '',
proallargtypes => '{int8,text,timestamptz,int8,text,timestamptz,timestamptz}',
proargmodes => '{o,o,o,o,o,o,o}',
proargnames => '{archived_count,last_archived_wal,last_archived_time,failed_count,last_failed_wal,last_failed_time,stats_reset}',
prosrc => 'pg_stat_get_archiver' },
{ oid => '2769',
descr => 'statistics: number of timed checkpoints started by the bgwriter',
proname => 'pg_stat_get_bgwriter_timed_checkpoints', provolatile => 's',
proparallel => 'r', prorettype => 'int8', proargtypes => '',
prosrc => 'pg_stat_get_bgwriter_timed_checkpoints' },
{ oid => '2770',
descr => 'statistics: number of backend requested checkpoints started by the bgwriter',
proname => 'pg_stat_get_bgwriter_requested_checkpoints', provolatile => 's',
proparallel => 'r', prorettype => 'int8', proargtypes => '',
prosrc => 'pg_stat_get_bgwriter_requested_checkpoints' },
{ oid => '2771',
descr => 'statistics: number of buffers written by the bgwriter during checkpoints',
proname => 'pg_stat_get_bgwriter_buf_written_checkpoints', provolatile => 's',
proparallel => 'r', prorettype => 'int8', proargtypes => '',
prosrc => 'pg_stat_get_bgwriter_buf_written_checkpoints' },
{ oid => '2772',
descr => 'statistics: number of buffers written by the bgwriter for cleaning dirty buffers',
proname => 'pg_stat_get_bgwriter_buf_written_clean', provolatile => 's',
proparallel => 'r', prorettype => 'int8', proargtypes => '',
prosrc => 'pg_stat_get_bgwriter_buf_written_clean' },
{ oid => '2773',
descr => 'statistics: number of times the bgwriter stopped processing when it had written too many buffers while cleaning',
proname => 'pg_stat_get_bgwriter_maxwritten_clean', provolatile => 's',
proparallel => 'r', prorettype => 'int8', proargtypes => '',
prosrc => 'pg_stat_get_bgwriter_maxwritten_clean' },
{ oid => '3075', descr => 'statistics: last reset for the bgwriter',
proname => 'pg_stat_get_bgwriter_stat_reset_time', provolatile => 's',
proparallel => 'r', prorettype => 'timestamptz', proargtypes => '',
prosrc => 'pg_stat_get_bgwriter_stat_reset_time' },
{ oid => '3160',
descr => 'statistics: checkpoint time spent writing buffers to disk, in milliseconds',
proname => 'pg_stat_get_checkpoint_write_time', provolatile => 's',
proparallel => 'r', prorettype => 'float8', proargtypes => '',
prosrc => 'pg_stat_get_checkpoint_write_time' },
{ oid => '3161',
descr => 'statistics: checkpoint time spent synchronizing buffers to disk, in milliseconds',
proname => 'pg_stat_get_checkpoint_sync_time', provolatile => 's',
proparallel => 'r', prorettype => 'float8', proargtypes => '',
prosrc => 'pg_stat_get_checkpoint_sync_time' },
{ oid => '2775', descr => 'statistics: number of buffers written by backends',
proname => 'pg_stat_get_buf_written_backend', provolatile => 's',
proparallel => 'r', prorettype => 'int8', proargtypes => '',
prosrc => 'pg_stat_get_buf_written_backend' },
{ oid => '3063',
descr => 'statistics: number of backend buffer writes that did their own fsync',
proname => 'pg_stat_get_buf_fsync_backend', provolatile => 's',
proparallel => 'r', prorettype => 'int8', proargtypes => '',
prosrc => 'pg_stat_get_buf_fsync_backend' },
{ oid => '2859', descr => 'statistics: number of buffer allocations',
proname => 'pg_stat_get_buf_alloc', provolatile => 's', proparallel => 'r',
prorettype => 'int8', proargtypes => '', prosrc => 'pg_stat_get_buf_alloc' },
{ oid => '2978', descr => 'statistics: number of function calls',
proname => 'pg_stat_get_function_calls', provolatile => 's',
proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_function_calls' },
{ oid => '2979',
descr => 'statistics: total execution time of function, in milliseconds',
proname => 'pg_stat_get_function_total_time', provolatile => 's',
proparallel => 'r', prorettype => 'float8', proargtypes => 'oid',
prosrc => 'pg_stat_get_function_total_time' },
{ oid => '2980',
descr => 'statistics: self execution time of function, in milliseconds',
proname => 'pg_stat_get_function_self_time', provolatile => 's',
proparallel => 'r', prorettype => 'float8', proargtypes => 'oid',
prosrc => 'pg_stat_get_function_self_time' },
{ oid => '3037',
descr => 'statistics: number of scans done for table/index in current transaction',
proname => 'pg_stat_get_xact_numscans', provolatile => 'v',
proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_xact_numscans' },
{ oid => '3038',
descr => 'statistics: number of tuples read by seqscan in current transaction',
proname => 'pg_stat_get_xact_tuples_returned', provolatile => 'v',
proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_xact_tuples_returned' },
{ oid => '3039',
descr => 'statistics: number of tuples fetched by idxscan in current transaction',
proname => 'pg_stat_get_xact_tuples_fetched', provolatile => 'v',
proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_xact_tuples_fetched' },
{ oid => '3040',
descr => 'statistics: number of tuples inserted in current transaction',
proname => 'pg_stat_get_xact_tuples_inserted', provolatile => 'v',
proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_xact_tuples_inserted' },
{ oid => '3041',
descr => 'statistics: number of tuples updated in current transaction',
proname => 'pg_stat_get_xact_tuples_updated', provolatile => 'v',
proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_xact_tuples_updated' },
{ oid => '3042',
descr => 'statistics: number of tuples deleted in current transaction',
proname => 'pg_stat_get_xact_tuples_deleted', provolatile => 'v',
proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_xact_tuples_deleted' },
{ oid => '3043',
descr => 'statistics: number of tuples hot updated in current transaction',
proname => 'pg_stat_get_xact_tuples_hot_updated', provolatile => 'v',
proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_xact_tuples_hot_updated' },
{ oid => '3044',
descr => 'statistics: number of blocks fetched in current transaction',
proname => 'pg_stat_get_xact_blocks_fetched', provolatile => 'v',
proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_xact_blocks_fetched' },
{ oid => '3045',
descr => 'statistics: number of blocks found in cache in current transaction',
proname => 'pg_stat_get_xact_blocks_hit', provolatile => 'v',
proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_xact_blocks_hit' },
{ oid => '3046',
descr => 'statistics: number of function calls in current transaction',
proname => 'pg_stat_get_xact_function_calls', provolatile => 'v',
proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
prosrc => 'pg_stat_get_xact_function_calls' },
{ oid => '3047',
descr => 'statistics: total execution time of function in current transaction, in milliseconds',
proname => 'pg_stat_get_xact_function_total_time', provolatile => 'v',
proparallel => 'r', prorettype => 'float8', proargtypes => 'oid',
prosrc => 'pg_stat_get_xact_function_total_time' },
{ oid => '3048',
descr => 'statistics: self execution time of function in current transaction, in milliseconds',
proname => 'pg_stat_get_xact_function_self_time', provolatile => 'v',
proparallel => 'r', prorettype => 'float8', proargtypes => 'oid',
prosrc => 'pg_stat_get_xact_function_self_time' },
{ oid => '3788',
descr => 'statistics: timestamp of the current statistics snapshot',
proname => 'pg_stat_get_snapshot_timestamp', provolatile => 's',
proparallel => 'r', prorettype => 'timestamptz', proargtypes => '',
prosrc => 'pg_stat_get_snapshot_timestamp' },
{ oid => '2230',
descr => 'statistics: discard current transaction\'s statistics snapshot',
proname => 'pg_stat_clear_snapshot', proisstrict => 'f', provolatile => 'v',
proparallel => 'r', prorettype => 'void', proargtypes => '',
prosrc => 'pg_stat_clear_snapshot' },
{ oid => '2274',
descr => 'statistics: reset collected statistics for current database',
proname => 'pg_stat_reset', proisstrict => 'f', provolatile => 'v',
prorettype => 'void', proargtypes => '', prosrc => 'pg_stat_reset' },
{ oid => '3775',
descr => 'statistics: reset collected statistics shared across the cluster',
proname => 'pg_stat_reset_shared', provolatile => 'v', prorettype => 'void',
proargtypes => 'text', prosrc => 'pg_stat_reset_shared' },
{ oid => '3776',
descr => 'statistics: reset collected statistics for a single table or index in the current database',
proname => 'pg_stat_reset_single_table_counters', provolatile => 'v',
prorettype => 'void', proargtypes => 'oid',
prosrc => 'pg_stat_reset_single_table_counters' },
{ oid => '3777',
descr => 'statistics: reset collected statistics for a single function in the current database',
proname => 'pg_stat_reset_single_function_counters', provolatile => 'v',
prorettype => 'void', proargtypes => 'oid',
prosrc => 'pg_stat_reset_single_function_counters' },
{ oid => '3163', descr => 'current trigger depth',
proname => 'pg_trigger_depth', provolatile => 's', proparallel => 'r',
prorettype => 'int4', proargtypes => '', prosrc => 'pg_trigger_depth' },
{ oid => '3778', descr => 'tablespace location',
proname => 'pg_tablespace_location', provolatile => 's', prorettype => 'text',
proargtypes => 'oid', prosrc => 'pg_tablespace_location' },
{ oid => '1946',
descr => 'convert bytea value into some ascii-only text string',
proname => 'encode', prorettype => 'text', proargtypes => 'bytea text',
prosrc => 'binary_encode' },
{ oid => '1947',
descr => 'convert ascii-encoded text string into bytea value',
proname => 'decode', prorettype => 'bytea', proargtypes => 'text text',
prosrc => 'binary_decode' },
{ oid => '1948',
proname => 'byteaeq', proleakproof => 't', prorettype => 'bool',
proargtypes => 'bytea bytea', prosrc => 'byteaeq' },
{ oid => '1949',
proname => 'bytealt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'bytea bytea', prosrc => 'bytealt' },
{ oid => '1950',
proname => 'byteale', proleakproof => 't', prorettype => 'bool',
proargtypes => 'bytea bytea', prosrc => 'byteale' },
{ oid => '1951',
proname => 'byteagt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'bytea bytea', prosrc => 'byteagt' },
{ oid => '1952',
proname => 'byteage', proleakproof => 't', prorettype => 'bool',
proargtypes => 'bytea bytea', prosrc => 'byteage' },
{ oid => '1953',
proname => 'byteane', proleakproof => 't', prorettype => 'bool',
proargtypes => 'bytea bytea', prosrc => 'byteane' },
{ oid => '1954', descr => 'less-equal-greater',
Mark built-in btree comparison functions as leakproof where it's safe. Generally, if the comparison operators for a datatype or pair of datatypes are leakproof, the corresponding btree comparison support function can be considered so as well. But we had not originally worried about marking support functions as leakproof, reasoning that they'd not likely be used in queries so the marking wouldn't matter. It turns out there's at least one place where it does matter: calc_arraycontsel() finds the target datatype's default btree comparison function and tries to use that to estimate selectivity, but it will be blocked in some cases if the function isn't leakproof. This leads to unnecessarily poor selectivity estimates and bad plans, as seen in bug #15251. Hence, run around and apply proleakproof markings where the corresponding btree comparison operators are leakproof. (I did eyeball each function to verify that it wasn't doing anything surprising, too.) This isn't a full solution to bug #15251, and it's not back-patchable because of the need for a catversion bump. A more useful response probably is to consider whether we can check permissions on the parent table instead of the child. However, this change will help in some cases where that won't, and it's easy enough to do in HEAD, so let's do so. Discussion: https://postgr.es/m/3876.1531261875@sss.pgh.pa.us
2018-07-12 00:47:31 +02:00
proname => 'byteacmp', proleakproof => 't', prorettype => 'int4',
proargtypes => 'bytea bytea', prosrc => 'byteacmp' },
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
{ oid => '3331', descr => 'sort support',
proname => 'bytea_sortsupport', prorettype => 'void',
proargtypes => 'internal', prosrc => 'bytea_sortsupport' },
{ oid => '3917', descr => 'transform a timestamp length coercion',
proname => 'timestamp_transform', prorettype => 'internal',
proargtypes => 'internal', prosrc => 'timestamp_transform' },
{ oid => '3944', descr => 'transform a time length coercion',
proname => 'time_transform', prorettype => 'internal',
proargtypes => 'internal', prosrc => 'time_transform' },
{ oid => '1961', descr => 'adjust timestamp precision',
proname => 'timestamp', protransform => 'timestamp_transform',
prorettype => 'timestamp', proargtypes => 'timestamp int4',
prosrc => 'timestamp_scale' },
{ oid => '1965', descr => 'larger of two',
proname => 'oidlarger', prorettype => 'oid', proargtypes => 'oid oid',
prosrc => 'oidlarger' },
{ oid => '1966', descr => 'smaller of two',
proname => 'oidsmaller', prorettype => 'oid', proargtypes => 'oid oid',
prosrc => 'oidsmaller' },
{ oid => '1967', descr => 'adjust timestamptz precision',
proname => 'timestamptz', protransform => 'timestamp_transform',
prorettype => 'timestamptz', proargtypes => 'timestamptz int4',
prosrc => 'timestamptz_scale' },
{ oid => '1968', descr => 'adjust time precision',
proname => 'time', protransform => 'time_transform', prorettype => 'time',
proargtypes => 'time int4', prosrc => 'time_scale' },
{ oid => '1969', descr => 'adjust time with time zone precision',
proname => 'timetz', protransform => 'time_transform', prorettype => 'timetz',
proargtypes => 'timetz int4', prosrc => 'timetz_scale' },
{ oid => '2003',
proname => 'textanycat', prolang => '14', provolatile => 's',
prorettype => 'text', proargtypes => 'text anynonarray',
prosrc => 'select $1 || $2::pg_catalog.text' },
{ oid => '2004',
proname => 'anytextcat', prolang => '14', provolatile => 's',
prorettype => 'text', proargtypes => 'anynonarray text',
prosrc => 'select $1::pg_catalog.text || $2' },
{ oid => '2005',
proname => 'bytealike', prorettype => 'bool', proargtypes => 'bytea bytea',
prosrc => 'bytealike' },
{ oid => '2006',
proname => 'byteanlike', prorettype => 'bool', proargtypes => 'bytea bytea',
prosrc => 'byteanlike' },
{ oid => '2007', descr => 'matches LIKE expression',
proname => 'like', prorettype => 'bool', proargtypes => 'bytea bytea',
prosrc => 'bytealike' },
{ oid => '2008', descr => 'does not match LIKE expression',
proname => 'notlike', prorettype => 'bool', proargtypes => 'bytea bytea',
prosrc => 'byteanlike' },
{ oid => '2009', descr => 'convert LIKE pattern to use backslash escapes',
proname => 'like_escape', prorettype => 'bytea', proargtypes => 'bytea bytea',
prosrc => 'like_escape_bytea' },
{ oid => '2010', descr => 'octet length',
proname => 'length', prorettype => 'int4', proargtypes => 'bytea',
prosrc => 'byteaoctetlen' },
{ oid => '2011',
proname => 'byteacat', prorettype => 'bytea', proargtypes => 'bytea bytea',
prosrc => 'byteacat' },
{ oid => '2012', descr => 'extract portion of string',
proname => 'substring', prorettype => 'bytea',
proargtypes => 'bytea int4 int4', prosrc => 'bytea_substr' },
{ oid => '2013', descr => 'extract portion of string',
proname => 'substring', prorettype => 'bytea', proargtypes => 'bytea int4',
prosrc => 'bytea_substr_no_len' },
{ oid => '2085', descr => 'extract portion of string',
proname => 'substr', prorettype => 'bytea', proargtypes => 'bytea int4 int4',
prosrc => 'bytea_substr' },
{ oid => '2086', descr => 'extract portion of string',
proname => 'substr', prorettype => 'bytea', proargtypes => 'bytea int4',
prosrc => 'bytea_substr_no_len' },
{ oid => '2014', descr => 'position of substring',
proname => 'position', prorettype => 'int4', proargtypes => 'bytea bytea',
prosrc => 'byteapos' },
{ oid => '2015', descr => 'trim both ends of string',
proname => 'btrim', prorettype => 'bytea', proargtypes => 'bytea bytea',
prosrc => 'byteatrim' },
{ oid => '2019', descr => 'convert timestamp with time zone to time',
proname => 'time', provolatile => 's', prorettype => 'time',
proargtypes => 'timestamptz', prosrc => 'timestamptz_time' },
{ oid => '2020', descr => 'truncate timestamp to specified units',
proname => 'date_trunc', prorettype => 'timestamp',
proargtypes => 'text timestamp', prosrc => 'timestamp_trunc' },
{ oid => '2021', descr => 'extract field from timestamp',
proname => 'date_part', prorettype => 'float8',
proargtypes => 'text timestamp', prosrc => 'timestamp_part' },
{ oid => '2024', descr => 'convert date to timestamp',
proname => 'timestamp', prorettype => 'timestamp', proargtypes => 'date',
prosrc => 'date_timestamp' },
{ oid => '2025', descr => 'convert date and time to timestamp',
proname => 'timestamp', prorettype => 'timestamp', proargtypes => 'date time',
prosrc => 'datetime_timestamp' },
{ oid => '2027', descr => 'convert timestamp with time zone to timestamp',
proname => 'timestamp', provolatile => 's', prorettype => 'timestamp',
proargtypes => 'timestamptz', prosrc => 'timestamptz_timestamp' },
{ oid => '2028', descr => 'convert timestamp to timestamp with time zone',
proname => 'timestamptz', provolatile => 's', prorettype => 'timestamptz',
proargtypes => 'timestamp', prosrc => 'timestamp_timestamptz' },
{ oid => '2029', descr => 'convert timestamp to date',
proname => 'date', prorettype => 'date', proargtypes => 'timestamp',
prosrc => 'timestamp_date' },
{ oid => '2031',
proname => 'timestamp_mi', prorettype => 'interval',
proargtypes => 'timestamp timestamp', prosrc => 'timestamp_mi' },
{ oid => '2032',
proname => 'timestamp_pl_interval', prorettype => 'timestamp',
proargtypes => 'timestamp interval', prosrc => 'timestamp_pl_interval' },
{ oid => '2033',
proname => 'timestamp_mi_interval', prorettype => 'timestamp',
proargtypes => 'timestamp interval', prosrc => 'timestamp_mi_interval' },
{ oid => '2035', descr => 'smaller of two',
proname => 'timestamp_smaller', prorettype => 'timestamp',
proargtypes => 'timestamp timestamp', prosrc => 'timestamp_smaller' },
{ oid => '2036', descr => 'larger of two',
proname => 'timestamp_larger', prorettype => 'timestamp',
proargtypes => 'timestamp timestamp', prosrc => 'timestamp_larger' },
{ oid => '2037', descr => 'adjust time with time zone to new zone',
proname => 'timezone', provolatile => 'v', prorettype => 'timetz',
proargtypes => 'text timetz', prosrc => 'timetz_zone' },
{ oid => '2038', descr => 'adjust time with time zone to new zone',
proname => 'timezone', prorettype => 'timetz',
proargtypes => 'interval timetz', prosrc => 'timetz_izone' },
{ oid => '2039', descr => 'hash',
proname => 'timestamp_hash', prorettype => 'int4', proargtypes => 'timestamp',
prosrc => 'timestamp_hash' },
{ oid => '3411', descr => 'hash',
proname => 'timestamp_hash_extended', prorettype => 'int8',
proargtypes => 'timestamp int8', prosrc => 'timestamp_hash_extended' },
{ oid => '2041', descr => 'intervals overlap?',
proname => 'overlaps', proisstrict => 'f', prorettype => 'bool',
proargtypes => 'timestamp timestamp timestamp timestamp',
prosrc => 'overlaps_timestamp' },
{ oid => '2042', descr => 'intervals overlap?',
proname => 'overlaps', prolang => '14', proisstrict => 'f',
prorettype => 'bool', proargtypes => 'timestamp interval timestamp interval',
prosrc => 'select ($1, ($1 + $2)) overlaps ($3, ($3 + $4))' },
{ oid => '2043', descr => 'intervals overlap?',
proname => 'overlaps', prolang => '14', proisstrict => 'f',
prorettype => 'bool', proargtypes => 'timestamp timestamp timestamp interval',
prosrc => 'select ($1, $2) overlaps ($3, ($3 + $4))' },
{ oid => '2044', descr => 'intervals overlap?',
proname => 'overlaps', prolang => '14', proisstrict => 'f',
prorettype => 'bool', proargtypes => 'timestamp interval timestamp timestamp',
prosrc => 'select ($1, ($1 + $2)) overlaps ($3, $4)' },
{ oid => '2045', descr => 'less-equal-greater',
Mark built-in btree comparison functions as leakproof where it's safe. Generally, if the comparison operators for a datatype or pair of datatypes are leakproof, the corresponding btree comparison support function can be considered so as well. But we had not originally worried about marking support functions as leakproof, reasoning that they'd not likely be used in queries so the marking wouldn't matter. It turns out there's at least one place where it does matter: calc_arraycontsel() finds the target datatype's default btree comparison function and tries to use that to estimate selectivity, but it will be blocked in some cases if the function isn't leakproof. This leads to unnecessarily poor selectivity estimates and bad plans, as seen in bug #15251. Hence, run around and apply proleakproof markings where the corresponding btree comparison operators are leakproof. (I did eyeball each function to verify that it wasn't doing anything surprising, too.) This isn't a full solution to bug #15251, and it's not back-patchable because of the need for a catversion bump. A more useful response probably is to consider whether we can check permissions on the parent table instead of the child. However, this change will help in some cases where that won't, and it's easy enough to do in HEAD, so let's do so. Discussion: https://postgr.es/m/3876.1531261875@sss.pgh.pa.us
2018-07-12 00:47:31 +02:00
proname => 'timestamp_cmp', proleakproof => 't', prorettype => 'int4',
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
proargtypes => 'timestamp timestamp', prosrc => 'timestamp_cmp' },
{ oid => '3137', descr => 'sort support',
proname => 'timestamp_sortsupport', prorettype => 'void',
proargtypes => 'internal', prosrc => 'timestamp_sortsupport' },
{ oid => '4134', descr => 'window RANGE support',
proname => 'in_range', prorettype => 'bool',
proargtypes => 'timestamp timestamp interval bool bool',
prosrc => 'in_range_timestamp_interval' },
{ oid => '4135', descr => 'window RANGE support',
proname => 'in_range', provolatile => 's', prorettype => 'bool',
proargtypes => 'timestamptz timestamptz interval bool bool',
prosrc => 'in_range_timestamptz_interval' },
{ oid => '4136', descr => 'window RANGE support',
proname => 'in_range', prorettype => 'bool',
proargtypes => 'interval interval interval bool bool',
prosrc => 'in_range_interval_interval' },
{ oid => '4137', descr => 'window RANGE support',
proname => 'in_range', prorettype => 'bool',
proargtypes => 'time time interval bool bool',
prosrc => 'in_range_time_interval' },
{ oid => '4138', descr => 'window RANGE support',
proname => 'in_range', prorettype => 'bool',
proargtypes => 'timetz timetz interval bool bool',
prosrc => 'in_range_timetz_interval' },
{ oid => '2046', descr => 'convert time with time zone to time',
proname => 'time', prorettype => 'time', proargtypes => 'timetz',
prosrc => 'timetz_time' },
{ oid => '2047', descr => 'convert time to time with time zone',
proname => 'timetz', provolatile => 's', prorettype => 'timetz',
proargtypes => 'time', prosrc => 'time_timetz' },
{ oid => '2048', descr => 'finite timestamp?',
proname => 'isfinite', prorettype => 'bool', proargtypes => 'timestamp',
prosrc => 'timestamp_finite' },
{ oid => '2049', descr => 'format timestamp to text',
proname => 'to_char', provolatile => 's', prorettype => 'text',
proargtypes => 'timestamp text', prosrc => 'timestamp_to_char' },
{ oid => '2052',
proname => 'timestamp_eq', proleakproof => 't', prorettype => 'bool',
proargtypes => 'timestamp timestamp', prosrc => 'timestamp_eq' },
{ oid => '2053',
proname => 'timestamp_ne', proleakproof => 't', prorettype => 'bool',
proargtypes => 'timestamp timestamp', prosrc => 'timestamp_ne' },
{ oid => '2054',
proname => 'timestamp_lt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'timestamp timestamp', prosrc => 'timestamp_lt' },
{ oid => '2055',
proname => 'timestamp_le', proleakproof => 't', prorettype => 'bool',
proargtypes => 'timestamp timestamp', prosrc => 'timestamp_le' },
{ oid => '2056',
proname => 'timestamp_ge', proleakproof => 't', prorettype => 'bool',
proargtypes => 'timestamp timestamp', prosrc => 'timestamp_ge' },
{ oid => '2057',
proname => 'timestamp_gt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'timestamp timestamp', prosrc => 'timestamp_gt' },
{ oid => '2058', descr => 'date difference preserving months and years',
proname => 'age', prorettype => 'interval',
proargtypes => 'timestamp timestamp', prosrc => 'timestamp_age' },
{ oid => '2059',
descr => 'date difference from today preserving months and years',
proname => 'age', prolang => '14', provolatile => 's',
prorettype => 'interval', proargtypes => 'timestamp',
prosrc => 'select pg_catalog.age(cast(current_date as timestamp without time zone), $1)' },
{ oid => '2069', descr => 'adjust timestamp to new time zone',
proname => 'timezone', protransform => 'timestamp_zone_transform',
prorettype => 'timestamptz', proargtypes => 'text timestamp',
prosrc => 'timestamp_zone' },
{ oid => '2070', descr => 'adjust timestamp to new time zone',
proname => 'timezone', protransform => 'timestamp_izone_transform',
prorettype => 'timestamptz', proargtypes => 'interval timestamp',
prosrc => 'timestamp_izone' },
{ oid => '2071',
proname => 'date_pl_interval', prorettype => 'timestamp',
proargtypes => 'date interval', prosrc => 'date_pl_interval' },
{ oid => '2072',
proname => 'date_mi_interval', prorettype => 'timestamp',
proargtypes => 'date interval', prosrc => 'date_mi_interval' },
{ oid => '2073', descr => 'extract text matching regular expression',
proname => 'substring', prorettype => 'text', proargtypes => 'text text',
prosrc => 'textregexsubstr' },
{ oid => '2074', descr => 'extract text matching SQL99 regular expression',
proname => 'substring', prolang => '14', prorettype => 'text',
proargtypes => 'text text text',
prosrc => 'select pg_catalog.substring($1, pg_catalog.similar_escape($2, $3))' },
{ oid => '2075', descr => 'convert int8 to bitstring',
proname => 'bit', prorettype => 'bit', proargtypes => 'int8 int4',
prosrc => 'bitfromint8' },
{ oid => '2076', descr => 'convert bitstring to int8',
proname => 'int8', prorettype => 'int8', proargtypes => 'bit',
prosrc => 'bittoint8' },
{ oid => '2077', descr => 'SHOW X as a function',
proname => 'current_setting', provolatile => 's', prorettype => 'text',
proargtypes => 'text', prosrc => 'show_config_by_name' },
{ oid => '3294',
descr => 'SHOW X as a function, optionally no error for missing variable',
proname => 'current_setting', provolatile => 's', prorettype => 'text',
proargtypes => 'text bool', prosrc => 'show_config_by_name_missing_ok' },
{ oid => '2078', descr => 'SET X as a function',
proname => 'set_config', proisstrict => 'f', provolatile => 'v',
proparallel => 'u', prorettype => 'text', proargtypes => 'text text bool',
prosrc => 'set_config_by_name' },
{ oid => '2084', descr => 'SHOW ALL as a function',
proname => 'pg_show_all_settings', prorows => '1000', proretset => 't',
provolatile => 's', prorettype => 'record', proargtypes => '',
proallargtypes => '{text,text,text,text,text,text,text,text,text,text,text,_text,text,text,text,int4,bool}',
proargmodes => '{o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o}',
proargnames => '{name,setting,unit,category,short_desc,extra_desc,context,vartype,source,min_val,max_val,enumvals,boot_val,reset_val,sourcefile,sourceline,pending_restart}',
prosrc => 'show_all_settings' },
{ oid => '3329', descr => 'show config file settings',
proname => 'pg_show_all_file_settings', prorows => '1000', proretset => 't',
provolatile => 'v', prorettype => 'record', proargtypes => '',
proallargtypes => '{text,int4,int4,text,text,bool,text}',
proargmodes => '{o,o,o,o,o,o,o}',
proargnames => '{sourcefile,sourceline,seqno,name,setting,applied,error}',
prosrc => 'show_all_file_settings' },
{ oid => '3401', descr => 'show pg_hba.conf rules',
proname => 'pg_hba_file_rules', prorows => '1000', proretset => 't',
provolatile => 'v', prorettype => 'record', proargtypes => '',
proallargtypes => '{int4,text,_text,_text,text,text,text,_text,text}',
proargmodes => '{o,o,o,o,o,o,o,o,o}',
proargnames => '{line_number,type,database,user_name,address,netmask,auth_method,options,error}',
prosrc => 'pg_hba_file_rules' },
{ oid => '1371', descr => 'view system lock information',
proname => 'pg_lock_status', prorows => '1000', proretset => 't',
provolatile => 'v', prorettype => 'record', proargtypes => '',
proallargtypes => '{text,oid,oid,int4,int2,text,xid,oid,oid,int2,text,int4,text,bool,bool}',
proargmodes => '{o,o,o,o,o,o,o,o,o,o,o,o,o,o,o}',
proargnames => '{locktype,database,relation,page,tuple,virtualxid,transactionid,classid,objid,objsubid,virtualtransaction,pid,mode,granted,fastpath}',
prosrc => 'pg_lock_status' },
{ oid => '2561',
descr => 'get array of PIDs of sessions blocking specified backend PID from acquiring a heavyweight lock',
proname => 'pg_blocking_pids', provolatile => 'v', prorettype => '_int4',
proargtypes => 'int4', prosrc => 'pg_blocking_pids' },
{ oid => '3376',
descr => 'get array of PIDs of sessions blocking specified backend PID from acquiring a safe snapshot',
proname => 'pg_safe_snapshot_blocking_pids', provolatile => 'v',
prorettype => '_int4', proargtypes => 'int4',
prosrc => 'pg_safe_snapshot_blocking_pids' },
{ oid => '3378', descr => 'isolationtester support function',
proname => 'pg_isolation_test_session_is_blocked', provolatile => 'v',
prorettype => 'bool', proargtypes => 'int4 _int4',
prosrc => 'pg_isolation_test_session_is_blocked' },
{ oid => '1065', descr => 'view two-phase transactions',
proname => 'pg_prepared_xact', prorows => '1000', proretset => 't',
provolatile => 'v', prorettype => 'record', proargtypes => '',
proallargtypes => '{xid,text,timestamptz,oid,oid}',
proargmodes => '{o,o,o,o,o}',
proargnames => '{transaction,gid,prepared,ownerid,dbid}',
prosrc => 'pg_prepared_xact' },
{ oid => '3819', descr => 'view members of a multixactid',
proname => 'pg_get_multixact_members', prorows => '1000', proretset => 't',
provolatile => 'v', prorettype => 'record', proargtypes => 'xid',
proallargtypes => '{xid,xid,text}', proargmodes => '{i,o,o}',
proargnames => '{multixid,xid,mode}', prosrc => 'pg_get_multixact_members' },
{ oid => '3581', descr => 'get commit timestamp of a transaction',
proname => 'pg_xact_commit_timestamp', provolatile => 'v',
prorettype => 'timestamptz', proargtypes => 'xid',
prosrc => 'pg_xact_commit_timestamp' },
{ oid => '3583',
descr => 'get transaction Id and commit timestamp of latest transaction commit',
proname => 'pg_last_committed_xact', provolatile => 'v',
prorettype => 'record', proargtypes => '',
proallargtypes => '{xid,timestamptz}', proargmodes => '{o,o}',
proargnames => '{xid,timestamp}', prosrc => 'pg_last_committed_xact' },
{ oid => '3537', descr => 'get identification of SQL object',
proname => 'pg_describe_object', provolatile => 's', prorettype => 'text',
proargtypes => 'oid oid int4', prosrc => 'pg_describe_object' },
{ oid => '3839',
descr => 'get machine-parseable identification of SQL object',
proname => 'pg_identify_object', provolatile => 's', prorettype => 'record',
proargtypes => 'oid oid int4',
proallargtypes => '{oid,oid,int4,text,text,text,text}',
proargmodes => '{i,i,i,o,o,o,o}',
proargnames => '{classid,objid,objsubid,type,schema,name,identity}',
prosrc => 'pg_identify_object' },
{ oid => '3382',
descr => 'get identification of SQL object for pg_get_object_address()',
proname => 'pg_identify_object_as_address', provolatile => 's',
prorettype => 'record', proargtypes => 'oid oid int4',
proallargtypes => '{oid,oid,int4,text,_text,_text}',
proargmodes => '{i,i,i,o,o,o}',
proargnames => '{classid,objid,objsubid,type,object_names,object_args}',
prosrc => 'pg_identify_object_as_address' },
{ oid => '3954',
descr => 'get OID-based object address from name/args arrays',
proname => 'pg_get_object_address', provolatile => 's',
prorettype => 'record', proargtypes => 'text _text _text',
proallargtypes => '{text,_text,_text,oid,oid,int4}',
proargmodes => '{i,i,i,o,o,o}',
Make argument names of pg_get_object_address consistent, and fix docs. pg_get_object_address and pg_identify_object_as_address are supposed to be inverses, but they disagreed as to the names of the arguments representing the textual form of an object address. Moreover, the documented argument names didn't agree with reality at all, either for these functions or pg_identify_object. In HEAD and v11, I think we can get away with renaming the input arguments of pg_get_object_address to match the outputs of pg_identify_object_as_address. In theory that might break queries using named-argument notation to call pg_get_object_address, but it seems really unlikely that anybody is doing that, or that they'd have much trouble adjusting if they were. In older branches, we'll just live with the lack of consistency. Aside from fixing the documentation of these functions to match reality, I couldn't resist the temptation to do some copy-editing. Per complaint from Jean-Pierre Pelletier. Back-patch to 9.5 where these functions were introduced. (Before v11, this is a documentation change only.) Discussion: https://postgr.es/m/CANGqjDnWH8wsTY_GzDUxbt4i=y-85SJreZin4Hm8uOqv1vzRQA@mail.gmail.com
2018-09-05 19:47:15 +02:00
proargnames => '{type,object_names,object_args,classid,objid,objsubid}',
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
prosrc => 'pg_get_object_address' },
{ oid => '2079', descr => 'is table visible in search path?',
proname => 'pg_table_is_visible', procost => '10', provolatile => 's',
prorettype => 'bool', proargtypes => 'oid', prosrc => 'pg_table_is_visible' },
{ oid => '2080', descr => 'is type visible in search path?',
proname => 'pg_type_is_visible', procost => '10', provolatile => 's',
prorettype => 'bool', proargtypes => 'oid', prosrc => 'pg_type_is_visible' },
{ oid => '2081', descr => 'is function visible in search path?',
proname => 'pg_function_is_visible', procost => '10', provolatile => 's',
prorettype => 'bool', proargtypes => 'oid',
prosrc => 'pg_function_is_visible' },
{ oid => '2082', descr => 'is operator visible in search path?',
proname => 'pg_operator_is_visible', procost => '10', provolatile => 's',
prorettype => 'bool', proargtypes => 'oid',
prosrc => 'pg_operator_is_visible' },
{ oid => '2083', descr => 'is opclass visible in search path?',
proname => 'pg_opclass_is_visible', procost => '10', provolatile => 's',
prorettype => 'bool', proargtypes => 'oid',
prosrc => 'pg_opclass_is_visible' },
{ oid => '3829', descr => 'is opfamily visible in search path?',
proname => 'pg_opfamily_is_visible', procost => '10', provolatile => 's',
prorettype => 'bool', proargtypes => 'oid',
prosrc => 'pg_opfamily_is_visible' },
{ oid => '2093', descr => 'is conversion visible in search path?',
proname => 'pg_conversion_is_visible', procost => '10', provolatile => 's',
prorettype => 'bool', proargtypes => 'oid',
prosrc => 'pg_conversion_is_visible' },
{ oid => '3403', descr => 'is statistics object visible in search path?',
proname => 'pg_statistics_obj_is_visible', procost => '10',
provolatile => 's', prorettype => 'bool', proargtypes => 'oid',
prosrc => 'pg_statistics_obj_is_visible' },
{ oid => '3756', descr => 'is text search parser visible in search path?',
proname => 'pg_ts_parser_is_visible', procost => '10', provolatile => 's',
prorettype => 'bool', proargtypes => 'oid',
prosrc => 'pg_ts_parser_is_visible' },
{ oid => '3757', descr => 'is text search dictionary visible in search path?',
proname => 'pg_ts_dict_is_visible', procost => '10', provolatile => 's',
prorettype => 'bool', proargtypes => 'oid',
prosrc => 'pg_ts_dict_is_visible' },
{ oid => '3768', descr => 'is text search template visible in search path?',
proname => 'pg_ts_template_is_visible', procost => '10', provolatile => 's',
prorettype => 'bool', proargtypes => 'oid',
prosrc => 'pg_ts_template_is_visible' },
{ oid => '3758',
descr => 'is text search configuration visible in search path?',
proname => 'pg_ts_config_is_visible', procost => '10', provolatile => 's',
prorettype => 'bool', proargtypes => 'oid',
prosrc => 'pg_ts_config_is_visible' },
{ oid => '3815', descr => 'is collation visible in search path?',
proname => 'pg_collation_is_visible', procost => '10', provolatile => 's',
prorettype => 'bool', proargtypes => 'oid',
prosrc => 'pg_collation_is_visible' },
{ oid => '2854', descr => 'get OID of current session\'s temp schema, if any',
proname => 'pg_my_temp_schema', provolatile => 's', proparallel => 'r',
prorettype => 'oid', proargtypes => '', prosrc => 'pg_my_temp_schema' },
{ oid => '2855', descr => 'is schema another session\'s temp schema?',
proname => 'pg_is_other_temp_schema', provolatile => 's',
prorettype => 'bool', proargtypes => 'oid',
prosrc => 'pg_is_other_temp_schema' },
{ oid => '2171', descr => 'cancel a server process\' current query',
proname => 'pg_cancel_backend', provolatile => 'v', prorettype => 'bool',
proargtypes => 'int4', prosrc => 'pg_cancel_backend' },
{ oid => '2096', descr => 'terminate a server process',
proname => 'pg_terminate_backend', provolatile => 'v', prorettype => 'bool',
proargtypes => 'int4', prosrc => 'pg_terminate_backend' },
{ oid => '2172', descr => 'prepare for taking an online backup',
proname => 'pg_start_backup', provolatile => 'v', proparallel => 'r',
prorettype => 'pg_lsn', proargtypes => 'text bool bool',
prosrc => 'pg_start_backup' },
{ oid => '2173', descr => 'finish taking an online backup',
proname => 'pg_stop_backup', provolatile => 'v', proparallel => 'r',
prorettype => 'pg_lsn', proargtypes => '', prosrc => 'pg_stop_backup' },
{ oid => '2739', descr => 'finish taking an online backup',
proname => 'pg_stop_backup', prorows => '1', proretset => 't',
provolatile => 'v', proparallel => 'r', prorettype => 'record',
proargtypes => 'bool bool', proallargtypes => '{bool,bool,pg_lsn,text,text}',
proargmodes => '{i,i,o,o,o}',
proargnames => '{exclusive,wait_for_archive,lsn,labelfile,spcmapfile}',
prosrc => 'pg_stop_backup_v2' },
{ oid => '3813', descr => 'true if server is in online backup',
proname => 'pg_is_in_backup', provolatile => 'v', prorettype => 'bool',
proargtypes => '', prosrc => 'pg_is_in_backup' },
{ oid => '3814', descr => 'start time of an online backup',
proname => 'pg_backup_start_time', provolatile => 's',
prorettype => 'timestamptz', proargtypes => '',
prosrc => 'pg_backup_start_time' },
Add pg_promote function This function is able to promote a standby with this new SQL-callable function. Execution access can be granted to non-superusers so that failover tools can observe the principle of least privilege. Catalog version is bumped. Author: Laurenz Albe Reviewed-by: Michael Paquier, Masahiko Sawada Discussion: https://postgr.es/m/6e7c79b3ec916cf49742fb8849ed17cd87aed620.camel@cybertec.at
2018-10-25 02:46:00 +02:00
{ oid => '3436', descr => 'promote standby server',
Add a timezone-specific variant of date_trunc(). date_trunc(field, timestamptz, zone_name) performs truncation using the named time zone as reference, rather than working in the session time zone as is the default behavior. It's equivalent to date_trunc(field, timestamptz at time zone zone_name) at time zone zone_name but it's faster, easier to type, and arguably easier to understand. Vik Fearing and Tom Lane Discussion: https://postgr.es/m/6249ffc4-2b22-4c1b-4e7d-7af84fedd7c6@2ndquadrant.com
2018-11-14 21:41:07 +01:00
proname => 'pg_promote', provolatile => 'v', prorettype => 'bool',
proargtypes => 'bool int4', proargnames => '{wait,wait_seconds}',
Add pg_promote function This function is able to promote a standby with this new SQL-callable function. Execution access can be granted to non-superusers so that failover tools can observe the principle of least privilege. Catalog version is bumped. Author: Laurenz Albe Reviewed-by: Michael Paquier, Masahiko Sawada Discussion: https://postgr.es/m/6e7c79b3ec916cf49742fb8849ed17cd87aed620.camel@cybertec.at
2018-10-25 02:46:00 +02:00
prosrc => 'pg_promote' },
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
{ oid => '2848', descr => 'switch to new wal file',
proname => 'pg_switch_wal', provolatile => 'v', prorettype => 'pg_lsn',
proargtypes => '', prosrc => 'pg_switch_wal' },
{ oid => '3098', descr => 'create a named restore point',
proname => 'pg_create_restore_point', provolatile => 'v',
prorettype => 'pg_lsn', proargtypes => 'text',
prosrc => 'pg_create_restore_point' },
{ oid => '2849', descr => 'current wal write location',
proname => 'pg_current_wal_lsn', provolatile => 'v', prorettype => 'pg_lsn',
proargtypes => '', prosrc => 'pg_current_wal_lsn' },
{ oid => '2852', descr => 'current wal insert location',
proname => 'pg_current_wal_insert_lsn', provolatile => 'v',
prorettype => 'pg_lsn', proargtypes => '',
prosrc => 'pg_current_wal_insert_lsn' },
{ oid => '3330', descr => 'current wal flush location',
proname => 'pg_current_wal_flush_lsn', provolatile => 'v',
prorettype => 'pg_lsn', proargtypes => '',
prosrc => 'pg_current_wal_flush_lsn' },
{ oid => '2850',
descr => 'wal filename and byte offset, given a wal location',
proname => 'pg_walfile_name_offset', prorettype => 'record',
proargtypes => 'pg_lsn', proallargtypes => '{pg_lsn,text,int4}',
proargmodes => '{i,o,o}', proargnames => '{lsn,file_name,file_offset}',
prosrc => 'pg_walfile_name_offset' },
{ oid => '2851', descr => 'wal filename, given a wal location',
proname => 'pg_walfile_name', prorettype => 'text', proargtypes => 'pg_lsn',
prosrc => 'pg_walfile_name' },
{ oid => '3165', descr => 'difference in bytes, given two wal locations',
proname => 'pg_wal_lsn_diff', prorettype => 'numeric',
proargtypes => 'pg_lsn pg_lsn', prosrc => 'pg_wal_lsn_diff' },
{ oid => '3809', descr => 'export a snapshot',
proname => 'pg_export_snapshot', provolatile => 'v', proparallel => 'u',
prorettype => 'text', proargtypes => '', prosrc => 'pg_export_snapshot' },
{ oid => '3810', descr => 'true if server is in recovery',
proname => 'pg_is_in_recovery', provolatile => 'v', prorettype => 'bool',
proargtypes => '', prosrc => 'pg_is_in_recovery' },
{ oid => '3820', descr => 'current wal flush location',
proname => 'pg_last_wal_receive_lsn', provolatile => 'v',
prorettype => 'pg_lsn', proargtypes => '',
prosrc => 'pg_last_wal_receive_lsn' },
{ oid => '3821', descr => 'last wal replay location',
proname => 'pg_last_wal_replay_lsn', provolatile => 'v',
prorettype => 'pg_lsn', proargtypes => '',
prosrc => 'pg_last_wal_replay_lsn' },
{ oid => '3830', descr => 'timestamp of last replay xact',
proname => 'pg_last_xact_replay_timestamp', provolatile => 'v',
prorettype => 'timestamptz', proargtypes => '',
prosrc => 'pg_last_xact_replay_timestamp' },
{ oid => '3071', descr => 'pause wal replay',
proname => 'pg_wal_replay_pause', provolatile => 'v', prorettype => 'void',
proargtypes => '', prosrc => 'pg_wal_replay_pause' },
{ oid => '3072', descr => 'resume wal replay, if it was paused',
proname => 'pg_wal_replay_resume', provolatile => 'v', prorettype => 'void',
proargtypes => '', prosrc => 'pg_wal_replay_resume' },
{ oid => '3073', descr => 'true if wal replay is paused',
proname => 'pg_is_wal_replay_paused', provolatile => 'v',
prorettype => 'bool', proargtypes => '',
prosrc => 'pg_is_wal_replay_paused' },
{ oid => '2621', descr => 'reload configuration files',
proname => 'pg_reload_conf', provolatile => 'v', prorettype => 'bool',
proargtypes => '', prosrc => 'pg_reload_conf' },
{ oid => '2622', descr => 'rotate log file',
proname => 'pg_rotate_logfile', provolatile => 'v', prorettype => 'bool',
proargtypes => '', prosrc => 'pg_rotate_logfile_v2' },
{ oid => '4099', descr => 'rotate log file - old version for adminpack 1.0',
proname => 'pg_rotate_logfile_old', provolatile => 'v', prorettype => 'bool',
proargtypes => '', prosrc => 'pg_rotate_logfile' },
{ oid => '3800', descr => 'current logging collector file location',
proname => 'pg_current_logfile', proisstrict => 'f', provolatile => 'v',
prorettype => 'text', proargtypes => '', prosrc => 'pg_current_logfile' },
{ oid => '3801', descr => 'current logging collector file location',
proname => 'pg_current_logfile', proisstrict => 'f', provolatile => 'v',
prorettype => 'text', proargtypes => 'text',
prosrc => 'pg_current_logfile_1arg' },
{ oid => '2623', descr => 'get information about file',
proname => 'pg_stat_file', provolatile => 'v', prorettype => 'record',
proargtypes => 'text',
proallargtypes => '{text,int8,timestamptz,timestamptz,timestamptz,timestamptz,bool}',
proargmodes => '{i,o,o,o,o,o,o}',
proargnames => '{filename,size,access,modification,change,creation,isdir}',
prosrc => 'pg_stat_file_1arg' },
{ oid => '3307', descr => 'get information about file',
proname => 'pg_stat_file', provolatile => 'v', prorettype => 'record',
proargtypes => 'text bool',
proallargtypes => '{text,bool,int8,timestamptz,timestamptz,timestamptz,timestamptz,bool}',
proargmodes => '{i,i,o,o,o,o,o,o}',
proargnames => '{filename,missing_ok,size,access,modification,change,creation,isdir}',
prosrc => 'pg_stat_file' },
{ oid => '2624', descr => 'read text from a file',
proname => 'pg_read_file', provolatile => 'v', prorettype => 'text',
proargtypes => 'text int8 int8', prosrc => 'pg_read_file_off_len' },
{ oid => '3293', descr => 'read text from a file',
proname => 'pg_read_file', provolatile => 'v', prorettype => 'text',
proargtypes => 'text int8 int8 bool', prosrc => 'pg_read_file_v2' },
{ oid => '4100',
descr => 'read text from a file - old version for adminpack 1.0',
proname => 'pg_read_file_old', provolatile => 'v', prorettype => 'text',
proargtypes => 'text int8 int8', prosrc => 'pg_read_file' },
{ oid => '3826', descr => 'read text from a file',
proname => 'pg_read_file', provolatile => 'v', prorettype => 'text',
proargtypes => 'text', prosrc => 'pg_read_file_all' },
{ oid => '3827', descr => 'read bytea from a file',
proname => 'pg_read_binary_file', provolatile => 'v', prorettype => 'bytea',
proargtypes => 'text int8 int8', prosrc => 'pg_read_binary_file_off_len' },
{ oid => '3295', descr => 'read bytea from a file',
proname => 'pg_read_binary_file', provolatile => 'v', prorettype => 'bytea',
proargtypes => 'text int8 int8 bool', prosrc => 'pg_read_binary_file' },
{ oid => '3828', descr => 'read bytea from a file',
proname => 'pg_read_binary_file', provolatile => 'v', prorettype => 'bytea',
proargtypes => 'text', prosrc => 'pg_read_binary_file_all' },
{ oid => '2625', descr => 'list all files in a directory',
proname => 'pg_ls_dir', prorows => '1000', proretset => 't',
provolatile => 'v', prorettype => 'text', proargtypes => 'text',
prosrc => 'pg_ls_dir_1arg' },
{ oid => '3297', descr => 'list all files in a directory',
proname => 'pg_ls_dir', prorows => '1000', proretset => 't',
provolatile => 'v', prorettype => 'text', proargtypes => 'text bool bool',
prosrc => 'pg_ls_dir' },
{ oid => '2626', descr => 'sleep for the specified time in seconds',
proname => 'pg_sleep', provolatile => 'v', prorettype => 'void',
proargtypes => 'float8', prosrc => 'pg_sleep' },
{ oid => '3935', descr => 'sleep for the specified interval',
proname => 'pg_sleep_for', prolang => '14', provolatile => 'v',
prorettype => 'void', proargtypes => 'interval',
prosrc => 'select pg_catalog.pg_sleep(extract(epoch from pg_catalog.clock_timestamp() operator(pg_catalog.+) $1) operator(pg_catalog.-) extract(epoch from pg_catalog.clock_timestamp()))' },
{ oid => '3936', descr => 'sleep until the specified time',
proname => 'pg_sleep_until', prolang => '14', provolatile => 'v',
prorettype => 'void', proargtypes => 'timestamptz',
prosrc => 'select pg_catalog.pg_sleep(extract(epoch from $1) operator(pg_catalog.-) extract(epoch from pg_catalog.clock_timestamp()))' },
{ oid => '315', descr => 'Is JIT compilation available in this session?',
proname => 'pg_jit_available', provolatile => 'v', prorettype => 'bool',
proargtypes => '', prosrc => 'pg_jit_available' },
{ oid => '2971', descr => 'convert boolean to text',
proname => 'text', prorettype => 'text', proargtypes => 'bool',
prosrc => 'booltext' },
# Aggregates (moved here from pg_aggregate for 7.3)
{ oid => '2100',
descr => 'the average (arithmetic mean) as numeric of all bigint values',
proname => 'avg', prokind => 'a', proisstrict => 'f', prorettype => 'numeric',
proargtypes => 'int8', prosrc => 'aggregate_dummy' },
{ oid => '2101',
descr => 'the average (arithmetic mean) as numeric of all integer values',
proname => 'avg', prokind => 'a', proisstrict => 'f', prorettype => 'numeric',
proargtypes => 'int4', prosrc => 'aggregate_dummy' },
{ oid => '2102',
descr => 'the average (arithmetic mean) as numeric of all smallint values',
proname => 'avg', prokind => 'a', proisstrict => 'f', prorettype => 'numeric',
proargtypes => 'int2', prosrc => 'aggregate_dummy' },
{ oid => '2103',
descr => 'the average (arithmetic mean) as numeric of all numeric values',
proname => 'avg', prokind => 'a', proisstrict => 'f', prorettype => 'numeric',
proargtypes => 'numeric', prosrc => 'aggregate_dummy' },
{ oid => '2104',
descr => 'the average (arithmetic mean) as float8 of all float4 values',
proname => 'avg', prokind => 'a', proisstrict => 'f', prorettype => 'float8',
proargtypes => 'float4', prosrc => 'aggregate_dummy' },
{ oid => '2105',
descr => 'the average (arithmetic mean) as float8 of all float8 values',
proname => 'avg', prokind => 'a', proisstrict => 'f', prorettype => 'float8',
proargtypes => 'float8', prosrc => 'aggregate_dummy' },
{ oid => '2106',
descr => 'the average (arithmetic mean) as interval of all interval values',
proname => 'avg', prokind => 'a', proisstrict => 'f',
prorettype => 'interval', proargtypes => 'interval',
prosrc => 'aggregate_dummy' },
{ oid => '2107', descr => 'sum as numeric across all bigint input values',
proname => 'sum', prokind => 'a', proisstrict => 'f', prorettype => 'numeric',
proargtypes => 'int8', prosrc => 'aggregate_dummy' },
{ oid => '2108', descr => 'sum as bigint across all integer input values',
proname => 'sum', prokind => 'a', proisstrict => 'f', prorettype => 'int8',
proargtypes => 'int4', prosrc => 'aggregate_dummy' },
{ oid => '2109', descr => 'sum as bigint across all smallint input values',
proname => 'sum', prokind => 'a', proisstrict => 'f', prorettype => 'int8',
proargtypes => 'int2', prosrc => 'aggregate_dummy' },
{ oid => '2110', descr => 'sum as float4 across all float4 input values',
proname => 'sum', prokind => 'a', proisstrict => 'f', prorettype => 'float4',
proargtypes => 'float4', prosrc => 'aggregate_dummy' },
{ oid => '2111', descr => 'sum as float8 across all float8 input values',
proname => 'sum', prokind => 'a', proisstrict => 'f', prorettype => 'float8',
proargtypes => 'float8', prosrc => 'aggregate_dummy' },
{ oid => '2112', descr => 'sum as money across all money input values',
proname => 'sum', prokind => 'a', proisstrict => 'f', prorettype => 'money',
proargtypes => 'money', prosrc => 'aggregate_dummy' },
{ oid => '2113', descr => 'sum as interval across all interval input values',
proname => 'sum', prokind => 'a', proisstrict => 'f',
prorettype => 'interval', proargtypes => 'interval',
prosrc => 'aggregate_dummy' },
{ oid => '2114', descr => 'sum as numeric across all numeric input values',
proname => 'sum', prokind => 'a', proisstrict => 'f', prorettype => 'numeric',
proargtypes => 'numeric', prosrc => 'aggregate_dummy' },
{ oid => '2115', descr => 'maximum value of all bigint input values',
proname => 'max', prokind => 'a', proisstrict => 'f', prorettype => 'int8',
proargtypes => 'int8', prosrc => 'aggregate_dummy' },
{ oid => '2116', descr => 'maximum value of all integer input values',
proname => 'max', prokind => 'a', proisstrict => 'f', prorettype => 'int4',
proargtypes => 'int4', prosrc => 'aggregate_dummy' },
{ oid => '2117', descr => 'maximum value of all smallint input values',
proname => 'max', prokind => 'a', proisstrict => 'f', prorettype => 'int2',
proargtypes => 'int2', prosrc => 'aggregate_dummy' },
{ oid => '2118', descr => 'maximum value of all oid input values',
proname => 'max', prokind => 'a', proisstrict => 'f', prorettype => 'oid',
proargtypes => 'oid', prosrc => 'aggregate_dummy' },
{ oid => '2119', descr => 'maximum value of all float4 input values',
proname => 'max', prokind => 'a', proisstrict => 'f', prorettype => 'float4',
proargtypes => 'float4', prosrc => 'aggregate_dummy' },
{ oid => '2120', descr => 'maximum value of all float8 input values',
proname => 'max', prokind => 'a', proisstrict => 'f', prorettype => 'float8',
proargtypes => 'float8', prosrc => 'aggregate_dummy' },
{ oid => '2122', descr => 'maximum value of all date input values',
proname => 'max', prokind => 'a', proisstrict => 'f', prorettype => 'date',
proargtypes => 'date', prosrc => 'aggregate_dummy' },
{ oid => '2123', descr => 'maximum value of all time input values',
proname => 'max', prokind => 'a', proisstrict => 'f', prorettype => 'time',
proargtypes => 'time', prosrc => 'aggregate_dummy' },
{ oid => '2124',
descr => 'maximum value of all time with time zone input values',
proname => 'max', prokind => 'a', proisstrict => 'f', prorettype => 'timetz',
proargtypes => 'timetz', prosrc => 'aggregate_dummy' },
{ oid => '2125', descr => 'maximum value of all money input values',
proname => 'max', prokind => 'a', proisstrict => 'f', prorettype => 'money',
proargtypes => 'money', prosrc => 'aggregate_dummy' },
{ oid => '2126', descr => 'maximum value of all timestamp input values',
proname => 'max', prokind => 'a', proisstrict => 'f',
prorettype => 'timestamp', proargtypes => 'timestamp',
prosrc => 'aggregate_dummy' },
{ oid => '2127',
descr => 'maximum value of all timestamp with time zone input values',
proname => 'max', prokind => 'a', proisstrict => 'f',
prorettype => 'timestamptz', proargtypes => 'timestamptz',
prosrc => 'aggregate_dummy' },
{ oid => '2128', descr => 'maximum value of all interval input values',
proname => 'max', prokind => 'a', proisstrict => 'f',
prorettype => 'interval', proargtypes => 'interval',
prosrc => 'aggregate_dummy' },
{ oid => '2129', descr => 'maximum value of all text input values',
proname => 'max', prokind => 'a', proisstrict => 'f', prorettype => 'text',
proargtypes => 'text', prosrc => 'aggregate_dummy' },
{ oid => '2130', descr => 'maximum value of all numeric input values',
proname => 'max', prokind => 'a', proisstrict => 'f', prorettype => 'numeric',
proargtypes => 'numeric', prosrc => 'aggregate_dummy' },
{ oid => '2050', descr => 'maximum value of all anyarray input values',
proname => 'max', prokind => 'a', proisstrict => 'f',
prorettype => 'anyarray', proargtypes => 'anyarray',
prosrc => 'aggregate_dummy' },
{ oid => '2244', descr => 'maximum value of all bpchar input values',
proname => 'max', prokind => 'a', proisstrict => 'f', prorettype => 'bpchar',
proargtypes => 'bpchar', prosrc => 'aggregate_dummy' },
{ oid => '2797', descr => 'maximum value of all tid input values',
proname => 'max', prokind => 'a', proisstrict => 'f', prorettype => 'tid',
proargtypes => 'tid', prosrc => 'aggregate_dummy' },
{ oid => '3564', descr => 'maximum value of all inet input values',
proname => 'max', prokind => 'a', proisstrict => 'f', prorettype => 'inet',
proargtypes => 'inet', prosrc => 'aggregate_dummy' },
{ oid => '2131', descr => 'minimum value of all bigint input values',
proname => 'min', prokind => 'a', proisstrict => 'f', prorettype => 'int8',
proargtypes => 'int8', prosrc => 'aggregate_dummy' },
{ oid => '2132', descr => 'minimum value of all integer input values',
proname => 'min', prokind => 'a', proisstrict => 'f', prorettype => 'int4',
proargtypes => 'int4', prosrc => 'aggregate_dummy' },
{ oid => '2133', descr => 'minimum value of all smallint input values',
proname => 'min', prokind => 'a', proisstrict => 'f', prorettype => 'int2',
proargtypes => 'int2', prosrc => 'aggregate_dummy' },
{ oid => '2134', descr => 'minimum value of all oid input values',
proname => 'min', prokind => 'a', proisstrict => 'f', prorettype => 'oid',
proargtypes => 'oid', prosrc => 'aggregate_dummy' },
{ oid => '2135', descr => 'minimum value of all float4 input values',
proname => 'min', prokind => 'a', proisstrict => 'f', prorettype => 'float4',
proargtypes => 'float4', prosrc => 'aggregate_dummy' },
{ oid => '2136', descr => 'minimum value of all float8 input values',
proname => 'min', prokind => 'a', proisstrict => 'f', prorettype => 'float8',
proargtypes => 'float8', prosrc => 'aggregate_dummy' },
{ oid => '2138', descr => 'minimum value of all date input values',
proname => 'min', prokind => 'a', proisstrict => 'f', prorettype => 'date',
proargtypes => 'date', prosrc => 'aggregate_dummy' },
{ oid => '2139', descr => 'minimum value of all time input values',
proname => 'min', prokind => 'a', proisstrict => 'f', prorettype => 'time',
proargtypes => 'time', prosrc => 'aggregate_dummy' },
{ oid => '2140',
descr => 'minimum value of all time with time zone input values',
proname => 'min', prokind => 'a', proisstrict => 'f', prorettype => 'timetz',
proargtypes => 'timetz', prosrc => 'aggregate_dummy' },
{ oid => '2141', descr => 'minimum value of all money input values',
proname => 'min', prokind => 'a', proisstrict => 'f', prorettype => 'money',
proargtypes => 'money', prosrc => 'aggregate_dummy' },
{ oid => '2142', descr => 'minimum value of all timestamp input values',
proname => 'min', prokind => 'a', proisstrict => 'f',
prorettype => 'timestamp', proargtypes => 'timestamp',
prosrc => 'aggregate_dummy' },
{ oid => '2143',
descr => 'minimum value of all timestamp with time zone input values',
proname => 'min', prokind => 'a', proisstrict => 'f',
prorettype => 'timestamptz', proargtypes => 'timestamptz',
prosrc => 'aggregate_dummy' },
{ oid => '2144', descr => 'minimum value of all interval input values',
proname => 'min', prokind => 'a', proisstrict => 'f',
prorettype => 'interval', proargtypes => 'interval',
prosrc => 'aggregate_dummy' },
{ oid => '2145', descr => 'minimum value of all text values',
proname => 'min', prokind => 'a', proisstrict => 'f', prorettype => 'text',
proargtypes => 'text', prosrc => 'aggregate_dummy' },
{ oid => '2146', descr => 'minimum value of all numeric input values',
proname => 'min', prokind => 'a', proisstrict => 'f', prorettype => 'numeric',
proargtypes => 'numeric', prosrc => 'aggregate_dummy' },
{ oid => '2051', descr => 'minimum value of all anyarray input values',
proname => 'min', prokind => 'a', proisstrict => 'f',
prorettype => 'anyarray', proargtypes => 'anyarray',
prosrc => 'aggregate_dummy' },
{ oid => '2245', descr => 'minimum value of all bpchar input values',
proname => 'min', prokind => 'a', proisstrict => 'f', prorettype => 'bpchar',
proargtypes => 'bpchar', prosrc => 'aggregate_dummy' },
{ oid => '2798', descr => 'minimum value of all tid input values',
proname => 'min', prokind => 'a', proisstrict => 'f', prorettype => 'tid',
proargtypes => 'tid', prosrc => 'aggregate_dummy' },
{ oid => '3565', descr => 'minimum value of all inet input values',
proname => 'min', prokind => 'a', proisstrict => 'f', prorettype => 'inet',
proargtypes => 'inet', prosrc => 'aggregate_dummy' },
# count has two forms: count(any) and count(*)
{ oid => '2147',
descr => 'number of input rows for which the input expression is not null',
proname => 'count', prokind => 'a', proisstrict => 'f', prorettype => 'int8',
proargtypes => 'any', prosrc => 'aggregate_dummy' },
{ oid => '2803', descr => 'number of input rows',
proname => 'count', prokind => 'a', proisstrict => 'f', prorettype => 'int8',
proargtypes => '', prosrc => 'aggregate_dummy' },
{ oid => '2718',
descr => 'population variance of bigint input values (square of the population standard deviation)',
proname => 'var_pop', prokind => 'a', proisstrict => 'f',
prorettype => 'numeric', proargtypes => 'int8', prosrc => 'aggregate_dummy' },
{ oid => '2719',
descr => 'population variance of integer input values (square of the population standard deviation)',
proname => 'var_pop', prokind => 'a', proisstrict => 'f',
prorettype => 'numeric', proargtypes => 'int4', prosrc => 'aggregate_dummy' },
{ oid => '2720',
descr => 'population variance of smallint input values (square of the population standard deviation)',
proname => 'var_pop', prokind => 'a', proisstrict => 'f',
prorettype => 'numeric', proargtypes => 'int2', prosrc => 'aggregate_dummy' },
{ oid => '2721',
descr => 'population variance of float4 input values (square of the population standard deviation)',
proname => 'var_pop', prokind => 'a', proisstrict => 'f',
prorettype => 'float8', proargtypes => 'float4',
prosrc => 'aggregate_dummy' },
{ oid => '2722',
descr => 'population variance of float8 input values (square of the population standard deviation)',
proname => 'var_pop', prokind => 'a', proisstrict => 'f',
prorettype => 'float8', proargtypes => 'float8',
prosrc => 'aggregate_dummy' },
{ oid => '2723',
descr => 'population variance of numeric input values (square of the population standard deviation)',
proname => 'var_pop', prokind => 'a', proisstrict => 'f',
prorettype => 'numeric', proargtypes => 'numeric',
prosrc => 'aggregate_dummy' },
{ oid => '2641',
descr => 'sample variance of bigint input values (square of the sample standard deviation)',
proname => 'var_samp', prokind => 'a', proisstrict => 'f',
prorettype => 'numeric', proargtypes => 'int8', prosrc => 'aggregate_dummy' },
{ oid => '2642',
descr => 'sample variance of integer input values (square of the sample standard deviation)',
proname => 'var_samp', prokind => 'a', proisstrict => 'f',
prorettype => 'numeric', proargtypes => 'int4', prosrc => 'aggregate_dummy' },
{ oid => '2643',
descr => 'sample variance of smallint input values (square of the sample standard deviation)',
proname => 'var_samp', prokind => 'a', proisstrict => 'f',
prorettype => 'numeric', proargtypes => 'int2', prosrc => 'aggregate_dummy' },
{ oid => '2644',
descr => 'sample variance of float4 input values (square of the sample standard deviation)',
proname => 'var_samp', prokind => 'a', proisstrict => 'f',
prorettype => 'float8', proargtypes => 'float4',
prosrc => 'aggregate_dummy' },
{ oid => '2645',
descr => 'sample variance of float8 input values (square of the sample standard deviation)',
proname => 'var_samp', prokind => 'a', proisstrict => 'f',
prorettype => 'float8', proargtypes => 'float8',
prosrc => 'aggregate_dummy' },
{ oid => '2646',
descr => 'sample variance of numeric input values (square of the sample standard deviation)',
proname => 'var_samp', prokind => 'a', proisstrict => 'f',
prorettype => 'numeric', proargtypes => 'numeric',
prosrc => 'aggregate_dummy' },
{ oid => '2148', descr => 'historical alias for var_samp',
proname => 'variance', prokind => 'a', proisstrict => 'f',
prorettype => 'numeric', proargtypes => 'int8', prosrc => 'aggregate_dummy' },
{ oid => '2149', descr => 'historical alias for var_samp',
proname => 'variance', prokind => 'a', proisstrict => 'f',
prorettype => 'numeric', proargtypes => 'int4', prosrc => 'aggregate_dummy' },
{ oid => '2150', descr => 'historical alias for var_samp',
proname => 'variance', prokind => 'a', proisstrict => 'f',
prorettype => 'numeric', proargtypes => 'int2', prosrc => 'aggregate_dummy' },
{ oid => '2151', descr => 'historical alias for var_samp',
proname => 'variance', prokind => 'a', proisstrict => 'f',
prorettype => 'float8', proargtypes => 'float4',
prosrc => 'aggregate_dummy' },
{ oid => '2152', descr => 'historical alias for var_samp',
proname => 'variance', prokind => 'a', proisstrict => 'f',
prorettype => 'float8', proargtypes => 'float8',
prosrc => 'aggregate_dummy' },
{ oid => '2153', descr => 'historical alias for var_samp',
proname => 'variance', prokind => 'a', proisstrict => 'f',
prorettype => 'numeric', proargtypes => 'numeric',
prosrc => 'aggregate_dummy' },
{ oid => '2724',
descr => 'population standard deviation of bigint input values',
proname => 'stddev_pop', prokind => 'a', proisstrict => 'f',
prorettype => 'numeric', proargtypes => 'int8', prosrc => 'aggregate_dummy' },
{ oid => '2725',
descr => 'population standard deviation of integer input values',
proname => 'stddev_pop', prokind => 'a', proisstrict => 'f',
prorettype => 'numeric', proargtypes => 'int4', prosrc => 'aggregate_dummy' },
{ oid => '2726',
descr => 'population standard deviation of smallint input values',
proname => 'stddev_pop', prokind => 'a', proisstrict => 'f',
prorettype => 'numeric', proargtypes => 'int2', prosrc => 'aggregate_dummy' },
{ oid => '2727',
descr => 'population standard deviation of float4 input values',
proname => 'stddev_pop', prokind => 'a', proisstrict => 'f',
prorettype => 'float8', proargtypes => 'float4',
prosrc => 'aggregate_dummy' },
{ oid => '2728',
descr => 'population standard deviation of float8 input values',
proname => 'stddev_pop', prokind => 'a', proisstrict => 'f',
prorettype => 'float8', proargtypes => 'float8',
prosrc => 'aggregate_dummy' },
{ oid => '2729',
descr => 'population standard deviation of numeric input values',
proname => 'stddev_pop', prokind => 'a', proisstrict => 'f',
prorettype => 'numeric', proargtypes => 'numeric',
prosrc => 'aggregate_dummy' },
{ oid => '2712', descr => 'sample standard deviation of bigint input values',
proname => 'stddev_samp', prokind => 'a', proisstrict => 'f',
prorettype => 'numeric', proargtypes => 'int8', prosrc => 'aggregate_dummy' },
{ oid => '2713', descr => 'sample standard deviation of integer input values',
proname => 'stddev_samp', prokind => 'a', proisstrict => 'f',
prorettype => 'numeric', proargtypes => 'int4', prosrc => 'aggregate_dummy' },
{ oid => '2714',
descr => 'sample standard deviation of smallint input values',
proname => 'stddev_samp', prokind => 'a', proisstrict => 'f',
prorettype => 'numeric', proargtypes => 'int2', prosrc => 'aggregate_dummy' },
{ oid => '2715', descr => 'sample standard deviation of float4 input values',
proname => 'stddev_samp', prokind => 'a', proisstrict => 'f',
prorettype => 'float8', proargtypes => 'float4',
prosrc => 'aggregate_dummy' },
{ oid => '2716', descr => 'sample standard deviation of float8 input values',
proname => 'stddev_samp', prokind => 'a', proisstrict => 'f',
prorettype => 'float8', proargtypes => 'float8',
prosrc => 'aggregate_dummy' },
{ oid => '2717', descr => 'sample standard deviation of numeric input values',
proname => 'stddev_samp', prokind => 'a', proisstrict => 'f',
prorettype => 'numeric', proargtypes => 'numeric',
prosrc => 'aggregate_dummy' },
{ oid => '2154', descr => 'historical alias for stddev_samp',
proname => 'stddev', prokind => 'a', proisstrict => 'f',
prorettype => 'numeric', proargtypes => 'int8', prosrc => 'aggregate_dummy' },
{ oid => '2155', descr => 'historical alias for stddev_samp',
proname => 'stddev', prokind => 'a', proisstrict => 'f',
prorettype => 'numeric', proargtypes => 'int4', prosrc => 'aggregate_dummy' },
{ oid => '2156', descr => 'historical alias for stddev_samp',
proname => 'stddev', prokind => 'a', proisstrict => 'f',
prorettype => 'numeric', proargtypes => 'int2', prosrc => 'aggregate_dummy' },
{ oid => '2157', descr => 'historical alias for stddev_samp',
proname => 'stddev', prokind => 'a', proisstrict => 'f',
prorettype => 'float8', proargtypes => 'float4',
prosrc => 'aggregate_dummy' },
{ oid => '2158', descr => 'historical alias for stddev_samp',
proname => 'stddev', prokind => 'a', proisstrict => 'f',
prorettype => 'float8', proargtypes => 'float8',
prosrc => 'aggregate_dummy' },
{ oid => '2159', descr => 'historical alias for stddev_samp',
proname => 'stddev', prokind => 'a', proisstrict => 'f',
prorettype => 'numeric', proargtypes => 'numeric',
prosrc => 'aggregate_dummy' },
{ oid => '2818',
descr => 'number of input rows in which both expressions are not null',
proname => 'regr_count', prokind => 'a', proisstrict => 'f',
prorettype => 'int8', proargtypes => 'float8 float8',
prosrc => 'aggregate_dummy' },
{ oid => '2819',
descr => 'sum of squares of the independent variable (sum(X^2) - sum(X)^2/N)',
proname => 'regr_sxx', prokind => 'a', proisstrict => 'f',
prorettype => 'float8', proargtypes => 'float8 float8',
prosrc => 'aggregate_dummy' },
{ oid => '2820',
descr => 'sum of squares of the dependent variable (sum(Y^2) - sum(Y)^2/N)',
proname => 'regr_syy', prokind => 'a', proisstrict => 'f',
prorettype => 'float8', proargtypes => 'float8 float8',
prosrc => 'aggregate_dummy' },
{ oid => '2821',
descr => 'sum of products of independent times dependent variable (sum(X*Y) - sum(X) * sum(Y)/N)',
proname => 'regr_sxy', prokind => 'a', proisstrict => 'f',
prorettype => 'float8', proargtypes => 'float8 float8',
prosrc => 'aggregate_dummy' },
{ oid => '2822', descr => 'average of the independent variable (sum(X)/N)',
proname => 'regr_avgx', prokind => 'a', proisstrict => 'f',
prorettype => 'float8', proargtypes => 'float8 float8',
prosrc => 'aggregate_dummy' },
{ oid => '2823', descr => 'average of the dependent variable (sum(Y)/N)',
proname => 'regr_avgy', prokind => 'a', proisstrict => 'f',
prorettype => 'float8', proargtypes => 'float8 float8',
prosrc => 'aggregate_dummy' },
{ oid => '2824', descr => 'square of the correlation coefficient',
proname => 'regr_r2', prokind => 'a', proisstrict => 'f',
prorettype => 'float8', proargtypes => 'float8 float8',
prosrc => 'aggregate_dummy' },
{ oid => '2825',
descr => 'slope of the least-squares-fit linear equation determined by the (X, Y) pairs',
proname => 'regr_slope', prokind => 'a', proisstrict => 'f',
prorettype => 'float8', proargtypes => 'float8 float8',
prosrc => 'aggregate_dummy' },
{ oid => '2826',
descr => 'y-intercept of the least-squares-fit linear equation determined by the (X, Y) pairs',
proname => 'regr_intercept', prokind => 'a', proisstrict => 'f',
prorettype => 'float8', proargtypes => 'float8 float8',
prosrc => 'aggregate_dummy' },
{ oid => '2827', descr => 'population covariance',
proname => 'covar_pop', prokind => 'a', proisstrict => 'f',
prorettype => 'float8', proargtypes => 'float8 float8',
prosrc => 'aggregate_dummy' },
{ oid => '2828', descr => 'sample covariance',
proname => 'covar_samp', prokind => 'a', proisstrict => 'f',
prorettype => 'float8', proargtypes => 'float8 float8',
prosrc => 'aggregate_dummy' },
{ oid => '2829', descr => 'correlation coefficient',
proname => 'corr', prokind => 'a', proisstrict => 'f', prorettype => 'float8',
proargtypes => 'float8 float8', prosrc => 'aggregate_dummy' },
{ oid => '2160',
proname => 'text_pattern_lt', prorettype => 'bool',
proargtypes => 'text text', prosrc => 'text_pattern_lt' },
{ oid => '2161',
proname => 'text_pattern_le', prorettype => 'bool',
proargtypes => 'text text', prosrc => 'text_pattern_le' },
{ oid => '2163',
proname => 'text_pattern_ge', prorettype => 'bool',
proargtypes => 'text text', prosrc => 'text_pattern_ge' },
{ oid => '2164',
proname => 'text_pattern_gt', prorettype => 'bool',
proargtypes => 'text text', prosrc => 'text_pattern_gt' },
{ oid => '2166', descr => 'less-equal-greater',
proname => 'bttext_pattern_cmp', prorettype => 'int4',
proargtypes => 'text text', prosrc => 'bttext_pattern_cmp' },
{ oid => '3332', descr => 'sort support',
proname => 'bttext_pattern_sortsupport', prorettype => 'void',
proargtypes => 'internal', prosrc => 'bttext_pattern_sortsupport' },
{ oid => '2174',
proname => 'bpchar_pattern_lt', prorettype => 'bool',
proargtypes => 'bpchar bpchar', prosrc => 'bpchar_pattern_lt' },
{ oid => '2175',
proname => 'bpchar_pattern_le', prorettype => 'bool',
proargtypes => 'bpchar bpchar', prosrc => 'bpchar_pattern_le' },
{ oid => '2177',
proname => 'bpchar_pattern_ge', prorettype => 'bool',
proargtypes => 'bpchar bpchar', prosrc => 'bpchar_pattern_ge' },
{ oid => '2178',
proname => 'bpchar_pattern_gt', prorettype => 'bool',
proargtypes => 'bpchar bpchar', prosrc => 'bpchar_pattern_gt' },
{ oid => '2180', descr => 'less-equal-greater',
proname => 'btbpchar_pattern_cmp', prorettype => 'int4',
proargtypes => 'bpchar bpchar', prosrc => 'btbpchar_pattern_cmp' },
{ oid => '3333', descr => 'sort support',
proname => 'btbpchar_pattern_sortsupport', prorettype => 'void',
proargtypes => 'internal', prosrc => 'btbpchar_pattern_sortsupport' },
{ oid => '2188', descr => 'less-equal-greater',
Mark built-in btree comparison functions as leakproof where it's safe. Generally, if the comparison operators for a datatype or pair of datatypes are leakproof, the corresponding btree comparison support function can be considered so as well. But we had not originally worried about marking support functions as leakproof, reasoning that they'd not likely be used in queries so the marking wouldn't matter. It turns out there's at least one place where it does matter: calc_arraycontsel() finds the target datatype's default btree comparison function and tries to use that to estimate selectivity, but it will be blocked in some cases if the function isn't leakproof. This leads to unnecessarily poor selectivity estimates and bad plans, as seen in bug #15251. Hence, run around and apply proleakproof markings where the corresponding btree comparison operators are leakproof. (I did eyeball each function to verify that it wasn't doing anything surprising, too.) This isn't a full solution to bug #15251, and it's not back-patchable because of the need for a catversion bump. A more useful response probably is to consider whether we can check permissions on the parent table instead of the child. However, this change will help in some cases where that won't, and it's easy enough to do in HEAD, so let's do so. Discussion: https://postgr.es/m/3876.1531261875@sss.pgh.pa.us
2018-07-12 00:47:31 +02:00
proname => 'btint48cmp', proleakproof => 't', prorettype => 'int4',
proargtypes => 'int4 int8', prosrc => 'btint48cmp' },
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
{ oid => '2189', descr => 'less-equal-greater',
Mark built-in btree comparison functions as leakproof where it's safe. Generally, if the comparison operators for a datatype or pair of datatypes are leakproof, the corresponding btree comparison support function can be considered so as well. But we had not originally worried about marking support functions as leakproof, reasoning that they'd not likely be used in queries so the marking wouldn't matter. It turns out there's at least one place where it does matter: calc_arraycontsel() finds the target datatype's default btree comparison function and tries to use that to estimate selectivity, but it will be blocked in some cases if the function isn't leakproof. This leads to unnecessarily poor selectivity estimates and bad plans, as seen in bug #15251. Hence, run around and apply proleakproof markings where the corresponding btree comparison operators are leakproof. (I did eyeball each function to verify that it wasn't doing anything surprising, too.) This isn't a full solution to bug #15251, and it's not back-patchable because of the need for a catversion bump. A more useful response probably is to consider whether we can check permissions on the parent table instead of the child. However, this change will help in some cases where that won't, and it's easy enough to do in HEAD, so let's do so. Discussion: https://postgr.es/m/3876.1531261875@sss.pgh.pa.us
2018-07-12 00:47:31 +02:00
proname => 'btint84cmp', proleakproof => 't', prorettype => 'int4',
proargtypes => 'int8 int4', prosrc => 'btint84cmp' },
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
{ oid => '2190', descr => 'less-equal-greater',
Mark built-in btree comparison functions as leakproof where it's safe. Generally, if the comparison operators for a datatype or pair of datatypes are leakproof, the corresponding btree comparison support function can be considered so as well. But we had not originally worried about marking support functions as leakproof, reasoning that they'd not likely be used in queries so the marking wouldn't matter. It turns out there's at least one place where it does matter: calc_arraycontsel() finds the target datatype's default btree comparison function and tries to use that to estimate selectivity, but it will be blocked in some cases if the function isn't leakproof. This leads to unnecessarily poor selectivity estimates and bad plans, as seen in bug #15251. Hence, run around and apply proleakproof markings where the corresponding btree comparison operators are leakproof. (I did eyeball each function to verify that it wasn't doing anything surprising, too.) This isn't a full solution to bug #15251, and it's not back-patchable because of the need for a catversion bump. A more useful response probably is to consider whether we can check permissions on the parent table instead of the child. However, this change will help in some cases where that won't, and it's easy enough to do in HEAD, so let's do so. Discussion: https://postgr.es/m/3876.1531261875@sss.pgh.pa.us
2018-07-12 00:47:31 +02:00
proname => 'btint24cmp', proleakproof => 't', prorettype => 'int4',
proargtypes => 'int2 int4', prosrc => 'btint24cmp' },
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
{ oid => '2191', descr => 'less-equal-greater',
Mark built-in btree comparison functions as leakproof where it's safe. Generally, if the comparison operators for a datatype or pair of datatypes are leakproof, the corresponding btree comparison support function can be considered so as well. But we had not originally worried about marking support functions as leakproof, reasoning that they'd not likely be used in queries so the marking wouldn't matter. It turns out there's at least one place where it does matter: calc_arraycontsel() finds the target datatype's default btree comparison function and tries to use that to estimate selectivity, but it will be blocked in some cases if the function isn't leakproof. This leads to unnecessarily poor selectivity estimates and bad plans, as seen in bug #15251. Hence, run around and apply proleakproof markings where the corresponding btree comparison operators are leakproof. (I did eyeball each function to verify that it wasn't doing anything surprising, too.) This isn't a full solution to bug #15251, and it's not back-patchable because of the need for a catversion bump. A more useful response probably is to consider whether we can check permissions on the parent table instead of the child. However, this change will help in some cases where that won't, and it's easy enough to do in HEAD, so let's do so. Discussion: https://postgr.es/m/3876.1531261875@sss.pgh.pa.us
2018-07-12 00:47:31 +02:00
proname => 'btint42cmp', proleakproof => 't', prorettype => 'int4',
proargtypes => 'int4 int2', prosrc => 'btint42cmp' },
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
{ oid => '2192', descr => 'less-equal-greater',
Mark built-in btree comparison functions as leakproof where it's safe. Generally, if the comparison operators for a datatype or pair of datatypes are leakproof, the corresponding btree comparison support function can be considered so as well. But we had not originally worried about marking support functions as leakproof, reasoning that they'd not likely be used in queries so the marking wouldn't matter. It turns out there's at least one place where it does matter: calc_arraycontsel() finds the target datatype's default btree comparison function and tries to use that to estimate selectivity, but it will be blocked in some cases if the function isn't leakproof. This leads to unnecessarily poor selectivity estimates and bad plans, as seen in bug #15251. Hence, run around and apply proleakproof markings where the corresponding btree comparison operators are leakproof. (I did eyeball each function to verify that it wasn't doing anything surprising, too.) This isn't a full solution to bug #15251, and it's not back-patchable because of the need for a catversion bump. A more useful response probably is to consider whether we can check permissions on the parent table instead of the child. However, this change will help in some cases where that won't, and it's easy enough to do in HEAD, so let's do so. Discussion: https://postgr.es/m/3876.1531261875@sss.pgh.pa.us
2018-07-12 00:47:31 +02:00
proname => 'btint28cmp', proleakproof => 't', prorettype => 'int4',
proargtypes => 'int2 int8', prosrc => 'btint28cmp' },
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
{ oid => '2193', descr => 'less-equal-greater',
Mark built-in btree comparison functions as leakproof where it's safe. Generally, if the comparison operators for a datatype or pair of datatypes are leakproof, the corresponding btree comparison support function can be considered so as well. But we had not originally worried about marking support functions as leakproof, reasoning that they'd not likely be used in queries so the marking wouldn't matter. It turns out there's at least one place where it does matter: calc_arraycontsel() finds the target datatype's default btree comparison function and tries to use that to estimate selectivity, but it will be blocked in some cases if the function isn't leakproof. This leads to unnecessarily poor selectivity estimates and bad plans, as seen in bug #15251. Hence, run around and apply proleakproof markings where the corresponding btree comparison operators are leakproof. (I did eyeball each function to verify that it wasn't doing anything surprising, too.) This isn't a full solution to bug #15251, and it's not back-patchable because of the need for a catversion bump. A more useful response probably is to consider whether we can check permissions on the parent table instead of the child. However, this change will help in some cases where that won't, and it's easy enough to do in HEAD, so let's do so. Discussion: https://postgr.es/m/3876.1531261875@sss.pgh.pa.us
2018-07-12 00:47:31 +02:00
proname => 'btint82cmp', proleakproof => 't', prorettype => 'int4',
proargtypes => 'int8 int2', prosrc => 'btint82cmp' },
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
{ oid => '2194', descr => 'less-equal-greater',
Mark built-in btree comparison functions as leakproof where it's safe. Generally, if the comparison operators for a datatype or pair of datatypes are leakproof, the corresponding btree comparison support function can be considered so as well. But we had not originally worried about marking support functions as leakproof, reasoning that they'd not likely be used in queries so the marking wouldn't matter. It turns out there's at least one place where it does matter: calc_arraycontsel() finds the target datatype's default btree comparison function and tries to use that to estimate selectivity, but it will be blocked in some cases if the function isn't leakproof. This leads to unnecessarily poor selectivity estimates and bad plans, as seen in bug #15251. Hence, run around and apply proleakproof markings where the corresponding btree comparison operators are leakproof. (I did eyeball each function to verify that it wasn't doing anything surprising, too.) This isn't a full solution to bug #15251, and it's not back-patchable because of the need for a catversion bump. A more useful response probably is to consider whether we can check permissions on the parent table instead of the child. However, this change will help in some cases where that won't, and it's easy enough to do in HEAD, so let's do so. Discussion: https://postgr.es/m/3876.1531261875@sss.pgh.pa.us
2018-07-12 00:47:31 +02:00
proname => 'btfloat48cmp', proleakproof => 't', prorettype => 'int4',
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
proargtypes => 'float4 float8', prosrc => 'btfloat48cmp' },
{ oid => '2195', descr => 'less-equal-greater',
Mark built-in btree comparison functions as leakproof where it's safe. Generally, if the comparison operators for a datatype or pair of datatypes are leakproof, the corresponding btree comparison support function can be considered so as well. But we had not originally worried about marking support functions as leakproof, reasoning that they'd not likely be used in queries so the marking wouldn't matter. It turns out there's at least one place where it does matter: calc_arraycontsel() finds the target datatype's default btree comparison function and tries to use that to estimate selectivity, but it will be blocked in some cases if the function isn't leakproof. This leads to unnecessarily poor selectivity estimates and bad plans, as seen in bug #15251. Hence, run around and apply proleakproof markings where the corresponding btree comparison operators are leakproof. (I did eyeball each function to verify that it wasn't doing anything surprising, too.) This isn't a full solution to bug #15251, and it's not back-patchable because of the need for a catversion bump. A more useful response probably is to consider whether we can check permissions on the parent table instead of the child. However, this change will help in some cases where that won't, and it's easy enough to do in HEAD, so let's do so. Discussion: https://postgr.es/m/3876.1531261875@sss.pgh.pa.us
2018-07-12 00:47:31 +02:00
proname => 'btfloat84cmp', proleakproof => 't', prorettype => 'int4',
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
proargtypes => 'float8 float4', prosrc => 'btfloat84cmp' },
{ oid => '2212', descr => 'I/O',
proname => 'regprocedurein', provolatile => 's', prorettype => 'regprocedure',
proargtypes => 'cstring', prosrc => 'regprocedurein' },
{ oid => '2213', descr => 'I/O',
proname => 'regprocedureout', provolatile => 's', prorettype => 'cstring',
proargtypes => 'regprocedure', prosrc => 'regprocedureout' },
{ oid => '2214', descr => 'I/O',
proname => 'regoperin', provolatile => 's', prorettype => 'regoper',
proargtypes => 'cstring', prosrc => 'regoperin' },
{ oid => '2215', descr => 'I/O',
proname => 'regoperout', provolatile => 's', prorettype => 'cstring',
proargtypes => 'regoper', prosrc => 'regoperout' },
{ oid => '3492', descr => 'convert operator name to regoper',
proname => 'to_regoper', provolatile => 's', prorettype => 'regoper',
proargtypes => 'text', prosrc => 'to_regoper' },
{ oid => '3476', descr => 'convert operator name to regoperator',
proname => 'to_regoperator', provolatile => 's', prorettype => 'regoperator',
proargtypes => 'text', prosrc => 'to_regoperator' },
{ oid => '2216', descr => 'I/O',
proname => 'regoperatorin', provolatile => 's', prorettype => 'regoperator',
proargtypes => 'cstring', prosrc => 'regoperatorin' },
{ oid => '2217', descr => 'I/O',
proname => 'regoperatorout', provolatile => 's', prorettype => 'cstring',
proargtypes => 'regoperator', prosrc => 'regoperatorout' },
{ oid => '2218', descr => 'I/O',
proname => 'regclassin', provolatile => 's', prorettype => 'regclass',
proargtypes => 'cstring', prosrc => 'regclassin' },
{ oid => '2219', descr => 'I/O',
proname => 'regclassout', provolatile => 's', prorettype => 'cstring',
proargtypes => 'regclass', prosrc => 'regclassout' },
{ oid => '3495', descr => 'convert classname to regclass',
proname => 'to_regclass', provolatile => 's', prorettype => 'regclass',
proargtypes => 'text', prosrc => 'to_regclass' },
{ oid => '2220', descr => 'I/O',
proname => 'regtypein', provolatile => 's', prorettype => 'regtype',
proargtypes => 'cstring', prosrc => 'regtypein' },
{ oid => '2221', descr => 'I/O',
proname => 'regtypeout', provolatile => 's', prorettype => 'cstring',
proargtypes => 'regtype', prosrc => 'regtypeout' },
{ oid => '3493', descr => 'convert type name to regtype',
proname => 'to_regtype', provolatile => 's', prorettype => 'regtype',
proargtypes => 'text', prosrc => 'to_regtype' },
{ oid => '1079', descr => 'convert text to regclass',
proname => 'regclass', provolatile => 's', prorettype => 'regclass',
proargtypes => 'text', prosrc => 'text_regclass' },
{ oid => '4098', descr => 'I/O',
proname => 'regrolein', provolatile => 's', prorettype => 'regrole',
proargtypes => 'cstring', prosrc => 'regrolein' },
{ oid => '4092', descr => 'I/O',
proname => 'regroleout', provolatile => 's', prorettype => 'cstring',
proargtypes => 'regrole', prosrc => 'regroleout' },
{ oid => '4093', descr => 'convert role name to regrole',
proname => 'to_regrole', provolatile => 's', prorettype => 'regrole',
proargtypes => 'text', prosrc => 'to_regrole' },
{ oid => '4084', descr => 'I/O',
proname => 'regnamespacein', provolatile => 's', prorettype => 'regnamespace',
proargtypes => 'cstring', prosrc => 'regnamespacein' },
{ oid => '4085', descr => 'I/O',
proname => 'regnamespaceout', provolatile => 's', prorettype => 'cstring',
proargtypes => 'regnamespace', prosrc => 'regnamespaceout' },
{ oid => '4086', descr => 'convert namespace name to regnamespace',
proname => 'to_regnamespace', provolatile => 's',
prorettype => 'regnamespace', proargtypes => 'text',
prosrc => 'to_regnamespace' },
{ oid => '1268',
descr => 'parse qualified identifier to array of identifiers',
proname => 'parse_ident', prorettype => '_text', proargtypes => 'text bool',
proargnames => '{str,strict}', prosrc => 'parse_ident' },
{ oid => '2246', descr => '(internal)',
proname => 'fmgr_internal_validator', provolatile => 's',
prorettype => 'void', proargtypes => 'oid',
prosrc => 'fmgr_internal_validator' },
{ oid => '2247', descr => '(internal)',
proname => 'fmgr_c_validator', provolatile => 's', prorettype => 'void',
proargtypes => 'oid', prosrc => 'fmgr_c_validator' },
{ oid => '2248', descr => '(internal)',
proname => 'fmgr_sql_validator', provolatile => 's', prorettype => 'void',
proargtypes => 'oid', prosrc => 'fmgr_sql_validator' },
{ oid => '2250',
descr => 'user privilege on database by username, database name',
proname => 'has_database_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'name text text',
prosrc => 'has_database_privilege_name_name' },
{ oid => '2251',
descr => 'user privilege on database by username, database oid',
proname => 'has_database_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'name oid text', prosrc => 'has_database_privilege_name_id' },
{ oid => '2252',
descr => 'user privilege on database by user oid, database name',
proname => 'has_database_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'oid text text', prosrc => 'has_database_privilege_id_name' },
{ oid => '2253',
descr => 'user privilege on database by user oid, database oid',
proname => 'has_database_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'oid oid text', prosrc => 'has_database_privilege_id_id' },
{ oid => '2254',
descr => 'current user privilege on database by database name',
proname => 'has_database_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'text text', prosrc => 'has_database_privilege_name' },
{ oid => '2255',
descr => 'current user privilege on database by database oid',
proname => 'has_database_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'oid text', prosrc => 'has_database_privilege_id' },
{ oid => '2256',
descr => 'user privilege on function by username, function name',
proname => 'has_function_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'name text text',
prosrc => 'has_function_privilege_name_name' },
{ oid => '2257',
descr => 'user privilege on function by username, function oid',
proname => 'has_function_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'name oid text', prosrc => 'has_function_privilege_name_id' },
{ oid => '2258',
descr => 'user privilege on function by user oid, function name',
proname => 'has_function_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'oid text text', prosrc => 'has_function_privilege_id_name' },
{ oid => '2259',
descr => 'user privilege on function by user oid, function oid',
proname => 'has_function_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'oid oid text', prosrc => 'has_function_privilege_id_id' },
{ oid => '2260',
descr => 'current user privilege on function by function name',
proname => 'has_function_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'text text', prosrc => 'has_function_privilege_name' },
{ oid => '2261',
descr => 'current user privilege on function by function oid',
proname => 'has_function_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'oid text', prosrc => 'has_function_privilege_id' },
{ oid => '2262',
descr => 'user privilege on language by username, language name',
proname => 'has_language_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'name text text',
prosrc => 'has_language_privilege_name_name' },
{ oid => '2263',
descr => 'user privilege on language by username, language oid',
proname => 'has_language_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'name oid text', prosrc => 'has_language_privilege_name_id' },
{ oid => '2264',
descr => 'user privilege on language by user oid, language name',
proname => 'has_language_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'oid text text', prosrc => 'has_language_privilege_id_name' },
{ oid => '2265',
descr => 'user privilege on language by user oid, language oid',
proname => 'has_language_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'oid oid text', prosrc => 'has_language_privilege_id_id' },
{ oid => '2266',
descr => 'current user privilege on language by language name',
proname => 'has_language_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'text text', prosrc => 'has_language_privilege_name' },
{ oid => '2267',
descr => 'current user privilege on language by language oid',
proname => 'has_language_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'oid text', prosrc => 'has_language_privilege_id' },
{ oid => '2268', descr => 'user privilege on schema by username, schema name',
proname => 'has_schema_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'name text text', prosrc => 'has_schema_privilege_name_name' },
{ oid => '2269', descr => 'user privilege on schema by username, schema oid',
proname => 'has_schema_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'name oid text', prosrc => 'has_schema_privilege_name_id' },
{ oid => '2270', descr => 'user privilege on schema by user oid, schema name',
proname => 'has_schema_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'oid text text', prosrc => 'has_schema_privilege_id_name' },
{ oid => '2271', descr => 'user privilege on schema by user oid, schema oid',
proname => 'has_schema_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'oid oid text', prosrc => 'has_schema_privilege_id_id' },
{ oid => '2272', descr => 'current user privilege on schema by schema name',
proname => 'has_schema_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'text text', prosrc => 'has_schema_privilege_name' },
{ oid => '2273', descr => 'current user privilege on schema by schema oid',
proname => 'has_schema_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'oid text', prosrc => 'has_schema_privilege_id' },
{ oid => '2390',
descr => 'user privilege on tablespace by username, tablespace name',
proname => 'has_tablespace_privilege', provolatile => 's',
prorettype => 'bool', proargtypes => 'name text text',
prosrc => 'has_tablespace_privilege_name_name' },
{ oid => '2391',
descr => 'user privilege on tablespace by username, tablespace oid',
proname => 'has_tablespace_privilege', provolatile => 's',
prorettype => 'bool', proargtypes => 'name oid text',
prosrc => 'has_tablespace_privilege_name_id' },
{ oid => '2392',
descr => 'user privilege on tablespace by user oid, tablespace name',
proname => 'has_tablespace_privilege', provolatile => 's',
prorettype => 'bool', proargtypes => 'oid text text',
prosrc => 'has_tablespace_privilege_id_name' },
{ oid => '2393',
descr => 'user privilege on tablespace by user oid, tablespace oid',
proname => 'has_tablespace_privilege', provolatile => 's',
prorettype => 'bool', proargtypes => 'oid oid text',
prosrc => 'has_tablespace_privilege_id_id' },
{ oid => '2394',
descr => 'current user privilege on tablespace by tablespace name',
proname => 'has_tablespace_privilege', provolatile => 's',
prorettype => 'bool', proargtypes => 'text text',
prosrc => 'has_tablespace_privilege_name' },
{ oid => '2395',
descr => 'current user privilege on tablespace by tablespace oid',
proname => 'has_tablespace_privilege', provolatile => 's',
prorettype => 'bool', proargtypes => 'oid text',
prosrc => 'has_tablespace_privilege_id' },
{ oid => '3000',
descr => 'user privilege on foreign data wrapper by username, foreign data wrapper name',
proname => 'has_foreign_data_wrapper_privilege', provolatile => 's',
prorettype => 'bool', proargtypes => 'name text text',
prosrc => 'has_foreign_data_wrapper_privilege_name_name' },
{ oid => '3001',
descr => 'user privilege on foreign data wrapper by username, foreign data wrapper oid',
proname => 'has_foreign_data_wrapper_privilege', provolatile => 's',
prorettype => 'bool', proargtypes => 'name oid text',
prosrc => 'has_foreign_data_wrapper_privilege_name_id' },
{ oid => '3002',
descr => 'user privilege on foreign data wrapper by user oid, foreign data wrapper name',
proname => 'has_foreign_data_wrapper_privilege', provolatile => 's',
prorettype => 'bool', proargtypes => 'oid text text',
prosrc => 'has_foreign_data_wrapper_privilege_id_name' },
{ oid => '3003',
descr => 'user privilege on foreign data wrapper by user oid, foreign data wrapper oid',
proname => 'has_foreign_data_wrapper_privilege', provolatile => 's',
prorettype => 'bool', proargtypes => 'oid oid text',
prosrc => 'has_foreign_data_wrapper_privilege_id_id' },
{ oid => '3004',
descr => 'current user privilege on foreign data wrapper by foreign data wrapper name',
proname => 'has_foreign_data_wrapper_privilege', provolatile => 's',
prorettype => 'bool', proargtypes => 'text text',
prosrc => 'has_foreign_data_wrapper_privilege_name' },
{ oid => '3005',
descr => 'current user privilege on foreign data wrapper by foreign data wrapper oid',
proname => 'has_foreign_data_wrapper_privilege', provolatile => 's',
prorettype => 'bool', proargtypes => 'oid text',
prosrc => 'has_foreign_data_wrapper_privilege_id' },
{ oid => '3006', descr => 'user privilege on server by username, server name',
proname => 'has_server_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'name text text', prosrc => 'has_server_privilege_name_name' },
{ oid => '3007', descr => 'user privilege on server by username, server oid',
proname => 'has_server_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'name oid text', prosrc => 'has_server_privilege_name_id' },
{ oid => '3008', descr => 'user privilege on server by user oid, server name',
proname => 'has_server_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'oid text text', prosrc => 'has_server_privilege_id_name' },
{ oid => '3009', descr => 'user privilege on server by user oid, server oid',
proname => 'has_server_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'oid oid text', prosrc => 'has_server_privilege_id_id' },
{ oid => '3010', descr => 'current user privilege on server by server name',
proname => 'has_server_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'text text', prosrc => 'has_server_privilege_name' },
{ oid => '3011', descr => 'current user privilege on server by server oid',
proname => 'has_server_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'oid text', prosrc => 'has_server_privilege_id' },
{ oid => '3138', descr => 'user privilege on type by username, type name',
proname => 'has_type_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'name text text', prosrc => 'has_type_privilege_name_name' },
{ oid => '3139', descr => 'user privilege on type by username, type oid',
proname => 'has_type_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'name oid text', prosrc => 'has_type_privilege_name_id' },
{ oid => '3140', descr => 'user privilege on type by user oid, type name',
proname => 'has_type_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'oid text text', prosrc => 'has_type_privilege_id_name' },
{ oid => '3141', descr => 'user privilege on type by user oid, type oid',
proname => 'has_type_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'oid oid text', prosrc => 'has_type_privilege_id_id' },
{ oid => '3142', descr => 'current user privilege on type by type name',
proname => 'has_type_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'text text', prosrc => 'has_type_privilege_name' },
{ oid => '3143', descr => 'current user privilege on type by type oid',
proname => 'has_type_privilege', provolatile => 's', prorettype => 'bool',
proargtypes => 'oid text', prosrc => 'has_type_privilege_id' },
{ oid => '2705', descr => 'user privilege on role by username, role name',
proname => 'pg_has_role', provolatile => 's', prorettype => 'bool',
proargtypes => 'name name text', prosrc => 'pg_has_role_name_name' },
{ oid => '2706', descr => 'user privilege on role by username, role oid',
proname => 'pg_has_role', provolatile => 's', prorettype => 'bool',
proargtypes => 'name oid text', prosrc => 'pg_has_role_name_id' },
{ oid => '2707', descr => 'user privilege on role by user oid, role name',
proname => 'pg_has_role', provolatile => 's', prorettype => 'bool',
proargtypes => 'oid name text', prosrc => 'pg_has_role_id_name' },
{ oid => '2708', descr => 'user privilege on role by user oid, role oid',
proname => 'pg_has_role', provolatile => 's', prorettype => 'bool',
proargtypes => 'oid oid text', prosrc => 'pg_has_role_id_id' },
{ oid => '2709', descr => 'current user privilege on role by role name',
proname => 'pg_has_role', provolatile => 's', prorettype => 'bool',
proargtypes => 'name text', prosrc => 'pg_has_role_name' },
{ oid => '2710', descr => 'current user privilege on role by role oid',
proname => 'pg_has_role', provolatile => 's', prorettype => 'bool',
proargtypes => 'oid text', prosrc => 'pg_has_role_id' },
{ oid => '1269',
descr => 'bytes required to store the value, perhaps with compression',
proname => 'pg_column_size', provolatile => 's', prorettype => 'int4',
proargtypes => 'any', prosrc => 'pg_column_size' },
{ oid => '2322',
descr => 'total disk space usage for the specified tablespace',
proname => 'pg_tablespace_size', provolatile => 'v', prorettype => 'int8',
proargtypes => 'oid', prosrc => 'pg_tablespace_size_oid' },
{ oid => '2323',
descr => 'total disk space usage for the specified tablespace',
proname => 'pg_tablespace_size', provolatile => 'v', prorettype => 'int8',
proargtypes => 'name', prosrc => 'pg_tablespace_size_name' },
{ oid => '2324', descr => 'total disk space usage for the specified database',
proname => 'pg_database_size', provolatile => 'v', prorettype => 'int8',
proargtypes => 'oid', prosrc => 'pg_database_size_oid' },
{ oid => '2168', descr => 'total disk space usage for the specified database',
proname => 'pg_database_size', provolatile => 'v', prorettype => 'int8',
proargtypes => 'name', prosrc => 'pg_database_size_name' },
{ oid => '2325',
descr => 'disk space usage for the main fork of the specified table or index',
proname => 'pg_relation_size', prolang => '14', provolatile => 'v',
prorettype => 'int8', proargtypes => 'regclass',
Rationalize handling of single and double quotes in bootstrap data. Change things around so that proper quoting of values interpolated into the BKI data by initdb is the responsibility of initdb, not something we half-heartedly handle by putting double quotes into the raw BKI data. (Note: experimentation shows that it still doesn't work to put a double quote into the initial superuser username, but that's the fault of inadequate quoting while interpolating the name into SQL scripts; the BKI aspect of it works fine now.) Having done that, we can remove the special-case handling of values that look like "something" from genbki.pl, and instead teach it to escape double --- and single --- quotes properly. This removes the nowhere-documented need to treat those specially in the BKI source data; whatever you write will be passed through unchanged into the inserted data value, modulo Perl's rules about single-quoted strings. Add documentation explaining the (pre-existing) handling of backslashes in the BKI data. Per an earlier discussion with John Naylor. Discussion: https://postgr.es/m/CAJVSVGUNao=-Q2-vAN3PYcdF5tnL5JAHwGwzZGuYHtq+Mk_9ng@mail.gmail.com
2018-04-18 01:53:50 +02:00
prosrc => 'select pg_catalog.pg_relation_size($1, \'main\')' },
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
{ oid => '2332',
descr => 'disk space usage for the specified fork of a table or index',
proname => 'pg_relation_size', provolatile => 'v', prorettype => 'int8',
proargtypes => 'regclass text', prosrc => 'pg_relation_size' },
{ oid => '2286',
descr => 'total disk space usage for the specified table and associated indexes',
proname => 'pg_total_relation_size', provolatile => 'v', prorettype => 'int8',
proargtypes => 'regclass', prosrc => 'pg_total_relation_size' },
{ oid => '2288',
descr => 'convert a long int to a human readable text using size units',
proname => 'pg_size_pretty', prorettype => 'text', proargtypes => 'int8',
prosrc => 'pg_size_pretty' },
{ oid => '3166',
descr => 'convert a numeric to a human readable text using size units',
proname => 'pg_size_pretty', prorettype => 'text', proargtypes => 'numeric',
prosrc => 'pg_size_pretty_numeric' },
{ oid => '3334',
descr => 'convert a size in human-readable format with size units into bytes',
proname => 'pg_size_bytes', prorettype => 'int8', proargtypes => 'text',
prosrc => 'pg_size_bytes' },
{ oid => '2997',
descr => 'disk space usage for the specified table, including TOAST, free space and visibility map',
proname => 'pg_table_size', provolatile => 'v', prorettype => 'int8',
proargtypes => 'regclass', prosrc => 'pg_table_size' },
{ oid => '2998',
descr => 'disk space usage for all indexes attached to the specified table',
proname => 'pg_indexes_size', provolatile => 'v', prorettype => 'int8',
proargtypes => 'regclass', prosrc => 'pg_indexes_size' },
{ oid => '2999', descr => 'filenode identifier of relation',
proname => 'pg_relation_filenode', provolatile => 's', prorettype => 'oid',
proargtypes => 'regclass', prosrc => 'pg_relation_filenode' },
{ oid => '3454', descr => 'relation OID for filenode and tablespace',
proname => 'pg_filenode_relation', provolatile => 's',
prorettype => 'regclass', proargtypes => 'oid oid',
prosrc => 'pg_filenode_relation' },
{ oid => '3034', descr => 'file path of relation',
proname => 'pg_relation_filepath', provolatile => 's', prorettype => 'text',
proargtypes => 'regclass', prosrc => 'pg_relation_filepath' },
{ oid => '2316', descr => '(internal)',
proname => 'postgresql_fdw_validator', prorettype => 'bool',
proargtypes => '_text oid', prosrc => 'postgresql_fdw_validator' },
{ oid => '2290', descr => 'I/O',
proname => 'record_in', provolatile => 's', prorettype => 'record',
proargtypes => 'cstring oid int4', prosrc => 'record_in' },
{ oid => '2291', descr => 'I/O',
proname => 'record_out', provolatile => 's', prorettype => 'cstring',
proargtypes => 'record', prosrc => 'record_out' },
{ oid => '2292', descr => 'I/O',
proname => 'cstring_in', prorettype => 'cstring', proargtypes => 'cstring',
prosrc => 'cstring_in' },
{ oid => '2293', descr => 'I/O',
proname => 'cstring_out', prorettype => 'cstring', proargtypes => 'cstring',
prosrc => 'cstring_out' },
{ oid => '2294', descr => 'I/O',
proname => 'any_in', prorettype => 'any', proargtypes => 'cstring',
prosrc => 'any_in' },
{ oid => '2295', descr => 'I/O',
proname => 'any_out', prorettype => 'cstring', proargtypes => 'any',
prosrc => 'any_out' },
{ oid => '2296', descr => 'I/O',
proname => 'anyarray_in', prorettype => 'anyarray', proargtypes => 'cstring',
prosrc => 'anyarray_in' },
{ oid => '2297', descr => 'I/O',
proname => 'anyarray_out', provolatile => 's', prorettype => 'cstring',
proargtypes => 'anyarray', prosrc => 'anyarray_out' },
{ oid => '2298', descr => 'I/O',
proname => 'void_in', prorettype => 'void', proargtypes => 'cstring',
prosrc => 'void_in' },
{ oid => '2299', descr => 'I/O',
proname => 'void_out', prorettype => 'cstring', proargtypes => 'void',
prosrc => 'void_out' },
{ oid => '2300', descr => 'I/O',
proname => 'trigger_in', proisstrict => 'f', prorettype => 'trigger',
proargtypes => 'cstring', prosrc => 'trigger_in' },
{ oid => '2301', descr => 'I/O',
proname => 'trigger_out', prorettype => 'cstring', proargtypes => 'trigger',
prosrc => 'trigger_out' },
{ oid => '3594', descr => 'I/O',
proname => 'event_trigger_in', proisstrict => 'f',
prorettype => 'event_trigger', proargtypes => 'cstring',
prosrc => 'event_trigger_in' },
{ oid => '3595', descr => 'I/O',
proname => 'event_trigger_out', prorettype => 'cstring',
proargtypes => 'event_trigger', prosrc => 'event_trigger_out' },
{ oid => '2302', descr => 'I/O',
proname => 'language_handler_in', proisstrict => 'f',
prorettype => 'language_handler', proargtypes => 'cstring',
prosrc => 'language_handler_in' },
{ oid => '2303', descr => 'I/O',
proname => 'language_handler_out', prorettype => 'cstring',
proargtypes => 'language_handler', prosrc => 'language_handler_out' },
{ oid => '2304', descr => 'I/O',
proname => 'internal_in', proisstrict => 'f', prorettype => 'internal',
proargtypes => 'cstring', prosrc => 'internal_in' },
{ oid => '2305', descr => 'I/O',
proname => 'internal_out', prorettype => 'cstring', proargtypes => 'internal',
prosrc => 'internal_out' },
{ oid => '2306', descr => 'I/O',
proname => 'opaque_in', proisstrict => 'f', prorettype => 'opaque',
proargtypes => 'cstring', prosrc => 'opaque_in' },
{ oid => '2307', descr => 'I/O',
proname => 'opaque_out', prorettype => 'cstring', proargtypes => 'opaque',
prosrc => 'opaque_out' },
{ oid => '2312', descr => 'I/O',
proname => 'anyelement_in', prorettype => 'anyelement',
proargtypes => 'cstring', prosrc => 'anyelement_in' },
{ oid => '2313', descr => 'I/O',
proname => 'anyelement_out', prorettype => 'cstring',
proargtypes => 'anyelement', prosrc => 'anyelement_out' },
{ oid => '2398', descr => 'I/O',
proname => 'shell_in', proisstrict => 'f', prorettype => 'opaque',
proargtypes => 'cstring', prosrc => 'shell_in' },
{ oid => '2399', descr => 'I/O',
proname => 'shell_out', prorettype => 'cstring', proargtypes => 'opaque',
prosrc => 'shell_out' },
{ oid => '2597', descr => 'I/O',
proname => 'domain_in', proisstrict => 'f', provolatile => 's',
prorettype => 'any', proargtypes => 'cstring oid int4',
prosrc => 'domain_in' },
{ oid => '2598', descr => 'I/O',
proname => 'domain_recv', proisstrict => 'f', provolatile => 's',
prorettype => 'any', proargtypes => 'internal oid int4',
prosrc => 'domain_recv' },
{ oid => '2777', descr => 'I/O',
proname => 'anynonarray_in', prorettype => 'anynonarray',
proargtypes => 'cstring', prosrc => 'anynonarray_in' },
{ oid => '2778', descr => 'I/O',
proname => 'anynonarray_out', prorettype => 'cstring',
proargtypes => 'anynonarray', prosrc => 'anynonarray_out' },
{ oid => '3116', descr => 'I/O',
proname => 'fdw_handler_in', proisstrict => 'f', prorettype => 'fdw_handler',
proargtypes => 'cstring', prosrc => 'fdw_handler_in' },
{ oid => '3117', descr => 'I/O',
proname => 'fdw_handler_out', prorettype => 'cstring',
proargtypes => 'fdw_handler', prosrc => 'fdw_handler_out' },
{ oid => '326', descr => 'I/O',
proname => 'index_am_handler_in', proisstrict => 'f',
prorettype => 'index_am_handler', proargtypes => 'cstring',
prosrc => 'index_am_handler_in' },
{ oid => '327', descr => 'I/O',
proname => 'index_am_handler_out', prorettype => 'cstring',
proargtypes => 'index_am_handler', prosrc => 'index_am_handler_out' },
{ oid => '3311', descr => 'I/O',
proname => 'tsm_handler_in', proisstrict => 'f', prorettype => 'tsm_handler',
proargtypes => 'cstring', prosrc => 'tsm_handler_in' },
{ oid => '3312', descr => 'I/O',
proname => 'tsm_handler_out', prorettype => 'cstring',
proargtypes => 'tsm_handler', prosrc => 'tsm_handler_out' },
# tablesample method handlers
{ oid => '3313', descr => 'BERNOULLI tablesample method handler',
proname => 'bernoulli', provolatile => 'v', prorettype => 'tsm_handler',
proargtypes => 'internal', prosrc => 'tsm_bernoulli_handler' },
{ oid => '3314', descr => 'SYSTEM tablesample method handler',
proname => 'system', provolatile => 'v', prorettype => 'tsm_handler',
proargtypes => 'internal', prosrc => 'tsm_system_handler' },
# cryptographic
{ oid => '2311', descr => 'MD5 hash',
proname => 'md5', proleakproof => 't', prorettype => 'text',
proargtypes => 'text', prosrc => 'md5_text' },
{ oid => '2321', descr => 'MD5 hash',
proname => 'md5', proleakproof => 't', prorettype => 'text',
proargtypes => 'bytea', prosrc => 'md5_bytea' },
{ oid => '3419', descr => 'SHA-224 hash',
proname => 'sha224', proleakproof => 't', prorettype => 'bytea',
proargtypes => 'bytea', prosrc => 'sha224_bytea' },
{ oid => '3420', descr => 'SHA-256 hash',
proname => 'sha256', proleakproof => 't', prorettype => 'bytea',
proargtypes => 'bytea', prosrc => 'sha256_bytea' },
{ oid => '3421', descr => 'SHA-384 hash',
proname => 'sha384', proleakproof => 't', prorettype => 'bytea',
proargtypes => 'bytea', prosrc => 'sha384_bytea' },
{ oid => '3422', descr => 'SHA-512 hash',
proname => 'sha512', proleakproof => 't', prorettype => 'bytea',
proargtypes => 'bytea', prosrc => 'sha512_bytea' },
# crosstype operations for date vs. timestamp and timestamptz
{ oid => '2338',
proname => 'date_lt_timestamp', prorettype => 'bool',
proargtypes => 'date timestamp', prosrc => 'date_lt_timestamp' },
{ oid => '2339',
proname => 'date_le_timestamp', prorettype => 'bool',
proargtypes => 'date timestamp', prosrc => 'date_le_timestamp' },
{ oid => '2340',
proname => 'date_eq_timestamp', prorettype => 'bool',
proargtypes => 'date timestamp', prosrc => 'date_eq_timestamp' },
{ oid => '2341',
proname => 'date_gt_timestamp', prorettype => 'bool',
proargtypes => 'date timestamp', prosrc => 'date_gt_timestamp' },
{ oid => '2342',
proname => 'date_ge_timestamp', prorettype => 'bool',
proargtypes => 'date timestamp', prosrc => 'date_ge_timestamp' },
{ oid => '2343',
proname => 'date_ne_timestamp', prorettype => 'bool',
proargtypes => 'date timestamp', prosrc => 'date_ne_timestamp' },
{ oid => '2344', descr => 'less-equal-greater',
proname => 'date_cmp_timestamp', prorettype => 'int4',
proargtypes => 'date timestamp', prosrc => 'date_cmp_timestamp' },
{ oid => '2351',
proname => 'date_lt_timestamptz', provolatile => 's', prorettype => 'bool',
proargtypes => 'date timestamptz', prosrc => 'date_lt_timestamptz' },
{ oid => '2352',
proname => 'date_le_timestamptz', provolatile => 's', prorettype => 'bool',
proargtypes => 'date timestamptz', prosrc => 'date_le_timestamptz' },
{ oid => '2353',
proname => 'date_eq_timestamptz', provolatile => 's', prorettype => 'bool',
proargtypes => 'date timestamptz', prosrc => 'date_eq_timestamptz' },
{ oid => '2354',
proname => 'date_gt_timestamptz', provolatile => 's', prorettype => 'bool',
proargtypes => 'date timestamptz', prosrc => 'date_gt_timestamptz' },
{ oid => '2355',
proname => 'date_ge_timestamptz', provolatile => 's', prorettype => 'bool',
proargtypes => 'date timestamptz', prosrc => 'date_ge_timestamptz' },
{ oid => '2356',
proname => 'date_ne_timestamptz', provolatile => 's', prorettype => 'bool',
proargtypes => 'date timestamptz', prosrc => 'date_ne_timestamptz' },
{ oid => '2357', descr => 'less-equal-greater',
proname => 'date_cmp_timestamptz', provolatile => 's', prorettype => 'int4',
proargtypes => 'date timestamptz', prosrc => 'date_cmp_timestamptz' },
{ oid => '2364',
proname => 'timestamp_lt_date', prorettype => 'bool',
proargtypes => 'timestamp date', prosrc => 'timestamp_lt_date' },
{ oid => '2365',
proname => 'timestamp_le_date', prorettype => 'bool',
proargtypes => 'timestamp date', prosrc => 'timestamp_le_date' },
{ oid => '2366',
proname => 'timestamp_eq_date', prorettype => 'bool',
proargtypes => 'timestamp date', prosrc => 'timestamp_eq_date' },
{ oid => '2367',
proname => 'timestamp_gt_date', prorettype => 'bool',
proargtypes => 'timestamp date', prosrc => 'timestamp_gt_date' },
{ oid => '2368',
proname => 'timestamp_ge_date', prorettype => 'bool',
proargtypes => 'timestamp date', prosrc => 'timestamp_ge_date' },
{ oid => '2369',
proname => 'timestamp_ne_date', prorettype => 'bool',
proargtypes => 'timestamp date', prosrc => 'timestamp_ne_date' },
{ oid => '2370', descr => 'less-equal-greater',
proname => 'timestamp_cmp_date', prorettype => 'int4',
proargtypes => 'timestamp date', prosrc => 'timestamp_cmp_date' },
{ oid => '2377',
proname => 'timestamptz_lt_date', provolatile => 's', prorettype => 'bool',
proargtypes => 'timestamptz date', prosrc => 'timestamptz_lt_date' },
{ oid => '2378',
proname => 'timestamptz_le_date', provolatile => 's', prorettype => 'bool',
proargtypes => 'timestamptz date', prosrc => 'timestamptz_le_date' },
{ oid => '2379',
proname => 'timestamptz_eq_date', provolatile => 's', prorettype => 'bool',
proargtypes => 'timestamptz date', prosrc => 'timestamptz_eq_date' },
{ oid => '2380',
proname => 'timestamptz_gt_date', provolatile => 's', prorettype => 'bool',
proargtypes => 'timestamptz date', prosrc => 'timestamptz_gt_date' },
{ oid => '2381',
proname => 'timestamptz_ge_date', provolatile => 's', prorettype => 'bool',
proargtypes => 'timestamptz date', prosrc => 'timestamptz_ge_date' },
{ oid => '2382',
proname => 'timestamptz_ne_date', provolatile => 's', prorettype => 'bool',
proargtypes => 'timestamptz date', prosrc => 'timestamptz_ne_date' },
{ oid => '2383', descr => 'less-equal-greater',
proname => 'timestamptz_cmp_date', provolatile => 's', prorettype => 'int4',
proargtypes => 'timestamptz date', prosrc => 'timestamptz_cmp_date' },
# crosstype operations for timestamp vs. timestamptz
{ oid => '2520',
proname => 'timestamp_lt_timestamptz', provolatile => 's',
prorettype => 'bool', proargtypes => 'timestamp timestamptz',
prosrc => 'timestamp_lt_timestamptz' },
{ oid => '2521',
proname => 'timestamp_le_timestamptz', provolatile => 's',
prorettype => 'bool', proargtypes => 'timestamp timestamptz',
prosrc => 'timestamp_le_timestamptz' },
{ oid => '2522',
proname => 'timestamp_eq_timestamptz', provolatile => 's',
prorettype => 'bool', proargtypes => 'timestamp timestamptz',
prosrc => 'timestamp_eq_timestamptz' },
{ oid => '2523',
proname => 'timestamp_gt_timestamptz', provolatile => 's',
prorettype => 'bool', proargtypes => 'timestamp timestamptz',
prosrc => 'timestamp_gt_timestamptz' },
{ oid => '2524',
proname => 'timestamp_ge_timestamptz', provolatile => 's',
prorettype => 'bool', proargtypes => 'timestamp timestamptz',
prosrc => 'timestamp_ge_timestamptz' },
{ oid => '2525',
proname => 'timestamp_ne_timestamptz', provolatile => 's',
prorettype => 'bool', proargtypes => 'timestamp timestamptz',
prosrc => 'timestamp_ne_timestamptz' },
{ oid => '2526', descr => 'less-equal-greater',
proname => 'timestamp_cmp_timestamptz', provolatile => 's',
prorettype => 'int4', proargtypes => 'timestamp timestamptz',
prosrc => 'timestamp_cmp_timestamptz' },
{ oid => '2527',
proname => 'timestamptz_lt_timestamp', provolatile => 's',
prorettype => 'bool', proargtypes => 'timestamptz timestamp',
prosrc => 'timestamptz_lt_timestamp' },
{ oid => '2528',
proname => 'timestamptz_le_timestamp', provolatile => 's',
prorettype => 'bool', proargtypes => 'timestamptz timestamp',
prosrc => 'timestamptz_le_timestamp' },
{ oid => '2529',
proname => 'timestamptz_eq_timestamp', provolatile => 's',
prorettype => 'bool', proargtypes => 'timestamptz timestamp',
prosrc => 'timestamptz_eq_timestamp' },
{ oid => '2530',
proname => 'timestamptz_gt_timestamp', provolatile => 's',
prorettype => 'bool', proargtypes => 'timestamptz timestamp',
prosrc => 'timestamptz_gt_timestamp' },
{ oid => '2531',
proname => 'timestamptz_ge_timestamp', provolatile => 's',
prorettype => 'bool', proargtypes => 'timestamptz timestamp',
prosrc => 'timestamptz_ge_timestamp' },
{ oid => '2532',
proname => 'timestamptz_ne_timestamp', provolatile => 's',
prorettype => 'bool', proargtypes => 'timestamptz timestamp',
prosrc => 'timestamptz_ne_timestamp' },
{ oid => '2533', descr => 'less-equal-greater',
proname => 'timestamptz_cmp_timestamp', provolatile => 's',
prorettype => 'int4', proargtypes => 'timestamptz timestamp',
prosrc => 'timestamptz_cmp_timestamp' },
# send/receive functions
{ oid => '2400', descr => 'I/O',
proname => 'array_recv', provolatile => 's', prorettype => 'anyarray',
proargtypes => 'internal oid int4', prosrc => 'array_recv' },
{ oid => '2401', descr => 'I/O',
proname => 'array_send', provolatile => 's', prorettype => 'bytea',
proargtypes => 'anyarray', prosrc => 'array_send' },
{ oid => '2402', descr => 'I/O',
proname => 'record_recv', provolatile => 's', prorettype => 'record',
proargtypes => 'internal oid int4', prosrc => 'record_recv' },
{ oid => '2403', descr => 'I/O',
proname => 'record_send', provolatile => 's', prorettype => 'bytea',
proargtypes => 'record', prosrc => 'record_send' },
{ oid => '2404', descr => 'I/O',
proname => 'int2recv', prorettype => 'int2', proargtypes => 'internal',
prosrc => 'int2recv' },
{ oid => '2405', descr => 'I/O',
proname => 'int2send', prorettype => 'bytea', proargtypes => 'int2',
prosrc => 'int2send' },
{ oid => '2406', descr => 'I/O',
proname => 'int4recv', prorettype => 'int4', proargtypes => 'internal',
prosrc => 'int4recv' },
{ oid => '2407', descr => 'I/O',
proname => 'int4send', prorettype => 'bytea', proargtypes => 'int4',
prosrc => 'int4send' },
{ oid => '2408', descr => 'I/O',
proname => 'int8recv', prorettype => 'int8', proargtypes => 'internal',
prosrc => 'int8recv' },
{ oid => '2409', descr => 'I/O',
proname => 'int8send', prorettype => 'bytea', proargtypes => 'int8',
prosrc => 'int8send' },
{ oid => '2410', descr => 'I/O',
proname => 'int2vectorrecv', prorettype => 'int2vector',
proargtypes => 'internal', prosrc => 'int2vectorrecv' },
{ oid => '2411', descr => 'I/O',
proname => 'int2vectorsend', prorettype => 'bytea',
proargtypes => 'int2vector', prosrc => 'int2vectorsend' },
{ oid => '2412', descr => 'I/O',
proname => 'bytearecv', prorettype => 'bytea', proargtypes => 'internal',
prosrc => 'bytearecv' },
{ oid => '2413', descr => 'I/O',
proname => 'byteasend', prorettype => 'bytea', proargtypes => 'bytea',
prosrc => 'byteasend' },
{ oid => '2414', descr => 'I/O',
proname => 'textrecv', provolatile => 's', prorettype => 'text',
proargtypes => 'internal', prosrc => 'textrecv' },
{ oid => '2415', descr => 'I/O',
proname => 'textsend', provolatile => 's', prorettype => 'bytea',
proargtypes => 'text', prosrc => 'textsend' },
{ oid => '2416', descr => 'I/O',
proname => 'unknownrecv', prorettype => 'unknown', proargtypes => 'internal',
prosrc => 'unknownrecv' },
{ oid => '2417', descr => 'I/O',
proname => 'unknownsend', prorettype => 'bytea', proargtypes => 'unknown',
prosrc => 'unknownsend' },
{ oid => '2418', descr => 'I/O',
proname => 'oidrecv', prorettype => 'oid', proargtypes => 'internal',
prosrc => 'oidrecv' },
{ oid => '2419', descr => 'I/O',
proname => 'oidsend', prorettype => 'bytea', proargtypes => 'oid',
prosrc => 'oidsend' },
{ oid => '2420', descr => 'I/O',
proname => 'oidvectorrecv', prorettype => 'oidvector',
proargtypes => 'internal', prosrc => 'oidvectorrecv' },
{ oid => '2421', descr => 'I/O',
proname => 'oidvectorsend', prorettype => 'bytea', proargtypes => 'oidvector',
prosrc => 'oidvectorsend' },
{ oid => '2422', descr => 'I/O',
proname => 'namerecv', provolatile => 's', prorettype => 'name',
proargtypes => 'internal', prosrc => 'namerecv' },
{ oid => '2423', descr => 'I/O',
proname => 'namesend', provolatile => 's', prorettype => 'bytea',
proargtypes => 'name', prosrc => 'namesend' },
{ oid => '2424', descr => 'I/O',
proname => 'float4recv', prorettype => 'float4', proargtypes => 'internal',
prosrc => 'float4recv' },
{ oid => '2425', descr => 'I/O',
proname => 'float4send', prorettype => 'bytea', proargtypes => 'float4',
prosrc => 'float4send' },
{ oid => '2426', descr => 'I/O',
proname => 'float8recv', prorettype => 'float8', proargtypes => 'internal',
prosrc => 'float8recv' },
{ oid => '2427', descr => 'I/O',
proname => 'float8send', prorettype => 'bytea', proargtypes => 'float8',
prosrc => 'float8send' },
{ oid => '2428', descr => 'I/O',
proname => 'point_recv', prorettype => 'point', proargtypes => 'internal',
prosrc => 'point_recv' },
{ oid => '2429', descr => 'I/O',
proname => 'point_send', prorettype => 'bytea', proargtypes => 'point',
prosrc => 'point_send' },
{ oid => '2430', descr => 'I/O',
proname => 'bpcharrecv', provolatile => 's', prorettype => 'bpchar',
proargtypes => 'internal oid int4', prosrc => 'bpcharrecv' },
{ oid => '2431', descr => 'I/O',
proname => 'bpcharsend', provolatile => 's', prorettype => 'bytea',
proargtypes => 'bpchar', prosrc => 'bpcharsend' },
{ oid => '2432', descr => 'I/O',
proname => 'varcharrecv', provolatile => 's', prorettype => 'varchar',
proargtypes => 'internal oid int4', prosrc => 'varcharrecv' },
{ oid => '2433', descr => 'I/O',
proname => 'varcharsend', provolatile => 's', prorettype => 'bytea',
proargtypes => 'varchar', prosrc => 'varcharsend' },
{ oid => '2434', descr => 'I/O',
proname => 'charrecv', prorettype => 'char', proargtypes => 'internal',
prosrc => 'charrecv' },
{ oid => '2435', descr => 'I/O',
proname => 'charsend', prorettype => 'bytea', proargtypes => 'char',
prosrc => 'charsend' },
{ oid => '2436', descr => 'I/O',
proname => 'boolrecv', prorettype => 'bool', proargtypes => 'internal',
prosrc => 'boolrecv' },
{ oid => '2437', descr => 'I/O',
proname => 'boolsend', prorettype => 'bytea', proargtypes => 'bool',
prosrc => 'boolsend' },
{ oid => '2438', descr => 'I/O',
proname => 'tidrecv', prorettype => 'tid', proargtypes => 'internal',
prosrc => 'tidrecv' },
{ oid => '2439', descr => 'I/O',
proname => 'tidsend', prorettype => 'bytea', proargtypes => 'tid',
prosrc => 'tidsend' },
{ oid => '2440', descr => 'I/O',
proname => 'xidrecv', prorettype => 'xid', proargtypes => 'internal',
prosrc => 'xidrecv' },
{ oid => '2441', descr => 'I/O',
proname => 'xidsend', prorettype => 'bytea', proargtypes => 'xid',
prosrc => 'xidsend' },
{ oid => '2442', descr => 'I/O',
proname => 'cidrecv', prorettype => 'cid', proargtypes => 'internal',
prosrc => 'cidrecv' },
{ oid => '2443', descr => 'I/O',
proname => 'cidsend', prorettype => 'bytea', proargtypes => 'cid',
prosrc => 'cidsend' },
{ oid => '2444', descr => 'I/O',
proname => 'regprocrecv', prorettype => 'regproc', proargtypes => 'internal',
prosrc => 'regprocrecv' },
{ oid => '2445', descr => 'I/O',
proname => 'regprocsend', prorettype => 'bytea', proargtypes => 'regproc',
prosrc => 'regprocsend' },
{ oid => '2446', descr => 'I/O',
proname => 'regprocedurerecv', prorettype => 'regprocedure',
proargtypes => 'internal', prosrc => 'regprocedurerecv' },
{ oid => '2447', descr => 'I/O',
proname => 'regproceduresend', prorettype => 'bytea',
proargtypes => 'regprocedure', prosrc => 'regproceduresend' },
{ oid => '2448', descr => 'I/O',
proname => 'regoperrecv', prorettype => 'regoper', proargtypes => 'internal',
prosrc => 'regoperrecv' },
{ oid => '2449', descr => 'I/O',
proname => 'regopersend', prorettype => 'bytea', proargtypes => 'regoper',
prosrc => 'regopersend' },
{ oid => '2450', descr => 'I/O',
proname => 'regoperatorrecv', prorettype => 'regoperator',
proargtypes => 'internal', prosrc => 'regoperatorrecv' },
{ oid => '2451', descr => 'I/O',
proname => 'regoperatorsend', prorettype => 'bytea',
proargtypes => 'regoperator', prosrc => 'regoperatorsend' },
{ oid => '2452', descr => 'I/O',
proname => 'regclassrecv', prorettype => 'regclass',
proargtypes => 'internal', prosrc => 'regclassrecv' },
{ oid => '2453', descr => 'I/O',
proname => 'regclasssend', prorettype => 'bytea', proargtypes => 'regclass',
prosrc => 'regclasssend' },
{ oid => '2454', descr => 'I/O',
proname => 'regtyperecv', prorettype => 'regtype', proargtypes => 'internal',
prosrc => 'regtyperecv' },
{ oid => '2455', descr => 'I/O',
proname => 'regtypesend', prorettype => 'bytea', proargtypes => 'regtype',
prosrc => 'regtypesend' },
{ oid => '4094', descr => 'I/O',
proname => 'regrolerecv', prorettype => 'regrole', proargtypes => 'internal',
prosrc => 'regrolerecv' },
{ oid => '4095', descr => 'I/O',
proname => 'regrolesend', prorettype => 'bytea', proargtypes => 'regrole',
prosrc => 'regrolesend' },
{ oid => '4087', descr => 'I/O',
proname => 'regnamespacerecv', prorettype => 'regnamespace',
proargtypes => 'internal', prosrc => 'regnamespacerecv' },
{ oid => '4088', descr => 'I/O',
proname => 'regnamespacesend', prorettype => 'bytea',
proargtypes => 'regnamespace', prosrc => 'regnamespacesend' },
{ oid => '2456', descr => 'I/O',
proname => 'bit_recv', prorettype => 'bit',
proargtypes => 'internal oid int4', prosrc => 'bit_recv' },
{ oid => '2457', descr => 'I/O',
proname => 'bit_send', prorettype => 'bytea', proargtypes => 'bit',
prosrc => 'bit_send' },
{ oid => '2458', descr => 'I/O',
proname => 'varbit_recv', prorettype => 'varbit',
proargtypes => 'internal oid int4', prosrc => 'varbit_recv' },
{ oid => '2459', descr => 'I/O',
proname => 'varbit_send', prorettype => 'bytea', proargtypes => 'varbit',
prosrc => 'varbit_send' },
{ oid => '2460', descr => 'I/O',
proname => 'numeric_recv', prorettype => 'numeric',
proargtypes => 'internal oid int4', prosrc => 'numeric_recv' },
{ oid => '2461', descr => 'I/O',
proname => 'numeric_send', prorettype => 'bytea', proargtypes => 'numeric',
prosrc => 'numeric_send' },
{ oid => '2468', descr => 'I/O',
proname => 'date_recv', prorettype => 'date', proargtypes => 'internal',
prosrc => 'date_recv' },
{ oid => '2469', descr => 'I/O',
proname => 'date_send', prorettype => 'bytea', proargtypes => 'date',
prosrc => 'date_send' },
{ oid => '2470', descr => 'I/O',
proname => 'time_recv', prorettype => 'time',
proargtypes => 'internal oid int4', prosrc => 'time_recv' },
{ oid => '2471', descr => 'I/O',
proname => 'time_send', prorettype => 'bytea', proargtypes => 'time',
prosrc => 'time_send' },
{ oid => '2472', descr => 'I/O',
proname => 'timetz_recv', prorettype => 'timetz',
proargtypes => 'internal oid int4', prosrc => 'timetz_recv' },
{ oid => '2473', descr => 'I/O',
proname => 'timetz_send', prorettype => 'bytea', proargtypes => 'timetz',
prosrc => 'timetz_send' },
{ oid => '2474', descr => 'I/O',
proname => 'timestamp_recv', prorettype => 'timestamp',
proargtypes => 'internal oid int4', prosrc => 'timestamp_recv' },
{ oid => '2475', descr => 'I/O',
proname => 'timestamp_send', prorettype => 'bytea',
proargtypes => 'timestamp', prosrc => 'timestamp_send' },
{ oid => '2476', descr => 'I/O',
proname => 'timestamptz_recv', prorettype => 'timestamptz',
proargtypes => 'internal oid int4', prosrc => 'timestamptz_recv' },
{ oid => '2477', descr => 'I/O',
proname => 'timestamptz_send', prorettype => 'bytea',
proargtypes => 'timestamptz', prosrc => 'timestamptz_send' },
{ oid => '2478', descr => 'I/O',
proname => 'interval_recv', prorettype => 'interval',
proargtypes => 'internal oid int4', prosrc => 'interval_recv' },
{ oid => '2479', descr => 'I/O',
proname => 'interval_send', prorettype => 'bytea', proargtypes => 'interval',
prosrc => 'interval_send' },
{ oid => '2480', descr => 'I/O',
proname => 'lseg_recv', prorettype => 'lseg', proargtypes => 'internal',
prosrc => 'lseg_recv' },
{ oid => '2481', descr => 'I/O',
proname => 'lseg_send', prorettype => 'bytea', proargtypes => 'lseg',
prosrc => 'lseg_send' },
{ oid => '2482', descr => 'I/O',
proname => 'path_recv', prorettype => 'path', proargtypes => 'internal',
prosrc => 'path_recv' },
{ oid => '2483', descr => 'I/O',
proname => 'path_send', prorettype => 'bytea', proargtypes => 'path',
prosrc => 'path_send' },
{ oid => '2484', descr => 'I/O',
proname => 'box_recv', prorettype => 'box', proargtypes => 'internal',
prosrc => 'box_recv' },
{ oid => '2485', descr => 'I/O',
proname => 'box_send', prorettype => 'bytea', proargtypes => 'box',
prosrc => 'box_send' },
{ oid => '2486', descr => 'I/O',
proname => 'poly_recv', prorettype => 'polygon', proargtypes => 'internal',
prosrc => 'poly_recv' },
{ oid => '2487', descr => 'I/O',
proname => 'poly_send', prorettype => 'bytea', proargtypes => 'polygon',
prosrc => 'poly_send' },
{ oid => '2488', descr => 'I/O',
proname => 'line_recv', prorettype => 'line', proargtypes => 'internal',
prosrc => 'line_recv' },
{ oid => '2489', descr => 'I/O',
proname => 'line_send', prorettype => 'bytea', proargtypes => 'line',
prosrc => 'line_send' },
{ oid => '2490', descr => 'I/O',
proname => 'circle_recv', prorettype => 'circle', proargtypes => 'internal',
prosrc => 'circle_recv' },
{ oid => '2491', descr => 'I/O',
proname => 'circle_send', prorettype => 'bytea', proargtypes => 'circle',
prosrc => 'circle_send' },
{ oid => '2492', descr => 'I/O',
proname => 'cash_recv', prorettype => 'money', proargtypes => 'internal',
prosrc => 'cash_recv' },
{ oid => '2493', descr => 'I/O',
proname => 'cash_send', prorettype => 'bytea', proargtypes => 'money',
prosrc => 'cash_send' },
{ oid => '2494', descr => 'I/O',
proname => 'macaddr_recv', prorettype => 'macaddr', proargtypes => 'internal',
prosrc => 'macaddr_recv' },
{ oid => '2495', descr => 'I/O',
proname => 'macaddr_send', prorettype => 'bytea', proargtypes => 'macaddr',
prosrc => 'macaddr_send' },
{ oid => '2496', descr => 'I/O',
proname => 'inet_recv', prorettype => 'inet', proargtypes => 'internal',
prosrc => 'inet_recv' },
{ oid => '2497', descr => 'I/O',
proname => 'inet_send', prorettype => 'bytea', proargtypes => 'inet',
prosrc => 'inet_send' },
{ oid => '2498', descr => 'I/O',
proname => 'cidr_recv', prorettype => 'cidr', proargtypes => 'internal',
prosrc => 'cidr_recv' },
{ oid => '2499', descr => 'I/O',
proname => 'cidr_send', prorettype => 'bytea', proargtypes => 'cidr',
prosrc => 'cidr_send' },
{ oid => '2500', descr => 'I/O',
proname => 'cstring_recv', provolatile => 's', prorettype => 'cstring',
proargtypes => 'internal', prosrc => 'cstring_recv' },
{ oid => '2501', descr => 'I/O',
proname => 'cstring_send', provolatile => 's', prorettype => 'bytea',
proargtypes => 'cstring', prosrc => 'cstring_send' },
{ oid => '2502', descr => 'I/O',
proname => 'anyarray_recv', provolatile => 's', prorettype => 'anyarray',
proargtypes => 'internal', prosrc => 'anyarray_recv' },
{ oid => '2503', descr => 'I/O',
proname => 'anyarray_send', provolatile => 's', prorettype => 'bytea',
proargtypes => 'anyarray', prosrc => 'anyarray_send' },
{ oid => '3120', descr => 'I/O',
proname => 'void_recv', prorettype => 'void', proargtypes => 'internal',
prosrc => 'void_recv' },
{ oid => '3121', descr => 'I/O',
proname => 'void_send', prorettype => 'bytea', proargtypes => 'void',
prosrc => 'void_send' },
{ oid => '3446', descr => 'I/O',
proname => 'macaddr8_recv', prorettype => 'macaddr8',
proargtypes => 'internal', prosrc => 'macaddr8_recv' },
{ oid => '3447', descr => 'I/O',
proname => 'macaddr8_send', prorettype => 'bytea', proargtypes => 'macaddr8',
prosrc => 'macaddr8_send' },
# System-view support functions with pretty-print option
{ oid => '2504', descr => 'source text of a rule with pretty-print option',
proname => 'pg_get_ruledef', provolatile => 's', prorettype => 'text',
proargtypes => 'oid bool', prosrc => 'pg_get_ruledef_ext' },
{ oid => '2505',
descr => 'select statement of a view with pretty-print option',
proname => 'pg_get_viewdef', provolatile => 's', proparallel => 'r',
prorettype => 'text', proargtypes => 'text bool',
prosrc => 'pg_get_viewdef_name_ext' },
{ oid => '2506',
descr => 'select statement of a view with pretty-print option',
proname => 'pg_get_viewdef', provolatile => 's', proparallel => 'r',
prorettype => 'text', proargtypes => 'oid bool',
prosrc => 'pg_get_viewdef_ext' },
{ oid => '3159',
descr => 'select statement of a view with pretty-printing and specified line wrapping',
proname => 'pg_get_viewdef', provolatile => 's', proparallel => 'r',
prorettype => 'text', proargtypes => 'oid int4',
prosrc => 'pg_get_viewdef_wrap' },
{ oid => '2507',
descr => 'index description (full create statement or single expression) with pretty-print option',
proname => 'pg_get_indexdef', provolatile => 's', prorettype => 'text',
proargtypes => 'oid int4 bool', prosrc => 'pg_get_indexdef_ext' },
{ oid => '2508', descr => 'constraint description with pretty-print option',
proname => 'pg_get_constraintdef', provolatile => 's', prorettype => 'text',
proargtypes => 'oid bool', prosrc => 'pg_get_constraintdef_ext' },
{ oid => '2509',
descr => 'deparse an encoded expression with pretty-print option',
proname => 'pg_get_expr', provolatile => 's', prorettype => 'text',
proargtypes => 'pg_node_tree oid bool', prosrc => 'pg_get_expr_ext' },
{ oid => '2510', descr => 'get the prepared statements for this session',
proname => 'pg_prepared_statement', prorows => '1000', proretset => 't',
provolatile => 's', proparallel => 'r', prorettype => 'record',
proargtypes => '', proallargtypes => '{text,text,timestamptz,_regtype,bool}',
proargmodes => '{o,o,o,o,o}',
proargnames => '{name,statement,prepare_time,parameter_types,from_sql}',
prosrc => 'pg_prepared_statement' },
{ oid => '2511', descr => 'get the open cursors for this session',
proname => 'pg_cursor', prorows => '1000', proretset => 't',
provolatile => 's', proparallel => 'r', prorettype => 'record',
proargtypes => '', proallargtypes => '{text,text,bool,bool,bool,timestamptz}',
proargmodes => '{o,o,o,o,o,o}',
proargnames => '{name,statement,is_holdable,is_binary,is_scrollable,creation_time}',
prosrc => 'pg_cursor' },
{ oid => '2599', descr => 'get the available time zone abbreviations',
proname => 'pg_timezone_abbrevs', prorows => '1000', proretset => 't',
provolatile => 's', prorettype => 'record', proargtypes => '',
proallargtypes => '{text,interval,bool}', proargmodes => '{o,o,o}',
proargnames => '{abbrev,utc_offset,is_dst}',
prosrc => 'pg_timezone_abbrevs' },
{ oid => '2856', descr => 'get the available time zone names',
proname => 'pg_timezone_names', prorows => '1000', proretset => 't',
provolatile => 's', prorettype => 'record', proargtypes => '',
proallargtypes => '{text,text,interval,bool}', proargmodes => '{o,o,o,o}',
proargnames => '{name,abbrev,utc_offset,is_dst}',
prosrc => 'pg_timezone_names' },
{ oid => '2730', descr => 'trigger description with pretty-print option',
proname => 'pg_get_triggerdef', provolatile => 's', prorettype => 'text',
proargtypes => 'oid bool', prosrc => 'pg_get_triggerdef_ext' },
# asynchronous notifications
{ oid => '3035',
descr => 'get the channels that the current backend listens to',
proname => 'pg_listening_channels', prorows => '10', proretset => 't',
provolatile => 's', proparallel => 'r', prorettype => 'text',
proargtypes => '', prosrc => 'pg_listening_channels' },
{ oid => '3036', descr => 'send a notification event',
proname => 'pg_notify', proisstrict => 'f', provolatile => 'v',
proparallel => 'r', prorettype => 'void', proargtypes => 'text text',
prosrc => 'pg_notify' },
{ oid => '3296',
descr => 'get the fraction of the asynchronous notification queue currently in use',
proname => 'pg_notification_queue_usage', provolatile => 'v',
prorettype => 'float8', proargtypes => '',
prosrc => 'pg_notification_queue_usage' },
# non-persistent series generator
{ oid => '1066', descr => 'non-persistent series generator',
proname => 'generate_series', prorows => '1000', proretset => 't',
prorettype => 'int4', proargtypes => 'int4 int4 int4',
prosrc => 'generate_series_step_int4' },
{ oid => '1067', descr => 'non-persistent series generator',
proname => 'generate_series', prorows => '1000', proretset => 't',
prorettype => 'int4', proargtypes => 'int4 int4',
prosrc => 'generate_series_int4' },
{ oid => '1068', descr => 'non-persistent series generator',
proname => 'generate_series', prorows => '1000', proretset => 't',
prorettype => 'int8', proargtypes => 'int8 int8 int8',
prosrc => 'generate_series_step_int8' },
{ oid => '1069', descr => 'non-persistent series generator',
proname => 'generate_series', prorows => '1000', proretset => 't',
prorettype => 'int8', proargtypes => 'int8 int8',
prosrc => 'generate_series_int8' },
{ oid => '3259', descr => 'non-persistent series generator',
proname => 'generate_series', prorows => '1000', proretset => 't',
prorettype => 'numeric', proargtypes => 'numeric numeric numeric',
prosrc => 'generate_series_step_numeric' },
{ oid => '3260', descr => 'non-persistent series generator',
proname => 'generate_series', prorows => '1000', proretset => 't',
prorettype => 'numeric', proargtypes => 'numeric numeric',
prosrc => 'generate_series_numeric' },
{ oid => '938', descr => 'non-persistent series generator',
proname => 'generate_series', prorows => '1000', proretset => 't',
prorettype => 'timestamp', proargtypes => 'timestamp timestamp interval',
prosrc => 'generate_series_timestamp' },
{ oid => '939', descr => 'non-persistent series generator',
proname => 'generate_series', prorows => '1000', proretset => 't',
provolatile => 's', prorettype => 'timestamptz',
proargtypes => 'timestamptz timestamptz interval',
prosrc => 'generate_series_timestamptz' },
# boolean aggregates
{ oid => '2515', descr => 'aggregate transition function',
proname => 'booland_statefunc', prorettype => 'bool',
proargtypes => 'bool bool', prosrc => 'booland_statefunc' },
{ oid => '2516', descr => 'aggregate transition function',
proname => 'boolor_statefunc', prorettype => 'bool',
proargtypes => 'bool bool', prosrc => 'boolor_statefunc' },
{ oid => '3496', descr => 'aggregate transition function',
proname => 'bool_accum', proisstrict => 'f', prorettype => 'internal',
proargtypes => 'internal bool', prosrc => 'bool_accum' },
{ oid => '3497', descr => 'aggregate transition function',
proname => 'bool_accum_inv', proisstrict => 'f', prorettype => 'internal',
proargtypes => 'internal bool', prosrc => 'bool_accum_inv' },
{ oid => '3498', descr => 'aggregate final function',
proname => 'bool_alltrue', prorettype => 'bool', proargtypes => 'internal',
prosrc => 'bool_alltrue' },
{ oid => '3499', descr => 'aggregate final function',
proname => 'bool_anytrue', prorettype => 'bool', proargtypes => 'internal',
prosrc => 'bool_anytrue' },
{ oid => '2517', descr => 'boolean-and aggregate',
proname => 'bool_and', prokind => 'a', proisstrict => 'f',
prorettype => 'bool', proargtypes => 'bool', prosrc => 'aggregate_dummy' },
# ANY, SOME? These names conflict with subquery operators. See doc.
{ oid => '2518', descr => 'boolean-or aggregate',
proname => 'bool_or', prokind => 'a', proisstrict => 'f',
prorettype => 'bool', proargtypes => 'bool', prosrc => 'aggregate_dummy' },
{ oid => '2519', descr => 'boolean-and aggregate',
proname => 'every', prokind => 'a', proisstrict => 'f', prorettype => 'bool',
proargtypes => 'bool', prosrc => 'aggregate_dummy' },
# bitwise integer aggregates
{ oid => '2236', descr => 'bitwise-and smallint aggregate',
proname => 'bit_and', prokind => 'a', proisstrict => 'f',
prorettype => 'int2', proargtypes => 'int2', prosrc => 'aggregate_dummy' },
{ oid => '2237', descr => 'bitwise-or smallint aggregate',
proname => 'bit_or', prokind => 'a', proisstrict => 'f', prorettype => 'int2',
proargtypes => 'int2', prosrc => 'aggregate_dummy' },
{ oid => '2238', descr => 'bitwise-and integer aggregate',
proname => 'bit_and', prokind => 'a', proisstrict => 'f',
prorettype => 'int4', proargtypes => 'int4', prosrc => 'aggregate_dummy' },
{ oid => '2239', descr => 'bitwise-or integer aggregate',
proname => 'bit_or', prokind => 'a', proisstrict => 'f', prorettype => 'int4',
proargtypes => 'int4', prosrc => 'aggregate_dummy' },
{ oid => '2240', descr => 'bitwise-and bigint aggregate',
proname => 'bit_and', prokind => 'a', proisstrict => 'f',
prorettype => 'int8', proargtypes => 'int8', prosrc => 'aggregate_dummy' },
{ oid => '2241', descr => 'bitwise-or bigint aggregate',
proname => 'bit_or', prokind => 'a', proisstrict => 'f', prorettype => 'int8',
proargtypes => 'int8', prosrc => 'aggregate_dummy' },
{ oid => '2242', descr => 'bitwise-and bit aggregate',
proname => 'bit_and', prokind => 'a', proisstrict => 'f', prorettype => 'bit',
proargtypes => 'bit', prosrc => 'aggregate_dummy' },
{ oid => '2243', descr => 'bitwise-or bit aggregate',
proname => 'bit_or', prokind => 'a', proisstrict => 'f', prorettype => 'bit',
proargtypes => 'bit', prosrc => 'aggregate_dummy' },
# formerly-missing interval + datetime operators
{ oid => '2546',
proname => 'interval_pl_date', prolang => '14', prorettype => 'timestamp',
proargtypes => 'interval date', prosrc => 'select $2 + $1' },
{ oid => '2547',
proname => 'interval_pl_timetz', prolang => '14', prorettype => 'timetz',
proargtypes => 'interval timetz', prosrc => 'select $2 + $1' },
{ oid => '2548',
proname => 'interval_pl_timestamp', prolang => '14',
prorettype => 'timestamp', proargtypes => 'interval timestamp',
prosrc => 'select $2 + $1' },
{ oid => '2549',
proname => 'interval_pl_timestamptz', prolang => '14', provolatile => 's',
prorettype => 'timestamptz', proargtypes => 'interval timestamptz',
prosrc => 'select $2 + $1' },
{ oid => '2550',
proname => 'integer_pl_date', prolang => '14', prorettype => 'date',
proargtypes => 'int4 date', prosrc => 'select $2 + $1' },
{ oid => '2556', descr => 'get OIDs of databases in a tablespace',
proname => 'pg_tablespace_databases', prorows => '1000', proretset => 't',
provolatile => 's', prorettype => 'oid', proargtypes => 'oid',
prosrc => 'pg_tablespace_databases' },
{ oid => '2557', descr => 'convert int4 to boolean',
proname => 'bool', prorettype => 'bool', proargtypes => 'int4',
prosrc => 'int4_bool' },
{ oid => '2558', descr => 'convert boolean to int4',
proname => 'int4', prorettype => 'int4', proargtypes => 'bool',
prosrc => 'bool_int4' },
{ oid => '2559', descr => 'current value from last used sequence',
proname => 'lastval', provolatile => 'v', proparallel => 'u',
prorettype => 'int8', proargtypes => '', prosrc => 'lastval' },
# start time function
{ oid => '2560', descr => 'postmaster start time',
proname => 'pg_postmaster_start_time', provolatile => 's',
prorettype => 'timestamptz', proargtypes => '',
prosrc => 'pg_postmaster_start_time' },
# config reload time function
{ oid => '2034', descr => 'configuration load time',
proname => 'pg_conf_load_time', provolatile => 's', proparallel => 'r',
prorettype => 'timestamptz', proargtypes => '',
prosrc => 'pg_conf_load_time' },
# new functions for Y-direction rtree opclasses
{ oid => '2562',
proname => 'box_below', prorettype => 'bool', proargtypes => 'box box',
prosrc => 'box_below' },
{ oid => '2563',
proname => 'box_overbelow', prorettype => 'bool', proargtypes => 'box box',
prosrc => 'box_overbelow' },
{ oid => '2564',
proname => 'box_overabove', prorettype => 'bool', proargtypes => 'box box',
prosrc => 'box_overabove' },
{ oid => '2565',
proname => 'box_above', prorettype => 'bool', proargtypes => 'box box',
prosrc => 'box_above' },
{ oid => '2566',
proname => 'poly_below', prorettype => 'bool',
proargtypes => 'polygon polygon', prosrc => 'poly_below' },
{ oid => '2567',
proname => 'poly_overbelow', prorettype => 'bool',
proargtypes => 'polygon polygon', prosrc => 'poly_overbelow' },
{ oid => '2568',
proname => 'poly_overabove', prorettype => 'bool',
proargtypes => 'polygon polygon', prosrc => 'poly_overabove' },
{ oid => '2569',
proname => 'poly_above', prorettype => 'bool',
proargtypes => 'polygon polygon', prosrc => 'poly_above' },
{ oid => '2587',
proname => 'circle_overbelow', prorettype => 'bool',
proargtypes => 'circle circle', prosrc => 'circle_overbelow' },
{ oid => '2588',
proname => 'circle_overabove', prorettype => 'bool',
proargtypes => 'circle circle', prosrc => 'circle_overabove' },
# support functions for GiST r-tree emulation
{ oid => '2578', descr => 'GiST support',
proname => 'gist_box_consistent', prorettype => 'bool',
proargtypes => 'internal box int2 oid internal',
prosrc => 'gist_box_consistent' },
{ oid => '2581', descr => 'GiST support',
proname => 'gist_box_penalty', prorettype => 'internal',
proargtypes => 'internal internal internal', prosrc => 'gist_box_penalty' },
{ oid => '2582', descr => 'GiST support',
proname => 'gist_box_picksplit', prorettype => 'internal',
proargtypes => 'internal internal', prosrc => 'gist_box_picksplit' },
{ oid => '2583', descr => 'GiST support',
proname => 'gist_box_union', prorettype => 'box',
proargtypes => 'internal internal', prosrc => 'gist_box_union' },
{ oid => '2584', descr => 'GiST support',
proname => 'gist_box_same', prorettype => 'internal',
proargtypes => 'box box internal', prosrc => 'gist_box_same' },
{ oid => '2585', descr => 'GiST support',
proname => 'gist_poly_consistent', prorettype => 'bool',
proargtypes => 'internal polygon int2 oid internal',
prosrc => 'gist_poly_consistent' },
{ oid => '2586', descr => 'GiST support',
proname => 'gist_poly_compress', prorettype => 'internal',
proargtypes => 'internal', prosrc => 'gist_poly_compress' },
{ oid => '2591', descr => 'GiST support',
proname => 'gist_circle_consistent', prorettype => 'bool',
proargtypes => 'internal circle int2 oid internal',
prosrc => 'gist_circle_consistent' },
{ oid => '2592', descr => 'GiST support',
proname => 'gist_circle_compress', prorettype => 'internal',
proargtypes => 'internal', prosrc => 'gist_circle_compress' },
{ oid => '1030', descr => 'GiST support',
proname => 'gist_point_compress', prorettype => 'internal',
proargtypes => 'internal', prosrc => 'gist_point_compress' },
{ oid => '3282', descr => 'GiST support',
proname => 'gist_point_fetch', prorettype => 'internal',
proargtypes => 'internal', prosrc => 'gist_point_fetch' },
{ oid => '2179', descr => 'GiST support',
proname => 'gist_point_consistent', prorettype => 'bool',
proargtypes => 'internal point int2 oid internal',
prosrc => 'gist_point_consistent' },
{ oid => '3064', descr => 'GiST support',
proname => 'gist_point_distance', prorettype => 'float8',
proargtypes => 'internal point int2 oid internal',
prosrc => 'gist_point_distance' },
{ oid => '3280', descr => 'GiST support',
proname => 'gist_circle_distance', prorettype => 'float8',
proargtypes => 'internal circle int2 oid internal',
prosrc => 'gist_circle_distance' },
{ oid => '3288', descr => 'GiST support',
proname => 'gist_poly_distance', prorettype => 'float8',
proargtypes => 'internal polygon int2 oid internal',
prosrc => 'gist_poly_distance' },
# GIN array support
{ oid => '2743', descr => 'GIN array support',
proname => 'ginarrayextract', prorettype => 'internal',
proargtypes => 'anyarray internal internal', prosrc => 'ginarrayextract' },
{ oid => '2774', descr => 'GIN array support',
proname => 'ginqueryarrayextract', prorettype => 'internal',
proargtypes => 'anyarray internal int2 internal internal internal internal',
prosrc => 'ginqueryarrayextract' },
{ oid => '2744', descr => 'GIN array support',
proname => 'ginarrayconsistent', prorettype => 'bool',
proargtypes => 'internal int2 anyarray int4 internal internal internal internal',
prosrc => 'ginarrayconsistent' },
{ oid => '3920', descr => 'GIN array support',
proname => 'ginarraytriconsistent', prorettype => 'char',
proargtypes => 'internal int2 anyarray int4 internal internal internal',
prosrc => 'ginarraytriconsistent' },
{ oid => '3076', descr => 'GIN array support (obsolete)',
proname => 'ginarrayextract', prorettype => 'internal',
proargtypes => 'anyarray internal', prosrc => 'ginarrayextract_2args' },
# overlap/contains/contained
{ oid => '2747',
proname => 'arrayoverlap', prorettype => 'bool',
proargtypes => 'anyarray anyarray', prosrc => 'arrayoverlap' },
{ oid => '2748',
proname => 'arraycontains', prorettype => 'bool',
proargtypes => 'anyarray anyarray', prosrc => 'arraycontains' },
{ oid => '2749',
proname => 'arraycontained', prorettype => 'bool',
proargtypes => 'anyarray anyarray', prosrc => 'arraycontained' },
# BRIN minmax
{ oid => '3383', descr => 'BRIN minmax support',
proname => 'brin_minmax_opcinfo', prorettype => 'internal',
proargtypes => 'internal', prosrc => 'brin_minmax_opcinfo' },
{ oid => '3384', descr => 'BRIN minmax support',
proname => 'brin_minmax_add_value', prorettype => 'bool',
proargtypes => 'internal internal internal internal',
prosrc => 'brin_minmax_add_value' },
{ oid => '3385', descr => 'BRIN minmax support',
proname => 'brin_minmax_consistent', prorettype => 'bool',
proargtypes => 'internal internal internal',
prosrc => 'brin_minmax_consistent' },
{ oid => '3386', descr => 'BRIN minmax support',
proname => 'brin_minmax_union', prorettype => 'bool',
proargtypes => 'internal internal internal', prosrc => 'brin_minmax_union' },
# BRIN inclusion
{ oid => '4105', descr => 'BRIN inclusion support',
proname => 'brin_inclusion_opcinfo', prorettype => 'internal',
proargtypes => 'internal', prosrc => 'brin_inclusion_opcinfo' },
{ oid => '4106', descr => 'BRIN inclusion support',
proname => 'brin_inclusion_add_value', prorettype => 'bool',
proargtypes => 'internal internal internal internal',
prosrc => 'brin_inclusion_add_value' },
{ oid => '4107', descr => 'BRIN inclusion support',
proname => 'brin_inclusion_consistent', prorettype => 'bool',
proargtypes => 'internal internal internal',
prosrc => 'brin_inclusion_consistent' },
{ oid => '4108', descr => 'BRIN inclusion support',
proname => 'brin_inclusion_union', prorettype => 'bool',
proargtypes => 'internal internal internal',
prosrc => 'brin_inclusion_union' },
# userlock replacements
{ oid => '2880', descr => 'obtain exclusive advisory lock',
proname => 'pg_advisory_lock', provolatile => 'v', proparallel => 'u',
prorettype => 'void', proargtypes => 'int8',
prosrc => 'pg_advisory_lock_int8' },
{ oid => '3089', descr => 'obtain exclusive advisory lock',
proname => 'pg_advisory_xact_lock', provolatile => 'v', proparallel => 'u',
prorettype => 'void', proargtypes => 'int8',
prosrc => 'pg_advisory_xact_lock_int8' },
{ oid => '2881', descr => 'obtain shared advisory lock',
proname => 'pg_advisory_lock_shared', provolatile => 'v', proparallel => 'u',
prorettype => 'void', proargtypes => 'int8',
prosrc => 'pg_advisory_lock_shared_int8' },
{ oid => '3090', descr => 'obtain shared advisory lock',
proname => 'pg_advisory_xact_lock_shared', provolatile => 'v',
proparallel => 'u', prorettype => 'void', proargtypes => 'int8',
prosrc => 'pg_advisory_xact_lock_shared_int8' },
{ oid => '2882', descr => 'obtain exclusive advisory lock if available',
proname => 'pg_try_advisory_lock', provolatile => 'v', proparallel => 'u',
prorettype => 'bool', proargtypes => 'int8',
prosrc => 'pg_try_advisory_lock_int8' },
{ oid => '3091', descr => 'obtain exclusive advisory lock if available',
proname => 'pg_try_advisory_xact_lock', provolatile => 'v',
proparallel => 'u', prorettype => 'bool', proargtypes => 'int8',
prosrc => 'pg_try_advisory_xact_lock_int8' },
{ oid => '2883', descr => 'obtain shared advisory lock if available',
proname => 'pg_try_advisory_lock_shared', provolatile => 'v',
proparallel => 'u', prorettype => 'bool', proargtypes => 'int8',
prosrc => 'pg_try_advisory_lock_shared_int8' },
{ oid => '3092', descr => 'obtain shared advisory lock if available',
proname => 'pg_try_advisory_xact_lock_shared', provolatile => 'v',
proparallel => 'u', prorettype => 'bool', proargtypes => 'int8',
prosrc => 'pg_try_advisory_xact_lock_shared_int8' },
{ oid => '2884', descr => 'release exclusive advisory lock',
proname => 'pg_advisory_unlock', provolatile => 'v', proparallel => 'u',
prorettype => 'bool', proargtypes => 'int8',
prosrc => 'pg_advisory_unlock_int8' },
{ oid => '2885', descr => 'release shared advisory lock',
proname => 'pg_advisory_unlock_shared', provolatile => 'v',
proparallel => 'u', prorettype => 'bool', proargtypes => 'int8',
prosrc => 'pg_advisory_unlock_shared_int8' },
{ oid => '2886', descr => 'obtain exclusive advisory lock',
proname => 'pg_advisory_lock', provolatile => 'v', proparallel => 'u',
prorettype => 'void', proargtypes => 'int4 int4',
prosrc => 'pg_advisory_lock_int4' },
{ oid => '3093', descr => 'obtain exclusive advisory lock',
proname => 'pg_advisory_xact_lock', provolatile => 'v', proparallel => 'u',
prorettype => 'void', proargtypes => 'int4 int4',
prosrc => 'pg_advisory_xact_lock_int4' },
{ oid => '2887', descr => 'obtain shared advisory lock',
proname => 'pg_advisory_lock_shared', provolatile => 'v', proparallel => 'u',
prorettype => 'void', proargtypes => 'int4 int4',
prosrc => 'pg_advisory_lock_shared_int4' },
{ oid => '3094', descr => 'obtain shared advisory lock',
proname => 'pg_advisory_xact_lock_shared', provolatile => 'v',
proparallel => 'u', prorettype => 'void', proargtypes => 'int4 int4',
prosrc => 'pg_advisory_xact_lock_shared_int4' },
{ oid => '2888', descr => 'obtain exclusive advisory lock if available',
proname => 'pg_try_advisory_lock', provolatile => 'v', proparallel => 'u',
prorettype => 'bool', proargtypes => 'int4 int4',
prosrc => 'pg_try_advisory_lock_int4' },
{ oid => '3095', descr => 'obtain exclusive advisory lock if available',
proname => 'pg_try_advisory_xact_lock', provolatile => 'v',
proparallel => 'u', prorettype => 'bool', proargtypes => 'int4 int4',
prosrc => 'pg_try_advisory_xact_lock_int4' },
{ oid => '2889', descr => 'obtain shared advisory lock if available',
proname => 'pg_try_advisory_lock_shared', provolatile => 'v',
proparallel => 'u', prorettype => 'bool', proargtypes => 'int4 int4',
prosrc => 'pg_try_advisory_lock_shared_int4' },
{ oid => '3096', descr => 'obtain shared advisory lock if available',
proname => 'pg_try_advisory_xact_lock_shared', provolatile => 'v',
proparallel => 'u', prorettype => 'bool', proargtypes => 'int4 int4',
prosrc => 'pg_try_advisory_xact_lock_shared_int4' },
{ oid => '2890', descr => 'release exclusive advisory lock',
proname => 'pg_advisory_unlock', provolatile => 'v', proparallel => 'u',
prorettype => 'bool', proargtypes => 'int4 int4',
prosrc => 'pg_advisory_unlock_int4' },
{ oid => '2891', descr => 'release shared advisory lock',
proname => 'pg_advisory_unlock_shared', provolatile => 'v',
proparallel => 'u', prorettype => 'bool', proargtypes => 'int4 int4',
prosrc => 'pg_advisory_unlock_shared_int4' },
{ oid => '2892', descr => 'release all advisory locks',
proname => 'pg_advisory_unlock_all', provolatile => 'v', proparallel => 'u',
prorettype => 'void', proargtypes => '', prosrc => 'pg_advisory_unlock_all' },
# XML support
{ oid => '2893', descr => 'I/O',
proname => 'xml_in', provolatile => 's', prorettype => 'xml',
proargtypes => 'cstring', prosrc => 'xml_in' },
{ oid => '2894', descr => 'I/O',
proname => 'xml_out', prorettype => 'cstring', proargtypes => 'xml',
prosrc => 'xml_out' },
{ oid => '2895', descr => 'generate XML comment',
proname => 'xmlcomment', prorettype => 'xml', proargtypes => 'text',
prosrc => 'xmlcomment' },
{ oid => '2896',
descr => 'perform a non-validating parse of a character string to produce an XML value',
proname => 'xml', provolatile => 's', prorettype => 'xml',
proargtypes => 'text', prosrc => 'texttoxml' },
{ oid => '2897', descr => 'validate an XML value',
proname => 'xmlvalidate', prorettype => 'bool', proargtypes => 'xml text',
prosrc => 'xmlvalidate' },
{ oid => '2898', descr => 'I/O',
proname => 'xml_recv', provolatile => 's', prorettype => 'xml',
proargtypes => 'internal', prosrc => 'xml_recv' },
{ oid => '2899', descr => 'I/O',
proname => 'xml_send', provolatile => 's', prorettype => 'bytea',
proargtypes => 'xml', prosrc => 'xml_send' },
{ oid => '2900', descr => 'aggregate transition function',
proname => 'xmlconcat2', proisstrict => 'f', prorettype => 'xml',
proargtypes => 'xml xml', prosrc => 'xmlconcat2' },
{ oid => '2901', descr => 'concatenate XML values',
proname => 'xmlagg', prokind => 'a', proisstrict => 'f', prorettype => 'xml',
proargtypes => 'xml', prosrc => 'aggregate_dummy' },
{ oid => '2922', descr => 'serialize an XML value to a character string',
proname => 'text', prorettype => 'text', proargtypes => 'xml',
prosrc => 'xmltotext' },
{ oid => '2923', descr => 'map table contents to XML',
proname => 'table_to_xml', procost => '100', provolatile => 's',
proparallel => 'r', prorettype => 'xml',
proargtypes => 'regclass bool bool text',
proargnames => '{tbl,nulls,tableforest,targetns}', prosrc => 'table_to_xml' },
{ oid => '2924', descr => 'map query result to XML',
proname => 'query_to_xml', procost => '100', provolatile => 'v',
proparallel => 'u', prorettype => 'xml', proargtypes => 'text bool bool text',
proargnames => '{query,nulls,tableforest,targetns}',
prosrc => 'query_to_xml' },
{ oid => '2925', descr => 'map rows from cursor to XML',
proname => 'cursor_to_xml', procost => '100', provolatile => 'v',
proparallel => 'u', prorettype => 'xml',
proargtypes => 'refcursor int4 bool bool text',
proargnames => '{cursor,count,nulls,tableforest,targetns}',
prosrc => 'cursor_to_xml' },
{ oid => '2926', descr => 'map table structure to XML Schema',
proname => 'table_to_xmlschema', procost => '100', provolatile => 's',
proparallel => 'r', prorettype => 'xml',
proargtypes => 'regclass bool bool text',
proargnames => '{tbl,nulls,tableforest,targetns}',
prosrc => 'table_to_xmlschema' },
{ oid => '2927', descr => 'map query result structure to XML Schema',
proname => 'query_to_xmlschema', procost => '100', provolatile => 'v',
proparallel => 'u', prorettype => 'xml', proargtypes => 'text bool bool text',
proargnames => '{query,nulls,tableforest,targetns}',
prosrc => 'query_to_xmlschema' },
{ oid => '2928', descr => 'map cursor structure to XML Schema',
proname => 'cursor_to_xmlschema', procost => '100', provolatile => 'v',
proparallel => 'u', prorettype => 'xml',
proargtypes => 'refcursor bool bool text',
proargnames => '{cursor,nulls,tableforest,targetns}',
prosrc => 'cursor_to_xmlschema' },
{ oid => '2929',
descr => 'map table contents and structure to XML and XML Schema',
proname => 'table_to_xml_and_xmlschema', procost => '100', provolatile => 's',
proparallel => 'r', prorettype => 'xml',
proargtypes => 'regclass bool bool text',
proargnames => '{tbl,nulls,tableforest,targetns}',
prosrc => 'table_to_xml_and_xmlschema' },
{ oid => '2930',
descr => 'map query result and structure to XML and XML Schema',
proname => 'query_to_xml_and_xmlschema', procost => '100', provolatile => 'v',
proparallel => 'u', prorettype => 'xml', proargtypes => 'text bool bool text',
proargnames => '{query,nulls,tableforest,targetns}',
prosrc => 'query_to_xml_and_xmlschema' },
{ oid => '2933', descr => 'map schema contents to XML',
proname => 'schema_to_xml', procost => '100', provolatile => 's',
proparallel => 'r', prorettype => 'xml', proargtypes => 'name bool bool text',
proargnames => '{schema,nulls,tableforest,targetns}',
prosrc => 'schema_to_xml' },
{ oid => '2934', descr => 'map schema structure to XML Schema',
proname => 'schema_to_xmlschema', procost => '100', provolatile => 's',
proparallel => 'r', prorettype => 'xml', proargtypes => 'name bool bool text',
proargnames => '{schema,nulls,tableforest,targetns}',
prosrc => 'schema_to_xmlschema' },
{ oid => '2935',
descr => 'map schema contents and structure to XML and XML Schema',
proname => 'schema_to_xml_and_xmlschema', procost => '100',
provolatile => 's', proparallel => 'r', prorettype => 'xml',
proargtypes => 'name bool bool text',
proargnames => '{schema,nulls,tableforest,targetns}',
prosrc => 'schema_to_xml_and_xmlschema' },
{ oid => '2936', descr => 'map database contents to XML',
proname => 'database_to_xml', procost => '100', provolatile => 's',
proparallel => 'r', prorettype => 'xml', proargtypes => 'bool bool text',
proargnames => '{nulls,tableforest,targetns}', prosrc => 'database_to_xml' },
{ oid => '2937', descr => 'map database structure to XML Schema',
proname => 'database_to_xmlschema', procost => '100', provolatile => 's',
proparallel => 'r', prorettype => 'xml', proargtypes => 'bool bool text',
proargnames => '{nulls,tableforest,targetns}',
prosrc => 'database_to_xmlschema' },
{ oid => '2938',
descr => 'map database contents and structure to XML and XML Schema',
proname => 'database_to_xml_and_xmlschema', procost => '100',
provolatile => 's', proparallel => 'r', prorettype => 'xml',
proargtypes => 'bool bool text',
proargnames => '{nulls,tableforest,targetns}',
prosrc => 'database_to_xml_and_xmlschema' },
{ oid => '2931',
descr => 'evaluate XPath expression, with namespaces support',
proname => 'xpath', prorettype => '_xml', proargtypes => 'text xml _text',
prosrc => 'xpath' },
{ oid => '2932', descr => 'evaluate XPath expression',
proname => 'xpath', prolang => '14', prorettype => '_xml',
proargtypes => 'text xml',
Rationalize handling of single and double quotes in bootstrap data. Change things around so that proper quoting of values interpolated into the BKI data by initdb is the responsibility of initdb, not something we half-heartedly handle by putting double quotes into the raw BKI data. (Note: experimentation shows that it still doesn't work to put a double quote into the initial superuser username, but that's the fault of inadequate quoting while interpolating the name into SQL scripts; the BKI aspect of it works fine now.) Having done that, we can remove the special-case handling of values that look like "something" from genbki.pl, and instead teach it to escape double --- and single --- quotes properly. This removes the nowhere-documented need to treat those specially in the BKI source data; whatever you write will be passed through unchanged into the inserted data value, modulo Perl's rules about single-quoted strings. Add documentation explaining the (pre-existing) handling of backslashes in the BKI data. Per an earlier discussion with John Naylor. Discussion: https://postgr.es/m/CAJVSVGUNao=-Q2-vAN3PYcdF5tnL5JAHwGwzZGuYHtq+Mk_9ng@mail.gmail.com
2018-04-18 01:53:50 +02:00
prosrc => 'select pg_catalog.xpath($1, $2, \'{}\'::pg_catalog.text[])' },
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
{ oid => '2614', descr => 'test XML value against XPath expression',
proname => 'xmlexists', prorettype => 'bool', proargtypes => 'text xml',
prosrc => 'xmlexists' },
{ oid => '3049',
descr => 'test XML value against XPath expression, with namespace support',
proname => 'xpath_exists', prorettype => 'bool',
proargtypes => 'text xml _text', prosrc => 'xpath_exists' },
{ oid => '3050', descr => 'test XML value against XPath expression',
proname => 'xpath_exists', prolang => '14', prorettype => 'bool',
proargtypes => 'text xml',
Rationalize handling of single and double quotes in bootstrap data. Change things around so that proper quoting of values interpolated into the BKI data by initdb is the responsibility of initdb, not something we half-heartedly handle by putting double quotes into the raw BKI data. (Note: experimentation shows that it still doesn't work to put a double quote into the initial superuser username, but that's the fault of inadequate quoting while interpolating the name into SQL scripts; the BKI aspect of it works fine now.) Having done that, we can remove the special-case handling of values that look like "something" from genbki.pl, and instead teach it to escape double --- and single --- quotes properly. This removes the nowhere-documented need to treat those specially in the BKI source data; whatever you write will be passed through unchanged into the inserted data value, modulo Perl's rules about single-quoted strings. Add documentation explaining the (pre-existing) handling of backslashes in the BKI data. Per an earlier discussion with John Naylor. Discussion: https://postgr.es/m/CAJVSVGUNao=-Q2-vAN3PYcdF5tnL5JAHwGwzZGuYHtq+Mk_9ng@mail.gmail.com
2018-04-18 01:53:50 +02:00
prosrc => 'select pg_catalog.xpath_exists($1, $2, \'{}\'::pg_catalog.text[])' },
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
{ oid => '3051', descr => 'determine if a string is well formed XML',
proname => 'xml_is_well_formed', provolatile => 's', prorettype => 'bool',
proargtypes => 'text', prosrc => 'xml_is_well_formed' },
{ oid => '3052', descr => 'determine if a string is well formed XML document',
proname => 'xml_is_well_formed_document', prorettype => 'bool',
proargtypes => 'text', prosrc => 'xml_is_well_formed_document' },
{ oid => '3053', descr => 'determine if a string is well formed XML content',
proname => 'xml_is_well_formed_content', prorettype => 'bool',
proargtypes => 'text', prosrc => 'xml_is_well_formed_content' },
# json
{ oid => '321', descr => 'I/O',
proname => 'json_in', prorettype => 'json', proargtypes => 'cstring',
prosrc => 'json_in' },
{ oid => '322', descr => 'I/O',
proname => 'json_out', prorettype => 'cstring', proargtypes => 'json',
prosrc => 'json_out' },
{ oid => '323', descr => 'I/O',
proname => 'json_recv', prorettype => 'json', proargtypes => 'internal',
prosrc => 'json_recv' },
{ oid => '324', descr => 'I/O',
proname => 'json_send', prorettype => 'bytea', proargtypes => 'json',
prosrc => 'json_send' },
{ oid => '3153', descr => 'map array to json',
proname => 'array_to_json', provolatile => 's', prorettype => 'json',
proargtypes => 'anyarray', prosrc => 'array_to_json' },
{ oid => '3154', descr => 'map array to json with optional pretty printing',
proname => 'array_to_json', provolatile => 's', prorettype => 'json',
proargtypes => 'anyarray bool', prosrc => 'array_to_json_pretty' },
{ oid => '3155', descr => 'map row to json',
proname => 'row_to_json', provolatile => 's', prorettype => 'json',
proargtypes => 'record', prosrc => 'row_to_json' },
{ oid => '3156', descr => 'map row to json with optional pretty printing',
proname => 'row_to_json', provolatile => 's', prorettype => 'json',
proargtypes => 'record bool', prosrc => 'row_to_json_pretty' },
{ oid => '3173', descr => 'json aggregate transition function',
proname => 'json_agg_transfn', proisstrict => 'f', provolatile => 's',
prorettype => 'internal', proargtypes => 'internal anyelement',
prosrc => 'json_agg_transfn' },
{ oid => '3174', descr => 'json aggregate final function',
proname => 'json_agg_finalfn', proisstrict => 'f', prorettype => 'json',
proargtypes => 'internal', prosrc => 'json_agg_finalfn' },
{ oid => '3175', descr => 'aggregate input into json',
proname => 'json_agg', prokind => 'a', proisstrict => 'f', provolatile => 's',
prorettype => 'json', proargtypes => 'anyelement',
prosrc => 'aggregate_dummy' },
{ oid => '3180', descr => 'json object aggregate transition function',
proname => 'json_object_agg_transfn', proisstrict => 'f', provolatile => 's',
prorettype => 'internal', proargtypes => 'internal any any',
prosrc => 'json_object_agg_transfn' },
{ oid => '3196', descr => 'json object aggregate final function',
proname => 'json_object_agg_finalfn', proisstrict => 'f',
prorettype => 'json', proargtypes => 'internal',
prosrc => 'json_object_agg_finalfn' },
{ oid => '3197', descr => 'aggregate input into a json object',
proname => 'json_object_agg', prokind => 'a', proisstrict => 'f',
provolatile => 's', prorettype => 'json', proargtypes => 'any any',
prosrc => 'aggregate_dummy' },
{ oid => '3198', descr => 'build a json array from any inputs',
proname => 'json_build_array', provariadic => 'any', proisstrict => 'f',
provolatile => 's', prorettype => 'json', proargtypes => 'any',
proallargtypes => '{any}', proargmodes => '{v}',
prosrc => 'json_build_array' },
{ oid => '3199', descr => 'build an empty json array',
proname => 'json_build_array', proisstrict => 'f', provolatile => 's',
prorettype => 'json', proargtypes => '',
prosrc => 'json_build_array_noargs' },
{ oid => '3200',
descr => 'build a json object from pairwise key/value inputs',
proname => 'json_build_object', provariadic => 'any', proisstrict => 'f',
provolatile => 's', prorettype => 'json', proargtypes => 'any',
proallargtypes => '{any}', proargmodes => '{v}',
prosrc => 'json_build_object' },
{ oid => '3201', descr => 'build an empty json object',
proname => 'json_build_object', proisstrict => 'f', provolatile => 's',
prorettype => 'json', proargtypes => '',
prosrc => 'json_build_object_noargs' },
{ oid => '3202', descr => 'map text array of key value pairs to json object',
proname => 'json_object', prorettype => 'json', proargtypes => '_text',
prosrc => 'json_object' },
{ oid => '3203', descr => 'map text arrays of keys and values to json object',
proname => 'json_object', prorettype => 'json', proargtypes => '_text _text',
prosrc => 'json_object_two_arg' },
{ oid => '3176', descr => 'map input to json',
proname => 'to_json', provolatile => 's', prorettype => 'json',
proargtypes => 'anyelement', prosrc => 'to_json' },
{ oid => '3261', descr => 'remove object fields with null values from json',
proname => 'json_strip_nulls', prorettype => 'json', proargtypes => 'json',
prosrc => 'json_strip_nulls' },
{ oid => '3947',
proname => 'json_object_field', prorettype => 'json',
proargtypes => 'json text', proargnames => '{from_json, field_name}',
prosrc => 'json_object_field' },
{ oid => '3948',
proname => 'json_object_field_text', prorettype => 'text',
proargtypes => 'json text', proargnames => '{from_json, field_name}',
prosrc => 'json_object_field_text' },
{ oid => '3949',
proname => 'json_array_element', prorettype => 'json',
proargtypes => 'json int4', proargnames => '{from_json, element_index}',
prosrc => 'json_array_element' },
{ oid => '3950',
proname => 'json_array_element_text', prorettype => 'text',
proargtypes => 'json int4', proargnames => '{from_json, element_index}',
prosrc => 'json_array_element_text' },
{ oid => '3951', descr => 'get value from json with path elements',
proname => 'json_extract_path', provariadic => 'text', prorettype => 'json',
proargtypes => 'json _text', proallargtypes => '{json,_text}',
proargmodes => '{i,v}', proargnames => '{from_json,path_elems}',
prosrc => 'json_extract_path' },
{ oid => '3953', descr => 'get value from json as text with path elements',
proname => 'json_extract_path_text', provariadic => 'text',
prorettype => 'text', proargtypes => 'json _text',
proallargtypes => '{json,_text}', proargmodes => '{i,v}',
proargnames => '{from_json,path_elems}', prosrc => 'json_extract_path_text' },
{ oid => '3955', descr => 'key value pairs of a json object',
proname => 'json_array_elements', prorows => '100', proretset => 't',
prorettype => 'json', proargtypes => 'json', proallargtypes => '{json,json}',
proargmodes => '{i,o}', proargnames => '{from_json,value}',
prosrc => 'json_array_elements' },
{ oid => '3969', descr => 'elements of json array',
proname => 'json_array_elements_text', prorows => '100', proretset => 't',
prorettype => 'text', proargtypes => 'json', proallargtypes => '{json,text}',
proargmodes => '{i,o}', proargnames => '{from_json,value}',
prosrc => 'json_array_elements_text' },
{ oid => '3956', descr => 'length of json array',
proname => 'json_array_length', prorettype => 'int4', proargtypes => 'json',
prosrc => 'json_array_length' },
{ oid => '3957', descr => 'get json object keys',
proname => 'json_object_keys', prorows => '100', proretset => 't',
prorettype => 'text', proargtypes => 'json', prosrc => 'json_object_keys' },
{ oid => '3958', descr => 'key value pairs of a json object',
proname => 'json_each', prorows => '100', proretset => 't',
prorettype => 'record', proargtypes => 'json',
proallargtypes => '{json,text,json}', proargmodes => '{i,o,o}',
proargnames => '{from_json,key,value}', prosrc => 'json_each' },
{ oid => '3959', descr => 'key value pairs of a json object',
proname => 'json_each_text', prorows => '100', proretset => 't',
prorettype => 'record', proargtypes => 'json',
proallargtypes => '{json,text,text}', proargmodes => '{i,o,o}',
proargnames => '{from_json,key,value}', prosrc => 'json_each_text' },
{ oid => '3960', descr => 'get record fields from a json object',
proname => 'json_populate_record', proisstrict => 'f', provolatile => 's',
prorettype => 'anyelement', proargtypes => 'anyelement json bool',
prosrc => 'json_populate_record' },
{ oid => '3961',
descr => 'get set of records with fields from a json array of objects',
proname => 'json_populate_recordset', prorows => '100', proisstrict => 'f',
proretset => 't', provolatile => 's', prorettype => 'anyelement',
proargtypes => 'anyelement json bool', prosrc => 'json_populate_recordset' },
{ oid => '3204', descr => 'get record fields from a json object',
proname => 'json_to_record', provolatile => 's', prorettype => 'record',
proargtypes => 'json', prosrc => 'json_to_record' },
{ oid => '3205',
descr => 'get set of records with fields from a json array of objects',
proname => 'json_to_recordset', prorows => '100', proisstrict => 'f',
proretset => 't', provolatile => 's', prorettype => 'record',
proargtypes => 'json', prosrc => 'json_to_recordset' },
{ oid => '3968', descr => 'get the type of a json value',
proname => 'json_typeof', prorettype => 'text', proargtypes => 'json',
prosrc => 'json_typeof' },
# uuid
{ oid => '2952', descr => 'I/O',
proname => 'uuid_in', prorettype => 'uuid', proargtypes => 'cstring',
prosrc => 'uuid_in' },
{ oid => '2953', descr => 'I/O',
proname => 'uuid_out', prorettype => 'cstring', proargtypes => 'uuid',
prosrc => 'uuid_out' },
{ oid => '2954',
proname => 'uuid_lt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'uuid uuid', prosrc => 'uuid_lt' },
{ oid => '2955',
proname => 'uuid_le', proleakproof => 't', prorettype => 'bool',
proargtypes => 'uuid uuid', prosrc => 'uuid_le' },
{ oid => '2956',
proname => 'uuid_eq', proleakproof => 't', prorettype => 'bool',
proargtypes => 'uuid uuid', prosrc => 'uuid_eq' },
{ oid => '2957',
proname => 'uuid_ge', proleakproof => 't', prorettype => 'bool',
proargtypes => 'uuid uuid', prosrc => 'uuid_ge' },
{ oid => '2958',
proname => 'uuid_gt', proleakproof => 't', prorettype => 'bool',
proargtypes => 'uuid uuid', prosrc => 'uuid_gt' },
{ oid => '2959',
proname => 'uuid_ne', proleakproof => 't', prorettype => 'bool',
proargtypes => 'uuid uuid', prosrc => 'uuid_ne' },
{ oid => '2960', descr => 'less-equal-greater',
Mark built-in btree comparison functions as leakproof where it's safe. Generally, if the comparison operators for a datatype or pair of datatypes are leakproof, the corresponding btree comparison support function can be considered so as well. But we had not originally worried about marking support functions as leakproof, reasoning that they'd not likely be used in queries so the marking wouldn't matter. It turns out there's at least one place where it does matter: calc_arraycontsel() finds the target datatype's default btree comparison function and tries to use that to estimate selectivity, but it will be blocked in some cases if the function isn't leakproof. This leads to unnecessarily poor selectivity estimates and bad plans, as seen in bug #15251. Hence, run around and apply proleakproof markings where the corresponding btree comparison operators are leakproof. (I did eyeball each function to verify that it wasn't doing anything surprising, too.) This isn't a full solution to bug #15251, and it's not back-patchable because of the need for a catversion bump. A more useful response probably is to consider whether we can check permissions on the parent table instead of the child. However, this change will help in some cases where that won't, and it's easy enough to do in HEAD, so let's do so. Discussion: https://postgr.es/m/3876.1531261875@sss.pgh.pa.us
2018-07-12 00:47:31 +02:00
proname => 'uuid_cmp', proleakproof => 't', prorettype => 'int4',
proargtypes => 'uuid uuid', prosrc => 'uuid_cmp' },
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
{ oid => '3300', descr => 'sort support',
proname => 'uuid_sortsupport', prorettype => 'void',
proargtypes => 'internal', prosrc => 'uuid_sortsupport' },
{ oid => '2961', descr => 'I/O',
proname => 'uuid_recv', prorettype => 'uuid', proargtypes => 'internal',
prosrc => 'uuid_recv' },
{ oid => '2962', descr => 'I/O',
proname => 'uuid_send', prorettype => 'bytea', proargtypes => 'uuid',
prosrc => 'uuid_send' },
{ oid => '2963', descr => 'hash',
proname => 'uuid_hash', prorettype => 'int4', proargtypes => 'uuid',
prosrc => 'uuid_hash' },
{ oid => '3412', descr => 'hash',
proname => 'uuid_hash_extended', prorettype => 'int8',
proargtypes => 'uuid int8', prosrc => 'uuid_hash_extended' },
# pg_lsn
{ oid => '3229', descr => 'I/O',
proname => 'pg_lsn_in', prorettype => 'pg_lsn', proargtypes => 'cstring',
prosrc => 'pg_lsn_in' },
{ oid => '3230', descr => 'I/O',
proname => 'pg_lsn_out', prorettype => 'cstring', proargtypes => 'pg_lsn',
prosrc => 'pg_lsn_out' },
{ oid => '3231',
proname => 'pg_lsn_lt', prorettype => 'bool', proargtypes => 'pg_lsn pg_lsn',
prosrc => 'pg_lsn_lt' },
{ oid => '3232',
proname => 'pg_lsn_le', prorettype => 'bool', proargtypes => 'pg_lsn pg_lsn',
prosrc => 'pg_lsn_le' },
{ oid => '3233',
proname => 'pg_lsn_eq', prorettype => 'bool', proargtypes => 'pg_lsn pg_lsn',
prosrc => 'pg_lsn_eq' },
{ oid => '3234',
proname => 'pg_lsn_ge', prorettype => 'bool', proargtypes => 'pg_lsn pg_lsn',
prosrc => 'pg_lsn_ge' },
{ oid => '3235',
proname => 'pg_lsn_gt', prorettype => 'bool', proargtypes => 'pg_lsn pg_lsn',
prosrc => 'pg_lsn_gt' },
{ oid => '3236',
proname => 'pg_lsn_ne', prorettype => 'bool', proargtypes => 'pg_lsn pg_lsn',
prosrc => 'pg_lsn_ne' },
{ oid => '3237',
proname => 'pg_lsn_mi', prorettype => 'numeric',
proargtypes => 'pg_lsn pg_lsn', prosrc => 'pg_lsn_mi' },
{ oid => '3238', descr => 'I/O',
proname => 'pg_lsn_recv', prorettype => 'pg_lsn', proargtypes => 'internal',
prosrc => 'pg_lsn_recv' },
{ oid => '3239', descr => 'I/O',
proname => 'pg_lsn_send', prorettype => 'bytea', proargtypes => 'pg_lsn',
prosrc => 'pg_lsn_send' },
{ oid => '3251', descr => 'less-equal-greater',
proname => 'pg_lsn_cmp', prorettype => 'int4', proargtypes => 'pg_lsn pg_lsn',
prosrc => 'pg_lsn_cmp' },
{ oid => '3252', descr => 'hash',
proname => 'pg_lsn_hash', prorettype => 'int4', proargtypes => 'pg_lsn',
prosrc => 'pg_lsn_hash' },
{ oid => '3413', descr => 'hash',
proname => 'pg_lsn_hash_extended', prorettype => 'int8',
proargtypes => 'pg_lsn int8', prosrc => 'pg_lsn_hash_extended' },
# enum related procs
{ oid => '3504', descr => 'I/O',
proname => 'anyenum_in', prorettype => 'anyenum', proargtypes => 'cstring',
prosrc => 'anyenum_in' },
{ oid => '3505', descr => 'I/O',
proname => 'anyenum_out', provolatile => 's', prorettype => 'cstring',
proargtypes => 'anyenum', prosrc => 'anyenum_out' },
{ oid => '3506', descr => 'I/O',
proname => 'enum_in', provolatile => 's', prorettype => 'anyenum',
proargtypes => 'cstring oid', prosrc => 'enum_in' },
{ oid => '3507', descr => 'I/O',
proname => 'enum_out', provolatile => 's', prorettype => 'cstring',
proargtypes => 'anyenum', prosrc => 'enum_out' },
{ oid => '3508',
proname => 'enum_eq', prorettype => 'bool', proargtypes => 'anyenum anyenum',
prosrc => 'enum_eq' },
{ oid => '3509',
proname => 'enum_ne', prorettype => 'bool', proargtypes => 'anyenum anyenum',
prosrc => 'enum_ne' },
{ oid => '3510',
proname => 'enum_lt', prorettype => 'bool', proargtypes => 'anyenum anyenum',
prosrc => 'enum_lt' },
{ oid => '3511',
proname => 'enum_gt', prorettype => 'bool', proargtypes => 'anyenum anyenum',
prosrc => 'enum_gt' },
{ oid => '3512',
proname => 'enum_le', prorettype => 'bool', proargtypes => 'anyenum anyenum',
prosrc => 'enum_le' },
{ oid => '3513',
proname => 'enum_ge', prorettype => 'bool', proargtypes => 'anyenum anyenum',
prosrc => 'enum_ge' },
{ oid => '3514', descr => 'less-equal-greater',
proname => 'enum_cmp', prorettype => 'int4', proargtypes => 'anyenum anyenum',
prosrc => 'enum_cmp' },
{ oid => '3515', descr => 'hash',
proname => 'hashenum', prorettype => 'int4', proargtypes => 'anyenum',
prosrc => 'hashenum' },
{ oid => '3414', descr => 'hash',
proname => 'hashenumextended', prorettype => 'int8',
proargtypes => 'anyenum int8', prosrc => 'hashenumextended' },
{ oid => '3524', descr => 'smaller of two',
proname => 'enum_smaller', prorettype => 'anyenum',
proargtypes => 'anyenum anyenum', prosrc => 'enum_smaller' },
{ oid => '3525', descr => 'larger of two',
proname => 'enum_larger', prorettype => 'anyenum',
proargtypes => 'anyenum anyenum', prosrc => 'enum_larger' },
{ oid => '3526', descr => 'maximum value of all enum input values',
proname => 'max', prokind => 'a', proisstrict => 'f', prorettype => 'anyenum',
proargtypes => 'anyenum', prosrc => 'aggregate_dummy' },
{ oid => '3527', descr => 'minimum value of all enum input values',
proname => 'min', prokind => 'a', proisstrict => 'f', prorettype => 'anyenum',
proargtypes => 'anyenum', prosrc => 'aggregate_dummy' },
{ oid => '3528', descr => 'first value of the input enum type',
proname => 'enum_first', proisstrict => 'f', provolatile => 's',
prorettype => 'anyenum', proargtypes => 'anyenum', prosrc => 'enum_first' },
{ oid => '3529', descr => 'last value of the input enum type',
proname => 'enum_last', proisstrict => 'f', provolatile => 's',
prorettype => 'anyenum', proargtypes => 'anyenum', prosrc => 'enum_last' },
{ oid => '3530',
descr => 'range between the two given enum values, as an ordered array',
proname => 'enum_range', proisstrict => 'f', provolatile => 's',
prorettype => 'anyarray', proargtypes => 'anyenum anyenum',
prosrc => 'enum_range_bounds' },
{ oid => '3531', descr => 'range of the given enum type, as an ordered array',
proname => 'enum_range', proisstrict => 'f', provolatile => 's',
prorettype => 'anyarray', proargtypes => 'anyenum',
prosrc => 'enum_range_all' },
{ oid => '3532', descr => 'I/O',
proname => 'enum_recv', provolatile => 's', prorettype => 'anyenum',
proargtypes => 'internal oid', prosrc => 'enum_recv' },
{ oid => '3533', descr => 'I/O',
proname => 'enum_send', provolatile => 's', prorettype => 'bytea',
proargtypes => 'anyenum', prosrc => 'enum_send' },
# text search stuff
{ oid => '3610', descr => 'I/O',
proname => 'tsvectorin', prorettype => 'tsvector', proargtypes => 'cstring',
prosrc => 'tsvectorin' },
{ oid => '3639', descr => 'I/O',
proname => 'tsvectorrecv', prorettype => 'tsvector',
proargtypes => 'internal', prosrc => 'tsvectorrecv' },
{ oid => '3611', descr => 'I/O',
proname => 'tsvectorout', prorettype => 'cstring', proargtypes => 'tsvector',
prosrc => 'tsvectorout' },
{ oid => '3638', descr => 'I/O',
proname => 'tsvectorsend', prorettype => 'bytea', proargtypes => 'tsvector',
prosrc => 'tsvectorsend' },
{ oid => '3612', descr => 'I/O',
proname => 'tsqueryin', prorettype => 'tsquery', proargtypes => 'cstring',
prosrc => 'tsqueryin' },
{ oid => '3641', descr => 'I/O',
proname => 'tsqueryrecv', prorettype => 'tsquery', proargtypes => 'internal',
prosrc => 'tsqueryrecv' },
{ oid => '3613', descr => 'I/O',
proname => 'tsqueryout', prorettype => 'cstring', proargtypes => 'tsquery',
prosrc => 'tsqueryout' },
{ oid => '3640', descr => 'I/O',
proname => 'tsquerysend', prorettype => 'bytea', proargtypes => 'tsquery',
prosrc => 'tsquerysend' },
{ oid => '3646', descr => 'I/O',
proname => 'gtsvectorin', prorettype => 'gtsvector', proargtypes => 'cstring',
prosrc => 'gtsvectorin' },
{ oid => '3647', descr => 'I/O',
proname => 'gtsvectorout', prorettype => 'cstring',
proargtypes => 'gtsvector', prosrc => 'gtsvectorout' },
{ oid => '3616',
proname => 'tsvector_lt', prorettype => 'bool',
proargtypes => 'tsvector tsvector', prosrc => 'tsvector_lt' },
{ oid => '3617',
proname => 'tsvector_le', prorettype => 'bool',
proargtypes => 'tsvector tsvector', prosrc => 'tsvector_le' },
{ oid => '3618',
proname => 'tsvector_eq', prorettype => 'bool',
proargtypes => 'tsvector tsvector', prosrc => 'tsvector_eq' },
{ oid => '3619',
proname => 'tsvector_ne', prorettype => 'bool',
proargtypes => 'tsvector tsvector', prosrc => 'tsvector_ne' },
{ oid => '3620',
proname => 'tsvector_ge', prorettype => 'bool',
proargtypes => 'tsvector tsvector', prosrc => 'tsvector_ge' },
{ oid => '3621',
proname => 'tsvector_gt', prorettype => 'bool',
proargtypes => 'tsvector tsvector', prosrc => 'tsvector_gt' },
{ oid => '3622', descr => 'less-equal-greater',
proname => 'tsvector_cmp', prorettype => 'int4',
proargtypes => 'tsvector tsvector', prosrc => 'tsvector_cmp' },
{ oid => '3711', descr => 'number of lexemes',
proname => 'length', prorettype => 'int4', proargtypes => 'tsvector',
prosrc => 'tsvector_length' },
{ oid => '3623', descr => 'strip position information',
proname => 'strip', prorettype => 'tsvector', proargtypes => 'tsvector',
prosrc => 'tsvector_strip' },
{ oid => '3624', descr => 'set given weight for whole tsvector',
proname => 'setweight', prorettype => 'tsvector',
proargtypes => 'tsvector char', prosrc => 'tsvector_setweight' },
{ oid => '3320', descr => 'set given weight for given lexemes',
proname => 'setweight', prorettype => 'tsvector',
proargtypes => 'tsvector char _text',
prosrc => 'tsvector_setweight_by_filter' },
{ oid => '3625',
proname => 'tsvector_concat', prorettype => 'tsvector',
proargtypes => 'tsvector tsvector', prosrc => 'tsvector_concat' },
{ oid => '3321', descr => 'delete lexeme',
proname => 'ts_delete', prorettype => 'tsvector',
proargtypes => 'tsvector text', prosrc => 'tsvector_delete_str' },
{ oid => '3323', descr => 'delete given lexemes',
proname => 'ts_delete', prorettype => 'tsvector',
proargtypes => 'tsvector _text', prosrc => 'tsvector_delete_arr' },
{ oid => '3322', descr => 'expand tsvector to set of rows',
proname => 'unnest', prorows => '10', proretset => 't',
prorettype => 'record', proargtypes => 'tsvector',
proallargtypes => '{tsvector,text,_int2,_text}', proargmodes => '{i,o,o,o}',
proargnames => '{tsvector,lexeme,positions,weights}',
prosrc => 'tsvector_unnest' },
{ oid => '3326', descr => 'convert tsvector to array of lexemes',
proname => 'tsvector_to_array', prorettype => '_text',
proargtypes => 'tsvector', prosrc => 'tsvector_to_array' },
{ oid => '3327', descr => 'build tsvector from array of lexemes',
proname => 'array_to_tsvector', prorettype => 'tsvector',
proargtypes => '_text', prosrc => 'array_to_tsvector' },
{ oid => '3319',
descr => 'delete lexemes that do not have one of the given weights',
proname => 'ts_filter', prorettype => 'tsvector',
proargtypes => 'tsvector _char', prosrc => 'tsvector_filter' },
{ oid => '3634',
proname => 'ts_match_vq', prorettype => 'bool',
proargtypes => 'tsvector tsquery', prosrc => 'ts_match_vq' },
{ oid => '3635',
proname => 'ts_match_qv', prorettype => 'bool',
proargtypes => 'tsquery tsvector', prosrc => 'ts_match_qv' },
{ oid => '3760',
proname => 'ts_match_tt', procost => '100', provolatile => 's',
prorettype => 'bool', proargtypes => 'text text', prosrc => 'ts_match_tt' },
{ oid => '3761',
proname => 'ts_match_tq', procost => '100', provolatile => 's',
prorettype => 'bool', proargtypes => 'text tsquery',
prosrc => 'ts_match_tq' },
{ oid => '3648', descr => 'GiST tsvector support',
proname => 'gtsvector_compress', prorettype => 'internal',
proargtypes => 'internal', prosrc => 'gtsvector_compress' },
{ oid => '3649', descr => 'GiST tsvector support',
proname => 'gtsvector_decompress', prorettype => 'internal',
proargtypes => 'internal', prosrc => 'gtsvector_decompress' },
{ oid => '3650', descr => 'GiST tsvector support',
proname => 'gtsvector_picksplit', prorettype => 'internal',
proargtypes => 'internal internal', prosrc => 'gtsvector_picksplit' },
{ oid => '3651', descr => 'GiST tsvector support',
proname => 'gtsvector_union', prorettype => 'gtsvector',
proargtypes => 'internal internal', prosrc => 'gtsvector_union' },
{ oid => '3652', descr => 'GiST tsvector support',
proname => 'gtsvector_same', prorettype => 'internal',
proargtypes => 'gtsvector gtsvector internal', prosrc => 'gtsvector_same' },
{ oid => '3653', descr => 'GiST tsvector support',
proname => 'gtsvector_penalty', prorettype => 'internal',
proargtypes => 'internal internal internal', prosrc => 'gtsvector_penalty' },
{ oid => '3654', descr => 'GiST tsvector support',
proname => 'gtsvector_consistent', prorettype => 'bool',
proargtypes => 'internal tsvector int2 oid internal',
prosrc => 'gtsvector_consistent' },
{ oid => '3790', descr => 'GiST tsvector support (obsolete)',
proname => 'gtsvector_consistent', prorettype => 'bool',
proargtypes => 'internal gtsvector int4 oid internal',
prosrc => 'gtsvector_consistent_oldsig' },
{ oid => '3656', descr => 'GIN tsvector support',
proname => 'gin_extract_tsvector', prorettype => 'internal',
proargtypes => 'tsvector internal internal',
prosrc => 'gin_extract_tsvector' },
{ oid => '3657', descr => 'GIN tsvector support',
proname => 'gin_extract_tsquery', prorettype => 'internal',
proargtypes => 'tsvector internal int2 internal internal internal internal',
prosrc => 'gin_extract_tsquery' },
{ oid => '3658', descr => 'GIN tsvector support',
proname => 'gin_tsquery_consistent', prorettype => 'bool',
proargtypes => 'internal int2 tsvector int4 internal internal internal internal',
prosrc => 'gin_tsquery_consistent' },
{ oid => '3921', descr => 'GIN tsvector support',
proname => 'gin_tsquery_triconsistent', prorettype => 'char',
proargtypes => 'internal int2 tsvector int4 internal internal internal',
prosrc => 'gin_tsquery_triconsistent' },
{ oid => '3724', descr => 'GIN tsvector support',
proname => 'gin_cmp_tslexeme', prorettype => 'int4',
proargtypes => 'text text', prosrc => 'gin_cmp_tslexeme' },
{ oid => '2700', descr => 'GIN tsvector support',
proname => 'gin_cmp_prefix', prorettype => 'int4',
proargtypes => 'text text int2 internal', prosrc => 'gin_cmp_prefix' },
{ oid => '3077', descr => 'GIN tsvector support (obsolete)',
proname => 'gin_extract_tsvector', prorettype => 'internal',
proargtypes => 'tsvector internal', prosrc => 'gin_extract_tsvector_2args' },
{ oid => '3087', descr => 'GIN tsvector support (obsolete)',
proname => 'gin_extract_tsquery', prorettype => 'internal',
proargtypes => 'tsquery internal int2 internal internal',
prosrc => 'gin_extract_tsquery_5args' },
{ oid => '3088', descr => 'GIN tsvector support (obsolete)',
proname => 'gin_tsquery_consistent', prorettype => 'bool',
proargtypes => 'internal int2 tsquery int4 internal internal',
prosrc => 'gin_tsquery_consistent_6args' },
{ oid => '3791', descr => 'GIN tsvector support (obsolete)',
proname => 'gin_extract_tsquery', prorettype => 'internal',
proargtypes => 'tsquery internal int2 internal internal internal internal',
prosrc => 'gin_extract_tsquery_oldsig' },
{ oid => '3792', descr => 'GIN tsvector support (obsolete)',
proname => 'gin_tsquery_consistent', prorettype => 'bool',
proargtypes => 'internal int2 tsquery int4 internal internal internal internal',
prosrc => 'gin_tsquery_consistent_oldsig' },
{ oid => '3789', descr => 'clean up GIN pending list',
proname => 'gin_clean_pending_list', provolatile => 'v', proparallel => 'u',
prorettype => 'int8', proargtypes => 'regclass',
prosrc => 'gin_clean_pending_list' },
{ oid => '3662',
proname => 'tsquery_lt', prorettype => 'bool',
proargtypes => 'tsquery tsquery', prosrc => 'tsquery_lt' },
{ oid => '3663',
proname => 'tsquery_le', prorettype => 'bool',
proargtypes => 'tsquery tsquery', prosrc => 'tsquery_le' },
{ oid => '3664',
proname => 'tsquery_eq', prorettype => 'bool',
proargtypes => 'tsquery tsquery', prosrc => 'tsquery_eq' },
{ oid => '3665',
proname => 'tsquery_ne', prorettype => 'bool',
proargtypes => 'tsquery tsquery', prosrc => 'tsquery_ne' },
{ oid => '3666',
proname => 'tsquery_ge', prorettype => 'bool',
proargtypes => 'tsquery tsquery', prosrc => 'tsquery_ge' },
{ oid => '3667',
proname => 'tsquery_gt', prorettype => 'bool',
proargtypes => 'tsquery tsquery', prosrc => 'tsquery_gt' },
{ oid => '3668', descr => 'less-equal-greater',
proname => 'tsquery_cmp', prorettype => 'int4',
proargtypes => 'tsquery tsquery', prosrc => 'tsquery_cmp' },
{ oid => '3669',
proname => 'tsquery_and', prorettype => 'tsquery',
proargtypes => 'tsquery tsquery', prosrc => 'tsquery_and' },
{ oid => '3670',
proname => 'tsquery_or', prorettype => 'tsquery',
proargtypes => 'tsquery tsquery', prosrc => 'tsquery_or' },
{ oid => '5003',
proname => 'tsquery_phrase', prorettype => 'tsquery',
proargtypes => 'tsquery tsquery', prosrc => 'tsquery_phrase' },
{ oid => '5004', descr => 'phrase-concatenate with distance',
proname => 'tsquery_phrase', prorettype => 'tsquery',
proargtypes => 'tsquery tsquery int4', prosrc => 'tsquery_phrase_distance' },
{ oid => '3671',
proname => 'tsquery_not', prorettype => 'tsquery', proargtypes => 'tsquery',
prosrc => 'tsquery_not' },
{ oid => '3691',
proname => 'tsq_mcontains', prorettype => 'bool',
proargtypes => 'tsquery tsquery', prosrc => 'tsq_mcontains' },
{ oid => '3692',
proname => 'tsq_mcontained', prorettype => 'bool',
proargtypes => 'tsquery tsquery', prosrc => 'tsq_mcontained' },
{ oid => '3672', descr => 'number of nodes',
proname => 'numnode', prorettype => 'int4', proargtypes => 'tsquery',
prosrc => 'tsquery_numnode' },
{ oid => '3673', descr => 'show real useful query for GiST index',
proname => 'querytree', prorettype => 'text', proargtypes => 'tsquery',
prosrc => 'tsquerytree' },
{ oid => '3684', descr => 'rewrite tsquery',
proname => 'ts_rewrite', prorettype => 'tsquery',
proargtypes => 'tsquery tsquery tsquery', prosrc => 'tsquery_rewrite' },
{ oid => '3685', descr => 'rewrite tsquery',
proname => 'ts_rewrite', procost => '100', provolatile => 'v',
proparallel => 'u', prorettype => 'tsquery', proargtypes => 'tsquery text',
prosrc => 'tsquery_rewrite_query' },
{ oid => '3695', descr => 'GiST tsquery support',
proname => 'gtsquery_compress', prorettype => 'internal',
proargtypes => 'internal', prosrc => 'gtsquery_compress' },
{ oid => '3697', descr => 'GiST tsquery support',
proname => 'gtsquery_picksplit', prorettype => 'internal',
proargtypes => 'internal internal', prosrc => 'gtsquery_picksplit' },
{ oid => '3698', descr => 'GiST tsquery support',
proname => 'gtsquery_union', prorettype => 'int8',
proargtypes => 'internal internal', prosrc => 'gtsquery_union' },
{ oid => '3699', descr => 'GiST tsquery support',
proname => 'gtsquery_same', prorettype => 'internal',
proargtypes => 'int8 int8 internal', prosrc => 'gtsquery_same' },
{ oid => '3700', descr => 'GiST tsquery support',
proname => 'gtsquery_penalty', prorettype => 'internal',
proargtypes => 'internal internal internal', prosrc => 'gtsquery_penalty' },
{ oid => '3701', descr => 'GiST tsquery support',
proname => 'gtsquery_consistent', prorettype => 'bool',
proargtypes => 'internal tsquery int2 oid internal',
prosrc => 'gtsquery_consistent' },
{ oid => '3793', descr => 'GiST tsquery support (obsolete)',
proname => 'gtsquery_consistent', prorettype => 'bool',
proargtypes => 'internal internal int4 oid internal',
prosrc => 'gtsquery_consistent_oldsig' },
{ oid => '3686', descr => 'restriction selectivity of tsvector @@ tsquery',
proname => 'tsmatchsel', provolatile => 's', prorettype => 'float8',
proargtypes => 'internal oid internal int4', prosrc => 'tsmatchsel' },
{ oid => '3687', descr => 'join selectivity of tsvector @@ tsquery',
proname => 'tsmatchjoinsel', provolatile => 's', prorettype => 'float8',
proargtypes => 'internal oid internal int2 internal',
prosrc => 'tsmatchjoinsel' },
{ oid => '3688', descr => 'tsvector typanalyze',
proname => 'ts_typanalyze', provolatile => 's', prorettype => 'bool',
proargtypes => 'internal', prosrc => 'ts_typanalyze' },
{ oid => '3689', descr => 'statistics of tsvector column',
proname => 'ts_stat', procost => '10', prorows => '10000', proretset => 't',
provolatile => 'v', proparallel => 'u', prorettype => 'record',
proargtypes => 'text', proallargtypes => '{text,text,int4,int4}',
proargmodes => '{i,o,o,o}', proargnames => '{query,word,ndoc,nentry}',
prosrc => 'ts_stat1' },
{ oid => '3690', descr => 'statistics of tsvector column',
proname => 'ts_stat', procost => '10', prorows => '10000', proretset => 't',
provolatile => 'v', proparallel => 'u', prorettype => 'record',
proargtypes => 'text text', proallargtypes => '{text,text,text,int4,int4}',
proargmodes => '{i,i,o,o,o}',
proargnames => '{query,weights,word,ndoc,nentry}', prosrc => 'ts_stat2' },
{ oid => '3703', descr => 'relevance',
proname => 'ts_rank', prorettype => 'float4',
proargtypes => '_float4 tsvector tsquery int4', prosrc => 'ts_rank_wttf' },
{ oid => '3704', descr => 'relevance',
proname => 'ts_rank', prorettype => 'float4',
proargtypes => '_float4 tsvector tsquery', prosrc => 'ts_rank_wtt' },
{ oid => '3705', descr => 'relevance',
proname => 'ts_rank', prorettype => 'float4',
proargtypes => 'tsvector tsquery int4', prosrc => 'ts_rank_ttf' },
{ oid => '3706', descr => 'relevance',
proname => 'ts_rank', prorettype => 'float4',
proargtypes => 'tsvector tsquery', prosrc => 'ts_rank_tt' },
{ oid => '3707', descr => 'relevance',
proname => 'ts_rank_cd', prorettype => 'float4',
proargtypes => '_float4 tsvector tsquery int4', prosrc => 'ts_rankcd_wttf' },
{ oid => '3708', descr => 'relevance',
proname => 'ts_rank_cd', prorettype => 'float4',
proargtypes => '_float4 tsvector tsquery', prosrc => 'ts_rankcd_wtt' },
{ oid => '3709', descr => 'relevance',
proname => 'ts_rank_cd', prorettype => 'float4',
proargtypes => 'tsvector tsquery int4', prosrc => 'ts_rankcd_ttf' },
{ oid => '3710', descr => 'relevance',
proname => 'ts_rank_cd', prorettype => 'float4',
proargtypes => 'tsvector tsquery', prosrc => 'ts_rankcd_tt' },
{ oid => '3713', descr => 'get parser\'s token types',
proname => 'ts_token_type', prorows => '16', proretset => 't',
prorettype => 'record', proargtypes => 'oid',
proallargtypes => '{oid,int4,text,text}', proargmodes => '{i,o,o,o}',
proargnames => '{parser_oid,tokid,alias,description}',
prosrc => 'ts_token_type_byid' },
{ oid => '3714', descr => 'get parser\'s token types',
proname => 'ts_token_type', prorows => '16', proretset => 't',
provolatile => 's', prorettype => 'record', proargtypes => 'text',
proallargtypes => '{text,int4,text,text}', proargmodes => '{i,o,o,o}',
proargnames => '{parser_name,tokid,alias,description}',
prosrc => 'ts_token_type_byname' },
{ oid => '3715', descr => 'parse text to tokens',
proname => 'ts_parse', prorows => '1000', proretset => 't',
prorettype => 'record', proargtypes => 'oid text',
proallargtypes => '{oid,text,int4,text}', proargmodes => '{i,i,o,o}',
proargnames => '{parser_oid,txt,tokid,token}', prosrc => 'ts_parse_byid' },
{ oid => '3716', descr => 'parse text to tokens',
proname => 'ts_parse', prorows => '1000', proretset => 't',
provolatile => 's', prorettype => 'record', proargtypes => 'text text',
proallargtypes => '{text,text,int4,text}', proargmodes => '{i,i,o,o}',
proargnames => '{parser_name,txt,tokid,token}', prosrc => 'ts_parse_byname' },
{ oid => '3717', descr => '(internal)',
proname => 'prsd_start', prorettype => 'internal',
proargtypes => 'internal int4', prosrc => 'prsd_start' },
{ oid => '3718', descr => '(internal)',
proname => 'prsd_nexttoken', prorettype => 'internal',
proargtypes => 'internal internal internal', prosrc => 'prsd_nexttoken' },
{ oid => '3719', descr => '(internal)',
proname => 'prsd_end', prorettype => 'void', proargtypes => 'internal',
prosrc => 'prsd_end' },
{ oid => '3720', descr => '(internal)',
proname => 'prsd_headline', prorettype => 'internal',
proargtypes => 'internal internal tsquery', prosrc => 'prsd_headline' },
{ oid => '3721', descr => '(internal)',
proname => 'prsd_lextype', prorettype => 'internal',
proargtypes => 'internal', prosrc => 'prsd_lextype' },
{ oid => '3723', descr => 'normalize one word by dictionary',
proname => 'ts_lexize', prorettype => '_text',
proargtypes => 'regdictionary text', prosrc => 'ts_lexize' },
{ oid => '3725', descr => '(internal)',
proname => 'dsimple_init', prorettype => 'internal',
proargtypes => 'internal', prosrc => 'dsimple_init' },
{ oid => '3726', descr => '(internal)',
proname => 'dsimple_lexize', prorettype => 'internal',
proargtypes => 'internal internal internal internal',
prosrc => 'dsimple_lexize' },
{ oid => '3728', descr => '(internal)',
proname => 'dsynonym_init', prorettype => 'internal',
proargtypes => 'internal', prosrc => 'dsynonym_init' },
{ oid => '3729', descr => '(internal)',
proname => 'dsynonym_lexize', prorettype => 'internal',
proargtypes => 'internal internal internal internal',
prosrc => 'dsynonym_lexize' },
{ oid => '3731', descr => '(internal)',
proname => 'dispell_init', prorettype => 'internal',
proargtypes => 'internal', prosrc => 'dispell_init' },
{ oid => '3732', descr => '(internal)',
proname => 'dispell_lexize', prorettype => 'internal',
proargtypes => 'internal internal internal internal',
prosrc => 'dispell_lexize' },
{ oid => '3740', descr => '(internal)',
proname => 'thesaurus_init', prorettype => 'internal',
proargtypes => 'internal', prosrc => 'thesaurus_init' },
{ oid => '3741', descr => '(internal)',
proname => 'thesaurus_lexize', prorettype => 'internal',
proargtypes => 'internal internal internal internal',
prosrc => 'thesaurus_lexize' },
{ oid => '3743', descr => 'generate headline',
proname => 'ts_headline', procost => '100', prorettype => 'text',
proargtypes => 'regconfig text tsquery text',
prosrc => 'ts_headline_byid_opt' },
{ oid => '3744', descr => 'generate headline',
proname => 'ts_headline', procost => '100', prorettype => 'text',
proargtypes => 'regconfig text tsquery', prosrc => 'ts_headline_byid' },
{ oid => '3754', descr => 'generate headline',
proname => 'ts_headline', procost => '100', provolatile => 's',
prorettype => 'text', proargtypes => 'text tsquery text',
prosrc => 'ts_headline_opt' },
{ oid => '3755', descr => 'generate headline',
proname => 'ts_headline', procost => '100', provolatile => 's',
prorettype => 'text', proargtypes => 'text tsquery',
prosrc => 'ts_headline' },
{ oid => '4201', descr => 'generate headline from jsonb',
proname => 'ts_headline', procost => '100', prorettype => 'jsonb',
proargtypes => 'regconfig jsonb tsquery text',
prosrc => 'ts_headline_jsonb_byid_opt' },
{ oid => '4202', descr => 'generate headline from jsonb',
proname => 'ts_headline', procost => '100', prorettype => 'jsonb',
proargtypes => 'regconfig jsonb tsquery',
prosrc => 'ts_headline_jsonb_byid' },
{ oid => '4203', descr => 'generate headline from jsonb',
proname => 'ts_headline', procost => '100', provolatile => 's',
prorettype => 'jsonb', proargtypes => 'jsonb tsquery text',
prosrc => 'ts_headline_jsonb_opt' },
{ oid => '4204', descr => 'generate headline from jsonb',
proname => 'ts_headline', procost => '100', provolatile => 's',
prorettype => 'jsonb', proargtypes => 'jsonb tsquery',
prosrc => 'ts_headline_jsonb' },
{ oid => '4205', descr => 'generate headline from json',
proname => 'ts_headline', procost => '100', prorettype => 'json',
proargtypes => 'regconfig json tsquery text',
prosrc => 'ts_headline_json_byid_opt' },
{ oid => '4206', descr => 'generate headline from json',
proname => 'ts_headline', procost => '100', prorettype => 'json',
proargtypes => 'regconfig json tsquery', prosrc => 'ts_headline_json_byid' },
{ oid => '4207', descr => 'generate headline from json',
proname => 'ts_headline', procost => '100', provolatile => 's',
prorettype => 'json', proargtypes => 'json tsquery text',
prosrc => 'ts_headline_json_opt' },
{ oid => '4208', descr => 'generate headline from json',
proname => 'ts_headline', procost => '100', provolatile => 's',
prorettype => 'json', proargtypes => 'json tsquery',
prosrc => 'ts_headline_json' },
{ oid => '3745', descr => 'transform to tsvector',
proname => 'to_tsvector', procost => '100', prorettype => 'tsvector',
proargtypes => 'regconfig text', prosrc => 'to_tsvector_byid' },
{ oid => '3746', descr => 'make tsquery',
proname => 'to_tsquery', procost => '100', prorettype => 'tsquery',
proargtypes => 'regconfig text', prosrc => 'to_tsquery_byid' },
{ oid => '3747', descr => 'transform to tsquery',
proname => 'plainto_tsquery', procost => '100', prorettype => 'tsquery',
proargtypes => 'regconfig text', prosrc => 'plainto_tsquery_byid' },
{ oid => '5006', descr => 'transform to tsquery',
proname => 'phraseto_tsquery', procost => '100', prorettype => 'tsquery',
proargtypes => 'regconfig text', prosrc => 'phraseto_tsquery_byid' },
Cosmetic cleanups in initial catalog data. Write ',' and ';' for typdelim values instead of the obscurantist ASCII octal equivalents. Not sure why anybody ever thought the latter were better; maybe it had something to do with lack of a better quoting convention, twenty-plus years ago? Reassign a couple of high-numbered OIDs that were left in during yesterday's mad rush to commit stuff of uncertain internal temperature. The latter requires a catversion bump, though the former wouldn't since the end-result catalog data is unchanged.
2018-04-08 21:55:49 +02:00
{ oid => '5007', descr => 'transform to tsquery',
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
proname => 'websearch_to_tsquery', procost => '100', prorettype => 'tsquery',
proargtypes => 'regconfig text', prosrc => 'websearch_to_tsquery_byid' },
{ oid => '3749', descr => 'transform to tsvector',
proname => 'to_tsvector', procost => '100', provolatile => 's',
prorettype => 'tsvector', proargtypes => 'text', prosrc => 'to_tsvector' },
{ oid => '3750', descr => 'make tsquery',
proname => 'to_tsquery', procost => '100', provolatile => 's',
prorettype => 'tsquery', proargtypes => 'text', prosrc => 'to_tsquery' },
{ oid => '3751', descr => 'transform to tsquery',
proname => 'plainto_tsquery', procost => '100', provolatile => 's',
prorettype => 'tsquery', proargtypes => 'text', prosrc => 'plainto_tsquery' },
{ oid => '5001', descr => 'transform to tsquery',
proname => 'phraseto_tsquery', procost => '100', provolatile => 's',
prorettype => 'tsquery', proargtypes => 'text',
prosrc => 'phraseto_tsquery' },
Cosmetic cleanups in initial catalog data. Write ',' and ';' for typdelim values instead of the obscurantist ASCII octal equivalents. Not sure why anybody ever thought the latter were better; maybe it had something to do with lack of a better quoting convention, twenty-plus years ago? Reassign a couple of high-numbered OIDs that were left in during yesterday's mad rush to commit stuff of uncertain internal temperature. The latter requires a catversion bump, though the former wouldn't since the end-result catalog data is unchanged.
2018-04-08 21:55:49 +02:00
{ oid => '5009', descr => 'transform to tsquery',
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
proname => 'websearch_to_tsquery', procost => '100', provolatile => 's',
prorettype => 'tsquery', proargtypes => 'text',
prosrc => 'websearch_to_tsquery' },
{ oid => '4209', descr => 'transform string values from jsonb to tsvector',
proname => 'to_tsvector', procost => '100', provolatile => 's',
prorettype => 'tsvector', proargtypes => 'jsonb',
prosrc => 'jsonb_string_to_tsvector' },
{ oid => '4213', descr => 'transform specified values from jsonb to tsvector',
proname => 'jsonb_to_tsvector', procost => '100', provolatile => 's',
prorettype => 'tsvector', proargtypes => 'jsonb jsonb',
prosrc => 'jsonb_to_tsvector' },
{ oid => '4210', descr => 'transform string values from json to tsvector',
proname => 'to_tsvector', procost => '100', provolatile => 's',
prorettype => 'tsvector', proargtypes => 'json',
prosrc => 'json_string_to_tsvector' },
{ oid => '4215', descr => 'transform specified values from json to tsvector',
proname => 'json_to_tsvector', procost => '100', provolatile => 's',
prorettype => 'tsvector', proargtypes => 'json jsonb',
prosrc => 'json_to_tsvector' },
{ oid => '4211', descr => 'transform string values from jsonb to tsvector',
proname => 'to_tsvector', procost => '100', prorettype => 'tsvector',
proargtypes => 'regconfig jsonb', prosrc => 'jsonb_string_to_tsvector_byid' },
{ oid => '4214', descr => 'transform specified values from jsonb to tsvector',
proname => 'jsonb_to_tsvector', procost => '100', prorettype => 'tsvector',
proargtypes => 'regconfig jsonb jsonb', prosrc => 'jsonb_to_tsvector_byid' },
{ oid => '4212', descr => 'transform string values from json to tsvector',
proname => 'to_tsvector', procost => '100', prorettype => 'tsvector',
proargtypes => 'regconfig json', prosrc => 'json_string_to_tsvector_byid' },
{ oid => '4216', descr => 'transform specified values from json to tsvector',
proname => 'json_to_tsvector', procost => '100', prorettype => 'tsvector',
proargtypes => 'regconfig json jsonb', prosrc => 'json_to_tsvector_byid' },
{ oid => '3752', descr => 'trigger for automatic update of tsvector column',
proname => 'tsvector_update_trigger', proisstrict => 'f', provolatile => 'v',
prorettype => 'trigger', proargtypes => '',
prosrc => 'tsvector_update_trigger_byid' },
{ oid => '3753', descr => 'trigger for automatic update of tsvector column',
proname => 'tsvector_update_trigger_column', proisstrict => 'f',
provolatile => 'v', prorettype => 'trigger', proargtypes => '',
prosrc => 'tsvector_update_trigger_bycolumn' },
{ oid => '3759', descr => 'get current tsearch configuration',
proname => 'get_current_ts_config', provolatile => 's',
prorettype => 'regconfig', proargtypes => '',
prosrc => 'get_current_ts_config' },
{ oid => '3736', descr => 'I/O',
proname => 'regconfigin', provolatile => 's', prorettype => 'regconfig',
proargtypes => 'cstring', prosrc => 'regconfigin' },
{ oid => '3737', descr => 'I/O',
proname => 'regconfigout', provolatile => 's', prorettype => 'cstring',
proargtypes => 'regconfig', prosrc => 'regconfigout' },
{ oid => '3738', descr => 'I/O',
proname => 'regconfigrecv', prorettype => 'regconfig',
proargtypes => 'internal', prosrc => 'regconfigrecv' },
{ oid => '3739', descr => 'I/O',
proname => 'regconfigsend', prorettype => 'bytea', proargtypes => 'regconfig',
prosrc => 'regconfigsend' },
{ oid => '3771', descr => 'I/O',
proname => 'regdictionaryin', provolatile => 's',
prorettype => 'regdictionary', proargtypes => 'cstring',
prosrc => 'regdictionaryin' },
{ oid => '3772', descr => 'I/O',
proname => 'regdictionaryout', provolatile => 's', prorettype => 'cstring',
proargtypes => 'regdictionary', prosrc => 'regdictionaryout' },
{ oid => '3773', descr => 'I/O',
proname => 'regdictionaryrecv', prorettype => 'regdictionary',
proargtypes => 'internal', prosrc => 'regdictionaryrecv' },
{ oid => '3774', descr => 'I/O',
proname => 'regdictionarysend', prorettype => 'bytea',
proargtypes => 'regdictionary', prosrc => 'regdictionarysend' },
# jsonb
{ oid => '3806', descr => 'I/O',
proname => 'jsonb_in', prorettype => 'jsonb', proargtypes => 'cstring',
prosrc => 'jsonb_in' },
{ oid => '3805', descr => 'I/O',
proname => 'jsonb_recv', prorettype => 'jsonb', proargtypes => 'internal',
prosrc => 'jsonb_recv' },
{ oid => '3804', descr => 'I/O',
proname => 'jsonb_out', prorettype => 'cstring', proargtypes => 'jsonb',
prosrc => 'jsonb_out' },
{ oid => '3803', descr => 'I/O',
proname => 'jsonb_send', prorettype => 'bytea', proargtypes => 'jsonb',
prosrc => 'jsonb_send' },
{ oid => '3263', descr => 'map text array of key value pairs to jsonb object',
proname => 'jsonb_object', prorettype => 'jsonb', proargtypes => '_text',
prosrc => 'jsonb_object' },
{ oid => '3264', descr => 'map text array of key value pairs to jsonb object',
proname => 'jsonb_object', prorettype => 'jsonb',
proargtypes => '_text _text', prosrc => 'jsonb_object_two_arg' },
{ oid => '3787', descr => 'map input to jsonb',
proname => 'to_jsonb', provolatile => 's', prorettype => 'jsonb',
proargtypes => 'anyelement', prosrc => 'to_jsonb' },
{ oid => '3265', descr => 'jsonb aggregate transition function',
proname => 'jsonb_agg_transfn', proisstrict => 'f', provolatile => 's',
prorettype => 'internal', proargtypes => 'internal anyelement',
prosrc => 'jsonb_agg_transfn' },
{ oid => '3266', descr => 'jsonb aggregate final function',
proname => 'jsonb_agg_finalfn', proisstrict => 'f', provolatile => 's',
prorettype => 'jsonb', proargtypes => 'internal',
prosrc => 'jsonb_agg_finalfn' },
{ oid => '3267', descr => 'aggregate input into jsonb',
proname => 'jsonb_agg', prokind => 'a', proisstrict => 'f',
provolatile => 's', prorettype => 'jsonb', proargtypes => 'anyelement',
prosrc => 'aggregate_dummy' },
{ oid => '3268', descr => 'jsonb object aggregate transition function',
proname => 'jsonb_object_agg_transfn', proisstrict => 'f', provolatile => 's',
prorettype => 'internal', proargtypes => 'internal any any',
prosrc => 'jsonb_object_agg_transfn' },
{ oid => '3269', descr => 'jsonb object aggregate final function',
proname => 'jsonb_object_agg_finalfn', proisstrict => 'f', provolatile => 's',
prorettype => 'jsonb', proargtypes => 'internal',
prosrc => 'jsonb_object_agg_finalfn' },
{ oid => '3270', descr => 'aggregate inputs into jsonb object',
proname => 'jsonb_object_agg', prokind => 'a', proisstrict => 'f',
prorettype => 'jsonb', proargtypes => 'any any',
prosrc => 'aggregate_dummy' },
{ oid => '3271', descr => 'build a jsonb array from any inputs',
proname => 'jsonb_build_array', provariadic => 'any', proisstrict => 'f',
provolatile => 's', prorettype => 'jsonb', proargtypes => 'any',
proallargtypes => '{any}', proargmodes => '{v}',
prosrc => 'jsonb_build_array' },
{ oid => '3272', descr => 'build an empty jsonb array',
proname => 'jsonb_build_array', proisstrict => 'f', provolatile => 's',
prorettype => 'jsonb', proargtypes => '',
prosrc => 'jsonb_build_array_noargs' },
{ oid => '3273',
descr => 'build a jsonb object from pairwise key/value inputs',
proname => 'jsonb_build_object', provariadic => 'any', proisstrict => 'f',
provolatile => 's', prorettype => 'jsonb', proargtypes => 'any',
proallargtypes => '{any}', proargmodes => '{v}',
prosrc => 'jsonb_build_object' },
{ oid => '3274', descr => 'build an empty jsonb object',
proname => 'jsonb_build_object', proisstrict => 'f', provolatile => 's',
prorettype => 'jsonb', proargtypes => '',
prosrc => 'jsonb_build_object_noargs' },
{ oid => '3262', descr => 'remove object fields with null values from jsonb',
proname => 'jsonb_strip_nulls', prorettype => 'jsonb', proargtypes => 'jsonb',
prosrc => 'jsonb_strip_nulls' },
{ oid => '3478',
proname => 'jsonb_object_field', prorettype => 'jsonb',
proargtypes => 'jsonb text', proargnames => '{from_json, field_name}',
prosrc => 'jsonb_object_field' },
{ oid => '3214',
proname => 'jsonb_object_field_text', prorettype => 'text',
proargtypes => 'jsonb text', proargnames => '{from_json, field_name}',
prosrc => 'jsonb_object_field_text' },
{ oid => '3215',
proname => 'jsonb_array_element', prorettype => 'jsonb',
proargtypes => 'jsonb int4', proargnames => '{from_json, element_index}',
prosrc => 'jsonb_array_element' },
{ oid => '3216',
proname => 'jsonb_array_element_text', prorettype => 'text',
proargtypes => 'jsonb int4', proargnames => '{from_json, element_index}',
prosrc => 'jsonb_array_element_text' },
{ oid => '3217', descr => 'get value from jsonb with path elements',
proname => 'jsonb_extract_path', provariadic => 'text', prorettype => 'jsonb',
proargtypes => 'jsonb _text', proallargtypes => '{jsonb,_text}',
proargmodes => '{i,v}', proargnames => '{from_json,path_elems}',
prosrc => 'jsonb_extract_path' },
{ oid => '3940', descr => 'get value from jsonb as text with path elements',
proname => 'jsonb_extract_path_text', provariadic => 'text',
prorettype => 'text', proargtypes => 'jsonb _text',
proallargtypes => '{jsonb,_text}', proargmodes => '{i,v}',
proargnames => '{from_json,path_elems}',
prosrc => 'jsonb_extract_path_text' },
{ oid => '3219', descr => 'elements of a jsonb array',
proname => 'jsonb_array_elements', prorows => '100', proretset => 't',
prorettype => 'jsonb', proargtypes => 'jsonb',
proallargtypes => '{jsonb,jsonb}', proargmodes => '{i,o}',
proargnames => '{from_json,value}', prosrc => 'jsonb_array_elements' },
{ oid => '3465', descr => 'elements of jsonb array',
proname => 'jsonb_array_elements_text', prorows => '100', proretset => 't',
prorettype => 'text', proargtypes => 'jsonb',
proallargtypes => '{jsonb,text}', proargmodes => '{i,o}',
proargnames => '{from_json,value}', prosrc => 'jsonb_array_elements_text' },
{ oid => '3207', descr => 'length of jsonb array',
proname => 'jsonb_array_length', prorettype => 'int4', proargtypes => 'jsonb',
prosrc => 'jsonb_array_length' },
{ oid => '3931', descr => 'get jsonb object keys',
proname => 'jsonb_object_keys', prorows => '100', proretset => 't',
prorettype => 'text', proargtypes => 'jsonb', prosrc => 'jsonb_object_keys' },
{ oid => '3208', descr => 'key value pairs of a jsonb object',
proname => 'jsonb_each', prorows => '100', proretset => 't',
prorettype => 'record', proargtypes => 'jsonb',
proallargtypes => '{jsonb,text,jsonb}', proargmodes => '{i,o,o}',
proargnames => '{from_json,key,value}', prosrc => 'jsonb_each' },
{ oid => '3932', descr => 'key value pairs of a jsonb object',
proname => 'jsonb_each_text', prorows => '100', proretset => 't',
prorettype => 'record', proargtypes => 'jsonb',
proallargtypes => '{jsonb,text,text}', proargmodes => '{i,o,o}',
proargnames => '{from_json,key,value}', prosrc => 'jsonb_each_text' },
{ oid => '3209', descr => 'get record fields from a jsonb object',
proname => 'jsonb_populate_record', proisstrict => 'f', provolatile => 's',
prorettype => 'anyelement', proargtypes => 'anyelement jsonb',
prosrc => 'jsonb_populate_record' },
{ oid => '3475',
descr => 'get set of records with fields from a jsonb array of objects',
proname => 'jsonb_populate_recordset', prorows => '100', proisstrict => 'f',
proretset => 't', provolatile => 's', prorettype => 'anyelement',
proargtypes => 'anyelement jsonb', prosrc => 'jsonb_populate_recordset' },
{ oid => '3490', descr => 'get record fields from a jsonb object',
proname => 'jsonb_to_record', provolatile => 's', prorettype => 'record',
proargtypes => 'jsonb', prosrc => 'jsonb_to_record' },
{ oid => '3491',
descr => 'get set of records with fields from a jsonb array of objects',
proname => 'jsonb_to_recordset', prorows => '100', proisstrict => 'f',
proretset => 't', provolatile => 's', prorettype => 'record',
proargtypes => 'jsonb', prosrc => 'jsonb_to_recordset' },
{ oid => '3210', descr => 'get the type of a jsonb value',
proname => 'jsonb_typeof', prorettype => 'text', proargtypes => 'jsonb',
prosrc => 'jsonb_typeof' },
{ oid => '4038',
proname => 'jsonb_ne', prorettype => 'bool', proargtypes => 'jsonb jsonb',
prosrc => 'jsonb_ne' },
{ oid => '4039',
proname => 'jsonb_lt', prorettype => 'bool', proargtypes => 'jsonb jsonb',
prosrc => 'jsonb_lt' },
{ oid => '4040',
proname => 'jsonb_gt', prorettype => 'bool', proargtypes => 'jsonb jsonb',
prosrc => 'jsonb_gt' },
{ oid => '4041',
proname => 'jsonb_le', prorettype => 'bool', proargtypes => 'jsonb jsonb',
prosrc => 'jsonb_le' },
{ oid => '4042',
proname => 'jsonb_ge', prorettype => 'bool', proargtypes => 'jsonb jsonb',
prosrc => 'jsonb_ge' },
{ oid => '4043',
proname => 'jsonb_eq', prorettype => 'bool', proargtypes => 'jsonb jsonb',
prosrc => 'jsonb_eq' },
{ oid => '4044', descr => 'less-equal-greater',
proname => 'jsonb_cmp', prorettype => 'int4', proargtypes => 'jsonb jsonb',
prosrc => 'jsonb_cmp' },
{ oid => '4045', descr => 'hash',
proname => 'jsonb_hash', prorettype => 'int4', proargtypes => 'jsonb',
prosrc => 'jsonb_hash' },
{ oid => '3416', descr => 'hash',
proname => 'jsonb_hash_extended', prorettype => 'int8',
proargtypes => 'jsonb int8', prosrc => 'jsonb_hash_extended' },
{ oid => '4046',
proname => 'jsonb_contains', prorettype => 'bool',
proargtypes => 'jsonb jsonb', prosrc => 'jsonb_contains' },
{ oid => '4047',
proname => 'jsonb_exists', prorettype => 'bool', proargtypes => 'jsonb text',
prosrc => 'jsonb_exists' },
{ oid => '4048',
proname => 'jsonb_exists_any', prorettype => 'bool',
proargtypes => 'jsonb _text', prosrc => 'jsonb_exists_any' },
{ oid => '4049',
proname => 'jsonb_exists_all', prorettype => 'bool',
proargtypes => 'jsonb _text', prosrc => 'jsonb_exists_all' },
{ oid => '4050',
proname => 'jsonb_contained', prorettype => 'bool',
proargtypes => 'jsonb jsonb', prosrc => 'jsonb_contained' },
{ oid => '3480', descr => 'GIN support',
proname => 'gin_compare_jsonb', prorettype => 'int4',
proargtypes => 'text text', prosrc => 'gin_compare_jsonb' },
{ oid => '3482', descr => 'GIN support',
proname => 'gin_extract_jsonb', prorettype => 'internal',
proargtypes => 'jsonb internal internal', prosrc => 'gin_extract_jsonb' },
{ oid => '3483', descr => 'GIN support',
proname => 'gin_extract_jsonb_query', prorettype => 'internal',
proargtypes => 'jsonb internal int2 internal internal internal internal',
prosrc => 'gin_extract_jsonb_query' },
{ oid => '3484', descr => 'GIN support',
proname => 'gin_consistent_jsonb', prorettype => 'bool',
proargtypes => 'internal int2 jsonb int4 internal internal internal internal',
prosrc => 'gin_consistent_jsonb' },
{ oid => '3488', descr => 'GIN support',
proname => 'gin_triconsistent_jsonb', prorettype => 'char',
proargtypes => 'internal int2 jsonb int4 internal internal internal',
prosrc => 'gin_triconsistent_jsonb' },
{ oid => '3485', descr => 'GIN support',
proname => 'gin_extract_jsonb_path', prorettype => 'internal',
proargtypes => 'jsonb internal internal',
prosrc => 'gin_extract_jsonb_path' },
{ oid => '3486', descr => 'GIN support',
proname => 'gin_extract_jsonb_query_path', prorettype => 'internal',
proargtypes => 'jsonb internal int2 internal internal internal internal',
prosrc => 'gin_extract_jsonb_query_path' },
{ oid => '3487', descr => 'GIN support',
proname => 'gin_consistent_jsonb_path', prorettype => 'bool',
proargtypes => 'internal int2 jsonb int4 internal internal internal internal',
prosrc => 'gin_consistent_jsonb_path' },
{ oid => '3489', descr => 'GIN support',
proname => 'gin_triconsistent_jsonb_path', prorettype => 'char',
proargtypes => 'internal int2 jsonb int4 internal internal internal',
prosrc => 'gin_triconsistent_jsonb_path' },
{ oid => '3301',
proname => 'jsonb_concat', prorettype => 'jsonb',
proargtypes => 'jsonb jsonb', prosrc => 'jsonb_concat' },
{ oid => '3302',
proname => 'jsonb_delete', prorettype => 'jsonb', proargtypes => 'jsonb text',
prosrc => 'jsonb_delete' },
{ oid => '3303',
proname => 'jsonb_delete', prorettype => 'jsonb', proargtypes => 'jsonb int4',
prosrc => 'jsonb_delete_idx' },
{ oid => '3343',
proname => 'jsonb_delete', provariadic => 'text', prorettype => 'jsonb',
proargtypes => 'jsonb _text', proallargtypes => '{jsonb,_text}',
proargmodes => '{i,v}', proargnames => '{from_json,path_elems}',
prosrc => 'jsonb_delete_array' },
{ oid => '3304',
proname => 'jsonb_delete_path', prorettype => 'jsonb',
proargtypes => 'jsonb _text', prosrc => 'jsonb_delete_path' },
{ oid => '3305', descr => 'Set part of a jsonb',
proname => 'jsonb_set', prorettype => 'jsonb',
proargtypes => 'jsonb _text jsonb bool', prosrc => 'jsonb_set' },
{ oid => '3306', descr => 'Indented text from jsonb',
proname => 'jsonb_pretty', prorettype => 'text', proargtypes => 'jsonb',
prosrc => 'jsonb_pretty' },
{ oid => '3579', descr => 'Insert value into a jsonb',
proname => 'jsonb_insert', prorettype => 'jsonb',
proargtypes => 'jsonb _text jsonb bool', prosrc => 'jsonb_insert' },
# txid
{ oid => '2939', descr => 'I/O',
proname => 'txid_snapshot_in', prorettype => 'txid_snapshot',
proargtypes => 'cstring', prosrc => 'txid_snapshot_in' },
{ oid => '2940', descr => 'I/O',
proname => 'txid_snapshot_out', prorettype => 'cstring',
proargtypes => 'txid_snapshot', prosrc => 'txid_snapshot_out' },
{ oid => '2941', descr => 'I/O',
proname => 'txid_snapshot_recv', prorettype => 'txid_snapshot',
proargtypes => 'internal', prosrc => 'txid_snapshot_recv' },
{ oid => '2942', descr => 'I/O',
proname => 'txid_snapshot_send', prorettype => 'bytea',
proargtypes => 'txid_snapshot', prosrc => 'txid_snapshot_send' },
{ oid => '2943', descr => 'get current transaction ID',
proname => 'txid_current', provolatile => 's', proparallel => 'u',
prorettype => 'int8', proargtypes => '', prosrc => 'txid_current' },
{ oid => '3348', descr => 'get current transaction ID',
proname => 'txid_current_if_assigned', provolatile => 's', proparallel => 'u',
prorettype => 'int8', proargtypes => '',
prosrc => 'txid_current_if_assigned' },
{ oid => '2944', descr => 'get current snapshot',
proname => 'txid_current_snapshot', provolatile => 's',
prorettype => 'txid_snapshot', proargtypes => '',
prosrc => 'txid_current_snapshot' },
{ oid => '2945', descr => 'get xmin of snapshot',
proname => 'txid_snapshot_xmin', prorettype => 'int8',
proargtypes => 'txid_snapshot', prosrc => 'txid_snapshot_xmin' },
{ oid => '2946', descr => 'get xmax of snapshot',
proname => 'txid_snapshot_xmax', prorettype => 'int8',
proargtypes => 'txid_snapshot', prosrc => 'txid_snapshot_xmax' },
{ oid => '2947', descr => 'get set of in-progress txids in snapshot',
proname => 'txid_snapshot_xip', prorows => '50', proretset => 't',
prorettype => 'int8', proargtypes => 'txid_snapshot',
prosrc => 'txid_snapshot_xip' },
{ oid => '2948', descr => 'is txid visible in snapshot?',
proname => 'txid_visible_in_snapshot', prorettype => 'bool',
proargtypes => 'int8 txid_snapshot', prosrc => 'txid_visible_in_snapshot' },
{ oid => '3360', descr => 'commit status of transaction',
proname => 'txid_status', provolatile => 'v', prorettype => 'text',
proargtypes => 'int8', prosrc => 'txid_status' },
# record comparison using normal comparison rules
{ oid => '2981',
proname => 'record_eq', prorettype => 'bool', proargtypes => 'record record',
prosrc => 'record_eq' },
{ oid => '2982',
proname => 'record_ne', prorettype => 'bool', proargtypes => 'record record',
prosrc => 'record_ne' },
{ oid => '2983',
proname => 'record_lt', prorettype => 'bool', proargtypes => 'record record',
prosrc => 'record_lt' },
{ oid => '2984',
proname => 'record_gt', prorettype => 'bool', proargtypes => 'record record',
prosrc => 'record_gt' },
{ oid => '2985',
proname => 'record_le', prorettype => 'bool', proargtypes => 'record record',
prosrc => 'record_le' },
{ oid => '2986',
proname => 'record_ge', prorettype => 'bool', proargtypes => 'record record',
prosrc => 'record_ge' },
{ oid => '2987', descr => 'less-equal-greater',
proname => 'btrecordcmp', prorettype => 'int4',
proargtypes => 'record record', prosrc => 'btrecordcmp' },
# record comparison using raw byte images
{ oid => '3181',
proname => 'record_image_eq', prorettype => 'bool',
proargtypes => 'record record', prosrc => 'record_image_eq' },
{ oid => '3182',
proname => 'record_image_ne', prorettype => 'bool',
proargtypes => 'record record', prosrc => 'record_image_ne' },
{ oid => '3183',
proname => 'record_image_lt', prorettype => 'bool',
proargtypes => 'record record', prosrc => 'record_image_lt' },
{ oid => '3184',
proname => 'record_image_gt', prorettype => 'bool',
proargtypes => 'record record', prosrc => 'record_image_gt' },
{ oid => '3185',
proname => 'record_image_le', prorettype => 'bool',
proargtypes => 'record record', prosrc => 'record_image_le' },
{ oid => '3186',
proname => 'record_image_ge', prorettype => 'bool',
proargtypes => 'record record', prosrc => 'record_image_ge' },
{ oid => '3187', descr => 'less-equal-greater based on byte images',
proname => 'btrecordimagecmp', prorettype => 'int4',
proargtypes => 'record record', prosrc => 'btrecordimagecmp' },
# Extensions
{ oid => '3082', descr => 'list available extensions',
proname => 'pg_available_extensions', procost => '10', prorows => '100',
proretset => 't', provolatile => 's', prorettype => 'record',
proargtypes => '', proallargtypes => '{name,text,text}',
proargmodes => '{o,o,o}', proargnames => '{name,default_version,comment}',
prosrc => 'pg_available_extensions' },
{ oid => '3083', descr => 'list available extension versions',
proname => 'pg_available_extension_versions', procost => '10',
prorows => '100', proretset => 't', provolatile => 's',
prorettype => 'record', proargtypes => '',
proallargtypes => '{name,text,bool,bool,name,_name,text}',
proargmodes => '{o,o,o,o,o,o,o}',
proargnames => '{name,version,superuser,relocatable,schema,requires,comment}',
prosrc => 'pg_available_extension_versions' },
{ oid => '3084', descr => 'list an extension\'s version update paths',
proname => 'pg_extension_update_paths', procost => '10', prorows => '100',
proretset => 't', provolatile => 's', prorettype => 'record',
proargtypes => 'name', proallargtypes => '{name,text,text,text}',
proargmodes => '{i,o,o,o}', proargnames => '{name,source,target,path}',
prosrc => 'pg_extension_update_paths' },
{ oid => '3086',
descr => 'flag an extension\'s table contents to be emitted by pg_dump',
proname => 'pg_extension_config_dump', provolatile => 'v', proparallel => 'u',
prorettype => 'void', proargtypes => 'regclass text',
prosrc => 'pg_extension_config_dump' },
# SQL-spec window functions
{ oid => '3100', descr => 'row number within partition',
proname => 'row_number', prokind => 'w', proisstrict => 'f',
prorettype => 'int8', proargtypes => '', prosrc => 'window_row_number' },
{ oid => '3101', descr => 'integer rank with gaps',
proname => 'rank', prokind => 'w', proisstrict => 'f', prorettype => 'int8',
proargtypes => '', prosrc => 'window_rank' },
{ oid => '3102', descr => 'integer rank without gaps',
proname => 'dense_rank', prokind => 'w', proisstrict => 'f',
prorettype => 'int8', proargtypes => '', prosrc => 'window_dense_rank' },
{ oid => '3103', descr => 'fractional rank within partition',
proname => 'percent_rank', prokind => 'w', proisstrict => 'f',
prorettype => 'float8', proargtypes => '', prosrc => 'window_percent_rank' },
{ oid => '3104', descr => 'fractional row number within partition',
proname => 'cume_dist', prokind => 'w', proisstrict => 'f',
prorettype => 'float8', proargtypes => '', prosrc => 'window_cume_dist' },
{ oid => '3105', descr => 'split rows into N groups',
proname => 'ntile', prokind => 'w', prorettype => 'int4',
proargtypes => 'int4', prosrc => 'window_ntile' },
{ oid => '3106', descr => 'fetch the preceding row value',
proname => 'lag', prokind => 'w', prorettype => 'anyelement',
proargtypes => 'anyelement', prosrc => 'window_lag' },
{ oid => '3107', descr => 'fetch the Nth preceding row value',
proname => 'lag', prokind => 'w', prorettype => 'anyelement',
proargtypes => 'anyelement int4', prosrc => 'window_lag_with_offset' },
{ oid => '3108', descr => 'fetch the Nth preceding row value with default',
proname => 'lag', prokind => 'w', prorettype => 'anyelement',
proargtypes => 'anyelement int4 anyelement',
prosrc => 'window_lag_with_offset_and_default' },
{ oid => '3109', descr => 'fetch the following row value',
proname => 'lead', prokind => 'w', prorettype => 'anyelement',
proargtypes => 'anyelement', prosrc => 'window_lead' },
{ oid => '3110', descr => 'fetch the Nth following row value',
proname => 'lead', prokind => 'w', prorettype => 'anyelement',
proargtypes => 'anyelement int4', prosrc => 'window_lead_with_offset' },
{ oid => '3111', descr => 'fetch the Nth following row value with default',
proname => 'lead', prokind => 'w', prorettype => 'anyelement',
proargtypes => 'anyelement int4 anyelement',
prosrc => 'window_lead_with_offset_and_default' },
{ oid => '3112', descr => 'fetch the first row value',
proname => 'first_value', prokind => 'w', prorettype => 'anyelement',
proargtypes => 'anyelement', prosrc => 'window_first_value' },
{ oid => '3113', descr => 'fetch the last row value',
proname => 'last_value', prokind => 'w', prorettype => 'anyelement',
proargtypes => 'anyelement', prosrc => 'window_last_value' },
{ oid => '3114', descr => 'fetch the Nth row value',
proname => 'nth_value', prokind => 'w', prorettype => 'anyelement',
proargtypes => 'anyelement int4', prosrc => 'window_nth_value' },
# functions for range types
{ oid => '3832', descr => 'I/O',
proname => 'anyrange_in', provolatile => 's', prorettype => 'anyrange',
proargtypes => 'cstring oid int4', prosrc => 'anyrange_in' },
{ oid => '3833', descr => 'I/O',
proname => 'anyrange_out', provolatile => 's', prorettype => 'cstring',
proargtypes => 'anyrange', prosrc => 'anyrange_out' },
{ oid => '3834', descr => 'I/O',
proname => 'range_in', provolatile => 's', prorettype => 'anyrange',
proargtypes => 'cstring oid int4', prosrc => 'range_in' },
{ oid => '3835', descr => 'I/O',
proname => 'range_out', provolatile => 's', prorettype => 'cstring',
proargtypes => 'anyrange', prosrc => 'range_out' },
{ oid => '3836', descr => 'I/O',
proname => 'range_recv', provolatile => 's', prorettype => 'anyrange',
proargtypes => 'internal oid int4', prosrc => 'range_recv' },
{ oid => '3837', descr => 'I/O',
proname => 'range_send', provolatile => 's', prorettype => 'bytea',
proargtypes => 'anyrange', prosrc => 'range_send' },
{ oid => '3848', descr => 'lower bound of range',
proname => 'lower', prorettype => 'anyelement', proargtypes => 'anyrange',
prosrc => 'range_lower' },
{ oid => '3849', descr => 'upper bound of range',
proname => 'upper', prorettype => 'anyelement', proargtypes => 'anyrange',
prosrc => 'range_upper' },
{ oid => '3850', descr => 'is the range empty?',
proname => 'isempty', prorettype => 'bool', proargtypes => 'anyrange',
prosrc => 'range_empty' },
{ oid => '3851', descr => 'is the range\'s lower bound inclusive?',
proname => 'lower_inc', prorettype => 'bool', proargtypes => 'anyrange',
prosrc => 'range_lower_inc' },
{ oid => '3852', descr => 'is the range\'s upper bound inclusive?',
proname => 'upper_inc', prorettype => 'bool', proargtypes => 'anyrange',
prosrc => 'range_upper_inc' },
{ oid => '3853', descr => 'is the range\'s lower bound infinite?',
proname => 'lower_inf', prorettype => 'bool', proargtypes => 'anyrange',
prosrc => 'range_lower_inf' },
{ oid => '3854', descr => 'is the range\'s upper bound infinite?',
proname => 'upper_inf', prorettype => 'bool', proargtypes => 'anyrange',
prosrc => 'range_upper_inf' },
{ oid => '3855',
proname => 'range_eq', prorettype => 'bool',
proargtypes => 'anyrange anyrange', prosrc => 'range_eq' },
{ oid => '3856',
proname => 'range_ne', prorettype => 'bool',
proargtypes => 'anyrange anyrange', prosrc => 'range_ne' },
{ oid => '3857',
proname => 'range_overlaps', prorettype => 'bool',
proargtypes => 'anyrange anyrange', prosrc => 'range_overlaps' },
{ oid => '3858',
proname => 'range_contains_elem', prorettype => 'bool',
proargtypes => 'anyrange anyelement', prosrc => 'range_contains_elem' },
{ oid => '3859',
proname => 'range_contains', prorettype => 'bool',
proargtypes => 'anyrange anyrange', prosrc => 'range_contains' },
{ oid => '3860',
proname => 'elem_contained_by_range', prorettype => 'bool',
proargtypes => 'anyelement anyrange', prosrc => 'elem_contained_by_range' },
{ oid => '3861',
proname => 'range_contained_by', prorettype => 'bool',
proargtypes => 'anyrange anyrange', prosrc => 'range_contained_by' },
{ oid => '3862',
proname => 'range_adjacent', prorettype => 'bool',
proargtypes => 'anyrange anyrange', prosrc => 'range_adjacent' },
{ oid => '3863',
proname => 'range_before', prorettype => 'bool',
proargtypes => 'anyrange anyrange', prosrc => 'range_before' },
{ oid => '3864',
proname => 'range_after', prorettype => 'bool',
proargtypes => 'anyrange anyrange', prosrc => 'range_after' },
{ oid => '3865',
proname => 'range_overleft', prorettype => 'bool',
proargtypes => 'anyrange anyrange', prosrc => 'range_overleft' },
{ oid => '3866',
proname => 'range_overright', prorettype => 'bool',
proargtypes => 'anyrange anyrange', prosrc => 'range_overright' },
{ oid => '3867',
proname => 'range_union', prorettype => 'anyrange',
proargtypes => 'anyrange anyrange', prosrc => 'range_union' },
{ oid => '4057',
descr => 'the smallest range which includes both of the given ranges',
proname => 'range_merge', prorettype => 'anyrange',
proargtypes => 'anyrange anyrange', prosrc => 'range_merge' },
{ oid => '3868',
proname => 'range_intersect', prorettype => 'anyrange',
proargtypes => 'anyrange anyrange', prosrc => 'range_intersect' },
{ oid => '3869',
proname => 'range_minus', prorettype => 'anyrange',
proargtypes => 'anyrange anyrange', prosrc => 'range_minus' },
{ oid => '3870', descr => 'less-equal-greater',
proname => 'range_cmp', prorettype => 'int4',
proargtypes => 'anyrange anyrange', prosrc => 'range_cmp' },
{ oid => '3871',
proname => 'range_lt', prorettype => 'bool',
proargtypes => 'anyrange anyrange', prosrc => 'range_lt' },
{ oid => '3872',
proname => 'range_le', prorettype => 'bool',
proargtypes => 'anyrange anyrange', prosrc => 'range_le' },
{ oid => '3873',
proname => 'range_ge', prorettype => 'bool',
proargtypes => 'anyrange anyrange', prosrc => 'range_ge' },
{ oid => '3874',
proname => 'range_gt', prorettype => 'bool',
proargtypes => 'anyrange anyrange', prosrc => 'range_gt' },
{ oid => '3875', descr => 'GiST support',
proname => 'range_gist_consistent', prorettype => 'bool',
proargtypes => 'internal anyrange int2 oid internal',
prosrc => 'range_gist_consistent' },
{ oid => '3876', descr => 'GiST support',
proname => 'range_gist_union', prorettype => 'anyrange',
proargtypes => 'internal internal', prosrc => 'range_gist_union' },
{ oid => '3879', descr => 'GiST support',
proname => 'range_gist_penalty', prorettype => 'internal',
proargtypes => 'internal internal internal', prosrc => 'range_gist_penalty' },
{ oid => '3880', descr => 'GiST support',
proname => 'range_gist_picksplit', prorettype => 'internal',
proargtypes => 'internal internal', prosrc => 'range_gist_picksplit' },
{ oid => '3881', descr => 'GiST support',
proname => 'range_gist_same', prorettype => 'internal',
proargtypes => 'anyrange anyrange internal', prosrc => 'range_gist_same' },
{ oid => '3902', descr => 'hash a range',
proname => 'hash_range', prorettype => 'int4', proargtypes => 'anyrange',
prosrc => 'hash_range' },
{ oid => '3417', descr => 'hash a range',
proname => 'hash_range_extended', prorettype => 'int8',
proargtypes => 'anyrange int8', prosrc => 'hash_range_extended' },
{ oid => '3916', descr => 'range typanalyze',
proname => 'range_typanalyze', provolatile => 's', prorettype => 'bool',
proargtypes => 'internal', prosrc => 'range_typanalyze' },
{ oid => '3169', descr => 'restriction selectivity for range operators',
proname => 'rangesel', provolatile => 's', prorettype => 'float8',
proargtypes => 'internal oid internal int4', prosrc => 'rangesel' },
{ oid => '3914', descr => 'convert an int4 range to canonical form',
proname => 'int4range_canonical', prorettype => 'int4range',
proargtypes => 'int4range', prosrc => 'int4range_canonical' },
{ oid => '3928', descr => 'convert an int8 range to canonical form',
proname => 'int8range_canonical', prorettype => 'int8range',
proargtypes => 'int8range', prosrc => 'int8range_canonical' },
{ oid => '3915', descr => 'convert a date range to canonical form',
proname => 'daterange_canonical', prorettype => 'daterange',
proargtypes => 'daterange', prosrc => 'daterange_canonical' },
{ oid => '3922', descr => 'float8 difference of two int4 values',
proname => 'int4range_subdiff', prorettype => 'float8',
proargtypes => 'int4 int4', prosrc => 'int4range_subdiff' },
{ oid => '3923', descr => 'float8 difference of two int8 values',
proname => 'int8range_subdiff', prorettype => 'float8',
proargtypes => 'int8 int8', prosrc => 'int8range_subdiff' },
{ oid => '3924', descr => 'float8 difference of two numeric values',
proname => 'numrange_subdiff', prorettype => 'float8',
proargtypes => 'numeric numeric', prosrc => 'numrange_subdiff' },
{ oid => '3925', descr => 'float8 difference of two date values',
proname => 'daterange_subdiff', prorettype => 'float8',
proargtypes => 'date date', prosrc => 'daterange_subdiff' },
{ oid => '3929', descr => 'float8 difference of two timestamp values',
proname => 'tsrange_subdiff', prorettype => 'float8',
proargtypes => 'timestamp timestamp', prosrc => 'tsrange_subdiff' },
{ oid => '3930',
descr => 'float8 difference of two timestamp with time zone values',
proname => 'tstzrange_subdiff', prorettype => 'float8',
proargtypes => 'timestamptz timestamptz', prosrc => 'tstzrange_subdiff' },
{ oid => '3840', descr => 'int4range constructor',
proname => 'int4range', proisstrict => 'f', prorettype => 'int4range',
proargtypes => 'int4 int4', prosrc => 'range_constructor2' },
{ oid => '3841', descr => 'int4range constructor',
proname => 'int4range', proisstrict => 'f', prorettype => 'int4range',
proargtypes => 'int4 int4 text', prosrc => 'range_constructor3' },
{ oid => '3844', descr => 'numrange constructor',
proname => 'numrange', proisstrict => 'f', prorettype => 'numrange',
proargtypes => 'numeric numeric', prosrc => 'range_constructor2' },
{ oid => '3845', descr => 'numrange constructor',
proname => 'numrange', proisstrict => 'f', prorettype => 'numrange',
proargtypes => 'numeric numeric text', prosrc => 'range_constructor3' },
{ oid => '3933', descr => 'tsrange constructor',
proname => 'tsrange', proisstrict => 'f', prorettype => 'tsrange',
proargtypes => 'timestamp timestamp', prosrc => 'range_constructor2' },
{ oid => '3934', descr => 'tsrange constructor',
proname => 'tsrange', proisstrict => 'f', prorettype => 'tsrange',
proargtypes => 'timestamp timestamp text', prosrc => 'range_constructor3' },
{ oid => '3937', descr => 'tstzrange constructor',
proname => 'tstzrange', proisstrict => 'f', prorettype => 'tstzrange',
proargtypes => 'timestamptz timestamptz', prosrc => 'range_constructor2' },
{ oid => '3938', descr => 'tstzrange constructor',
proname => 'tstzrange', proisstrict => 'f', prorettype => 'tstzrange',
proargtypes => 'timestamptz timestamptz text',
prosrc => 'range_constructor3' },
{ oid => '3941', descr => 'daterange constructor',
proname => 'daterange', proisstrict => 'f', prorettype => 'daterange',
proargtypes => 'date date', prosrc => 'range_constructor2' },
{ oid => '3942', descr => 'daterange constructor',
proname => 'daterange', proisstrict => 'f', prorettype => 'daterange',
proargtypes => 'date date text', prosrc => 'range_constructor3' },
{ oid => '3945', descr => 'int8range constructor',
proname => 'int8range', proisstrict => 'f', prorettype => 'int8range',
proargtypes => 'int8 int8', prosrc => 'range_constructor2' },
{ oid => '3946', descr => 'int8range constructor',
proname => 'int8range', proisstrict => 'f', prorettype => 'int8range',
proargtypes => 'int8 int8 text', prosrc => 'range_constructor3' },
# date, time, timestamp constructors
{ oid => '3846', descr => 'construct date',
proname => 'make_date', prorettype => 'date', proargtypes => 'int4 int4 int4',
proargnames => '{year,month,day}', prosrc => 'make_date' },
{ oid => '3847', descr => 'construct time',
proname => 'make_time', prorettype => 'time',
proargtypes => 'int4 int4 float8', proargnames => '{hour,min,sec}',
prosrc => 'make_time' },
{ oid => '3461', descr => 'construct timestamp',
proname => 'make_timestamp', prorettype => 'timestamp',
proargtypes => 'int4 int4 int4 int4 int4 float8',
proargnames => '{year,month,mday,hour,min,sec}', prosrc => 'make_timestamp' },
{ oid => '3462', descr => 'construct timestamp with time zone',
proname => 'make_timestamptz', provolatile => 's',
prorettype => 'timestamptz', proargtypes => 'int4 int4 int4 int4 int4 float8',
proargnames => '{year,month,mday,hour,min,sec}',
prosrc => 'make_timestamptz' },
{ oid => '3463', descr => 'construct timestamp with time zone',
proname => 'make_timestamptz', provolatile => 's',
prorettype => 'timestamptz',
proargtypes => 'int4 int4 int4 int4 int4 float8 text',
proargnames => '{year,month,mday,hour,min,sec,timezone}',
prosrc => 'make_timestamptz_at_timezone' },
{ oid => '3464', descr => 'construct interval',
proname => 'make_interval', prorettype => 'interval',
proargtypes => 'int4 int4 int4 int4 int4 int4 float8',
proargnames => '{years,months,weeks,days,hours,mins,secs}',
prosrc => 'make_interval' },
# spgist opclasses
{ oid => '4018', descr => 'SP-GiST support for quad tree over point',
proname => 'spg_quad_config', prorettype => 'void',
proargtypes => 'internal internal', prosrc => 'spg_quad_config' },
{ oid => '4019', descr => 'SP-GiST support for quad tree over point',
proname => 'spg_quad_choose', prorettype => 'void',
proargtypes => 'internal internal', prosrc => 'spg_quad_choose' },
{ oid => '4020', descr => 'SP-GiST support for quad tree over point',
proname => 'spg_quad_picksplit', prorettype => 'void',
proargtypes => 'internal internal', prosrc => 'spg_quad_picksplit' },
{ oid => '4021', descr => 'SP-GiST support for quad tree over point',
proname => 'spg_quad_inner_consistent', prorettype => 'void',
proargtypes => 'internal internal', prosrc => 'spg_quad_inner_consistent' },
{ oid => '4022',
descr => 'SP-GiST support for quad tree and k-d tree over point',
proname => 'spg_quad_leaf_consistent', prorettype => 'bool',
proargtypes => 'internal internal', prosrc => 'spg_quad_leaf_consistent' },
{ oid => '4023', descr => 'SP-GiST support for k-d tree over point',
proname => 'spg_kd_config', prorettype => 'void',
proargtypes => 'internal internal', prosrc => 'spg_kd_config' },
{ oid => '4024', descr => 'SP-GiST support for k-d tree over point',
proname => 'spg_kd_choose', prorettype => 'void',
proargtypes => 'internal internal', prosrc => 'spg_kd_choose' },
{ oid => '4025', descr => 'SP-GiST support for k-d tree over point',
proname => 'spg_kd_picksplit', prorettype => 'void',
proargtypes => 'internal internal', prosrc => 'spg_kd_picksplit' },
{ oid => '4026', descr => 'SP-GiST support for k-d tree over point',
proname => 'spg_kd_inner_consistent', prorettype => 'void',
proargtypes => 'internal internal', prosrc => 'spg_kd_inner_consistent' },
{ oid => '4027', descr => 'SP-GiST support for radix tree over text',
proname => 'spg_text_config', prorettype => 'void',
proargtypes => 'internal internal', prosrc => 'spg_text_config' },
{ oid => '4028', descr => 'SP-GiST support for radix tree over text',
proname => 'spg_text_choose', prorettype => 'void',
proargtypes => 'internal internal', prosrc => 'spg_text_choose' },
{ oid => '4029', descr => 'SP-GiST support for radix tree over text',
proname => 'spg_text_picksplit', prorettype => 'void',
proargtypes => 'internal internal', prosrc => 'spg_text_picksplit' },
{ oid => '4030', descr => 'SP-GiST support for radix tree over text',
proname => 'spg_text_inner_consistent', prorettype => 'void',
proargtypes => 'internal internal', prosrc => 'spg_text_inner_consistent' },
{ oid => '4031', descr => 'SP-GiST support for radix tree over text',
proname => 'spg_text_leaf_consistent', prorettype => 'bool',
proargtypes => 'internal internal', prosrc => 'spg_text_leaf_consistent' },
{ oid => '3469', descr => 'SP-GiST support for quad tree over range',
proname => 'spg_range_quad_config', prorettype => 'void',
proargtypes => 'internal internal', prosrc => 'spg_range_quad_config' },
{ oid => '3470', descr => 'SP-GiST support for quad tree over range',
proname => 'spg_range_quad_choose', prorettype => 'void',
proargtypes => 'internal internal', prosrc => 'spg_range_quad_choose' },
{ oid => '3471', descr => 'SP-GiST support for quad tree over range',
proname => 'spg_range_quad_picksplit', prorettype => 'void',
proargtypes => 'internal internal', prosrc => 'spg_range_quad_picksplit' },
{ oid => '3472', descr => 'SP-GiST support for quad tree over range',
proname => 'spg_range_quad_inner_consistent', prorettype => 'void',
proargtypes => 'internal internal',
prosrc => 'spg_range_quad_inner_consistent' },
{ oid => '3473', descr => 'SP-GiST support for quad tree over range',
proname => 'spg_range_quad_leaf_consistent', prorettype => 'bool',
proargtypes => 'internal internal',
prosrc => 'spg_range_quad_leaf_consistent' },
{ oid => '5012', descr => 'SP-GiST support for quad tree over box',
proname => 'spg_box_quad_config', prorettype => 'void',
proargtypes => 'internal internal', prosrc => 'spg_box_quad_config' },
{ oid => '5013', descr => 'SP-GiST support for quad tree over box',
proname => 'spg_box_quad_choose', prorettype => 'void',
proargtypes => 'internal internal', prosrc => 'spg_box_quad_choose' },
{ oid => '5014', descr => 'SP-GiST support for quad tree over box',
proname => 'spg_box_quad_picksplit', prorettype => 'void',
proargtypes => 'internal internal', prosrc => 'spg_box_quad_picksplit' },
{ oid => '5015', descr => 'SP-GiST support for quad tree over box',
proname => 'spg_box_quad_inner_consistent', prorettype => 'void',
proargtypes => 'internal internal',
prosrc => 'spg_box_quad_inner_consistent' },
{ oid => '5016', descr => 'SP-GiST support for quad tree over box',
proname => 'spg_box_quad_leaf_consistent', prorettype => 'bool',
proargtypes => 'internal internal',
prosrc => 'spg_box_quad_leaf_consistent' },
{ oid => '5010',
descr => 'SP-GiST support for quad tree over 2-D types represented by their bounding boxes',
proname => 'spg_bbox_quad_config', prorettype => 'void',
proargtypes => 'internal internal', prosrc => 'spg_bbox_quad_config' },
{ oid => '5011', descr => 'SP-GiST support for quad tree over polygons',
proname => 'spg_poly_quad_compress', prorettype => 'box',
proargtypes => 'polygon', prosrc => 'spg_poly_quad_compress' },
# replication slots
{ oid => '3779', descr => 'create a physical replication slot',
proname => 'pg_create_physical_replication_slot', provolatile => 'v',
proparallel => 'u', prorettype => 'record', proargtypes => 'name bool bool',
proallargtypes => '{name,bool,bool,name,pg_lsn}',
proargmodes => '{i,i,i,o,o}',
proargnames => '{slot_name,immediately_reserve,temporary,slot_name,lsn}',
prosrc => 'pg_create_physical_replication_slot' },
{ oid => '3780', descr => 'drop a replication slot',
proname => 'pg_drop_replication_slot', provolatile => 'v', proparallel => 'u',
prorettype => 'void', proargtypes => 'name',
prosrc => 'pg_drop_replication_slot' },
{ oid => '3781',
descr => 'information about replication slots currently in use',
proname => 'pg_get_replication_slots', prorows => '10', proisstrict => 'f',
proretset => 't', provolatile => 's', prorettype => 'record',
proargtypes => '',
proallargtypes => '{name,name,text,oid,bool,bool,int4,xid,xid,pg_lsn,pg_lsn}',
proargmodes => '{o,o,o,o,o,o,o,o,o,o,o}',
proargnames => '{slot_name,plugin,slot_type,datoid,temporary,active,active_pid,xmin,catalog_xmin,restart_lsn,confirmed_flush_lsn}',
prosrc => 'pg_get_replication_slots' },
{ oid => '3786', descr => 'set up a logical replication slot',
proname => 'pg_create_logical_replication_slot', provolatile => 'v',
proparallel => 'u', prorettype => 'record', proargtypes => 'name name bool',
Fix argument of pg_create_logical_replication_slot for slot name All attributes and arguments using a slot name map to the data type "name", but this function has been using "text". This is cosmetic, as even if text is used then the slot name would be truncated to 64 characters anyway and stored as such. The documentation already said so and the function already assumed that the argument was of this type when fetching its value. Bump catalog version. Author: Sawada Masahiko Discussion: https://postgr.es/m/CAD21AoADYz_-eAqH5AVFaCaojcRgwpo9PW=u8kgTMys63oB8Cw@mail.gmail.com
2018-07-13 02:32:12 +02:00
proallargtypes => '{name,name,bool,name,pg_lsn}',
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
proargmodes => '{i,i,i,o,o}',
proargnames => '{slot_name,plugin,temporary,slot_name,lsn}',
prosrc => 'pg_create_logical_replication_slot' },
{ oid => '3782', descr => 'get changes from replication slot',
proname => 'pg_logical_slot_get_changes', procost => '1000',
prorows => '1000', provariadic => 'text', proisstrict => 'f',
proretset => 't', provolatile => 'v', proparallel => 'u',
prorettype => 'record', proargtypes => 'name pg_lsn int4 _text',
proallargtypes => '{name,pg_lsn,int4,_text,pg_lsn,xid,text}',
proargmodes => '{i,i,i,v,o,o,o}',
proargnames => '{slot_name,upto_lsn,upto_nchanges,options,lsn,xid,data}',
prosrc => 'pg_logical_slot_get_changes' },
{ oid => '3783', descr => 'get binary changes from replication slot',
proname => 'pg_logical_slot_get_binary_changes', procost => '1000',
prorows => '1000', provariadic => 'text', proisstrict => 'f',
proretset => 't', provolatile => 'v', proparallel => 'u',
prorettype => 'record', proargtypes => 'name pg_lsn int4 _text',
proallargtypes => '{name,pg_lsn,int4,_text,pg_lsn,xid,bytea}',
proargmodes => '{i,i,i,v,o,o,o}',
proargnames => '{slot_name,upto_lsn,upto_nchanges,options,lsn,xid,data}',
prosrc => 'pg_logical_slot_get_binary_changes' },
{ oid => '3784', descr => 'peek at changes from replication slot',
proname => 'pg_logical_slot_peek_changes', procost => '1000',
prorows => '1000', provariadic => 'text', proisstrict => 'f',
proretset => 't', provolatile => 'v', proparallel => 'u',
prorettype => 'record', proargtypes => 'name pg_lsn int4 _text',
proallargtypes => '{name,pg_lsn,int4,_text,pg_lsn,xid,text}',
proargmodes => '{i,i,i,v,o,o,o}',
proargnames => '{slot_name,upto_lsn,upto_nchanges,options,lsn,xid,data}',
prosrc => 'pg_logical_slot_peek_changes' },
{ oid => '3785', descr => 'peek at binary changes from replication slot',
proname => 'pg_logical_slot_peek_binary_changes', procost => '1000',
prorows => '1000', provariadic => 'text', proisstrict => 'f',
proretset => 't', provolatile => 'v', proparallel => 'u',
prorettype => 'record', proargtypes => 'name pg_lsn int4 _text',
proallargtypes => '{name,pg_lsn,int4,_text,pg_lsn,xid,bytea}',
proargmodes => '{i,i,i,v,o,o,o}',
proargnames => '{slot_name,upto_lsn,upto_nchanges,options,lsn,xid,data}',
prosrc => 'pg_logical_slot_peek_binary_changes' },
{ oid => '3878', descr => 'advance logical replication slot',
proname => 'pg_replication_slot_advance', provolatile => 'v',
proparallel => 'u', prorettype => 'record', proargtypes => 'name pg_lsn',
proallargtypes => '{name,pg_lsn,name,pg_lsn}', proargmodes => '{i,i,o,o}',
proargnames => '{slot_name,upto_lsn,slot_name,end_lsn}',
prosrc => 'pg_replication_slot_advance' },
{ oid => '3577', descr => 'emit a textual logical decoding message',
proname => 'pg_logical_emit_message', provolatile => 'v', proparallel => 'u',
prorettype => 'pg_lsn', proargtypes => 'bool text text',
prosrc => 'pg_logical_emit_message_text' },
{ oid => '3578', descr => 'emit a binary logical decoding message',
proname => 'pg_logical_emit_message', provolatile => 'v', proparallel => 'u',
prorettype => 'pg_lsn', proargtypes => 'bool text bytea',
prosrc => 'pg_logical_emit_message_bytea' },
# event triggers
{ oid => '3566', descr => 'list objects dropped by the current command',
proname => 'pg_event_trigger_dropped_objects', procost => '10',
prorows => '100', proretset => 't', provolatile => 's', proparallel => 'r',
prorettype => 'record', proargtypes => '',
proallargtypes => '{oid,oid,int4,bool,bool,bool,text,text,text,text,_text,_text}',
proargmodes => '{o,o,o,o,o,o,o,o,o,o,o,o}',
proargnames => '{classid, objid, objsubid, original, normal, is_temporary, object_type, schema_name, object_name, object_identity, address_names, address_args}',
prosrc => 'pg_event_trigger_dropped_objects' },
{ oid => '4566', descr => 'return Oid of the table getting rewritten',
proname => 'pg_event_trigger_table_rewrite_oid', provolatile => 's',
proparallel => 'r', prorettype => 'oid', proargtypes => '',
proallargtypes => '{oid}', proargmodes => '{o}', proargnames => '{oid}',
prosrc => 'pg_event_trigger_table_rewrite_oid' },
{ oid => '4567', descr => 'return reason code for table getting rewritten',
proname => 'pg_event_trigger_table_rewrite_reason', provolatile => 's',
proparallel => 'r', prorettype => 'int4', proargtypes => '',
prosrc => 'pg_event_trigger_table_rewrite_reason' },
{ oid => '4568',
descr => 'list DDL actions being executed by the current command',
proname => 'pg_event_trigger_ddl_commands', procost => '10', prorows => '100',
proretset => 't', provolatile => 's', proparallel => 'r',
prorettype => 'record', proargtypes => '',
proallargtypes => '{oid,oid,int4,text,text,text,text,bool,pg_ddl_command}',
proargmodes => '{o,o,o,o,o,o,o,o,o}',
proargnames => '{classid, objid, objsubid, command_tag, object_type, schema_name, object_identity, in_extension, command}',
prosrc => 'pg_event_trigger_ddl_commands' },
# generic transition functions for ordered-set aggregates
{ oid => '3970', descr => 'aggregate transition function',
proname => 'ordered_set_transition', proisstrict => 'f',
prorettype => 'internal', proargtypes => 'internal any',
prosrc => 'ordered_set_transition' },
{ oid => '3971', descr => 'aggregate transition function',
proname => 'ordered_set_transition_multi', provariadic => 'any',
proisstrict => 'f', prorettype => 'internal', proargtypes => 'internal any',
proallargtypes => '{internal,any}', proargmodes => '{i,v}',
prosrc => 'ordered_set_transition_multi' },
# inverse distribution aggregates (and their support functions)
{ oid => '3972', descr => 'discrete percentile',
proname => 'percentile_disc', prokind => 'a', proisstrict => 'f',
prorettype => 'anyelement', proargtypes => 'float8 anyelement',
prosrc => 'aggregate_dummy' },
{ oid => '3973', descr => 'aggregate final function',
proname => 'percentile_disc_final', proisstrict => 'f',
prorettype => 'anyelement', proargtypes => 'internal float8 anyelement',
prosrc => 'percentile_disc_final' },
{ oid => '3974', descr => 'continuous distribution percentile',
proname => 'percentile_cont', prokind => 'a', proisstrict => 'f',
prorettype => 'float8', proargtypes => 'float8 float8',
prosrc => 'aggregate_dummy' },
{ oid => '3975', descr => 'aggregate final function',
proname => 'percentile_cont_float8_final', proisstrict => 'f',
prorettype => 'float8', proargtypes => 'internal float8',
prosrc => 'percentile_cont_float8_final' },
{ oid => '3976', descr => 'continuous distribution percentile',
proname => 'percentile_cont', prokind => 'a', proisstrict => 'f',
prorettype => 'interval', proargtypes => 'float8 interval',
prosrc => 'aggregate_dummy' },
{ oid => '3977', descr => 'aggregate final function',
proname => 'percentile_cont_interval_final', proisstrict => 'f',
prorettype => 'interval', proargtypes => 'internal float8',
prosrc => 'percentile_cont_interval_final' },
{ oid => '3978', descr => 'multiple discrete percentiles',
proname => 'percentile_disc', prokind => 'a', proisstrict => 'f',
prorettype => 'anyarray', proargtypes => '_float8 anyelement',
prosrc => 'aggregate_dummy' },
{ oid => '3979', descr => 'aggregate final function',
proname => 'percentile_disc_multi_final', proisstrict => 'f',
prorettype => 'anyarray', proargtypes => 'internal _float8 anyelement',
prosrc => 'percentile_disc_multi_final' },
{ oid => '3980', descr => 'multiple continuous percentiles',
proname => 'percentile_cont', prokind => 'a', proisstrict => 'f',
prorettype => '_float8', proargtypes => '_float8 float8',
prosrc => 'aggregate_dummy' },
{ oid => '3981', descr => 'aggregate final function',
proname => 'percentile_cont_float8_multi_final', proisstrict => 'f',
prorettype => '_float8', proargtypes => 'internal _float8',
prosrc => 'percentile_cont_float8_multi_final' },
{ oid => '3982', descr => 'multiple continuous percentiles',
proname => 'percentile_cont', prokind => 'a', proisstrict => 'f',
prorettype => '_interval', proargtypes => '_float8 interval',
prosrc => 'aggregate_dummy' },
{ oid => '3983', descr => 'aggregate final function',
proname => 'percentile_cont_interval_multi_final', proisstrict => 'f',
prorettype => '_interval', proargtypes => 'internal _float8',
prosrc => 'percentile_cont_interval_multi_final' },
{ oid => '3984', descr => 'most common value',
proname => 'mode', prokind => 'a', proisstrict => 'f',
prorettype => 'anyelement', proargtypes => 'anyelement',
prosrc => 'aggregate_dummy' },
{ oid => '3985', descr => 'aggregate final function',
proname => 'mode_final', proisstrict => 'f', prorettype => 'anyelement',
proargtypes => 'internal anyelement', prosrc => 'mode_final' },
# hypothetical-set aggregates (and their support functions)
{ oid => '3986', descr => 'rank of hypothetical row',
proname => 'rank', provariadic => 'any', prokind => 'a', proisstrict => 'f',
prorettype => 'int8', proargtypes => 'any', proallargtypes => '{any}',
proargmodes => '{v}', prosrc => 'aggregate_dummy' },
{ oid => '3987', descr => 'aggregate final function',
proname => 'rank_final', provariadic => 'any', proisstrict => 'f',
prorettype => 'int8', proargtypes => 'internal any',
proallargtypes => '{internal,any}', proargmodes => '{i,v}',
prosrc => 'hypothetical_rank_final' },
{ oid => '3988', descr => 'fractional rank of hypothetical row',
proname => 'percent_rank', provariadic => 'any', prokind => 'a',
proisstrict => 'f', prorettype => 'float8', proargtypes => 'any',
proallargtypes => '{any}', proargmodes => '{v}',
prosrc => 'aggregate_dummy' },
{ oid => '3989', descr => 'aggregate final function',
proname => 'percent_rank_final', provariadic => 'any', proisstrict => 'f',
prorettype => 'float8', proargtypes => 'internal any',
proallargtypes => '{internal,any}', proargmodes => '{i,v}',
prosrc => 'hypothetical_percent_rank_final' },
{ oid => '3990', descr => 'cumulative distribution of hypothetical row',
proname => 'cume_dist', provariadic => 'any', prokind => 'a',
proisstrict => 'f', prorettype => 'float8', proargtypes => 'any',
proallargtypes => '{any}', proargmodes => '{v}',
prosrc => 'aggregate_dummy' },
{ oid => '3991', descr => 'aggregate final function',
proname => 'cume_dist_final', provariadic => 'any', proisstrict => 'f',
prorettype => 'float8', proargtypes => 'internal any',
proallargtypes => '{internal,any}', proargmodes => '{i,v}',
prosrc => 'hypothetical_cume_dist_final' },
{ oid => '3992', descr => 'rank of hypothetical row without gaps',
proname => 'dense_rank', provariadic => 'any', prokind => 'a',
proisstrict => 'f', prorettype => 'int8', proargtypes => 'any',
proallargtypes => '{any}', proargmodes => '{v}',
prosrc => 'aggregate_dummy' },
{ oid => '3993', descr => 'aggregate final function',
proname => 'dense_rank_final', provariadic => 'any', proisstrict => 'f',
prorettype => 'int8', proargtypes => 'internal any',
proallargtypes => '{internal,any}', proargmodes => '{i,v}',
prosrc => 'hypothetical_dense_rank_final' },
# pg_upgrade support
{ oid => '3582', descr => 'for use by pg_upgrade',
proname => 'binary_upgrade_set_next_pg_type_oid', provolatile => 'v',
proparallel => 'r', prorettype => 'void', proargtypes => 'oid',
prosrc => 'binary_upgrade_set_next_pg_type_oid' },
{ oid => '3584', descr => 'for use by pg_upgrade',
proname => 'binary_upgrade_set_next_array_pg_type_oid', provolatile => 'v',
proparallel => 'r', prorettype => 'void', proargtypes => 'oid',
prosrc => 'binary_upgrade_set_next_array_pg_type_oid' },
{ oid => '3585', descr => 'for use by pg_upgrade',
proname => 'binary_upgrade_set_next_toast_pg_type_oid', provolatile => 'v',
proparallel => 'r', prorettype => 'void', proargtypes => 'oid',
prosrc => 'binary_upgrade_set_next_toast_pg_type_oid' },
{ oid => '3586', descr => 'for use by pg_upgrade',
proname => 'binary_upgrade_set_next_heap_pg_class_oid', provolatile => 'v',
proparallel => 'r', prorettype => 'void', proargtypes => 'oid',
prosrc => 'binary_upgrade_set_next_heap_pg_class_oid' },
{ oid => '3587', descr => 'for use by pg_upgrade',
proname => 'binary_upgrade_set_next_index_pg_class_oid', provolatile => 'v',
proparallel => 'r', prorettype => 'void', proargtypes => 'oid',
prosrc => 'binary_upgrade_set_next_index_pg_class_oid' },
{ oid => '3588', descr => 'for use by pg_upgrade',
proname => 'binary_upgrade_set_next_toast_pg_class_oid', provolatile => 'v',
proparallel => 'r', prorettype => 'void', proargtypes => 'oid',
prosrc => 'binary_upgrade_set_next_toast_pg_class_oid' },
{ oid => '3589', descr => 'for use by pg_upgrade',
proname => 'binary_upgrade_set_next_pg_enum_oid', provolatile => 'v',
proparallel => 'r', prorettype => 'void', proargtypes => 'oid',
prosrc => 'binary_upgrade_set_next_pg_enum_oid' },
{ oid => '3590', descr => 'for use by pg_upgrade',
proname => 'binary_upgrade_set_next_pg_authid_oid', provolatile => 'v',
proparallel => 'r', prorettype => 'void', proargtypes => 'oid',
prosrc => 'binary_upgrade_set_next_pg_authid_oid' },
{ oid => '3591', descr => 'for use by pg_upgrade',
proname => 'binary_upgrade_create_empty_extension', proisstrict => 'f',
provolatile => 'v', proparallel => 'u', prorettype => 'void',
proargtypes => 'text text bool text _oid _text _text',
prosrc => 'binary_upgrade_create_empty_extension' },
{ oid => '4083', descr => 'for use by pg_upgrade',
proname => 'binary_upgrade_set_record_init_privs', provolatile => 'v',
proparallel => 'r', prorettype => 'void', proargtypes => 'bool',
prosrc => 'binary_upgrade_set_record_init_privs' },
Allow for pg_upgrade of attributes with missing values Commit 16828d5c02 neglected to do this, so upgraded databases would silently get null instead of the specified default in rows without the attribute defined. A new binary upgrade function is provided to perform this and pg_dump is adjusted to output a call to the function if required in binary upgrade mode. Also included is code to drop missing attribute values for dropped columns. That way if the type is later dropped the missing value won't have a dangling reference to the type. Finally the regression tests are adjusted to ensure that there is a row with a missing value so that this code is exercised in upgrade testing. Catalog version unfortunately bumped. Regression test changes from Tom Lane. Remainder from me, reviewed by Tom Lane, Andres Freund, Alvaro Herrera Discussion: https://postgr.es/m/19987.1529420110@sss.pgh.pa.us
2018-06-22 14:42:36 +02:00
{ oid => '4101', descr => 'for use by pg_upgrade',
proname => 'binary_upgrade_set_missing_value', provolatile => 'v',
Mark binary_upgrade_set_missing_value as parallel_unsafe per buildfarm. Bump catalog version again although in practice nobody is going to use this in a parallel query.
2018-06-23 14:43:05 +02:00
proparallel => 'u', prorettype => 'void', proargtypes => 'oid text text',
Allow for pg_upgrade of attributes with missing values Commit 16828d5c02 neglected to do this, so upgraded databases would silently get null instead of the specified default in rows without the attribute defined. A new binary upgrade function is provided to perform this and pg_dump is adjusted to output a call to the function if required in binary upgrade mode. Also included is code to drop missing attribute values for dropped columns. That way if the type is later dropped the missing value won't have a dangling reference to the type. Finally the regression tests are adjusted to ensure that there is a row with a missing value so that this code is exercised in upgrade testing. Catalog version unfortunately bumped. Regression test changes from Tom Lane. Remainder from me, reviewed by Tom Lane, Andres Freund, Alvaro Herrera Discussion: https://postgr.es/m/19987.1529420110@sss.pgh.pa.us
2018-06-22 14:42:36 +02:00
prosrc => 'binary_upgrade_set_missing_value' },
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
# replication/origin.h
{ oid => '6003', descr => 'create a replication origin',
proname => 'pg_replication_origin_create', provolatile => 'v',
proparallel => 'u', prorettype => 'oid', proargtypes => 'text',
prosrc => 'pg_replication_origin_create' },
{ oid => '6004', descr => 'drop replication origin identified by its name',
proname => 'pg_replication_origin_drop', provolatile => 'v',
proparallel => 'u', prorettype => 'void', proargtypes => 'text',
prosrc => 'pg_replication_origin_drop' },
{ oid => '6005',
descr => 'translate the replication origin\'s name to its id',
proname => 'pg_replication_origin_oid', provolatile => 's',
prorettype => 'oid', proargtypes => 'text',
prosrc => 'pg_replication_origin_oid' },
{ oid => '6006',
descr => 'configure session to maintain replication progress tracking for the passed in origin',
proname => 'pg_replication_origin_session_setup', provolatile => 'v',
proparallel => 'u', prorettype => 'void', proargtypes => 'text',
prosrc => 'pg_replication_origin_session_setup' },
{ oid => '6007', descr => 'teardown configured replication progress tracking',
proname => 'pg_replication_origin_session_reset', provolatile => 'v',
proparallel => 'u', prorettype => 'void', proargtypes => '',
prosrc => 'pg_replication_origin_session_reset' },
{ oid => '6008',
descr => 'is a replication origin configured in this session',
proname => 'pg_replication_origin_session_is_setup', provolatile => 'v',
proparallel => 'r', prorettype => 'bool', proargtypes => '',
prosrc => 'pg_replication_origin_session_is_setup' },
{ oid => '6009',
descr => 'get the replication progress of the current session',
proname => 'pg_replication_origin_session_progress', provolatile => 'v',
proparallel => 'u', prorettype => 'pg_lsn', proargtypes => 'bool',
prosrc => 'pg_replication_origin_session_progress' },
{ oid => '6010', descr => 'setup the transaction\'s origin lsn and timestamp',
proname => 'pg_replication_origin_xact_setup', provolatile => 'v',
proparallel => 'r', prorettype => 'void', proargtypes => 'pg_lsn timestamptz',
prosrc => 'pg_replication_origin_xact_setup' },
{ oid => '6011', descr => 'reset the transaction\'s origin lsn and timestamp',
proname => 'pg_replication_origin_xact_reset', provolatile => 'v',
proparallel => 'r', prorettype => 'void', proargtypes => '',
prosrc => 'pg_replication_origin_xact_reset' },
{ oid => '6012',
descr => 'advance replication identifier to specific location',
proname => 'pg_replication_origin_advance', provolatile => 'v',
proparallel => 'u', prorettype => 'void', proargtypes => 'text pg_lsn',
prosrc => 'pg_replication_origin_advance' },
{ oid => '6013',
descr => 'get an individual replication origin\'s replication progress',
proname => 'pg_replication_origin_progress', provolatile => 'v',
proparallel => 'u', prorettype => 'pg_lsn', proargtypes => 'text bool',
prosrc => 'pg_replication_origin_progress' },
{ oid => '6014', descr => 'get progress for all replication origins',
proname => 'pg_show_replication_origin_status', prorows => '100',
proisstrict => 'f', proretset => 't', provolatile => 'v', proparallel => 'r',
prorettype => 'record', proargtypes => '',
proallargtypes => '{oid,text,pg_lsn,pg_lsn}', proargmodes => '{o,o,o,o}',
proargnames => '{local_id, external_id, remote_lsn, local_lsn}',
prosrc => 'pg_show_replication_origin_status' },
# publications
{ oid => '6119', descr => 'get OIDs of tables in a publication',
proname => 'pg_get_publication_tables', prorows => '1000', proretset => 't',
provolatile => 's', prorettype => 'oid', proargtypes => 'text',
proallargtypes => '{text,oid}', proargmodes => '{i,o}',
proargnames => '{pubname,relid}', prosrc => 'pg_get_publication_tables' },
{ oid => '6121',
descr => 'returns whether a relation can be part of a publication',
proname => 'pg_relation_is_publishable', provolatile => 's',
prorettype => 'bool', proargtypes => 'regclass',
prosrc => 'pg_relation_is_publishable' },
# rls
{ oid => '3298',
descr => 'row security for current context active on table by table oid',
proname => 'row_security_active', provolatile => 's', prorettype => 'bool',
proargtypes => 'oid', prosrc => 'row_security_active' },
{ oid => '3299',
descr => 'row security for current context active on table by table name',
proname => 'row_security_active', provolatile => 's', prorettype => 'bool',
proargtypes => 'text', prosrc => 'row_security_active_name' },
# pg_config
{ oid => '3400', descr => 'pg_config binary as a function',
proname => 'pg_config', prorows => '23', proretset => 't', proparallel => 'r',
prorettype => 'record', proargtypes => '', proallargtypes => '{text,text}',
proargmodes => '{o,o}', proargnames => '{name,setting}',
prosrc => 'pg_config' },
# pg_controldata related functions
{ oid => '3441',
descr => 'pg_controldata general state information as a function',
proname => 'pg_control_system', provolatile => 'v', prorettype => 'record',
proargtypes => '', proallargtypes => '{int4,int4,int8,timestamptz}',
proargmodes => '{o,o,o,o}',
proargnames => '{pg_control_version,catalog_version_no,system_identifier,pg_control_last_modified}',
prosrc => 'pg_control_system' },
{ oid => '3442',
descr => 'pg_controldata checkpoint state information as a function',
proname => 'pg_control_checkpoint', provolatile => 'v',
prorettype => 'record', proargtypes => '',
proallargtypes => '{pg_lsn,pg_lsn,text,int4,int4,bool,text,oid,xid,xid,xid,oid,xid,xid,oid,xid,xid,timestamptz}',
proargmodes => '{o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o}',
proargnames => '{checkpoint_lsn,redo_lsn,redo_wal_file,timeline_id,prev_timeline_id,full_page_writes,next_xid,next_oid,next_multixact_id,next_multi_offset,oldest_xid,oldest_xid_dbid,oldest_active_xid,oldest_multi_xid,oldest_multi_dbid,oldest_commit_ts_xid,newest_commit_ts_xid,checkpoint_time}',
prosrc => 'pg_control_checkpoint' },
{ oid => '3443',
descr => 'pg_controldata recovery state information as a function',
proname => 'pg_control_recovery', provolatile => 'v', prorettype => 'record',
proargtypes => '', proallargtypes => '{pg_lsn,int4,pg_lsn,pg_lsn,bool}',
proargmodes => '{o,o,o,o,o}',
proargnames => '{min_recovery_end_lsn,min_recovery_end_timeline,backup_start_lsn,backup_end_lsn,end_of_backup_record_required}',
prosrc => 'pg_control_recovery' },
{ oid => '3444',
descr => 'pg_controldata init state information as a function',
proname => 'pg_control_init', provolatile => 'v', prorettype => 'record',
proargtypes => '',
proallargtypes => '{int4,int4,int4,int4,int4,int4,int4,int4,int4,bool,bool,int4}',
proargmodes => '{o,o,o,o,o,o,o,o,o,o,o,o}',
proargnames => '{max_data_alignment,database_block_size,blocks_per_segment,wal_block_size,bytes_per_wal_segment,max_identifier_length,max_index_columns,max_toast_chunk_size,large_object_chunk_size,float4_pass_by_value,float8_pass_by_value,data_page_checksum_version}',
prosrc => 'pg_control_init' },
# collation management functions
{ oid => '3445', descr => 'import collations from operating system',
proname => 'pg_import_system_collations', procost => '100',
provolatile => 'v', proparallel => 'u', prorettype => 'int4',
proargtypes => 'regnamespace', prosrc => 'pg_import_system_collations' },
{ oid => '3448',
descr => 'get actual version of collation from operating system',
proname => 'pg_collation_actual_version', procost => '100',
provolatile => 'v', prorettype => 'text', proargtypes => 'oid',
prosrc => 'pg_collation_actual_version' },
# system management/monitoring related functions
{ oid => '3353', descr => 'list files in the log directory',
proname => 'pg_ls_logdir', procost => '10', prorows => '20', proretset => 't',
provolatile => 'v', prorettype => 'record', proargtypes => '',
proallargtypes => '{text,int8,timestamptz}', proargmodes => '{o,o,o}',
proargnames => '{name,size,modification}', prosrc => 'pg_ls_logdir' },
{ oid => '3354', descr => 'list of files in the WAL directory',
proname => 'pg_ls_waldir', procost => '10', prorows => '20', proretset => 't',
provolatile => 'v', prorettype => 'record', proargtypes => '',
proallargtypes => '{text,int8,timestamptz}', proargmodes => '{o,o,o}',
proargnames => '{name,size,modification}', prosrc => 'pg_ls_waldir' },
Add pg_ls_archive_statusdir function This function lists the contents of the WAL archive status directory, and is intended to be used by monitoring tools. Unlike pg_ls_dir(), access to it can be granted to non-superusers so that those monitoring tools can observe the principle of least privilege. Access is also given by default to members of pg_monitor. Author: Christoph Moench-Tegeder Reviewed-by: Aya Iwata Discussion: https://postgr.es/m/20180930205920.GA64534@elch.exwg.net
2018-10-09 15:29:09 +02:00
{ oid => '5031', descr => 'list of files in the archive_status directory',
Add a timezone-specific variant of date_trunc(). date_trunc(field, timestamptz, zone_name) performs truncation using the named time zone as reference, rather than working in the session time zone as is the default behavior. It's equivalent to date_trunc(field, timestamptz at time zone zone_name) at time zone zone_name but it's faster, easier to type, and arguably easier to understand. Vik Fearing and Tom Lane Discussion: https://postgr.es/m/6249ffc4-2b22-4c1b-4e7d-7af84fedd7c6@2ndquadrant.com
2018-11-14 21:41:07 +01:00
proname => 'pg_ls_archive_statusdir', procost => '10', prorows => '20',
proretset => 't', provolatile => 'v', prorettype => 'record',
proargtypes => '', proallargtypes => '{text,int8,timestamptz}',
proargmodes => '{o,o,o}', proargnames => '{name,size,modification}',
prosrc => 'pg_ls_archive_statusdir' },
Add pg_ls_tmpdir function This lists the contents of a temporary directory associated to a given tablespace, useful to get information about on-disk consumption caused by temporary files used by a session query. By default, pg_default is scanned, and a tablespace can be specified as argument. This function is intended to be used by monitoring tools, and, unlike pg_ls_dir(), access to them can be granted to non-superusers so that those monitoring tools can observe the principle of least privilege. Access is also given by default to members of pg_monitor. Author: Nathan Bossart Reviewed-by: Laurenz Albe Discussion: https://postgr.es/m/92F458A2-6459-44B8-A7F2-2ADD3225046A@amazon.com
2018-10-05 02:21:48 +02:00
{ oid => '5029', descr => 'list files in the pgsql_tmp directory',
proname => 'pg_ls_tmpdir', procost => '10', prorows => '20', proretset => 't',
provolatile => 'v', prorettype => 'record', proargtypes => '',
proallargtypes => '{text,int8,timestamptz}', proargmodes => '{o,o,o}',
proargnames => '{name,size,modification}', prosrc => 'pg_ls_tmpdir_noargs' },
{ oid => '5030', descr => 'list files in the pgsql_tmp directory',
proname => 'pg_ls_tmpdir', procost => '10', prorows => '20', proretset => 't',
provolatile => 'v', prorettype => 'record', proargtypes => 'oid',
proallargtypes => '{oid,text,int8,timestamptz}', proargmodes => '{i,o,o,o}',
Propagate xactStartTimestamp and stmtStartTimestamp to parallel workers. Previously, a worker process would establish values for these based on its own start time. In v10 and up, this can trivially be shown to cause misbehavior of transaction_timestamp(), timestamp_in(), and related functions which are (perhaps unwisely?) marked parallel-safe. It seems likely that other behaviors might diverge from what happens in the parent as well. It's not as trivial to demonstrate problems in 9.6 or 9.5, but I'm sure it's still possible, so back-patch to all branches containing parallel worker infrastructure. In HEAD only, mark now() and statement_timestamp() as parallel-safe (other affected functions already were). While in theory we could still squeeze that change into v11, it doesn't seem important enough to force a last-minute catversion bump. Konstantin Knizhnik, whacked around a bit by me Discussion: https://postgr.es/m/6406dbd2-5d37-4cb6-6eb2-9c44172c7e7c@postgrespro.ru
2018-10-06 18:00:09 +02:00
proargnames => '{tablespace,name,size,modification}',
prosrc => 'pg_ls_tmpdir_1arg' },
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
# hash partitioning constraint function
{ oid => '5028', descr => 'hash partition CHECK constraint',
proname => 'satisfies_hash_partition', provariadic => 'any',
proisstrict => 'f', prorettype => 'bool', proargtypes => 'oid int4 int4 any',
proargmodes => '{i,i,i,v}', prosrc => 'satisfies_hash_partition' },
Add pg_partition_tree to display information about partitions This new function is useful to display a full tree of partitions with a partitioned table given in output, and avoids the need of any complex WITH RECURSIVE query when looking at partition trees which are deep multiple levels. It returns a set of records, one for each partition, containing the partition's name, its immediate parent's name, a boolean value telling if the relation is a leaf in the tree and an integer telling its level in the partition tree with given table considered as root, beginning at zero for the root, and incrementing by one each time the scan goes one level down. Author: Amit Langote Reviewed-by: Jesper Pedersen, Michael Paquier, Robert Haas Discussion: https://postgr.es/m/8d00e51a-9a51-ad02-d53e-ba6bf50b2e52@lab.ntt.co.jp
2018-10-30 02:25:06 +01:00
# information about a partition tree
{ oid => '3423', descr => 'view partition tree tables',
proname => 'pg_partition_tree', prorows => '1000', proretset => 't',
provolatile => 'v', prorettype => 'record', proargtypes => 'regclass',
proallargtypes => '{regclass,regclass,regclass,bool,int4}',
proargmodes => '{i,o,o,o,o}',
proargnames => '{rootrelid,relid,parentrelid,isleaf,level}',
Add a timezone-specific variant of date_trunc(). date_trunc(field, timestamptz, zone_name) performs truncation using the named time zone as reference, rather than working in the session time zone as is the default behavior. It's equivalent to date_trunc(field, timestamptz at time zone zone_name) at time zone zone_name but it's faster, easier to type, and arguably easier to understand. Vik Fearing and Tom Lane Discussion: https://postgr.es/m/6249ffc4-2b22-4c1b-4e7d-7af84fedd7c6@2ndquadrant.com
2018-11-14 21:41:07 +01:00
prosrc => 'pg_partition_tree' },
Add pg_partition_tree to display information about partitions This new function is useful to display a full tree of partitions with a partitioned table given in output, and avoids the need of any complex WITH RECURSIVE query when looking at partition trees which are deep multiple levels. It returns a set of records, one for each partition, containing the partition's name, its immediate parent's name, a boolean value telling if the relation is a leaf in the tree and an integer telling its level in the partition tree with given table considered as root, beginning at zero for the root, and incrementing by one each time the scan goes one level down. Author: Amit Langote Reviewed-by: Jesper Pedersen, Michael Paquier, Robert Haas Discussion: https://postgr.es/m/8d00e51a-9a51-ad02-d53e-ba6bf50b2e52@lab.ntt.co.jp
2018-10-30 02:25:06 +01:00
Replace our traditional initial-catalog-data format with a better design. Historically, the initial catalog data to be installed during bootstrap has been written in DATA() lines in the catalog header files. This had lots of disadvantages: the format was badly underdocumented, it was very difficult to edit the data in any mechanized way, and due to the lack of any abstraction the data was verbose, hard to read/understand, and easy to get wrong. Hence, move this data into separate ".dat" files and represent it in a way that can easily be read and rewritten by Perl scripts. The new format is essentially "key => value" for each column; while it's a bit repetitive, explicit labeling of each value makes the data far more readable and less error-prone. Provide a way to abbreviate entries by omitting field values that match a specified default value for their column. This allows removal of a large amount of repetitive boilerplate and also lowers the barrier to adding new columns. Also teach genbki.pl how to translate symbolic OID references into numeric OIDs for more cases than just "regproc"-like pg_proc references. It can now do that for regprocedure-like references (thus solving the problem that regproc is ambiguous for overloaded functions), operators, types, opfamilies, opclasses, and access methods. Use this to turn nearly all OID cross-references in the initial data into symbolic form. This represents a very large step forward in readability and error resistance of the initial catalog data. It should also reduce the difficulty of renumbering OID assignments in uncommitted patches. Also, solve the longstanding problem that frontend code that would like to use OID macros and other information from the catalog headers often had difficulty with backend-only code in the headers. To do this, arrange for all generated macros, plus such other declarations as we deem fit, to be placed in "derived" header files that are safe for frontend inclusion. (Once clients migrate to using these pg_*_d.h headers, it will be possible to get rid of the pg_*_fn.h headers, which only exist to quarantine code away from clients. That is left for follow-on patches, however.) The now-automatically-generated macros include the Anum_xxx and Natts_xxx constants that we used to have to update by hand when adding or removing catalog columns. Replace the former manual method of generating OID macros for pg_type entries with an automatic method, ensuring that all built-in types have OID macros. (But note that this patch does not change the way that OID macros for pg_proc entries are built and used. It's not clear that making that match the other catalogs would be worth extra code churn.) Add SGML documentation explaining what the new data format is and how to work with it. Despite being a very large change in the catalog headers, there is no catversion bump here, because postgres.bki and related output files haven't changed at all. John Naylor, based on ideas from various people; review and minor additional coding by me; previous review by Alvaro Herrera Discussion: https://postgr.es/m/CAJVSVGWO48JbbwXkJz_yBFyGYW-M9YWxnPdxJBUosDC9ou_F0Q@mail.gmail.com
2018-04-08 19:16:50 +02:00
]