YQL-13710 use .dat from contrib

ref:9c6092ec75933d1325acf5ecf1217d408ea5dcad

192 files changed, 36513 insertions, 0 deletions

diff --git a/contrib/libs/postgresql/src/include/c.h b/contrib/libs/postgresql/src/include/c.h
new file mode 100644
index 0000000000..9cd5e233ac
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/c.h
@@ -0,0 +1,1327 @@
+/*-------------------------------------------------------------------------
+ *
+ * c.h
+ *	  Fundamental C definitions.  This is included by every .c file in
+ *	  PostgreSQL (via either postgres.h or postgres_fe.h, as appropriate).
+ *
+ *	  Note that the definitions here are not intended to be exposed to clients
+ *	  of the frontend interface libraries --- so we don't worry much about
+ *	  polluting the namespace with lots of stuff...
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/c.h
+ *
+ *-------------------------------------------------------------------------
+ */
+/*
+ *----------------------------------------------------------------
+ *	 TABLE OF CONTENTS
+ *
+ *		When adding stuff to this file, please try to put stuff
+ *		into the relevant section, or add new sections as appropriate.
+ *
+ *	  section	description
+ *	  -------	------------------------------------------------
+ *		0)		pg_config.h and standard system headers
+ *		1)		compiler characteristics
+ *		2)		bool, true, false
+ *		3)		standard system types
+ *		4)		IsValid macros for system types
+ *		5)		offsetof, lengthof, alignment
+ *		6)		assertions
+ *		7)		widely useful macros
+ *		8)		random stuff
+ *		9)		system-specific hacks
+ *
+ * NOTE: since this file is included by both frontend and backend modules,
+ * it's usually wrong to put an "extern" declaration here, unless it's
+ * ifdef'd so that it's seen in only one case or the other.
+ * typedefs and macros are the kind of thing that might go here.
+ *
+ *----------------------------------------------------------------
+ */
+#ifndef C_H
+#define C_H
+
+#include "postgres_ext.h"
+
+/* Must undef pg_config_ext.h symbols before including pg_config.h */
+#undef PG_INT64_TYPE
+
+#include "pg_config.h"
+#include "pg_config_manual.h"	/* must be after pg_config.h */
+#include "pg_config_os.h"		/* must be before any system header files */
+
+/* System header files that should be available everywhere in Postgres */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stddef.h>
+#include <stdarg.h>
+#ifdef HAVE_STRINGS_H
+#include <strings.h>
+#endif
+#include <stdint.h>
+#include <sys/types.h>
+#include <errno.h>
+#if defined(WIN32) || defined(__CYGWIN__)
+#include <fcntl.h>				/* ensure O_BINARY is available */
+#endif
+#include <locale.h>
+#ifdef ENABLE_NLS
+#include <libintl.h>
+#endif
+
+
+/* ----------------------------------------------------------------
+ *				Section 1: compiler characteristics
+ *
+ * type prefixes (const, signed, volatile, inline) are handled in pg_config.h.
+ * ----------------------------------------------------------------
+ */
+
+/*
+ * Disable "inline" if PG_FORCE_DISABLE_INLINE is defined.
+ * This is used to work around compiler bugs and might also be useful for
+ * investigatory purposes.
+ */
+#ifdef PG_FORCE_DISABLE_INLINE
+#undef inline
+#define inline
+#endif
+
+/*
+ * Attribute macros
+ *
+ * GCC: https://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
+ * GCC: https://gcc.gnu.org/onlinedocs/gcc/Type-Attributes.html
+ * Sunpro: https://docs.oracle.com/cd/E18659_01/html/821-1384/gjzke.html
+ * XLC: https://www.ibm.com/support/knowledgecenter/SSGH2K_13.1.2/com.ibm.xlc131.aix.doc/language_ref/function_attributes.html
+ * XLC: https://www.ibm.com/support/knowledgecenter/SSGH2K_13.1.2/com.ibm.xlc131.aix.doc/language_ref/type_attrib.html
+ */
+
+/* only GCC supports the unused attribute */
+#ifdef __GNUC__
+#define pg_attribute_unused() __attribute__((unused))
+#else
+#define pg_attribute_unused()
+#endif
+
+/*
+ * Place this macro before functions that should be allowed to make misaligned
+ * accesses.  Think twice before using it on non-x86-specific code!
+ * Testing can be done with "-fsanitize=alignment -fsanitize-trap=alignment"
+ * on clang, or "-fsanitize=alignment -fno-sanitize-recover=alignment" on gcc.
+ */
+#if __clang_major__ >= 7 || __GNUC__ >= 8
+#define pg_attribute_no_sanitize_alignment() __attribute__((no_sanitize("alignment")))
+#else
+#define pg_attribute_no_sanitize_alignment()
+#endif
+
+/*
+ * Append PG_USED_FOR_ASSERTS_ONLY to definitions of variables that are only
+ * used in assert-enabled builds, to avoid compiler warnings about unused
+ * variables in assert-disabled builds.
+ */
+#ifdef USE_ASSERT_CHECKING
+#define PG_USED_FOR_ASSERTS_ONLY
+#else
+#define PG_USED_FOR_ASSERTS_ONLY pg_attribute_unused()
+#endif
+
+/* GCC and XLC support format attributes */
+#if defined(__GNUC__) || defined(__IBMC__)
+#define pg_attribute_format_arg(a) __attribute__((format_arg(a)))
+#define pg_attribute_printf(f,a) __attribute__((format(PG_PRINTF_ATTRIBUTE, f, a)))
+#else
+#define pg_attribute_format_arg(a)
+#define pg_attribute_printf(f,a)
+#endif
+
+/* GCC, Sunpro and XLC support aligned, packed and noreturn */
+#if defined(__GNUC__) || defined(__SUNPRO_C) || defined(__IBMC__)
+#define pg_attribute_aligned(a) __attribute__((aligned(a)))
+#define pg_attribute_noreturn() __attribute__((noreturn))
+#define pg_attribute_packed() __attribute__((packed))
+#define HAVE_PG_ATTRIBUTE_NORETURN 1
+#else
+/*
+ * NB: aligned and packed are not given default definitions because they
+ * affect code functionality; they *must* be implemented by the compiler
+ * if they are to be used.
+ */
+#define pg_attribute_noreturn()
+#endif
+
+/*
+ * Use "pg_attribute_always_inline" in place of "inline" for functions that
+ * we wish to force inlining of, even when the compiler's heuristics would
+ * choose not to.  But, if possible, don't force inlining in unoptimized
+ * debug builds.
+ */
+#if (defined(__GNUC__) && __GNUC__ > 3 && defined(__OPTIMIZE__)) || defined(__SUNPRO_C) || defined(__IBMC__)
+/* GCC > 3, Sunpro and XLC support always_inline via __attribute__ */
+#define pg_attribute_always_inline __attribute__((always_inline)) inline
+#elif defined(_MSC_VER)
+/* MSVC has a special keyword for this */
+#define pg_attribute_always_inline __forceinline
+#else
+/* Otherwise, the best we can do is to say "inline" */
+#define pg_attribute_always_inline inline
+#endif
+
+/*
+ * Forcing a function not to be inlined can be useful if it's the slow path of
+ * a performance-critical function, or should be visible in profiles to allow
+ * for proper cost attribution.  Note that unlike the pg_attribute_XXX macros
+ * above, this should be placed before the function's return type and name.
+ */
+/* GCC, Sunpro and XLC support noinline via __attribute__ */
+#if (defined(__GNUC__) && __GNUC__ > 2) || defined(__SUNPRO_C) || defined(__IBMC__)
+#define pg_noinline __attribute__((noinline))
+/* msvc via declspec */
+#elif defined(_MSC_VER)
+#define pg_noinline __declspec(noinline)
+#else
+#define pg_noinline
+#endif
+
+/*
+ * Mark a point as unreachable in a portable fashion.  This should preferably
+ * be something that the compiler understands, to aid code generation.
+ * In assert-enabled builds, we prefer abort() for debugging reasons.
+ */
+#if defined(HAVE__BUILTIN_UNREACHABLE) && !defined(USE_ASSERT_CHECKING)
+#define pg_unreachable() __builtin_unreachable()
+#elif defined(_MSC_VER) && !defined(USE_ASSERT_CHECKING)
+#define pg_unreachable() __assume(0)
+#else
+#define pg_unreachable() abort()
+#endif
+
+/*
+ * Hints to the compiler about the likelihood of a branch. Both likely() and
+ * unlikely() return the boolean value of the contained expression.
+ *
+ * These should only be used sparingly, in very hot code paths. It's very easy
+ * to mis-estimate likelihoods.
+ */
+#if __GNUC__ >= 3
+#define likely(x)	__builtin_expect((x) != 0, 1)
+#define unlikely(x) __builtin_expect((x) != 0, 0)
+#else
+#define likely(x)	((x) != 0)
+#define unlikely(x) ((x) != 0)
+#endif
+
+/*
+ * CppAsString
+ *		Convert the argument to a string, using the C preprocessor.
+ * CppAsString2
+ *		Convert the argument to a string, after one round of macro expansion.
+ * CppConcat
+ *		Concatenate two arguments together, using the C preprocessor.
+ *
+ * Note: There used to be support here for pre-ANSI C compilers that didn't
+ * support # and ##.  Nowadays, these macros are just for clarity and/or
+ * backward compatibility with existing PostgreSQL code.
+ */
+#define CppAsString(identifier) #identifier
+#define CppAsString2(x)			CppAsString(x)
+#define CppConcat(x, y)			x##y
+
+/*
+ * VA_ARGS_NARGS
+ *		Returns the number of macro arguments it is passed.
+ *
+ * An empty argument still counts as an argument, so effectively, this is
+ * "one more than the number of commas in the argument list".
+ *
+ * This works for up to 63 arguments.  Internally, VA_ARGS_NARGS_() is passed
+ * 64+N arguments, and the C99 standard only requires macros to allow up to
+ * 127 arguments, so we can't portably go higher.  The implementation is
+ * pretty trivial: VA_ARGS_NARGS_() returns its 64th argument, and we set up
+ * the call so that that is the appropriate one of the list of constants.
+ * This idea is due to Laurent Deniau.
+ */
+#define VA_ARGS_NARGS(...) \
+	VA_ARGS_NARGS_(__VA_ARGS__, \
+				   63,62,61,60,                   \
+				   59,58,57,56,55,54,53,52,51,50, \
+				   49,48,47,46,45,44,43,42,41,40, \
+				   39,38,37,36,35,34,33,32,31,30, \
+				   29,28,27,26,25,24,23,22,21,20, \
+				   19,18,17,16,15,14,13,12,11,10, \
+				   9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
+#define VA_ARGS_NARGS_( \
+	_01,_02,_03,_04,_05,_06,_07,_08,_09,_10, \
+	_11,_12,_13,_14,_15,_16,_17,_18,_19,_20, \
+	_21,_22,_23,_24,_25,_26,_27,_28,_29,_30, \
+	_31,_32,_33,_34,_35,_36,_37,_38,_39,_40, \
+	_41,_42,_43,_44,_45,_46,_47,_48,_49,_50, \
+	_51,_52,_53,_54,_55,_56,_57,_58,_59,_60, \
+	_61,_62,_63,  N, ...) \
+	(N)
+
+/*
+ * dummyret is used to set return values in macros that use ?: to make
+ * assignments.  gcc wants these to be void, other compilers like char
+ */
+#ifdef __GNUC__					/* GNU cc */
+#define dummyret	void
+#else
+#define dummyret	char
+#endif
+
+/*
+ * We require C99, hence the compiler should understand flexible array
+ * members.  However, for documentation purposes we still consider it to be
+ * project style to write "field[FLEXIBLE_ARRAY_MEMBER]" not just "field[]".
+ * When computing the size of such an object, use "offsetof(struct s, f)"
+ * for portability.  Don't use "offsetof(struct s, f[0])", as this doesn't
+ * work with MSVC and with C++ compilers.
+ */
+#define FLEXIBLE_ARRAY_MEMBER	/* empty */
+
+/* Which __func__ symbol do we have, if any? */
+#ifdef HAVE_FUNCNAME__FUNC
+#define PG_FUNCNAME_MACRO	__func__
+#else
+#ifdef HAVE_FUNCNAME__FUNCTION
+#define PG_FUNCNAME_MACRO	__FUNCTION__
+#else
+#define PG_FUNCNAME_MACRO	NULL
+#endif
+#endif
+
+
+/* ----------------------------------------------------------------
+ *				Section 2:	bool, true, false
+ * ----------------------------------------------------------------
+ */
+
+/*
+ * bool
+ *		Boolean value, either true or false.
+ *
+ * We use stdbool.h if available and its bool has size 1.  That's useful for
+ * better compiler and debugger output and for compatibility with third-party
+ * libraries.  But PostgreSQL currently cannot deal with bool of other sizes;
+ * there are static assertions around the code to prevent that.
+ *
+ * For C++ compilers, we assume the compiler has a compatible built-in
+ * definition of bool.
+ *
+ * See also the version of this code in src/interfaces/ecpg/include/ecpglib.h.
+ */
+
+#ifndef __cplusplus
+
+#ifdef PG_USE_STDBOOL
+#include <stdbool.h>
+#else
+
+#ifndef bool
+typedef unsigned char bool;
+#endif
+
+#ifndef true
+#define true	((bool) 1)
+#endif
+
+#ifndef false
+#define false	((bool) 0)
+#endif
+
+#endif							/* not PG_USE_STDBOOL */
+#endif							/* not C++ */
+
+
+/* ----------------------------------------------------------------
+ *				Section 3:	standard system types
+ * ----------------------------------------------------------------
+ */
+
+/*
+ * Pointer
+ *		Variable holding address of any memory resident object.
+ *
+ *		XXX Pointer arithmetic is done with this, so it can't be void *
+ *		under "true" ANSI compilers.
+ */
+typedef char *Pointer;
+
+/*
+ * intN
+ *		Signed integer, EXACTLY N BITS IN SIZE,
+ *		used for numerical computations and the
+ *		frontend/backend protocol.
+ */
+#ifndef HAVE_INT8
+typedef signed char int8;		/* == 8 bits */
+typedef signed short int16;		/* == 16 bits */
+typedef signed int int32;		/* == 32 bits */
+#endif							/* not HAVE_INT8 */
+
+/*
+ * uintN
+ *		Unsigned integer, EXACTLY N BITS IN SIZE,
+ *		used for numerical computations and the
+ *		frontend/backend protocol.
+ */
+#ifndef HAVE_UINT8
+typedef unsigned char uint8;	/* == 8 bits */
+typedef unsigned short uint16;	/* == 16 bits */
+typedef unsigned int uint32;	/* == 32 bits */
+#endif							/* not HAVE_UINT8 */
+
+/*
+ * bitsN
+ *		Unit of bitwise operation, AT LEAST N BITS IN SIZE.
+ */
+typedef uint8 bits8;			/* >= 8 bits */
+typedef uint16 bits16;			/* >= 16 bits */
+typedef uint32 bits32;			/* >= 32 bits */
+
+/*
+ * 64-bit integers
+ */
+#ifdef HAVE_LONG_INT_64
+/* Plain "long int" fits, use it */
+
+#ifndef HAVE_INT64
+typedef long int int64;
+#endif
+#ifndef HAVE_UINT64
+typedef unsigned long int uint64;
+#endif
+#define INT64CONST(x)  (x##L)
+#define UINT64CONST(x) (x##UL)
+#elif defined(HAVE_LONG_LONG_INT_64)
+/* We have working support for "long long int", use that */
+
+#ifndef HAVE_INT64
+typedef long long int int64;
+#endif
+#ifndef HAVE_UINT64
+typedef unsigned long long int uint64;
+#endif
+#define INT64CONST(x)  (x##LL)
+#define UINT64CONST(x) (x##ULL)
+#else
+/* neither HAVE_LONG_INT_64 nor HAVE_LONG_LONG_INT_64 */
+#error must have a working 64-bit integer datatype
+#endif
+
+/* snprintf format strings to use for 64-bit integers */
+#define INT64_FORMAT "%" INT64_MODIFIER "d"
+#define UINT64_FORMAT "%" INT64_MODIFIER "u"
+
+/*
+ * 128-bit signed and unsigned integers
+ *		There currently is only limited support for such types.
+ *		E.g. 128bit literals and snprintf are not supported; but math is.
+ *		Also, because we exclude such types when choosing MAXIMUM_ALIGNOF,
+ *		it must be possible to coerce the compiler to allocate them on no
+ *		more than MAXALIGN boundaries.
+ */
+#if defined(PG_INT128_TYPE)
+#if defined(pg_attribute_aligned) || ALIGNOF_PG_INT128_TYPE <= MAXIMUM_ALIGNOF
+#define HAVE_INT128 1
+
+typedef PG_INT128_TYPE int128
+#if defined(pg_attribute_aligned)
+			pg_attribute_aligned(MAXIMUM_ALIGNOF)
+#endif
+		   ;
+
+typedef unsigned PG_INT128_TYPE uint128
+#if defined(pg_attribute_aligned)
+			pg_attribute_aligned(MAXIMUM_ALIGNOF)
+#endif
+		   ;
+
+#endif
+#endif
+
+/*
+ * stdint.h limits aren't guaranteed to have compatible types with our fixed
+ * width types. So just define our own.
+ */
+#define PG_INT8_MIN		(-0x7F-1)
+#define PG_INT8_MAX		(0x7F)
+#define PG_UINT8_MAX	(0xFF)
+#define PG_INT16_MIN	(-0x7FFF-1)
+#define PG_INT16_MAX	(0x7FFF)
+#define PG_UINT16_MAX	(0xFFFF)
+#define PG_INT32_MIN	(-0x7FFFFFFF-1)
+#define PG_INT32_MAX	(0x7FFFFFFF)
+#define PG_UINT32_MAX	(0xFFFFFFFFU)
+#define PG_INT64_MIN	(-INT64CONST(0x7FFFFFFFFFFFFFFF) - 1)
+#define PG_INT64_MAX	INT64CONST(0x7FFFFFFFFFFFFFFF)
+#define PG_UINT64_MAX	UINT64CONST(0xFFFFFFFFFFFFFFFF)
+
+/*
+ * We now always use int64 timestamps, but keep this symbol defined for the
+ * benefit of external code that might test it.
+ */
+#define HAVE_INT64_TIMESTAMP
+
+/*
+ * Size
+ *		Size of any memory resident object, as returned by sizeof.
+ */
+typedef size_t Size;
+
+/*
+ * Index
+ *		Index into any memory resident array.
+ *
+ * Note:
+ *		Indices are non negative.
+ */
+typedef unsigned int Index;
+
+/*
+ * Offset
+ *		Offset into any memory resident array.
+ *
+ * Note:
+ *		This differs from an Index in that an Index is always
+ *		non negative, whereas Offset may be negative.
+ */
+typedef signed int Offset;
+
+/*
+ * Common Postgres datatype names (as used in the catalogs)
+ */
+typedef float float4;
+typedef double float8;
+
+#ifdef USE_FLOAT8_BYVAL
+#define FLOAT8PASSBYVAL true
+#else
+#define FLOAT8PASSBYVAL false
+#endif
+
+/*
+ * Oid, RegProcedure, TransactionId, SubTransactionId, MultiXactId,
+ * CommandId
+ */
+
+/* typedef Oid is in postgres_ext.h */
+
+/*
+ * regproc is the type name used in the include/catalog headers, but
+ * RegProcedure is the preferred name in C code.
+ */
+typedef Oid regproc;
+typedef regproc RegProcedure;
+
+typedef uint32 TransactionId;
+
+typedef uint32 LocalTransactionId;
+
+typedef uint32 SubTransactionId;
+
+#define InvalidSubTransactionId		((SubTransactionId) 0)
+#define TopSubTransactionId			((SubTransactionId) 1)
+
+/* MultiXactId must be equivalent to TransactionId, to fit in t_xmax */
+typedef TransactionId MultiXactId;
+
+typedef uint32 MultiXactOffset;
+
+typedef uint32 CommandId;
+
+#define FirstCommandId	((CommandId) 0)
+#define InvalidCommandId	(~(CommandId)0)
+
+/*
+ * Array indexing support
+ */
+#define MAXDIM 6
+typedef struct
+{
+	int			indx[MAXDIM];
+}			IntArray;
+
+/* ----------------
+ *		Variable-length datatypes all share the 'struct varlena' header.
+ *
+ * NOTE: for TOASTable types, this is an oversimplification, since the value
+ * may be compressed or moved out-of-line.  However datatype-specific routines
+ * are mostly content to deal with de-TOASTed values only, and of course
+ * client-side routines should never see a TOASTed value.  But even in a
+ * de-TOASTed value, beware of touching vl_len_ directly, as its
+ * representation is no longer convenient.  It's recommended that code always
+ * use macros VARDATA_ANY, VARSIZE_ANY, VARSIZE_ANY_EXHDR, VARDATA, VARSIZE,
+ * and SET_VARSIZE instead of relying on direct mentions of the struct fields.
+ * See postgres.h for details of the TOASTed form.
+ * ----------------
+ */
+struct varlena
+{
+	char		vl_len_[4];		/* Do not touch this field directly! */
+	char		vl_dat[FLEXIBLE_ARRAY_MEMBER];	/* Data content is here */
+};
+
+#define VARHDRSZ		((int32) sizeof(int32))
+
+/*
+ * These widely-used datatypes are just a varlena header and the data bytes.
+ * There is no terminating null or anything like that --- the data length is
+ * always VARSIZE_ANY_EXHDR(ptr).
+ */
+typedef struct varlena bytea;
+typedef struct varlena text;
+typedef struct varlena BpChar;	/* blank-padded char, ie SQL char(n) */
+typedef struct varlena VarChar; /* var-length char, ie SQL varchar(n) */
+
+/*
+ * Specialized array types.  These are physically laid out just the same
+ * as regular arrays (so that the regular array subscripting code works
+ * with them).  They exist as distinct types mostly for historical reasons:
+ * they have nonstandard I/O behavior which we don't want to change for fear
+ * of breaking applications that look at the system catalogs.  There is also
+ * an implementation issue for oidvector: it's part of the primary key for
+ * pg_proc, and we can't use the normal btree array support routines for that
+ * without circularity.
+ */
+typedef struct
+{
+	int32		vl_len_;		/* these fields must match ArrayType! */
+	int			ndim;			/* always 1 for int2vector */
+	int32		dataoffset;		/* always 0 for int2vector */
+	Oid			elemtype;
+	int			dim1;
+	int			lbound1;
+	int16		values[FLEXIBLE_ARRAY_MEMBER];
+} int2vector;
+
+typedef struct
+{
+	int32		vl_len_;		/* these fields must match ArrayType! */
+	int			ndim;			/* always 1 for oidvector */
+	int32		dataoffset;		/* always 0 for oidvector */
+	Oid			elemtype;
+	int			dim1;
+	int			lbound1;
+	Oid			values[FLEXIBLE_ARRAY_MEMBER];
+} oidvector;
+
+/*
+ * Representation of a Name: effectively just a C string, but null-padded to
+ * exactly NAMEDATALEN bytes.  The use of a struct is historical.
+ */
+typedef struct nameData
+{
+	char		data[NAMEDATALEN];
+} NameData;
+typedef NameData *Name;
+
+#define NameStr(name)	((name).data)
+
+
+/* ----------------------------------------------------------------
+ *				Section 4:	IsValid macros for system types
+ * ----------------------------------------------------------------
+ */
+/*
+ * BoolIsValid
+ *		True iff bool is valid.
+ */
+#define BoolIsValid(boolean)	((boolean) == false || (boolean) == true)
+
+/*
+ * PointerIsValid
+ *		True iff pointer is valid.
+ */
+#define PointerIsValid(pointer) ((const void*)(pointer) != NULL)
+
+/*
+ * PointerIsAligned
+ *		True iff pointer is properly aligned to point to the given type.
+ */
+#define PointerIsAligned(pointer, type) \
+		(((uintptr_t)(pointer) % (sizeof (type))) == 0)
+
+#define OffsetToPointer(base, offset) \
+		((void *)((char *) base + offset))
+
+#define OidIsValid(objectId)  ((bool) ((objectId) != InvalidOid))
+
+#define RegProcedureIsValid(p)	OidIsValid(p)
+
+
+/* ----------------------------------------------------------------
+ *				Section 5:	offsetof, lengthof, alignment
+ * ----------------------------------------------------------------
+ */
+/*
+ * offsetof
+ *		Offset of a structure/union field within that structure/union.
+ *
+ *		XXX This is supposed to be part of stddef.h, but isn't on
+ *		some systems (like SunOS 4).
+ */
+#ifndef offsetof
+#define offsetof(type, field)	((long) &((type *)0)->field)
+#endif							/* offsetof */
+
+/*
+ * lengthof
+ *		Number of elements in an array.
+ */
+#define lengthof(array) (sizeof (array) / sizeof ((array)[0]))
+
+/* ----------------
+ * Alignment macros: align a length or address appropriately for a given type.
+ * The fooALIGN() macros round up to a multiple of the required alignment,
+ * while the fooALIGN_DOWN() macros round down.  The latter are more useful
+ * for problems like "how many X-sized structures will fit in a page?".
+ *
+ * NOTE: TYPEALIGN[_DOWN] will not work if ALIGNVAL is not a power of 2.
+ * That case seems extremely unlikely to be needed in practice, however.
+ *
+ * NOTE: MAXIMUM_ALIGNOF, and hence MAXALIGN(), intentionally exclude any
+ * larger-than-8-byte types the compiler might have.
+ * ----------------
+ */
+
+#define TYPEALIGN(ALIGNVAL,LEN)  \
+	(((uintptr_t) (LEN) + ((ALIGNVAL) - 1)) & ~((uintptr_t) ((ALIGNVAL) - 1)))
+
+#define SHORTALIGN(LEN)			TYPEALIGN(ALIGNOF_SHORT, (LEN))
+#define INTALIGN(LEN)			TYPEALIGN(ALIGNOF_INT, (LEN))
+#define LONGALIGN(LEN)			TYPEALIGN(ALIGNOF_LONG, (LEN))
+#define DOUBLEALIGN(LEN)		TYPEALIGN(ALIGNOF_DOUBLE, (LEN))
+#define MAXALIGN(LEN)			TYPEALIGN(MAXIMUM_ALIGNOF, (LEN))
+/* MAXALIGN covers only built-in types, not buffers */
+#define BUFFERALIGN(LEN)		TYPEALIGN(ALIGNOF_BUFFER, (LEN))
+#define CACHELINEALIGN(LEN)		TYPEALIGN(PG_CACHE_LINE_SIZE, (LEN))
+
+#define TYPEALIGN_DOWN(ALIGNVAL,LEN)  \
+	(((uintptr_t) (LEN)) & ~((uintptr_t) ((ALIGNVAL) - 1)))
+
+#define SHORTALIGN_DOWN(LEN)	TYPEALIGN_DOWN(ALIGNOF_SHORT, (LEN))
+#define INTALIGN_DOWN(LEN)		TYPEALIGN_DOWN(ALIGNOF_INT, (LEN))
+#define LONGALIGN_DOWN(LEN)		TYPEALIGN_DOWN(ALIGNOF_LONG, (LEN))
+#define DOUBLEALIGN_DOWN(LEN)	TYPEALIGN_DOWN(ALIGNOF_DOUBLE, (LEN))
+#define MAXALIGN_DOWN(LEN)		TYPEALIGN_DOWN(MAXIMUM_ALIGNOF, (LEN))
+#define BUFFERALIGN_DOWN(LEN)	TYPEALIGN_DOWN(ALIGNOF_BUFFER, (LEN))
+
+/*
+ * The above macros will not work with types wider than uintptr_t, like with
+ * uint64 on 32-bit platforms.  That's not problem for the usual use where a
+ * pointer or a length is aligned, but for the odd case that you need to
+ * align something (potentially) wider, use TYPEALIGN64.
+ */
+#define TYPEALIGN64(ALIGNVAL,LEN)  \
+	(((uint64) (LEN) + ((ALIGNVAL) - 1)) & ~((uint64) ((ALIGNVAL) - 1)))
+
+/* we don't currently need wider versions of the other ALIGN macros */
+#define MAXALIGN64(LEN)			TYPEALIGN64(MAXIMUM_ALIGNOF, (LEN))
+
+
+/* ----------------------------------------------------------------
+ *				Section 6:	assertions
+ * ----------------------------------------------------------------
+ */
+
+/*
+ * USE_ASSERT_CHECKING, if defined, turns on all the assertions.
+ * - plai  9/5/90
+ *
+ * It should _NOT_ be defined in releases or in benchmark copies
+ */
+
+/*
+ * Assert() can be used in both frontend and backend code. In frontend code it
+ * just calls the standard assert, if it's available. If use of assertions is
+ * not configured, it does nothing.
+ */
+#ifndef USE_ASSERT_CHECKING
+
+#define Assert(condition)	((void)true)
+#define AssertMacro(condition)	((void)true)
+#define AssertArg(condition)	((void)true)
+#define AssertState(condition)	((void)true)
+#define AssertPointerAlignment(ptr, bndr)	((void)true)
+#define Trap(condition, errorType)	((void)true)
+#define TrapMacro(condition, errorType) (true)
+
+#elif defined(FRONTEND)
+
+#include <assert.h>
+#define Assert(p) assert(p)
+#define AssertMacro(p)	((void) assert(p))
+#define AssertArg(condition) assert(condition)
+#define AssertState(condition) assert(condition)
+#define AssertPointerAlignment(ptr, bndr)	((void)true)
+
+#else							/* USE_ASSERT_CHECKING && !FRONTEND */
+
+/*
+ * Trap
+ *		Generates an exception if the given condition is true.
+ */
+#define Trap(condition, errorType) \
+	do { \
+		if (condition) \
+			ExceptionalCondition(#condition, (errorType), \
+								 __FILE__, __LINE__); \
+	} while (0)
+
+/*
+ *	TrapMacro is the same as Trap but it's intended for use in macros:
+ *
+ *		#define foo(x) (AssertMacro(x != 0), bar(x))
+ *
+ *	Isn't CPP fun?
+ */
+#define TrapMacro(condition, errorType) \
+	((bool) (! (condition) || \
+			 (ExceptionalCondition(#condition, (errorType), \
+								   __FILE__, __LINE__), 0)))
+
+#define Assert(condition) \
+	do { \
+		if (!(condition)) \
+			ExceptionalCondition(#condition, "FailedAssertion", \
+								 __FILE__, __LINE__); \
+	} while (0)
+
+#define AssertMacro(condition) \
+	((void) ((condition) || \
+			 (ExceptionalCondition(#condition, "FailedAssertion", \
+								   __FILE__, __LINE__), 0)))
+
+#define AssertArg(condition) \
+	do { \
+		if (!(condition)) \
+			ExceptionalCondition(#condition, "BadArgument", \
+								 __FILE__, __LINE__); \
+	} while (0)
+
+#define AssertState(condition) \
+	do { \
+		if (!(condition)) \
+			ExceptionalCondition(#condition, "BadState", \
+								 __FILE__, __LINE__); \
+	} while (0)
+
+/*
+ * Check that `ptr' is `bndr' aligned.
+ */
+#define AssertPointerAlignment(ptr, bndr) \
+	Trap(TYPEALIGN(bndr, (uintptr_t)(ptr)) != (uintptr_t)(ptr), \
+		 "UnalignedPointer")
+
+#endif							/* USE_ASSERT_CHECKING && !FRONTEND */
+
+/*
+ * ExceptionalCondition is compiled into the backend whether or not
+ * USE_ASSERT_CHECKING is defined, so as to support use of extensions
+ * that are built with that #define with a backend that isn't.  Hence,
+ * we should declare it as long as !FRONTEND.
+ */
+#ifndef FRONTEND
+extern void ExceptionalCondition(const char *conditionName,
+								 const char *errorType,
+								 const char *fileName, int lineNumber) pg_attribute_noreturn();
+#endif
+
+/*
+ * Macros to support compile-time assertion checks.
+ *
+ * If the "condition" (a compile-time-constant expression) evaluates to false,
+ * throw a compile error using the "errmessage" (a string literal).
+ *
+ * gcc 4.6 and up supports _Static_assert(), but there are bizarre syntactic
+ * placement restrictions.  Macros StaticAssertStmt() and StaticAssertExpr()
+ * make it safe to use as a statement or in an expression, respectively.
+ * The macro StaticAssertDecl() is suitable for use at file scope (outside of
+ * any function).
+ *
+ * Otherwise we fall back on a kluge that assumes the compiler will complain
+ * about a negative width for a struct bit-field.  This will not include a
+ * helpful error message, but it beats not getting an error at all.
+ */
+#ifndef __cplusplus
+#ifdef HAVE__STATIC_ASSERT
+#define StaticAssertStmt(condition, errmessage) \
+	do { _Static_assert(condition, errmessage); } while(0)
+#define StaticAssertExpr(condition, errmessage) \
+	((void) ({ StaticAssertStmt(condition, errmessage); true; }))
+#define StaticAssertDecl(condition, errmessage) \
+	_Static_assert(condition, errmessage)
+#else							/* !HAVE__STATIC_ASSERT */
+#define StaticAssertStmt(condition, errmessage) \
+	((void) sizeof(struct { int static_assert_failure : (condition) ? 1 : -1; }))
+#define StaticAssertExpr(condition, errmessage) \
+	StaticAssertStmt(condition, errmessage)
+#define StaticAssertDecl(condition, errmessage) \
+	extern void static_assert_func(int static_assert_failure[(condition) ? 1 : -1])
+#endif							/* HAVE__STATIC_ASSERT */
+#else							/* C++ */
+#if defined(__cpp_static_assert) && __cpp_static_assert >= 200410
+#define StaticAssertStmt(condition, errmessage) \
+	static_assert(condition, errmessage)
+#define StaticAssertExpr(condition, errmessage) \
+	({ static_assert(condition, errmessage); })
+#define StaticAssertDecl(condition, errmessage) \
+	static_assert(condition, errmessage)
+#else							/* !__cpp_static_assert */
+#define StaticAssertStmt(condition, errmessage) \
+	do { struct static_assert_struct { int static_assert_failure : (condition) ? 1 : -1; }; } while(0)
+#define StaticAssertExpr(condition, errmessage) \
+	((void) ({ StaticAssertStmt(condition, errmessage); }))
+#define StaticAssertDecl(condition, errmessage) \
+	extern void static_assert_func(int static_assert_failure[(condition) ? 1 : -1])
+#endif							/* __cpp_static_assert */
+#endif							/* C++ */
+
+
+/*
+ * Compile-time checks that a variable (or expression) has the specified type.
+ *
+ * AssertVariableIsOfType() can be used as a statement.
+ * AssertVariableIsOfTypeMacro() is intended for use in macros, eg
+ *		#define foo(x) (AssertVariableIsOfTypeMacro(x, int), bar(x))
+ *
+ * If we don't have __builtin_types_compatible_p, we can still assert that
+ * the types have the same size.  This is far from ideal (especially on 32-bit
+ * platforms) but it provides at least some coverage.
+ */
+#ifdef HAVE__BUILTIN_TYPES_COMPATIBLE_P
+#define AssertVariableIsOfType(varname, typename) \
+	StaticAssertStmt(__builtin_types_compatible_p(__typeof__(varname), typename), \
+	CppAsString(varname) " does not have type " CppAsString(typename))
+#define AssertVariableIsOfTypeMacro(varname, typename) \
+	(StaticAssertExpr(__builtin_types_compatible_p(__typeof__(varname), typename), \
+	 CppAsString(varname) " does not have type " CppAsString(typename)))
+#else							/* !HAVE__BUILTIN_TYPES_COMPATIBLE_P */
+#define AssertVariableIsOfType(varname, typename) \
+	StaticAssertStmt(sizeof(varname) == sizeof(typename), \
+	CppAsString(varname) " does not have type " CppAsString(typename))
+#define AssertVariableIsOfTypeMacro(varname, typename) \
+	(StaticAssertExpr(sizeof(varname) == sizeof(typename), \
+	 CppAsString(varname) " does not have type " CppAsString(typename)))
+#endif							/* HAVE__BUILTIN_TYPES_COMPATIBLE_P */
+
+
+/* ----------------------------------------------------------------
+ *				Section 7:	widely useful macros
+ * ----------------------------------------------------------------
+ */
+/*
+ * Max
+ *		Return the maximum of two numbers.
+ */
+#define Max(x, y)		((x) > (y) ? (x) : (y))
+
+/*
+ * Min
+ *		Return the minimum of two numbers.
+ */
+#define Min(x, y)		((x) < (y) ? (x) : (y))
+
+/*
+ * Abs
+ *		Return the absolute value of the argument.
+ */
+#define Abs(x)			((x) >= 0 ? (x) : -(x))
+
+/*
+ * StrNCpy
+ *	Like standard library function strncpy(), except that result string
+ *	is guaranteed to be null-terminated --- that is, at most N-1 bytes
+ *	of the source string will be kept.
+ *	Also, the macro returns no result (too hard to do that without
+ *	evaluating the arguments multiple times, which seems worse).
+ *
+ *	BTW: when you need to copy a non-null-terminated string (like a text
+ *	datum) and add a null, do not do it with StrNCpy(..., len+1).  That
+ *	might seem to work, but it fetches one byte more than there is in the
+ *	text object.  One fine day you'll have a SIGSEGV because there isn't
+ *	another byte before the end of memory.  Don't laugh, we've had real
+ *	live bug reports from real live users over exactly this mistake.
+ *	Do it honestly with "memcpy(dst,src,len); dst[len] = '\0';", instead.
+ */
+#define StrNCpy(dst,src,len) \
+	do \
+	{ \
+		char * _dst = (dst); \
+		Size _len = (len); \
+\
+		if (_len > 0) \
+		{ \
+			strncpy(_dst, (src), _len); \
+			_dst[_len-1] = '\0'; \
+		} \
+	} while (0)
+
+
+/* Get a bit mask of the bits set in non-long aligned addresses */
+#define LONG_ALIGN_MASK (sizeof(long) - 1)
+
+/*
+ * MemSet
+ *	Exactly the same as standard library function memset(), but considerably
+ *	faster for zeroing small word-aligned structures (such as parsetree nodes).
+ *	This has to be a macro because the main point is to avoid function-call
+ *	overhead.   However, we have also found that the loop is faster than
+ *	native libc memset() on some platforms, even those with assembler
+ *	memset() functions.  More research needs to be done, perhaps with
+ *	MEMSET_LOOP_LIMIT tests in configure.
+ */
+#define MemSet(start, val, len) \
+	do \
+	{ \
+		/* must be void* because we don't know if it is integer aligned yet */ \
+		void   *_vstart = (void *) (start); \
+		int		_val = (val); \
+		Size	_len = (len); \
+\
+		if ((((uintptr_t) _vstart) & LONG_ALIGN_MASK) == 0 && \
+			(_len & LONG_ALIGN_MASK) == 0 && \
+			_val == 0 && \
+			_len <= MEMSET_LOOP_LIMIT && \
+			/* \
+			 *	If MEMSET_LOOP_LIMIT == 0, optimizer should find \
+			 *	the whole "if" false at compile time. \
+			 */ \
+			MEMSET_LOOP_LIMIT != 0) \
+		{ \
+			long *_start = (long *) _vstart; \
+			long *_stop = (long *) ((char *) _start + _len); \
+			while (_start < _stop) \
+				*_start++ = 0; \
+		} \
+		else \
+			memset(_vstart, _val, _len); \
+	} while (0)
+
+/*
+ * MemSetAligned is the same as MemSet except it omits the test to see if
+ * "start" is word-aligned.  This is okay to use if the caller knows a-priori
+ * that the pointer is suitably aligned (typically, because he just got it
+ * from palloc(), which always delivers a max-aligned pointer).
+ */
+#define MemSetAligned(start, val, len) \
+	do \
+	{ \
+		long   *_start = (long *) (start); \
+		int		_val = (val); \
+		Size	_len = (len); \
+\
+		if ((_len & LONG_ALIGN_MASK) == 0 && \
+			_val == 0 && \
+			_len <= MEMSET_LOOP_LIMIT && \
+			MEMSET_LOOP_LIMIT != 0) \
+		{ \
+			long *_stop = (long *) ((char *) _start + _len); \
+			while (_start < _stop) \
+				*_start++ = 0; \
+		} \
+		else \
+			memset(_start, _val, _len); \
+	} while (0)
+
+
+/*
+ * MemSetTest/MemSetLoop are a variant version that allow all the tests in
+ * MemSet to be done at compile time in cases where "val" and "len" are
+ * constants *and* we know the "start" pointer must be word-aligned.
+ * If MemSetTest succeeds, then it is okay to use MemSetLoop, otherwise use
+ * MemSetAligned.  Beware of multiple evaluations of the arguments when using
+ * this approach.
+ */
+#define MemSetTest(val, len) \
+	( ((len) & LONG_ALIGN_MASK) == 0 && \
+	(len) <= MEMSET_LOOP_LIMIT && \
+	MEMSET_LOOP_LIMIT != 0 && \
+	(val) == 0 )
+
+#define MemSetLoop(start, val, len) \
+	do \
+	{ \
+		long * _start = (long *) (start); \
+		long * _stop = (long *) ((char *) _start + (Size) (len)); \
+	\
+		while (_start < _stop) \
+			*_start++ = 0; \
+	} while (0)
+
+/*
+ * Macros for range-checking float values before converting to integer.
+ * We must be careful here that the boundary values are expressed exactly
+ * in the float domain.  PG_INTnn_MIN is an exact power of 2, so it will
+ * be represented exactly; but PG_INTnn_MAX isn't, and might get rounded
+ * off, so avoid using that.
+ * The input must be rounded to an integer beforehand, typically with rint(),
+ * else we might draw the wrong conclusion about close-to-the-limit values.
+ * These macros will do the right thing for Inf, but not necessarily for NaN,
+ * so check isnan(num) first if that's a possibility.
+ */
+#define FLOAT4_FITS_IN_INT16(num) \
+	((num) >= (float4) PG_INT16_MIN && (num) < -((float4) PG_INT16_MIN))
+#define FLOAT4_FITS_IN_INT32(num) \
+	((num) >= (float4) PG_INT32_MIN && (num) < -((float4) PG_INT32_MIN))
+#define FLOAT4_FITS_IN_INT64(num) \
+	((num) >= (float4) PG_INT64_MIN && (num) < -((float4) PG_INT64_MIN))
+#define FLOAT8_FITS_IN_INT16(num) \
+	((num) >= (float8) PG_INT16_MIN && (num) < -((float8) PG_INT16_MIN))
+#define FLOAT8_FITS_IN_INT32(num) \
+	((num) >= (float8) PG_INT32_MIN && (num) < -((float8) PG_INT32_MIN))
+#define FLOAT8_FITS_IN_INT64(num) \
+	((num) >= (float8) PG_INT64_MIN && (num) < -((float8) PG_INT64_MIN))
+
+
+/* ----------------------------------------------------------------
+ *				Section 8:	random stuff
+ * ----------------------------------------------------------------
+ */
+
+#ifdef HAVE_STRUCT_SOCKADDR_UN
+#define HAVE_UNIX_SOCKETS 1
+#endif
+
+/*
+ * Invert the sign of a qsort-style comparison result, ie, exchange negative
+ * and positive integer values, being careful not to get the wrong answer
+ * for INT_MIN.  The argument should be an integral variable.
+ */
+#define INVERT_COMPARE_RESULT(var) \
+	((var) = ((var) < 0) ? 1 : -(var))
+
+/*
+ * Use this, not "char buf[BLCKSZ]", to declare a field or local variable
+ * holding a page buffer, if that page might be accessed as a page and not
+ * just a string of bytes.  Otherwise the variable might be under-aligned,
+ * causing problems on alignment-picky hardware.  (In some places, we use
+ * this to declare buffers even though we only pass them to read() and
+ * write(), because copying to/from aligned buffers is usually faster than
+ * using unaligned buffers.)  We include both "double" and "int64" in the
+ * union to ensure that the compiler knows the value must be MAXALIGN'ed
+ * (cf. configure's computation of MAXIMUM_ALIGNOF).
+ */
+typedef union PGAlignedBlock
+{
+	char		data[BLCKSZ];
+	double		force_align_d;
+	int64		force_align_i64;
+} PGAlignedBlock;
+
+/* Same, but for an XLOG_BLCKSZ-sized buffer */
+typedef union PGAlignedXLogBlock
+{
+	char		data[XLOG_BLCKSZ];
+	double		force_align_d;
+	int64		force_align_i64;
+} PGAlignedXLogBlock;
+
+/* msb for char */
+#define HIGHBIT					(0x80)
+#define IS_HIGHBIT_SET(ch)		((unsigned char)(ch) & HIGHBIT)
+
+/*
+ * Support macros for escaping strings.  escape_backslash should be true
+ * if generating a non-standard-conforming string.  Prefixing a string
+ * with ESCAPE_STRING_SYNTAX guarantees it is non-standard-conforming.
+ * Beware of multiple evaluation of the "ch" argument!
+ */
+#define SQL_STR_DOUBLE(ch, escape_backslash)	\
+	((ch) == '\'' || ((ch) == '\\' && (escape_backslash)))
+
+#define ESCAPE_STRING_SYNTAX	'E'
+
+
+#define STATUS_OK				(0)
+#define STATUS_ERROR			(-1)
+#define STATUS_EOF				(-2)
+#define STATUS_WAITING			(2)
+
+/*
+ * gettext support
+ */
+
+#ifndef ENABLE_NLS
+/* stuff we'd otherwise get from <libintl.h> */
+#define gettext(x) (x)
+#define dgettext(d,x) (x)
+#define ngettext(s,p,n) ((n) == 1 ? (s) : (p))
+#define dngettext(d,s,p,n) ((n) == 1 ? (s) : (p))
+#endif
+
+#define _(x) gettext(x)
+
+/*
+ *	Use this to mark string constants as needing translation at some later
+ *	time, rather than immediately.  This is useful for cases where you need
+ *	access to the original string and translated string, and for cases where
+ *	immediate translation is not possible, like when initializing global
+ *	variables.
+ *		http://www.gnu.org/software/autoconf/manual/gettext/Special-cases.html
+ */
+#define gettext_noop(x) (x)
+
+/*
+ * To better support parallel installations of major PostgreSQL
+ * versions as well as parallel installations of major library soname
+ * versions, we mangle the gettext domain name by appending those
+ * version numbers.  The coding rule ought to be that wherever the
+ * domain name is mentioned as a literal, it must be wrapped into
+ * PG_TEXTDOMAIN().  The macros below do not work on non-literals; but
+ * that is somewhat intentional because it avoids having to worry
+ * about multiple states of premangling and postmangling as the values
+ * are being passed around.
+ *
+ * Make sure this matches the installation rules in nls-global.mk.
+ */
+#ifdef SO_MAJOR_VERSION
+#define PG_TEXTDOMAIN(domain) (domain CppAsString2(SO_MAJOR_VERSION) "-" PG_MAJORVERSION)
+#else
+#define PG_TEXTDOMAIN(domain) (domain "-" PG_MAJORVERSION)
+#endif
+
+/*
+ * Macro that allows to cast constness and volatile away from an expression, but doesn't
+ * allow changing the underlying type.  Enforcement of the latter
+ * currently only works for gcc like compilers.
+ *
+ * Please note IT IS NOT SAFE to cast constness away if the result will ever
+ * be modified (it would be undefined behaviour). Doing so anyway can cause
+ * compiler misoptimizations or runtime crashes (modifying readonly memory).
+ * It is only safe to use when the result will not be modified, but API
+ * design or language restrictions prevent you from declaring that
+ * (e.g. because a function returns both const and non-const variables).
+ *
+ * Note that this only works in function scope, not for global variables (it'd
+ * be nice, but not trivial, to improve that).
+ */
+#if defined(HAVE__BUILTIN_TYPES_COMPATIBLE_P)
+#define unconstify(underlying_type, expr) \
+	(StaticAssertExpr(__builtin_types_compatible_p(__typeof(expr), const underlying_type), \
+					  "wrong cast"), \
+	 (underlying_type) (expr))
+#define unvolatize(underlying_type, expr) \
+	(StaticAssertExpr(__builtin_types_compatible_p(__typeof(expr), volatile underlying_type), \
+					  "wrong cast"), \
+	 (underlying_type) (expr))
+#else
+#define unconstify(underlying_type, expr) \
+	((underlying_type) (expr))
+#define unvolatize(underlying_type, expr) \
+	((underlying_type) (expr))
+#endif
+
+/* ----------------------------------------------------------------
+ *				Section 9: system-specific hacks
+ *
+ *		This should be limited to things that absolutely have to be
+ *		included in every source file.  The port-specific header file
+ *		is usually a better place for this sort of thing.
+ * ----------------------------------------------------------------
+ */
+
+/*
+ *	NOTE:  this is also used for opening text files.
+ *	WIN32 treats Control-Z as EOF in files opened in text mode.
+ *	Therefore, we open files in binary mode on Win32 so we can read
+ *	literal control-Z.  The other affect is that we see CRLF, but
+ *	that is OK because we can already handle those cleanly.
+ */
+#if defined(WIN32) || defined(__CYGWIN__)
+#define PG_BINARY	O_BINARY
+#define PG_BINARY_A "ab"
+#define PG_BINARY_R "rb"
+#define PG_BINARY_W "wb"
+#else
+#define PG_BINARY	0
+#define PG_BINARY_A "a"
+#define PG_BINARY_R "r"
+#define PG_BINARY_W "w"
+#endif
+
+/*
+ * Provide prototypes for routines not present in a particular machine's
+ * standard C library.
+ */
+
+#if defined(HAVE_FDATASYNC) && !HAVE_DECL_FDATASYNC
+extern int	fdatasync(int fildes);
+#endif
+
+/* Older platforms may provide strto[u]ll functionality under other names */
+#if !defined(HAVE_STRTOLL) && defined(HAVE___STRTOLL)
+#define strtoll __strtoll
+#define HAVE_STRTOLL 1
+#endif
+
+#if !defined(HAVE_STRTOLL) && defined(HAVE_STRTOQ)
+#define strtoll strtoq
+#define HAVE_STRTOLL 1
+#endif
+
+#if !defined(HAVE_STRTOULL) && defined(HAVE___STRTOULL)
+#define strtoull __strtoull
+#define HAVE_STRTOULL 1
+#endif
+
+#if !defined(HAVE_STRTOULL) && defined(HAVE_STRTOUQ)
+#define strtoull strtouq
+#define HAVE_STRTOULL 1
+#endif
+
+#if defined(HAVE_STRTOLL) && !HAVE_DECL_STRTOLL
+extern long long strtoll(const char *str, char **endptr, int base);
+#endif
+
+#if defined(HAVE_STRTOULL) && !HAVE_DECL_STRTOULL
+extern unsigned long long strtoull(const char *str, char **endptr, int base);
+#endif
+
+#define PGDLLIMPORT
+#define PGDLLEXPORT
+
+/*
+ * The following is used as the arg list for signal handlers.  Any ports
+ * that take something other than an int argument should override this in
+ * their pg_config_os.h file.  Note that variable names are required
+ * because it is used in both the prototypes as well as the definitions.
+ * Note also the long name.  We expect that this won't collide with
+ * other names causing compiler warnings.
+ */
+
+#ifndef SIGNAL_ARGS
+#define SIGNAL_ARGS  int postgres_signal_arg
+#endif
+
+/*
+ * When there is no sigsetjmp, its functionality is provided by plain
+ * setjmp. Incidentally, nothing provides setjmp's functionality in
+ * that case.  We now support the case only on Windows.
+ */
+#ifdef WIN32
+#define sigjmp_buf jmp_buf
+#define sigsetjmp(x,y) setjmp(x)
+#define siglongjmp longjmp
+#endif
+
+/* EXEC_BACKEND defines */
+#ifdef EXEC_BACKEND
+#define NON_EXEC_STATIC
+#else
+#define NON_EXEC_STATIC static
+#endif
+
+/* /port compatibility functions */
+#include "port.h"
+
+#endif							/* C_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/binary_upgrade.h b/contrib/libs/postgresql/src/include/catalog/binary_upgrade.h
new file mode 100644
index 0000000000..12d94fe1b3
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/binary_upgrade.h
@@ -0,0 +1,30 @@
+/*-------------------------------------------------------------------------
+ *
+ * binary_upgrade.h
+ *	  variables used for binary upgrades
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/binary_upgrade.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef BINARY_UPGRADE_H
+#define BINARY_UPGRADE_H
+
+extern PGDLLIMPORT Oid binary_upgrade_next_pg_type_oid;
+extern PGDLLIMPORT Oid binary_upgrade_next_array_pg_type_oid;
+extern PGDLLIMPORT Oid binary_upgrade_next_toast_pg_type_oid;
+
+extern PGDLLIMPORT Oid binary_upgrade_next_heap_pg_class_oid;
+extern PGDLLIMPORT Oid binary_upgrade_next_index_pg_class_oid;
+extern PGDLLIMPORT Oid binary_upgrade_next_toast_pg_class_oid;
+
+extern PGDLLIMPORT Oid binary_upgrade_next_pg_enum_oid;
+extern PGDLLIMPORT Oid binary_upgrade_next_pg_authid_oid;
+
+extern PGDLLIMPORT bool binary_upgrade_record_init_privs;
+
+#endif							/* BINARY_UPGRADE_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/catalog.h b/contrib/libs/postgresql/src/include/catalog/catalog.h
new file mode 100644
index 0000000000..7824a123c2
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/catalog.h
@@ -0,0 +1,42 @@
+/*-------------------------------------------------------------------------
+ *
+ * catalog.h
+ *	  prototypes for functions in backend/catalog/catalog.c
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/catalog.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef CATALOG_H
+#define CATALOG_H
+
+#include "catalog/pg_class.h"
+#include "utils/relcache.h"
+
+
+extern bool IsSystemRelation(Relation relation);
+extern bool IsToastRelation(Relation relation);
+extern bool IsCatalogRelation(Relation relation);
+
+extern bool IsSystemClass(Oid relid, Form_pg_class reltuple);
+extern bool IsToastClass(Form_pg_class reltuple);
+
+extern bool IsCatalogRelationOid(Oid relid);
+
+extern bool IsCatalogNamespace(Oid namespaceId);
+extern bool IsToastNamespace(Oid namespaceId);
+
+extern bool IsReservedName(const char *name);
+
+extern bool IsSharedRelation(Oid relationId);
+
+extern Oid	GetNewOidWithIndex(Relation relation, Oid indexId,
+							   AttrNumber oidcolumn);
+extern Oid	GetNewRelFileNode(Oid reltablespace, Relation pg_class,
+							  char relpersistence);
+
+#endif							/* CATALOG_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/catversion.h b/contrib/libs/postgresql/src/include/catalog/catversion.h
new file mode 100644
index 0000000000..282019c49d
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/catversion.h
@@ -0,0 +1,58 @@
+/*-------------------------------------------------------------------------
+ *
+ * catversion.h
+ *	  "Catalog version number" for PostgreSQL.
+ *
+ * The catalog version number is used to flag incompatible changes in
+ * the PostgreSQL system catalogs.  Whenever anyone changes the format of
+ * a system catalog relation, or adds, deletes, or modifies standard
+ * catalog entries in such a way that an updated backend wouldn't work
+ * with an old database (or vice versa), the catalog version number
+ * should be changed.  The version number stored in pg_control by initdb
+ * is checked against the version number compiled into the backend at
+ * startup time, so that a backend can refuse to run in an incompatible
+ * database.
+ *
+ * The point of this feature is to provide a finer grain of compatibility
+ * checking than is possible from looking at the major version number
+ * stored in PG_VERSION.  It shouldn't matter to end users, but during
+ * development cycles we usually make quite a few incompatible changes
+ * to the contents of the system catalogs, and we don't want to bump the
+ * major version number for each one.  What we can do instead is bump
+ * this internal version number.  This should save some grief for
+ * developers who might otherwise waste time tracking down "bugs" that
+ * are really just code-vs-database incompatibilities.
+ *
+ * The rule for developers is: if you commit a change that requires
+ * an initdb, you should update the catalog version number (as well as
+ * notifying the pgsql-hackers mailing list, which has been the
+ * informal practice for a long time).
+ *
+ * The catalog version number is placed here since modifying files in
+ * include/catalog is the most common kind of initdb-forcing change.
+ * But it could be used to protect any kind of incompatible change in
+ * database contents or layout, such as altering tuple headers.
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/catversion.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef CATVERSION_H
+#define CATVERSION_H
+
+/*
+ * We could use anything we wanted for version numbers, but I recommend
+ * following the "YYYYMMDDN" style often used for DNS zone serial numbers.
+ * YYYYMMDD are the date of the change, and N is the number of the change
+ * on that day.  (Hopefully we'll never commit ten independent sets of
+ * catalog changes on the same day...)
+ */
+
+/*							yyyymmddN */
+#define CATALOG_VERSION_NO	202007201
+
+#endif
diff --git a/contrib/libs/postgresql/src/include/catalog/dependency.h b/contrib/libs/postgresql/src/include/catalog/dependency.h
new file mode 100644
index 0000000000..7fe3fb7e7c
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/dependency.h
@@ -0,0 +1,275 @@
+/*-------------------------------------------------------------------------
+ *
+ * dependency.h
+ *	  Routines to support inter-object dependencies.
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/dependency.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef DEPENDENCY_H
+#define DEPENDENCY_H
+
+#include "catalog/objectaddress.h"
+
+
+/*
+ * Precise semantics of a dependency relationship are specified by the
+ * DependencyType code (which is stored in a "char" field in pg_depend,
+ * so we assign ASCII-code values to the enumeration members).
+ *
+ * In all cases, a dependency relationship indicates that the referenced
+ * object may not be dropped without also dropping the dependent object.
+ * However, there are several subflavors; see the description of pg_depend
+ * in catalogs.sgml for details.
+ */
+
+typedef enum DependencyType
+{
+	DEPENDENCY_NORMAL = 'n',
+	DEPENDENCY_AUTO = 'a',
+	DEPENDENCY_INTERNAL = 'i',
+	DEPENDENCY_PARTITION_PRI = 'P',
+	DEPENDENCY_PARTITION_SEC = 'S',
+	DEPENDENCY_EXTENSION = 'e',
+	DEPENDENCY_AUTO_EXTENSION = 'x',
+	DEPENDENCY_PIN = 'p'
+} DependencyType;
+
+/*
+ * There is also a SharedDependencyType enum type that determines the exact
+ * semantics of an entry in pg_shdepend.  Just like regular dependency entries,
+ * any pg_shdepend entry means that the referenced object cannot be dropped
+ * unless the dependent object is dropped at the same time.  There are some
+ * additional rules however:
+ *
+ * (a) For a SHARED_DEPENDENCY_PIN entry, there is no dependent object --
+ * rather, the referenced object is an essential part of the system.  This
+ * applies to the initdb-created superuser.  Entries of this type are only
+ * created by initdb; objects in this category don't need further pg_shdepend
+ * entries if more objects come to depend on them.
+ *
+ * (b) a SHARED_DEPENDENCY_OWNER entry means that the referenced object is
+ * the role owning the dependent object.  The referenced object must be
+ * a pg_authid entry.
+ *
+ * (c) a SHARED_DEPENDENCY_ACL entry means that the referenced object is
+ * a role mentioned in the ACL field of the dependent object.  The referenced
+ * object must be a pg_authid entry.  (SHARED_DEPENDENCY_ACL entries are not
+ * created for the owner of an object; hence two objects may be linked by
+ * one or the other, but not both, of these dependency types.)
+ *
+ * (d) a SHARED_DEPENDENCY_POLICY entry means that the referenced object is
+ * a role mentioned in a policy object.  The referenced object must be a
+ * pg_authid entry.
+ *
+ * (e) a SHARED_DEPENDENCY_TABLESPACE entry means that the referenced
+ * object is a tablespace mentioned in a relation without storage.  The
+ * referenced object must be a pg_tablespace entry.  (Relations that have
+ * storage don't need this: they are protected by the existence of a physical
+ * file in the tablespace.)
+ *
+ * SHARED_DEPENDENCY_INVALID is a value used as a parameter in internal
+ * routines, and is not valid in the catalog itself.
+ */
+typedef enum SharedDependencyType
+{
+	SHARED_DEPENDENCY_PIN = 'p',
+	SHARED_DEPENDENCY_OWNER = 'o',
+	SHARED_DEPENDENCY_ACL = 'a',
+	SHARED_DEPENDENCY_POLICY = 'r',
+	SHARED_DEPENDENCY_TABLESPACE = 't',
+	SHARED_DEPENDENCY_INVALID = 0
+} SharedDependencyType;
+
+/* expansible list of ObjectAddresses (private in dependency.c) */
+typedef struct ObjectAddresses ObjectAddresses;
+
+/*
+ * This enum covers all system catalogs whose OIDs can appear in
+ * pg_depend.classId or pg_shdepend.classId.  Keep object_classes[] in sync.
+ */
+typedef enum ObjectClass
+{
+	OCLASS_CLASS,				/* pg_class */
+	OCLASS_PROC,				/* pg_proc */
+	OCLASS_TYPE,				/* pg_type */
+	OCLASS_CAST,				/* pg_cast */
+	OCLASS_COLLATION,			/* pg_collation */
+	OCLASS_CONSTRAINT,			/* pg_constraint */
+	OCLASS_CONVERSION,			/* pg_conversion */
+	OCLASS_DEFAULT,				/* pg_attrdef */
+	OCLASS_LANGUAGE,			/* pg_language */
+	OCLASS_LARGEOBJECT,			/* pg_largeobject */
+	OCLASS_OPERATOR,			/* pg_operator */
+	OCLASS_OPCLASS,				/* pg_opclass */
+	OCLASS_OPFAMILY,			/* pg_opfamily */
+	OCLASS_AM,					/* pg_am */
+	OCLASS_AMOP,				/* pg_amop */
+	OCLASS_AMPROC,				/* pg_amproc */
+	OCLASS_REWRITE,				/* pg_rewrite */
+	OCLASS_TRIGGER,				/* pg_trigger */
+	OCLASS_SCHEMA,				/* pg_namespace */
+	OCLASS_STATISTIC_EXT,		/* pg_statistic_ext */
+	OCLASS_TSPARSER,			/* pg_ts_parser */
+	OCLASS_TSDICT,				/* pg_ts_dict */
+	OCLASS_TSTEMPLATE,			/* pg_ts_template */
+	OCLASS_TSCONFIG,			/* pg_ts_config */
+	OCLASS_ROLE,				/* pg_authid */
+	OCLASS_DATABASE,			/* pg_database */
+	OCLASS_TBLSPACE,			/* pg_tablespace */
+	OCLASS_FDW,					/* pg_foreign_data_wrapper */
+	OCLASS_FOREIGN_SERVER,		/* pg_foreign_server */
+	OCLASS_USER_MAPPING,		/* pg_user_mapping */
+	OCLASS_DEFACL,				/* pg_default_acl */
+	OCLASS_EXTENSION,			/* pg_extension */
+	OCLASS_EVENT_TRIGGER,		/* pg_event_trigger */
+	OCLASS_POLICY,				/* pg_policy */
+	OCLASS_PUBLICATION,			/* pg_publication */
+	OCLASS_PUBLICATION_REL,		/* pg_publication_rel */
+	OCLASS_SUBSCRIPTION,		/* pg_subscription */
+	OCLASS_TRANSFORM			/* pg_transform */
+} ObjectClass;
+
+#define LAST_OCLASS		OCLASS_TRANSFORM
+
+/* flag bits for performDeletion/performMultipleDeletions: */
+#define PERFORM_DELETION_INTERNAL			0x0001	/* internal action */
+#define PERFORM_DELETION_CONCURRENTLY		0x0002	/* concurrent drop */
+#define PERFORM_DELETION_QUIETLY			0x0004	/* suppress notices */
+#define PERFORM_DELETION_SKIP_ORIGINAL		0x0008	/* keep original obj */
+#define PERFORM_DELETION_SKIP_EXTENSIONS	0x0010	/* keep extensions */
+#define PERFORM_DELETION_CONCURRENT_LOCK	0x0020	/* normal drop with
+													 * concurrent lock mode */
+
+
+/* in dependency.c */
+
+extern void AcquireDeletionLock(const ObjectAddress *object, int flags);
+
+extern void ReleaseDeletionLock(const ObjectAddress *object);
+
+extern void performDeletion(const ObjectAddress *object,
+							DropBehavior behavior, int flags);
+
+extern void performMultipleDeletions(const ObjectAddresses *objects,
+									 DropBehavior behavior, int flags);
+
+extern void recordDependencyOnExpr(const ObjectAddress *depender,
+								   Node *expr, List *rtable,
+								   DependencyType behavior);
+
+extern void recordDependencyOnSingleRelExpr(const ObjectAddress *depender,
+											Node *expr, Oid relId,
+											DependencyType behavior,
+											DependencyType self_behavior,
+											bool reverse_self);
+
+extern ObjectClass getObjectClass(const ObjectAddress *object);
+
+extern ObjectAddresses *new_object_addresses(void);
+
+extern void add_exact_object_address(const ObjectAddress *object,
+									 ObjectAddresses *addrs);
+
+extern bool object_address_present(const ObjectAddress *object,
+								   const ObjectAddresses *addrs);
+
+extern void record_object_address_dependencies(const ObjectAddress *depender,
+											   ObjectAddresses *referenced,
+											   DependencyType behavior);
+
+extern void sort_object_addresses(ObjectAddresses *addrs);
+
+extern void free_object_addresses(ObjectAddresses *addrs);
+
+/* in pg_depend.c */
+
+extern void recordDependencyOn(const ObjectAddress *depender,
+							   const ObjectAddress *referenced,
+							   DependencyType behavior);
+
+extern void recordMultipleDependencies(const ObjectAddress *depender,
+									   const ObjectAddress *referenced,
+									   int nreferenced,
+									   DependencyType behavior);
+
+extern void recordDependencyOnCurrentExtension(const ObjectAddress *object,
+											   bool isReplace);
+
+extern long deleteDependencyRecordsFor(Oid classId, Oid objectId,
+									   bool skipExtensionDeps);
+
+extern long deleteDependencyRecordsForClass(Oid classId, Oid objectId,
+											Oid refclassId, char deptype);
+
+extern long deleteDependencyRecordsForSpecific(Oid classId, Oid objectId,
+											   char deptype,
+											   Oid refclassId, Oid refobjectId);
+
+extern long changeDependencyFor(Oid classId, Oid objectId,
+								Oid refClassId, Oid oldRefObjectId,
+								Oid newRefObjectId);
+
+extern long changeDependenciesOf(Oid classId, Oid oldObjectId,
+								 Oid newObjectId);
+
+extern long changeDependenciesOn(Oid refClassId, Oid oldRefObjectId,
+								 Oid newRefObjectId);
+
+extern Oid	getExtensionOfObject(Oid classId, Oid objectId);
+extern List *getAutoExtensionsOfObject(Oid classId, Oid objectId);
+
+extern bool sequenceIsOwned(Oid seqId, char deptype, Oid *tableId, int32 *colId);
+extern List *getOwnedSequences(Oid relid);
+extern Oid	getIdentitySequence(Oid relid, AttrNumber attnum, bool missing_ok);
+
+extern Oid	get_constraint_index(Oid constraintId);
+
+extern Oid	get_index_constraint(Oid indexId);
+
+extern List *get_index_ref_constraints(Oid indexId);
+
+/* in pg_shdepend.c */
+
+extern void recordSharedDependencyOn(ObjectAddress *depender,
+									 ObjectAddress *referenced,
+									 SharedDependencyType deptype);
+
+extern void deleteSharedDependencyRecordsFor(Oid classId, Oid objectId,
+											 int32 objectSubId);
+
+extern void recordDependencyOnOwner(Oid classId, Oid objectId, Oid owner);
+
+extern void changeDependencyOnOwner(Oid classId, Oid objectId,
+									Oid newOwnerId);
+
+extern void recordDependencyOnTablespace(Oid classId, Oid objectId,
+										 Oid tablespace);
+
+extern void changeDependencyOnTablespace(Oid classId, Oid objectId,
+										 Oid newTablespaceId);
+
+extern void updateAclDependencies(Oid classId, Oid objectId, int32 objectSubId,
+								  Oid ownerId,
+								  int noldmembers, Oid *oldmembers,
+								  int nnewmembers, Oid *newmembers);
+
+extern bool checkSharedDependencies(Oid classId, Oid objectId,
+									char **detail_msg, char **detail_log_msg);
+
+extern void shdepLockAndCheckObject(Oid classId, Oid objectId);
+
+extern void copyTemplateDependencies(Oid templateDbId, Oid newDbId);
+
+extern void dropDatabaseDependencies(Oid databaseId);
+
+extern void shdepDropOwned(List *relids, DropBehavior behavior);
+
+extern void shdepReassignOwned(List *relids, Oid newrole);
+
+#endif							/* DEPENDENCY_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/genbki.h b/contrib/libs/postgresql/src/include/catalog/genbki.h
new file mode 100644
index 0000000000..4a6c8636da
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/genbki.h
@@ -0,0 +1,64 @@
+/*-------------------------------------------------------------------------
+ *
+ * genbki.h
+ *	  Required include file for all POSTGRES catalog header files
+ *
+ * genbki.h defines CATALOG(), BKI_BOOTSTRAP and related macros
+ * so that the catalog header files can be read by the C compiler.
+ * (These same words are recognized by genbki.pl to build the BKI
+ * bootstrap file from these header files.)
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/genbki.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef GENBKI_H
+#define GENBKI_H
+
+/* Introduces a catalog's structure definition */
+#define CATALOG(name,oid,oidmacro)	typedef struct CppConcat(FormData_,name)
+
+/* Options that may appear after CATALOG (on the same line) */
+#define BKI_BOOTSTRAP
+#define BKI_SHARED_RELATION
+#define BKI_ROWTYPE_OID(oid,oidmacro)
+#define BKI_SCHEMA_MACRO
+
+/* Options that may appear after an attribute (on the same line) */
+#define BKI_FORCE_NULL
+#define BKI_FORCE_NOT_NULL
+/* Specifies a default value for a catalog field */
+#define BKI_DEFAULT(value)
+/* Specifies a default value for auto-generated array types */
+#define BKI_ARRAY_DEFAULT(value)
+/*
+ * Indicates how to perform name lookups, typically for an OID or
+ * OID-array field
+ */
+#define BKI_LOOKUP(catalog)
+
+/* The following are never defined; they are here only for documentation. */
+
+/*
+ * Variable-length catalog fields (except possibly the first not nullable one)
+ * should not be visible in C structures, so they are made invisible by #ifdefs
+ * of an undefined symbol.  See also MARKNOTNULL in bootstrap.c for how this is
+ * handled.
+ */
+#undef CATALOG_VARLEN
+
+/*
+ * There is code in some catalog headers that needs to be visible to clients,
+ * but we don't want clients to include the full header because of safety
+ * issues with other code in the header.  To handle that, surround code that
+ * should be visible to clients with "#ifdef EXPOSE_TO_CLIENT_CODE".  That
+ * instructs genbki.pl to copy the section when generating the corresponding
+ * "_d" header, which can be included by both client and backend code.
+ */
+#undef EXPOSE_TO_CLIENT_CODE
+
+#endif							/* GENBKI_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/heap.h b/contrib/libs/postgresql/src/include/catalog/heap.h
new file mode 100644
index 0000000000..bec795abac
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/heap.h
@@ -0,0 +1,163 @@
+/*-------------------------------------------------------------------------
+ *
+ * heap.h
+ *	  prototypes for functions in backend/catalog/heap.c
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/heap.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef HEAP_H
+#define HEAP_H
+
+#include "catalog/indexing.h"
+#include "catalog/objectaddress.h"
+#include "parser/parse_node.h"
+
+
+/* flag bits for CheckAttributeType/CheckAttributeNamesTypes */
+#define CHKATYPE_ANYARRAY		0x01	/* allow ANYARRAY */
+#define CHKATYPE_ANYRECORD		0x02	/* allow RECORD and RECORD[] */
+#define CHKATYPE_IS_PARTKEY		0x04	/* attname is part key # not column */
+
+typedef struct RawColumnDefault
+{
+	AttrNumber	attnum;			/* attribute to attach default to */
+	Node	   *raw_default;	/* default value (untransformed parse tree) */
+	bool		missingMode;	/* true if part of add column processing */
+	char		generated;		/* attgenerated setting */
+} RawColumnDefault;
+
+typedef struct CookedConstraint
+{
+	ConstrType	contype;		/* CONSTR_DEFAULT or CONSTR_CHECK */
+	Oid			conoid;			/* constr OID if created, otherwise Invalid */
+	char	   *name;			/* name, or NULL if none */
+	AttrNumber	attnum;			/* which attr (only for DEFAULT) */
+	Node	   *expr;			/* transformed default or check expr */
+	bool		skip_validation;	/* skip validation? (only for CHECK) */
+	bool		is_local;		/* constraint has local (non-inherited) def */
+	int			inhcount;		/* number of times constraint is inherited */
+	bool		is_no_inherit;	/* constraint has local def and cannot be
+								 * inherited */
+} CookedConstraint;
+
+extern Relation heap_create(const char *relname,
+							Oid relnamespace,
+							Oid reltablespace,
+							Oid relid,
+							Oid relfilenode,
+							Oid accessmtd,
+							TupleDesc tupDesc,
+							char relkind,
+							char relpersistence,
+							bool shared_relation,
+							bool mapped_relation,
+							bool allow_system_table_mods,
+							TransactionId *relfrozenxid,
+							MultiXactId *relminmxid);
+
+extern Oid	heap_create_with_catalog(const char *relname,
+									 Oid relnamespace,
+									 Oid reltablespace,
+									 Oid relid,
+									 Oid reltypeid,
+									 Oid reloftypeid,
+									 Oid ownerid,
+									 Oid accessmtd,
+									 TupleDesc tupdesc,
+									 List *cooked_constraints,
+									 char relkind,
+									 char relpersistence,
+									 bool shared_relation,
+									 bool mapped_relation,
+									 OnCommitAction oncommit,
+									 Datum reloptions,
+									 bool use_user_acl,
+									 bool allow_system_table_mods,
+									 bool is_internal,
+									 Oid relrewrite,
+									 ObjectAddress *typaddress);
+
+extern void heap_drop_with_catalog(Oid relid);
+
+extern void heap_truncate(List *relids);
+
+extern void heap_truncate_one_rel(Relation rel);
+
+extern void heap_truncate_check_FKs(List *relations, bool tempTables);
+
+extern List *heap_truncate_find_FKs(List *relationIds);
+
+extern void InsertPgAttributeTuple(Relation pg_attribute_rel,
+								   Form_pg_attribute new_attribute,
+								   Datum attoptions,
+								   CatalogIndexState indstate);
+
+extern void InsertPgClassTuple(Relation pg_class_desc,
+							   Relation new_rel_desc,
+							   Oid new_rel_oid,
+							   Datum relacl,
+							   Datum reloptions);
+
+extern List *AddRelationNewConstraints(Relation rel,
+									   List *newColDefaults,
+									   List *newConstraints,
+									   bool allow_merge,
+									   bool is_local,
+									   bool is_internal,
+									   const char *queryString);
+
+extern void RelationClearMissing(Relation rel);
+extern void SetAttrMissing(Oid relid, char *attname, char *value);
+
+extern Oid	StoreAttrDefault(Relation rel, AttrNumber attnum,
+							 Node *expr, bool is_internal,
+							 bool add_column_mode);
+
+extern Node *cookDefault(ParseState *pstate,
+						 Node *raw_default,
+						 Oid atttypid,
+						 int32 atttypmod,
+						 const char *attname,
+						 char attgenerated);
+
+extern void DeleteRelationTuple(Oid relid);
+extern void DeleteAttributeTuples(Oid relid);
+extern void DeleteSystemAttributeTuples(Oid relid);
+extern void RemoveAttributeById(Oid relid, AttrNumber attnum);
+extern void RemoveAttrDefault(Oid relid, AttrNumber attnum,
+							  DropBehavior behavior, bool complain, bool internal);
+extern void RemoveAttrDefaultById(Oid attrdefId);
+extern void CopyStatistics(Oid fromrelid, Oid torelid);
+extern void RemoveStatistics(Oid relid, AttrNumber attnum);
+
+extern const FormData_pg_attribute *SystemAttributeDefinition(AttrNumber attno);
+
+extern const FormData_pg_attribute *SystemAttributeByName(const char *attname);
+
+extern void CheckAttributeNamesTypes(TupleDesc tupdesc, char relkind,
+									 int flags);
+
+extern void CheckAttributeType(const char *attname,
+							   Oid atttypid, Oid attcollation,
+							   List *containing_rowtypes,
+							   int flags);
+
+/* pg_partitioned_table catalog manipulation functions */
+extern void StorePartitionKey(Relation rel,
+							  char strategy,
+							  int16 partnatts,
+							  AttrNumber *partattrs,
+							  List *partexprs,
+							  Oid *partopclass,
+							  Oid *partcollation);
+extern void RemovePartitionKeyByRelId(Oid relid);
+extern void StorePartitionBound(Relation rel, Relation parent,
+								PartitionBoundSpec *bound);
+
+#endif							/* HEAP_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/index.h b/contrib/libs/postgresql/src/include/catalog/index.h
new file mode 100644
index 0000000000..f58e8675f3
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/index.h
@@ -0,0 +1,199 @@
+/*-------------------------------------------------------------------------
+ *
+ * index.h
+ *	  prototypes for catalog/index.c.
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/index.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef INDEX_H
+#define INDEX_H
+
+#include "catalog/objectaddress.h"
+#include "nodes/execnodes.h"
+
+
+#define DEFAULT_INDEX_TYPE	"btree"
+
+/* Action code for index_set_state_flags */
+typedef enum
+{
+	INDEX_CREATE_SET_READY,
+	INDEX_CREATE_SET_VALID,
+	INDEX_DROP_CLEAR_VALID,
+	INDEX_DROP_SET_DEAD
+} IndexStateFlagsAction;
+
+/* state info for validate_index bulkdelete callback */
+typedef struct ValidateIndexState
+{
+	Tuplesortstate *tuplesort;	/* for sorting the index TIDs */
+	/* statistics (for debug purposes only): */
+	double		htups,
+				itups,
+				tups_inserted;
+} ValidateIndexState;
+
+extern void index_check_primary_key(Relation heapRel,
+									IndexInfo *indexInfo,
+									bool is_alter_table,
+									IndexStmt *stmt);
+
+#define	INDEX_CREATE_IS_PRIMARY				(1 << 0)
+#define	INDEX_CREATE_ADD_CONSTRAINT			(1 << 1)
+#define	INDEX_CREATE_SKIP_BUILD				(1 << 2)
+#define	INDEX_CREATE_CONCURRENT				(1 << 3)
+#define	INDEX_CREATE_IF_NOT_EXISTS			(1 << 4)
+#define	INDEX_CREATE_PARTITIONED			(1 << 5)
+#define INDEX_CREATE_INVALID				(1 << 6)
+
+extern Oid	index_create(Relation heapRelation,
+						 const char *indexRelationName,
+						 Oid indexRelationId,
+						 Oid parentIndexRelid,
+						 Oid parentConstraintId,
+						 Oid relFileNode,
+						 IndexInfo *indexInfo,
+						 List *indexColNames,
+						 Oid accessMethodObjectId,
+						 Oid tableSpaceId,
+						 Oid *collationObjectId,
+						 Oid *classObjectId,
+						 int16 *coloptions,
+						 Datum reloptions,
+						 bits16 flags,
+						 bits16 constr_flags,
+						 bool allow_system_table_mods,
+						 bool is_internal,
+						 Oid *constraintId);
+
+#define	INDEX_CONSTR_CREATE_MARK_AS_PRIMARY	(1 << 0)
+#define	INDEX_CONSTR_CREATE_DEFERRABLE		(1 << 1)
+#define	INDEX_CONSTR_CREATE_INIT_DEFERRED	(1 << 2)
+#define	INDEX_CONSTR_CREATE_UPDATE_INDEX	(1 << 3)
+#define	INDEX_CONSTR_CREATE_REMOVE_OLD_DEPS	(1 << 4)
+
+extern Oid	index_concurrently_create_copy(Relation heapRelation,
+										   Oid oldIndexId,
+										   const char *newName);
+
+extern void index_concurrently_build(Oid heapRelationId,
+									 Oid indexRelationId);
+
+extern void index_concurrently_swap(Oid newIndexId,
+									Oid oldIndexId,
+									const char *oldName);
+
+extern void index_concurrently_set_dead(Oid heapId,
+										Oid indexId);
+
+extern ObjectAddress index_constraint_create(Relation heapRelation,
+											 Oid indexRelationId,
+											 Oid parentConstraintId,
+											 IndexInfo *indexInfo,
+											 const char *constraintName,
+											 char constraintType,
+											 bits16 constr_flags,
+											 bool allow_system_table_mods,
+											 bool is_internal);
+
+extern void index_drop(Oid indexId, bool concurrent, bool concurrent_lock_mode);
+
+extern IndexInfo *BuildIndexInfo(Relation index);
+
+extern IndexInfo *BuildDummyIndexInfo(Relation index);
+
+extern bool CompareIndexInfo(IndexInfo *info1, IndexInfo *info2,
+							 Oid *collations1, Oid *collations2,
+							 Oid *opfamilies1, Oid *opfamilies2,
+							 AttrMap *attmap);
+
+extern void BuildSpeculativeIndexInfo(Relation index, IndexInfo *ii);
+
+extern void FormIndexDatum(IndexInfo *indexInfo,
+						   TupleTableSlot *slot,
+						   EState *estate,
+						   Datum *values,
+						   bool *isnull);
+
+extern void index_build(Relation heapRelation,
+						Relation indexRelation,
+						IndexInfo *indexInfo,
+						bool isreindex,
+						bool parallel);
+
+extern void validate_index(Oid heapId, Oid indexId, Snapshot snapshot);
+
+extern void index_set_state_flags(Oid indexId, IndexStateFlagsAction action);
+
+extern Oid	IndexGetRelation(Oid indexId, bool missing_ok);
+
+extern void reindex_index(Oid indexId, bool skip_constraint_checks,
+						  char relpersistence, int options);
+
+/* Flag bits for reindex_relation(): */
+#define REINDEX_REL_PROCESS_TOAST			0x01
+#define REINDEX_REL_SUPPRESS_INDEX_USE		0x02
+#define REINDEX_REL_CHECK_CONSTRAINTS		0x04
+#define REINDEX_REL_FORCE_INDEXES_UNLOGGED	0x08
+#define REINDEX_REL_FORCE_INDEXES_PERMANENT 0x10
+
+extern bool reindex_relation(Oid relid, int flags, int options);
+
+extern bool ReindexIsProcessingHeap(Oid heapOid);
+extern bool ReindexIsProcessingIndex(Oid indexOid);
+
+extern void ResetReindexState(int nestLevel);
+extern Size EstimateReindexStateSpace(void);
+extern void SerializeReindexState(Size maxsize, char *start_address);
+extern void RestoreReindexState(void *reindexstate);
+
+extern void IndexSetParentIndex(Relation idx, Oid parentOid);
+
+
+/*
+ * itemptr_encode - Encode ItemPointer as int64/int8
+ *
+ * This representation must produce values encoded as int64 that sort in the
+ * same order as their corresponding original TID values would (using the
+ * default int8 opclass to produce a result equivalent to the default TID
+ * opclass).
+ *
+ * As noted in validate_index(), this can be significantly faster.
+ */
+static inline int64
+itemptr_encode(ItemPointer itemptr)
+{
+	BlockNumber block = ItemPointerGetBlockNumber(itemptr);
+	OffsetNumber offset = ItemPointerGetOffsetNumber(itemptr);
+	int64		encoded;
+
+	/*
+	 * Use the 16 least significant bits for the offset.  32 adjacent bits are
+	 * used for the block number.  Since remaining bits are unused, there
+	 * cannot be negative encoded values (We assume a two's complement
+	 * representation).
+	 */
+	encoded = ((uint64) block << 16) | (uint16) offset;
+
+	return encoded;
+}
+
+/*
+ * itemptr_decode - Decode int64/int8 representation back to ItemPointer
+ */
+static inline void
+itemptr_decode(ItemPointer itemptr, int64 encoded)
+{
+	BlockNumber block = (BlockNumber) (encoded >> 16);
+	OffsetNumber offset = (OffsetNumber) (encoded & 0xFFFF);
+
+	ItemPointerSet(itemptr, block, offset);
+}
+
+#endif							/* INDEX_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/indexing.h b/contrib/libs/postgresql/src/include/catalog/indexing.h
new file mode 100644
index 0000000000..8be303870f
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/indexing.h
@@ -0,0 +1,366 @@
+/*-------------------------------------------------------------------------
+ *
+ * indexing.h
+ *	  This file provides some definitions to support indexing
+ *	  on system catalogs
+ *
+ * Caution: all #define's with numeric values in this file had better be
+ * object OIDs, else renumber_oids.pl might change them inappropriately.
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/indexing.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef INDEXING_H
+#define INDEXING_H
+
+#include "access/htup.h"
+#include "utils/relcache.h"
+
+/*
+ * The state object used by CatalogOpenIndexes and friends is actually the
+ * same as the executor's ResultRelInfo, but we give it another type name
+ * to decouple callers from that fact.
+ */
+typedef struct ResultRelInfo *CatalogIndexState;
+
+/*
+ * indexing.c prototypes
+ */
+extern CatalogIndexState CatalogOpenIndexes(Relation heapRel);
+extern void CatalogCloseIndexes(CatalogIndexState indstate);
+extern void CatalogTupleInsert(Relation heapRel, HeapTuple tup);
+extern void CatalogTupleInsertWithInfo(Relation heapRel, HeapTuple tup,
+									   CatalogIndexState indstate);
+extern void CatalogTupleUpdate(Relation heapRel, ItemPointer otid,
+							   HeapTuple tup);
+extern void CatalogTupleUpdateWithInfo(Relation heapRel,
+									   ItemPointer otid, HeapTuple tup,
+									   CatalogIndexState indstate);
+extern void CatalogTupleDelete(Relation heapRel, ItemPointer tid);
+
+
+/*
+ * These macros are just to keep the C compiler from spitting up on the
+ * upcoming commands for Catalog.pm.
+ */
+#define DECLARE_INDEX(name,oid,decl) extern int no_such_variable
+#define DECLARE_UNIQUE_INDEX(name,oid,decl) extern int no_such_variable
+
+
+/*
+ * What follows are lines processed by genbki.pl to create the statements
+ * the bootstrap parser will turn into DefineIndex calls.
+ *
+ * The keyword is DECLARE_INDEX or DECLARE_UNIQUE_INDEX.  The first two
+ * arguments are the index name and OID, the rest is much like a standard
+ * 'create index' SQL command.
+ *
+ * For each index, we also provide a #define for its OID.  References to
+ * the index in the C code should always use these #defines, not the actual
+ * index name (much less the numeric OID).
+ */
+
+DECLARE_UNIQUE_INDEX(pg_aggregate_fnoid_index, 2650, on pg_aggregate using btree(aggfnoid oid_ops));
+#define AggregateFnoidIndexId  2650
+
+DECLARE_UNIQUE_INDEX(pg_am_name_index, 2651, on pg_am using btree(amname name_ops));
+#define AmNameIndexId  2651
+DECLARE_UNIQUE_INDEX(pg_am_oid_index, 2652, on pg_am using btree(oid oid_ops));
+#define AmOidIndexId  2652
+
+DECLARE_UNIQUE_INDEX(pg_amop_fam_strat_index, 2653, on pg_amop using btree(amopfamily oid_ops, amoplefttype oid_ops, amoprighttype oid_ops, amopstrategy int2_ops));
+#define AccessMethodStrategyIndexId  2653
+DECLARE_UNIQUE_INDEX(pg_amop_opr_fam_index, 2654, on pg_amop using btree(amopopr oid_ops, amoppurpose char_ops, amopfamily oid_ops));
+#define AccessMethodOperatorIndexId  2654
+DECLARE_UNIQUE_INDEX(pg_amop_oid_index, 2756, on pg_amop using btree(oid oid_ops));
+#define AccessMethodOperatorOidIndexId	2756
+
+DECLARE_UNIQUE_INDEX(pg_amproc_fam_proc_index, 2655, on pg_amproc using btree(amprocfamily oid_ops, amproclefttype oid_ops, amprocrighttype oid_ops, amprocnum int2_ops));
+#define AccessMethodProcedureIndexId  2655
+DECLARE_UNIQUE_INDEX(pg_amproc_oid_index, 2757, on pg_amproc using btree(oid oid_ops));
+#define AccessMethodProcedureOidIndexId  2757
+
+DECLARE_UNIQUE_INDEX(pg_attrdef_adrelid_adnum_index, 2656, on pg_attrdef using btree(adrelid oid_ops, adnum int2_ops));
+#define AttrDefaultIndexId	2656
+DECLARE_UNIQUE_INDEX(pg_attrdef_oid_index, 2657, on pg_attrdef using btree(oid oid_ops));
+#define AttrDefaultOidIndexId  2657
+
+DECLARE_UNIQUE_INDEX(pg_attribute_relid_attnam_index, 2658, on pg_attribute using btree(attrelid oid_ops, attname name_ops));
+#define AttributeRelidNameIndexId  2658
+DECLARE_UNIQUE_INDEX(pg_attribute_relid_attnum_index, 2659, on pg_attribute using btree(attrelid oid_ops, attnum int2_ops));
+#define AttributeRelidNumIndexId  2659
+
+DECLARE_UNIQUE_INDEX(pg_authid_rolname_index, 2676, on pg_authid using btree(rolname name_ops));
+#define AuthIdRolnameIndexId	2676
+DECLARE_UNIQUE_INDEX(pg_authid_oid_index, 2677, on pg_authid using btree(oid oid_ops));
+#define AuthIdOidIndexId	2677
+
+DECLARE_UNIQUE_INDEX(pg_auth_members_role_member_index, 2694, on pg_auth_members using btree(roleid oid_ops, member oid_ops));
+#define AuthMemRoleMemIndexId	2694
+DECLARE_UNIQUE_INDEX(pg_auth_members_member_role_index, 2695, on pg_auth_members using btree(member oid_ops, roleid oid_ops));
+#define AuthMemMemRoleIndexId	2695
+
+DECLARE_UNIQUE_INDEX(pg_cast_oid_index, 2660, on pg_cast using btree(oid oid_ops));
+#define CastOidIndexId	2660
+DECLARE_UNIQUE_INDEX(pg_cast_source_target_index, 2661, on pg_cast using btree(castsource oid_ops, casttarget oid_ops));
+#define CastSourceTargetIndexId  2661
+
+DECLARE_UNIQUE_INDEX(pg_class_oid_index, 2662, on pg_class using btree(oid oid_ops));
+#define ClassOidIndexId  2662
+DECLARE_UNIQUE_INDEX(pg_class_relname_nsp_index, 2663, on pg_class using btree(relname name_ops, relnamespace oid_ops));
+#define ClassNameNspIndexId  2663
+DECLARE_INDEX(pg_class_tblspc_relfilenode_index, 3455, on pg_class using btree(reltablespace oid_ops, relfilenode oid_ops));
+#define ClassTblspcRelfilenodeIndexId  3455
+
+DECLARE_UNIQUE_INDEX(pg_collation_name_enc_nsp_index, 3164, on pg_collation using btree(collname name_ops, collencoding int4_ops, collnamespace oid_ops));
+#define CollationNameEncNspIndexId 3164
+DECLARE_UNIQUE_INDEX(pg_collation_oid_index, 3085, on pg_collation using btree(oid oid_ops));
+#define CollationOidIndexId  3085
+
+DECLARE_INDEX(pg_constraint_conname_nsp_index, 2664, on pg_constraint using btree(conname name_ops, connamespace oid_ops));
+#define ConstraintNameNspIndexId  2664
+DECLARE_UNIQUE_INDEX(pg_constraint_conrelid_contypid_conname_index, 2665, on pg_constraint using btree(conrelid oid_ops, contypid oid_ops, conname name_ops));
+#define ConstraintRelidTypidNameIndexId	2665
+DECLARE_INDEX(pg_constraint_contypid_index, 2666, on pg_constraint using btree(contypid oid_ops));
+#define ConstraintTypidIndexId	2666
+DECLARE_UNIQUE_INDEX(pg_constraint_oid_index, 2667, on pg_constraint using btree(oid oid_ops));
+#define ConstraintOidIndexId  2667
+DECLARE_INDEX(pg_constraint_conparentid_index, 2579, on pg_constraint using btree(conparentid oid_ops));
+#define ConstraintParentIndexId	2579
+
+DECLARE_UNIQUE_INDEX(pg_conversion_default_index, 2668, on pg_conversion using btree(connamespace oid_ops, conforencoding int4_ops, contoencoding int4_ops, oid oid_ops));
+#define ConversionDefaultIndexId  2668
+DECLARE_UNIQUE_INDEX(pg_conversion_name_nsp_index, 2669, on pg_conversion using btree(conname name_ops, connamespace oid_ops));
+#define ConversionNameNspIndexId  2669
+DECLARE_UNIQUE_INDEX(pg_conversion_oid_index, 2670, on pg_conversion using btree(oid oid_ops));
+#define ConversionOidIndexId  2670
+
+DECLARE_UNIQUE_INDEX(pg_database_datname_index, 2671, on pg_database using btree(datname name_ops));
+#define DatabaseNameIndexId  2671
+DECLARE_UNIQUE_INDEX(pg_database_oid_index, 2672, on pg_database using btree(oid oid_ops));
+#define DatabaseOidIndexId	2672
+
+DECLARE_INDEX(pg_depend_depender_index, 2673, on pg_depend using btree(classid oid_ops, objid oid_ops, objsubid int4_ops));
+#define DependDependerIndexId  2673
+DECLARE_INDEX(pg_depend_reference_index, 2674, on pg_depend using btree(refclassid oid_ops, refobjid oid_ops, refobjsubid int4_ops));
+#define DependReferenceIndexId	2674
+
+DECLARE_UNIQUE_INDEX(pg_description_o_c_o_index, 2675, on pg_description using btree(objoid oid_ops, classoid oid_ops, objsubid int4_ops));
+#define DescriptionObjIndexId  2675
+DECLARE_UNIQUE_INDEX(pg_shdescription_o_c_index, 2397, on pg_shdescription using btree(objoid oid_ops, classoid oid_ops));
+#define SharedDescriptionObjIndexId 2397
+
+DECLARE_UNIQUE_INDEX(pg_enum_oid_index, 3502, on pg_enum using btree(oid oid_ops));
+#define EnumOidIndexId	3502
+DECLARE_UNIQUE_INDEX(pg_enum_typid_label_index, 3503, on pg_enum using btree(enumtypid oid_ops, enumlabel name_ops));
+#define EnumTypIdLabelIndexId 3503
+DECLARE_UNIQUE_INDEX(pg_enum_typid_sortorder_index, 3534, on pg_enum using btree(enumtypid oid_ops, enumsortorder float4_ops));
+#define EnumTypIdSortOrderIndexId 3534
+
+DECLARE_INDEX(pg_index_indrelid_index, 2678, on pg_index using btree(indrelid oid_ops));
+#define IndexIndrelidIndexId  2678
+DECLARE_UNIQUE_INDEX(pg_index_indexrelid_index, 2679, on pg_index using btree(indexrelid oid_ops));
+#define IndexRelidIndexId  2679
+
+DECLARE_UNIQUE_INDEX(pg_inherits_relid_seqno_index, 2680, on pg_inherits using btree(inhrelid oid_ops, inhseqno int4_ops));
+#define InheritsRelidSeqnoIndexId  2680
+DECLARE_INDEX(pg_inherits_parent_index, 2187, on pg_inherits using btree(inhparent oid_ops));
+#define InheritsParentIndexId  2187
+
+DECLARE_UNIQUE_INDEX(pg_init_privs_o_c_o_index, 3395, on pg_init_privs using btree(objoid oid_ops, classoid oid_ops, objsubid int4_ops));
+#define InitPrivsObjIndexId  3395
+
+DECLARE_UNIQUE_INDEX(pg_language_name_index, 2681, on pg_language using btree(lanname name_ops));
+#define LanguageNameIndexId  2681
+DECLARE_UNIQUE_INDEX(pg_language_oid_index, 2682, on pg_language using btree(oid oid_ops));
+#define LanguageOidIndexId	2682
+
+DECLARE_UNIQUE_INDEX(pg_largeobject_loid_pn_index, 2683, on pg_largeobject using btree(loid oid_ops, pageno int4_ops));
+#define LargeObjectLOidPNIndexId  2683
+
+DECLARE_UNIQUE_INDEX(pg_largeobject_metadata_oid_index, 2996, on pg_largeobject_metadata using btree(oid oid_ops));
+#define LargeObjectMetadataOidIndexId	2996
+
+DECLARE_UNIQUE_INDEX(pg_namespace_nspname_index, 2684, on pg_namespace using btree(nspname name_ops));
+#define NamespaceNameIndexId  2684
+DECLARE_UNIQUE_INDEX(pg_namespace_oid_index, 2685, on pg_namespace using btree(oid oid_ops));
+#define NamespaceOidIndexId  2685
+
+DECLARE_UNIQUE_INDEX(pg_opclass_am_name_nsp_index, 2686, on pg_opclass using btree(opcmethod oid_ops, opcname name_ops, opcnamespace oid_ops));
+#define OpclassAmNameNspIndexId  2686
+DECLARE_UNIQUE_INDEX(pg_opclass_oid_index, 2687, on pg_opclass using btree(oid oid_ops));
+#define OpclassOidIndexId  2687
+
+DECLARE_UNIQUE_INDEX(pg_operator_oid_index, 2688, on pg_operator using btree(oid oid_ops));
+#define OperatorOidIndexId	2688
+DECLARE_UNIQUE_INDEX(pg_operator_oprname_l_r_n_index, 2689, on pg_operator using btree(oprname name_ops, oprleft oid_ops, oprright oid_ops, oprnamespace oid_ops));
+#define OperatorNameNspIndexId	2689
+
+DECLARE_UNIQUE_INDEX(pg_opfamily_am_name_nsp_index, 2754, on pg_opfamily using btree(opfmethod oid_ops, opfname name_ops, opfnamespace oid_ops));
+#define OpfamilyAmNameNspIndexId  2754
+DECLARE_UNIQUE_INDEX(pg_opfamily_oid_index, 2755, on pg_opfamily using btree(oid oid_ops));
+#define OpfamilyOidIndexId	2755
+
+DECLARE_UNIQUE_INDEX(pg_proc_oid_index, 2690, on pg_proc using btree(oid oid_ops));
+#define ProcedureOidIndexId  2690
+DECLARE_UNIQUE_INDEX(pg_proc_proname_args_nsp_index, 2691, on pg_proc using btree(proname name_ops, proargtypes oidvector_ops, pronamespace oid_ops));
+#define ProcedureNameArgsNspIndexId  2691
+
+DECLARE_UNIQUE_INDEX(pg_rewrite_oid_index, 2692, on pg_rewrite using btree(oid oid_ops));
+#define RewriteOidIndexId  2692
+DECLARE_UNIQUE_INDEX(pg_rewrite_rel_rulename_index, 2693, on pg_rewrite using btree(ev_class oid_ops, rulename name_ops));
+#define RewriteRelRulenameIndexId  2693
+
+DECLARE_UNIQUE_INDEX(pg_sequence_seqrelid_index, 5002, on pg_sequence using btree(seqrelid oid_ops));
+#define SequenceRelidIndexId	5002
+
+DECLARE_INDEX(pg_shdepend_depender_index, 1232, on pg_shdepend using btree(dbid oid_ops, classid oid_ops, objid oid_ops, objsubid int4_ops));
+#define SharedDependDependerIndexId		1232
+DECLARE_INDEX(pg_shdepend_reference_index, 1233, on pg_shdepend using btree(refclassid oid_ops, refobjid oid_ops));
+#define SharedDependReferenceIndexId	1233
+
+DECLARE_UNIQUE_INDEX(pg_statistic_relid_att_inh_index, 2696, on pg_statistic using btree(starelid oid_ops, staattnum int2_ops, stainherit bool_ops));
+#define StatisticRelidAttnumInhIndexId	2696
+
+DECLARE_UNIQUE_INDEX(pg_statistic_ext_oid_index, 3380, on pg_statistic_ext using btree(oid oid_ops));
+#define StatisticExtOidIndexId	3380
+DECLARE_UNIQUE_INDEX(pg_statistic_ext_name_index, 3997, on pg_statistic_ext using btree(stxname name_ops, stxnamespace oid_ops));
+#define StatisticExtNameIndexId 3997
+DECLARE_INDEX(pg_statistic_ext_relid_index, 3379, on pg_statistic_ext using btree(stxrelid oid_ops));
+#define StatisticExtRelidIndexId 3379
+
+DECLARE_UNIQUE_INDEX(pg_statistic_ext_data_stxoid_index, 3433, on pg_statistic_ext_data using btree(stxoid oid_ops));
+#define StatisticExtDataStxoidIndexId 3433
+
+DECLARE_UNIQUE_INDEX(pg_tablespace_oid_index, 2697, on pg_tablespace using btree(oid oid_ops));
+#define TablespaceOidIndexId  2697
+DECLARE_UNIQUE_INDEX(pg_tablespace_spcname_index, 2698, on pg_tablespace using btree(spcname name_ops));
+#define TablespaceNameIndexId  2698
+
+DECLARE_UNIQUE_INDEX(pg_transform_oid_index, 3574, on pg_transform using btree(oid oid_ops));
+#define TransformOidIndexId 3574
+DECLARE_UNIQUE_INDEX(pg_transform_type_lang_index, 3575, on pg_transform using btree(trftype oid_ops, trflang oid_ops));
+#define TransformTypeLangIndexId  3575
+
+DECLARE_INDEX(pg_trigger_tgconstraint_index, 2699, on pg_trigger using btree(tgconstraint oid_ops));
+#define TriggerConstraintIndexId  2699
+DECLARE_UNIQUE_INDEX(pg_trigger_tgrelid_tgname_index, 2701, on pg_trigger using btree(tgrelid oid_ops, tgname name_ops));
+#define TriggerRelidNameIndexId  2701
+DECLARE_UNIQUE_INDEX(pg_trigger_oid_index, 2702, on pg_trigger using btree(oid oid_ops));
+#define TriggerOidIndexId  2702
+
+DECLARE_UNIQUE_INDEX(pg_event_trigger_evtname_index, 3467, on pg_event_trigger using btree(evtname name_ops));
+#define EventTriggerNameIndexId  3467
+DECLARE_UNIQUE_INDEX(pg_event_trigger_oid_index, 3468, on pg_event_trigger using btree(oid oid_ops));
+#define EventTriggerOidIndexId	3468
+
+DECLARE_UNIQUE_INDEX(pg_ts_config_cfgname_index, 3608, on pg_ts_config using btree(cfgname name_ops, cfgnamespace oid_ops));
+#define TSConfigNameNspIndexId	3608
+DECLARE_UNIQUE_INDEX(pg_ts_config_oid_index, 3712, on pg_ts_config using btree(oid oid_ops));
+#define TSConfigOidIndexId	3712
+
+DECLARE_UNIQUE_INDEX(pg_ts_config_map_index, 3609, on pg_ts_config_map using btree(mapcfg oid_ops, maptokentype int4_ops, mapseqno int4_ops));
+#define TSConfigMapIndexId	3609
+
+DECLARE_UNIQUE_INDEX(pg_ts_dict_dictname_index, 3604, on pg_ts_dict using btree(dictname name_ops, dictnamespace oid_ops));
+#define TSDictionaryNameNspIndexId	3604
+DECLARE_UNIQUE_INDEX(pg_ts_dict_oid_index, 3605, on pg_ts_dict using btree(oid oid_ops));
+#define TSDictionaryOidIndexId	3605
+
+DECLARE_UNIQUE_INDEX(pg_ts_parser_prsname_index, 3606, on pg_ts_parser using btree(prsname name_ops, prsnamespace oid_ops));
+#define TSParserNameNspIndexId	3606
+DECLARE_UNIQUE_INDEX(pg_ts_parser_oid_index, 3607, on pg_ts_parser using btree(oid oid_ops));
+#define TSParserOidIndexId	3607
+
+DECLARE_UNIQUE_INDEX(pg_ts_template_tmplname_index, 3766, on pg_ts_template using btree(tmplname name_ops, tmplnamespace oid_ops));
+#define TSTemplateNameNspIndexId	3766
+DECLARE_UNIQUE_INDEX(pg_ts_template_oid_index, 3767, on pg_ts_template using btree(oid oid_ops));
+#define TSTemplateOidIndexId	3767
+
+DECLARE_UNIQUE_INDEX(pg_type_oid_index, 2703, on pg_type using btree(oid oid_ops));
+#define TypeOidIndexId	2703
+DECLARE_UNIQUE_INDEX(pg_type_typname_nsp_index, 2704, on pg_type using btree(typname name_ops, typnamespace oid_ops));
+#define TypeNameNspIndexId	2704
+
+DECLARE_UNIQUE_INDEX(pg_foreign_data_wrapper_oid_index, 112, on pg_foreign_data_wrapper using btree(oid oid_ops));
+#define ForeignDataWrapperOidIndexId	112
+DECLARE_UNIQUE_INDEX(pg_foreign_data_wrapper_name_index, 548, on pg_foreign_data_wrapper using btree(fdwname name_ops));
+#define ForeignDataWrapperNameIndexId	548
+
+DECLARE_UNIQUE_INDEX(pg_foreign_server_oid_index, 113, on pg_foreign_server using btree(oid oid_ops));
+#define ForeignServerOidIndexId 113
+DECLARE_UNIQUE_INDEX(pg_foreign_server_name_index, 549, on pg_foreign_server using btree(srvname name_ops));
+#define ForeignServerNameIndexId	549
+
+DECLARE_UNIQUE_INDEX(pg_user_mapping_oid_index, 174, on pg_user_mapping using btree(oid oid_ops));
+#define UserMappingOidIndexId	174
+DECLARE_UNIQUE_INDEX(pg_user_mapping_user_server_index, 175, on pg_user_mapping using btree(umuser oid_ops, umserver oid_ops));
+#define UserMappingUserServerIndexId	175
+
+DECLARE_UNIQUE_INDEX(pg_foreign_table_relid_index, 3119, on pg_foreign_table using btree(ftrelid oid_ops));
+#define ForeignTableRelidIndexId 3119
+
+DECLARE_UNIQUE_INDEX(pg_default_acl_role_nsp_obj_index, 827, on pg_default_acl using btree(defaclrole oid_ops, defaclnamespace oid_ops, defaclobjtype char_ops));
+#define DefaultAclRoleNspObjIndexId 827
+DECLARE_UNIQUE_INDEX(pg_default_acl_oid_index, 828, on pg_default_acl using btree(oid oid_ops));
+#define DefaultAclOidIndexId	828
+
+DECLARE_UNIQUE_INDEX(pg_db_role_setting_databaseid_rol_index, 2965, on pg_db_role_setting using btree(setdatabase oid_ops, setrole oid_ops));
+#define DbRoleSettingDatidRolidIndexId	2965
+
+DECLARE_UNIQUE_INDEX(pg_seclabel_object_index, 3597, on pg_seclabel using btree(objoid oid_ops, classoid oid_ops, objsubid int4_ops, provider text_ops));
+#define SecLabelObjectIndexId				3597
+
+DECLARE_UNIQUE_INDEX(pg_shseclabel_object_index, 3593, on pg_shseclabel using btree(objoid oid_ops, classoid oid_ops, provider text_ops));
+#define SharedSecLabelObjectIndexId			3593
+
+DECLARE_UNIQUE_INDEX(pg_extension_oid_index, 3080, on pg_extension using btree(oid oid_ops));
+#define ExtensionOidIndexId 3080
+DECLARE_UNIQUE_INDEX(pg_extension_name_index, 3081, on pg_extension using btree(extname name_ops));
+#define ExtensionNameIndexId 3081
+
+DECLARE_UNIQUE_INDEX(pg_range_rngtypid_index, 3542, on pg_range using btree(rngtypid oid_ops));
+#define RangeTypidIndexId					3542
+
+DECLARE_UNIQUE_INDEX(pg_policy_oid_index, 3257, on pg_policy using btree(oid oid_ops));
+#define PolicyOidIndexId				3257
+
+DECLARE_UNIQUE_INDEX(pg_policy_polrelid_polname_index, 3258, on pg_policy using btree(polrelid oid_ops, polname name_ops));
+#define PolicyPolrelidPolnameIndexId				3258
+
+DECLARE_UNIQUE_INDEX(pg_replication_origin_roiident_index, 6001, on pg_replication_origin using btree(roident oid_ops));
+#define ReplicationOriginIdentIndex 6001
+
+DECLARE_UNIQUE_INDEX(pg_replication_origin_roname_index, 6002, on pg_replication_origin using btree(roname text_ops));
+#define ReplicationOriginNameIndex 6002
+
+DECLARE_UNIQUE_INDEX(pg_partitioned_table_partrelid_index, 3351, on pg_partitioned_table using btree(partrelid oid_ops));
+#define PartitionedRelidIndexId			 3351
+
+DECLARE_UNIQUE_INDEX(pg_publication_oid_index, 6110, on pg_publication using btree(oid oid_ops));
+#define PublicationObjectIndexId 6110
+
+DECLARE_UNIQUE_INDEX(pg_publication_pubname_index, 6111, on pg_publication using btree(pubname name_ops));
+#define PublicationNameIndexId 6111
+
+DECLARE_UNIQUE_INDEX(pg_publication_rel_oid_index, 6112, on pg_publication_rel using btree(oid oid_ops));
+#define PublicationRelObjectIndexId 6112
+
+DECLARE_UNIQUE_INDEX(pg_publication_rel_prrelid_prpubid_index, 6113, on pg_publication_rel using btree(prrelid oid_ops, prpubid oid_ops));
+#define PublicationRelPrrelidPrpubidIndexId 6113
+
+DECLARE_UNIQUE_INDEX(pg_subscription_oid_index, 6114, on pg_subscription using btree(oid oid_ops));
+#define SubscriptionObjectIndexId 6114
+
+DECLARE_UNIQUE_INDEX(pg_subscription_subname_index, 6115, on pg_subscription using btree(subdbid oid_ops, subname name_ops));
+#define SubscriptionNameIndexId 6115
+
+DECLARE_UNIQUE_INDEX(pg_subscription_rel_srrelid_srsubid_index, 6117, on pg_subscription_rel using btree(srrelid oid_ops, srsubid oid_ops));
+#define SubscriptionRelSrrelidSrsubidIndexId 6117
+
+#endif							/* INDEXING_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/namespace.h b/contrib/libs/postgresql/src/include/catalog/namespace.h
new file mode 100644
index 0000000000..2456c08bf7
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/namespace.h
@@ -0,0 +1,188 @@
+/*-------------------------------------------------------------------------
+ *
+ * namespace.h
+ *	  prototypes for functions in backend/catalog/namespace.c
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/namespace.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef NAMESPACE_H
+#define NAMESPACE_H
+
+#include "nodes/primnodes.h"
+#include "storage/lock.h"
+
+
+/*
+ *	This structure holds a list of possible functions or operators
+ *	found by namespace lookup.  Each function/operator is identified
+ *	by OID and by argument types; the list must be pruned by type
+ *	resolution rules that are embodied in the parser, not here.
+ *	See FuncnameGetCandidates's comments for more info.
+ */
+typedef struct _FuncCandidateList
+{
+	struct _FuncCandidateList *next;
+	int			pathpos;		/* for internal use of namespace lookup */
+	Oid			oid;			/* the function or operator's OID */
+	int			nargs;			/* number of arg types returned */
+	int			nvargs;			/* number of args to become variadic array */
+	int			ndargs;			/* number of defaulted args */
+	int		   *argnumbers;		/* args' positional indexes, if named call */
+	Oid			args[FLEXIBLE_ARRAY_MEMBER];	/* arg types */
+}		   *FuncCandidateList;
+
+/*
+ * Result of checkTempNamespaceStatus
+ */
+typedef enum TempNamespaceStatus
+{
+	TEMP_NAMESPACE_NOT_TEMP,	/* nonexistent, or non-temp namespace */
+	TEMP_NAMESPACE_IDLE,		/* exists, belongs to no active session */
+	TEMP_NAMESPACE_IN_USE		/* belongs to some active session */
+} TempNamespaceStatus;
+
+/*
+ *	Structure for xxxOverrideSearchPath functions
+ *
+ * The generation counter is private to namespace.c and shouldn't be touched
+ * by other code.  It can be initialized to zero if necessary (that means
+ * "not known equal to the current active path").
+ */
+typedef struct OverrideSearchPath
+{
+	List	   *schemas;		/* OIDs of explicitly named schemas */
+	bool		addCatalog;		/* implicitly prepend pg_catalog? */
+	bool		addTemp;		/* implicitly prepend temp schema? */
+	uint64		generation;		/* for quick detection of equality to active */
+} OverrideSearchPath;
+
+/*
+ * Option flag bits for RangeVarGetRelidExtended().
+ */
+typedef enum RVROption
+{
+	RVR_MISSING_OK = 1 << 0,	/* don't error if relation doesn't exist */
+	RVR_NOWAIT = 1 << 1,		/* error if relation cannot be locked */
+	RVR_SKIP_LOCKED = 1 << 2	/* skip if relation cannot be locked */
+} RVROption;
+
+typedef void (*RangeVarGetRelidCallback) (const RangeVar *relation, Oid relId,
+										  Oid oldRelId, void *callback_arg);
+
+#define RangeVarGetRelid(relation, lockmode, missing_ok) \
+	RangeVarGetRelidExtended(relation, lockmode, \
+							 (missing_ok) ? RVR_MISSING_OK : 0, NULL, NULL)
+
+extern Oid	RangeVarGetRelidExtended(const RangeVar *relation,
+									 LOCKMODE lockmode, uint32 flags,
+									 RangeVarGetRelidCallback callback,
+									 void *callback_arg);
+extern Oid	RangeVarGetCreationNamespace(const RangeVar *newRelation);
+extern Oid	RangeVarGetAndCheckCreationNamespace(RangeVar *newRelation,
+												 LOCKMODE lockmode,
+												 Oid *existing_relation_id);
+extern void RangeVarAdjustRelationPersistence(RangeVar *newRelation, Oid nspid);
+extern Oid	RelnameGetRelid(const char *relname);
+extern bool RelationIsVisible(Oid relid);
+
+extern Oid	TypenameGetTypid(const char *typname);
+extern Oid	TypenameGetTypidExtended(const char *typname, bool temp_ok);
+extern bool TypeIsVisible(Oid typid);
+
+extern FuncCandidateList FuncnameGetCandidates(List *names,
+											   int nargs, List *argnames,
+											   bool expand_variadic,
+											   bool expand_defaults,
+											   bool missing_ok);
+extern bool FunctionIsVisible(Oid funcid);
+
+extern Oid	OpernameGetOprid(List *names, Oid oprleft, Oid oprright);
+extern FuncCandidateList OpernameGetCandidates(List *names, char oprkind,
+											   bool missing_schema_ok);
+extern bool OperatorIsVisible(Oid oprid);
+
+extern Oid	OpclassnameGetOpcid(Oid amid, const char *opcname);
+extern bool OpclassIsVisible(Oid opcid);
+
+extern Oid	OpfamilynameGetOpfid(Oid amid, const char *opfname);
+extern bool OpfamilyIsVisible(Oid opfid);
+
+extern Oid	CollationGetCollid(const char *collname);
+extern bool CollationIsVisible(Oid collid);
+
+extern Oid	ConversionGetConid(const char *conname);
+extern bool ConversionIsVisible(Oid conid);
+
+extern Oid	get_statistics_object_oid(List *names, bool missing_ok);
+extern bool StatisticsObjIsVisible(Oid relid);
+
+extern Oid	get_ts_parser_oid(List *names, bool missing_ok);
+extern bool TSParserIsVisible(Oid prsId);
+
+extern Oid	get_ts_dict_oid(List *names, bool missing_ok);
+extern bool TSDictionaryIsVisible(Oid dictId);
+
+extern Oid	get_ts_template_oid(List *names, bool missing_ok);
+extern bool TSTemplateIsVisible(Oid tmplId);
+
+extern Oid	get_ts_config_oid(List *names, bool missing_ok);
+extern bool TSConfigIsVisible(Oid cfgid);
+
+extern void DeconstructQualifiedName(List *names,
+									 char **nspname_p,
+									 char **objname_p);
+extern Oid	LookupNamespaceNoError(const char *nspname);
+extern Oid	LookupExplicitNamespace(const char *nspname, bool missing_ok);
+extern Oid	get_namespace_oid(const char *nspname, bool missing_ok);
+
+extern Oid	LookupCreationNamespace(const char *nspname);
+extern void CheckSetNamespace(Oid oldNspOid, Oid nspOid);
+extern Oid	QualifiedNameGetCreationNamespace(List *names, char **objname_p);
+extern RangeVar *makeRangeVarFromNameList(List *names);
+extern char *NameListToString(List *names);
+extern char *NameListToQuotedString(List *names);
+
+extern bool isTempNamespace(Oid namespaceId);
+extern bool isTempToastNamespace(Oid namespaceId);
+extern bool isTempOrTempToastNamespace(Oid namespaceId);
+extern bool isAnyTempNamespace(Oid namespaceId);
+extern bool isOtherTempNamespace(Oid namespaceId);
+extern TempNamespaceStatus checkTempNamespaceStatus(Oid namespaceId);
+extern int	GetTempNamespaceBackendId(Oid namespaceId);
+extern Oid	GetTempToastNamespace(void);
+extern void GetTempNamespaceState(Oid *tempNamespaceId,
+								  Oid *tempToastNamespaceId);
+extern void SetTempNamespaceState(Oid tempNamespaceId,
+								  Oid tempToastNamespaceId);
+extern void ResetTempTableNamespace(void);
+
+extern OverrideSearchPath *GetOverrideSearchPath(MemoryContext context);
+extern OverrideSearchPath *CopyOverrideSearchPath(OverrideSearchPath *path);
+extern bool OverrideSearchPathMatchesCurrent(OverrideSearchPath *path);
+extern void PushOverrideSearchPath(OverrideSearchPath *newpath);
+extern void PopOverrideSearchPath(void);
+
+extern Oid	get_collation_oid(List *collname, bool missing_ok);
+extern Oid	get_conversion_oid(List *conname, bool missing_ok);
+extern Oid	FindDefaultConversionProc(int32 for_encoding, int32 to_encoding);
+
+
+/* initialization & transaction cleanup code */
+extern void InitializeSearchPath(void);
+extern void AtEOXact_Namespace(bool isCommit, bool parallel);
+extern void AtEOSubXact_Namespace(bool isCommit, SubTransactionId mySubid,
+								  SubTransactionId parentSubid);
+
+/* stuff for search_path GUC variable */
+extern char *namespace_search_path;
+
+extern List *fetch_search_path(bool includeImplicit);
+extern int	fetch_search_path_array(Oid *sarray, int sarray_len);
+
+#endif							/* NAMESPACE_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/objectaccess.h b/contrib/libs/postgresql/src/include/catalog/objectaccess.h
new file mode 100644
index 0000000000..fef383692f
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/objectaccess.h
@@ -0,0 +1,197 @@
+/*
+ * objectaccess.h
+ *
+ *		Object access hooks.
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ */
+
+#ifndef OBJECTACCESS_H
+#define OBJECTACCESS_H
+
+/*
+ * Object access hooks are intended to be called just before or just after
+ * performing certain actions on a SQL object.  This is intended as
+ * infrastructure for security or logging plugins.
+ *
+ * OAT_POST_CREATE should be invoked just after the object is created.
+ * Typically, this is done after inserting the primary catalog records and
+ * associated dependencies.
+ *
+ * OAT_DROP should be invoked just before deletion of objects; typically
+ * deleteOneObject(). Its arguments are packed within ObjectAccessDrop.
+ *
+ * OAT_POST_ALTER should be invoked just after the object is altered,
+ * but before the command counter is incremented.  An extension using the
+ * hook can use a current MVCC snapshot to get the old version of the tuple,
+ * and can use SnapshotSelf to get the new version of the tuple.
+ *
+ * OAT_NAMESPACE_SEARCH should be invoked prior to object name lookup under
+ * a particular namespace. This event is equivalent to usage permission
+ * on a schema under the default access control mechanism.
+ *
+ * OAT_FUNCTION_EXECUTE should be invoked prior to function execution.
+ * This event is almost equivalent to execute permission on functions,
+ * except for the case when execute permission is checked during object
+ * creation or altering, because OAT_POST_CREATE or OAT_POST_ALTER are
+ * sufficient for extensions to track these kind of checks.
+ *
+ * OAT_TRUNCATE should be invoked just before truncation of objects. This
+ * event is equivalent to truncate permission on a relation under the
+ * default access control mechanism.
+ *
+ * Other types may be added in the future.
+ */
+typedef enum ObjectAccessType
+{
+	OAT_POST_CREATE,
+	OAT_DROP,
+	OAT_POST_ALTER,
+	OAT_NAMESPACE_SEARCH,
+	OAT_FUNCTION_EXECUTE,
+	OAT_TRUNCATE
+} ObjectAccessType;
+
+/*
+ * Arguments of OAT_POST_CREATE event
+ */
+typedef struct
+{
+	/*
+	 * This flag informs extensions whether the context of this creation is
+	 * invoked by user's operations, or not. E.g, it shall be dealt as
+	 * internal stuff on toast tables or indexes due to type changes.
+	 */
+	bool		is_internal;
+} ObjectAccessPostCreate;
+
+/*
+ * Arguments of OAT_DROP event
+ */
+typedef struct
+{
+	/*
+	 * Flags to inform extensions the context of this deletion. Also see
+	 * PERFORM_DELETION_* in dependency.h
+	 */
+	int			dropflags;
+} ObjectAccessDrop;
+
+/*
+ * Arguments of OAT_POST_ALTER event
+ */
+typedef struct
+{
+	/*
+	 * This identifier is used when system catalog takes two IDs to identify a
+	 * particular tuple of the catalog. It is only used when the caller want
+	 * to identify an entry of pg_inherits, pg_db_role_setting or
+	 * pg_user_mapping. Elsewhere, InvalidOid should be set.
+	 */
+	Oid			auxiliary_id;
+
+	/*
+	 * If this flag is set, the user hasn't requested that the object be
+	 * altered, but we're doing it anyway for some internal reason.
+	 * Permissions-checking hooks may want to skip checks if, say, we're alter
+	 * the constraints of a temporary heap during CLUSTER.
+	 */
+	bool		is_internal;
+} ObjectAccessPostAlter;
+
+/*
+ * Arguments of OAT_NAMESPACE_SEARCH
+ */
+typedef struct
+{
+	/*
+	 * If true, hook should report an error when permission to search this
+	 * schema is denied.
+	 */
+	bool		ereport_on_violation;
+
+	/*
+	 * This is, in essence, an out parameter.  Core code should initialize
+	 * this to true, and any extension that wants to deny access should reset
+	 * it to false.  But an extension should be careful never to store a true
+	 * value here, so that in case there are multiple extensions access is
+	 * only allowed if all extensions agree.
+	 */
+	bool		result;
+} ObjectAccessNamespaceSearch;
+
+/* Plugin provides a hook function matching this signature. */
+typedef void (*object_access_hook_type) (ObjectAccessType access,
+										 Oid classId,
+										 Oid objectId,
+										 int subId,
+										 void *arg);
+
+/* Plugin sets this variable to a suitable hook function. */
+extern PGDLLIMPORT object_access_hook_type object_access_hook;
+
+/* Core code uses these functions to call the hook (see macros below). */
+extern void RunObjectPostCreateHook(Oid classId, Oid objectId, int subId,
+									bool is_internal);
+extern void RunObjectDropHook(Oid classId, Oid objectId, int subId,
+							  int dropflags);
+extern void RunObjectTruncateHook(Oid objectId);
+extern void RunObjectPostAlterHook(Oid classId, Oid objectId, int subId,
+								   Oid auxiliaryId, bool is_internal);
+extern bool RunNamespaceSearchHook(Oid objectId, bool ereport_on_violation);
+extern void RunFunctionExecuteHook(Oid objectId);
+
+/*
+ * The following macros are wrappers around the functions above; these should
+ * normally be used to invoke the hook in lieu of calling the above functions
+ * directly.
+ */
+
+#define InvokeObjectPostCreateHook(classId,objectId,subId)			\
+	InvokeObjectPostCreateHookArg((classId),(objectId),(subId),false)
+#define InvokeObjectPostCreateHookArg(classId,objectId,subId,is_internal) \
+	do {															\
+		if (object_access_hook)										\
+			RunObjectPostCreateHook((classId),(objectId),(subId),	\
+									(is_internal));					\
+	} while(0)
+
+#define InvokeObjectDropHook(classId,objectId,subId)				\
+	InvokeObjectDropHookArg((classId),(objectId),(subId),0)
+#define InvokeObjectDropHookArg(classId,objectId,subId,dropflags)	\
+	do {															\
+		if (object_access_hook)										\
+			RunObjectDropHook((classId),(objectId),(subId),			\
+							  (dropflags));							\
+	} while(0)
+
+#define InvokeObjectTruncateHook(objectId)							\
+	do {															\
+		if (object_access_hook)										\
+			RunObjectTruncateHook(objectId);						\
+	} while(0)
+
+#define InvokeObjectPostAlterHook(classId,objectId,subId)			\
+	InvokeObjectPostAlterHookArg((classId),(objectId),(subId),		\
+								 InvalidOid,false)
+#define InvokeObjectPostAlterHookArg(classId,objectId,subId,		\
+									 auxiliaryId,is_internal)		\
+	do {															\
+		if (object_access_hook)										\
+			RunObjectPostAlterHook((classId),(objectId),(subId),	\
+								   (auxiliaryId),(is_internal));	\
+	} while(0)
+
+#define InvokeNamespaceSearchHook(objectId, ereport_on_violation)	\
+	(!object_access_hook											\
+	 ? true															\
+	 : RunNamespaceSearchHook((objectId), (ereport_on_violation)))
+
+#define InvokeFunctionExecuteHook(objectId)		\
+	do {										\
+		if (object_access_hook)					\
+			RunFunctionExecuteHook(objectId);	\
+	} while(0)
+
+#endif							/* OBJECTACCESS_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/objectaddress.h b/contrib/libs/postgresql/src/include/catalog/objectaddress.h
new file mode 100644
index 0000000000..7f15efd58a
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/objectaddress.h
@@ -0,0 +1,84 @@
+/*-------------------------------------------------------------------------
+ *
+ * objectaddress.h
+ *	  functions for working with object addresses
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/objectaddress.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef OBJECTADDRESS_H
+#define OBJECTADDRESS_H
+
+#include "access/htup.h"
+#include "nodes/parsenodes.h"
+#include "storage/lockdefs.h"
+#include "utils/relcache.h"
+
+/*
+ * An ObjectAddress represents a database object of any type.
+ */
+typedef struct ObjectAddress
+{
+	Oid			classId;		/* Class Id from pg_class */
+	Oid			objectId;		/* OID of the object */
+	int32		objectSubId;	/* Subitem within object (eg column), or 0 */
+} ObjectAddress;
+
+extern const ObjectAddress InvalidObjectAddress;
+
+#define ObjectAddressSubSet(addr, class_id, object_id, object_sub_id) \
+	do { \
+		(addr).classId = (class_id); \
+		(addr).objectId = (object_id); \
+		(addr).objectSubId = (object_sub_id); \
+	} while (0)
+
+#define ObjectAddressSet(addr, class_id, object_id) \
+	ObjectAddressSubSet(addr, class_id, object_id, 0)
+
+extern ObjectAddress get_object_address(ObjectType objtype, Node *object,
+										Relation *relp,
+										LOCKMODE lockmode, bool missing_ok);
+
+extern ObjectAddress get_object_address_rv(ObjectType objtype, RangeVar *rel,
+										   List *object, Relation *relp,
+										   LOCKMODE lockmode, bool missing_ok);
+
+extern void check_object_ownership(Oid roleid,
+								   ObjectType objtype, ObjectAddress address,
+								   Node *object, Relation relation);
+
+extern Oid	get_object_namespace(const ObjectAddress *address);
+
+extern bool is_objectclass_supported(Oid class_id);
+extern Oid	get_object_oid_index(Oid class_id);
+extern int	get_object_catcache_oid(Oid class_id);
+extern int	get_object_catcache_name(Oid class_id);
+extern AttrNumber get_object_attnum_oid(Oid class_id);
+extern AttrNumber get_object_attnum_name(Oid class_id);
+extern AttrNumber get_object_attnum_namespace(Oid class_id);
+extern AttrNumber get_object_attnum_owner(Oid class_id);
+extern AttrNumber get_object_attnum_acl(Oid class_id);
+extern ObjectType get_object_type(Oid class_id, Oid object_id);
+extern bool get_object_namensp_unique(Oid class_id);
+
+extern HeapTuple get_catalog_object_by_oid(Relation catalog,
+										   AttrNumber oidcol, Oid objectId);
+
+extern char *getObjectDescription(const ObjectAddress *object);
+extern char *getObjectDescriptionOids(Oid classid, Oid objid);
+
+extern int	read_objtype_from_string(const char *objtype);
+extern char *getObjectTypeDescription(const ObjectAddress *object);
+extern char *getObjectIdentity(const ObjectAddress *address);
+extern char *getObjectIdentityParts(const ObjectAddress *address,
+									List **objname, List **objargs);
+extern struct ArrayType *strlist_to_textarray(List *list);
+
+extern ObjectType get_relkind_objtype(char relkind);
+
+#endif							/* OBJECTADDRESS_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/opfam_internal.h b/contrib/libs/postgresql/src/include/catalog/opfam_internal.h
new file mode 100644
index 0000000000..d63bd9ffa3
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/opfam_internal.h
@@ -0,0 +1,28 @@
+/*-------------------------------------------------------------------------
+ *
+ * opfam_internal.h
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/opfam_internal.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef OPFAM_INTERNAL_H
+#define OPFAM_INTERNAL_H
+
+/*
+ * We use lists of this struct type to keep track of both operators and
+ * procedures while building or adding to an opfamily.
+ */
+typedef struct
+{
+	Oid			object;			/* operator or support proc's OID */
+	int			number;			/* strategy or support proc number */
+	Oid			lefttype;		/* lefttype */
+	Oid			righttype;		/* righttype */
+	Oid			sortfamily;		/* ordering operator's sort opfamily, or 0 */
+} OpFamilyMember;
+
+#endif							/* OPFAM_INTERNAL_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/partition.h b/contrib/libs/postgresql/src/include/catalog/partition.h
new file mode 100644
index 0000000000..27873aff6e
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/partition.h
@@ -0,0 +1,34 @@
+/*-------------------------------------------------------------------------
+ *
+ * partition.h
+ *		Header file for structures and utility functions related to
+ *		partitioning
+ *
+ * Copyright (c) 2007-2020, PostgreSQL Global Development Group
+ *
+ * src/include/catalog/partition.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PARTITION_H
+#define PARTITION_H
+
+#include "partitioning/partdefs.h"
+#include "utils/relcache.h"
+
+/* Seed for the extended hash function */
+#define HASH_PARTITION_SEED UINT64CONST(0x7A5B22367996DCFD)
+
+extern Oid	get_partition_parent(Oid relid);
+extern List *get_partition_ancestors(Oid relid);
+extern Oid	index_get_partition(Relation partition, Oid indexId);
+extern List *map_partition_varattnos(List *expr, int fromrel_varno,
+									 Relation to_rel, Relation from_rel);
+extern bool has_partition_attrs(Relation rel, Bitmapset *attnums,
+								bool *used_in_expr);
+
+extern Oid	get_default_partition_oid(Oid parentId);
+extern void update_default_partition_oid(Oid parentId, Oid defaultPartId);
+extern List *get_proposed_default_constraint(List *new_part_constraints);
+
+#endif							/* PARTITION_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_aggregate.dat b/contrib/libs/postgresql/src/include/catalog/pg_aggregate.dat
new file mode 100644
index 0000000000..ffabe275c0
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_aggregate.dat
@@ -0,0 +1,598 @@
+#----------------------------------------------------------------------
+#
+# pg_aggregate.dat
+#    Initial contents of the pg_aggregate system catalog.
+#
+# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+# Portions Copyright (c) 1994, Regents of the University of California
+#
+# src/include/catalog/pg_aggregate.dat
+#
+#----------------------------------------------------------------------
+
+[
+
+# avg
+{ aggfnoid => 'avg(int8)', aggtransfn => 'int8_avg_accum',
+  aggfinalfn => 'numeric_poly_avg', aggcombinefn => 'int8_avg_combine',
+  aggserialfn => 'int8_avg_serialize', aggdeserialfn => 'int8_avg_deserialize',
+  aggmtransfn => 'int8_avg_accum', aggminvtransfn => 'int8_avg_accum_inv',
+  aggmfinalfn => 'numeric_poly_avg', aggtranstype => 'internal',
+  aggtransspace => '48', aggmtranstype => 'internal', aggmtransspace => '48' },
+{ aggfnoid => 'avg(int4)', aggtransfn => 'int4_avg_accum',
+  aggfinalfn => 'int8_avg', aggcombinefn => 'int4_avg_combine',
+  aggmtransfn => 'int4_avg_accum', aggminvtransfn => 'int4_avg_accum_inv',
+  aggmfinalfn => 'int8_avg', aggtranstype => '_int8', aggmtranstype => '_int8',
+  agginitval => '{0,0}', aggminitval => '{0,0}' },
+{ aggfnoid => 'avg(int2)', aggtransfn => 'int2_avg_accum',
+  aggfinalfn => 'int8_avg', aggcombinefn => 'int4_avg_combine',
+  aggmtransfn => 'int2_avg_accum', aggminvtransfn => 'int2_avg_accum_inv',
+  aggmfinalfn => 'int8_avg', aggtranstype => '_int8', aggmtranstype => '_int8',
+  agginitval => '{0,0}', aggminitval => '{0,0}' },
+{ aggfnoid => 'avg(numeric)', aggtransfn => 'numeric_avg_accum',
+  aggfinalfn => 'numeric_avg', aggcombinefn => 'numeric_avg_combine',
+  aggserialfn => 'numeric_avg_serialize',
+  aggdeserialfn => 'numeric_avg_deserialize',
+  aggmtransfn => 'numeric_avg_accum', aggminvtransfn => 'numeric_accum_inv',
+  aggmfinalfn => 'numeric_avg', aggtranstype => 'internal',
+  aggtransspace => '128', aggmtranstype => 'internal',
+  aggmtransspace => '128' },
+{ aggfnoid => 'avg(float4)', aggtransfn => 'float4_accum',
+  aggfinalfn => 'float8_avg', aggcombinefn => 'float8_combine',
+  aggtranstype => '_float8', agginitval => '{0,0,0}' },
+{ aggfnoid => 'avg(float8)', aggtransfn => 'float8_accum',
+  aggfinalfn => 'float8_avg', aggcombinefn => 'float8_combine',
+  aggtranstype => '_float8', agginitval => '{0,0,0}' },
+{ aggfnoid => 'avg(interval)', aggtransfn => 'interval_accum',
+  aggfinalfn => 'interval_avg', aggcombinefn => 'interval_combine',
+  aggmtransfn => 'interval_accum', aggminvtransfn => 'interval_accum_inv',
+  aggmfinalfn => 'interval_avg', aggtranstype => '_interval',
+  aggmtranstype => '_interval', agginitval => '{0 second,0 second}',
+  aggminitval => '{0 second,0 second}' },
+
+# sum
+{ aggfnoid => 'sum(int8)', aggtransfn => 'int8_avg_accum',
+  aggfinalfn => 'numeric_poly_sum', aggcombinefn => 'int8_avg_combine',
+  aggserialfn => 'int8_avg_serialize', aggdeserialfn => 'int8_avg_deserialize',
+  aggmtransfn => 'int8_avg_accum', aggminvtransfn => 'int8_avg_accum_inv',
+  aggmfinalfn => 'numeric_poly_sum', aggtranstype => 'internal',
+  aggtransspace => '48', aggmtranstype => 'internal', aggmtransspace => '48' },
+{ aggfnoid => 'sum(int4)', aggtransfn => 'int4_sum', aggcombinefn => 'int8pl',
+  aggmtransfn => 'int4_avg_accum', aggminvtransfn => 'int4_avg_accum_inv',
+  aggmfinalfn => 'int2int4_sum', aggtranstype => 'int8',
+  aggmtranstype => '_int8', aggminitval => '{0,0}' },
+{ aggfnoid => 'sum(int2)', aggtransfn => 'int2_sum', aggcombinefn => 'int8pl',
+  aggmtransfn => 'int2_avg_accum', aggminvtransfn => 'int2_avg_accum_inv',
+  aggmfinalfn => 'int2int4_sum', aggtranstype => 'int8',
+  aggmtranstype => '_int8', aggminitval => '{0,0}' },
+{ aggfnoid => 'sum(float4)', aggtransfn => 'float4pl',
+  aggcombinefn => 'float4pl', aggtranstype => 'float4' },
+{ aggfnoid => 'sum(float8)', aggtransfn => 'float8pl',
+  aggcombinefn => 'float8pl', aggtranstype => 'float8' },
+{ aggfnoid => 'sum(money)', aggtransfn => 'cash_pl', aggcombinefn => 'cash_pl',
+  aggmtransfn => 'cash_pl', aggminvtransfn => 'cash_mi',
+  aggtranstype => 'money', aggmtranstype => 'money' },
+{ aggfnoid => 'sum(interval)', aggtransfn => 'interval_pl',
+  aggcombinefn => 'interval_pl', aggmtransfn => 'interval_pl',
+  aggminvtransfn => 'interval_mi', aggtranstype => 'interval',
+  aggmtranstype => 'interval' },
+{ aggfnoid => 'sum(numeric)', aggtransfn => 'numeric_avg_accum',
+  aggfinalfn => 'numeric_sum', aggcombinefn => 'numeric_avg_combine',
+  aggserialfn => 'numeric_avg_serialize',
+  aggdeserialfn => 'numeric_avg_deserialize',
+  aggmtransfn => 'numeric_avg_accum', aggminvtransfn => 'numeric_accum_inv',
+  aggmfinalfn => 'numeric_sum', aggtranstype => 'internal',
+  aggtransspace => '128', aggmtranstype => 'internal',
+  aggmtransspace => '128' },
+
+# max
+{ aggfnoid => 'max(int8)', aggtransfn => 'int8larger',
+  aggcombinefn => 'int8larger', aggsortop => '>(int8,int8)',
+  aggtranstype => 'int8' },
+{ aggfnoid => 'max(int4)', aggtransfn => 'int4larger',
+  aggcombinefn => 'int4larger', aggsortop => '>(int4,int4)',
+  aggtranstype => 'int4' },
+{ aggfnoid => 'max(int2)', aggtransfn => 'int2larger',
+  aggcombinefn => 'int2larger', aggsortop => '>(int2,int2)',
+  aggtranstype => 'int2' },
+{ aggfnoid => 'max(oid)', aggtransfn => 'oidlarger',
+  aggcombinefn => 'oidlarger', aggsortop => '>(oid,oid)',
+  aggtranstype => 'oid' },
+{ aggfnoid => 'max(float4)', aggtransfn => 'float4larger',
+  aggcombinefn => 'float4larger', aggsortop => '>(float4,float4)',
+  aggtranstype => 'float4' },
+{ aggfnoid => 'max(float8)', aggtransfn => 'float8larger',
+  aggcombinefn => 'float8larger', aggsortop => '>(float8,float8)',
+  aggtranstype => 'float8' },
+{ aggfnoid => 'max(date)', aggtransfn => 'date_larger',
+  aggcombinefn => 'date_larger', aggsortop => '>(date,date)',
+  aggtranstype => 'date' },
+{ aggfnoid => 'max(time)', aggtransfn => 'time_larger',
+  aggcombinefn => 'time_larger', aggsortop => '>(time,time)',
+  aggtranstype => 'time' },
+{ aggfnoid => 'max(timetz)', aggtransfn => 'timetz_larger',
+  aggcombinefn => 'timetz_larger', aggsortop => '>(timetz,timetz)',
+  aggtranstype => 'timetz' },
+{ aggfnoid => 'max(money)', aggtransfn => 'cashlarger',
+  aggcombinefn => 'cashlarger', aggsortop => '>(money,money)',
+  aggtranstype => 'money' },
+{ aggfnoid => 'max(timestamp)', aggtransfn => 'timestamp_larger',
+  aggcombinefn => 'timestamp_larger', aggsortop => '>(timestamp,timestamp)',
+  aggtranstype => 'timestamp' },
+{ aggfnoid => 'max(timestamptz)', aggtransfn => 'timestamptz_larger',
+  aggcombinefn => 'timestamptz_larger',
+  aggsortop => '>(timestamptz,timestamptz)', aggtranstype => 'timestamptz' },
+{ aggfnoid => 'max(interval)', aggtransfn => 'interval_larger',
+  aggcombinefn => 'interval_larger', aggsortop => '>(interval,interval)',
+  aggtranstype => 'interval' },
+{ aggfnoid => 'max(text)', aggtransfn => 'text_larger',
+  aggcombinefn => 'text_larger', aggsortop => '>(text,text)',
+  aggtranstype => 'text' },
+{ aggfnoid => 'max(numeric)', aggtransfn => 'numeric_larger',
+  aggcombinefn => 'numeric_larger', aggsortop => '>(numeric,numeric)',
+  aggtranstype => 'numeric' },
+{ aggfnoid => 'max(anyarray)', aggtransfn => 'array_larger',
+  aggcombinefn => 'array_larger', aggsortop => '>(anyarray,anyarray)',
+  aggtranstype => 'anyarray' },
+{ aggfnoid => 'max(bpchar)', aggtransfn => 'bpchar_larger',
+  aggcombinefn => 'bpchar_larger', aggsortop => '>(bpchar,bpchar)',
+  aggtranstype => 'bpchar' },
+{ aggfnoid => 'max(tid)', aggtransfn => 'tidlarger',
+  aggcombinefn => 'tidlarger', aggsortop => '>(tid,tid)',
+  aggtranstype => 'tid' },
+{ aggfnoid => 'max(anyenum)', aggtransfn => 'enum_larger',
+  aggcombinefn => 'enum_larger', aggsortop => '>(anyenum,anyenum)',
+  aggtranstype => 'anyenum' },
+{ aggfnoid => 'max(inet)', aggtransfn => 'network_larger',
+  aggcombinefn => 'network_larger', aggsortop => '>(inet,inet)',
+  aggtranstype => 'inet' },
+{ aggfnoid => 'max(pg_lsn)', aggtransfn => 'pg_lsn_larger',
+  aggcombinefn => 'pg_lsn_larger', aggsortop => '>(pg_lsn,pg_lsn)',
+  aggtranstype => 'pg_lsn' },
+
+# min
+{ aggfnoid => 'min(int8)', aggtransfn => 'int8smaller',
+  aggcombinefn => 'int8smaller', aggsortop => '<(int8,int8)',
+  aggtranstype => 'int8' },
+{ aggfnoid => 'min(int4)', aggtransfn => 'int4smaller',
+  aggcombinefn => 'int4smaller', aggsortop => '<(int4,int4)',
+  aggtranstype => 'int4' },
+{ aggfnoid => 'min(int2)', aggtransfn => 'int2smaller',
+  aggcombinefn => 'int2smaller', aggsortop => '<(int2,int2)',
+  aggtranstype => 'int2' },
+{ aggfnoid => 'min(oid)', aggtransfn => 'oidsmaller',
+  aggcombinefn => 'oidsmaller', aggsortop => '<(oid,oid)',
+  aggtranstype => 'oid' },
+{ aggfnoid => 'min(float4)', aggtransfn => 'float4smaller',
+  aggcombinefn => 'float4smaller', aggsortop => '<(float4,float4)',
+  aggtranstype => 'float4' },
+{ aggfnoid => 'min(float8)', aggtransfn => 'float8smaller',
+  aggcombinefn => 'float8smaller', aggsortop => '<(float8,float8)',
+  aggtranstype => 'float8' },
+{ aggfnoid => 'min(date)', aggtransfn => 'date_smaller',
+  aggcombinefn => 'date_smaller', aggsortop => '<(date,date)',
+  aggtranstype => 'date' },
+{ aggfnoid => 'min(time)', aggtransfn => 'time_smaller',
+  aggcombinefn => 'time_smaller', aggsortop => '<(time,time)',
+  aggtranstype => 'time' },
+{ aggfnoid => 'min(timetz)', aggtransfn => 'timetz_smaller',
+  aggcombinefn => 'timetz_smaller', aggsortop => '<(timetz,timetz)',
+  aggtranstype => 'timetz' },
+{ aggfnoid => 'min(money)', aggtransfn => 'cashsmaller',
+  aggcombinefn => 'cashsmaller', aggsortop => '<(money,money)',
+  aggtranstype => 'money' },
+{ aggfnoid => 'min(timestamp)', aggtransfn => 'timestamp_smaller',
+  aggcombinefn => 'timestamp_smaller', aggsortop => '<(timestamp,timestamp)',
+  aggtranstype => 'timestamp' },
+{ aggfnoid => 'min(timestamptz)', aggtransfn => 'timestamptz_smaller',
+  aggcombinefn => 'timestamptz_smaller',
+  aggsortop => '<(timestamptz,timestamptz)', aggtranstype => 'timestamptz' },
+{ aggfnoid => 'min(interval)', aggtransfn => 'interval_smaller',
+  aggcombinefn => 'interval_smaller', aggsortop => '<(interval,interval)',
+  aggtranstype => 'interval' },
+{ aggfnoid => 'min(text)', aggtransfn => 'text_smaller',
+  aggcombinefn => 'text_smaller', aggsortop => '<(text,text)',
+  aggtranstype => 'text' },
+{ aggfnoid => 'min(numeric)', aggtransfn => 'numeric_smaller',
+  aggcombinefn => 'numeric_smaller', aggsortop => '<(numeric,numeric)',
+  aggtranstype => 'numeric' },
+{ aggfnoid => 'min(anyarray)', aggtransfn => 'array_smaller',
+  aggcombinefn => 'array_smaller', aggsortop => '<(anyarray,anyarray)',
+  aggtranstype => 'anyarray' },
+{ aggfnoid => 'min(bpchar)', aggtransfn => 'bpchar_smaller',
+  aggcombinefn => 'bpchar_smaller', aggsortop => '<(bpchar,bpchar)',
+  aggtranstype => 'bpchar' },
+{ aggfnoid => 'min(tid)', aggtransfn => 'tidsmaller',
+  aggcombinefn => 'tidsmaller', aggsortop => '<(tid,tid)',
+  aggtranstype => 'tid' },
+{ aggfnoid => 'min(anyenum)', aggtransfn => 'enum_smaller',
+  aggcombinefn => 'enum_smaller', aggsortop => '<(anyenum,anyenum)',
+  aggtranstype => 'anyenum' },
+{ aggfnoid => 'min(inet)', aggtransfn => 'network_smaller',
+  aggcombinefn => 'network_smaller', aggsortop => '<(inet,inet)',
+  aggtranstype => 'inet' },
+{ aggfnoid => 'min(pg_lsn)', aggtransfn => 'pg_lsn_smaller',
+  aggcombinefn => 'pg_lsn_smaller', aggsortop => '<(pg_lsn,pg_lsn)',
+  aggtranstype => 'pg_lsn' },
+
+# count
+{ aggfnoid => 'count(any)', aggtransfn => 'int8inc_any',
+  aggcombinefn => 'int8pl', aggmtransfn => 'int8inc_any',
+  aggminvtransfn => 'int8dec_any', aggtranstype => 'int8',
+  aggmtranstype => 'int8', agginitval => '0', aggminitval => '0' },
+{ aggfnoid => 'count()', aggtransfn => 'int8inc', aggcombinefn => 'int8pl',
+  aggmtransfn => 'int8inc', aggminvtransfn => 'int8dec', aggtranstype => 'int8',
+  aggmtranstype => 'int8', agginitval => '0', aggminitval => '0' },
+
+# var_pop
+{ aggfnoid => 'var_pop(int8)', aggtransfn => 'int8_accum',
+  aggfinalfn => 'numeric_var_pop', aggcombinefn => 'numeric_combine',
+  aggserialfn => 'numeric_serialize', aggdeserialfn => 'numeric_deserialize',
+  aggmtransfn => 'int8_accum', aggminvtransfn => 'int8_accum_inv',
+  aggmfinalfn => 'numeric_var_pop', aggtranstype => 'internal',
+  aggtransspace => '128', aggmtranstype => 'internal',
+  aggmtransspace => '128' },
+{ aggfnoid => 'var_pop(int4)', aggtransfn => 'int4_accum',
+  aggfinalfn => 'numeric_poly_var_pop', aggcombinefn => 'numeric_poly_combine',
+  aggserialfn => 'numeric_poly_serialize',
+  aggdeserialfn => 'numeric_poly_deserialize', aggmtransfn => 'int4_accum',
+  aggminvtransfn => 'int4_accum_inv', aggmfinalfn => 'numeric_poly_var_pop',
+  aggtranstype => 'internal', aggtransspace => '48',
+  aggmtranstype => 'internal', aggmtransspace => '48' },
+{ aggfnoid => 'var_pop(int2)', aggtransfn => 'int2_accum',
+  aggfinalfn => 'numeric_poly_var_pop', aggcombinefn => 'numeric_poly_combine',
+  aggserialfn => 'numeric_poly_serialize',
+  aggdeserialfn => 'numeric_poly_deserialize', aggmtransfn => 'int2_accum',
+  aggminvtransfn => 'int2_accum_inv', aggmfinalfn => 'numeric_poly_var_pop',
+  aggtranstype => 'internal', aggtransspace => '48',
+  aggmtranstype => 'internal', aggmtransspace => '48' },
+{ aggfnoid => 'var_pop(float4)', aggtransfn => 'float4_accum',
+  aggfinalfn => 'float8_var_pop', aggcombinefn => 'float8_combine',
+  aggtranstype => '_float8', agginitval => '{0,0,0}' },
+{ aggfnoid => 'var_pop(float8)', aggtransfn => 'float8_accum',
+  aggfinalfn => 'float8_var_pop', aggcombinefn => 'float8_combine',
+  aggtranstype => '_float8', agginitval => '{0,0,0}' },
+{ aggfnoid => 'var_pop(numeric)', aggtransfn => 'numeric_accum',
+  aggfinalfn => 'numeric_var_pop', aggcombinefn => 'numeric_combine',
+  aggserialfn => 'numeric_serialize', aggdeserialfn => 'numeric_deserialize',
+  aggmtransfn => 'numeric_accum', aggminvtransfn => 'numeric_accum_inv',
+  aggmfinalfn => 'numeric_var_pop', aggtranstype => 'internal',
+  aggtransspace => '128', aggmtranstype => 'internal',
+  aggmtransspace => '128' },
+
+# var_samp
+{ aggfnoid => 'var_samp(int8)', aggtransfn => 'int8_accum',
+  aggfinalfn => 'numeric_var_samp', aggcombinefn => 'numeric_combine',
+  aggserialfn => 'numeric_serialize', aggdeserialfn => 'numeric_deserialize',
+  aggmtransfn => 'int8_accum', aggminvtransfn => 'int8_accum_inv',
+  aggmfinalfn => 'numeric_var_samp', aggtranstype => 'internal',
+  aggtransspace => '128', aggmtranstype => 'internal',
+  aggmtransspace => '128' },
+{ aggfnoid => 'var_samp(int4)', aggtransfn => 'int4_accum',
+  aggfinalfn => 'numeric_poly_var_samp', aggcombinefn => 'numeric_poly_combine',
+  aggserialfn => 'numeric_poly_serialize',
+  aggdeserialfn => 'numeric_poly_deserialize', aggmtransfn => 'int4_accum',
+  aggminvtransfn => 'int4_accum_inv', aggmfinalfn => 'numeric_poly_var_samp',
+  aggtranstype => 'internal', aggtransspace => '48',
+  aggmtranstype => 'internal', aggmtransspace => '48' },
+{ aggfnoid => 'var_samp(int2)', aggtransfn => 'int2_accum',
+  aggfinalfn => 'numeric_poly_var_samp', aggcombinefn => 'numeric_poly_combine',
+  aggserialfn => 'numeric_poly_serialize',
+  aggdeserialfn => 'numeric_poly_deserialize', aggmtransfn => 'int2_accum',
+  aggminvtransfn => 'int2_accum_inv', aggmfinalfn => 'numeric_poly_var_samp',
+  aggtranstype => 'internal', aggtransspace => '48',
+  aggmtranstype => 'internal', aggmtransspace => '48' },
+{ aggfnoid => 'var_samp(float4)', aggtransfn => 'float4_accum',
+  aggfinalfn => 'float8_var_samp', aggcombinefn => 'float8_combine',
+  aggtranstype => '_float8', agginitval => '{0,0,0}' },
+{ aggfnoid => 'var_samp(float8)', aggtransfn => 'float8_accum',
+  aggfinalfn => 'float8_var_samp', aggcombinefn => 'float8_combine',
+  aggtranstype => '_float8', agginitval => '{0,0,0}' },
+{ aggfnoid => 'var_samp(numeric)', aggtransfn => 'numeric_accum',
+  aggfinalfn => 'numeric_var_samp', aggcombinefn => 'numeric_combine',
+  aggserialfn => 'numeric_serialize', aggdeserialfn => 'numeric_deserialize',
+  aggmtransfn => 'numeric_accum', aggminvtransfn => 'numeric_accum_inv',
+  aggmfinalfn => 'numeric_var_samp', aggtranstype => 'internal',
+  aggtransspace => '128', aggmtranstype => 'internal',
+  aggmtransspace => '128' },
+
+# variance: historical Postgres syntax for var_samp
+{ aggfnoid => 'variance(int8)', aggtransfn => 'int8_accum',
+  aggfinalfn => 'numeric_var_samp', aggcombinefn => 'numeric_combine',
+  aggserialfn => 'numeric_serialize', aggdeserialfn => 'numeric_deserialize',
+  aggmtransfn => 'int8_accum', aggminvtransfn => 'int8_accum_inv',
+  aggmfinalfn => 'numeric_var_samp', aggtranstype => 'internal',
+  aggtransspace => '128', aggmtranstype => 'internal',
+  aggmtransspace => '128' },
+{ aggfnoid => 'variance(int4)', aggtransfn => 'int4_accum',
+  aggfinalfn => 'numeric_poly_var_samp', aggcombinefn => 'numeric_poly_combine',
+  aggserialfn => 'numeric_poly_serialize',
+  aggdeserialfn => 'numeric_poly_deserialize', aggmtransfn => 'int4_accum',
+  aggminvtransfn => 'int4_accum_inv', aggmfinalfn => 'numeric_poly_var_samp',
+  aggtranstype => 'internal', aggtransspace => '48',
+  aggmtranstype => 'internal', aggmtransspace => '48' },
+{ aggfnoid => 'variance(int2)', aggtransfn => 'int2_accum',
+  aggfinalfn => 'numeric_poly_var_samp', aggcombinefn => 'numeric_poly_combine',
+  aggserialfn => 'numeric_poly_serialize',
+  aggdeserialfn => 'numeric_poly_deserialize', aggmtransfn => 'int2_accum',
+  aggminvtransfn => 'int2_accum_inv', aggmfinalfn => 'numeric_poly_var_samp',
+  aggtranstype => 'internal', aggtransspace => '48',
+  aggmtranstype => 'internal', aggmtransspace => '48' },
+{ aggfnoid => 'variance(float4)', aggtransfn => 'float4_accum',
+  aggfinalfn => 'float8_var_samp', aggcombinefn => 'float8_combine',
+  aggtranstype => '_float8', agginitval => '{0,0,0}' },
+{ aggfnoid => 'variance(float8)', aggtransfn => 'float8_accum',
+  aggfinalfn => 'float8_var_samp', aggcombinefn => 'float8_combine',
+  aggtranstype => '_float8', agginitval => '{0,0,0}' },
+{ aggfnoid => 'variance(numeric)', aggtransfn => 'numeric_accum',
+  aggfinalfn => 'numeric_var_samp', aggcombinefn => 'numeric_combine',
+  aggserialfn => 'numeric_serialize', aggdeserialfn => 'numeric_deserialize',
+  aggmtransfn => 'numeric_accum', aggminvtransfn => 'numeric_accum_inv',
+  aggmfinalfn => 'numeric_var_samp', aggtranstype => 'internal',
+  aggtransspace => '128', aggmtranstype => 'internal',
+  aggmtransspace => '128' },
+
+# stddev_pop
+{ aggfnoid => 'stddev_pop(int8)', aggtransfn => 'int8_accum',
+  aggfinalfn => 'numeric_stddev_pop', aggcombinefn => 'numeric_combine',
+  aggserialfn => 'numeric_serialize', aggdeserialfn => 'numeric_deserialize',
+  aggmtransfn => 'int8_accum', aggminvtransfn => 'int8_accum_inv',
+  aggmfinalfn => 'numeric_stddev_pop', aggtranstype => 'internal',
+  aggtransspace => '128', aggmtranstype => 'internal',
+  aggmtransspace => '128' },
+{ aggfnoid => 'stddev_pop(int4)', aggtransfn => 'int4_accum',
+  aggfinalfn => 'numeric_poly_stddev_pop',
+  aggcombinefn => 'numeric_poly_combine',
+  aggserialfn => 'numeric_poly_serialize',
+  aggdeserialfn => 'numeric_poly_deserialize', aggmtransfn => 'int4_accum',
+  aggminvtransfn => 'int4_accum_inv', aggmfinalfn => 'numeric_poly_stddev_pop',
+  aggtranstype => 'internal', aggtransspace => '48',
+  aggmtranstype => 'internal', aggmtransspace => '48' },
+{ aggfnoid => 'stddev_pop(int2)', aggtransfn => 'int2_accum',
+  aggfinalfn => 'numeric_poly_stddev_pop',
+  aggcombinefn => 'numeric_poly_combine',
+  aggserialfn => 'numeric_poly_serialize',
+  aggdeserialfn => 'numeric_poly_deserialize', aggmtransfn => 'int2_accum',
+  aggminvtransfn => 'int2_accum_inv', aggmfinalfn => 'numeric_poly_stddev_pop',
+  aggtranstype => 'internal', aggtransspace => '48',
+  aggmtranstype => 'internal', aggmtransspace => '48' },
+{ aggfnoid => 'stddev_pop(float4)', aggtransfn => 'float4_accum',
+  aggfinalfn => 'float8_stddev_pop', aggcombinefn => 'float8_combine',
+  aggtranstype => '_float8', agginitval => '{0,0,0}' },
+{ aggfnoid => 'stddev_pop(float8)', aggtransfn => 'float8_accum',
+  aggfinalfn => 'float8_stddev_pop', aggcombinefn => 'float8_combine',
+  aggtranstype => '_float8', agginitval => '{0,0,0}' },
+{ aggfnoid => 'stddev_pop(numeric)', aggtransfn => 'numeric_accum',
+  aggfinalfn => 'numeric_stddev_pop', aggcombinefn => 'numeric_combine',
+  aggserialfn => 'numeric_serialize', aggdeserialfn => 'numeric_deserialize',
+  aggmtransfn => 'numeric_accum', aggminvtransfn => 'numeric_accum_inv',
+  aggmfinalfn => 'numeric_stddev_pop', aggtranstype => 'internal',
+  aggtransspace => '128', aggmtranstype => 'internal',
+  aggmtransspace => '128' },
+
+# stddev_samp
+{ aggfnoid => 'stddev_samp(int8)', aggtransfn => 'int8_accum',
+  aggfinalfn => 'numeric_stddev_samp', aggcombinefn => 'numeric_combine',
+  aggserialfn => 'numeric_serialize', aggdeserialfn => 'numeric_deserialize',
+  aggmtransfn => 'int8_accum', aggminvtransfn => 'int8_accum_inv',
+  aggmfinalfn => 'numeric_stddev_samp', aggtranstype => 'internal',
+  aggtransspace => '128', aggmtranstype => 'internal',
+  aggmtransspace => '128' },
+{ aggfnoid => 'stddev_samp(int4)', aggtransfn => 'int4_accum',
+  aggfinalfn => 'numeric_poly_stddev_samp',
+  aggcombinefn => 'numeric_poly_combine',
+  aggserialfn => 'numeric_poly_serialize',
+  aggdeserialfn => 'numeric_poly_deserialize', aggmtransfn => 'int4_accum',
+  aggminvtransfn => 'int4_accum_inv', aggmfinalfn => 'numeric_poly_stddev_samp',
+  aggtranstype => 'internal', aggtransspace => '48',
+  aggmtranstype => 'internal', aggmtransspace => '48' },
+{ aggfnoid => 'stddev_samp(int2)', aggtransfn => 'int2_accum',
+  aggfinalfn => 'numeric_poly_stddev_samp',
+  aggcombinefn => 'numeric_poly_combine',
+  aggserialfn => 'numeric_poly_serialize',
+  aggdeserialfn => 'numeric_poly_deserialize', aggmtransfn => 'int2_accum',
+  aggminvtransfn => 'int2_accum_inv', aggmfinalfn => 'numeric_poly_stddev_samp',
+  aggtranstype => 'internal', aggtransspace => '48',
+  aggmtranstype => 'internal', aggmtransspace => '48' },
+{ aggfnoid => 'stddev_samp(float4)', aggtransfn => 'float4_accum',
+  aggfinalfn => 'float8_stddev_samp', aggcombinefn => 'float8_combine',
+  aggtranstype => '_float8', agginitval => '{0,0,0}' },
+{ aggfnoid => 'stddev_samp(float8)', aggtransfn => 'float8_accum',
+  aggfinalfn => 'float8_stddev_samp', aggcombinefn => 'float8_combine',
+  aggtranstype => '_float8', agginitval => '{0,0,0}' },
+{ aggfnoid => 'stddev_samp(numeric)', aggtransfn => 'numeric_accum',
+  aggfinalfn => 'numeric_stddev_samp', aggcombinefn => 'numeric_combine',
+  aggserialfn => 'numeric_serialize', aggdeserialfn => 'numeric_deserialize',
+  aggmtransfn => 'numeric_accum', aggminvtransfn => 'numeric_accum_inv',
+  aggmfinalfn => 'numeric_stddev_samp', aggtranstype => 'internal',
+  aggtransspace => '128', aggmtranstype => 'internal',
+  aggmtransspace => '128' },
+
+# stddev: historical Postgres syntax for stddev_samp
+{ aggfnoid => 'stddev(int8)', aggtransfn => 'int8_accum',
+  aggfinalfn => 'numeric_stddev_samp', aggcombinefn => 'numeric_combine',
+  aggserialfn => 'numeric_serialize', aggdeserialfn => 'numeric_deserialize',
+  aggmtransfn => 'int8_accum', aggminvtransfn => 'int8_accum_inv',
+  aggmfinalfn => 'numeric_stddev_samp', aggtranstype => 'internal',
+  aggtransspace => '128', aggmtranstype => 'internal',
+  aggmtransspace => '128' },
+{ aggfnoid => 'stddev(int4)', aggtransfn => 'int4_accum',
+  aggfinalfn => 'numeric_poly_stddev_samp',
+  aggcombinefn => 'numeric_poly_combine',
+  aggserialfn => 'numeric_poly_serialize',
+  aggdeserialfn => 'numeric_poly_deserialize', aggmtransfn => 'int4_accum',
+  aggminvtransfn => 'int4_accum_inv', aggmfinalfn => 'numeric_poly_stddev_samp',
+  aggtranstype => 'internal', aggtransspace => '48',
+  aggmtranstype => 'internal', aggmtransspace => '48' },
+{ aggfnoid => 'stddev(int2)', aggtransfn => 'int2_accum',
+  aggfinalfn => 'numeric_poly_stddev_samp',
+  aggcombinefn => 'numeric_poly_combine',
+  aggserialfn => 'numeric_poly_serialize',
+  aggdeserialfn => 'numeric_poly_deserialize', aggmtransfn => 'int2_accum',
+  aggminvtransfn => 'int2_accum_inv', aggmfinalfn => 'numeric_poly_stddev_samp',
+  aggtranstype => 'internal', aggtransspace => '48',
+  aggmtranstype => 'internal', aggmtransspace => '48' },
+{ aggfnoid => 'stddev(float4)', aggtransfn => 'float4_accum',
+  aggfinalfn => 'float8_stddev_samp', aggcombinefn => 'float8_combine',
+  aggtranstype => '_float8', agginitval => '{0,0,0}' },
+{ aggfnoid => 'stddev(float8)', aggtransfn => 'float8_accum',
+  aggfinalfn => 'float8_stddev_samp', aggcombinefn => 'float8_combine',
+  aggtranstype => '_float8', agginitval => '{0,0,0}' },
+{ aggfnoid => 'stddev(numeric)', aggtransfn => 'numeric_accum',
+  aggfinalfn => 'numeric_stddev_samp', aggcombinefn => 'numeric_combine',
+  aggserialfn => 'numeric_serialize', aggdeserialfn => 'numeric_deserialize',
+  aggmtransfn => 'numeric_accum', aggminvtransfn => 'numeric_accum_inv',
+  aggmfinalfn => 'numeric_stddev_samp', aggtranstype => 'internal',
+  aggtransspace => '128', aggmtranstype => 'internal',
+  aggmtransspace => '128' },
+
+# SQL2003 binary regression aggregates
+{ aggfnoid => 'regr_count', aggtransfn => 'int8inc_float8_float8',
+  aggcombinefn => 'int8pl', aggtranstype => 'int8', agginitval => '0' },
+{ aggfnoid => 'regr_sxx', aggtransfn => 'float8_regr_accum',
+  aggfinalfn => 'float8_regr_sxx', aggcombinefn => 'float8_regr_combine',
+  aggtranstype => '_float8', agginitval => '{0,0,0,0,0,0}' },
+{ aggfnoid => 'regr_syy', aggtransfn => 'float8_regr_accum',
+  aggfinalfn => 'float8_regr_syy', aggcombinefn => 'float8_regr_combine',
+  aggtranstype => '_float8', agginitval => '{0,0,0,0,0,0}' },
+{ aggfnoid => 'regr_sxy', aggtransfn => 'float8_regr_accum',
+  aggfinalfn => 'float8_regr_sxy', aggcombinefn => 'float8_regr_combine',
+  aggtranstype => '_float8', agginitval => '{0,0,0,0,0,0}' },
+{ aggfnoid => 'regr_avgx', aggtransfn => 'float8_regr_accum',
+  aggfinalfn => 'float8_regr_avgx', aggcombinefn => 'float8_regr_combine',
+  aggtranstype => '_float8', agginitval => '{0,0,0,0,0,0}' },
+{ aggfnoid => 'regr_avgy', aggtransfn => 'float8_regr_accum',
+  aggfinalfn => 'float8_regr_avgy', aggcombinefn => 'float8_regr_combine',
+  aggtranstype => '_float8', agginitval => '{0,0,0,0,0,0}' },
+{ aggfnoid => 'regr_r2', aggtransfn => 'float8_regr_accum',
+  aggfinalfn => 'float8_regr_r2', aggcombinefn => 'float8_regr_combine',
+  aggtranstype => '_float8', agginitval => '{0,0,0,0,0,0}' },
+{ aggfnoid => 'regr_slope', aggtransfn => 'float8_regr_accum',
+  aggfinalfn => 'float8_regr_slope', aggcombinefn => 'float8_regr_combine',
+  aggtranstype => '_float8', agginitval => '{0,0,0,0,0,0}' },
+{ aggfnoid => 'regr_intercept', aggtransfn => 'float8_regr_accum',
+  aggfinalfn => 'float8_regr_intercept', aggcombinefn => 'float8_regr_combine',
+  aggtranstype => '_float8', agginitval => '{0,0,0,0,0,0}' },
+{ aggfnoid => 'covar_pop', aggtransfn => 'float8_regr_accum',
+  aggfinalfn => 'float8_covar_pop', aggcombinefn => 'float8_regr_combine',
+  aggtranstype => '_float8', agginitval => '{0,0,0,0,0,0}' },
+{ aggfnoid => 'covar_samp', aggtransfn => 'float8_regr_accum',
+  aggfinalfn => 'float8_covar_samp', aggcombinefn => 'float8_regr_combine',
+  aggtranstype => '_float8', agginitval => '{0,0,0,0,0,0}' },
+{ aggfnoid => 'corr', aggtransfn => 'float8_regr_accum',
+  aggfinalfn => 'float8_corr', aggcombinefn => 'float8_regr_combine',
+  aggtranstype => '_float8', agginitval => '{0,0,0,0,0,0}' },
+
+# boolean-and and boolean-or
+{ aggfnoid => 'bool_and', aggtransfn => 'booland_statefunc',
+  aggcombinefn => 'booland_statefunc', aggmtransfn => 'bool_accum',
+  aggminvtransfn => 'bool_accum_inv', aggmfinalfn => 'bool_alltrue',
+  aggsortop => '<(bool,bool)', aggtranstype => 'bool',
+  aggmtranstype => 'internal', aggmtransspace => '16' },
+{ aggfnoid => 'bool_or', aggtransfn => 'boolor_statefunc',
+  aggcombinefn => 'boolor_statefunc', aggmtransfn => 'bool_accum',
+  aggminvtransfn => 'bool_accum_inv', aggmfinalfn => 'bool_anytrue',
+  aggsortop => '>(bool,bool)', aggtranstype => 'bool',
+  aggmtranstype => 'internal', aggmtransspace => '16' },
+{ aggfnoid => 'every', aggtransfn => 'booland_statefunc',
+  aggcombinefn => 'booland_statefunc', aggmtransfn => 'bool_accum',
+  aggminvtransfn => 'bool_accum_inv', aggmfinalfn => 'bool_alltrue',
+  aggsortop => '<(bool,bool)', aggtranstype => 'bool',
+  aggmtranstype => 'internal', aggmtransspace => '16' },
+
+# bitwise integer
+{ aggfnoid => 'bit_and(int2)', aggtransfn => 'int2and',
+  aggcombinefn => 'int2and', aggtranstype => 'int2' },
+{ aggfnoid => 'bit_or(int2)', aggtransfn => 'int2or', aggcombinefn => 'int2or',
+  aggtranstype => 'int2' },
+{ aggfnoid => 'bit_and(int4)', aggtransfn => 'int4and',
+  aggcombinefn => 'int4and', aggtranstype => 'int4' },
+{ aggfnoid => 'bit_or(int4)', aggtransfn => 'int4or', aggcombinefn => 'int4or',
+  aggtranstype => 'int4' },
+{ aggfnoid => 'bit_and(int8)', aggtransfn => 'int8and',
+  aggcombinefn => 'int8and', aggtranstype => 'int8' },
+{ aggfnoid => 'bit_or(int8)', aggtransfn => 'int8or', aggcombinefn => 'int8or',
+  aggtranstype => 'int8' },
+{ aggfnoid => 'bit_and(bit)', aggtransfn => 'bitand', aggcombinefn => 'bitand',
+  aggtranstype => 'bit' },
+{ aggfnoid => 'bit_or(bit)', aggtransfn => 'bitor', aggcombinefn => 'bitor',
+  aggtranstype => 'bit' },
+
+# xml
+{ aggfnoid => 'xmlagg', aggtransfn => 'xmlconcat2', aggtranstype => 'xml' },
+
+# array
+{ aggfnoid => 'array_agg(anynonarray)', aggtransfn => 'array_agg_transfn',
+  aggfinalfn => 'array_agg_finalfn', aggfinalextra => 't',
+  aggtranstype => 'internal' },
+{ aggfnoid => 'array_agg(anyarray)', aggtransfn => 'array_agg_array_transfn',
+  aggfinalfn => 'array_agg_array_finalfn', aggfinalextra => 't',
+  aggtranstype => 'internal' },
+
+# text
+{ aggfnoid => 'string_agg(text,text)', aggtransfn => 'string_agg_transfn',
+  aggfinalfn => 'string_agg_finalfn', aggtranstype => 'internal' },
+
+# bytea
+{ aggfnoid => 'string_agg(bytea,bytea)',
+  aggtransfn => 'bytea_string_agg_transfn',
+  aggfinalfn => 'bytea_string_agg_finalfn', aggtranstype => 'internal' },
+
+# json
+{ aggfnoid => 'json_agg', aggtransfn => 'json_agg_transfn',
+  aggfinalfn => 'json_agg_finalfn', aggtranstype => 'internal' },
+{ aggfnoid => 'json_object_agg', aggtransfn => 'json_object_agg_transfn',
+  aggfinalfn => 'json_object_agg_finalfn', aggtranstype => 'internal' },
+
+# jsonb
+{ aggfnoid => 'jsonb_agg', aggtransfn => 'jsonb_agg_transfn',
+  aggfinalfn => 'jsonb_agg_finalfn', aggtranstype => 'internal' },
+{ aggfnoid => 'jsonb_object_agg', aggtransfn => 'jsonb_object_agg_transfn',
+  aggfinalfn => 'jsonb_object_agg_finalfn', aggtranstype => 'internal' },
+
+# ordered-set and hypothetical-set aggregates
+{ aggfnoid => 'percentile_disc(float8,anyelement)', aggkind => 'o',
+  aggnumdirectargs => '1', aggtransfn => 'ordered_set_transition',
+  aggfinalfn => 'percentile_disc_final', aggfinalextra => 't',
+  aggfinalmodify => 's', aggmfinalmodify => 's', aggtranstype => 'internal' },
+{ aggfnoid => 'percentile_cont(float8,float8)', aggkind => 'o',
+  aggnumdirectargs => '1', aggtransfn => 'ordered_set_transition',
+  aggfinalfn => 'percentile_cont_float8_final', aggfinalmodify => 's',
+  aggmfinalmodify => 's', aggtranstype => 'internal' },
+{ aggfnoid => 'percentile_cont(float8,interval)', aggkind => 'o',
+  aggnumdirectargs => '1', aggtransfn => 'ordered_set_transition',
+  aggfinalfn => 'percentile_cont_interval_final', aggfinalmodify => 's',
+  aggmfinalmodify => 's', aggtranstype => 'internal' },
+{ aggfnoid => 'percentile_disc(_float8,anyelement)', aggkind => 'o',
+  aggnumdirectargs => '1', aggtransfn => 'ordered_set_transition',
+  aggfinalfn => 'percentile_disc_multi_final', aggfinalextra => 't',
+  aggfinalmodify => 's', aggmfinalmodify => 's', aggtranstype => 'internal' },
+{ aggfnoid => 'percentile_cont(_float8,float8)', aggkind => 'o',
+  aggnumdirectargs => '1', aggtransfn => 'ordered_set_transition',
+  aggfinalfn => 'percentile_cont_float8_multi_final', aggfinalmodify => 's',
+  aggmfinalmodify => 's', aggtranstype => 'internal' },
+{ aggfnoid => 'percentile_cont(_float8,interval)', aggkind => 'o',
+  aggnumdirectargs => '1', aggtransfn => 'ordered_set_transition',
+  aggfinalfn => 'percentile_cont_interval_multi_final', aggfinalmodify => 's',
+  aggmfinalmodify => 's', aggtranstype => 'internal' },
+{ aggfnoid => 'mode', aggkind => 'o', aggtransfn => 'ordered_set_transition',
+  aggfinalfn => 'mode_final', aggfinalextra => 't', aggfinalmodify => 's',
+  aggmfinalmodify => 's', aggtranstype => 'internal' },
+{ aggfnoid => 'rank(any)', aggkind => 'h', aggnumdirectargs => '1',
+  aggtransfn => 'ordered_set_transition_multi', aggfinalfn => 'rank_final',
+  aggfinalextra => 't', aggfinalmodify => 'w', aggmfinalmodify => 'w',
+  aggtranstype => 'internal' },
+{ aggfnoid => 'percent_rank(any)', aggkind => 'h', aggnumdirectargs => '1',
+  aggtransfn => 'ordered_set_transition_multi',
+  aggfinalfn => 'percent_rank_final', aggfinalextra => 't',
+  aggfinalmodify => 'w', aggmfinalmodify => 'w', aggtranstype => 'internal' },
+{ aggfnoid => 'cume_dist(any)', aggkind => 'h', aggnumdirectargs => '1',
+  aggtransfn => 'ordered_set_transition_multi', aggfinalfn => 'cume_dist_final',
+  aggfinalextra => 't', aggfinalmodify => 'w', aggmfinalmodify => 'w',
+  aggtranstype => 'internal' },
+{ aggfnoid => 'dense_rank(any)', aggkind => 'h', aggnumdirectargs => '1',
+  aggtransfn => 'ordered_set_transition_multi',
+  aggfinalfn => 'dense_rank_final', aggfinalextra => 't', aggfinalmodify => 'w',
+  aggmfinalmodify => 'w', aggtranstype => 'internal' },
+
+]
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_aggregate.h b/contrib/libs/postgresql/src/include/catalog/pg_aggregate.h
new file mode 100644
index 0000000000..457ca18444
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_aggregate.h
@@ -0,0 +1,176 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_aggregate.h
+ *	  definition of the "aggregate" system catalog (pg_aggregate)
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_aggregate.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_AGGREGATE_H
+#define PG_AGGREGATE_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_aggregate_d.h"
+
+#include "catalog/objectaddress.h"
+#include "nodes/pg_list.h"
+
+/* ----------------------------------------------------------------
+ *		pg_aggregate definition.
+ *		cpp turns this into typedef struct FormData_pg_aggregate
+ * ----------------------------------------------------------------
+ */
+CATALOG(pg_aggregate,2600,AggregateRelationId)
+{
+	/* pg_proc OID of the aggregate itself */
+	regproc		aggfnoid BKI_LOOKUP(pg_proc);
+
+	/* aggregate kind, see AGGKIND_ categories below */
+	char		aggkind BKI_DEFAULT(n);
+
+	/* number of arguments that are "direct" arguments */
+	int16		aggnumdirectargs BKI_DEFAULT(0);
+
+	/* transition function */
+	regproc		aggtransfn BKI_LOOKUP(pg_proc);
+
+	/* final function (0 if none) */
+	regproc		aggfinalfn BKI_DEFAULT(-) BKI_LOOKUP(pg_proc);
+
+	/* combine function (0 if none) */
+	regproc		aggcombinefn BKI_DEFAULT(-) BKI_LOOKUP(pg_proc);
+
+	/* function to convert transtype to bytea (0 if none) */
+	regproc		aggserialfn BKI_DEFAULT(-) BKI_LOOKUP(pg_proc);
+
+	/* function to convert bytea to transtype (0 if none) */
+	regproc		aggdeserialfn BKI_DEFAULT(-) BKI_LOOKUP(pg_proc);
+
+	/* forward function for moving-aggregate mode (0 if none) */
+	regproc		aggmtransfn BKI_DEFAULT(-) BKI_LOOKUP(pg_proc);
+
+	/* inverse function for moving-aggregate mode (0 if none) */
+	regproc		aggminvtransfn BKI_DEFAULT(-) BKI_LOOKUP(pg_proc);
+
+	/* final function for moving-aggregate mode (0 if none) */
+	regproc		aggmfinalfn BKI_DEFAULT(-) BKI_LOOKUP(pg_proc);
+
+	/* true to pass extra dummy arguments to aggfinalfn */
+	bool		aggfinalextra BKI_DEFAULT(f);
+
+	/* true to pass extra dummy arguments to aggmfinalfn */
+	bool		aggmfinalextra BKI_DEFAULT(f);
+
+	/* tells whether aggfinalfn modifies transition state */
+	char		aggfinalmodify BKI_DEFAULT(r);
+
+	/* tells whether aggmfinalfn modifies transition state */
+	char		aggmfinalmodify BKI_DEFAULT(r);
+
+	/* associated sort operator (0 if none) */
+	Oid			aggsortop BKI_DEFAULT(0) BKI_LOOKUP(pg_operator);
+
+	/* type of aggregate's transition (state) data */
+	Oid			aggtranstype BKI_LOOKUP(pg_type);
+
+	/* estimated size of state data (0 for default estimate) */
+	int32		aggtransspace BKI_DEFAULT(0);
+
+	/* type of moving-aggregate state data (0 if none) */
+	Oid			aggmtranstype BKI_DEFAULT(0) BKI_LOOKUP(pg_type);
+
+	/* estimated size of moving-agg state (0 for default est) */
+	int32		aggmtransspace BKI_DEFAULT(0);
+
+#ifdef CATALOG_VARLEN			/* variable-length fields start here */
+
+	/* initial value for transition state (can be NULL) */
+	text		agginitval BKI_DEFAULT(_null_);
+
+	/* initial value for moving-agg state (can be NULL) */
+	text		aggminitval BKI_DEFAULT(_null_);
+#endif
+} FormData_pg_aggregate;
+
+/* ----------------
+ *		Form_pg_aggregate corresponds to a pointer to a tuple with
+ *		the format of pg_aggregate relation.
+ * ----------------
+ */
+typedef FormData_pg_aggregate *Form_pg_aggregate;
+
+#ifdef EXPOSE_TO_CLIENT_CODE
+
+/*
+ * Symbolic values for aggkind column.  We distinguish normal aggregates
+ * from ordered-set aggregates (which have two sets of arguments, namely
+ * direct and aggregated arguments) and from hypothetical-set aggregates
+ * (which are a subclass of ordered-set aggregates in which the last
+ * direct arguments have to match up in number and datatypes with the
+ * aggregated arguments).
+ */
+#define AGGKIND_NORMAL			'n'
+#define AGGKIND_ORDERED_SET		'o'
+#define AGGKIND_HYPOTHETICAL	'h'
+
+/* Use this macro to test for "ordered-set agg including hypothetical case" */
+#define AGGKIND_IS_ORDERED_SET(kind)  ((kind) != AGGKIND_NORMAL)
+
+/*
+ * Symbolic values for aggfinalmodify and aggmfinalmodify columns.
+ * Preferably, finalfns do not modify the transition state value at all,
+ * but in some cases that would cost too much performance.  We distinguish
+ * "pure read only" and "trashes it arbitrarily" cases, as well as the
+ * intermediate case where multiple finalfn calls are allowed but the
+ * transfn cannot be applied anymore after the first finalfn call.
+ */
+#define AGGMODIFY_READ_ONLY			'r'
+#define AGGMODIFY_SHAREABLE			's'
+#define AGGMODIFY_READ_WRITE		'w'
+
+#endif							/* EXPOSE_TO_CLIENT_CODE */
+
+
+extern ObjectAddress AggregateCreate(const char *aggName,
+									 Oid aggNamespace,
+									 bool replace,
+									 char aggKind,
+									 int numArgs,
+									 int numDirectArgs,
+									 oidvector *parameterTypes,
+									 Datum allParameterTypes,
+									 Datum parameterModes,
+									 Datum parameterNames,
+									 List *parameterDefaults,
+									 Oid variadicArgType,
+									 List *aggtransfnName,
+									 List *aggfinalfnName,
+									 List *aggcombinefnName,
+									 List *aggserialfnName,
+									 List *aggdeserialfnName,
+									 List *aggmtransfnName,
+									 List *aggminvtransfnName,
+									 List *aggmfinalfnName,
+									 bool finalfnExtraArgs,
+									 bool mfinalfnExtraArgs,
+									 char finalfnModify,
+									 char mfinalfnModify,
+									 List *aggsortopName,
+									 Oid aggTransType,
+									 int32 aggTransSpace,
+									 Oid aggmTransType,
+									 int32 aggmTransSpace,
+									 const char *agginitval,
+									 const char *aggminitval,
+									 char proparallel);
+
+#endif							/* PG_AGGREGATE_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_aggregate_d.h b/contrib/libs/postgresql/src/include/catalog/pg_aggregate_d.h
new file mode 100644
index 0000000000..0e5ce1127f
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_aggregate_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_aggregate_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_am.dat b/contrib/libs/postgresql/src/include/catalog/pg_am.dat
new file mode 100644
index 0000000000..0f051277a6
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_am.dat
@@ -0,0 +1,37 @@
+#----------------------------------------------------------------------
+#
+# pg_am.dat
+#    Initial contents of the pg_am system catalog.
+#
+# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+# Portions Copyright (c) 1994, Regents of the University of California
+#
+# src/include/catalog/pg_am.dat
+#
+#----------------------------------------------------------------------
+
+[
+
+{ oid => '2', oid_symbol => 'HEAP_TABLE_AM_OID',
+  descr => 'heap table access method',
+  amname => 'heap', amhandler => 'heap_tableam_handler', amtype => 't' },
+{ oid => '403', oid_symbol => 'BTREE_AM_OID',
+  descr => 'b-tree index access method',
+  amname => 'btree', amhandler => 'bthandler', amtype => 'i' },
+{ oid => '405', oid_symbol => 'HASH_AM_OID',
+  descr => 'hash index access method',
+  amname => 'hash', amhandler => 'hashhandler', amtype => 'i' },
+{ oid => '783', oid_symbol => 'GIST_AM_OID',
+  descr => 'GiST index access method',
+  amname => 'gist', amhandler => 'gisthandler', amtype => 'i' },
+{ oid => '2742', oid_symbol => 'GIN_AM_OID',
+  descr => 'GIN index access method',
+  amname => 'gin', amhandler => 'ginhandler', amtype => 'i' },
+{ oid => '4000', oid_symbol => 'SPGIST_AM_OID',
+  descr => 'SP-GiST index access method',
+  amname => 'spgist', amhandler => 'spghandler', amtype => 'i' },
+{ oid => '3580', oid_symbol => 'BRIN_AM_OID',
+  descr => 'block range index (BRIN) access method',
+  amname => 'brin', amhandler => 'brinhandler', amtype => 'i' },
+
+]
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_am.h b/contrib/libs/postgresql/src/include/catalog/pg_am.h
new file mode 100644
index 0000000000..63c03c4324
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_am.h
@@ -0,0 +1,60 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_am.h
+ *	  definition of the "access method" system catalog (pg_am)
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_am.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_AM_H
+#define PG_AM_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_am_d.h"
+
+/* ----------------
+ *		pg_am definition.  cpp turns this into
+ *		typedef struct FormData_pg_am
+ * ----------------
+ */
+CATALOG(pg_am,2601,AccessMethodRelationId)
+{
+	Oid			oid;			/* oid */
+
+	/* access method name */
+	NameData	amname;
+
+	/* handler function */
+	regproc		amhandler BKI_LOOKUP(pg_proc);
+
+	/* see AMTYPE_xxx constants below */
+	char		amtype;
+} FormData_pg_am;
+
+/* ----------------
+ *		Form_pg_am corresponds to a pointer to a tuple with
+ *		the format of pg_am relation.
+ * ----------------
+ */
+typedef FormData_pg_am *Form_pg_am;
+
+#ifdef EXPOSE_TO_CLIENT_CODE
+
+/*
+ * Allowed values for amtype
+ */
+#define AMTYPE_INDEX					'i' /* index access method */
+#define AMTYPE_TABLE					't' /* table access method */
+
+#endif							/* EXPOSE_TO_CLIENT_CODE */
+
+#endif							/* PG_AM_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_am_d.h b/contrib/libs/postgresql/src/include/catalog/pg_am_d.h
new file mode 100644
index 0000000000..607bfd8cee
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_am_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_am_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_amop.dat b/contrib/libs/postgresql/src/include/catalog/pg_amop.dat
new file mode 100644
index 0000000000..1dfb6fd373
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_amop.dat
@@ -0,0 +1,2463 @@
+#----------------------------------------------------------------------
+#
+# pg_amop.dat
+#    Initial contents of the pg_amop system catalog.
+#
+# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+# Portions Copyright (c) 1994, Regents of the University of California
+#
+# src/include/catalog/pg_amop.dat
+#
+#----------------------------------------------------------------------
+
+[
+
+# btree integer_ops
+
+# default operators int2
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int2',
+  amoprighttype => 'int2', amopstrategy => '1', amopopr => '<(int2,int2)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int2',
+  amoprighttype => 'int2', amopstrategy => '2', amopopr => '<=(int2,int2)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int2',
+  amoprighttype => 'int2', amopstrategy => '3', amopopr => '=(int2,int2)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int2',
+  amoprighttype => 'int2', amopstrategy => '4', amopopr => '>=(int2,int2)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int2',
+  amoprighttype => 'int2', amopstrategy => '5', amopopr => '>(int2,int2)',
+  amopmethod => 'btree' },
+
+# crosstype operators int24
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int2',
+  amoprighttype => 'int4', amopstrategy => '1', amopopr => '<(int2,int4)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int2',
+  amoprighttype => 'int4', amopstrategy => '2', amopopr => '<=(int2,int4)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int2',
+  amoprighttype => 'int4', amopstrategy => '3', amopopr => '=(int2,int4)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int2',
+  amoprighttype => 'int4', amopstrategy => '4', amopopr => '>=(int2,int4)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int2',
+  amoprighttype => 'int4', amopstrategy => '5', amopopr => '>(int2,int4)',
+  amopmethod => 'btree' },
+
+# crosstype operators int28
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int2',
+  amoprighttype => 'int8', amopstrategy => '1', amopopr => '<(int2,int8)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int2',
+  amoprighttype => 'int8', amopstrategy => '2', amopopr => '<=(int2,int8)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int2',
+  amoprighttype => 'int8', amopstrategy => '3', amopopr => '=(int2,int8)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int2',
+  amoprighttype => 'int8', amopstrategy => '4', amopopr => '>=(int2,int8)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int2',
+  amoprighttype => 'int8', amopstrategy => '5', amopopr => '>(int2,int8)',
+  amopmethod => 'btree' },
+
+# default operators int4
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int4',
+  amoprighttype => 'int4', amopstrategy => '1', amopopr => '<(int4,int4)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int4',
+  amoprighttype => 'int4', amopstrategy => '2', amopopr => '<=(int4,int4)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int4',
+  amoprighttype => 'int4', amopstrategy => '3', amopopr => '=(int4,int4)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int4',
+  amoprighttype => 'int4', amopstrategy => '4', amopopr => '>=(int4,int4)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int4',
+  amoprighttype => 'int4', amopstrategy => '5', amopopr => '>(int4,int4)',
+  amopmethod => 'btree' },
+
+# crosstype operators int42
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int4',
+  amoprighttype => 'int2', amopstrategy => '1', amopopr => '<(int4,int2)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int4',
+  amoprighttype => 'int2', amopstrategy => '2', amopopr => '<=(int4,int2)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int4',
+  amoprighttype => 'int2', amopstrategy => '3', amopopr => '=(int4,int2)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int4',
+  amoprighttype => 'int2', amopstrategy => '4', amopopr => '>=(int4,int2)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int4',
+  amoprighttype => 'int2', amopstrategy => '5', amopopr => '>(int4,int2)',
+  amopmethod => 'btree' },
+
+# crosstype operators int48
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int4',
+  amoprighttype => 'int8', amopstrategy => '1', amopopr => '<(int4,int8)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int4',
+  amoprighttype => 'int8', amopstrategy => '2', amopopr => '<=(int4,int8)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int4',
+  amoprighttype => 'int8', amopstrategy => '3', amopopr => '=(int4,int8)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int4',
+  amoprighttype => 'int8', amopstrategy => '4', amopopr => '>=(int4,int8)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int4',
+  amoprighttype => 'int8', amopstrategy => '5', amopopr => '>(int4,int8)',
+  amopmethod => 'btree' },
+
+# default operators int8
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int8',
+  amoprighttype => 'int8', amopstrategy => '1', amopopr => '<(int8,int8)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int8',
+  amoprighttype => 'int8', amopstrategy => '2', amopopr => '<=(int8,int8)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int8',
+  amoprighttype => 'int8', amopstrategy => '3', amopopr => '=(int8,int8)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int8',
+  amoprighttype => 'int8', amopstrategy => '4', amopopr => '>=(int8,int8)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int8',
+  amoprighttype => 'int8', amopstrategy => '5', amopopr => '>(int8,int8)',
+  amopmethod => 'btree' },
+
+# crosstype operators int82
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int8',
+  amoprighttype => 'int2', amopstrategy => '1', amopopr => '<(int8,int2)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int8',
+  amoprighttype => 'int2', amopstrategy => '2', amopopr => '<=(int8,int2)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int8',
+  amoprighttype => 'int2', amopstrategy => '3', amopopr => '=(int8,int2)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int8',
+  amoprighttype => 'int2', amopstrategy => '4', amopopr => '>=(int8,int2)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int8',
+  amoprighttype => 'int2', amopstrategy => '5', amopopr => '>(int8,int2)',
+  amopmethod => 'btree' },
+
+# crosstype operators int84
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int8',
+  amoprighttype => 'int4', amopstrategy => '1', amopopr => '<(int8,int4)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int8',
+  amoprighttype => 'int4', amopstrategy => '2', amopopr => '<=(int8,int4)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int8',
+  amoprighttype => 'int4', amopstrategy => '3', amopopr => '=(int8,int4)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int8',
+  amoprighttype => 'int4', amopstrategy => '4', amopopr => '>=(int8,int4)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/integer_ops', amoplefttype => 'int8',
+  amoprighttype => 'int4', amopstrategy => '5', amopopr => '>(int8,int4)',
+  amopmethod => 'btree' },
+
+# btree oid_ops
+
+{ amopfamily => 'btree/oid_ops', amoplefttype => 'oid', amoprighttype => 'oid',
+  amopstrategy => '1', amopopr => '<(oid,oid)', amopmethod => 'btree' },
+{ amopfamily => 'btree/oid_ops', amoplefttype => 'oid', amoprighttype => 'oid',
+  amopstrategy => '2', amopopr => '<=(oid,oid)', amopmethod => 'btree' },
+{ amopfamily => 'btree/oid_ops', amoplefttype => 'oid', amoprighttype => 'oid',
+  amopstrategy => '3', amopopr => '=(oid,oid)', amopmethod => 'btree' },
+{ amopfamily => 'btree/oid_ops', amoplefttype => 'oid', amoprighttype => 'oid',
+  amopstrategy => '4', amopopr => '>=(oid,oid)', amopmethod => 'btree' },
+{ amopfamily => 'btree/oid_ops', amoplefttype => 'oid', amoprighttype => 'oid',
+  amopstrategy => '5', amopopr => '>(oid,oid)', amopmethod => 'btree' },
+
+# btree xid8_ops
+
+{ amopfamily => 'btree/xid8_ops', amoplefttype => 'xid8',
+  amoprighttype => 'xid8', amopstrategy => '1', amopopr => '<(xid8,xid8)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/xid8_ops', amoplefttype => 'xid8',
+  amoprighttype => 'xid8', amopstrategy => '2', amopopr => '<=(xid8,xid8)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/xid8_ops', amoplefttype => 'xid8',
+  amoprighttype => 'xid8', amopstrategy => '3', amopopr => '=(xid8,xid8)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/xid8_ops', amoplefttype => 'xid8',
+  amoprighttype => 'xid8', amopstrategy => '4', amopopr => '>=(xid8,xid8)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/xid8_ops', amoplefttype => 'xid8',
+  amoprighttype => 'xid8', amopstrategy => '5', amopopr => '>(xid8,xid8)',
+  amopmethod => 'btree' },
+
+# btree tid_ops
+
+{ amopfamily => 'btree/tid_ops', amoplefttype => 'tid', amoprighttype => 'tid',
+  amopstrategy => '1', amopopr => '<(tid,tid)', amopmethod => 'btree' },
+{ amopfamily => 'btree/tid_ops', amoplefttype => 'tid', amoprighttype => 'tid',
+  amopstrategy => '2', amopopr => '<=(tid,tid)', amopmethod => 'btree' },
+{ amopfamily => 'btree/tid_ops', amoplefttype => 'tid', amoprighttype => 'tid',
+  amopstrategy => '3', amopopr => '=(tid,tid)', amopmethod => 'btree' },
+{ amopfamily => 'btree/tid_ops', amoplefttype => 'tid', amoprighttype => 'tid',
+  amopstrategy => '4', amopopr => '>=(tid,tid)', amopmethod => 'btree' },
+{ amopfamily => 'btree/tid_ops', amoplefttype => 'tid', amoprighttype => 'tid',
+  amopstrategy => '5', amopopr => '>(tid,tid)', amopmethod => 'btree' },
+
+# btree oidvector_ops
+
+{ amopfamily => 'btree/oidvector_ops', amoplefttype => 'oidvector',
+  amoprighttype => 'oidvector', amopstrategy => '1',
+  amopopr => '<(oidvector,oidvector)', amopmethod => 'btree' },
+{ amopfamily => 'btree/oidvector_ops', amoplefttype => 'oidvector',
+  amoprighttype => 'oidvector', amopstrategy => '2',
+  amopopr => '<=(oidvector,oidvector)', amopmethod => 'btree' },
+{ amopfamily => 'btree/oidvector_ops', amoplefttype => 'oidvector',
+  amoprighttype => 'oidvector', amopstrategy => '3',
+  amopopr => '=(oidvector,oidvector)', amopmethod => 'btree' },
+{ amopfamily => 'btree/oidvector_ops', amoplefttype => 'oidvector',
+  amoprighttype => 'oidvector', amopstrategy => '4',
+  amopopr => '>=(oidvector,oidvector)', amopmethod => 'btree' },
+{ amopfamily => 'btree/oidvector_ops', amoplefttype => 'oidvector',
+  amoprighttype => 'oidvector', amopstrategy => '5',
+  amopopr => '>(oidvector,oidvector)', amopmethod => 'btree' },
+
+# btree float_ops
+
+# default operators float4
+{ amopfamily => 'btree/float_ops', amoplefttype => 'float4',
+  amoprighttype => 'float4', amopstrategy => '1', amopopr => '<(float4,float4)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/float_ops', amoplefttype => 'float4',
+  amoprighttype => 'float4', amopstrategy => '2',
+  amopopr => '<=(float4,float4)', amopmethod => 'btree' },
+{ amopfamily => 'btree/float_ops', amoplefttype => 'float4',
+  amoprighttype => 'float4', amopstrategy => '3', amopopr => '=(float4,float4)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/float_ops', amoplefttype => 'float4',
+  amoprighttype => 'float4', amopstrategy => '4',
+  amopopr => '>=(float4,float4)', amopmethod => 'btree' },
+{ amopfamily => 'btree/float_ops', amoplefttype => 'float4',
+  amoprighttype => 'float4', amopstrategy => '5', amopopr => '>(float4,float4)',
+  amopmethod => 'btree' },
+
+# crosstype operators float48
+{ amopfamily => 'btree/float_ops', amoplefttype => 'float4',
+  amoprighttype => 'float8', amopstrategy => '1', amopopr => '<(float4,float8)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/float_ops', amoplefttype => 'float4',
+  amoprighttype => 'float8', amopstrategy => '2',
+  amopopr => '<=(float4,float8)', amopmethod => 'btree' },
+{ amopfamily => 'btree/float_ops', amoplefttype => 'float4',
+  amoprighttype => 'float8', amopstrategy => '3', amopopr => '=(float4,float8)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/float_ops', amoplefttype => 'float4',
+  amoprighttype => 'float8', amopstrategy => '4',
+  amopopr => '>=(float4,float8)', amopmethod => 'btree' },
+{ amopfamily => 'btree/float_ops', amoplefttype => 'float4',
+  amoprighttype => 'float8', amopstrategy => '5', amopopr => '>(float4,float8)',
+  amopmethod => 'btree' },
+
+# default operators float8
+{ amopfamily => 'btree/float_ops', amoplefttype => 'float8',
+  amoprighttype => 'float8', amopstrategy => '1', amopopr => '<(float8,float8)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/float_ops', amoplefttype => 'float8',
+  amoprighttype => 'float8', amopstrategy => '2',
+  amopopr => '<=(float8,float8)', amopmethod => 'btree' },
+{ amopfamily => 'btree/float_ops', amoplefttype => 'float8',
+  amoprighttype => 'float8', amopstrategy => '3', amopopr => '=(float8,float8)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/float_ops', amoplefttype => 'float8',
+  amoprighttype => 'float8', amopstrategy => '4',
+  amopopr => '>=(float8,float8)', amopmethod => 'btree' },
+{ amopfamily => 'btree/float_ops', amoplefttype => 'float8',
+  amoprighttype => 'float8', amopstrategy => '5', amopopr => '>(float8,float8)',
+  amopmethod => 'btree' },
+
+# crosstype operators float84
+{ amopfamily => 'btree/float_ops', amoplefttype => 'float8',
+  amoprighttype => 'float4', amopstrategy => '1', amopopr => '<(float8,float4)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/float_ops', amoplefttype => 'float8',
+  amoprighttype => 'float4', amopstrategy => '2',
+  amopopr => '<=(float8,float4)', amopmethod => 'btree' },
+{ amopfamily => 'btree/float_ops', amoplefttype => 'float8',
+  amoprighttype => 'float4', amopstrategy => '3', amopopr => '=(float8,float4)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/float_ops', amoplefttype => 'float8',
+  amoprighttype => 'float4', amopstrategy => '4',
+  amopopr => '>=(float8,float4)', amopmethod => 'btree' },
+{ amopfamily => 'btree/float_ops', amoplefttype => 'float8',
+  amoprighttype => 'float4', amopstrategy => '5', amopopr => '>(float8,float4)',
+  amopmethod => 'btree' },
+
+# btree char_ops
+
+{ amopfamily => 'btree/char_ops', amoplefttype => 'char',
+  amoprighttype => 'char', amopstrategy => '1', amopopr => '<(char,char)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/char_ops', amoplefttype => 'char',
+  amoprighttype => 'char', amopstrategy => '2', amopopr => '<=(char,char)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/char_ops', amoplefttype => 'char',
+  amoprighttype => 'char', amopstrategy => '3', amopopr => '=(char,char)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/char_ops', amoplefttype => 'char',
+  amoprighttype => 'char', amopstrategy => '4', amopopr => '>=(char,char)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/char_ops', amoplefttype => 'char',
+  amoprighttype => 'char', amopstrategy => '5', amopopr => '>(char,char)',
+  amopmethod => 'btree' },
+
+# btree text_ops
+
+{ amopfamily => 'btree/text_ops', amoplefttype => 'text',
+  amoprighttype => 'text', amopstrategy => '1', amopopr => '<(text,text)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/text_ops', amoplefttype => 'text',
+  amoprighttype => 'text', amopstrategy => '2', amopopr => '<=(text,text)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/text_ops', amoplefttype => 'text',
+  amoprighttype => 'text', amopstrategy => '3', amopopr => '=(text,text)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/text_ops', amoplefttype => 'text',
+  amoprighttype => 'text', amopstrategy => '4', amopopr => '>=(text,text)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/text_ops', amoplefttype => 'text',
+  amoprighttype => 'text', amopstrategy => '5', amopopr => '>(text,text)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/text_ops', amoplefttype => 'name',
+  amoprighttype => 'name', amopstrategy => '1', amopopr => '<(name,name)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/text_ops', amoplefttype => 'name',
+  amoprighttype => 'name', amopstrategy => '2', amopopr => '<=(name,name)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/text_ops', amoplefttype => 'name',
+  amoprighttype => 'name', amopstrategy => '3', amopopr => '=(name,name)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/text_ops', amoplefttype => 'name',
+  amoprighttype => 'name', amopstrategy => '4', amopopr => '>=(name,name)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/text_ops', amoplefttype => 'name',
+  amoprighttype => 'name', amopstrategy => '5', amopopr => '>(name,name)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/text_ops', amoplefttype => 'name',
+  amoprighttype => 'text', amopstrategy => '1', amopopr => '<(name,text)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/text_ops', amoplefttype => 'name',
+  amoprighttype => 'text', amopstrategy => '2', amopopr => '<=(name,text)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/text_ops', amoplefttype => 'name',
+  amoprighttype => 'text', amopstrategy => '3', amopopr => '=(name,text)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/text_ops', amoplefttype => 'name',
+  amoprighttype => 'text', amopstrategy => '4', amopopr => '>=(name,text)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/text_ops', amoplefttype => 'name',
+  amoprighttype => 'text', amopstrategy => '5', amopopr => '>(name,text)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/text_ops', amoplefttype => 'text',
+  amoprighttype => 'name', amopstrategy => '1', amopopr => '<(text,name)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/text_ops', amoplefttype => 'text',
+  amoprighttype => 'name', amopstrategy => '2', amopopr => '<=(text,name)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/text_ops', amoplefttype => 'text',
+  amoprighttype => 'name', amopstrategy => '3', amopopr => '=(text,name)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/text_ops', amoplefttype => 'text',
+  amoprighttype => 'name', amopstrategy => '4', amopopr => '>=(text,name)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/text_ops', amoplefttype => 'text',
+  amoprighttype => 'name', amopstrategy => '5', amopopr => '>(text,name)',
+  amopmethod => 'btree' },
+
+# btree bpchar_ops
+
+{ amopfamily => 'btree/bpchar_ops', amoplefttype => 'bpchar',
+  amoprighttype => 'bpchar', amopstrategy => '1', amopopr => '<(bpchar,bpchar)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/bpchar_ops', amoplefttype => 'bpchar',
+  amoprighttype => 'bpchar', amopstrategy => '2',
+  amopopr => '<=(bpchar,bpchar)', amopmethod => 'btree' },
+{ amopfamily => 'btree/bpchar_ops', amoplefttype => 'bpchar',
+  amoprighttype => 'bpchar', amopstrategy => '3', amopopr => '=(bpchar,bpchar)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/bpchar_ops', amoplefttype => 'bpchar',
+  amoprighttype => 'bpchar', amopstrategy => '4',
+  amopopr => '>=(bpchar,bpchar)', amopmethod => 'btree' },
+{ amopfamily => 'btree/bpchar_ops', amoplefttype => 'bpchar',
+  amoprighttype => 'bpchar', amopstrategy => '5', amopopr => '>(bpchar,bpchar)',
+  amopmethod => 'btree' },
+
+# btree bytea_ops
+
+{ amopfamily => 'btree/bytea_ops', amoplefttype => 'bytea',
+  amoprighttype => 'bytea', amopstrategy => '1', amopopr => '<(bytea,bytea)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/bytea_ops', amoplefttype => 'bytea',
+  amoprighttype => 'bytea', amopstrategy => '2', amopopr => '<=(bytea,bytea)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/bytea_ops', amoplefttype => 'bytea',
+  amoprighttype => 'bytea', amopstrategy => '3', amopopr => '=(bytea,bytea)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/bytea_ops', amoplefttype => 'bytea',
+  amoprighttype => 'bytea', amopstrategy => '4', amopopr => '>=(bytea,bytea)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/bytea_ops', amoplefttype => 'bytea',
+  amoprighttype => 'bytea', amopstrategy => '5', amopopr => '>(bytea,bytea)',
+  amopmethod => 'btree' },
+
+# btree datetime_ops
+
+# default operators date
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'date',
+  amoprighttype => 'date', amopstrategy => '1', amopopr => '<(date,date)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'date',
+  amoprighttype => 'date', amopstrategy => '2', amopopr => '<=(date,date)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'date',
+  amoprighttype => 'date', amopstrategy => '3', amopopr => '=(date,date)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'date',
+  amoprighttype => 'date', amopstrategy => '4', amopopr => '>=(date,date)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'date',
+  amoprighttype => 'date', amopstrategy => '5', amopopr => '>(date,date)',
+  amopmethod => 'btree' },
+
+# crosstype operators vs timestamp
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'date',
+  amoprighttype => 'timestamp', amopstrategy => '1',
+  amopopr => '<(date,timestamp)', amopmethod => 'btree' },
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'date',
+  amoprighttype => 'timestamp', amopstrategy => '2',
+  amopopr => '<=(date,timestamp)', amopmethod => 'btree' },
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'date',
+  amoprighttype => 'timestamp', amopstrategy => '3',
+  amopopr => '=(date,timestamp)', amopmethod => 'btree' },
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'date',
+  amoprighttype => 'timestamp', amopstrategy => '4',
+  amopopr => '>=(date,timestamp)', amopmethod => 'btree' },
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'date',
+  amoprighttype => 'timestamp', amopstrategy => '5',
+  amopopr => '>(date,timestamp)', amopmethod => 'btree' },
+
+# crosstype operators vs timestamptz
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'date',
+  amoprighttype => 'timestamptz', amopstrategy => '1',
+  amopopr => '<(date,timestamptz)', amopmethod => 'btree' },
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'date',
+  amoprighttype => 'timestamptz', amopstrategy => '2',
+  amopopr => '<=(date,timestamptz)', amopmethod => 'btree' },
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'date',
+  amoprighttype => 'timestamptz', amopstrategy => '3',
+  amopopr => '=(date,timestamptz)', amopmethod => 'btree' },
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'date',
+  amoprighttype => 'timestamptz', amopstrategy => '4',
+  amopopr => '>=(date,timestamptz)', amopmethod => 'btree' },
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'date',
+  amoprighttype => 'timestamptz', amopstrategy => '5',
+  amopopr => '>(date,timestamptz)', amopmethod => 'btree' },
+
+# default operators timestamp
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamp',
+  amoprighttype => 'timestamp', amopstrategy => '1',
+  amopopr => '<(timestamp,timestamp)', amopmethod => 'btree' },
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamp',
+  amoprighttype => 'timestamp', amopstrategy => '2',
+  amopopr => '<=(timestamp,timestamp)', amopmethod => 'btree' },
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamp',
+  amoprighttype => 'timestamp', amopstrategy => '3',
+  amopopr => '=(timestamp,timestamp)', amopmethod => 'btree' },
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamp',
+  amoprighttype => 'timestamp', amopstrategy => '4',
+  amopopr => '>=(timestamp,timestamp)', amopmethod => 'btree' },
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamp',
+  amoprighttype => 'timestamp', amopstrategy => '5',
+  amopopr => '>(timestamp,timestamp)', amopmethod => 'btree' },
+
+# crosstype operators vs date
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamp',
+  amoprighttype => 'date', amopstrategy => '1', amopopr => '<(timestamp,date)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamp',
+  amoprighttype => 'date', amopstrategy => '2', amopopr => '<=(timestamp,date)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamp',
+  amoprighttype => 'date', amopstrategy => '3', amopopr => '=(timestamp,date)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamp',
+  amoprighttype => 'date', amopstrategy => '4', amopopr => '>=(timestamp,date)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamp',
+  amoprighttype => 'date', amopstrategy => '5', amopopr => '>(timestamp,date)',
+  amopmethod => 'btree' },
+
+# crosstype operators vs timestamptz
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamp',
+  amoprighttype => 'timestamptz', amopstrategy => '1',
+  amopopr => '<(timestamp,timestamptz)', amopmethod => 'btree' },
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamp',
+  amoprighttype => 'timestamptz', amopstrategy => '2',
+  amopopr => '<=(timestamp,timestamptz)', amopmethod => 'btree' },
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamp',
+  amoprighttype => 'timestamptz', amopstrategy => '3',
+  amopopr => '=(timestamp,timestamptz)', amopmethod => 'btree' },
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamp',
+  amoprighttype => 'timestamptz', amopstrategy => '4',
+  amopopr => '>=(timestamp,timestamptz)', amopmethod => 'btree' },
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamp',
+  amoprighttype => 'timestamptz', amopstrategy => '5',
+  amopopr => '>(timestamp,timestamptz)', amopmethod => 'btree' },
+
+# default operators timestamptz
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamptz',
+  amoprighttype => 'timestamptz', amopstrategy => '1',
+  amopopr => '<(timestamptz,timestamptz)', amopmethod => 'btree' },
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamptz',
+  amoprighttype => 'timestamptz', amopstrategy => '2',
+  amopopr => '<=(timestamptz,timestamptz)', amopmethod => 'btree' },
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamptz',
+  amoprighttype => 'timestamptz', amopstrategy => '3',
+  amopopr => '=(timestamptz,timestamptz)', amopmethod => 'btree' },
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamptz',
+  amoprighttype => 'timestamptz', amopstrategy => '4',
+  amopopr => '>=(timestamptz,timestamptz)', amopmethod => 'btree' },
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamptz',
+  amoprighttype => 'timestamptz', amopstrategy => '5',
+  amopopr => '>(timestamptz,timestamptz)', amopmethod => 'btree' },
+
+# crosstype operators vs date
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamptz',
+  amoprighttype => 'date', amopstrategy => '1',
+  amopopr => '<(timestamptz,date)', amopmethod => 'btree' },
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamptz',
+  amoprighttype => 'date', amopstrategy => '2',
+  amopopr => '<=(timestamptz,date)', amopmethod => 'btree' },
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamptz',
+  amoprighttype => 'date', amopstrategy => '3',
+  amopopr => '=(timestamptz,date)', amopmethod => 'btree' },
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamptz',
+  amoprighttype => 'date', amopstrategy => '4',
+  amopopr => '>=(timestamptz,date)', amopmethod => 'btree' },
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamptz',
+  amoprighttype => 'date', amopstrategy => '5',
+  amopopr => '>(timestamptz,date)', amopmethod => 'btree' },
+
+# crosstype operators vs timestamp
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamptz',
+  amoprighttype => 'timestamp', amopstrategy => '1',
+  amopopr => '<(timestamptz,timestamp)', amopmethod => 'btree' },
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamptz',
+  amoprighttype => 'timestamp', amopstrategy => '2',
+  amopopr => '<=(timestamptz,timestamp)', amopmethod => 'btree' },
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamptz',
+  amoprighttype => 'timestamp', amopstrategy => '3',
+  amopopr => '=(timestamptz,timestamp)', amopmethod => 'btree' },
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamptz',
+  amoprighttype => 'timestamp', amopstrategy => '4',
+  amopopr => '>=(timestamptz,timestamp)', amopmethod => 'btree' },
+{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamptz',
+  amoprighttype => 'timestamp', amopstrategy => '5',
+  amopopr => '>(timestamptz,timestamp)', amopmethod => 'btree' },
+
+# btree time_ops
+
+{ amopfamily => 'btree/time_ops', amoplefttype => 'time',
+  amoprighttype => 'time', amopstrategy => '1', amopopr => '<(time,time)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/time_ops', amoplefttype => 'time',
+  amoprighttype => 'time', amopstrategy => '2', amopopr => '<=(time,time)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/time_ops', amoplefttype => 'time',
+  amoprighttype => 'time', amopstrategy => '3', amopopr => '=(time,time)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/time_ops', amoplefttype => 'time',
+  amoprighttype => 'time', amopstrategy => '4', amopopr => '>=(time,time)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/time_ops', amoplefttype => 'time',
+  amoprighttype => 'time', amopstrategy => '5', amopopr => '>(time,time)',
+  amopmethod => 'btree' },
+
+# btree timetz_ops
+
+{ amopfamily => 'btree/timetz_ops', amoplefttype => 'timetz',
+  amoprighttype => 'timetz', amopstrategy => '1', amopopr => '<(timetz,timetz)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/timetz_ops', amoplefttype => 'timetz',
+  amoprighttype => 'timetz', amopstrategy => '2',
+  amopopr => '<=(timetz,timetz)', amopmethod => 'btree' },
+{ amopfamily => 'btree/timetz_ops', amoplefttype => 'timetz',
+  amoprighttype => 'timetz', amopstrategy => '3', amopopr => '=(timetz,timetz)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/timetz_ops', amoplefttype => 'timetz',
+  amoprighttype => 'timetz', amopstrategy => '4',
+  amopopr => '>=(timetz,timetz)', amopmethod => 'btree' },
+{ amopfamily => 'btree/timetz_ops', amoplefttype => 'timetz',
+  amoprighttype => 'timetz', amopstrategy => '5', amopopr => '>(timetz,timetz)',
+  amopmethod => 'btree' },
+
+# btree interval_ops
+
+{ amopfamily => 'btree/interval_ops', amoplefttype => 'interval',
+  amoprighttype => 'interval', amopstrategy => '1',
+  amopopr => '<(interval,interval)', amopmethod => 'btree' },
+{ amopfamily => 'btree/interval_ops', amoplefttype => 'interval',
+  amoprighttype => 'interval', amopstrategy => '2',
+  amopopr => '<=(interval,interval)', amopmethod => 'btree' },
+{ amopfamily => 'btree/interval_ops', amoplefttype => 'interval',
+  amoprighttype => 'interval', amopstrategy => '3',
+  amopopr => '=(interval,interval)', amopmethod => 'btree' },
+{ amopfamily => 'btree/interval_ops', amoplefttype => 'interval',
+  amoprighttype => 'interval', amopstrategy => '4',
+  amopopr => '>=(interval,interval)', amopmethod => 'btree' },
+{ amopfamily => 'btree/interval_ops', amoplefttype => 'interval',
+  amoprighttype => 'interval', amopstrategy => '5',
+  amopopr => '>(interval,interval)', amopmethod => 'btree' },
+
+# btree macaddr
+
+{ amopfamily => 'btree/macaddr_ops', amoplefttype => 'macaddr',
+  amoprighttype => 'macaddr', amopstrategy => '1',
+  amopopr => '<(macaddr,macaddr)', amopmethod => 'btree' },
+{ amopfamily => 'btree/macaddr_ops', amoplefttype => 'macaddr',
+  amoprighttype => 'macaddr', amopstrategy => '2',
+  amopopr => '<=(macaddr,macaddr)', amopmethod => 'btree' },
+{ amopfamily => 'btree/macaddr_ops', amoplefttype => 'macaddr',
+  amoprighttype => 'macaddr', amopstrategy => '3',
+  amopopr => '=(macaddr,macaddr)', amopmethod => 'btree' },
+{ amopfamily => 'btree/macaddr_ops', amoplefttype => 'macaddr',
+  amoprighttype => 'macaddr', amopstrategy => '4',
+  amopopr => '>=(macaddr,macaddr)', amopmethod => 'btree' },
+{ amopfamily => 'btree/macaddr_ops', amoplefttype => 'macaddr',
+  amoprighttype => 'macaddr', amopstrategy => '5',
+  amopopr => '>(macaddr,macaddr)', amopmethod => 'btree' },
+
+# btree macaddr8
+
+{ amopfamily => 'btree/macaddr8_ops', amoplefttype => 'macaddr8',
+  amoprighttype => 'macaddr8', amopstrategy => '1',
+  amopopr => '<(macaddr8,macaddr8)', amopmethod => 'btree' },
+{ amopfamily => 'btree/macaddr8_ops', amoplefttype => 'macaddr8',
+  amoprighttype => 'macaddr8', amopstrategy => '2',
+  amopopr => '<=(macaddr8,macaddr8)', amopmethod => 'btree' },
+{ amopfamily => 'btree/macaddr8_ops', amoplefttype => 'macaddr8',
+  amoprighttype => 'macaddr8', amopstrategy => '3',
+  amopopr => '=(macaddr8,macaddr8)', amopmethod => 'btree' },
+{ amopfamily => 'btree/macaddr8_ops', amoplefttype => 'macaddr8',
+  amoprighttype => 'macaddr8', amopstrategy => '4',
+  amopopr => '>=(macaddr8,macaddr8)', amopmethod => 'btree' },
+{ amopfamily => 'btree/macaddr8_ops', amoplefttype => 'macaddr8',
+  amoprighttype => 'macaddr8', amopstrategy => '5',
+  amopopr => '>(macaddr8,macaddr8)', amopmethod => 'btree' },
+
+# btree network
+
+{ amopfamily => 'btree/network_ops', amoplefttype => 'inet',
+  amoprighttype => 'inet', amopstrategy => '1', amopopr => '<(inet,inet)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/network_ops', amoplefttype => 'inet',
+  amoprighttype => 'inet', amopstrategy => '2', amopopr => '<=(inet,inet)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/network_ops', amoplefttype => 'inet',
+  amoprighttype => 'inet', amopstrategy => '3', amopopr => '=(inet,inet)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/network_ops', amoplefttype => 'inet',
+  amoprighttype => 'inet', amopstrategy => '4', amopopr => '>=(inet,inet)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/network_ops', amoplefttype => 'inet',
+  amoprighttype => 'inet', amopstrategy => '5', amopopr => '>(inet,inet)',
+  amopmethod => 'btree' },
+
+# btree numeric
+
+{ amopfamily => 'btree/numeric_ops', amoplefttype => 'numeric',
+  amoprighttype => 'numeric', amopstrategy => '1',
+  amopopr => '<(numeric,numeric)', amopmethod => 'btree' },
+{ amopfamily => 'btree/numeric_ops', amoplefttype => 'numeric',
+  amoprighttype => 'numeric', amopstrategy => '2',
+  amopopr => '<=(numeric,numeric)', amopmethod => 'btree' },
+{ amopfamily => 'btree/numeric_ops', amoplefttype => 'numeric',
+  amoprighttype => 'numeric', amopstrategy => '3',
+  amopopr => '=(numeric,numeric)', amopmethod => 'btree' },
+{ amopfamily => 'btree/numeric_ops', amoplefttype => 'numeric',
+  amoprighttype => 'numeric', amopstrategy => '4',
+  amopopr => '>=(numeric,numeric)', amopmethod => 'btree' },
+{ amopfamily => 'btree/numeric_ops', amoplefttype => 'numeric',
+  amoprighttype => 'numeric', amopstrategy => '5',
+  amopopr => '>(numeric,numeric)', amopmethod => 'btree' },
+
+# btree bool
+
+{ amopfamily => 'btree/bool_ops', amoplefttype => 'bool',
+  amoprighttype => 'bool', amopstrategy => '1', amopopr => '<(bool,bool)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/bool_ops', amoplefttype => 'bool',
+  amoprighttype => 'bool', amopstrategy => '2', amopopr => '<=(bool,bool)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/bool_ops', amoplefttype => 'bool',
+  amoprighttype => 'bool', amopstrategy => '3', amopopr => '=(bool,bool)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/bool_ops', amoplefttype => 'bool',
+  amoprighttype => 'bool', amopstrategy => '4', amopopr => '>=(bool,bool)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/bool_ops', amoplefttype => 'bool',
+  amoprighttype => 'bool', amopstrategy => '5', amopopr => '>(bool,bool)',
+  amopmethod => 'btree' },
+
+# btree bit
+
+{ amopfamily => 'btree/bit_ops', amoplefttype => 'bit', amoprighttype => 'bit',
+  amopstrategy => '1', amopopr => '<(bit,bit)', amopmethod => 'btree' },
+{ amopfamily => 'btree/bit_ops', amoplefttype => 'bit', amoprighttype => 'bit',
+  amopstrategy => '2', amopopr => '<=(bit,bit)', amopmethod => 'btree' },
+{ amopfamily => 'btree/bit_ops', amoplefttype => 'bit', amoprighttype => 'bit',
+  amopstrategy => '3', amopopr => '=(bit,bit)', amopmethod => 'btree' },
+{ amopfamily => 'btree/bit_ops', amoplefttype => 'bit', amoprighttype => 'bit',
+  amopstrategy => '4', amopopr => '>=(bit,bit)', amopmethod => 'btree' },
+{ amopfamily => 'btree/bit_ops', amoplefttype => 'bit', amoprighttype => 'bit',
+  amopstrategy => '5', amopopr => '>(bit,bit)', amopmethod => 'btree' },
+
+# btree varbit
+
+{ amopfamily => 'btree/varbit_ops', amoplefttype => 'varbit',
+  amoprighttype => 'varbit', amopstrategy => '1', amopopr => '<(varbit,varbit)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/varbit_ops', amoplefttype => 'varbit',
+  amoprighttype => 'varbit', amopstrategy => '2',
+  amopopr => '<=(varbit,varbit)', amopmethod => 'btree' },
+{ amopfamily => 'btree/varbit_ops', amoplefttype => 'varbit',
+  amoprighttype => 'varbit', amopstrategy => '3', amopopr => '=(varbit,varbit)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/varbit_ops', amoplefttype => 'varbit',
+  amoprighttype => 'varbit', amopstrategy => '4',
+  amopopr => '>=(varbit,varbit)', amopmethod => 'btree' },
+{ amopfamily => 'btree/varbit_ops', amoplefttype => 'varbit',
+  amoprighttype => 'varbit', amopstrategy => '5', amopopr => '>(varbit,varbit)',
+  amopmethod => 'btree' },
+
+# btree text pattern
+
+{ amopfamily => 'btree/text_pattern_ops', amoplefttype => 'text',
+  amoprighttype => 'text', amopstrategy => '1', amopopr => '~<~(text,text)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/text_pattern_ops', amoplefttype => 'text',
+  amoprighttype => 'text', amopstrategy => '2', amopopr => '~<=~(text,text)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/text_pattern_ops', amoplefttype => 'text',
+  amoprighttype => 'text', amopstrategy => '3', amopopr => '=(text,text)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/text_pattern_ops', amoplefttype => 'text',
+  amoprighttype => 'text', amopstrategy => '4', amopopr => '~>=~(text,text)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/text_pattern_ops', amoplefttype => 'text',
+  amoprighttype => 'text', amopstrategy => '5', amopopr => '~>~(text,text)',
+  amopmethod => 'btree' },
+
+# btree bpchar pattern
+
+{ amopfamily => 'btree/bpchar_pattern_ops', amoplefttype => 'bpchar',
+  amoprighttype => 'bpchar', amopstrategy => '1',
+  amopopr => '~<~(bpchar,bpchar)', amopmethod => 'btree' },
+{ amopfamily => 'btree/bpchar_pattern_ops', amoplefttype => 'bpchar',
+  amoprighttype => 'bpchar', amopstrategy => '2',
+  amopopr => '~<=~(bpchar,bpchar)', amopmethod => 'btree' },
+{ amopfamily => 'btree/bpchar_pattern_ops', amoplefttype => 'bpchar',
+  amoprighttype => 'bpchar', amopstrategy => '3', amopopr => '=(bpchar,bpchar)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/bpchar_pattern_ops', amoplefttype => 'bpchar',
+  amoprighttype => 'bpchar', amopstrategy => '4',
+  amopopr => '~>=~(bpchar,bpchar)', amopmethod => 'btree' },
+{ amopfamily => 'btree/bpchar_pattern_ops', amoplefttype => 'bpchar',
+  amoprighttype => 'bpchar', amopstrategy => '5',
+  amopopr => '~>~(bpchar,bpchar)', amopmethod => 'btree' },
+
+# btree money_ops
+
+{ amopfamily => 'btree/money_ops', amoplefttype => 'money',
+  amoprighttype => 'money', amopstrategy => '1', amopopr => '<(money,money)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/money_ops', amoplefttype => 'money',
+  amoprighttype => 'money', amopstrategy => '2', amopopr => '<=(money,money)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/money_ops', amoplefttype => 'money',
+  amoprighttype => 'money', amopstrategy => '3', amopopr => '=(money,money)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/money_ops', amoplefttype => 'money',
+  amoprighttype => 'money', amopstrategy => '4', amopopr => '>=(money,money)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/money_ops', amoplefttype => 'money',
+  amoprighttype => 'money', amopstrategy => '5', amopopr => '>(money,money)',
+  amopmethod => 'btree' },
+
+# btree array_ops
+
+{ amopfamily => 'btree/array_ops', amoplefttype => 'anyarray',
+  amoprighttype => 'anyarray', amopstrategy => '1',
+  amopopr => '<(anyarray,anyarray)', amopmethod => 'btree' },
+{ amopfamily => 'btree/array_ops', amoplefttype => 'anyarray',
+  amoprighttype => 'anyarray', amopstrategy => '2',
+  amopopr => '<=(anyarray,anyarray)', amopmethod => 'btree' },
+{ amopfamily => 'btree/array_ops', amoplefttype => 'anyarray',
+  amoprighttype => 'anyarray', amopstrategy => '3',
+  amopopr => '=(anyarray,anyarray)', amopmethod => 'btree' },
+{ amopfamily => 'btree/array_ops', amoplefttype => 'anyarray',
+  amoprighttype => 'anyarray', amopstrategy => '4',
+  amopopr => '>=(anyarray,anyarray)', amopmethod => 'btree' },
+{ amopfamily => 'btree/array_ops', amoplefttype => 'anyarray',
+  amoprighttype => 'anyarray', amopstrategy => '5',
+  amopopr => '>(anyarray,anyarray)', amopmethod => 'btree' },
+
+# btree record_ops
+
+{ amopfamily => 'btree/record_ops', amoplefttype => 'record',
+  amoprighttype => 'record', amopstrategy => '1', amopopr => '<(record,record)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/record_ops', amoplefttype => 'record',
+  amoprighttype => 'record', amopstrategy => '2',
+  amopopr => '<=(record,record)', amopmethod => 'btree' },
+{ amopfamily => 'btree/record_ops', amoplefttype => 'record',
+  amoprighttype => 'record', amopstrategy => '3', amopopr => '=(record,record)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/record_ops', amoplefttype => 'record',
+  amoprighttype => 'record', amopstrategy => '4',
+  amopopr => '>=(record,record)', amopmethod => 'btree' },
+{ amopfamily => 'btree/record_ops', amoplefttype => 'record',
+  amoprighttype => 'record', amopstrategy => '5', amopopr => '>(record,record)',
+  amopmethod => 'btree' },
+
+# btree record_image_ops
+
+{ amopfamily => 'btree/record_image_ops', amoplefttype => 'record',
+  amoprighttype => 'record', amopstrategy => '1',
+  amopopr => '*<(record,record)', amopmethod => 'btree' },
+{ amopfamily => 'btree/record_image_ops', amoplefttype => 'record',
+  amoprighttype => 'record', amopstrategy => '2',
+  amopopr => '*<=(record,record)', amopmethod => 'btree' },
+{ amopfamily => 'btree/record_image_ops', amoplefttype => 'record',
+  amoprighttype => 'record', amopstrategy => '3',
+  amopopr => '*=(record,record)', amopmethod => 'btree' },
+{ amopfamily => 'btree/record_image_ops', amoplefttype => 'record',
+  amoprighttype => 'record', amopstrategy => '4',
+  amopopr => '*>=(record,record)', amopmethod => 'btree' },
+{ amopfamily => 'btree/record_image_ops', amoplefttype => 'record',
+  amoprighttype => 'record', amopstrategy => '5',
+  amopopr => '*>(record,record)', amopmethod => 'btree' },
+
+# btree uuid_ops
+
+{ amopfamily => 'btree/uuid_ops', amoplefttype => 'uuid',
+  amoprighttype => 'uuid', amopstrategy => '1', amopopr => '<(uuid,uuid)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/uuid_ops', amoplefttype => 'uuid',
+  amoprighttype => 'uuid', amopstrategy => '2', amopopr => '<=(uuid,uuid)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/uuid_ops', amoplefttype => 'uuid',
+  amoprighttype => 'uuid', amopstrategy => '3', amopopr => '=(uuid,uuid)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/uuid_ops', amoplefttype => 'uuid',
+  amoprighttype => 'uuid', amopstrategy => '4', amopopr => '>=(uuid,uuid)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/uuid_ops', amoplefttype => 'uuid',
+  amoprighttype => 'uuid', amopstrategy => '5', amopopr => '>(uuid,uuid)',
+  amopmethod => 'btree' },
+
+# btree pg_lsn_ops
+
+{ amopfamily => 'btree/pg_lsn_ops', amoplefttype => 'pg_lsn',
+  amoprighttype => 'pg_lsn', amopstrategy => '1', amopopr => '<(pg_lsn,pg_lsn)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/pg_lsn_ops', amoplefttype => 'pg_lsn',
+  amoprighttype => 'pg_lsn', amopstrategy => '2',
+  amopopr => '<=(pg_lsn,pg_lsn)', amopmethod => 'btree' },
+{ amopfamily => 'btree/pg_lsn_ops', amoplefttype => 'pg_lsn',
+  amoprighttype => 'pg_lsn', amopstrategy => '3', amopopr => '=(pg_lsn,pg_lsn)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/pg_lsn_ops', amoplefttype => 'pg_lsn',
+  amoprighttype => 'pg_lsn', amopstrategy => '4',
+  amopopr => '>=(pg_lsn,pg_lsn)', amopmethod => 'btree' },
+{ amopfamily => 'btree/pg_lsn_ops', amoplefttype => 'pg_lsn',
+  amoprighttype => 'pg_lsn', amopstrategy => '5', amopopr => '>(pg_lsn,pg_lsn)',
+  amopmethod => 'btree' },
+
+# hash index_ops
+
+# bpchar_ops
+{ amopfamily => 'hash/bpchar_ops', amoplefttype => 'bpchar',
+  amoprighttype => 'bpchar', amopstrategy => '1', amopopr => '=(bpchar,bpchar)',
+  amopmethod => 'hash' },
+
+# char_ops
+{ amopfamily => 'hash/char_ops', amoplefttype => 'char',
+  amoprighttype => 'char', amopstrategy => '1', amopopr => '=(char,char)',
+  amopmethod => 'hash' },
+
+# date_ops
+{ amopfamily => 'hash/date_ops', amoplefttype => 'date',
+  amoprighttype => 'date', amopstrategy => '1', amopopr => '=(date,date)',
+  amopmethod => 'hash' },
+
+# float_ops
+{ amopfamily => 'hash/float_ops', amoplefttype => 'float4',
+  amoprighttype => 'float4', amopstrategy => '1', amopopr => '=(float4,float4)',
+  amopmethod => 'hash' },
+{ amopfamily => 'hash/float_ops', amoplefttype => 'float8',
+  amoprighttype => 'float8', amopstrategy => '1', amopopr => '=(float8,float8)',
+  amopmethod => 'hash' },
+{ amopfamily => 'hash/float_ops', amoplefttype => 'float4',
+  amoprighttype => 'float8', amopstrategy => '1', amopopr => '=(float4,float8)',
+  amopmethod => 'hash' },
+{ amopfamily => 'hash/float_ops', amoplefttype => 'float8',
+  amoprighttype => 'float4', amopstrategy => '1', amopopr => '=(float8,float4)',
+  amopmethod => 'hash' },
+
+# network_ops
+{ amopfamily => 'hash/network_ops', amoplefttype => 'inet',
+  amoprighttype => 'inet', amopstrategy => '1', amopopr => '=(inet,inet)',
+  amopmethod => 'hash' },
+
+# integer_ops
+{ amopfamily => 'hash/integer_ops', amoplefttype => 'int2',
+  amoprighttype => 'int2', amopstrategy => '1', amopopr => '=(int2,int2)',
+  amopmethod => 'hash' },
+{ amopfamily => 'hash/integer_ops', amoplefttype => 'int4',
+  amoprighttype => 'int4', amopstrategy => '1', amopopr => '=(int4,int4)',
+  amopmethod => 'hash' },
+{ amopfamily => 'hash/integer_ops', amoplefttype => 'int8',
+  amoprighttype => 'int8', amopstrategy => '1', amopopr => '=(int8,int8)',
+  amopmethod => 'hash' },
+{ amopfamily => 'hash/integer_ops', amoplefttype => 'int2',
+  amoprighttype => 'int4', amopstrategy => '1', amopopr => '=(int2,int4)',
+  amopmethod => 'hash' },
+{ amopfamily => 'hash/integer_ops', amoplefttype => 'int2',
+  amoprighttype => 'int8', amopstrategy => '1', amopopr => '=(int2,int8)',
+  amopmethod => 'hash' },
+{ amopfamily => 'hash/integer_ops', amoplefttype => 'int4',
+  amoprighttype => 'int2', amopstrategy => '1', amopopr => '=(int4,int2)',
+  amopmethod => 'hash' },
+{ amopfamily => 'hash/integer_ops', amoplefttype => 'int4',
+  amoprighttype => 'int8', amopstrategy => '1', amopopr => '=(int4,int8)',
+  amopmethod => 'hash' },
+{ amopfamily => 'hash/integer_ops', amoplefttype => 'int8',
+  amoprighttype => 'int2', amopstrategy => '1', amopopr => '=(int8,int2)',
+  amopmethod => 'hash' },
+{ amopfamily => 'hash/integer_ops', amoplefttype => 'int8',
+  amoprighttype => 'int4', amopstrategy => '1', amopopr => '=(int8,int4)',
+  amopmethod => 'hash' },
+
+# interval_ops
+{ amopfamily => 'hash/interval_ops', amoplefttype => 'interval',
+  amoprighttype => 'interval', amopstrategy => '1',
+  amopopr => '=(interval,interval)', amopmethod => 'hash' },
+
+# macaddr_ops
+{ amopfamily => 'hash/macaddr_ops', amoplefttype => 'macaddr',
+  amoprighttype => 'macaddr', amopstrategy => '1',
+  amopopr => '=(macaddr,macaddr)', amopmethod => 'hash' },
+
+# macaddr8_ops
+{ amopfamily => 'hash/macaddr8_ops', amoplefttype => 'macaddr8',
+  amoprighttype => 'macaddr8', amopstrategy => '1',
+  amopopr => '=(macaddr8,macaddr8)', amopmethod => 'hash' },
+
+# oid_ops
+{ amopfamily => 'hash/oid_ops', amoplefttype => 'oid', amoprighttype => 'oid',
+  amopstrategy => '1', amopopr => '=(oid,oid)', amopmethod => 'hash' },
+
+# oidvector_ops
+{ amopfamily => 'hash/oidvector_ops', amoplefttype => 'oidvector',
+  amoprighttype => 'oidvector', amopstrategy => '1',
+  amopopr => '=(oidvector,oidvector)', amopmethod => 'hash' },
+
+# text_ops
+{ amopfamily => 'hash/text_ops', amoplefttype => 'text',
+  amoprighttype => 'text', amopstrategy => '1', amopopr => '=(text,text)',
+  amopmethod => 'hash' },
+{ amopfamily => 'hash/text_ops', amoplefttype => 'name',
+  amoprighttype => 'name', amopstrategy => '1', amopopr => '=(name,name)',
+  amopmethod => 'hash' },
+{ amopfamily => 'hash/text_ops', amoplefttype => 'name',
+  amoprighttype => 'text', amopstrategy => '1', amopopr => '=(name,text)',
+  amopmethod => 'hash' },
+{ amopfamily => 'hash/text_ops', amoplefttype => 'text',
+  amoprighttype => 'name', amopstrategy => '1', amopopr => '=(text,name)',
+  amopmethod => 'hash' },
+
+# time_ops
+{ amopfamily => 'hash/time_ops', amoplefttype => 'time',
+  amoprighttype => 'time', amopstrategy => '1', amopopr => '=(time,time)',
+  amopmethod => 'hash' },
+
+# timestamptz_ops
+{ amopfamily => 'hash/timestamptz_ops', amoplefttype => 'timestamptz',
+  amoprighttype => 'timestamptz', amopstrategy => '1',
+  amopopr => '=(timestamptz,timestamptz)', amopmethod => 'hash' },
+
+# timetz_ops
+{ amopfamily => 'hash/timetz_ops', amoplefttype => 'timetz',
+  amoprighttype => 'timetz', amopstrategy => '1', amopopr => '=(timetz,timetz)',
+  amopmethod => 'hash' },
+
+# timestamp_ops
+{ amopfamily => 'hash/timestamp_ops', amoplefttype => 'timestamp',
+  amoprighttype => 'timestamp', amopstrategy => '1',
+  amopopr => '=(timestamp,timestamp)', amopmethod => 'hash' },
+
+# bool_ops
+{ amopfamily => 'hash/bool_ops', amoplefttype => 'bool',
+  amoprighttype => 'bool', amopstrategy => '1', amopopr => '=(bool,bool)',
+  amopmethod => 'hash' },
+
+# bytea_ops
+{ amopfamily => 'hash/bytea_ops', amoplefttype => 'bytea',
+  amoprighttype => 'bytea', amopstrategy => '1', amopopr => '=(bytea,bytea)',
+  amopmethod => 'hash' },
+
+# xid_ops
+{ amopfamily => 'hash/xid_ops', amoplefttype => 'xid', amoprighttype => 'xid',
+  amopstrategy => '1', amopopr => '=(xid,xid)', amopmethod => 'hash' },
+
+# xid8_ops
+{ amopfamily => 'hash/xid8_ops', amoplefttype => 'xid8',
+  amoprighttype => 'xid8', amopstrategy => '1', amopopr => '=(xid8,xid8)',
+  amopmethod => 'hash' },
+
+# cid_ops
+{ amopfamily => 'hash/cid_ops', amoplefttype => 'cid', amoprighttype => 'cid',
+  amopstrategy => '1', amopopr => '=(cid,cid)', amopmethod => 'hash' },
+
+# tid_ops
+{ amopfamily => 'hash/tid_ops', amoplefttype => 'tid', amoprighttype => 'tid',
+  amopstrategy => '1', amopopr => '=(tid,tid)', amopmethod => 'hash' },
+
+# text_pattern_ops
+{ amopfamily => 'hash/text_pattern_ops', amoplefttype => 'text',
+  amoprighttype => 'text', amopstrategy => '1', amopopr => '=(text,text)',
+  amopmethod => 'hash' },
+
+# bpchar_pattern_ops
+{ amopfamily => 'hash/bpchar_pattern_ops', amoplefttype => 'bpchar',
+  amoprighttype => 'bpchar', amopstrategy => '1', amopopr => '=(bpchar,bpchar)',
+  amopmethod => 'hash' },
+
+# aclitem_ops
+{ amopfamily => 'hash/aclitem_ops', amoplefttype => 'aclitem',
+  amoprighttype => 'aclitem', amopstrategy => '1',
+  amopopr => '=(aclitem,aclitem)', amopmethod => 'hash' },
+
+# uuid_ops
+{ amopfamily => 'hash/uuid_ops', amoplefttype => 'uuid',
+  amoprighttype => 'uuid', amopstrategy => '1', amopopr => '=(uuid,uuid)',
+  amopmethod => 'hash' },
+
+# pg_lsn_ops
+{ amopfamily => 'hash/pg_lsn_ops', amoplefttype => 'pg_lsn',
+  amoprighttype => 'pg_lsn', amopstrategy => '1', amopopr => '=(pg_lsn,pg_lsn)',
+  amopmethod => 'hash' },
+
+# numeric_ops
+{ amopfamily => 'hash/numeric_ops', amoplefttype => 'numeric',
+  amoprighttype => 'numeric', amopstrategy => '1',
+  amopopr => '=(numeric,numeric)', amopmethod => 'hash' },
+
+# array_ops
+{ amopfamily => 'hash/array_ops', amoplefttype => 'anyarray',
+  amoprighttype => 'anyarray', amopstrategy => '1',
+  amopopr => '=(anyarray,anyarray)', amopmethod => 'hash' },
+
+# gist box_ops
+{ amopfamily => 'gist/box_ops', amoplefttype => 'box', amoprighttype => 'box',
+  amopstrategy => '1', amopopr => '<<(box,box)', amopmethod => 'gist' },
+{ amopfamily => 'gist/box_ops', amoplefttype => 'box', amoprighttype => 'box',
+  amopstrategy => '2', amopopr => '&<(box,box)', amopmethod => 'gist' },
+{ amopfamily => 'gist/box_ops', amoplefttype => 'box', amoprighttype => 'box',
+  amopstrategy => '3', amopopr => '&&(box,box)', amopmethod => 'gist' },
+{ amopfamily => 'gist/box_ops', amoplefttype => 'box', amoprighttype => 'box',
+  amopstrategy => '4', amopopr => '&>(box,box)', amopmethod => 'gist' },
+{ amopfamily => 'gist/box_ops', amoplefttype => 'box', amoprighttype => 'box',
+  amopstrategy => '5', amopopr => '>>(box,box)', amopmethod => 'gist' },
+{ amopfamily => 'gist/box_ops', amoplefttype => 'box', amoprighttype => 'box',
+  amopstrategy => '6', amopopr => '~=(box,box)', amopmethod => 'gist' },
+{ amopfamily => 'gist/box_ops', amoplefttype => 'box', amoprighttype => 'box',
+  amopstrategy => '7', amopopr => '@>(box,box)', amopmethod => 'gist' },
+{ amopfamily => 'gist/box_ops', amoplefttype => 'box', amoprighttype => 'box',
+  amopstrategy => '8', amopopr => '<@(box,box)', amopmethod => 'gist' },
+{ amopfamily => 'gist/box_ops', amoplefttype => 'box', amoprighttype => 'box',
+  amopstrategy => '9', amopopr => '&<|(box,box)', amopmethod => 'gist' },
+{ amopfamily => 'gist/box_ops', amoplefttype => 'box', amoprighttype => 'box',
+  amopstrategy => '10', amopopr => '<<|(box,box)', amopmethod => 'gist' },
+{ amopfamily => 'gist/box_ops', amoplefttype => 'box', amoprighttype => 'box',
+  amopstrategy => '11', amopopr => '|>>(box,box)', amopmethod => 'gist' },
+{ amopfamily => 'gist/box_ops', amoplefttype => 'box', amoprighttype => 'box',
+  amopstrategy => '12', amopopr => '|&>(box,box)', amopmethod => 'gist' },
+{ amopfamily => 'gist/box_ops', amoplefttype => 'box', amoprighttype => 'box',
+  amopstrategy => '13', amopopr => '~(box,box)', amopmethod => 'gist' },
+{ amopfamily => 'gist/box_ops', amoplefttype => 'box', amoprighttype => 'box',
+  amopstrategy => '14', amopopr => '@(box,box)', amopmethod => 'gist' },
+{ amopfamily => 'gist/box_ops', amoplefttype => 'box', amoprighttype => 'point',
+  amopstrategy => '15', amoppurpose => 'o', amopopr => '<->(box,point)',
+  amopmethod => 'gist', amopsortfamily => 'btree/float_ops' },
+
+# gist point_ops
+{ amopfamily => 'gist/point_ops', amoplefttype => 'point',
+  amoprighttype => 'point', amopstrategy => '11', amopopr => '>^(point,point)',
+  amopmethod => 'gist' },
+{ amopfamily => 'gist/point_ops', amoplefttype => 'point',
+  amoprighttype => 'point', amopstrategy => '1', amopopr => '<<(point,point)',
+  amopmethod => 'gist' },
+{ amopfamily => 'gist/point_ops', amoplefttype => 'point',
+  amoprighttype => 'point', amopstrategy => '5', amopopr => '>>(point,point)',
+  amopmethod => 'gist' },
+{ amopfamily => 'gist/point_ops', amoplefttype => 'point',
+  amoprighttype => 'point', amopstrategy => '10', amopopr => '<^(point,point)',
+  amopmethod => 'gist' },
+{ amopfamily => 'gist/point_ops', amoplefttype => 'point',
+  amoprighttype => 'point', amopstrategy => '6', amopopr => '~=(point,point)',
+  amopmethod => 'gist' },
+{ amopfamily => 'gist/point_ops', amoplefttype => 'point',
+  amoprighttype => 'point', amopstrategy => '15', amoppurpose => 'o',
+  amopopr => '<->(point,point)', amopmethod => 'gist',
+  amopsortfamily => 'btree/float_ops' },
+{ amopfamily => 'gist/point_ops', amoplefttype => 'point',
+  amoprighttype => 'box', amopstrategy => '28', amopopr => '<@(point,box)',
+  amopmethod => 'gist' },
+{ amopfamily => 'gist/point_ops', amoplefttype => 'point',
+  amoprighttype => 'polygon', amopstrategy => '48',
+  amopopr => '<@(point,polygon)', amopmethod => 'gist' },
+{ amopfamily => 'gist/point_ops', amoplefttype => 'point',
+  amoprighttype => 'circle', amopstrategy => '68',
+  amopopr => '<@(point,circle)', amopmethod => 'gist' },
+
+# gist poly_ops (supports polygons)
+{ amopfamily => 'gist/poly_ops', amoplefttype => 'polygon',
+  amoprighttype => 'polygon', amopstrategy => '1',
+  amopopr => '<<(polygon,polygon)', amopmethod => 'gist' },
+{ amopfamily => 'gist/poly_ops', amoplefttype => 'polygon',
+  amoprighttype => 'polygon', amopstrategy => '2',
+  amopopr => '&<(polygon,polygon)', amopmethod => 'gist' },
+{ amopfamily => 'gist/poly_ops', amoplefttype => 'polygon',
+  amoprighttype => 'polygon', amopstrategy => '3',
+  amopopr => '&&(polygon,polygon)', amopmethod => 'gist' },
+{ amopfamily => 'gist/poly_ops', amoplefttype => 'polygon',
+  amoprighttype => 'polygon', amopstrategy => '4',
+  amopopr => '&>(polygon,polygon)', amopmethod => 'gist' },
+{ amopfamily => 'gist/poly_ops', amoplefttype => 'polygon',
+  amoprighttype => 'polygon', amopstrategy => '5',
+  amopopr => '>>(polygon,polygon)', amopmethod => 'gist' },
+{ amopfamily => 'gist/poly_ops', amoplefttype => 'polygon',
+  amoprighttype => 'polygon', amopstrategy => '6',
+  amopopr => '~=(polygon,polygon)', amopmethod => 'gist' },
+{ amopfamily => 'gist/poly_ops', amoplefttype => 'polygon',
+  amoprighttype => 'polygon', amopstrategy => '7',
+  amopopr => '@>(polygon,polygon)', amopmethod => 'gist' },
+{ amopfamily => 'gist/poly_ops', amoplefttype => 'polygon',
+  amoprighttype => 'polygon', amopstrategy => '8',
+  amopopr => '<@(polygon,polygon)', amopmethod => 'gist' },
+{ amopfamily => 'gist/poly_ops', amoplefttype => 'polygon',
+  amoprighttype => 'polygon', amopstrategy => '9',
+  amopopr => '&<|(polygon,polygon)', amopmethod => 'gist' },
+{ amopfamily => 'gist/poly_ops', amoplefttype => 'polygon',
+  amoprighttype => 'polygon', amopstrategy => '10',
+  amopopr => '<<|(polygon,polygon)', amopmethod => 'gist' },
+{ amopfamily => 'gist/poly_ops', amoplefttype => 'polygon',
+  amoprighttype => 'polygon', amopstrategy => '11',
+  amopopr => '|>>(polygon,polygon)', amopmethod => 'gist' },
+{ amopfamily => 'gist/poly_ops', amoplefttype => 'polygon',
+  amoprighttype => 'polygon', amopstrategy => '12',
+  amopopr => '|&>(polygon,polygon)', amopmethod => 'gist' },
+{ amopfamily => 'gist/poly_ops', amoplefttype => 'polygon',
+  amoprighttype => 'polygon', amopstrategy => '13',
+  amopopr => '~(polygon,polygon)', amopmethod => 'gist' },
+{ amopfamily => 'gist/poly_ops', amoplefttype => 'polygon',
+  amoprighttype => 'polygon', amopstrategy => '14',
+  amopopr => '@(polygon,polygon)', amopmethod => 'gist' },
+{ amopfamily => 'gist/poly_ops', amoplefttype => 'polygon',
+  amoprighttype => 'point', amopstrategy => '15', amoppurpose => 'o',
+  amopopr => '<->(polygon,point)', amopmethod => 'gist',
+  amopsortfamily => 'btree/float_ops' },
+
+# gist circle_ops
+{ amopfamily => 'gist/circle_ops', amoplefttype => 'circle',
+  amoprighttype => 'circle', amopstrategy => '1',
+  amopopr => '<<(circle,circle)', amopmethod => 'gist' },
+{ amopfamily => 'gist/circle_ops', amoplefttype => 'circle',
+  amoprighttype => 'circle', amopstrategy => '2',
+  amopopr => '&<(circle,circle)', amopmethod => 'gist' },
+{ amopfamily => 'gist/circle_ops', amoplefttype => 'circle',
+  amoprighttype => 'circle', amopstrategy => '3',
+  amopopr => '&&(circle,circle)', amopmethod => 'gist' },
+{ amopfamily => 'gist/circle_ops', amoplefttype => 'circle',
+  amoprighttype => 'circle', amopstrategy => '4',
+  amopopr => '&>(circle,circle)', amopmethod => 'gist' },
+{ amopfamily => 'gist/circle_ops', amoplefttype => 'circle',
+  amoprighttype => 'circle', amopstrategy => '5',
+  amopopr => '>>(circle,circle)', amopmethod => 'gist' },
+{ amopfamily => 'gist/circle_ops', amoplefttype => 'circle',
+  amoprighttype => 'circle', amopstrategy => '6',
+  amopopr => '~=(circle,circle)', amopmethod => 'gist' },
+{ amopfamily => 'gist/circle_ops', amoplefttype => 'circle',
+  amoprighttype => 'circle', amopstrategy => '7',
+  amopopr => '@>(circle,circle)', amopmethod => 'gist' },
+{ amopfamily => 'gist/circle_ops', amoplefttype => 'circle',
+  amoprighttype => 'circle', amopstrategy => '8',
+  amopopr => '<@(circle,circle)', amopmethod => 'gist' },
+{ amopfamily => 'gist/circle_ops', amoplefttype => 'circle',
+  amoprighttype => 'circle', amopstrategy => '9',
+  amopopr => '&<|(circle,circle)', amopmethod => 'gist' },
+{ amopfamily => 'gist/circle_ops', amoplefttype => 'circle',
+  amoprighttype => 'circle', amopstrategy => '10',
+  amopopr => '<<|(circle,circle)', amopmethod => 'gist' },
+{ amopfamily => 'gist/circle_ops', amoplefttype => 'circle',
+  amoprighttype => 'circle', amopstrategy => '11',
+  amopopr => '|>>(circle,circle)', amopmethod => 'gist' },
+{ amopfamily => 'gist/circle_ops', amoplefttype => 'circle',
+  amoprighttype => 'circle', amopstrategy => '12',
+  amopopr => '|&>(circle,circle)', amopmethod => 'gist' },
+{ amopfamily => 'gist/circle_ops', amoplefttype => 'circle',
+  amoprighttype => 'circle', amopstrategy => '13',
+  amopopr => '~(circle,circle)', amopmethod => 'gist' },
+{ amopfamily => 'gist/circle_ops', amoplefttype => 'circle',
+  amoprighttype => 'circle', amopstrategy => '14',
+  amopopr => '@(circle,circle)', amopmethod => 'gist' },
+{ amopfamily => 'gist/circle_ops', amoplefttype => 'circle',
+  amoprighttype => 'point', amopstrategy => '15', amoppurpose => 'o',
+  amopopr => '<->(circle,point)', amopmethod => 'gist',
+  amopsortfamily => 'btree/float_ops' },
+
+# gin array_ops
+{ amopfamily => 'gin/array_ops', amoplefttype => 'anyarray',
+  amoprighttype => 'anyarray', amopstrategy => '1',
+  amopopr => '&&(anyarray,anyarray)', amopmethod => 'gin' },
+{ amopfamily => 'gin/array_ops', amoplefttype => 'anyarray',
+  amoprighttype => 'anyarray', amopstrategy => '2',
+  amopopr => '@>(anyarray,anyarray)', amopmethod => 'gin' },
+{ amopfamily => 'gin/array_ops', amoplefttype => 'anyarray',
+  amoprighttype => 'anyarray', amopstrategy => '3',
+  amopopr => '<@(anyarray,anyarray)', amopmethod => 'gin' },
+{ amopfamily => 'gin/array_ops', amoplefttype => 'anyarray',
+  amoprighttype => 'anyarray', amopstrategy => '4',
+  amopopr => '=(anyarray,anyarray)', amopmethod => 'gin' },
+
+# btree enum_ops
+{ amopfamily => 'btree/enum_ops', amoplefttype => 'anyenum',
+  amoprighttype => 'anyenum', amopstrategy => '1',
+  amopopr => '<(anyenum,anyenum)', amopmethod => 'btree' },
+{ amopfamily => 'btree/enum_ops', amoplefttype => 'anyenum',
+  amoprighttype => 'anyenum', amopstrategy => '2',
+  amopopr => '<=(anyenum,anyenum)', amopmethod => 'btree' },
+{ amopfamily => 'btree/enum_ops', amoplefttype => 'anyenum',
+  amoprighttype => 'anyenum', amopstrategy => '3',
+  amopopr => '=(anyenum,anyenum)', amopmethod => 'btree' },
+{ amopfamily => 'btree/enum_ops', amoplefttype => 'anyenum',
+  amoprighttype => 'anyenum', amopstrategy => '4',
+  amopopr => '>=(anyenum,anyenum)', amopmethod => 'btree' },
+{ amopfamily => 'btree/enum_ops', amoplefttype => 'anyenum',
+  amoprighttype => 'anyenum', amopstrategy => '5',
+  amopopr => '>(anyenum,anyenum)', amopmethod => 'btree' },
+
+# hash enum_ops
+{ amopfamily => 'hash/enum_ops', amoplefttype => 'anyenum',
+  amoprighttype => 'anyenum', amopstrategy => '1',
+  amopopr => '=(anyenum,anyenum)', amopmethod => 'hash' },
+
+# btree tsvector_ops
+{ amopfamily => 'btree/tsvector_ops', amoplefttype => 'tsvector',
+  amoprighttype => 'tsvector', amopstrategy => '1',
+  amopopr => '<(tsvector,tsvector)', amopmethod => 'btree' },
+{ amopfamily => 'btree/tsvector_ops', amoplefttype => 'tsvector',
+  amoprighttype => 'tsvector', amopstrategy => '2',
+  amopopr => '<=(tsvector,tsvector)', amopmethod => 'btree' },
+{ amopfamily => 'btree/tsvector_ops', amoplefttype => 'tsvector',
+  amoprighttype => 'tsvector', amopstrategy => '3',
+  amopopr => '=(tsvector,tsvector)', amopmethod => 'btree' },
+{ amopfamily => 'btree/tsvector_ops', amoplefttype => 'tsvector',
+  amoprighttype => 'tsvector', amopstrategy => '4',
+  amopopr => '>=(tsvector,tsvector)', amopmethod => 'btree' },
+{ amopfamily => 'btree/tsvector_ops', amoplefttype => 'tsvector',
+  amoprighttype => 'tsvector', amopstrategy => '5',
+  amopopr => '>(tsvector,tsvector)', amopmethod => 'btree' },
+
+# GiST tsvector_ops
+{ amopfamily => 'gist/tsvector_ops', amoplefttype => 'tsvector',
+  amoprighttype => 'tsquery', amopstrategy => '1',
+  amopopr => '@@(tsvector,tsquery)', amopmethod => 'gist' },
+
+# GIN tsvector_ops
+{ amopfamily => 'gin/tsvector_ops', amoplefttype => 'tsvector',
+  amoprighttype => 'tsquery', amopstrategy => '1',
+  amopopr => '@@(tsvector,tsquery)', amopmethod => 'gin' },
+{ amopfamily => 'gin/tsvector_ops', amoplefttype => 'tsvector',
+  amoprighttype => 'tsquery', amopstrategy => '2',
+  amopopr => '@@@(tsvector,tsquery)', amopmethod => 'gin' },
+
+# btree tsquery_ops
+{ amopfamily => 'btree/tsquery_ops', amoplefttype => 'tsquery',
+  amoprighttype => 'tsquery', amopstrategy => '1',
+  amopopr => '<(tsquery,tsquery)', amopmethod => 'btree' },
+{ amopfamily => 'btree/tsquery_ops', amoplefttype => 'tsquery',
+  amoprighttype => 'tsquery', amopstrategy => '2',
+  amopopr => '<=(tsquery,tsquery)', amopmethod => 'btree' },
+{ amopfamily => 'btree/tsquery_ops', amoplefttype => 'tsquery',
+  amoprighttype => 'tsquery', amopstrategy => '3',
+  amopopr => '=(tsquery,tsquery)', amopmethod => 'btree' },
+{ amopfamily => 'btree/tsquery_ops', amoplefttype => 'tsquery',
+  amoprighttype => 'tsquery', amopstrategy => '4',
+  amopopr => '>=(tsquery,tsquery)', amopmethod => 'btree' },
+{ amopfamily => 'btree/tsquery_ops', amoplefttype => 'tsquery',
+  amoprighttype => 'tsquery', amopstrategy => '5',
+  amopopr => '>(tsquery,tsquery)', amopmethod => 'btree' },
+
+# GiST tsquery_ops
+{ amopfamily => 'gist/tsquery_ops', amoplefttype => 'tsquery',
+  amoprighttype => 'tsquery', amopstrategy => '7',
+  amopopr => '@>(tsquery,tsquery)', amopmethod => 'gist' },
+{ amopfamily => 'gist/tsquery_ops', amoplefttype => 'tsquery',
+  amoprighttype => 'tsquery', amopstrategy => '8',
+  amopopr => '<@(tsquery,tsquery)', amopmethod => 'gist' },
+
+# btree range_ops
+{ amopfamily => 'btree/range_ops', amoplefttype => 'anyrange',
+  amoprighttype => 'anyrange', amopstrategy => '1',
+  amopopr => '<(anyrange,anyrange)', amopmethod => 'btree' },
+{ amopfamily => 'btree/range_ops', amoplefttype => 'anyrange',
+  amoprighttype => 'anyrange', amopstrategy => '2',
+  amopopr => '<=(anyrange,anyrange)', amopmethod => 'btree' },
+{ amopfamily => 'btree/range_ops', amoplefttype => 'anyrange',
+  amoprighttype => 'anyrange', amopstrategy => '3',
+  amopopr => '=(anyrange,anyrange)', amopmethod => 'btree' },
+{ amopfamily => 'btree/range_ops', amoplefttype => 'anyrange',
+  amoprighttype => 'anyrange', amopstrategy => '4',
+  amopopr => '>=(anyrange,anyrange)', amopmethod => 'btree' },
+{ amopfamily => 'btree/range_ops', amoplefttype => 'anyrange',
+  amoprighttype => 'anyrange', amopstrategy => '5',
+  amopopr => '>(anyrange,anyrange)', amopmethod => 'btree' },
+
+# hash range_ops
+{ amopfamily => 'hash/range_ops', amoplefttype => 'anyrange',
+  amoprighttype => 'anyrange', amopstrategy => '1',
+  amopopr => '=(anyrange,anyrange)', amopmethod => 'hash' },
+
+# GiST range_ops
+{ amopfamily => 'gist/range_ops', amoplefttype => 'anyrange',
+  amoprighttype => 'anyrange', amopstrategy => '1',
+  amopopr => '<<(anyrange,anyrange)', amopmethod => 'gist' },
+{ amopfamily => 'gist/range_ops', amoplefttype => 'anyrange',
+  amoprighttype => 'anyrange', amopstrategy => '2',
+  amopopr => '&<(anyrange,anyrange)', amopmethod => 'gist' },
+{ amopfamily => 'gist/range_ops', amoplefttype => 'anyrange',
+  amoprighttype => 'anyrange', amopstrategy => '3',
+  amopopr => '&&(anyrange,anyrange)', amopmethod => 'gist' },
+{ amopfamily => 'gist/range_ops', amoplefttype => 'anyrange',
+  amoprighttype => 'anyrange', amopstrategy => '4',
+  amopopr => '&>(anyrange,anyrange)', amopmethod => 'gist' },
+{ amopfamily => 'gist/range_ops', amoplefttype => 'anyrange',
+  amoprighttype => 'anyrange', amopstrategy => '5',
+  amopopr => '>>(anyrange,anyrange)', amopmethod => 'gist' },
+{ amopfamily => 'gist/range_ops', amoplefttype => 'anyrange',
+  amoprighttype => 'anyrange', amopstrategy => '6',
+  amopopr => '-|-(anyrange,anyrange)', amopmethod => 'gist' },
+{ amopfamily => 'gist/range_ops', amoplefttype => 'anyrange',
+  amoprighttype => 'anyrange', amopstrategy => '7',
+  amopopr => '@>(anyrange,anyrange)', amopmethod => 'gist' },
+{ amopfamily => 'gist/range_ops', amoplefttype => 'anyrange',
+  amoprighttype => 'anyrange', amopstrategy => '8',
+  amopopr => '<@(anyrange,anyrange)', amopmethod => 'gist' },
+{ amopfamily => 'gist/range_ops', amoplefttype => 'anyrange',
+  amoprighttype => 'anyelement', amopstrategy => '16',
+  amopopr => '@>(anyrange,anyelement)', amopmethod => 'gist' },
+{ amopfamily => 'gist/range_ops', amoplefttype => 'anyrange',
+  amoprighttype => 'anyrange', amopstrategy => '18',
+  amopopr => '=(anyrange,anyrange)', amopmethod => 'gist' },
+
+# SP-GiST quad_point_ops
+{ amopfamily => 'spgist/quad_point_ops', amoplefttype => 'point',
+  amoprighttype => 'point', amopstrategy => '11', amopopr => '>^(point,point)',
+  amopmethod => 'spgist' },
+{ amopfamily => 'spgist/quad_point_ops', amoplefttype => 'point',
+  amoprighttype => 'point', amopstrategy => '1', amopopr => '<<(point,point)',
+  amopmethod => 'spgist' },
+{ amopfamily => 'spgist/quad_point_ops', amoplefttype => 'point',
+  amoprighttype => 'point', amopstrategy => '5', amopopr => '>>(point,point)',
+  amopmethod => 'spgist' },
+{ amopfamily => 'spgist/quad_point_ops', amoplefttype => 'point',
+  amoprighttype => 'point', amopstrategy => '10', amopopr => '<^(point,point)',
+  amopmethod => 'spgist' },
+{ amopfamily => 'spgist/quad_point_ops', amoplefttype => 'point',
+  amoprighttype => 'point', amopstrategy => '6', amopopr => '~=(point,point)',
+  amopmethod => 'spgist' },
+{ amopfamily => 'spgist/quad_point_ops', amoplefttype => 'point',
+  amoprighttype => 'box', amopstrategy => '8', amopopr => '<@(point,box)',
+  amopmethod => 'spgist' },
+{ amopfamily => 'spgist/quad_point_ops', amoplefttype => 'point',
+  amoprighttype => 'point', amopstrategy => '15', amoppurpose => 'o',
+  amopopr => '<->(point,point)', amopmethod => 'spgist',
+  amopsortfamily => 'btree/float_ops' },
+
+# SP-GiST kd_point_ops
+{ amopfamily => 'spgist/kd_point_ops', amoplefttype => 'point',
+  amoprighttype => 'point', amopstrategy => '11', amopopr => '>^(point,point)',
+  amopmethod => 'spgist' },
+{ amopfamily => 'spgist/kd_point_ops', amoplefttype => 'point',
+  amoprighttype => 'point', amopstrategy => '1', amopopr => '<<(point,point)',
+  amopmethod => 'spgist' },
+{ amopfamily => 'spgist/kd_point_ops', amoplefttype => 'point',
+  amoprighttype => 'point', amopstrategy => '5', amopopr => '>>(point,point)',
+  amopmethod => 'spgist' },
+{ amopfamily => 'spgist/kd_point_ops', amoplefttype => 'point',
+  amoprighttype => 'point', amopstrategy => '10', amopopr => '<^(point,point)',
+  amopmethod => 'spgist' },
+{ amopfamily => 'spgist/kd_point_ops', amoplefttype => 'point',
+  amoprighttype => 'point', amopstrategy => '6', amopopr => '~=(point,point)',
+  amopmethod => 'spgist' },
+{ amopfamily => 'spgist/kd_point_ops', amoplefttype => 'point',
+  amoprighttype => 'box', amopstrategy => '8', amopopr => '<@(point,box)',
+  amopmethod => 'spgist' },
+{ amopfamily => 'spgist/kd_point_ops', amoplefttype => 'point',
+  amoprighttype => 'point', amopstrategy => '15', amoppurpose => 'o',
+  amopopr => '<->(point,point)', amopmethod => 'spgist',
+  amopsortfamily => 'btree/float_ops' },
+
+# SP-GiST text_ops
+{ amopfamily => 'spgist/text_ops', amoplefttype => 'text',
+  amoprighttype => 'text', amopstrategy => '1', amopopr => '~<~(text,text)',
+  amopmethod => 'spgist' },
+{ amopfamily => 'spgist/text_ops', amoplefttype => 'text',
+  amoprighttype => 'text', amopstrategy => '2', amopopr => '~<=~(text,text)',
+  amopmethod => 'spgist' },
+{ amopfamily => 'spgist/text_ops', amoplefttype => 'text',
+  amoprighttype => 'text', amopstrategy => '3', amopopr => '=(text,text)',
+  amopmethod => 'spgist' },
+{ amopfamily => 'spgist/text_ops', amoplefttype => 'text',
+  amoprighttype => 'text', amopstrategy => '4', amopopr => '~>=~(text,text)',
+  amopmethod => 'spgist' },
+{ amopfamily => 'spgist/text_ops', amoplefttype => 'text',
+  amoprighttype => 'text', amopstrategy => '5', amopopr => '~>~(text,text)',
+  amopmethod => 'spgist' },
+{ amopfamily => 'spgist/text_ops', amoplefttype => 'text',
+  amoprighttype => 'text', amopstrategy => '11', amopopr => '<(text,text)',
+  amopmethod => 'spgist' },
+{ amopfamily => 'spgist/text_ops', amoplefttype => 'text',
+  amoprighttype => 'text', amopstrategy => '12', amopopr => '<=(text,text)',
+  amopmethod => 'spgist' },
+{ amopfamily => 'spgist/text_ops', amoplefttype => 'text',
+  amoprighttype => 'text', amopstrategy => '14', amopopr => '>=(text,text)',
+  amopmethod => 'spgist' },
+{ amopfamily => 'spgist/text_ops', amoplefttype => 'text',
+  amoprighttype => 'text', amopstrategy => '15', amopopr => '>(text,text)',
+  amopmethod => 'spgist' },
+{ amopfamily => 'spgist/text_ops', amoplefttype => 'text',
+  amoprighttype => 'text', amopstrategy => '28', amopopr => '^@(text,text)',
+  amopmethod => 'spgist' },
+
+# btree jsonb_ops
+{ amopfamily => 'btree/jsonb_ops', amoplefttype => 'jsonb',
+  amoprighttype => 'jsonb', amopstrategy => '1', amopopr => '<(jsonb,jsonb)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/jsonb_ops', amoplefttype => 'jsonb',
+  amoprighttype => 'jsonb', amopstrategy => '2', amopopr => '<=(jsonb,jsonb)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/jsonb_ops', amoplefttype => 'jsonb',
+  amoprighttype => 'jsonb', amopstrategy => '3', amopopr => '=(jsonb,jsonb)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/jsonb_ops', amoplefttype => 'jsonb',
+  amoprighttype => 'jsonb', amopstrategy => '4', amopopr => '>=(jsonb,jsonb)',
+  amopmethod => 'btree' },
+{ amopfamily => 'btree/jsonb_ops', amoplefttype => 'jsonb',
+  amoprighttype => 'jsonb', amopstrategy => '5', amopopr => '>(jsonb,jsonb)',
+  amopmethod => 'btree' },
+
+# hash jsonb_ops
+{ amopfamily => 'hash/jsonb_ops', amoplefttype => 'jsonb',
+  amoprighttype => 'jsonb', amopstrategy => '1', amopopr => '=(jsonb,jsonb)',
+  amopmethod => 'hash' },
+
+# GIN jsonb_ops
+{ amopfamily => 'gin/jsonb_ops', amoplefttype => 'jsonb',
+  amoprighttype => 'jsonb', amopstrategy => '7', amopopr => '@>(jsonb,jsonb)',
+  amopmethod => 'gin' },
+{ amopfamily => 'gin/jsonb_ops', amoplefttype => 'jsonb',
+  amoprighttype => 'text', amopstrategy => '9', amopopr => '?(jsonb,text)',
+  amopmethod => 'gin' },
+{ amopfamily => 'gin/jsonb_ops', amoplefttype => 'jsonb',
+  amoprighttype => '_text', amopstrategy => '10', amopopr => '?|(jsonb,_text)',
+  amopmethod => 'gin' },
+{ amopfamily => 'gin/jsonb_ops', amoplefttype => 'jsonb',
+  amoprighttype => '_text', amopstrategy => '11', amopopr => '?&(jsonb,_text)',
+  amopmethod => 'gin' },
+{ amopfamily => 'gin/jsonb_ops', amoplefttype => 'jsonb',
+  amoprighttype => 'jsonpath', amopstrategy => '15',
+  amopopr => '@?(jsonb,jsonpath)', amopmethod => 'gin' },
+{ amopfamily => 'gin/jsonb_ops', amoplefttype => 'jsonb',
+  amoprighttype => 'jsonpath', amopstrategy => '16',
+  amopopr => '@@(jsonb,jsonpath)', amopmethod => 'gin' },
+
+# GIN jsonb_path_ops
+{ amopfamily => 'gin/jsonb_path_ops', amoplefttype => 'jsonb',
+  amoprighttype => 'jsonb', amopstrategy => '7', amopopr => '@>(jsonb,jsonb)',
+  amopmethod => 'gin' },
+{ amopfamily => 'gin/jsonb_path_ops', amoplefttype => 'jsonb',
+  amoprighttype => 'jsonpath', amopstrategy => '15',
+  amopopr => '@?(jsonb,jsonpath)', amopmethod => 'gin' },
+{ amopfamily => 'gin/jsonb_path_ops', amoplefttype => 'jsonb',
+  amoprighttype => 'jsonpath', amopstrategy => '16',
+  amopopr => '@@(jsonb,jsonpath)', amopmethod => 'gin' },
+
+# SP-GiST range_ops
+{ amopfamily => 'spgist/range_ops', amoplefttype => 'anyrange',
+  amoprighttype => 'anyrange', amopstrategy => '1',
+  amopopr => '<<(anyrange,anyrange)', amopmethod => 'spgist' },
+{ amopfamily => 'spgist/range_ops', amoplefttype => 'anyrange',
+  amoprighttype => 'anyrange', amopstrategy => '2',
+  amopopr => '&<(anyrange,anyrange)', amopmethod => 'spgist' },
+{ amopfamily => 'spgist/range_ops', amoplefttype => 'anyrange',
+  amoprighttype => 'anyrange', amopstrategy => '3',
+  amopopr => '&&(anyrange,anyrange)', amopmethod => 'spgist' },
+{ amopfamily => 'spgist/range_ops', amoplefttype => 'anyrange',
+  amoprighttype => 'anyrange', amopstrategy => '4',
+  amopopr => '&>(anyrange,anyrange)', amopmethod => 'spgist' },
+{ amopfamily => 'spgist/range_ops', amoplefttype => 'anyrange',
+  amoprighttype => 'anyrange', amopstrategy => '5',
+  amopopr => '>>(anyrange,anyrange)', amopmethod => 'spgist' },
+{ amopfamily => 'spgist/range_ops', amoplefttype => 'anyrange',
+  amoprighttype => 'anyrange', amopstrategy => '6',
+  amopopr => '-|-(anyrange,anyrange)', amopmethod => 'spgist' },
+{ amopfamily => 'spgist/range_ops', amoplefttype => 'anyrange',
+  amoprighttype => 'anyrange', amopstrategy => '7',
+  amopopr => '@>(anyrange,anyrange)', amopmethod => 'spgist' },
+{ amopfamily => 'spgist/range_ops', amoplefttype => 'anyrange',
+  amoprighttype => 'anyrange', amopstrategy => '8',
+  amopopr => '<@(anyrange,anyrange)', amopmethod => 'spgist' },
+{ amopfamily => 'spgist/range_ops', amoplefttype => 'anyrange',
+  amoprighttype => 'anyelement', amopstrategy => '16',
+  amopopr => '@>(anyrange,anyelement)', amopmethod => 'spgist' },
+{ amopfamily => 'spgist/range_ops', amoplefttype => 'anyrange',
+  amoprighttype => 'anyrange', amopstrategy => '18',
+  amopopr => '=(anyrange,anyrange)', amopmethod => 'spgist' },
+
+# SP-GiST box_ops
+{ amopfamily => 'spgist/box_ops', amoplefttype => 'box', amoprighttype => 'box',
+  amopstrategy => '1', amopopr => '<<(box,box)', amopmethod => 'spgist' },
+{ amopfamily => 'spgist/box_ops', amoplefttype => 'box', amoprighttype => 'box',
+  amopstrategy => '2', amopopr => '&<(box,box)', amopmethod => 'spgist' },
+{ amopfamily => 'spgist/box_ops', amoplefttype => 'box', amoprighttype => 'box',
+  amopstrategy => '3', amopopr => '&&(box,box)', amopmethod => 'spgist' },
+{ amopfamily => 'spgist/box_ops', amoplefttype => 'box', amoprighttype => 'box',
+  amopstrategy => '4', amopopr => '&>(box,box)', amopmethod => 'spgist' },
+{ amopfamily => 'spgist/box_ops', amoplefttype => 'box', amoprighttype => 'box',
+  amopstrategy => '5', amopopr => '>>(box,box)', amopmethod => 'spgist' },
+{ amopfamily => 'spgist/box_ops', amoplefttype => 'box', amoprighttype => 'box',
+  amopstrategy => '6', amopopr => '~=(box,box)', amopmethod => 'spgist' },
+{ amopfamily => 'spgist/box_ops', amoplefttype => 'box', amoprighttype => 'box',
+  amopstrategy => '7', amopopr => '@>(box,box)', amopmethod => 'spgist' },
+{ amopfamily => 'spgist/box_ops', amoplefttype => 'box', amoprighttype => 'box',
+  amopstrategy => '8', amopopr => '<@(box,box)', amopmethod => 'spgist' },
+{ amopfamily => 'spgist/box_ops', amoplefttype => 'box', amoprighttype => 'box',
+  amopstrategy => '9', amopopr => '&<|(box,box)', amopmethod => 'spgist' },
+{ amopfamily => 'spgist/box_ops', amoplefttype => 'box', amoprighttype => 'box',
+  amopstrategy => '10', amopopr => '<<|(box,box)', amopmethod => 'spgist' },
+{ amopfamily => 'spgist/box_ops', amoplefttype => 'box', amoprighttype => 'box',
+  amopstrategy => '11', amopopr => '|>>(box,box)', amopmethod => 'spgist' },
+{ amopfamily => 'spgist/box_ops', amoplefttype => 'box', amoprighttype => 'box',
+  amopstrategy => '12', amopopr => '|&>(box,box)', amopmethod => 'spgist' },
+{ amopfamily => 'spgist/box_ops', amoplefttype => 'box',
+  amoprighttype => 'point', amopstrategy => '15', amoppurpose => 'o',
+  amopopr => '<->(box,point)', amopmethod => 'spgist',
+  amopsortfamily => 'btree/float_ops' },
+
+# SP-GiST poly_ops (supports polygons)
+{ amopfamily => 'spgist/poly_ops', amoplefttype => 'polygon',
+  amoprighttype => 'polygon', amopstrategy => '1',
+  amopopr => '<<(polygon,polygon)', amopmethod => 'spgist' },
+{ amopfamily => 'spgist/poly_ops', amoplefttype => 'polygon',
+  amoprighttype => 'polygon', amopstrategy => '2',
+  amopopr => '&<(polygon,polygon)', amopmethod => 'spgist' },
+{ amopfamily => 'spgist/poly_ops', amoplefttype => 'polygon',
+  amoprighttype => 'polygon', amopstrategy => '3',
+  amopopr => '&&(polygon,polygon)', amopmethod => 'spgist' },
+{ amopfamily => 'spgist/poly_ops', amoplefttype => 'polygon',
+  amoprighttype => 'polygon', amopstrategy => '4',
+  amopopr => '&>(polygon,polygon)', amopmethod => 'spgist' },
+{ amopfamily => 'spgist/poly_ops', amoplefttype => 'polygon',
+  amoprighttype => 'polygon', amopstrategy => '5',
+  amopopr => '>>(polygon,polygon)', amopmethod => 'spgist' },
+{ amopfamily => 'spgist/poly_ops', amoplefttype => 'polygon',
+  amoprighttype => 'polygon', amopstrategy => '6',
+  amopopr => '~=(polygon,polygon)', amopmethod => 'spgist' },
+{ amopfamily => 'spgist/poly_ops', amoplefttype => 'polygon',
+  amoprighttype => 'polygon', amopstrategy => '7',
+  amopopr => '@>(polygon,polygon)', amopmethod => 'spgist' },
+{ amopfamily => 'spgist/poly_ops', amoplefttype => 'polygon',
+  amoprighttype => 'polygon', amopstrategy => '8',
+  amopopr => '<@(polygon,polygon)', amopmethod => 'spgist' },
+{ amopfamily => 'spgist/poly_ops', amoplefttype => 'polygon',
+  amoprighttype => 'polygon', amopstrategy => '9',
+  amopopr => '&<|(polygon,polygon)', amopmethod => 'spgist' },
+{ amopfamily => 'spgist/poly_ops', amoplefttype => 'polygon',
+  amoprighttype => 'polygon', amopstrategy => '10',
+  amopopr => '<<|(polygon,polygon)', amopmethod => 'spgist' },
+{ amopfamily => 'spgist/poly_ops', amoplefttype => 'polygon',
+  amoprighttype => 'polygon', amopstrategy => '11',
+  amopopr => '|>>(polygon,polygon)', amopmethod => 'spgist' },
+{ amopfamily => 'spgist/poly_ops', amoplefttype => 'polygon',
+  amoprighttype => 'polygon', amopstrategy => '12',
+  amopopr => '|&>(polygon,polygon)', amopmethod => 'spgist' },
+{ amopfamily => 'spgist/poly_ops', amoplefttype => 'polygon',
+  amoprighttype => 'point', amopstrategy => '15', amoppurpose => 'o',
+  amopopr => '<->(polygon,point)', amopmethod => 'spgist',
+  amopsortfamily => 'btree/float_ops' },
+
+# GiST inet_ops
+{ amopfamily => 'gist/network_ops', amoplefttype => 'inet',
+  amoprighttype => 'inet', amopstrategy => '3', amopopr => '&&(inet,inet)',
+  amopmethod => 'gist' },
+{ amopfamily => 'gist/network_ops', amoplefttype => 'inet',
+  amoprighttype => 'inet', amopstrategy => '18', amopopr => '=(inet,inet)',
+  amopmethod => 'gist' },
+{ amopfamily => 'gist/network_ops', amoplefttype => 'inet',
+  amoprighttype => 'inet', amopstrategy => '19', amopopr => '<>(inet,inet)',
+  amopmethod => 'gist' },
+{ amopfamily => 'gist/network_ops', amoplefttype => 'inet',
+  amoprighttype => 'inet', amopstrategy => '20', amopopr => '<(inet,inet)',
+  amopmethod => 'gist' },
+{ amopfamily => 'gist/network_ops', amoplefttype => 'inet',
+  amoprighttype => 'inet', amopstrategy => '21', amopopr => '<=(inet,inet)',
+  amopmethod => 'gist' },
+{ amopfamily => 'gist/network_ops', amoplefttype => 'inet',
+  amoprighttype => 'inet', amopstrategy => '22', amopopr => '>(inet,inet)',
+  amopmethod => 'gist' },
+{ amopfamily => 'gist/network_ops', amoplefttype => 'inet',
+  amoprighttype => 'inet', amopstrategy => '23', amopopr => '>=(inet,inet)',
+  amopmethod => 'gist' },
+{ amopfamily => 'gist/network_ops', amoplefttype => 'inet',
+  amoprighttype => 'inet', amopstrategy => '24', amopopr => '<<(inet,inet)',
+  amopmethod => 'gist' },
+{ amopfamily => 'gist/network_ops', amoplefttype => 'inet',
+  amoprighttype => 'inet', amopstrategy => '25', amopopr => '<<=(inet,inet)',
+  amopmethod => 'gist' },
+{ amopfamily => 'gist/network_ops', amoplefttype => 'inet',
+  amoprighttype => 'inet', amopstrategy => '26', amopopr => '>>(inet,inet)',
+  amopmethod => 'gist' },
+{ amopfamily => 'gist/network_ops', amoplefttype => 'inet',
+  amoprighttype => 'inet', amopstrategy => '27', amopopr => '>>=(inet,inet)',
+  amopmethod => 'gist' },
+
+# SP-GiST inet_ops
+{ amopfamily => 'spgist/network_ops', amoplefttype => 'inet',
+  amoprighttype => 'inet', amopstrategy => '3', amopopr => '&&(inet,inet)',
+  amopmethod => 'spgist' },
+{ amopfamily => 'spgist/network_ops', amoplefttype => 'inet',
+  amoprighttype => 'inet', amopstrategy => '18', amopopr => '=(inet,inet)',
+  amopmethod => 'spgist' },
+{ amopfamily => 'spgist/network_ops', amoplefttype => 'inet',
+  amoprighttype => 'inet', amopstrategy => '19', amopopr => '<>(inet,inet)',
+  amopmethod => 'spgist' },
+{ amopfamily => 'spgist/network_ops', amoplefttype => 'inet',
+  amoprighttype => 'inet', amopstrategy => '20', amopopr => '<(inet,inet)',
+  amopmethod => 'spgist' },
+{ amopfamily => 'spgist/network_ops', amoplefttype => 'inet',
+  amoprighttype => 'inet', amopstrategy => '21', amopopr => '<=(inet,inet)',
+  amopmethod => 'spgist' },
+{ amopfamily => 'spgist/network_ops', amoplefttype => 'inet',
+  amoprighttype => 'inet', amopstrategy => '22', amopopr => '>(inet,inet)',
+  amopmethod => 'spgist' },
+{ amopfamily => 'spgist/network_ops', amoplefttype => 'inet',
+  amoprighttype => 'inet', amopstrategy => '23', amopopr => '>=(inet,inet)',
+  amopmethod => 'spgist' },
+{ amopfamily => 'spgist/network_ops', amoplefttype => 'inet',
+  amoprighttype => 'inet', amopstrategy => '24', amopopr => '<<(inet,inet)',
+  amopmethod => 'spgist' },
+{ amopfamily => 'spgist/network_ops', amoplefttype => 'inet',
+  amoprighttype => 'inet', amopstrategy => '25', amopopr => '<<=(inet,inet)',
+  amopmethod => 'spgist' },
+{ amopfamily => 'spgist/network_ops', amoplefttype => 'inet',
+  amoprighttype => 'inet', amopstrategy => '26', amopopr => '>>(inet,inet)',
+  amopmethod => 'spgist' },
+{ amopfamily => 'spgist/network_ops', amoplefttype => 'inet',
+  amoprighttype => 'inet', amopstrategy => '27', amopopr => '>>=(inet,inet)',
+  amopmethod => 'spgist' },
+
+# BRIN opclasses
+
+# minmax bytea
+{ amopfamily => 'brin/bytea_minmax_ops', amoplefttype => 'bytea',
+  amoprighttype => 'bytea', amopstrategy => '1', amopopr => '<(bytea,bytea)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/bytea_minmax_ops', amoplefttype => 'bytea',
+  amoprighttype => 'bytea', amopstrategy => '2', amopopr => '<=(bytea,bytea)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/bytea_minmax_ops', amoplefttype => 'bytea',
+  amoprighttype => 'bytea', amopstrategy => '3', amopopr => '=(bytea,bytea)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/bytea_minmax_ops', amoplefttype => 'bytea',
+  amoprighttype => 'bytea', amopstrategy => '4', amopopr => '>=(bytea,bytea)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/bytea_minmax_ops', amoplefttype => 'bytea',
+  amoprighttype => 'bytea', amopstrategy => '5', amopopr => '>(bytea,bytea)',
+  amopmethod => 'brin' },
+
+# minmax "char"
+{ amopfamily => 'brin/char_minmax_ops', amoplefttype => 'char',
+  amoprighttype => 'char', amopstrategy => '1', amopopr => '<(char,char)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/char_minmax_ops', amoplefttype => 'char',
+  amoprighttype => 'char', amopstrategy => '2', amopopr => '<=(char,char)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/char_minmax_ops', amoplefttype => 'char',
+  amoprighttype => 'char', amopstrategy => '3', amopopr => '=(char,char)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/char_minmax_ops', amoplefttype => 'char',
+  amoprighttype => 'char', amopstrategy => '4', amopopr => '>=(char,char)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/char_minmax_ops', amoplefttype => 'char',
+  amoprighttype => 'char', amopstrategy => '5', amopopr => '>(char,char)',
+  amopmethod => 'brin' },
+
+# minmax name
+{ amopfamily => 'brin/name_minmax_ops', amoplefttype => 'name',
+  amoprighttype => 'name', amopstrategy => '1', amopopr => '<(name,name)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/name_minmax_ops', amoplefttype => 'name',
+  amoprighttype => 'name', amopstrategy => '2', amopopr => '<=(name,name)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/name_minmax_ops', amoplefttype => 'name',
+  amoprighttype => 'name', amopstrategy => '3', amopopr => '=(name,name)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/name_minmax_ops', amoplefttype => 'name',
+  amoprighttype => 'name', amopstrategy => '4', amopopr => '>=(name,name)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/name_minmax_ops', amoplefttype => 'name',
+  amoprighttype => 'name', amopstrategy => '5', amopopr => '>(name,name)',
+  amopmethod => 'brin' },
+
+# minmax integer
+
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int8',
+  amoprighttype => 'int8', amopstrategy => '1', amopopr => '<(int8,int8)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int8',
+  amoprighttype => 'int8', amopstrategy => '2', amopopr => '<=(int8,int8)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int8',
+  amoprighttype => 'int8', amopstrategy => '3', amopopr => '=(int8,int8)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int8',
+  amoprighttype => 'int8', amopstrategy => '4', amopopr => '>=(int8,int8)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int8',
+  amoprighttype => 'int8', amopstrategy => '5', amopopr => '>(int8,int8)',
+  amopmethod => 'brin' },
+
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int8',
+  amoprighttype => 'int2', amopstrategy => '1', amopopr => '<(int8,int2)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int8',
+  amoprighttype => 'int2', amopstrategy => '2', amopopr => '<=(int8,int2)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int8',
+  amoprighttype => 'int2', amopstrategy => '3', amopopr => '=(int8,int2)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int8',
+  amoprighttype => 'int2', amopstrategy => '4', amopopr => '>=(int8,int2)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int8',
+  amoprighttype => 'int2', amopstrategy => '5', amopopr => '>(int8,int2)',
+  amopmethod => 'brin' },
+
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int8',
+  amoprighttype => 'int4', amopstrategy => '1', amopopr => '<(int8,int4)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int8',
+  amoprighttype => 'int4', amopstrategy => '2', amopopr => '<=(int8,int4)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int8',
+  amoprighttype => 'int4', amopstrategy => '3', amopopr => '=(int8,int4)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int8',
+  amoprighttype => 'int4', amopstrategy => '4', amopopr => '>=(int8,int4)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int8',
+  amoprighttype => 'int4', amopstrategy => '5', amopopr => '>(int8,int4)',
+  amopmethod => 'brin' },
+
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int2',
+  amoprighttype => 'int2', amopstrategy => '1', amopopr => '<(int2,int2)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int2',
+  amoprighttype => 'int2', amopstrategy => '2', amopopr => '<=(int2,int2)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int2',
+  amoprighttype => 'int2', amopstrategy => '3', amopopr => '=(int2,int2)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int2',
+  amoprighttype => 'int2', amopstrategy => '4', amopopr => '>=(int2,int2)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int2',
+  amoprighttype => 'int2', amopstrategy => '5', amopopr => '>(int2,int2)',
+  amopmethod => 'brin' },
+
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int2',
+  amoprighttype => 'int8', amopstrategy => '1', amopopr => '<(int2,int8)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int2',
+  amoprighttype => 'int8', amopstrategy => '2', amopopr => '<=(int2,int8)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int2',
+  amoprighttype => 'int8', amopstrategy => '3', amopopr => '=(int2,int8)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int2',
+  amoprighttype => 'int8', amopstrategy => '4', amopopr => '>=(int2,int8)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int2',
+  amoprighttype => 'int8', amopstrategy => '5', amopopr => '>(int2,int8)',
+  amopmethod => 'brin' },
+
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int2',
+  amoprighttype => 'int4', amopstrategy => '1', amopopr => '<(int2,int4)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int2',
+  amoprighttype => 'int4', amopstrategy => '2', amopopr => '<=(int2,int4)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int2',
+  amoprighttype => 'int4', amopstrategy => '3', amopopr => '=(int2,int4)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int2',
+  amoprighttype => 'int4', amopstrategy => '4', amopopr => '>=(int2,int4)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int2',
+  amoprighttype => 'int4', amopstrategy => '5', amopopr => '>(int2,int4)',
+  amopmethod => 'brin' },
+
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int4',
+  amoprighttype => 'int4', amopstrategy => '1', amopopr => '<(int4,int4)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int4',
+  amoprighttype => 'int4', amopstrategy => '2', amopopr => '<=(int4,int4)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int4',
+  amoprighttype => 'int4', amopstrategy => '3', amopopr => '=(int4,int4)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int4',
+  amoprighttype => 'int4', amopstrategy => '4', amopopr => '>=(int4,int4)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int4',
+  amoprighttype => 'int4', amopstrategy => '5', amopopr => '>(int4,int4)',
+  amopmethod => 'brin' },
+
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int4',
+  amoprighttype => 'int2', amopstrategy => '1', amopopr => '<(int4,int2)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int4',
+  amoprighttype => 'int2', amopstrategy => '2', amopopr => '<=(int4,int2)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int4',
+  amoprighttype => 'int2', amopstrategy => '3', amopopr => '=(int4,int2)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int4',
+  amoprighttype => 'int2', amopstrategy => '4', amopopr => '>=(int4,int2)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int4',
+  amoprighttype => 'int2', amopstrategy => '5', amopopr => '>(int4,int2)',
+  amopmethod => 'brin' },
+
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int4',
+  amoprighttype => 'int8', amopstrategy => '1', amopopr => '<(int4,int8)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int4',
+  amoprighttype => 'int8', amopstrategy => '2', amopopr => '<=(int4,int8)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int4',
+  amoprighttype => 'int8', amopstrategy => '3', amopopr => '=(int4,int8)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int4',
+  amoprighttype => 'int8', amopstrategy => '4', amopopr => '>=(int4,int8)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int4',
+  amoprighttype => 'int8', amopstrategy => '5', amopopr => '>(int4,int8)',
+  amopmethod => 'brin' },
+
+# minmax text
+{ amopfamily => 'brin/text_minmax_ops', amoplefttype => 'text',
+  amoprighttype => 'text', amopstrategy => '1', amopopr => '<(text,text)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/text_minmax_ops', amoplefttype => 'text',
+  amoprighttype => 'text', amopstrategy => '2', amopopr => '<=(text,text)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/text_minmax_ops', amoplefttype => 'text',
+  amoprighttype => 'text', amopstrategy => '3', amopopr => '=(text,text)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/text_minmax_ops', amoplefttype => 'text',
+  amoprighttype => 'text', amopstrategy => '4', amopopr => '>=(text,text)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/text_minmax_ops', amoplefttype => 'text',
+  amoprighttype => 'text', amopstrategy => '5', amopopr => '>(text,text)',
+  amopmethod => 'brin' },
+
+# minmax oid
+{ amopfamily => 'brin/oid_minmax_ops', amoplefttype => 'oid',
+  amoprighttype => 'oid', amopstrategy => '1', amopopr => '<(oid,oid)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/oid_minmax_ops', amoplefttype => 'oid',
+  amoprighttype => 'oid', amopstrategy => '2', amopopr => '<=(oid,oid)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/oid_minmax_ops', amoplefttype => 'oid',
+  amoprighttype => 'oid', amopstrategy => '3', amopopr => '=(oid,oid)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/oid_minmax_ops', amoplefttype => 'oid',
+  amoprighttype => 'oid', amopstrategy => '4', amopopr => '>=(oid,oid)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/oid_minmax_ops', amoplefttype => 'oid',
+  amoprighttype => 'oid', amopstrategy => '5', amopopr => '>(oid,oid)',
+  amopmethod => 'brin' },
+
+# minmax tid
+{ amopfamily => 'brin/tid_minmax_ops', amoplefttype => 'tid',
+  amoprighttype => 'tid', amopstrategy => '1', amopopr => '<(tid,tid)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/tid_minmax_ops', amoplefttype => 'tid',
+  amoprighttype => 'tid', amopstrategy => '2', amopopr => '<=(tid,tid)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/tid_minmax_ops', amoplefttype => 'tid',
+  amoprighttype => 'tid', amopstrategy => '3', amopopr => '=(tid,tid)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/tid_minmax_ops', amoplefttype => 'tid',
+  amoprighttype => 'tid', amopstrategy => '4', amopopr => '>=(tid,tid)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/tid_minmax_ops', amoplefttype => 'tid',
+  amoprighttype => 'tid', amopstrategy => '5', amopopr => '>(tid,tid)',
+  amopmethod => 'brin' },
+
+# minmax float (float4, float8)
+
+{ amopfamily => 'brin/float_minmax_ops', amoplefttype => 'float4',
+  amoprighttype => 'float4', amopstrategy => '1', amopopr => '<(float4,float4)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/float_minmax_ops', amoplefttype => 'float4',
+  amoprighttype => 'float4', amopstrategy => '2',
+  amopopr => '<=(float4,float4)', amopmethod => 'brin' },
+{ amopfamily => 'brin/float_minmax_ops', amoplefttype => 'float4',
+  amoprighttype => 'float4', amopstrategy => '3', amopopr => '=(float4,float4)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/float_minmax_ops', amoplefttype => 'float4',
+  amoprighttype => 'float4', amopstrategy => '4',
+  amopopr => '>=(float4,float4)', amopmethod => 'brin' },
+{ amopfamily => 'brin/float_minmax_ops', amoplefttype => 'float4',
+  amoprighttype => 'float4', amopstrategy => '5', amopopr => '>(float4,float4)',
+  amopmethod => 'brin' },
+
+{ amopfamily => 'brin/float_minmax_ops', amoplefttype => 'float4',
+  amoprighttype => 'float8', amopstrategy => '1', amopopr => '<(float4,float8)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/float_minmax_ops', amoplefttype => 'float4',
+  amoprighttype => 'float8', amopstrategy => '2',
+  amopopr => '<=(float4,float8)', amopmethod => 'brin' },
+{ amopfamily => 'brin/float_minmax_ops', amoplefttype => 'float4',
+  amoprighttype => 'float8', amopstrategy => '3', amopopr => '=(float4,float8)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/float_minmax_ops', amoplefttype => 'float4',
+  amoprighttype => 'float8', amopstrategy => '4',
+  amopopr => '>=(float4,float8)', amopmethod => 'brin' },
+{ amopfamily => 'brin/float_minmax_ops', amoplefttype => 'float4',
+  amoprighttype => 'float8', amopstrategy => '5', amopopr => '>(float4,float8)',
+  amopmethod => 'brin' },
+
+{ amopfamily => 'brin/float_minmax_ops', amoplefttype => 'float8',
+  amoprighttype => 'float4', amopstrategy => '1', amopopr => '<(float8,float4)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/float_minmax_ops', amoplefttype => 'float8',
+  amoprighttype => 'float4', amopstrategy => '2',
+  amopopr => '<=(float8,float4)', amopmethod => 'brin' },
+{ amopfamily => 'brin/float_minmax_ops', amoplefttype => 'float8',
+  amoprighttype => 'float4', amopstrategy => '3', amopopr => '=(float8,float4)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/float_minmax_ops', amoplefttype => 'float8',
+  amoprighttype => 'float4', amopstrategy => '4',
+  amopopr => '>=(float8,float4)', amopmethod => 'brin' },
+{ amopfamily => 'brin/float_minmax_ops', amoplefttype => 'float8',
+  amoprighttype => 'float4', amopstrategy => '5', amopopr => '>(float8,float4)',
+  amopmethod => 'brin' },
+
+{ amopfamily => 'brin/float_minmax_ops', amoplefttype => 'float8',
+  amoprighttype => 'float8', amopstrategy => '1', amopopr => '<(float8,float8)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/float_minmax_ops', amoplefttype => 'float8',
+  amoprighttype => 'float8', amopstrategy => '2',
+  amopopr => '<=(float8,float8)', amopmethod => 'brin' },
+{ amopfamily => 'brin/float_minmax_ops', amoplefttype => 'float8',
+  amoprighttype => 'float8', amopstrategy => '3', amopopr => '=(float8,float8)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/float_minmax_ops', amoplefttype => 'float8',
+  amoprighttype => 'float8', amopstrategy => '4',
+  amopopr => '>=(float8,float8)', amopmethod => 'brin' },
+{ amopfamily => 'brin/float_minmax_ops', amoplefttype => 'float8',
+  amoprighttype => 'float8', amopstrategy => '5', amopopr => '>(float8,float8)',
+  amopmethod => 'brin' },
+
+# minmax macaddr
+{ amopfamily => 'brin/macaddr_minmax_ops', amoplefttype => 'macaddr',
+  amoprighttype => 'macaddr', amopstrategy => '1',
+  amopopr => '<(macaddr,macaddr)', amopmethod => 'brin' },
+{ amopfamily => 'brin/macaddr_minmax_ops', amoplefttype => 'macaddr',
+  amoprighttype => 'macaddr', amopstrategy => '2',
+  amopopr => '<=(macaddr,macaddr)', amopmethod => 'brin' },
+{ amopfamily => 'brin/macaddr_minmax_ops', amoplefttype => 'macaddr',
+  amoprighttype => 'macaddr', amopstrategy => '3',
+  amopopr => '=(macaddr,macaddr)', amopmethod => 'brin' },
+{ amopfamily => 'brin/macaddr_minmax_ops', amoplefttype => 'macaddr',
+  amoprighttype => 'macaddr', amopstrategy => '4',
+  amopopr => '>=(macaddr,macaddr)', amopmethod => 'brin' },
+{ amopfamily => 'brin/macaddr_minmax_ops', amoplefttype => 'macaddr',
+  amoprighttype => 'macaddr', amopstrategy => '5',
+  amopopr => '>(macaddr,macaddr)', amopmethod => 'brin' },
+
+# minmax macaddr8
+{ amopfamily => 'brin/macaddr8_minmax_ops', amoplefttype => 'macaddr8',
+  amoprighttype => 'macaddr8', amopstrategy => '1',
+  amopopr => '<(macaddr8,macaddr8)', amopmethod => 'brin' },
+{ amopfamily => 'brin/macaddr8_minmax_ops', amoplefttype => 'macaddr8',
+  amoprighttype => 'macaddr8', amopstrategy => '2',
+  amopopr => '<=(macaddr8,macaddr8)', amopmethod => 'brin' },
+{ amopfamily => 'brin/macaddr8_minmax_ops', amoplefttype => 'macaddr8',
+  amoprighttype => 'macaddr8', amopstrategy => '3',
+  amopopr => '=(macaddr8,macaddr8)', amopmethod => 'brin' },
+{ amopfamily => 'brin/macaddr8_minmax_ops', amoplefttype => 'macaddr8',
+  amoprighttype => 'macaddr8', amopstrategy => '4',
+  amopopr => '>=(macaddr8,macaddr8)', amopmethod => 'brin' },
+{ amopfamily => 'brin/macaddr8_minmax_ops', amoplefttype => 'macaddr8',
+  amoprighttype => 'macaddr8', amopstrategy => '5',
+  amopopr => '>(macaddr8,macaddr8)', amopmethod => 'brin' },
+
+# minmax inet
+{ amopfamily => 'brin/network_minmax_ops', amoplefttype => 'inet',
+  amoprighttype => 'inet', amopstrategy => '1', amopopr => '<(inet,inet)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/network_minmax_ops', amoplefttype => 'inet',
+  amoprighttype => 'inet', amopstrategy => '2', amopopr => '<=(inet,inet)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/network_minmax_ops', amoplefttype => 'inet',
+  amoprighttype => 'inet', amopstrategy => '3', amopopr => '=(inet,inet)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/network_minmax_ops', amoplefttype => 'inet',
+  amoprighttype => 'inet', amopstrategy => '4', amopopr => '>=(inet,inet)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/network_minmax_ops', amoplefttype => 'inet',
+  amoprighttype => 'inet', amopstrategy => '5', amopopr => '>(inet,inet)',
+  amopmethod => 'brin' },
+
+# inclusion inet
+{ amopfamily => 'brin/network_inclusion_ops', amoplefttype => 'inet',
+  amoprighttype => 'inet', amopstrategy => '3', amopopr => '&&(inet,inet)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/network_inclusion_ops', amoplefttype => 'inet',
+  amoprighttype => 'inet', amopstrategy => '7', amopopr => '>>=(inet,inet)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/network_inclusion_ops', amoplefttype => 'inet',
+  amoprighttype => 'inet', amopstrategy => '8', amopopr => '<<=(inet,inet)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/network_inclusion_ops', amoplefttype => 'inet',
+  amoprighttype => 'inet', amopstrategy => '18', amopopr => '=(inet,inet)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/network_inclusion_ops', amoplefttype => 'inet',
+  amoprighttype => 'inet', amopstrategy => '24', amopopr => '>>(inet,inet)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/network_inclusion_ops', amoplefttype => 'inet',
+  amoprighttype => 'inet', amopstrategy => '26', amopopr => '<<(inet,inet)',
+  amopmethod => 'brin' },
+
+# minmax character
+{ amopfamily => 'brin/bpchar_minmax_ops', amoplefttype => 'bpchar',
+  amoprighttype => 'bpchar', amopstrategy => '1', amopopr => '<(bpchar,bpchar)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/bpchar_minmax_ops', amoplefttype => 'bpchar',
+  amoprighttype => 'bpchar', amopstrategy => '2',
+  amopopr => '<=(bpchar,bpchar)', amopmethod => 'brin' },
+{ amopfamily => 'brin/bpchar_minmax_ops', amoplefttype => 'bpchar',
+  amoprighttype => 'bpchar', amopstrategy => '3', amopopr => '=(bpchar,bpchar)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/bpchar_minmax_ops', amoplefttype => 'bpchar',
+  amoprighttype => 'bpchar', amopstrategy => '4',
+  amopopr => '>=(bpchar,bpchar)', amopmethod => 'brin' },
+{ amopfamily => 'brin/bpchar_minmax_ops', amoplefttype => 'bpchar',
+  amoprighttype => 'bpchar', amopstrategy => '5', amopopr => '>(bpchar,bpchar)',
+  amopmethod => 'brin' },
+
+# minmax time without time zone
+{ amopfamily => 'brin/time_minmax_ops', amoplefttype => 'time',
+  amoprighttype => 'time', amopstrategy => '1', amopopr => '<(time,time)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/time_minmax_ops', amoplefttype => 'time',
+  amoprighttype => 'time', amopstrategy => '2', amopopr => '<=(time,time)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/time_minmax_ops', amoplefttype => 'time',
+  amoprighttype => 'time', amopstrategy => '3', amopopr => '=(time,time)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/time_minmax_ops', amoplefttype => 'time',
+  amoprighttype => 'time', amopstrategy => '4', amopopr => '>=(time,time)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/time_minmax_ops', amoplefttype => 'time',
+  amoprighttype => 'time', amopstrategy => '5', amopopr => '>(time,time)',
+  amopmethod => 'brin' },
+
+# minmax datetime (date, timestamp, timestamptz)
+
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamp',
+  amoprighttype => 'timestamp', amopstrategy => '1',
+  amopopr => '<(timestamp,timestamp)', amopmethod => 'brin' },
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamp',
+  amoprighttype => 'timestamp', amopstrategy => '2',
+  amopopr => '<=(timestamp,timestamp)', amopmethod => 'brin' },
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamp',
+  amoprighttype => 'timestamp', amopstrategy => '3',
+  amopopr => '=(timestamp,timestamp)', amopmethod => 'brin' },
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamp',
+  amoprighttype => 'timestamp', amopstrategy => '4',
+  amopopr => '>=(timestamp,timestamp)', amopmethod => 'brin' },
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamp',
+  amoprighttype => 'timestamp', amopstrategy => '5',
+  amopopr => '>(timestamp,timestamp)', amopmethod => 'brin' },
+
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamp',
+  amoprighttype => 'date', amopstrategy => '1', amopopr => '<(timestamp,date)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamp',
+  amoprighttype => 'date', amopstrategy => '2', amopopr => '<=(timestamp,date)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamp',
+  amoprighttype => 'date', amopstrategy => '3', amopopr => '=(timestamp,date)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamp',
+  amoprighttype => 'date', amopstrategy => '4', amopopr => '>=(timestamp,date)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamp',
+  amoprighttype => 'date', amopstrategy => '5', amopopr => '>(timestamp,date)',
+  amopmethod => 'brin' },
+
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamp',
+  amoprighttype => 'timestamptz', amopstrategy => '1',
+  amopopr => '<(timestamp,timestamptz)', amopmethod => 'brin' },
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamp',
+  amoprighttype => 'timestamptz', amopstrategy => '2',
+  amopopr => '<=(timestamp,timestamptz)', amopmethod => 'brin' },
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamp',
+  amoprighttype => 'timestamptz', amopstrategy => '3',
+  amopopr => '=(timestamp,timestamptz)', amopmethod => 'brin' },
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamp',
+  amoprighttype => 'timestamptz', amopstrategy => '4',
+  amopopr => '>=(timestamp,timestamptz)', amopmethod => 'brin' },
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamp',
+  amoprighttype => 'timestamptz', amopstrategy => '5',
+  amopopr => '>(timestamp,timestamptz)', amopmethod => 'brin' },
+
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'date',
+  amoprighttype => 'date', amopstrategy => '1', amopopr => '<(date,date)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'date',
+  amoprighttype => 'date', amopstrategy => '2', amopopr => '<=(date,date)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'date',
+  amoprighttype => 'date', amopstrategy => '3', amopopr => '=(date,date)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'date',
+  amoprighttype => 'date', amopstrategy => '4', amopopr => '>=(date,date)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'date',
+  amoprighttype => 'date', amopstrategy => '5', amopopr => '>(date,date)',
+  amopmethod => 'brin' },
+
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'date',
+  amoprighttype => 'timestamp', amopstrategy => '1',
+  amopopr => '<(date,timestamp)', amopmethod => 'brin' },
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'date',
+  amoprighttype => 'timestamp', amopstrategy => '2',
+  amopopr => '<=(date,timestamp)', amopmethod => 'brin' },
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'date',
+  amoprighttype => 'timestamp', amopstrategy => '3',
+  amopopr => '=(date,timestamp)', amopmethod => 'brin' },
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'date',
+  amoprighttype => 'timestamp', amopstrategy => '4',
+  amopopr => '>=(date,timestamp)', amopmethod => 'brin' },
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'date',
+  amoprighttype => 'timestamp', amopstrategy => '5',
+  amopopr => '>(date,timestamp)', amopmethod => 'brin' },
+
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'date',
+  amoprighttype => 'timestamptz', amopstrategy => '1',
+  amopopr => '<(date,timestamptz)', amopmethod => 'brin' },
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'date',
+  amoprighttype => 'timestamptz', amopstrategy => '2',
+  amopopr => '<=(date,timestamptz)', amopmethod => 'brin' },
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'date',
+  amoprighttype => 'timestamptz', amopstrategy => '3',
+  amopopr => '=(date,timestamptz)', amopmethod => 'brin' },
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'date',
+  amoprighttype => 'timestamptz', amopstrategy => '4',
+  amopopr => '>=(date,timestamptz)', amopmethod => 'brin' },
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'date',
+  amoprighttype => 'timestamptz', amopstrategy => '5',
+  amopopr => '>(date,timestamptz)', amopmethod => 'brin' },
+
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamptz',
+  amoprighttype => 'date', amopstrategy => '1',
+  amopopr => '<(timestamptz,date)', amopmethod => 'brin' },
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamptz',
+  amoprighttype => 'date', amopstrategy => '2',
+  amopopr => '<=(timestamptz,date)', amopmethod => 'brin' },
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamptz',
+  amoprighttype => 'date', amopstrategy => '3',
+  amopopr => '=(timestamptz,date)', amopmethod => 'brin' },
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamptz',
+  amoprighttype => 'date', amopstrategy => '4',
+  amopopr => '>=(timestamptz,date)', amopmethod => 'brin' },
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamptz',
+  amoprighttype => 'date', amopstrategy => '5',
+  amopopr => '>(timestamptz,date)', amopmethod => 'brin' },
+
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamptz',
+  amoprighttype => 'timestamp', amopstrategy => '1',
+  amopopr => '<(timestamptz,timestamp)', amopmethod => 'brin' },
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamptz',
+  amoprighttype => 'timestamp', amopstrategy => '2',
+  amopopr => '<=(timestamptz,timestamp)', amopmethod => 'brin' },
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamptz',
+  amoprighttype => 'timestamp', amopstrategy => '3',
+  amopopr => '=(timestamptz,timestamp)', amopmethod => 'brin' },
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamptz',
+  amoprighttype => 'timestamp', amopstrategy => '4',
+  amopopr => '>=(timestamptz,timestamp)', amopmethod => 'brin' },
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamptz',
+  amoprighttype => 'timestamp', amopstrategy => '5',
+  amopopr => '>(timestamptz,timestamp)', amopmethod => 'brin' },
+
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamptz',
+  amoprighttype => 'timestamptz', amopstrategy => '1',
+  amopopr => '<(timestamptz,timestamptz)', amopmethod => 'brin' },
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamptz',
+  amoprighttype => 'timestamptz', amopstrategy => '2',
+  amopopr => '<=(timestamptz,timestamptz)', amopmethod => 'brin' },
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamptz',
+  amoprighttype => 'timestamptz', amopstrategy => '3',
+  amopopr => '=(timestamptz,timestamptz)', amopmethod => 'brin' },
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamptz',
+  amoprighttype => 'timestamptz', amopstrategy => '4',
+  amopopr => '>=(timestamptz,timestamptz)', amopmethod => 'brin' },
+{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamptz',
+  amoprighttype => 'timestamptz', amopstrategy => '5',
+  amopopr => '>(timestamptz,timestamptz)', amopmethod => 'brin' },
+
+# minmax interval
+{ amopfamily => 'brin/interval_minmax_ops', amoplefttype => 'interval',
+  amoprighttype => 'interval', amopstrategy => '1',
+  amopopr => '<(interval,interval)', amopmethod => 'brin' },
+{ amopfamily => 'brin/interval_minmax_ops', amoplefttype => 'interval',
+  amoprighttype => 'interval', amopstrategy => '2',
+  amopopr => '<=(interval,interval)', amopmethod => 'brin' },
+{ amopfamily => 'brin/interval_minmax_ops', amoplefttype => 'interval',
+  amoprighttype => 'interval', amopstrategy => '3',
+  amopopr => '=(interval,interval)', amopmethod => 'brin' },
+{ amopfamily => 'brin/interval_minmax_ops', amoplefttype => 'interval',
+  amoprighttype => 'interval', amopstrategy => '4',
+  amopopr => '>=(interval,interval)', amopmethod => 'brin' },
+{ amopfamily => 'brin/interval_minmax_ops', amoplefttype => 'interval',
+  amoprighttype => 'interval', amopstrategy => '5',
+  amopopr => '>(interval,interval)', amopmethod => 'brin' },
+
+# minmax time with time zone
+{ amopfamily => 'brin/timetz_minmax_ops', amoplefttype => 'timetz',
+  amoprighttype => 'timetz', amopstrategy => '1', amopopr => '<(timetz,timetz)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/timetz_minmax_ops', amoplefttype => 'timetz',
+  amoprighttype => 'timetz', amopstrategy => '2',
+  amopopr => '<=(timetz,timetz)', amopmethod => 'brin' },
+{ amopfamily => 'brin/timetz_minmax_ops', amoplefttype => 'timetz',
+  amoprighttype => 'timetz', amopstrategy => '3', amopopr => '=(timetz,timetz)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/timetz_minmax_ops', amoplefttype => 'timetz',
+  amoprighttype => 'timetz', amopstrategy => '4',
+  amopopr => '>=(timetz,timetz)', amopmethod => 'brin' },
+{ amopfamily => 'brin/timetz_minmax_ops', amoplefttype => 'timetz',
+  amoprighttype => 'timetz', amopstrategy => '5', amopopr => '>(timetz,timetz)',
+  amopmethod => 'brin' },
+
+# minmax bit
+{ amopfamily => 'brin/bit_minmax_ops', amoplefttype => 'bit',
+  amoprighttype => 'bit', amopstrategy => '1', amopopr => '<(bit,bit)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/bit_minmax_ops', amoplefttype => 'bit',
+  amoprighttype => 'bit', amopstrategy => '2', amopopr => '<=(bit,bit)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/bit_minmax_ops', amoplefttype => 'bit',
+  amoprighttype => 'bit', amopstrategy => '3', amopopr => '=(bit,bit)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/bit_minmax_ops', amoplefttype => 'bit',
+  amoprighttype => 'bit', amopstrategy => '4', amopopr => '>=(bit,bit)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/bit_minmax_ops', amoplefttype => 'bit',
+  amoprighttype => 'bit', amopstrategy => '5', amopopr => '>(bit,bit)',
+  amopmethod => 'brin' },
+
+# minmax bit varying
+{ amopfamily => 'brin/varbit_minmax_ops', amoplefttype => 'varbit',
+  amoprighttype => 'varbit', amopstrategy => '1', amopopr => '<(varbit,varbit)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/varbit_minmax_ops', amoplefttype => 'varbit',
+  amoprighttype => 'varbit', amopstrategy => '2',
+  amopopr => '<=(varbit,varbit)', amopmethod => 'brin' },
+{ amopfamily => 'brin/varbit_minmax_ops', amoplefttype => 'varbit',
+  amoprighttype => 'varbit', amopstrategy => '3', amopopr => '=(varbit,varbit)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/varbit_minmax_ops', amoplefttype => 'varbit',
+  amoprighttype => 'varbit', amopstrategy => '4',
+  amopopr => '>=(varbit,varbit)', amopmethod => 'brin' },
+{ amopfamily => 'brin/varbit_minmax_ops', amoplefttype => 'varbit',
+  amoprighttype => 'varbit', amopstrategy => '5', amopopr => '>(varbit,varbit)',
+  amopmethod => 'brin' },
+
+# minmax numeric
+{ amopfamily => 'brin/numeric_minmax_ops', amoplefttype => 'numeric',
+  amoprighttype => 'numeric', amopstrategy => '1',
+  amopopr => '<(numeric,numeric)', amopmethod => 'brin' },
+{ amopfamily => 'brin/numeric_minmax_ops', amoplefttype => 'numeric',
+  amoprighttype => 'numeric', amopstrategy => '2',
+  amopopr => '<=(numeric,numeric)', amopmethod => 'brin' },
+{ amopfamily => 'brin/numeric_minmax_ops', amoplefttype => 'numeric',
+  amoprighttype => 'numeric', amopstrategy => '3',
+  amopopr => '=(numeric,numeric)', amopmethod => 'brin' },
+{ amopfamily => 'brin/numeric_minmax_ops', amoplefttype => 'numeric',
+  amoprighttype => 'numeric', amopstrategy => '4',
+  amopopr => '>=(numeric,numeric)', amopmethod => 'brin' },
+{ amopfamily => 'brin/numeric_minmax_ops', amoplefttype => 'numeric',
+  amoprighttype => 'numeric', amopstrategy => '5',
+  amopopr => '>(numeric,numeric)', amopmethod => 'brin' },
+
+# minmax uuid
+{ amopfamily => 'brin/uuid_minmax_ops', amoplefttype => 'uuid',
+  amoprighttype => 'uuid', amopstrategy => '1', amopopr => '<(uuid,uuid)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/uuid_minmax_ops', amoplefttype => 'uuid',
+  amoprighttype => 'uuid', amopstrategy => '2', amopopr => '<=(uuid,uuid)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/uuid_minmax_ops', amoplefttype => 'uuid',
+  amoprighttype => 'uuid', amopstrategy => '3', amopopr => '=(uuid,uuid)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/uuid_minmax_ops', amoplefttype => 'uuid',
+  amoprighttype => 'uuid', amopstrategy => '4', amopopr => '>=(uuid,uuid)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/uuid_minmax_ops', amoplefttype => 'uuid',
+  amoprighttype => 'uuid', amopstrategy => '5', amopopr => '>(uuid,uuid)',
+  amopmethod => 'brin' },
+
+# inclusion range types
+{ amopfamily => 'brin/range_inclusion_ops', amoplefttype => 'anyrange',
+  amoprighttype => 'anyrange', amopstrategy => '1',
+  amopopr => '<<(anyrange,anyrange)', amopmethod => 'brin' },
+{ amopfamily => 'brin/range_inclusion_ops', amoplefttype => 'anyrange',
+  amoprighttype => 'anyrange', amopstrategy => '2',
+  amopopr => '&<(anyrange,anyrange)', amopmethod => 'brin' },
+{ amopfamily => 'brin/range_inclusion_ops', amoplefttype => 'anyrange',
+  amoprighttype => 'anyrange', amopstrategy => '3',
+  amopopr => '&&(anyrange,anyrange)', amopmethod => 'brin' },
+{ amopfamily => 'brin/range_inclusion_ops', amoplefttype => 'anyrange',
+  amoprighttype => 'anyrange', amopstrategy => '4',
+  amopopr => '&>(anyrange,anyrange)', amopmethod => 'brin' },
+{ amopfamily => 'brin/range_inclusion_ops', amoplefttype => 'anyrange',
+  amoprighttype => 'anyrange', amopstrategy => '5',
+  amopopr => '>>(anyrange,anyrange)', amopmethod => 'brin' },
+{ amopfamily => 'brin/range_inclusion_ops', amoplefttype => 'anyrange',
+  amoprighttype => 'anyrange', amopstrategy => '7',
+  amopopr => '@>(anyrange,anyrange)', amopmethod => 'brin' },
+{ amopfamily => 'brin/range_inclusion_ops', amoplefttype => 'anyrange',
+  amoprighttype => 'anyrange', amopstrategy => '8',
+  amopopr => '<@(anyrange,anyrange)', amopmethod => 'brin' },
+{ amopfamily => 'brin/range_inclusion_ops', amoplefttype => 'anyrange',
+  amoprighttype => 'anyelement', amopstrategy => '16',
+  amopopr => '@>(anyrange,anyelement)', amopmethod => 'brin' },
+{ amopfamily => 'brin/range_inclusion_ops', amoplefttype => 'anyrange',
+  amoprighttype => 'anyrange', amopstrategy => '17',
+  amopopr => '-|-(anyrange,anyrange)', amopmethod => 'brin' },
+{ amopfamily => 'brin/range_inclusion_ops', amoplefttype => 'anyrange',
+  amoprighttype => 'anyrange', amopstrategy => '18',
+  amopopr => '=(anyrange,anyrange)', amopmethod => 'brin' },
+{ amopfamily => 'brin/range_inclusion_ops', amoplefttype => 'anyrange',
+  amoprighttype => 'anyrange', amopstrategy => '20',
+  amopopr => '<(anyrange,anyrange)', amopmethod => 'brin' },
+{ amopfamily => 'brin/range_inclusion_ops', amoplefttype => 'anyrange',
+  amoprighttype => 'anyrange', amopstrategy => '21',
+  amopopr => '<=(anyrange,anyrange)', amopmethod => 'brin' },
+{ amopfamily => 'brin/range_inclusion_ops', amoplefttype => 'anyrange',
+  amoprighttype => 'anyrange', amopstrategy => '22',
+  amopopr => '>(anyrange,anyrange)', amopmethod => 'brin' },
+{ amopfamily => 'brin/range_inclusion_ops', amoplefttype => 'anyrange',
+  amoprighttype => 'anyrange', amopstrategy => '23',
+  amopopr => '>=(anyrange,anyrange)', amopmethod => 'brin' },
+
+# minmax pg_lsn
+{ amopfamily => 'brin/pg_lsn_minmax_ops', amoplefttype => 'pg_lsn',
+  amoprighttype => 'pg_lsn', amopstrategy => '1', amopopr => '<(pg_lsn,pg_lsn)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/pg_lsn_minmax_ops', amoplefttype => 'pg_lsn',
+  amoprighttype => 'pg_lsn', amopstrategy => '2',
+  amopopr => '<=(pg_lsn,pg_lsn)', amopmethod => 'brin' },
+{ amopfamily => 'brin/pg_lsn_minmax_ops', amoplefttype => 'pg_lsn',
+  amoprighttype => 'pg_lsn', amopstrategy => '3', amopopr => '=(pg_lsn,pg_lsn)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/pg_lsn_minmax_ops', amoplefttype => 'pg_lsn',
+  amoprighttype => 'pg_lsn', amopstrategy => '4',
+  amopopr => '>=(pg_lsn,pg_lsn)', amopmethod => 'brin' },
+{ amopfamily => 'brin/pg_lsn_minmax_ops', amoplefttype => 'pg_lsn',
+  amoprighttype => 'pg_lsn', amopstrategy => '5', amopopr => '>(pg_lsn,pg_lsn)',
+  amopmethod => 'brin' },
+
+# inclusion box
+{ amopfamily => 'brin/box_inclusion_ops', amoplefttype => 'box',
+  amoprighttype => 'box', amopstrategy => '1', amopopr => '<<(box,box)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/box_inclusion_ops', amoplefttype => 'box',
+  amoprighttype => 'box', amopstrategy => '2', amopopr => '&<(box,box)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/box_inclusion_ops', amoplefttype => 'box',
+  amoprighttype => 'box', amopstrategy => '3', amopopr => '&&(box,box)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/box_inclusion_ops', amoplefttype => 'box',
+  amoprighttype => 'box', amopstrategy => '4', amopopr => '&>(box,box)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/box_inclusion_ops', amoplefttype => 'box',
+  amoprighttype => 'box', amopstrategy => '5', amopopr => '>>(box,box)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/box_inclusion_ops', amoplefttype => 'box',
+  amoprighttype => 'box', amopstrategy => '6', amopopr => '~=(box,box)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/box_inclusion_ops', amoplefttype => 'box',
+  amoprighttype => 'box', amopstrategy => '7', amopopr => '@>(box,box)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/box_inclusion_ops', amoplefttype => 'box',
+  amoprighttype => 'box', amopstrategy => '8', amopopr => '<@(box,box)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/box_inclusion_ops', amoplefttype => 'box',
+  amoprighttype => 'box', amopstrategy => '9', amopopr => '&<|(box,box)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/box_inclusion_ops', amoplefttype => 'box',
+  amoprighttype => 'box', amopstrategy => '10', amopopr => '<<|(box,box)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/box_inclusion_ops', amoplefttype => 'box',
+  amoprighttype => 'box', amopstrategy => '11', amopopr => '|>>(box,box)',
+  amopmethod => 'brin' },
+{ amopfamily => 'brin/box_inclusion_ops', amoplefttype => 'box',
+  amoprighttype => 'box', amopstrategy => '12', amopopr => '|&>(box,box)',
+  amopmethod => 'brin' },
+
+# we could, but choose not to, supply entries for strategies 13 and 14
+
+{ amopfamily => 'brin/box_inclusion_ops', amoplefttype => 'box',
+  amoprighttype => 'point', amopstrategy => '7', amopopr => '@>(box,point)',
+  amopmethod => 'brin' },
+
+]
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_amop.h b/contrib/libs/postgresql/src/include/catalog/pg_amop.h
new file mode 100644
index 0000000000..81a7eb6049
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_amop.h
@@ -0,0 +1,98 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_amop.h
+ *	  definition of the "access method operator" system catalog (pg_amop)
+ *
+ * The amop table identifies the operators associated with each index operator
+ * family and operator class (classes are subsets of families).  An associated
+ * operator can be either a search operator or an ordering operator, as
+ * identified by amoppurpose.
+ *
+ * The primary key for this table is <amopfamily, amoplefttype, amoprighttype,
+ * amopstrategy>.  amoplefttype and amoprighttype are just copies of the
+ * operator's oprleft/oprright, ie its declared input data types.  The
+ * "default" operators for a particular opclass within the family are those
+ * with amoplefttype = amoprighttype = opclass's opcintype.  An opfamily may
+ * also contain other operators, typically cross-data-type operators.  All the
+ * operators within a family are supposed to be compatible, in a way that is
+ * defined by each individual index AM.
+ *
+ * We also keep a unique index on <amopopr, amoppurpose, amopfamily>, so that
+ * we can use a syscache to quickly answer questions of the form "is this
+ * operator in this opfamily, and if so what are its semantics with respect to
+ * the family?"  This implies that the same operator cannot be listed for
+ * multiple strategy numbers within a single opfamily, with the exception that
+ * it's possible to list it for both search and ordering purposes (with
+ * different strategy numbers for the two purposes).
+ *
+ * amopmethod is a copy of the owning opfamily's opfmethod field.  This is an
+ * intentional denormalization of the catalogs to buy lookup speed.
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_amop.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_AMOP_H
+#define PG_AMOP_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_amop_d.h"
+
+/* ----------------
+ *		pg_amop definition.  cpp turns this into
+ *		typedef struct FormData_pg_amop
+ * ----------------
+ */
+CATALOG(pg_amop,2602,AccessMethodOperatorRelationId)
+{
+	Oid			oid;			/* oid */
+
+	/* the index opfamily this entry is for */
+	Oid			amopfamily BKI_LOOKUP(pg_opfamily);
+
+	/* operator's left input data type */
+	Oid			amoplefttype BKI_LOOKUP(pg_type);
+
+	/* operator's right input data type */
+	Oid			amoprighttype BKI_LOOKUP(pg_type);
+
+	/* operator strategy number */
+	int16		amopstrategy;
+
+	/* is operator for 's'earch or 'o'rdering? */
+	char		amoppurpose BKI_DEFAULT(s);
+
+	/* the operator's pg_operator OID */
+	Oid			amopopr BKI_LOOKUP(pg_operator);
+
+	/* the index access method this entry is for */
+	Oid			amopmethod BKI_LOOKUP(pg_am);
+
+	/* ordering opfamily OID, or 0 if search op */
+	Oid			amopsortfamily BKI_DEFAULT(0) BKI_LOOKUP(pg_opfamily);
+} FormData_pg_amop;
+
+/* ----------------
+ *		Form_pg_amop corresponds to a pointer to a tuple with
+ *		the format of pg_amop relation.
+ * ----------------
+ */
+typedef FormData_pg_amop *Form_pg_amop;
+
+#ifdef EXPOSE_TO_CLIENT_CODE
+
+/* allowed values of amoppurpose: */
+#define AMOP_SEARCH		's'		/* operator is for search */
+#define AMOP_ORDER		'o'		/* operator is for ordering */
+
+#endif							/* EXPOSE_TO_CLIENT_CODE */
+
+#endif							/* PG_AMOP_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_amop_d.h b/contrib/libs/postgresql/src/include/catalog/pg_amop_d.h
new file mode 100644
index 0000000000..3bf63b84c4
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_amop_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_amop_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_amproc.dat b/contrib/libs/postgresql/src/include/catalog/pg_amproc.dat
new file mode 100644
index 0000000000..37b580883f
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_amproc.dat
@@ -0,0 +1,1316 @@
+#----------------------------------------------------------------------
+#
+# pg_amproc.dat
+#    Initial contents of the pg_amproc system catalog.
+#
+# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+# Portions Copyright (c) 1994, Regents of the University of California
+#
+# src/include/catalog/pg_amproc.dat
+#
+#----------------------------------------------------------------------
+
+[
+
+# btree
+{ amprocfamily => 'btree/array_ops', amproclefttype => 'anyarray',
+  amprocrighttype => 'anyarray', amprocnum => '1', amproc => 'btarraycmp' },
+{ amprocfamily => 'btree/bit_ops', amproclefttype => 'bit',
+  amprocrighttype => 'bit', amprocnum => '1', amproc => 'bitcmp' },
+{ amprocfamily => 'btree/bit_ops', amproclefttype => 'bit',
+  amprocrighttype => 'bit', amprocnum => '4', amproc => 'btequalimage' },
+{ amprocfamily => 'btree/bool_ops', amproclefttype => 'bool',
+  amprocrighttype => 'bool', amprocnum => '1', amproc => 'btboolcmp' },
+{ amprocfamily => 'btree/bool_ops', amproclefttype => 'bool',
+  amprocrighttype => 'bool', amprocnum => '4', amproc => 'btequalimage' },
+{ amprocfamily => 'btree/bpchar_ops', amproclefttype => 'bpchar',
+  amprocrighttype => 'bpchar', amprocnum => '1', amproc => 'bpcharcmp' },
+{ amprocfamily => 'btree/bpchar_ops', amproclefttype => 'bpchar',
+  amprocrighttype => 'bpchar', amprocnum => '2',
+  amproc => 'bpchar_sortsupport' },
+{ amprocfamily => 'btree/bpchar_ops', amproclefttype => 'bpchar',
+  amprocrighttype => 'bpchar', amprocnum => '4',
+  amproc => 'btvarstrequalimage' },
+{ amprocfamily => 'btree/bytea_ops', amproclefttype => 'bytea',
+  amprocrighttype => 'bytea', amprocnum => '1', amproc => 'byteacmp' },
+{ amprocfamily => 'btree/bytea_ops', amproclefttype => 'bytea',
+  amprocrighttype => 'bytea', amprocnum => '2', amproc => 'bytea_sortsupport' },
+{ amprocfamily => 'btree/bytea_ops', amproclefttype => 'bytea',
+  amprocrighttype => 'bytea', amprocnum => '4', amproc => 'btequalimage' },
+{ amprocfamily => 'btree/char_ops', amproclefttype => 'char',
+  amprocrighttype => 'char', amprocnum => '1', amproc => 'btcharcmp' },
+{ amprocfamily => 'btree/char_ops', amproclefttype => 'char',
+  amprocrighttype => 'char', amprocnum => '4', amproc => 'btequalimage' },
+{ amprocfamily => 'btree/datetime_ops', amproclefttype => 'date',
+  amprocrighttype => 'date', amprocnum => '1', amproc => 'date_cmp' },
+{ amprocfamily => 'btree/datetime_ops', amproclefttype => 'date',
+  amprocrighttype => 'date', amprocnum => '2', amproc => 'date_sortsupport' },
+{ amprocfamily => 'btree/datetime_ops', amproclefttype => 'date',
+  amprocrighttype => 'date', amprocnum => '4', amproc => 'btequalimage' },
+{ amprocfamily => 'btree/datetime_ops', amproclefttype => 'date',
+  amprocrighttype => 'timestamp', amprocnum => '1',
+  amproc => 'date_cmp_timestamp' },
+{ amprocfamily => 'btree/datetime_ops', amproclefttype => 'date',
+  amprocrighttype => 'timestamptz', amprocnum => '1',
+  amproc => 'date_cmp_timestamptz' },
+{ amprocfamily => 'btree/datetime_ops', amproclefttype => 'timestamp',
+  amprocrighttype => 'timestamp', amprocnum => '1', amproc => 'timestamp_cmp' },
+{ amprocfamily => 'btree/datetime_ops', amproclefttype => 'timestamp',
+  amprocrighttype => 'timestamp', amprocnum => '2',
+  amproc => 'timestamp_sortsupport' },
+{ amprocfamily => 'btree/datetime_ops', amproclefttype => 'timestamp',
+  amprocrighttype => 'timestamp', amprocnum => '4', amproc => 'btequalimage' },
+{ amprocfamily => 'btree/datetime_ops', amproclefttype => 'timestamp',
+  amprocrighttype => 'date', amprocnum => '1', amproc => 'timestamp_cmp_date' },
+{ amprocfamily => 'btree/datetime_ops', amproclefttype => 'timestamp',
+  amprocrighttype => 'timestamptz', amprocnum => '1',
+  amproc => 'timestamp_cmp_timestamptz' },
+{ amprocfamily => 'btree/datetime_ops', amproclefttype => 'timestamptz',
+  amprocrighttype => 'timestamptz', amprocnum => '1',
+  amproc => 'timestamptz_cmp' },
+{ amprocfamily => 'btree/datetime_ops', amproclefttype => 'timestamptz',
+  amprocrighttype => 'timestamptz', amprocnum => '2',
+  amproc => 'timestamp_sortsupport' },
+{ amprocfamily => 'btree/datetime_ops', amproclefttype => 'timestamptz',
+  amprocrighttype => 'timestamptz', amprocnum => '4',
+  amproc => 'btequalimage' },
+{ amprocfamily => 'btree/datetime_ops', amproclefttype => 'timestamptz',
+  amprocrighttype => 'date', amprocnum => '1',
+  amproc => 'timestamptz_cmp_date' },
+{ amprocfamily => 'btree/datetime_ops', amproclefttype => 'timestamptz',
+  amprocrighttype => 'timestamp', amprocnum => '1',
+  amproc => 'timestamptz_cmp_timestamp' },
+{ amprocfamily => 'btree/datetime_ops', amproclefttype => 'date',
+  amprocrighttype => 'interval', amprocnum => '3',
+  amproc => 'in_range(date,date,interval,bool,bool)' },
+{ amprocfamily => 'btree/datetime_ops', amproclefttype => 'timestamp',
+  amprocrighttype => 'interval', amprocnum => '3',
+  amproc => 'in_range(timestamp,timestamp,interval,bool,bool)' },
+{ amprocfamily => 'btree/datetime_ops', amproclefttype => 'timestamptz',
+  amprocrighttype => 'interval', amprocnum => '3',
+  amproc => 'in_range(timestamptz,timestamptz,interval,bool,bool)' },
+{ amprocfamily => 'btree/float_ops', amproclefttype => 'float4',
+  amprocrighttype => 'float4', amprocnum => '1', amproc => 'btfloat4cmp' },
+{ amprocfamily => 'btree/float_ops', amproclefttype => 'float4',
+  amprocrighttype => 'float4', amprocnum => '2',
+  amproc => 'btfloat4sortsupport' },
+{ amprocfamily => 'btree/float_ops', amproclefttype => 'float4',
+  amprocrighttype => 'float8', amprocnum => '1', amproc => 'btfloat48cmp' },
+{ amprocfamily => 'btree/float_ops', amproclefttype => 'float8',
+  amprocrighttype => 'float8', amprocnum => '1', amproc => 'btfloat8cmp' },
+{ amprocfamily => 'btree/float_ops', amproclefttype => 'float8',
+  amprocrighttype => 'float8', amprocnum => '2',
+  amproc => 'btfloat8sortsupport' },
+{ amprocfamily => 'btree/float_ops', amproclefttype => 'float8',
+  amprocrighttype => 'float4', amprocnum => '1', amproc => 'btfloat84cmp' },
+{ amprocfamily => 'btree/float_ops', amproclefttype => 'float8',
+  amprocrighttype => 'float8', amprocnum => '3',
+  amproc => 'in_range(float8,float8,float8,bool,bool)' },
+{ amprocfamily => 'btree/float_ops', amproclefttype => 'float4',
+  amprocrighttype => 'float8', amprocnum => '3',
+  amproc => 'in_range(float4,float4,float8,bool,bool)' },
+{ amprocfamily => 'btree/network_ops', amproclefttype => 'inet',
+  amprocrighttype => 'inet', amprocnum => '1', amproc => 'network_cmp' },
+{ amprocfamily => 'btree/network_ops', amproclefttype => 'inet',
+  amprocrighttype => 'inet', amprocnum => '2',
+  amproc => 'network_sortsupport' },
+{ amprocfamily => 'btree/network_ops', amproclefttype => 'inet',
+  amprocrighttype => 'inet', amprocnum => '4', amproc => 'btequalimage' },
+{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int2',
+  amprocrighttype => 'int2', amprocnum => '1', amproc => 'btint2cmp' },
+{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int2',
+  amprocrighttype => 'int2', amprocnum => '2', amproc => 'btint2sortsupport' },
+{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int2',
+  amprocrighttype => 'int2', amprocnum => '4', amproc => 'btequalimage' },
+{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int2',
+  amprocrighttype => 'int4', amprocnum => '1', amproc => 'btint24cmp' },
+{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int2',
+  amprocrighttype => 'int8', amprocnum => '1', amproc => 'btint28cmp' },
+{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int2',
+  amprocrighttype => 'int8', amprocnum => '3',
+  amproc => 'in_range(int2,int2,int8,bool,bool)' },
+{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int2',
+  amprocrighttype => 'int4', amprocnum => '3',
+  amproc => 'in_range(int2,int2,int4,bool,bool)' },
+{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int2',
+  amprocrighttype => 'int2', amprocnum => '3',
+  amproc => 'in_range(int2,int2,int2,bool,bool)' },
+{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int4',
+  amprocrighttype => 'int4', amprocnum => '1', amproc => 'btint4cmp' },
+{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int4',
+  amprocrighttype => 'int4', amprocnum => '2', amproc => 'btint4sortsupport' },
+{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int4',
+  amprocrighttype => 'int4', amprocnum => '4', amproc => 'btequalimage' },
+{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int4',
+  amprocrighttype => 'int8', amprocnum => '1', amproc => 'btint48cmp' },
+{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int4',
+  amprocrighttype => 'int2', amprocnum => '1', amproc => 'btint42cmp' },
+{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int4',
+  amprocrighttype => 'int8', amprocnum => '3',
+  amproc => 'in_range(int4,int4,int8,bool,bool)' },
+{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int4',
+  amprocrighttype => 'int4', amprocnum => '3',
+  amproc => 'in_range(int4,int4,int4,bool,bool)' },
+{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int4',
+  amprocrighttype => 'int2', amprocnum => '3',
+  amproc => 'in_range(int4,int4,int2,bool,bool)' },
+{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int8',
+  amprocrighttype => 'int8', amprocnum => '1', amproc => 'btint8cmp' },
+{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int8',
+  amprocrighttype => 'int8', amprocnum => '2', amproc => 'btint8sortsupport' },
+{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int8',
+  amprocrighttype => 'int8', amprocnum => '4', amproc => 'btequalimage' },
+{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int8',
+  amprocrighttype => 'int4', amprocnum => '1', amproc => 'btint84cmp' },
+{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int8',
+  amprocrighttype => 'int2', amprocnum => '1', amproc => 'btint82cmp' },
+{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int8',
+  amprocrighttype => 'int8', amprocnum => '3',
+  amproc => 'in_range(int8,int8,int8,bool,bool)' },
+{ amprocfamily => 'btree/interval_ops', amproclefttype => 'interval',
+  amprocrighttype => 'interval', amprocnum => '1', amproc => 'interval_cmp' },
+{ amprocfamily => 'btree/interval_ops', amproclefttype => 'interval',
+  amprocrighttype => 'interval', amprocnum => '3',
+  amproc => 'in_range(interval,interval,interval,bool,bool)' },
+{ amprocfamily => 'btree/interval_ops', amproclefttype => 'interval',
+  amprocrighttype => 'interval', amprocnum => '4', amproc => 'btequalimage' },
+{ amprocfamily => 'btree/macaddr_ops', amproclefttype => 'macaddr',
+  amprocrighttype => 'macaddr', amprocnum => '1', amproc => 'macaddr_cmp' },
+{ amprocfamily => 'btree/macaddr_ops', amproclefttype => 'macaddr',
+  amprocrighttype => 'macaddr', amprocnum => '2',
+  amproc => 'macaddr_sortsupport' },
+{ amprocfamily => 'btree/macaddr_ops', amproclefttype => 'macaddr',
+  amprocrighttype => 'macaddr', amprocnum => '4', amproc => 'btequalimage' },
+{ amprocfamily => 'btree/numeric_ops', amproclefttype => 'numeric',
+  amprocrighttype => 'numeric', amprocnum => '1', amproc => 'numeric_cmp' },
+{ amprocfamily => 'btree/numeric_ops', amproclefttype => 'numeric',
+  amprocrighttype => 'numeric', amprocnum => '2',
+  amproc => 'numeric_sortsupport' },
+{ amprocfamily => 'btree/numeric_ops', amproclefttype => 'numeric',
+  amprocrighttype => 'numeric', amprocnum => '3',
+  amproc => 'in_range(numeric,numeric,numeric,bool,bool)' },
+{ amprocfamily => 'btree/oid_ops', amproclefttype => 'oid',
+  amprocrighttype => 'oid', amprocnum => '1', amproc => 'btoidcmp' },
+{ amprocfamily => 'btree/oid_ops', amproclefttype => 'oid',
+  amprocrighttype => 'oid', amprocnum => '2', amproc => 'btoidsortsupport' },
+{ amprocfamily => 'btree/oid_ops', amproclefttype => 'oid',
+  amprocrighttype => 'oid', amprocnum => '4', amproc => 'btequalimage' },
+{ amprocfamily => 'btree/oidvector_ops', amproclefttype => 'oidvector',
+  amprocrighttype => 'oidvector', amprocnum => '1',
+  amproc => 'btoidvectorcmp' },
+{ amprocfamily => 'btree/oidvector_ops', amproclefttype => 'oidvector',
+  amprocrighttype => 'oidvector', amprocnum => '4', amproc => 'btequalimage' },
+{ amprocfamily => 'btree/text_ops', amproclefttype => 'text',
+  amprocrighttype => 'text', amprocnum => '1', amproc => 'bttextcmp' },
+{ amprocfamily => 'btree/text_ops', amproclefttype => 'text',
+  amprocrighttype => 'text', amprocnum => '2', amproc => 'bttextsortsupport' },
+{ amprocfamily => 'btree/text_ops', amproclefttype => 'text',
+  amprocrighttype => 'text', amprocnum => '4', amproc => 'btvarstrequalimage' },
+{ amprocfamily => 'btree/text_ops', amproclefttype => 'name',
+  amprocrighttype => 'name', amprocnum => '1', amproc => 'btnamecmp' },
+{ amprocfamily => 'btree/text_ops', amproclefttype => 'name',
+  amprocrighttype => 'name', amprocnum => '2', amproc => 'btnamesortsupport' },
+{ amprocfamily => 'btree/text_ops', amproclefttype => 'name',
+  amprocrighttype => 'name', amprocnum => '4', amproc => 'btvarstrequalimage' },
+{ amprocfamily => 'btree/text_ops', amproclefttype => 'name',
+  amprocrighttype => 'text', amprocnum => '1', amproc => 'btnametextcmp' },
+{ amprocfamily => 'btree/text_ops', amproclefttype => 'text',
+  amprocrighttype => 'name', amprocnum => '1', amproc => 'bttextnamecmp' },
+{ amprocfamily => 'btree/time_ops', amproclefttype => 'time',
+  amprocrighttype => 'time', amprocnum => '1', amproc => 'time_cmp' },
+{ amprocfamily => 'btree/time_ops', amproclefttype => 'time',
+  amprocrighttype => 'time', amprocnum => '4', amproc => 'btequalimage' },
+{ amprocfamily => 'btree/time_ops', amproclefttype => 'time',
+  amprocrighttype => 'interval', amprocnum => '3',
+  amproc => 'in_range(time,time,interval,bool,bool)' },
+{ amprocfamily => 'btree/timetz_ops', amproclefttype => 'timetz',
+  amprocrighttype => 'timetz', amprocnum => '1', amproc => 'timetz_cmp' },
+{ amprocfamily => 'btree/timetz_ops', amproclefttype => 'timetz',
+  amprocrighttype => 'timetz', amprocnum => '4', amproc => 'btequalimage' },
+{ amprocfamily => 'btree/timetz_ops', amproclefttype => 'timetz',
+  amprocrighttype => 'interval', amprocnum => '3',
+  amproc => 'in_range(timetz,timetz,interval,bool,bool)' },
+{ amprocfamily => 'btree/varbit_ops', amproclefttype => 'varbit',
+  amprocrighttype => 'varbit', amprocnum => '1', amproc => 'varbitcmp' },
+{ amprocfamily => 'btree/varbit_ops', amproclefttype => 'varbit',
+  amprocrighttype => 'varbit', amprocnum => '4', amproc => 'btequalimage' },
+{ amprocfamily => 'btree/text_pattern_ops', amproclefttype => 'text',
+  amprocrighttype => 'text', amprocnum => '1', amproc => 'bttext_pattern_cmp' },
+{ amprocfamily => 'btree/text_pattern_ops', amproclefttype => 'text',
+  amprocrighttype => 'text', amprocnum => '2',
+  amproc => 'bttext_pattern_sortsupport' },
+{ amprocfamily => 'btree/text_pattern_ops', amproclefttype => 'text',
+  amprocrighttype => 'text', amprocnum => '4', amproc => 'btequalimage' },
+{ amprocfamily => 'btree/bpchar_pattern_ops', amproclefttype => 'bpchar',
+  amprocrighttype => 'bpchar', amprocnum => '1',
+  amproc => 'btbpchar_pattern_cmp' },
+{ amprocfamily => 'btree/bpchar_pattern_ops', amproclefttype => 'bpchar',
+  amprocrighttype => 'bpchar', amprocnum => '2',
+  amproc => 'btbpchar_pattern_sortsupport' },
+{ amprocfamily => 'btree/bpchar_pattern_ops', amproclefttype => 'bpchar',
+  amprocrighttype => 'bpchar', amprocnum => '4', amproc => 'btequalimage' },
+{ amprocfamily => 'btree/money_ops', amproclefttype => 'money',
+  amprocrighttype => 'money', amprocnum => '1', amproc => 'cash_cmp' },
+{ amprocfamily => 'btree/money_ops', amproclefttype => 'money',
+  amprocrighttype => 'money', amprocnum => '4', amproc => 'btequalimage' },
+{ amprocfamily => 'btree/tid_ops', amproclefttype => 'tid',
+  amprocrighttype => 'tid', amprocnum => '1', amproc => 'bttidcmp' },
+{ amprocfamily => 'btree/tid_ops', amproclefttype => 'tid',
+  amprocrighttype => 'tid', amprocnum => '4', amproc => 'btequalimage' },
+{ amprocfamily => 'btree/uuid_ops', amproclefttype => 'uuid',
+  amprocrighttype => 'uuid', amprocnum => '1', amproc => 'uuid_cmp' },
+{ amprocfamily => 'btree/uuid_ops', amproclefttype => 'uuid',
+  amprocrighttype => 'uuid', amprocnum => '2', amproc => 'uuid_sortsupport' },
+{ amprocfamily => 'btree/uuid_ops', amproclefttype => 'uuid',
+  amprocrighttype => 'uuid', amprocnum => '4', amproc => 'btequalimage' },
+{ amprocfamily => 'btree/record_ops', amproclefttype => 'record',
+  amprocrighttype => 'record', amprocnum => '1', amproc => 'btrecordcmp' },
+{ amprocfamily => 'btree/record_image_ops', amproclefttype => 'record',
+  amprocrighttype => 'record', amprocnum => '1', amproc => 'btrecordimagecmp' },
+{ amprocfamily => 'btree/pg_lsn_ops', amproclefttype => 'pg_lsn',
+  amprocrighttype => 'pg_lsn', amprocnum => '1', amproc => 'pg_lsn_cmp' },
+{ amprocfamily => 'btree/pg_lsn_ops', amproclefttype => 'pg_lsn',
+  amprocrighttype => 'pg_lsn', amprocnum => '4', amproc => 'btequalimage' },
+{ amprocfamily => 'btree/macaddr8_ops', amproclefttype => 'macaddr8',
+  amprocrighttype => 'macaddr8', amprocnum => '1', amproc => 'macaddr8_cmp' },
+{ amprocfamily => 'btree/macaddr8_ops', amproclefttype => 'macaddr8',
+  amprocrighttype => 'macaddr8', amprocnum => '4', amproc => 'btequalimage' },
+{ amprocfamily => 'btree/enum_ops', amproclefttype => 'anyenum',
+  amprocrighttype => 'anyenum', amprocnum => '1', amproc => 'enum_cmp' },
+{ amprocfamily => 'btree/enum_ops', amproclefttype => 'anyenum',
+  amprocrighttype => 'anyenum', amprocnum => '4', amproc => 'btequalimage' },
+{ amprocfamily => 'btree/tsvector_ops', amproclefttype => 'tsvector',
+  amprocrighttype => 'tsvector', amprocnum => '1', amproc => 'tsvector_cmp' },
+{ amprocfamily => 'btree/tsquery_ops', amproclefttype => 'tsquery',
+  amprocrighttype => 'tsquery', amprocnum => '1', amproc => 'tsquery_cmp' },
+{ amprocfamily => 'btree/range_ops', amproclefttype => 'anyrange',
+  amprocrighttype => 'anyrange', amprocnum => '1', amproc => 'range_cmp' },
+{ amprocfamily => 'btree/jsonb_ops', amproclefttype => 'jsonb',
+  amprocrighttype => 'jsonb', amprocnum => '1', amproc => 'jsonb_cmp' },
+{ amprocfamily => 'btree/xid8_ops', amproclefttype => 'xid8',
+  amprocrighttype => 'xid8', amprocnum => '1', amproc => 'xid8cmp' },
+{ amprocfamily => 'btree/xid8_ops', amproclefttype => 'xid8',
+  amprocrighttype => 'xid8', amprocnum => '4', amproc => 'btequalimage' },
+
+# hash
+{ amprocfamily => 'hash/bpchar_ops', amproclefttype => 'bpchar',
+  amprocrighttype => 'bpchar', amprocnum => '1', amproc => 'hashbpchar' },
+{ amprocfamily => 'hash/bpchar_ops', amproclefttype => 'bpchar',
+  amprocrighttype => 'bpchar', amprocnum => '2',
+  amproc => 'hashbpcharextended' },
+{ amprocfamily => 'hash/char_ops', amproclefttype => 'char',
+  amprocrighttype => 'char', amprocnum => '1', amproc => 'hashchar' },
+{ amprocfamily => 'hash/char_ops', amproclefttype => 'char',
+  amprocrighttype => 'char', amprocnum => '2', amproc => 'hashcharextended' },
+{ amprocfamily => 'hash/date_ops', amproclefttype => 'date',
+  amprocrighttype => 'date', amprocnum => '1', amproc => 'hashint4' },
+{ amprocfamily => 'hash/date_ops', amproclefttype => 'date',
+  amprocrighttype => 'date', amprocnum => '2', amproc => 'hashint4extended' },
+{ amprocfamily => 'hash/array_ops', amproclefttype => 'anyarray',
+  amprocrighttype => 'anyarray', amprocnum => '1', amproc => 'hash_array' },
+{ amprocfamily => 'hash/array_ops', amproclefttype => 'anyarray',
+  amprocrighttype => 'anyarray', amprocnum => '2',
+  amproc => 'hash_array_extended' },
+{ amprocfamily => 'hash/float_ops', amproclefttype => 'float4',
+  amprocrighttype => 'float4', amprocnum => '1', amproc => 'hashfloat4' },
+{ amprocfamily => 'hash/float_ops', amproclefttype => 'float4',
+  amprocrighttype => 'float4', amprocnum => '2',
+  amproc => 'hashfloat4extended' },
+{ amprocfamily => 'hash/float_ops', amproclefttype => 'float8',
+  amprocrighttype => 'float8', amprocnum => '1', amproc => 'hashfloat8' },
+{ amprocfamily => 'hash/float_ops', amproclefttype => 'float8',
+  amprocrighttype => 'float8', amprocnum => '2',
+  amproc => 'hashfloat8extended' },
+{ amprocfamily => 'hash/network_ops', amproclefttype => 'inet',
+  amprocrighttype => 'inet', amprocnum => '1', amproc => 'hashinet' },
+{ amprocfamily => 'hash/network_ops', amproclefttype => 'inet',
+  amprocrighttype => 'inet', amprocnum => '2', amproc => 'hashinetextended' },
+{ amprocfamily => 'hash/integer_ops', amproclefttype => 'int2',
+  amprocrighttype => 'int2', amprocnum => '1', amproc => 'hashint2' },
+{ amprocfamily => 'hash/integer_ops', amproclefttype => 'int2',
+  amprocrighttype => 'int2', amprocnum => '2', amproc => 'hashint2extended' },
+{ amprocfamily => 'hash/integer_ops', amproclefttype => 'int4',
+  amprocrighttype => 'int4', amprocnum => '1', amproc => 'hashint4' },
+{ amprocfamily => 'hash/integer_ops', amproclefttype => 'int4',
+  amprocrighttype => 'int4', amprocnum => '2', amproc => 'hashint4extended' },
+{ amprocfamily => 'hash/integer_ops', amproclefttype => 'int8',
+  amprocrighttype => 'int8', amprocnum => '1', amproc => 'hashint8' },
+{ amprocfamily => 'hash/integer_ops', amproclefttype => 'int8',
+  amprocrighttype => 'int8', amprocnum => '2', amproc => 'hashint8extended' },
+{ amprocfamily => 'hash/interval_ops', amproclefttype => 'interval',
+  amprocrighttype => 'interval', amprocnum => '1', amproc => 'interval_hash' },
+{ amprocfamily => 'hash/interval_ops', amproclefttype => 'interval',
+  amprocrighttype => 'interval', amprocnum => '2',
+  amproc => 'interval_hash_extended' },
+{ amprocfamily => 'hash/macaddr_ops', amproclefttype => 'macaddr',
+  amprocrighttype => 'macaddr', amprocnum => '1', amproc => 'hashmacaddr' },
+{ amprocfamily => 'hash/macaddr_ops', amproclefttype => 'macaddr',
+  amprocrighttype => 'macaddr', amprocnum => '2',
+  amproc => 'hashmacaddrextended' },
+{ amprocfamily => 'hash/oid_ops', amproclefttype => 'oid',
+  amprocrighttype => 'oid', amprocnum => '1', amproc => 'hashoid' },
+{ amprocfamily => 'hash/oid_ops', amproclefttype => 'oid',
+  amprocrighttype => 'oid', amprocnum => '2', amproc => 'hashoidextended' },
+{ amprocfamily => 'hash/oidvector_ops', amproclefttype => 'oidvector',
+  amprocrighttype => 'oidvector', amprocnum => '1', amproc => 'hashoidvector' },
+{ amprocfamily => 'hash/oidvector_ops', amproclefttype => 'oidvector',
+  amprocrighttype => 'oidvector', amprocnum => '2',
+  amproc => 'hashoidvectorextended' },
+{ amprocfamily => 'hash/text_ops', amproclefttype => 'text',
+  amprocrighttype => 'text', amprocnum => '1', amproc => 'hashtext' },
+{ amprocfamily => 'hash/text_ops', amproclefttype => 'text',
+  amprocrighttype => 'text', amprocnum => '2', amproc => 'hashtextextended' },
+{ amprocfamily => 'hash/text_ops', amproclefttype => 'name',
+  amprocrighttype => 'name', amprocnum => '1', amproc => 'hashname' },
+{ amprocfamily => 'hash/text_ops', amproclefttype => 'name',
+  amprocrighttype => 'name', amprocnum => '2', amproc => 'hashnameextended' },
+{ amprocfamily => 'hash/time_ops', amproclefttype => 'time',
+  amprocrighttype => 'time', amprocnum => '1', amproc => 'time_hash' },
+{ amprocfamily => 'hash/time_ops', amproclefttype => 'time',
+  amprocrighttype => 'time', amprocnum => '2', amproc => 'time_hash_extended' },
+{ amprocfamily => 'hash/numeric_ops', amproclefttype => 'numeric',
+  amprocrighttype => 'numeric', amprocnum => '1', amproc => 'hash_numeric' },
+{ amprocfamily => 'hash/numeric_ops', amproclefttype => 'numeric',
+  amprocrighttype => 'numeric', amprocnum => '2',
+  amproc => 'hash_numeric_extended' },
+{ amprocfamily => 'hash/timestamptz_ops', amproclefttype => 'timestamptz',
+  amprocrighttype => 'timestamptz', amprocnum => '1',
+  amproc => 'timestamp_hash' },
+{ amprocfamily => 'hash/timestamptz_ops', amproclefttype => 'timestamptz',
+  amprocrighttype => 'timestamptz', amprocnum => '2',
+  amproc => 'timestamp_hash_extended' },
+{ amprocfamily => 'hash/timetz_ops', amproclefttype => 'timetz',
+  amprocrighttype => 'timetz', amprocnum => '1', amproc => 'timetz_hash' },
+{ amprocfamily => 'hash/timetz_ops', amproclefttype => 'timetz',
+  amprocrighttype => 'timetz', amprocnum => '2',
+  amproc => 'timetz_hash_extended' },
+{ amprocfamily => 'hash/timestamp_ops', amproclefttype => 'timestamp',
+  amprocrighttype => 'timestamp', amprocnum => '1',
+  amproc => 'timestamp_hash' },
+{ amprocfamily => 'hash/timestamp_ops', amproclefttype => 'timestamp',
+  amprocrighttype => 'timestamp', amprocnum => '2',
+  amproc => 'timestamp_hash_extended' },
+{ amprocfamily => 'hash/bool_ops', amproclefttype => 'bool',
+  amprocrighttype => 'bool', amprocnum => '1', amproc => 'hashchar' },
+{ amprocfamily => 'hash/bool_ops', amproclefttype => 'bool',
+  amprocrighttype => 'bool', amprocnum => '2', amproc => 'hashcharextended' },
+{ amprocfamily => 'hash/bytea_ops', amproclefttype => 'bytea',
+  amprocrighttype => 'bytea', amprocnum => '1', amproc => 'hashvarlena' },
+{ amprocfamily => 'hash/bytea_ops', amproclefttype => 'bytea',
+  amprocrighttype => 'bytea', amprocnum => '2',
+  amproc => 'hashvarlenaextended' },
+{ amprocfamily => 'hash/xid_ops', amproclefttype => 'xid',
+  amprocrighttype => 'xid', amprocnum => '1', amproc => 'hashint4' },
+{ amprocfamily => 'hash/xid_ops', amproclefttype => 'xid',
+  amprocrighttype => 'xid', amprocnum => '2', amproc => 'hashint4extended' },
+{ amprocfamily => 'hash/xid8_ops', amproclefttype => 'xid8',
+  amprocrighttype => 'xid8', amprocnum => '1', amproc => 'hashint8' },
+{ amprocfamily => 'hash/xid8_ops', amproclefttype => 'xid8',
+  amprocrighttype => 'xid8', amprocnum => '2', amproc => 'hashint8extended' },
+{ amprocfamily => 'hash/cid_ops', amproclefttype => 'cid',
+  amprocrighttype => 'cid', amprocnum => '1', amproc => 'hashint4' },
+{ amprocfamily => 'hash/cid_ops', amproclefttype => 'cid',
+  amprocrighttype => 'cid', amprocnum => '2', amproc => 'hashint4extended' },
+{ amprocfamily => 'hash/tid_ops', amproclefttype => 'tid',
+  amprocrighttype => 'tid', amprocnum => '1', amproc => 'hashtid' },
+{ amprocfamily => 'hash/tid_ops', amproclefttype => 'tid',
+  amprocrighttype => 'tid', amprocnum => '2', amproc => 'hashtidextended' },
+{ amprocfamily => 'hash/text_pattern_ops', amproclefttype => 'text',
+  amprocrighttype => 'text', amprocnum => '1', amproc => 'hashtext' },
+{ amprocfamily => 'hash/text_pattern_ops', amproclefttype => 'text',
+  amprocrighttype => 'text', amprocnum => '2', amproc => 'hashtextextended' },
+{ amprocfamily => 'hash/bpchar_pattern_ops', amproclefttype => 'bpchar',
+  amprocrighttype => 'bpchar', amprocnum => '1', amproc => 'hashbpchar' },
+{ amprocfamily => 'hash/bpchar_pattern_ops', amproclefttype => 'bpchar',
+  amprocrighttype => 'bpchar', amprocnum => '2',
+  amproc => 'hashbpcharextended' },
+{ amprocfamily => 'hash/aclitem_ops', amproclefttype => 'aclitem',
+  amprocrighttype => 'aclitem', amprocnum => '1', amproc => 'hash_aclitem' },
+{ amprocfamily => 'hash/aclitem_ops', amproclefttype => 'aclitem',
+  amprocrighttype => 'aclitem', amprocnum => '2',
+  amproc => 'hash_aclitem_extended' },
+{ amprocfamily => 'hash/uuid_ops', amproclefttype => 'uuid',
+  amprocrighttype => 'uuid', amprocnum => '1', amproc => 'uuid_hash' },
+{ amprocfamily => 'hash/uuid_ops', amproclefttype => 'uuid',
+  amprocrighttype => 'uuid', amprocnum => '2', amproc => 'uuid_hash_extended' },
+{ amprocfamily => 'hash/pg_lsn_ops', amproclefttype => 'pg_lsn',
+  amprocrighttype => 'pg_lsn', amprocnum => '1', amproc => 'pg_lsn_hash' },
+{ amprocfamily => 'hash/pg_lsn_ops', amproclefttype => 'pg_lsn',
+  amprocrighttype => 'pg_lsn', amprocnum => '2',
+  amproc => 'pg_lsn_hash_extended' },
+{ amprocfamily => 'hash/macaddr8_ops', amproclefttype => 'macaddr8',
+  amprocrighttype => 'macaddr8', amprocnum => '1', amproc => 'hashmacaddr8' },
+{ amprocfamily => 'hash/macaddr8_ops', amproclefttype => 'macaddr8',
+  amprocrighttype => 'macaddr8', amprocnum => '2',
+  amproc => 'hashmacaddr8extended' },
+{ amprocfamily => 'hash/enum_ops', amproclefttype => 'anyenum',
+  amprocrighttype => 'anyenum', amprocnum => '1', amproc => 'hashenum' },
+{ amprocfamily => 'hash/enum_ops', amproclefttype => 'anyenum',
+  amprocrighttype => 'anyenum', amprocnum => '2',
+  amproc => 'hashenumextended' },
+{ amprocfamily => 'hash/range_ops', amproclefttype => 'anyrange',
+  amprocrighttype => 'anyrange', amprocnum => '1', amproc => 'hash_range' },
+{ amprocfamily => 'hash/range_ops', amproclefttype => 'anyrange',
+  amprocrighttype => 'anyrange', amprocnum => '2',
+  amproc => 'hash_range_extended' },
+{ amprocfamily => 'hash/jsonb_ops', amproclefttype => 'jsonb',
+  amprocrighttype => 'jsonb', amprocnum => '1', amproc => 'jsonb_hash' },
+{ amprocfamily => 'hash/jsonb_ops', amproclefttype => 'jsonb',
+  amprocrighttype => 'jsonb', amprocnum => '2',
+  amproc => 'jsonb_hash_extended' },
+
+# gist
+{ amprocfamily => 'gist/point_ops', amproclefttype => 'point',
+  amprocrighttype => 'point', amprocnum => '1',
+  amproc => 'gist_point_consistent' },
+{ amprocfamily => 'gist/point_ops', amproclefttype => 'point',
+  amprocrighttype => 'point', amprocnum => '2', amproc => 'gist_box_union' },
+{ amprocfamily => 'gist/point_ops', amproclefttype => 'point',
+  amprocrighttype => 'point', amprocnum => '3',
+  amproc => 'gist_point_compress' },
+{ amprocfamily => 'gist/point_ops', amproclefttype => 'point',
+  amprocrighttype => 'point', amprocnum => '5', amproc => 'gist_box_penalty' },
+{ amprocfamily => 'gist/point_ops', amproclefttype => 'point',
+  amprocrighttype => 'point', amprocnum => '6',
+  amproc => 'gist_box_picksplit' },
+{ amprocfamily => 'gist/point_ops', amproclefttype => 'point',
+  amprocrighttype => 'point', amprocnum => '7', amproc => 'gist_box_same' },
+{ amprocfamily => 'gist/point_ops', amproclefttype => 'point',
+  amprocrighttype => 'point', amprocnum => '8',
+  amproc => 'gist_point_distance' },
+{ amprocfamily => 'gist/point_ops', amproclefttype => 'point',
+  amprocrighttype => 'point', amprocnum => '9', amproc => 'gist_point_fetch' },
+{ amprocfamily => 'gist/box_ops', amproclefttype => 'box',
+  amprocrighttype => 'box', amprocnum => '1', amproc => 'gist_box_consistent' },
+{ amprocfamily => 'gist/box_ops', amproclefttype => 'box',
+  amprocrighttype => 'box', amprocnum => '2', amproc => 'gist_box_union' },
+{ amprocfamily => 'gist/box_ops', amproclefttype => 'box',
+  amprocrighttype => 'box', amprocnum => '5', amproc => 'gist_box_penalty' },
+{ amprocfamily => 'gist/box_ops', amproclefttype => 'box',
+  amprocrighttype => 'box', amprocnum => '6', amproc => 'gist_box_picksplit' },
+{ amprocfamily => 'gist/box_ops', amproclefttype => 'box',
+  amprocrighttype => 'box', amprocnum => '7', amproc => 'gist_box_same' },
+{ amprocfamily => 'gist/box_ops', amproclefttype => 'box',
+  amprocrighttype => 'box', amprocnum => '8', amproc => 'gist_box_distance' },
+{ amprocfamily => 'gist/poly_ops', amproclefttype => 'polygon',
+  amprocrighttype => 'polygon', amprocnum => '1',
+  amproc => 'gist_poly_consistent' },
+{ amprocfamily => 'gist/poly_ops', amproclefttype => 'polygon',
+  amprocrighttype => 'polygon', amprocnum => '2', amproc => 'gist_box_union' },
+{ amprocfamily => 'gist/poly_ops', amproclefttype => 'polygon',
+  amprocrighttype => 'polygon', amprocnum => '3',
+  amproc => 'gist_poly_compress' },
+{ amprocfamily => 'gist/poly_ops', amproclefttype => 'polygon',
+  amprocrighttype => 'polygon', amprocnum => '5',
+  amproc => 'gist_box_penalty' },
+{ amprocfamily => 'gist/poly_ops', amproclefttype => 'polygon',
+  amprocrighttype => 'polygon', amprocnum => '6',
+  amproc => 'gist_box_picksplit' },
+{ amprocfamily => 'gist/poly_ops', amproclefttype => 'polygon',
+  amprocrighttype => 'polygon', amprocnum => '7', amproc => 'gist_box_same' },
+{ amprocfamily => 'gist/poly_ops', amproclefttype => 'polygon',
+  amprocrighttype => 'polygon', amprocnum => '8',
+  amproc => 'gist_poly_distance' },
+{ amprocfamily => 'gist/circle_ops', amproclefttype => 'circle',
+  amprocrighttype => 'circle', amprocnum => '1',
+  amproc => 'gist_circle_consistent' },
+{ amprocfamily => 'gist/circle_ops', amproclefttype => 'circle',
+  amprocrighttype => 'circle', amprocnum => '2', amproc => 'gist_box_union' },
+{ amprocfamily => 'gist/circle_ops', amproclefttype => 'circle',
+  amprocrighttype => 'circle', amprocnum => '3',
+  amproc => 'gist_circle_compress' },
+{ amprocfamily => 'gist/circle_ops', amproclefttype => 'circle',
+  amprocrighttype => 'circle', amprocnum => '5', amproc => 'gist_box_penalty' },
+{ amprocfamily => 'gist/circle_ops', amproclefttype => 'circle',
+  amprocrighttype => 'circle', amprocnum => '6',
+  amproc => 'gist_box_picksplit' },
+{ amprocfamily => 'gist/circle_ops', amproclefttype => 'circle',
+  amprocrighttype => 'circle', amprocnum => '7', amproc => 'gist_box_same' },
+{ amprocfamily => 'gist/circle_ops', amproclefttype => 'circle',
+  amprocrighttype => 'circle', amprocnum => '8',
+  amproc => 'gist_circle_distance' },
+{ amprocfamily => 'gist/tsvector_ops', amproclefttype => 'tsvector',
+  amprocrighttype => 'tsvector', amprocnum => '1',
+  amproc => 'gtsvector_consistent(internal,tsvector,int2,oid,internal)' },
+{ amprocfamily => 'gist/tsvector_ops', amproclefttype => 'tsvector',
+  amprocrighttype => 'tsvector', amprocnum => '2',
+  amproc => 'gtsvector_union' },
+{ amprocfamily => 'gist/tsvector_ops', amproclefttype => 'tsvector',
+  amprocrighttype => 'tsvector', amprocnum => '3',
+  amproc => 'gtsvector_compress' },
+{ amprocfamily => 'gist/tsvector_ops', amproclefttype => 'tsvector',
+  amprocrighttype => 'tsvector', amprocnum => '4',
+  amproc => 'gtsvector_decompress' },
+{ amprocfamily => 'gist/tsvector_ops', amproclefttype => 'tsvector',
+  amprocrighttype => 'tsvector', amprocnum => '5',
+  amproc => 'gtsvector_penalty' },
+{ amprocfamily => 'gist/tsvector_ops', amproclefttype => 'tsvector',
+  amprocrighttype => 'tsvector', amprocnum => '6',
+  amproc => 'gtsvector_picksplit' },
+{ amprocfamily => 'gist/tsvector_ops', amproclefttype => 'tsvector',
+  amprocrighttype => 'tsvector', amprocnum => '7', amproc => 'gtsvector_same' },
+{ amprocfamily => 'gist/tsvector_ops', amproclefttype => 'tsvector',
+  amprocrighttype => 'tsvector', amprocnum => '10',
+  amproc => 'gtsvector_options' },
+{ amprocfamily => 'gist/tsquery_ops', amproclefttype => 'tsquery',
+  amprocrighttype => 'tsquery', amprocnum => '1',
+  amproc => 'gtsquery_consistent(internal,tsquery,int2,oid,internal)' },
+{ amprocfamily => 'gist/tsquery_ops', amproclefttype => 'tsquery',
+  amprocrighttype => 'tsquery', amprocnum => '2', amproc => 'gtsquery_union' },
+{ amprocfamily => 'gist/tsquery_ops', amproclefttype => 'tsquery',
+  amprocrighttype => 'tsquery', amprocnum => '3',
+  amproc => 'gtsquery_compress' },
+{ amprocfamily => 'gist/tsquery_ops', amproclefttype => 'tsquery',
+  amprocrighttype => 'tsquery', amprocnum => '5',
+  amproc => 'gtsquery_penalty' },
+{ amprocfamily => 'gist/tsquery_ops', amproclefttype => 'tsquery',
+  amprocrighttype => 'tsquery', amprocnum => '6',
+  amproc => 'gtsquery_picksplit' },
+{ amprocfamily => 'gist/tsquery_ops', amproclefttype => 'tsquery',
+  amprocrighttype => 'tsquery', amprocnum => '7', amproc => 'gtsquery_same' },
+{ amprocfamily => 'gist/range_ops', amproclefttype => 'anyrange',
+  amprocrighttype => 'anyrange', amprocnum => '1',
+  amproc => 'range_gist_consistent' },
+{ amprocfamily => 'gist/range_ops', amproclefttype => 'anyrange',
+  amprocrighttype => 'anyrange', amprocnum => '2',
+  amproc => 'range_gist_union' },
+{ amprocfamily => 'gist/range_ops', amproclefttype => 'anyrange',
+  amprocrighttype => 'anyrange', amprocnum => '5',
+  amproc => 'range_gist_penalty' },
+{ amprocfamily => 'gist/range_ops', amproclefttype => 'anyrange',
+  amprocrighttype => 'anyrange', amprocnum => '6',
+  amproc => 'range_gist_picksplit' },
+{ amprocfamily => 'gist/range_ops', amproclefttype => 'anyrange',
+  amprocrighttype => 'anyrange', amprocnum => '7',
+  amproc => 'range_gist_same' },
+{ amprocfamily => 'gist/network_ops', amproclefttype => 'inet',
+  amprocrighttype => 'inet', amprocnum => '1',
+  amproc => 'inet_gist_consistent' },
+{ amprocfamily => 'gist/network_ops', amproclefttype => 'inet',
+  amprocrighttype => 'inet', amprocnum => '2', amproc => 'inet_gist_union' },
+{ amprocfamily => 'gist/network_ops', amproclefttype => 'inet',
+  amprocrighttype => 'inet', amprocnum => '3', amproc => 'inet_gist_compress' },
+{ amprocfamily => 'gist/network_ops', amproclefttype => 'inet',
+  amprocrighttype => 'inet', amprocnum => '5', amproc => 'inet_gist_penalty' },
+{ amprocfamily => 'gist/network_ops', amproclefttype => 'inet',
+  amprocrighttype => 'inet', amprocnum => '6',
+  amproc => 'inet_gist_picksplit' },
+{ amprocfamily => 'gist/network_ops', amproclefttype => 'inet',
+  amprocrighttype => 'inet', amprocnum => '7', amproc => 'inet_gist_same' },
+{ amprocfamily => 'gist/network_ops', amproclefttype => 'inet',
+  amprocrighttype => 'inet', amprocnum => '9', amproc => 'inet_gist_fetch' },
+
+# gin
+{ amprocfamily => 'gin/array_ops', amproclefttype => 'anyarray',
+  amprocrighttype => 'anyarray', amprocnum => '2',
+  amproc => 'ginarrayextract(anyarray,internal,internal)' },
+{ amprocfamily => 'gin/array_ops', amproclefttype => 'anyarray',
+  amprocrighttype => 'anyarray', amprocnum => '3',
+  amproc => 'ginqueryarrayextract' },
+{ amprocfamily => 'gin/array_ops', amproclefttype => 'anyarray',
+  amprocrighttype => 'anyarray', amprocnum => '4',
+  amproc => 'ginarrayconsistent' },
+{ amprocfamily => 'gin/array_ops', amproclefttype => 'anyarray',
+  amprocrighttype => 'anyarray', amprocnum => '6',
+  amproc => 'ginarraytriconsistent' },
+{ amprocfamily => 'gin/tsvector_ops', amproclefttype => 'tsvector',
+  amprocrighttype => 'tsvector', amprocnum => '1',
+  amproc => 'gin_cmp_tslexeme' },
+{ amprocfamily => 'gin/tsvector_ops', amproclefttype => 'tsvector',
+  amprocrighttype => 'tsvector', amprocnum => '2',
+  amproc => 'gin_extract_tsvector(tsvector,internal,internal)' },
+{ amprocfamily => 'gin/tsvector_ops', amproclefttype => 'tsvector',
+  amprocrighttype => 'tsvector', amprocnum => '3',
+  amproc => 'gin_extract_tsquery(tsvector,internal,int2,internal,internal,internal,internal)' },
+{ amprocfamily => 'gin/tsvector_ops', amproclefttype => 'tsvector',
+  amprocrighttype => 'tsvector', amprocnum => '4',
+  amproc => 'gin_tsquery_consistent(internal,int2,tsvector,int4,internal,internal,internal,internal)' },
+{ amprocfamily => 'gin/tsvector_ops', amproclefttype => 'tsvector',
+  amprocrighttype => 'tsvector', amprocnum => '5', amproc => 'gin_cmp_prefix' },
+{ amprocfamily => 'gin/tsvector_ops', amproclefttype => 'tsvector',
+  amprocrighttype => 'tsvector', amprocnum => '6',
+  amproc => 'gin_tsquery_triconsistent' },
+{ amprocfamily => 'gin/jsonb_ops', amproclefttype => 'jsonb',
+  amprocrighttype => 'jsonb', amprocnum => '1', amproc => 'gin_compare_jsonb' },
+{ amprocfamily => 'gin/jsonb_ops', amproclefttype => 'jsonb',
+  amprocrighttype => 'jsonb', amprocnum => '2', amproc => 'gin_extract_jsonb' },
+{ amprocfamily => 'gin/jsonb_ops', amproclefttype => 'jsonb',
+  amprocrighttype => 'jsonb', amprocnum => '3',
+  amproc => 'gin_extract_jsonb_query' },
+{ amprocfamily => 'gin/jsonb_ops', amproclefttype => 'jsonb',
+  amprocrighttype => 'jsonb', amprocnum => '4',
+  amproc => 'gin_consistent_jsonb' },
+{ amprocfamily => 'gin/jsonb_ops', amproclefttype => 'jsonb',
+  amprocrighttype => 'jsonb', amprocnum => '6',
+  amproc => 'gin_triconsistent_jsonb' },
+{ amprocfamily => 'gin/jsonb_path_ops', amproclefttype => 'jsonb',
+  amprocrighttype => 'jsonb', amprocnum => '1', amproc => 'btint4cmp' },
+{ amprocfamily => 'gin/jsonb_path_ops', amproclefttype => 'jsonb',
+  amprocrighttype => 'jsonb', amprocnum => '2',
+  amproc => 'gin_extract_jsonb_path' },
+{ amprocfamily => 'gin/jsonb_path_ops', amproclefttype => 'jsonb',
+  amprocrighttype => 'jsonb', amprocnum => '3',
+  amproc => 'gin_extract_jsonb_query_path' },
+{ amprocfamily => 'gin/jsonb_path_ops', amproclefttype => 'jsonb',
+  amprocrighttype => 'jsonb', amprocnum => '4',
+  amproc => 'gin_consistent_jsonb_path' },
+{ amprocfamily => 'gin/jsonb_path_ops', amproclefttype => 'jsonb',
+  amprocrighttype => 'jsonb', amprocnum => '6',
+  amproc => 'gin_triconsistent_jsonb_path' },
+
+# sp-gist
+{ amprocfamily => 'spgist/range_ops', amproclefttype => 'anyrange',
+  amprocrighttype => 'anyrange', amprocnum => '1',
+  amproc => 'spg_range_quad_config' },
+{ amprocfamily => 'spgist/range_ops', amproclefttype => 'anyrange',
+  amprocrighttype => 'anyrange', amprocnum => '2',
+  amproc => 'spg_range_quad_choose' },
+{ amprocfamily => 'spgist/range_ops', amproclefttype => 'anyrange',
+  amprocrighttype => 'anyrange', amprocnum => '3',
+  amproc => 'spg_range_quad_picksplit' },
+{ amprocfamily => 'spgist/range_ops', amproclefttype => 'anyrange',
+  amprocrighttype => 'anyrange', amprocnum => '4',
+  amproc => 'spg_range_quad_inner_consistent' },
+{ amprocfamily => 'spgist/range_ops', amproclefttype => 'anyrange',
+  amprocrighttype => 'anyrange', amprocnum => '5',
+  amproc => 'spg_range_quad_leaf_consistent' },
+{ amprocfamily => 'spgist/network_ops', amproclefttype => 'inet',
+  amprocrighttype => 'inet', amprocnum => '1', amproc => 'inet_spg_config' },
+{ amprocfamily => 'spgist/network_ops', amproclefttype => 'inet',
+  amprocrighttype => 'inet', amprocnum => '2', amproc => 'inet_spg_choose' },
+{ amprocfamily => 'spgist/network_ops', amproclefttype => 'inet',
+  amprocrighttype => 'inet', amprocnum => '3', amproc => 'inet_spg_picksplit' },
+{ amprocfamily => 'spgist/network_ops', amproclefttype => 'inet',
+  amprocrighttype => 'inet', amprocnum => '4',
+  amproc => 'inet_spg_inner_consistent' },
+{ amprocfamily => 'spgist/network_ops', amproclefttype => 'inet',
+  amprocrighttype => 'inet', amprocnum => '5',
+  amproc => 'inet_spg_leaf_consistent' },
+{ amprocfamily => 'spgist/quad_point_ops', amproclefttype => 'point',
+  amprocrighttype => 'point', amprocnum => '1', amproc => 'spg_quad_config' },
+{ amprocfamily => 'spgist/quad_point_ops', amproclefttype => 'point',
+  amprocrighttype => 'point', amprocnum => '2', amproc => 'spg_quad_choose' },
+{ amprocfamily => 'spgist/quad_point_ops', amproclefttype => 'point',
+  amprocrighttype => 'point', amprocnum => '3',
+  amproc => 'spg_quad_picksplit' },
+{ amprocfamily => 'spgist/quad_point_ops', amproclefttype => 'point',
+  amprocrighttype => 'point', amprocnum => '4',
+  amproc => 'spg_quad_inner_consistent' },
+{ amprocfamily => 'spgist/quad_point_ops', amproclefttype => 'point',
+  amprocrighttype => 'point', amprocnum => '5',
+  amproc => 'spg_quad_leaf_consistent' },
+{ amprocfamily => 'spgist/kd_point_ops', amproclefttype => 'point',
+  amprocrighttype => 'point', amprocnum => '1', amproc => 'spg_kd_config' },
+{ amprocfamily => 'spgist/kd_point_ops', amproclefttype => 'point',
+  amprocrighttype => 'point', amprocnum => '2', amproc => 'spg_kd_choose' },
+{ amprocfamily => 'spgist/kd_point_ops', amproclefttype => 'point',
+  amprocrighttype => 'point', amprocnum => '3', amproc => 'spg_kd_picksplit' },
+{ amprocfamily => 'spgist/kd_point_ops', amproclefttype => 'point',
+  amprocrighttype => 'point', amprocnum => '4',
+  amproc => 'spg_kd_inner_consistent' },
+{ amprocfamily => 'spgist/kd_point_ops', amproclefttype => 'point',
+  amprocrighttype => 'point', amprocnum => '5',
+  amproc => 'spg_quad_leaf_consistent' },
+{ amprocfamily => 'spgist/text_ops', amproclefttype => 'text',
+  amprocrighttype => 'text', amprocnum => '1', amproc => 'spg_text_config' },
+{ amprocfamily => 'spgist/text_ops', amproclefttype => 'text',
+  amprocrighttype => 'text', amprocnum => '2', amproc => 'spg_text_choose' },
+{ amprocfamily => 'spgist/text_ops', amproclefttype => 'text',
+  amprocrighttype => 'text', amprocnum => '3', amproc => 'spg_text_picksplit' },
+{ amprocfamily => 'spgist/text_ops', amproclefttype => 'text',
+  amprocrighttype => 'text', amprocnum => '4',
+  amproc => 'spg_text_inner_consistent' },
+{ amprocfamily => 'spgist/text_ops', amproclefttype => 'text',
+  amprocrighttype => 'text', amprocnum => '5',
+  amproc => 'spg_text_leaf_consistent' },
+{ amprocfamily => 'spgist/box_ops', amproclefttype => 'box',
+  amprocrighttype => 'box', amprocnum => '1', amproc => 'spg_box_quad_config' },
+{ amprocfamily => 'spgist/box_ops', amproclefttype => 'box',
+  amprocrighttype => 'box', amprocnum => '2', amproc => 'spg_box_quad_choose' },
+{ amprocfamily => 'spgist/box_ops', amproclefttype => 'box',
+  amprocrighttype => 'box', amprocnum => '3',
+  amproc => 'spg_box_quad_picksplit' },
+{ amprocfamily => 'spgist/box_ops', amproclefttype => 'box',
+  amprocrighttype => 'box', amprocnum => '4',
+  amproc => 'spg_box_quad_inner_consistent' },
+{ amprocfamily => 'spgist/box_ops', amproclefttype => 'box',
+  amprocrighttype => 'box', amprocnum => '5',
+  amproc => 'spg_box_quad_leaf_consistent' },
+{ amprocfamily => 'spgist/poly_ops', amproclefttype => 'polygon',
+  amprocrighttype => 'polygon', amprocnum => '1',
+  amproc => 'spg_bbox_quad_config' },
+{ amprocfamily => 'spgist/poly_ops', amproclefttype => 'polygon',
+  amprocrighttype => 'polygon', amprocnum => '2',
+  amproc => 'spg_box_quad_choose' },
+{ amprocfamily => 'spgist/poly_ops', amproclefttype => 'polygon',
+  amprocrighttype => 'polygon', amprocnum => '3',
+  amproc => 'spg_box_quad_picksplit' },
+{ amprocfamily => 'spgist/poly_ops', amproclefttype => 'polygon',
+  amprocrighttype => 'polygon', amprocnum => '4',
+  amproc => 'spg_box_quad_inner_consistent' },
+{ amprocfamily => 'spgist/poly_ops', amproclefttype => 'polygon',
+  amprocrighttype => 'polygon', amprocnum => '5',
+  amproc => 'spg_box_quad_leaf_consistent' },
+{ amprocfamily => 'spgist/poly_ops', amproclefttype => 'polygon',
+  amprocrighttype => 'polygon', amprocnum => '6',
+  amproc => 'spg_poly_quad_compress' },
+
+# BRIN opclasses
+
+# minmax bytea
+{ amprocfamily => 'brin/bytea_minmax_ops', amproclefttype => 'bytea',
+  amprocrighttype => 'bytea', amprocnum => '1',
+  amproc => 'brin_minmax_opcinfo' },
+{ amprocfamily => 'brin/bytea_minmax_ops', amproclefttype => 'bytea',
+  amprocrighttype => 'bytea', amprocnum => '2',
+  amproc => 'brin_minmax_add_value' },
+{ amprocfamily => 'brin/bytea_minmax_ops', amproclefttype => 'bytea',
+  amprocrighttype => 'bytea', amprocnum => '3',
+  amproc => 'brin_minmax_consistent' },
+{ amprocfamily => 'brin/bytea_minmax_ops', amproclefttype => 'bytea',
+  amprocrighttype => 'bytea', amprocnum => '4', amproc => 'brin_minmax_union' },
+
+# minmax "char"
+{ amprocfamily => 'brin/char_minmax_ops', amproclefttype => 'char',
+  amprocrighttype => 'char', amprocnum => '1',
+  amproc => 'brin_minmax_opcinfo' },
+{ amprocfamily => 'brin/char_minmax_ops', amproclefttype => 'char',
+  amprocrighttype => 'char', amprocnum => '2',
+  amproc => 'brin_minmax_add_value' },
+{ amprocfamily => 'brin/char_minmax_ops', amproclefttype => 'char',
+  amprocrighttype => 'char', amprocnum => '3',
+  amproc => 'brin_minmax_consistent' },
+{ amprocfamily => 'brin/char_minmax_ops', amproclefttype => 'char',
+  amprocrighttype => 'char', amprocnum => '4', amproc => 'brin_minmax_union' },
+
+# minmax name
+{ amprocfamily => 'brin/name_minmax_ops', amproclefttype => 'name',
+  amprocrighttype => 'name', amprocnum => '1',
+  amproc => 'brin_minmax_opcinfo' },
+{ amprocfamily => 'brin/name_minmax_ops', amproclefttype => 'name',
+  amprocrighttype => 'name', amprocnum => '2',
+  amproc => 'brin_minmax_add_value' },
+{ amprocfamily => 'brin/name_minmax_ops', amproclefttype => 'name',
+  amprocrighttype => 'name', amprocnum => '3',
+  amproc => 'brin_minmax_consistent' },
+{ amprocfamily => 'brin/name_minmax_ops', amproclefttype => 'name',
+  amprocrighttype => 'name', amprocnum => '4', amproc => 'brin_minmax_union' },
+
+# minmax integer: int2, int4, int8
+{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int8',
+  amprocrighttype => 'int8', amprocnum => '1',
+  amproc => 'brin_minmax_opcinfo' },
+{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int8',
+  amprocrighttype => 'int8', amprocnum => '2',
+  amproc => 'brin_minmax_add_value' },
+{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int8',
+  amprocrighttype => 'int8', amprocnum => '3',
+  amproc => 'brin_minmax_consistent' },
+{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int8',
+  amprocrighttype => 'int8', amprocnum => '4', amproc => 'brin_minmax_union' },
+{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int8',
+  amprocrighttype => 'int2', amprocnum => '1',
+  amproc => 'brin_minmax_opcinfo' },
+{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int8',
+  amprocrighttype => 'int2', amprocnum => '2',
+  amproc => 'brin_minmax_add_value' },
+{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int8',
+  amprocrighttype => 'int2', amprocnum => '3',
+  amproc => 'brin_minmax_consistent' },
+{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int8',
+  amprocrighttype => 'int2', amprocnum => '4', amproc => 'brin_minmax_union' },
+{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int8',
+  amprocrighttype => 'int4', amprocnum => '1',
+  amproc => 'brin_minmax_opcinfo' },
+{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int8',
+  amprocrighttype => 'int4', amprocnum => '2',
+  amproc => 'brin_minmax_add_value' },
+{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int8',
+  amprocrighttype => 'int4', amprocnum => '3',
+  amproc => 'brin_minmax_consistent' },
+{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int8',
+  amprocrighttype => 'int4', amprocnum => '4', amproc => 'brin_minmax_union' },
+{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int2',
+  amprocrighttype => 'int2', amprocnum => '1',
+  amproc => 'brin_minmax_opcinfo' },
+{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int2',
+  amprocrighttype => 'int2', amprocnum => '2',
+  amproc => 'brin_minmax_add_value' },
+{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int2',
+  amprocrighttype => 'int2', amprocnum => '3',
+  amproc => 'brin_minmax_consistent' },
+{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int2',
+  amprocrighttype => 'int2', amprocnum => '4', amproc => 'brin_minmax_union' },
+{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int2',
+  amprocrighttype => 'int8', amprocnum => '1',
+  amproc => 'brin_minmax_opcinfo' },
+{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int2',
+  amprocrighttype => 'int8', amprocnum => '2',
+  amproc => 'brin_minmax_add_value' },
+{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int2',
+  amprocrighttype => 'int8', amprocnum => '3',
+  amproc => 'brin_minmax_consistent' },
+{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int2',
+  amprocrighttype => 'int8', amprocnum => '4', amproc => 'brin_minmax_union' },
+{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int2',
+  amprocrighttype => 'int4', amprocnum => '1',
+  amproc => 'brin_minmax_opcinfo' },
+{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int2',
+  amprocrighttype => 'int4', amprocnum => '2',
+  amproc => 'brin_minmax_add_value' },
+{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int2',
+  amprocrighttype => 'int4', amprocnum => '3',
+  amproc => 'brin_minmax_consistent' },
+{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int2',
+  amprocrighttype => 'int4', amprocnum => '4', amproc => 'brin_minmax_union' },
+{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int4',
+  amprocrighttype => 'int4', amprocnum => '1',
+  amproc => 'brin_minmax_opcinfo' },
+{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int4',
+  amprocrighttype => 'int4', amprocnum => '2',
+  amproc => 'brin_minmax_add_value' },
+{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int4',
+  amprocrighttype => 'int4', amprocnum => '3',
+  amproc => 'brin_minmax_consistent' },
+{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int4',
+  amprocrighttype => 'int4', amprocnum => '4', amproc => 'brin_minmax_union' },
+{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int4',
+  amprocrighttype => 'int8', amprocnum => '1',
+  amproc => 'brin_minmax_opcinfo' },
+{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int4',
+  amprocrighttype => 'int8', amprocnum => '2',
+  amproc => 'brin_minmax_add_value' },
+{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int4',
+  amprocrighttype => 'int8', amprocnum => '3',
+  amproc => 'brin_minmax_consistent' },
+{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int4',
+  amprocrighttype => 'int8', amprocnum => '4', amproc => 'brin_minmax_union' },
+{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int4',
+  amprocrighttype => 'int2', amprocnum => '1',
+  amproc => 'brin_minmax_opcinfo' },
+{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int4',
+  amprocrighttype => 'int2', amprocnum => '2',
+  amproc => 'brin_minmax_add_value' },
+{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int4',
+  amprocrighttype => 'int2', amprocnum => '3',
+  amproc => 'brin_minmax_consistent' },
+{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int4',
+  amprocrighttype => 'int2', amprocnum => '4', amproc => 'brin_minmax_union' },
+
+# minmax text
+{ amprocfamily => 'brin/text_minmax_ops', amproclefttype => 'text',
+  amprocrighttype => 'text', amprocnum => '1',
+  amproc => 'brin_minmax_opcinfo' },
+{ amprocfamily => 'brin/text_minmax_ops', amproclefttype => 'text',
+  amprocrighttype => 'text', amprocnum => '2',
+  amproc => 'brin_minmax_add_value' },
+{ amprocfamily => 'brin/text_minmax_ops', amproclefttype => 'text',
+  amprocrighttype => 'text', amprocnum => '3',
+  amproc => 'brin_minmax_consistent' },
+{ amprocfamily => 'brin/text_minmax_ops', amproclefttype => 'text',
+  amprocrighttype => 'text', amprocnum => '4', amproc => 'brin_minmax_union' },
+
+# minmax oid
+{ amprocfamily => 'brin/oid_minmax_ops', amproclefttype => 'oid',
+  amprocrighttype => 'oid', amprocnum => '1', amproc => 'brin_minmax_opcinfo' },
+{ amprocfamily => 'brin/oid_minmax_ops', amproclefttype => 'oid',
+  amprocrighttype => 'oid', amprocnum => '2',
+  amproc => 'brin_minmax_add_value' },
+{ amprocfamily => 'brin/oid_minmax_ops', amproclefttype => 'oid',
+  amprocrighttype => 'oid', amprocnum => '3',
+  amproc => 'brin_minmax_consistent' },
+{ amprocfamily => 'brin/oid_minmax_ops', amproclefttype => 'oid',
+  amprocrighttype => 'oid', amprocnum => '4', amproc => 'brin_minmax_union' },
+
+# minmax tid
+{ amprocfamily => 'brin/tid_minmax_ops', amproclefttype => 'tid',
+  amprocrighttype => 'tid', amprocnum => '1', amproc => 'brin_minmax_opcinfo' },
+{ amprocfamily => 'brin/tid_minmax_ops', amproclefttype => 'tid',
+  amprocrighttype => 'tid', amprocnum => '2',
+  amproc => 'brin_minmax_add_value' },
+{ amprocfamily => 'brin/tid_minmax_ops', amproclefttype => 'tid',
+  amprocrighttype => 'tid', amprocnum => '3',
+  amproc => 'brin_minmax_consistent' },
+{ amprocfamily => 'brin/tid_minmax_ops', amproclefttype => 'tid',
+  amprocrighttype => 'tid', amprocnum => '4', amproc => 'brin_minmax_union' },
+
+# minmax float
+{ amprocfamily => 'brin/float_minmax_ops', amproclefttype => 'float4',
+  amprocrighttype => 'float4', amprocnum => '1',
+  amproc => 'brin_minmax_opcinfo' },
+{ amprocfamily => 'brin/float_minmax_ops', amproclefttype => 'float4',
+  amprocrighttype => 'float4', amprocnum => '2',
+  amproc => 'brin_minmax_add_value' },
+{ amprocfamily => 'brin/float_minmax_ops', amproclefttype => 'float4',
+  amprocrighttype => 'float4', amprocnum => '3',
+  amproc => 'brin_minmax_consistent' },
+{ amprocfamily => 'brin/float_minmax_ops', amproclefttype => 'float4',
+  amprocrighttype => 'float4', amprocnum => '4',
+  amproc => 'brin_minmax_union' },
+{ amprocfamily => 'brin/float_minmax_ops', amproclefttype => 'float4',
+  amprocrighttype => 'float8', amprocnum => '1',
+  amproc => 'brin_minmax_opcinfo' },
+{ amprocfamily => 'brin/float_minmax_ops', amproclefttype => 'float4',
+  amprocrighttype => 'float8', amprocnum => '2',
+  amproc => 'brin_minmax_add_value' },
+{ amprocfamily => 'brin/float_minmax_ops', amproclefttype => 'float4',
+  amprocrighttype => 'float8', amprocnum => '3',
+  amproc => 'brin_minmax_consistent' },
+{ amprocfamily => 'brin/float_minmax_ops', amproclefttype => 'float4',
+  amprocrighttype => 'float8', amprocnum => '4',
+  amproc => 'brin_minmax_union' },
+{ amprocfamily => 'brin/float_minmax_ops', amproclefttype => 'float8',
+  amprocrighttype => 'float8', amprocnum => '1',
+  amproc => 'brin_minmax_opcinfo' },
+{ amprocfamily => 'brin/float_minmax_ops', amproclefttype => 'float8',
+  amprocrighttype => 'float8', amprocnum => '2',
+  amproc => 'brin_minmax_add_value' },
+{ amprocfamily => 'brin/float_minmax_ops', amproclefttype => 'float8',
+  amprocrighttype => 'float8', amprocnum => '3',
+  amproc => 'brin_minmax_consistent' },
+{ amprocfamily => 'brin/float_minmax_ops', amproclefttype => 'float8',
+  amprocrighttype => 'float8', amprocnum => '4',
+  amproc => 'brin_minmax_union' },
+{ amprocfamily => 'brin/float_minmax_ops', amproclefttype => 'float8',
+  amprocrighttype => 'float4', amprocnum => '1',
+  amproc => 'brin_minmax_opcinfo' },
+{ amprocfamily => 'brin/float_minmax_ops', amproclefttype => 'float8',
+  amprocrighttype => 'float4', amprocnum => '2',
+  amproc => 'brin_minmax_add_value' },
+{ amprocfamily => 'brin/float_minmax_ops', amproclefttype => 'float8',
+  amprocrighttype => 'float4', amprocnum => '3',
+  amproc => 'brin_minmax_consistent' },
+{ amprocfamily => 'brin/float_minmax_ops', amproclefttype => 'float8',
+  amprocrighttype => 'float4', amprocnum => '4',
+  amproc => 'brin_minmax_union' },
+
+# minmax macaddr
+{ amprocfamily => 'brin/macaddr_minmax_ops', amproclefttype => 'macaddr',
+  amprocrighttype => 'macaddr', amprocnum => '1',
+  amproc => 'brin_minmax_opcinfo' },
+{ amprocfamily => 'brin/macaddr_minmax_ops', amproclefttype => 'macaddr',
+  amprocrighttype => 'macaddr', amprocnum => '2',
+  amproc => 'brin_minmax_add_value' },
+{ amprocfamily => 'brin/macaddr_minmax_ops', amproclefttype => 'macaddr',
+  amprocrighttype => 'macaddr', amprocnum => '3',
+  amproc => 'brin_minmax_consistent' },
+{ amprocfamily => 'brin/macaddr_minmax_ops', amproclefttype => 'macaddr',
+  amprocrighttype => 'macaddr', amprocnum => '4',
+  amproc => 'brin_minmax_union' },
+
+# minmax macaddr8
+{ amprocfamily => 'brin/macaddr8_minmax_ops', amproclefttype => 'macaddr8',
+  amprocrighttype => 'macaddr8', amprocnum => '1',
+  amproc => 'brin_minmax_opcinfo' },
+{ amprocfamily => 'brin/macaddr8_minmax_ops', amproclefttype => 'macaddr8',
+  amprocrighttype => 'macaddr8', amprocnum => '2',
+  amproc => 'brin_minmax_add_value' },
+{ amprocfamily => 'brin/macaddr8_minmax_ops', amproclefttype => 'macaddr8',
+  amprocrighttype => 'macaddr8', amprocnum => '3',
+  amproc => 'brin_minmax_consistent' },
+{ amprocfamily => 'brin/macaddr8_minmax_ops', amproclefttype => 'macaddr8',
+  amprocrighttype => 'macaddr8', amprocnum => '4',
+  amproc => 'brin_minmax_union' },
+
+# minmax inet
+{ amprocfamily => 'brin/network_minmax_ops', amproclefttype => 'inet',
+  amprocrighttype => 'inet', amprocnum => '1',
+  amproc => 'brin_minmax_opcinfo' },
+{ amprocfamily => 'brin/network_minmax_ops', amproclefttype => 'inet',
+  amprocrighttype => 'inet', amprocnum => '2',
+  amproc => 'brin_minmax_add_value' },
+{ amprocfamily => 'brin/network_minmax_ops', amproclefttype => 'inet',
+  amprocrighttype => 'inet', amprocnum => '3',
+  amproc => 'brin_minmax_consistent' },
+{ amprocfamily => 'brin/network_minmax_ops', amproclefttype => 'inet',
+  amprocrighttype => 'inet', amprocnum => '4', amproc => 'brin_minmax_union' },
+
+# inclusion inet
+{ amprocfamily => 'brin/network_inclusion_ops', amproclefttype => 'inet',
+  amprocrighttype => 'inet', amprocnum => '1',
+  amproc => 'brin_inclusion_opcinfo' },
+{ amprocfamily => 'brin/network_inclusion_ops', amproclefttype => 'inet',
+  amprocrighttype => 'inet', amprocnum => '2',
+  amproc => 'brin_inclusion_add_value' },
+{ amprocfamily => 'brin/network_inclusion_ops', amproclefttype => 'inet',
+  amprocrighttype => 'inet', amprocnum => '3',
+  amproc => 'brin_inclusion_consistent' },
+{ amprocfamily => 'brin/network_inclusion_ops', amproclefttype => 'inet',
+  amprocrighttype => 'inet', amprocnum => '4',
+  amproc => 'brin_inclusion_union' },
+{ amprocfamily => 'brin/network_inclusion_ops', amproclefttype => 'inet',
+  amprocrighttype => 'inet', amprocnum => '11', amproc => 'inet_merge' },
+{ amprocfamily => 'brin/network_inclusion_ops', amproclefttype => 'inet',
+  amprocrighttype => 'inet', amprocnum => '12', amproc => 'inet_same_family' },
+{ amprocfamily => 'brin/network_inclusion_ops', amproclefttype => 'inet',
+  amprocrighttype => 'inet', amprocnum => '13', amproc => 'network_supeq' },
+
+# minmax character
+{ amprocfamily => 'brin/bpchar_minmax_ops', amproclefttype => 'bpchar',
+  amprocrighttype => 'bpchar', amprocnum => '1',
+  amproc => 'brin_minmax_opcinfo' },
+{ amprocfamily => 'brin/bpchar_minmax_ops', amproclefttype => 'bpchar',
+  amprocrighttype => 'bpchar', amprocnum => '2',
+  amproc => 'brin_minmax_add_value' },
+{ amprocfamily => 'brin/bpchar_minmax_ops', amproclefttype => 'bpchar',
+  amprocrighttype => 'bpchar', amprocnum => '3',
+  amproc => 'brin_minmax_consistent' },
+{ amprocfamily => 'brin/bpchar_minmax_ops', amproclefttype => 'bpchar',
+  amprocrighttype => 'bpchar', amprocnum => '4',
+  amproc => 'brin_minmax_union' },
+
+# minmax time without time zone
+{ amprocfamily => 'brin/time_minmax_ops', amproclefttype => 'time',
+  amprocrighttype => 'time', amprocnum => '1',
+  amproc => 'brin_minmax_opcinfo' },
+{ amprocfamily => 'brin/time_minmax_ops', amproclefttype => 'time',
+  amprocrighttype => 'time', amprocnum => '2',
+  amproc => 'brin_minmax_add_value' },
+{ amprocfamily => 'brin/time_minmax_ops', amproclefttype => 'time',
+  amprocrighttype => 'time', amprocnum => '3',
+  amproc => 'brin_minmax_consistent' },
+{ amprocfamily => 'brin/time_minmax_ops', amproclefttype => 'time',
+  amprocrighttype => 'time', amprocnum => '4', amproc => 'brin_minmax_union' },
+
+# minmax datetime (date, timestamp, timestamptz)
+{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamp',
+  amprocrighttype => 'timestamp', amprocnum => '1',
+  amproc => 'brin_minmax_opcinfo' },
+{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamp',
+  amprocrighttype => 'timestamp', amprocnum => '2',
+  amproc => 'brin_minmax_add_value' },
+{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamp',
+  amprocrighttype => 'timestamp', amprocnum => '3',
+  amproc => 'brin_minmax_consistent' },
+{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamp',
+  amprocrighttype => 'timestamp', amprocnum => '4',
+  amproc => 'brin_minmax_union' },
+{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamp',
+  amprocrighttype => 'timestamptz', amprocnum => '1',
+  amproc => 'brin_minmax_opcinfo' },
+{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamp',
+  amprocrighttype => 'timestamptz', amprocnum => '2',
+  amproc => 'brin_minmax_add_value' },
+{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamp',
+  amprocrighttype => 'timestamptz', amprocnum => '3',
+  amproc => 'brin_minmax_consistent' },
+{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamp',
+  amprocrighttype => 'timestamptz', amprocnum => '4',
+  amproc => 'brin_minmax_union' },
+{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamp',
+  amprocrighttype => 'date', amprocnum => '1',
+  amproc => 'brin_minmax_opcinfo' },
+{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamp',
+  amprocrighttype => 'date', amprocnum => '2',
+  amproc => 'brin_minmax_add_value' },
+{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamp',
+  amprocrighttype => 'date', amprocnum => '3',
+  amproc => 'brin_minmax_consistent' },
+{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamp',
+  amprocrighttype => 'date', amprocnum => '4', amproc => 'brin_minmax_union' },
+{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamptz',
+  amprocrighttype => 'timestamptz', amprocnum => '1',
+  amproc => 'brin_minmax_opcinfo' },
+{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamptz',
+  amprocrighttype => 'timestamptz', amprocnum => '2',
+  amproc => 'brin_minmax_add_value' },
+{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamptz',
+  amprocrighttype => 'timestamptz', amprocnum => '3',
+  amproc => 'brin_minmax_consistent' },
+{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamptz',
+  amprocrighttype => 'timestamptz', amprocnum => '4',
+  amproc => 'brin_minmax_union' },
+{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamptz',
+  amprocrighttype => 'timestamp', amprocnum => '1',
+  amproc => 'brin_minmax_opcinfo' },
+{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamptz',
+  amprocrighttype => 'timestamp', amprocnum => '2',
+  amproc => 'brin_minmax_add_value' },
+{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamptz',
+  amprocrighttype => 'timestamp', amprocnum => '3',
+  amproc => 'brin_minmax_consistent' },
+{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamptz',
+  amprocrighttype => 'timestamp', amprocnum => '4',
+  amproc => 'brin_minmax_union' },
+{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamptz',
+  amprocrighttype => 'date', amprocnum => '1',
+  amproc => 'brin_minmax_opcinfo' },
+{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamptz',
+  amprocrighttype => 'date', amprocnum => '2',
+  amproc => 'brin_minmax_add_value' },
+{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamptz',
+  amprocrighttype => 'date', amprocnum => '3',
+  amproc => 'brin_minmax_consistent' },
+{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamptz',
+  amprocrighttype => 'date', amprocnum => '4', amproc => 'brin_minmax_union' },
+{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'date',
+  amprocrighttype => 'date', amprocnum => '1',
+  amproc => 'brin_minmax_opcinfo' },
+{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'date',
+  amprocrighttype => 'date', amprocnum => '2',
+  amproc => 'brin_minmax_add_value' },
+{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'date',
+  amprocrighttype => 'date', amprocnum => '3',
+  amproc => 'brin_minmax_consistent' },
+{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'date',
+  amprocrighttype => 'date', amprocnum => '4', amproc => 'brin_minmax_union' },
+{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'date',
+  amprocrighttype => 'timestamp', amprocnum => '1',
+  amproc => 'brin_minmax_opcinfo' },
+{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'date',
+  amprocrighttype => 'timestamp', amprocnum => '2',
+  amproc => 'brin_minmax_add_value' },
+{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'date',
+  amprocrighttype => 'timestamp', amprocnum => '3',
+  amproc => 'brin_minmax_consistent' },
+{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'date',
+  amprocrighttype => 'timestamp', amprocnum => '4',
+  amproc => 'brin_minmax_union' },
+{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'date',
+  amprocrighttype => 'timestamptz', amprocnum => '1',
+  amproc => 'brin_minmax_opcinfo' },
+{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'date',
+  amprocrighttype => 'timestamptz', amprocnum => '2',
+  amproc => 'brin_minmax_add_value' },
+{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'date',
+  amprocrighttype => 'timestamptz', amprocnum => '3',
+  amproc => 'brin_minmax_consistent' },
+{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'date',
+  amprocrighttype => 'timestamptz', amprocnum => '4',
+  amproc => 'brin_minmax_union' },
+
+# minmax interval
+{ amprocfamily => 'brin/interval_minmax_ops', amproclefttype => 'interval',
+  amprocrighttype => 'interval', amprocnum => '1',
+  amproc => 'brin_minmax_opcinfo' },
+{ amprocfamily => 'brin/interval_minmax_ops', amproclefttype => 'interval',
+  amprocrighttype => 'interval', amprocnum => '2',
+  amproc => 'brin_minmax_add_value' },
+{ amprocfamily => 'brin/interval_minmax_ops', amproclefttype => 'interval',
+  amprocrighttype => 'interval', amprocnum => '3',
+  amproc => 'brin_minmax_consistent' },
+{ amprocfamily => 'brin/interval_minmax_ops', amproclefttype => 'interval',
+  amprocrighttype => 'interval', amprocnum => '4',
+  amproc => 'brin_minmax_union' },
+
+# minmax time with time zone
+{ amprocfamily => 'brin/timetz_minmax_ops', amproclefttype => 'timetz',
+  amprocrighttype => 'timetz', amprocnum => '1',
+  amproc => 'brin_minmax_opcinfo' },
+{ amprocfamily => 'brin/timetz_minmax_ops', amproclefttype => 'timetz',
+  amprocrighttype => 'timetz', amprocnum => '2',
+  amproc => 'brin_minmax_add_value' },
+{ amprocfamily => 'brin/timetz_minmax_ops', amproclefttype => 'timetz',
+  amprocrighttype => 'timetz', amprocnum => '3',
+  amproc => 'brin_minmax_consistent' },
+{ amprocfamily => 'brin/timetz_minmax_ops', amproclefttype => 'timetz',
+  amprocrighttype => 'timetz', amprocnum => '4',
+  amproc => 'brin_minmax_union' },
+
+# minmax bit
+{ amprocfamily => 'brin/bit_minmax_ops', amproclefttype => 'bit',
+  amprocrighttype => 'bit', amprocnum => '1', amproc => 'brin_minmax_opcinfo' },
+{ amprocfamily => 'brin/bit_minmax_ops', amproclefttype => 'bit',
+  amprocrighttype => 'bit', amprocnum => '2',
+  amproc => 'brin_minmax_add_value' },
+{ amprocfamily => 'brin/bit_minmax_ops', amproclefttype => 'bit',
+  amprocrighttype => 'bit', amprocnum => '3',
+  amproc => 'brin_minmax_consistent' },
+{ amprocfamily => 'brin/bit_minmax_ops', amproclefttype => 'bit',
+  amprocrighttype => 'bit', amprocnum => '4', amproc => 'brin_minmax_union' },
+
+# minmax bit varying
+{ amprocfamily => 'brin/varbit_minmax_ops', amproclefttype => 'varbit',
+  amprocrighttype => 'varbit', amprocnum => '1',
+  amproc => 'brin_minmax_opcinfo' },
+{ amprocfamily => 'brin/varbit_minmax_ops', amproclefttype => 'varbit',
+  amprocrighttype => 'varbit', amprocnum => '2',
+  amproc => 'brin_minmax_add_value' },
+{ amprocfamily => 'brin/varbit_minmax_ops', amproclefttype => 'varbit',
+  amprocrighttype => 'varbit', amprocnum => '3',
+  amproc => 'brin_minmax_consistent' },
+{ amprocfamily => 'brin/varbit_minmax_ops', amproclefttype => 'varbit',
+  amprocrighttype => 'varbit', amprocnum => '4',
+  amproc => 'brin_minmax_union' },
+
+# minmax numeric
+{ amprocfamily => 'brin/numeric_minmax_ops', amproclefttype => 'numeric',
+  amprocrighttype => 'numeric', amprocnum => '1',
+  amproc => 'brin_minmax_opcinfo' },
+{ amprocfamily => 'brin/numeric_minmax_ops', amproclefttype => 'numeric',
+  amprocrighttype => 'numeric', amprocnum => '2',
+  amproc => 'brin_minmax_add_value' },
+{ amprocfamily => 'brin/numeric_minmax_ops', amproclefttype => 'numeric',
+  amprocrighttype => 'numeric', amprocnum => '3',
+  amproc => 'brin_minmax_consistent' },
+{ amprocfamily => 'brin/numeric_minmax_ops', amproclefttype => 'numeric',
+  amprocrighttype => 'numeric', amprocnum => '4',
+  amproc => 'brin_minmax_union' },
+
+# minmax uuid
+{ amprocfamily => 'brin/uuid_minmax_ops', amproclefttype => 'uuid',
+  amprocrighttype => 'uuid', amprocnum => '1',
+  amproc => 'brin_minmax_opcinfo' },
+{ amprocfamily => 'brin/uuid_minmax_ops', amproclefttype => 'uuid',
+  amprocrighttype => 'uuid', amprocnum => '2',
+  amproc => 'brin_minmax_add_value' },
+{ amprocfamily => 'brin/uuid_minmax_ops', amproclefttype => 'uuid',
+  amprocrighttype => 'uuid', amprocnum => '3',
+  amproc => 'brin_minmax_consistent' },
+{ amprocfamily => 'brin/uuid_minmax_ops', amproclefttype => 'uuid',
+  amprocrighttype => 'uuid', amprocnum => '4', amproc => 'brin_minmax_union' },
+
+# inclusion range types
+{ amprocfamily => 'brin/range_inclusion_ops', amproclefttype => 'anyrange',
+  amprocrighttype => 'anyrange', amprocnum => '1',
+  amproc => 'brin_inclusion_opcinfo' },
+{ amprocfamily => 'brin/range_inclusion_ops', amproclefttype => 'anyrange',
+  amprocrighttype => 'anyrange', amprocnum => '2',
+  amproc => 'brin_inclusion_add_value' },
+{ amprocfamily => 'brin/range_inclusion_ops', amproclefttype => 'anyrange',
+  amprocrighttype => 'anyrange', amprocnum => '3',
+  amproc => 'brin_inclusion_consistent' },
+{ amprocfamily => 'brin/range_inclusion_ops', amproclefttype => 'anyrange',
+  amprocrighttype => 'anyrange', amprocnum => '4',
+  amproc => 'brin_inclusion_union' },
+{ amprocfamily => 'brin/range_inclusion_ops', amproclefttype => 'anyrange',
+  amprocrighttype => 'anyrange', amprocnum => '11', amproc => 'range_merge' },
+{ amprocfamily => 'brin/range_inclusion_ops', amproclefttype => 'anyrange',
+  amprocrighttype => 'anyrange', amprocnum => '13',
+  amproc => 'range_contains' },
+{ amprocfamily => 'brin/range_inclusion_ops', amproclefttype => 'anyrange',
+  amprocrighttype => 'anyrange', amprocnum => '14', amproc => 'isempty' },
+
+# minmax pg_lsn
+{ amprocfamily => 'brin/pg_lsn_minmax_ops', amproclefttype => 'pg_lsn',
+  amprocrighttype => 'pg_lsn', amprocnum => '1',
+  amproc => 'brin_minmax_opcinfo' },
+{ amprocfamily => 'brin/pg_lsn_minmax_ops', amproclefttype => 'pg_lsn',
+  amprocrighttype => 'pg_lsn', amprocnum => '2',
+  amproc => 'brin_minmax_add_value' },
+{ amprocfamily => 'brin/pg_lsn_minmax_ops', amproclefttype => 'pg_lsn',
+  amprocrighttype => 'pg_lsn', amprocnum => '3',
+  amproc => 'brin_minmax_consistent' },
+{ amprocfamily => 'brin/pg_lsn_minmax_ops', amproclefttype => 'pg_lsn',
+  amprocrighttype => 'pg_lsn', amprocnum => '4',
+  amproc => 'brin_minmax_union' },
+
+# inclusion box
+{ amprocfamily => 'brin/box_inclusion_ops', amproclefttype => 'box',
+  amprocrighttype => 'box', amprocnum => '1',
+  amproc => 'brin_inclusion_opcinfo' },
+{ amprocfamily => 'brin/box_inclusion_ops', amproclefttype => 'box',
+  amprocrighttype => 'box', amprocnum => '2',
+  amproc => 'brin_inclusion_add_value' },
+{ amprocfamily => 'brin/box_inclusion_ops', amproclefttype => 'box',
+  amprocrighttype => 'box', amprocnum => '3',
+  amproc => 'brin_inclusion_consistent' },
+{ amprocfamily => 'brin/box_inclusion_ops', amproclefttype => 'box',
+  amprocrighttype => 'box', amprocnum => '4',
+  amproc => 'brin_inclusion_union' },
+{ amprocfamily => 'brin/box_inclusion_ops', amproclefttype => 'box',
+  amprocrighttype => 'box', amprocnum => '11', amproc => 'bound_box' },
+{ amprocfamily => 'brin/box_inclusion_ops', amproclefttype => 'box',
+  amprocrighttype => 'box', amprocnum => '13', amproc => 'box_contain' },
+
+]
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_amproc.h b/contrib/libs/postgresql/src/include/catalog/pg_amproc.h
new file mode 100644
index 0000000000..e39bd70c29
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_amproc.h
@@ -0,0 +1,70 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_amproc.h
+ *	  definition of the "access method procedure" system catalog (pg_amproc)
+ *
+ * The amproc table identifies support procedures associated with index
+ * operator families and classes.  These procedures can't be listed in pg_amop
+ * since they are not the implementation of any indexable operator.
+ *
+ * The primary key for this table is <amprocfamily, amproclefttype,
+ * amprocrighttype, amprocnum>.  The "default" support functions for a
+ * particular opclass within the family are those with amproclefttype =
+ * amprocrighttype = opclass's opcintype.  These are the ones loaded into the
+ * relcache for an index and typically used for internal index operations.
+ * Other support functions are typically used to handle cross-type indexable
+ * operators with oprleft/oprright matching the entry's amproclefttype and
+ * amprocrighttype. The exact behavior depends on the index AM, however, and
+ * some don't pay attention to non-default functions at all.
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_amproc.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_AMPROC_H
+#define PG_AMPROC_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_amproc_d.h"
+
+/* ----------------
+ *		pg_amproc definition.  cpp turns this into
+ *		typedef struct FormData_pg_amproc
+ * ----------------
+ */
+CATALOG(pg_amproc,2603,AccessMethodProcedureRelationId)
+{
+	Oid			oid;			/* oid */
+
+	/* the index opfamily this entry is for */
+	Oid			amprocfamily BKI_LOOKUP(pg_opfamily);
+
+	/* procedure's left input data type */
+	Oid			amproclefttype BKI_LOOKUP(pg_type);
+
+	/* procedure's right input data type */
+	Oid			amprocrighttype BKI_LOOKUP(pg_type);
+
+	/* support procedure index */
+	int16		amprocnum;
+
+	/* OID of the proc */
+	regproc		amproc BKI_LOOKUP(pg_proc);
+} FormData_pg_amproc;
+
+/* ----------------
+ *		Form_pg_amproc corresponds to a pointer to a tuple with
+ *		the format of pg_amproc relation.
+ * ----------------
+ */
+typedef FormData_pg_amproc *Form_pg_amproc;
+
+#endif							/* PG_AMPROC_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_amproc_d.h b/contrib/libs/postgresql/src/include/catalog/pg_amproc_d.h
new file mode 100644
index 0000000000..7df62bb78f
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_amproc_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_amproc_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_attrdef.h b/contrib/libs/postgresql/src/include/catalog/pg_attrdef.h
new file mode 100644
index 0000000000..7b661df311
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_attrdef.h
@@ -0,0 +1,49 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_attrdef.h
+ *	  definition of the "attribute defaults" system catalog (pg_attrdef)
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_attrdef.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_ATTRDEF_H
+#define PG_ATTRDEF_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_attrdef_d.h"
+
+/* ----------------
+ *		pg_attrdef definition.  cpp turns this into
+ *		typedef struct FormData_pg_attrdef
+ * ----------------
+ */
+CATALOG(pg_attrdef,2604,AttrDefaultRelationId)
+{
+	Oid			oid;			/* oid */
+
+	Oid			adrelid;		/* OID of table containing attribute */
+	int16		adnum;			/* attnum of attribute */
+
+#ifdef CATALOG_VARLEN			/* variable-length fields start here */
+	pg_node_tree adbin BKI_FORCE_NOT_NULL;	/* nodeToString representation of
+											 * default */
+#endif
+} FormData_pg_attrdef;
+
+/* ----------------
+ *		Form_pg_attrdef corresponds to a pointer to a tuple with
+ *		the format of pg_attrdef relation.
+ * ----------------
+ */
+typedef FormData_pg_attrdef *Form_pg_attrdef;
+
+#endif							/* PG_ATTRDEF_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_attrdef_d.h b/contrib/libs/postgresql/src/include/catalog/pg_attrdef_d.h
new file mode 100644
index 0000000000..a5544bf1e0
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_attrdef_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_attrdef_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_attribute.h b/contrib/libs/postgresql/src/include/catalog/pg_attribute.h
new file mode 100644
index 0000000000..a4cc80adad
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_attribute.h
@@ -0,0 +1,204 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_attribute.h
+ *	  definition of the "attribute" system catalog (pg_attribute)
+ *
+ * The initial contents of pg_attribute are generated at compile time by
+ * genbki.pl, so there is no pg_attribute.dat file.  Only "bootstrapped"
+ * relations need be included.
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_attribute.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_ATTRIBUTE_H
+#define PG_ATTRIBUTE_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_attribute_d.h"
+
+/* ----------------
+ *		pg_attribute definition.  cpp turns this into
+ *		typedef struct FormData_pg_attribute
+ *
+ *		If you change the following, make sure you change the structs for
+ *		system attributes in catalog/heap.c also.
+ *		You may need to change catalog/genbki.pl as well.
+ * ----------------
+ */
+CATALOG(pg_attribute,1249,AttributeRelationId) BKI_BOOTSTRAP BKI_ROWTYPE_OID(75,AttributeRelation_Rowtype_Id) BKI_SCHEMA_MACRO
+{
+	Oid			attrelid;		/* OID of relation containing this attribute */
+	NameData	attname;		/* name of attribute */
+
+	/*
+	 * atttypid is the OID of the instance in Catalog Class pg_type that
+	 * defines the data type of this attribute (e.g. int4).  Information in
+	 * that instance is redundant with the attlen, attbyval, and attalign
+	 * attributes of this instance, so they had better match or Postgres will
+	 * fail.
+	 */
+	Oid			atttypid;
+
+	/*
+	 * attstattarget is the target number of statistics datapoints to collect
+	 * during VACUUM ANALYZE of this column.  A zero here indicates that we do
+	 * not wish to collect any stats about this column. A "-1" here indicates
+	 * that no value has been explicitly set for this column, so ANALYZE
+	 * should use the default setting.
+	 */
+	int32		attstattarget BKI_DEFAULT(-1);
+
+	/*
+	 * attlen is a copy of the typlen field from pg_type for this attribute.
+	 * See atttypid comments above.
+	 */
+	int16		attlen;
+
+	/*
+	 * attnum is the "attribute number" for the attribute:	A value that
+	 * uniquely identifies this attribute within its class. For user
+	 * attributes, Attribute numbers are greater than 0 and not greater than
+	 * the number of attributes in the class. I.e. if the Class pg_class says
+	 * that Class XYZ has 10 attributes, then the user attribute numbers in
+	 * Class pg_attribute must be 1-10.
+	 *
+	 * System attributes have attribute numbers less than 0 that are unique
+	 * within the class, but not constrained to any particular range.
+	 *
+	 * Note that (attnum - 1) is often used as the index to an array.
+	 */
+	int16		attnum;
+
+	/*
+	 * attndims is the declared number of dimensions, if an array type,
+	 * otherwise zero.
+	 */
+	int32		attndims;
+
+	/*
+	 * fastgetattr() uses attcacheoff to cache byte offsets of attributes in
+	 * heap tuples.  The value actually stored in pg_attribute (-1) indicates
+	 * no cached value.  But when we copy these tuples into a tuple
+	 * descriptor, we may then update attcacheoff in the copies. This speeds
+	 * up the attribute walking process.
+	 */
+	int32		attcacheoff BKI_DEFAULT(-1);
+
+	/*
+	 * atttypmod records type-specific data supplied at table creation time
+	 * (for example, the max length of a varchar field).  It is passed to
+	 * type-specific input and output functions as the third argument. The
+	 * value will generally be -1 for types that do not need typmod.
+	 */
+	int32		atttypmod BKI_DEFAULT(-1);
+
+	/*
+	 * attbyval is a copy of the typbyval field from pg_type for this
+	 * attribute.  See atttypid comments above.
+	 */
+	bool		attbyval;
+
+	/*----------
+	 * attstorage tells for VARLENA attributes, what the heap access
+	 * methods can do to it if a given tuple doesn't fit into a page.
+	 * Possible values are as for pg_type.typstorage (see TYPSTORAGE macros).
+	 *----------
+	 */
+	char		attstorage;
+
+	/*
+	 * attalign is a copy of the typalign field from pg_type for this
+	 * attribute.  See atttypid comments above.
+	 */
+	char		attalign;
+
+	/* This flag represents the "NOT NULL" constraint */
+	bool		attnotnull;
+
+	/* Has DEFAULT value or not */
+	bool		atthasdef BKI_DEFAULT(f);
+
+	/* Has a missing value or not */
+	bool		atthasmissing BKI_DEFAULT(f);
+
+	/* One of the ATTRIBUTE_IDENTITY_* constants below, or '\0' */
+	char		attidentity BKI_DEFAULT('\0');
+
+	/* One of the ATTRIBUTE_GENERATED_* constants below, or '\0' */
+	char		attgenerated BKI_DEFAULT('\0');
+
+	/* Is dropped (ie, logically invisible) or not */
+	bool		attisdropped BKI_DEFAULT(f);
+
+	/*
+	 * This flag specifies whether this column has ever had a local
+	 * definition.  It is set for normal non-inherited columns, but also for
+	 * columns that are inherited from parents if also explicitly listed in
+	 * CREATE TABLE INHERITS.  It is also set when inheritance is removed from
+	 * a table with ALTER TABLE NO INHERIT.  If the flag is set, the column is
+	 * not dropped by a parent's DROP COLUMN even if this causes the column's
+	 * attinhcount to become zero.
+	 */
+	bool		attislocal BKI_DEFAULT(t);
+
+	/* Number of times inherited from direct parent relation(s) */
+	int32		attinhcount BKI_DEFAULT(0);
+
+	/* attribute's collation */
+	Oid			attcollation;
+
+#ifdef CATALOG_VARLEN			/* variable-length fields start here */
+	/* NOTE: The following fields are not present in tuple descriptors. */
+
+	/* Column-level access permissions */
+	aclitem		attacl[1] BKI_DEFAULT(_null_);
+
+	/* Column-level options */
+	text		attoptions[1] BKI_DEFAULT(_null_);
+
+	/* Column-level FDW options */
+	text		attfdwoptions[1] BKI_DEFAULT(_null_);
+
+	/*
+	 * Missing value for added columns. This is a one element array which lets
+	 * us store a value of the attribute type here.
+	 */
+	anyarray	attmissingval BKI_DEFAULT(_null_);
+#endif
+} FormData_pg_attribute;
+
+/*
+ * ATTRIBUTE_FIXED_PART_SIZE is the size of the fixed-layout,
+ * guaranteed-not-null part of a pg_attribute row.  This is in fact as much
+ * of the row as gets copied into tuple descriptors, so don't expect you
+ * can access fields beyond attcollation except in a real tuple!
+ */
+#define ATTRIBUTE_FIXED_PART_SIZE \
+	(offsetof(FormData_pg_attribute,attcollation) + sizeof(Oid))
+
+/* ----------------
+ *		Form_pg_attribute corresponds to a pointer to a tuple with
+ *		the format of pg_attribute relation.
+ * ----------------
+ */
+typedef FormData_pg_attribute *Form_pg_attribute;
+
+#ifdef EXPOSE_TO_CLIENT_CODE
+
+#define		  ATTRIBUTE_IDENTITY_ALWAYS		'a'
+#define		  ATTRIBUTE_IDENTITY_BY_DEFAULT 'd'
+
+#define		  ATTRIBUTE_GENERATED_STORED	's'
+
+#endif							/* EXPOSE_TO_CLIENT_CODE */
+
+#endif							/* PG_ATTRIBUTE_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_attribute_d.h b/contrib/libs/postgresql/src/include/catalog/pg_attribute_d.h
new file mode 100644
index 0000000000..2fea2c5e48
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_attribute_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_attribute_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_auth_members.h b/contrib/libs/postgresql/src/include/catalog/pg_auth_members.h
new file mode 100644
index 0000000000..8563feb6c5
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_auth_members.h
@@ -0,0 +1,45 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_auth_members.h
+ *	  definition of the "authorization identifier members" system catalog
+ *	  (pg_auth_members).
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_auth_members.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_AUTH_MEMBERS_H
+#define PG_AUTH_MEMBERS_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_auth_members_d.h"
+
+/* ----------------
+ *		pg_auth_members definition.  cpp turns this into
+ *		typedef struct FormData_pg_auth_members
+ * ----------------
+ */
+CATALOG(pg_auth_members,1261,AuthMemRelationId) BKI_SHARED_RELATION BKI_ROWTYPE_OID(2843,AuthMemRelation_Rowtype_Id) BKI_SCHEMA_MACRO
+{
+	Oid			roleid;			/* ID of a role */
+	Oid			member;			/* ID of a member of that role */
+	Oid			grantor;		/* who granted the membership */
+	bool		admin_option;	/* granted with admin option? */
+} FormData_pg_auth_members;
+
+/* ----------------
+ *		Form_pg_auth_members corresponds to a pointer to a tuple with
+ *		the format of pg_auth_members relation.
+ * ----------------
+ */
+typedef FormData_pg_auth_members *Form_pg_auth_members;
+
+#endif							/* PG_AUTH_MEMBERS_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_auth_members_d.h b/contrib/libs/postgresql/src/include/catalog/pg_auth_members_d.h
new file mode 100644
index 0000000000..8298e984f3
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_auth_members_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_auth_members_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_authid.dat b/contrib/libs/postgresql/src/include/catalog/pg_authid.dat
new file mode 100644
index 0000000000..7c08851550
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_authid.dat
@@ -0,0 +1,64 @@
+#----------------------------------------------------------------------
+#
+# pg_authid.dat
+#    Initial contents of the pg_authid system catalog.
+#
+# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+# Portions Copyright (c) 1994, Regents of the University of California
+#
+# src/include/catalog/pg_authid.dat
+#
+#----------------------------------------------------------------------
+
+[
+
+# The C code typically refers to these roles using the #define symbols,
+# so make sure every entry has an oid_symbol value.
+
+{ oid => '10', oid_symbol => 'BOOTSTRAP_SUPERUSERID',
+  rolname => 'POSTGRES', rolsuper => 't', rolinherit => 't',
+  rolcreaterole => 't', rolcreatedb => 't', rolcanlogin => 't',
+  rolreplication => 't', rolbypassrls => 't', rolconnlimit => '-1',
+  rolpassword => '_null_', rolvaliduntil => '_null_' },
+{ oid => '3373', oid_symbol => 'DEFAULT_ROLE_MONITOR',
+  rolname => 'pg_monitor', rolsuper => 'f', rolinherit => 't',
+  rolcreaterole => 'f', rolcreatedb => 'f', rolcanlogin => 'f',
+  rolreplication => 'f', rolbypassrls => 'f', rolconnlimit => '-1',
+  rolpassword => '_null_', rolvaliduntil => '_null_' },
+{ oid => '3374', oid_symbol => 'DEFAULT_ROLE_READ_ALL_SETTINGS',
+  rolname => 'pg_read_all_settings', rolsuper => 'f', rolinherit => 't',
+  rolcreaterole => 'f', rolcreatedb => 'f', rolcanlogin => 'f',
+  rolreplication => 'f', rolbypassrls => 'f', rolconnlimit => '-1',
+  rolpassword => '_null_', rolvaliduntil => '_null_' },
+{ oid => '3375', oid_symbol => 'DEFAULT_ROLE_READ_ALL_STATS',
+  rolname => 'pg_read_all_stats', rolsuper => 'f', rolinherit => 't',
+  rolcreaterole => 'f', rolcreatedb => 'f', rolcanlogin => 'f',
+  rolreplication => 'f', rolbypassrls => 'f', rolconnlimit => '-1',
+  rolpassword => '_null_', rolvaliduntil => '_null_' },
+{ oid => '3377', oid_symbol => 'DEFAULT_ROLE_STAT_SCAN_TABLES',
+  rolname => 'pg_stat_scan_tables', rolsuper => 'f', rolinherit => 't',
+  rolcreaterole => 'f', rolcreatedb => 'f', rolcanlogin => 'f',
+  rolreplication => 'f', rolbypassrls => 'f', rolconnlimit => '-1',
+  rolpassword => '_null_', rolvaliduntil => '_null_' },
+{ oid => '4569', oid_symbol => 'DEFAULT_ROLE_READ_SERVER_FILES',
+  rolname => 'pg_read_server_files', rolsuper => 'f', rolinherit => 't',
+  rolcreaterole => 'f', rolcreatedb => 'f', rolcanlogin => 'f',
+  rolreplication => 'f', rolbypassrls => 'f', rolconnlimit => '-1',
+  rolpassword => '_null_', rolvaliduntil => '_null_' },
+{ oid => '4570', oid_symbol => 'DEFAULT_ROLE_WRITE_SERVER_FILES',
+  rolname => 'pg_write_server_files', rolsuper => 'f', rolinherit => 't',
+  rolcreaterole => 'f', rolcreatedb => 'f', rolcanlogin => 'f',
+  rolreplication => 'f', rolbypassrls => 'f', rolconnlimit => '-1',
+  rolpassword => '_null_', rolvaliduntil => '_null_' },
+{ oid => '4571', oid_symbol => 'DEFAULT_ROLE_EXECUTE_SERVER_PROGRAM',
+  rolname => 'pg_execute_server_program', rolsuper => 'f', rolinherit => 't',
+  rolcreaterole => 'f', rolcreatedb => 'f', rolcanlogin => 'f',
+  rolreplication => 'f', rolbypassrls => 'f', rolconnlimit => '-1',
+  rolpassword => '_null_', rolvaliduntil => '_null_' },
+{ oid => '4200', oid_symbol => 'DEFAULT_ROLE_SIGNAL_BACKENDID',
+  rolname => 'pg_signal_backend', rolsuper => 'f', rolinherit => 't',
+  rolcreaterole => 'f', rolcreatedb => 'f', rolcanlogin => 'f',
+  rolreplication => 'f', rolbypassrls => 'f', rolconnlimit => '-1',
+  rolpassword => '_null_', rolvaliduntil => '_null_' },
+
+]
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_authid.h b/contrib/libs/postgresql/src/include/catalog/pg_authid.h
new file mode 100644
index 0000000000..88a5373080
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_authid.h
@@ -0,0 +1,58 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_authid.h
+ *	  definition of the "authorization identifier" system catalog (pg_authid)
+ *
+ *	  pg_shadow and pg_group are now publicly accessible views on pg_authid.
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_authid.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_AUTHID_H
+#define PG_AUTHID_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_authid_d.h"
+
+/* ----------------
+ *		pg_authid definition.  cpp turns this into
+ *		typedef struct FormData_pg_authid
+ * ----------------
+ */
+CATALOG(pg_authid,1260,AuthIdRelationId) BKI_SHARED_RELATION BKI_ROWTYPE_OID(2842,AuthIdRelation_Rowtype_Id) BKI_SCHEMA_MACRO
+{
+	Oid			oid;			/* oid */
+	NameData	rolname;		/* name of role */
+	bool		rolsuper;		/* read this field via superuser() only! */
+	bool		rolinherit;		/* inherit privileges from other roles? */
+	bool		rolcreaterole;	/* allowed to create more roles? */
+	bool		rolcreatedb;	/* allowed to create databases? */
+	bool		rolcanlogin;	/* allowed to log in as session user? */
+	bool		rolreplication; /* role used for streaming replication */
+	bool		rolbypassrls;	/* bypasses row level security? */
+	int32		rolconnlimit;	/* max connections allowed (-1=no limit) */
+
+	/* remaining fields may be null; use heap_getattr to read them! */
+#ifdef CATALOG_VARLEN			/* variable-length fields start here */
+	text		rolpassword;	/* password, if any */
+	timestamptz rolvaliduntil;	/* password expiration time, if any */
+#endif
+} FormData_pg_authid;
+
+/* ----------------
+ *		Form_pg_authid corresponds to a pointer to a tuple with
+ *		the format of pg_authid relation.
+ * ----------------
+ */
+typedef FormData_pg_authid *Form_pg_authid;
+
+#endif							/* PG_AUTHID_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_authid_d.h b/contrib/libs/postgresql/src/include/catalog/pg_authid_d.h
new file mode 100644
index 0000000000..ac7acb4f82
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_authid_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_authid_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_cast.dat b/contrib/libs/postgresql/src/include/catalog/pg_cast.dat
new file mode 100644
index 0000000000..5a58f50fbb
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_cast.dat
@@ -0,0 +1,533 @@
+#----------------------------------------------------------------------
+#
+# pg_cast.dat
+#    Initial contents of the pg_cast system catalog.
+#
+# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+# Portions Copyright (c) 1994, Regents of the University of California
+#
+# src/include/catalog/pg_cast.dat
+#
+#----------------------------------------------------------------------
+
+[
+
+# Note: this table has OIDs, but we don't bother to assign them manually,
+# since nothing needs to know the specific OID of any built-in cast.
+
+# Numeric category: implicit casts are allowed in the direction
+# int2->int4->int8->numeric->float4->float8, while casts in the
+# reverse direction are assignment-only.
+{ castsource => 'int8', casttarget => 'int2', castfunc => 'int2(int8)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'int8', casttarget => 'int4', castfunc => 'int4(int8)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'int8', casttarget => 'float4', castfunc => 'float4(int8)',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'int8', casttarget => 'float8', castfunc => 'float8(int8)',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'int8', casttarget => 'numeric', castfunc => 'numeric(int8)',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'int2', casttarget => 'int8', castfunc => 'int8(int2)',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'int2', casttarget => 'int4', castfunc => 'int4(int2)',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'int2', casttarget => 'float4', castfunc => 'float4(int2)',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'int2', casttarget => 'float8', castfunc => 'float8(int2)',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'int2', casttarget => 'numeric', castfunc => 'numeric(int2)',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'int4', casttarget => 'int8', castfunc => 'int8(int4)',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'int4', casttarget => 'int2', castfunc => 'int2(int4)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'int4', casttarget => 'float4', castfunc => 'float4(int4)',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'int4', casttarget => 'float8', castfunc => 'float8(int4)',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'int4', casttarget => 'numeric', castfunc => 'numeric(int4)',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'float4', casttarget => 'int8', castfunc => 'int8(float4)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'float4', casttarget => 'int2', castfunc => 'int2(float4)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'float4', casttarget => 'int4', castfunc => 'int4(float4)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'float4', casttarget => 'float8', castfunc => 'float8(float4)',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'float4', casttarget => 'numeric',
+  castfunc => 'numeric(float4)', castcontext => 'a', castmethod => 'f' },
+{ castsource => 'float8', casttarget => 'int8', castfunc => 'int8(float8)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'float8', casttarget => 'int2', castfunc => 'int2(float8)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'float8', casttarget => 'int4', castfunc => 'int4(float8)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'float8', casttarget => 'float4', castfunc => 'float4(float8)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'float8', casttarget => 'numeric',
+  castfunc => 'numeric(float8)', castcontext => 'a', castmethod => 'f' },
+{ castsource => 'numeric', casttarget => 'int8', castfunc => 'int8(numeric)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'numeric', casttarget => 'int2', castfunc => 'int2(numeric)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'numeric', casttarget => 'int4', castfunc => 'int4(numeric)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'numeric', casttarget => 'float4',
+  castfunc => 'float4(numeric)', castcontext => 'i', castmethod => 'f' },
+{ castsource => 'numeric', casttarget => 'float8',
+  castfunc => 'float8(numeric)', castcontext => 'i', castmethod => 'f' },
+{ castsource => 'money', casttarget => 'numeric', castfunc => 'numeric(money)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'numeric', casttarget => 'money', castfunc => 'money(numeric)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'int4', casttarget => 'money', castfunc => 'money(int4)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'int8', casttarget => 'money', castfunc => 'money(int8)',
+  castcontext => 'a', castmethod => 'f' },
+
+# Allow explicit coercions between int4 and bool
+{ castsource => 'int4', casttarget => 'bool', castfunc => 'bool(int4)',
+  castcontext => 'e', castmethod => 'f' },
+{ castsource => 'bool', casttarget => 'int4', castfunc => 'int4(bool)',
+  castcontext => 'e', castmethod => 'f' },
+
+# Allow explicit coercions between xid8 and xid
+{ castsource => 'xid8', casttarget => 'xid', castfunc => 'xid(xid8)',
+  castcontext => 'e', castmethod => 'f' },
+
+# OID category: allow implicit conversion from any integral type (including
+# int8, to support OID literals > 2G) to OID, as well as assignment coercion
+# from OID to int4 or int8.  Similarly for each OID-alias type.  Also allow
+# implicit coercions between OID and each OID-alias type, as well as
+# regproc<->regprocedure and regoper<->regoperator.  (Other coercions
+# between alias types must pass through OID.)  Lastly, there are implicit
+# casts from text and varchar to regclass, which exist mainly to support
+# legacy forms of nextval() and related functions.
+{ castsource => 'int8', casttarget => 'oid', castfunc => 'oid',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'int2', casttarget => 'oid', castfunc => 'int4(int2)',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'int4', casttarget => 'oid', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'oid', casttarget => 'int8', castfunc => 'int8(oid)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'oid', casttarget => 'int4', castfunc => '0',
+  castcontext => 'a', castmethod => 'b' },
+{ castsource => 'oid', casttarget => 'regproc', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'regproc', casttarget => 'oid', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'int8', casttarget => 'regproc', castfunc => 'oid',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'int2', casttarget => 'regproc', castfunc => 'int4(int2)',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'int4', casttarget => 'regproc', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'regproc', casttarget => 'int8', castfunc => 'int8(oid)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'regproc', casttarget => 'int4', castfunc => '0',
+  castcontext => 'a', castmethod => 'b' },
+{ castsource => 'regproc', casttarget => 'regprocedure', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'regprocedure', casttarget => 'regproc', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'oid', casttarget => 'regprocedure', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'regprocedure', casttarget => 'oid', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'int8', casttarget => 'regprocedure', castfunc => 'oid',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'int2', casttarget => 'regprocedure', castfunc => 'int4(int2)',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'int4', casttarget => 'regprocedure', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'regprocedure', casttarget => 'int8', castfunc => 'int8(oid)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'regprocedure', casttarget => 'int4', castfunc => '0',
+  castcontext => 'a', castmethod => 'b' },
+{ castsource => 'oid', casttarget => 'regoper', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'regoper', casttarget => 'oid', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'int8', casttarget => 'regoper', castfunc => 'oid',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'int2', casttarget => 'regoper', castfunc => 'int4(int2)',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'int4', casttarget => 'regoper', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'regoper', casttarget => 'int8', castfunc => 'int8(oid)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'regoper', casttarget => 'int4', castfunc => '0',
+  castcontext => 'a', castmethod => 'b' },
+{ castsource => 'regoper', casttarget => 'regoperator', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'regoperator', casttarget => 'regoper', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'oid', casttarget => 'regoperator', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'regoperator', casttarget => 'oid', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'int8', casttarget => 'regoperator', castfunc => 'oid',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'int2', casttarget => 'regoperator', castfunc => 'int4(int2)',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'int4', casttarget => 'regoperator', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'regoperator', casttarget => 'int8', castfunc => 'int8(oid)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'regoperator', casttarget => 'int4', castfunc => '0',
+  castcontext => 'a', castmethod => 'b' },
+{ castsource => 'oid', casttarget => 'regclass', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'regclass', casttarget => 'oid', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'int8', casttarget => 'regclass', castfunc => 'oid',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'int2', casttarget => 'regclass', castfunc => 'int4(int2)',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'int4', casttarget => 'regclass', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'regclass', casttarget => 'int8', castfunc => 'int8(oid)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'regclass', casttarget => 'int4', castfunc => '0',
+  castcontext => 'a', castmethod => 'b' },
+{ castsource => 'oid', casttarget => 'regcollation', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'regcollation', casttarget => 'oid', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'int8', casttarget => 'regcollation', castfunc => 'oid',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'int2', casttarget => 'regcollation', castfunc => 'int4(int2)',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'int4', casttarget => 'regcollation', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'regcollation', casttarget => 'int8', castfunc => 'int8(oid)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'regcollation', casttarget => 'int4', castfunc => '0',
+  castcontext => 'a', castmethod => 'b' },
+{ castsource => 'oid', casttarget => 'regtype', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'regtype', casttarget => 'oid', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'int8', casttarget => 'regtype', castfunc => 'oid',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'int2', casttarget => 'regtype', castfunc => 'int4(int2)',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'int4', casttarget => 'regtype', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'regtype', casttarget => 'int8', castfunc => 'int8(oid)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'regtype', casttarget => 'int4', castfunc => '0',
+  castcontext => 'a', castmethod => 'b' },
+{ castsource => 'oid', casttarget => 'regconfig', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'regconfig', casttarget => 'oid', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'int8', casttarget => 'regconfig', castfunc => 'oid',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'int2', casttarget => 'regconfig', castfunc => 'int4(int2)',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'int4', casttarget => 'regconfig', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'regconfig', casttarget => 'int8', castfunc => 'int8(oid)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'regconfig', casttarget => 'int4', castfunc => '0',
+  castcontext => 'a', castmethod => 'b' },
+{ castsource => 'oid', casttarget => 'regdictionary', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'regdictionary', casttarget => 'oid', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'int8', casttarget => 'regdictionary', castfunc => 'oid',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'int2', casttarget => 'regdictionary', castfunc => 'int4(int2)',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'int4', casttarget => 'regdictionary', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'regdictionary', casttarget => 'int8', castfunc => 'int8(oid)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'regdictionary', casttarget => 'int4', castfunc => '0',
+  castcontext => 'a', castmethod => 'b' },
+{ castsource => 'text', casttarget => 'regclass', castfunc => 'regclass',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'varchar', casttarget => 'regclass', castfunc => 'regclass',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'oid', casttarget => 'regrole', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'regrole', casttarget => 'oid', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'int8', casttarget => 'regrole', castfunc => 'oid',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'int2', casttarget => 'regrole', castfunc => 'int4(int2)',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'int4', casttarget => 'regrole', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'regrole', casttarget => 'int8', castfunc => 'int8(oid)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'regrole', casttarget => 'int4', castfunc => '0',
+  castcontext => 'a', castmethod => 'b' },
+{ castsource => 'oid', casttarget => 'regnamespace', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'regnamespace', casttarget => 'oid', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'int8', casttarget => 'regnamespace', castfunc => 'oid',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'int2', casttarget => 'regnamespace', castfunc => 'int4(int2)',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'int4', casttarget => 'regnamespace', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'regnamespace', casttarget => 'int8', castfunc => 'int8(oid)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'regnamespace', casttarget => 'int4', castfunc => '0',
+  castcontext => 'a', castmethod => 'b' },
+
+# String category
+{ castsource => 'text', casttarget => 'bpchar', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'text', casttarget => 'varchar', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'bpchar', casttarget => 'text', castfunc => 'text(bpchar)',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'bpchar', casttarget => 'varchar', castfunc => 'text(bpchar)',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'varchar', casttarget => 'text', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'varchar', casttarget => 'bpchar', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'char', casttarget => 'text', castfunc => 'text(char)',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'char', casttarget => 'bpchar', castfunc => 'bpchar(char)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'char', casttarget => 'varchar', castfunc => 'text(char)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'name', casttarget => 'text', castfunc => 'text(name)',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'name', casttarget => 'bpchar', castfunc => 'bpchar(name)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'name', casttarget => 'varchar', castfunc => 'varchar(name)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'text', casttarget => 'char', castfunc => 'char(text)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'bpchar', casttarget => 'char', castfunc => 'char(text)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'varchar', casttarget => 'char', castfunc => 'char(text)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'text', casttarget => 'name', castfunc => 'name(text)',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'bpchar', casttarget => 'name', castfunc => 'name(bpchar)',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'varchar', casttarget => 'name', castfunc => 'name(varchar)',
+  castcontext => 'i', castmethod => 'f' },
+
+# Allow explicit coercions between int4 and "char"
+{ castsource => 'char', casttarget => 'int4', castfunc => 'int4(char)',
+  castcontext => 'e', castmethod => 'f' },
+{ castsource => 'int4', casttarget => 'char', castfunc => 'char(int4)',
+  castcontext => 'e', castmethod => 'f' },
+
+# pg_node_tree can be coerced to, but not from, text
+{ castsource => 'pg_node_tree', casttarget => 'text', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+
+# pg_ndistinct can be coerced to, but not from, bytea and text
+{ castsource => 'pg_ndistinct', casttarget => 'bytea', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'pg_ndistinct', casttarget => 'text', castfunc => '0',
+  castcontext => 'i', castmethod => 'i' },
+
+# pg_dependencies can be coerced to, but not from, bytea and text
+{ castsource => 'pg_dependencies', casttarget => 'bytea', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'pg_dependencies', casttarget => 'text', castfunc => '0',
+  castcontext => 'i', castmethod => 'i' },
+
+# pg_mcv_list can be coerced to, but not from, bytea and text
+{ castsource => 'pg_mcv_list', casttarget => 'bytea', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'pg_mcv_list', casttarget => 'text', castfunc => '0',
+  castcontext => 'i', castmethod => 'i' },
+
+# Datetime category
+{ castsource => 'date', casttarget => 'timestamp',
+  castfunc => 'timestamp(date)', castcontext => 'i', castmethod => 'f' },
+{ castsource => 'date', casttarget => 'timestamptz',
+  castfunc => 'timestamptz(date)', castcontext => 'i', castmethod => 'f' },
+{ castsource => 'time', casttarget => 'interval', castfunc => 'interval(time)',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'time', casttarget => 'timetz', castfunc => 'timetz(time)',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'timestamp', casttarget => 'date',
+  castfunc => 'date(timestamp)', castcontext => 'a', castmethod => 'f' },
+{ castsource => 'timestamp', casttarget => 'time',
+  castfunc => 'time(timestamp)', castcontext => 'a', castmethod => 'f' },
+{ castsource => 'timestamp', casttarget => 'timestamptz',
+  castfunc => 'timestamptz(timestamp)', castcontext => 'i', castmethod => 'f' },
+{ castsource => 'timestamptz', casttarget => 'date',
+  castfunc => 'date(timestamptz)', castcontext => 'a', castmethod => 'f' },
+{ castsource => 'timestamptz', casttarget => 'time',
+  castfunc => 'time(timestamptz)', castcontext => 'a', castmethod => 'f' },
+{ castsource => 'timestamptz', casttarget => 'timestamp',
+  castfunc => 'timestamp(timestamptz)', castcontext => 'a', castmethod => 'f' },
+{ castsource => 'timestamptz', casttarget => 'timetz',
+  castfunc => 'timetz(timestamptz)', castcontext => 'a', castmethod => 'f' },
+{ castsource => 'interval', casttarget => 'time', castfunc => 'time(interval)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'timetz', casttarget => 'time', castfunc => 'time(timetz)',
+  castcontext => 'a', castmethod => 'f' },
+
+# Geometric category
+{ castsource => 'point', casttarget => 'box', castfunc => 'box(point)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'lseg', casttarget => 'point', castfunc => 'point(lseg)',
+  castcontext => 'e', castmethod => 'f' },
+{ castsource => 'path', casttarget => 'point', castfunc => 'point(path)',
+  castcontext => 'e', castmethod => 'f' },
+{ castsource => 'path', casttarget => 'polygon', castfunc => 'polygon(path)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'box', casttarget => 'point', castfunc => 'point(box)',
+  castcontext => 'e', castmethod => 'f' },
+{ castsource => 'box', casttarget => 'lseg', castfunc => 'lseg(box)',
+  castcontext => 'e', castmethod => 'f' },
+{ castsource => 'box', casttarget => 'polygon', castfunc => 'polygon(box)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'box', casttarget => 'circle', castfunc => 'circle(box)',
+  castcontext => 'e', castmethod => 'f' },
+{ castsource => 'polygon', casttarget => 'point', castfunc => 'point(polygon)',
+  castcontext => 'e', castmethod => 'f' },
+{ castsource => 'polygon', casttarget => 'path', castfunc => 'path',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'polygon', casttarget => 'box', castfunc => 'box(polygon)',
+  castcontext => 'e', castmethod => 'f' },
+{ castsource => 'polygon', casttarget => 'circle',
+  castfunc => 'circle(polygon)', castcontext => 'e', castmethod => 'f' },
+{ castsource => 'circle', casttarget => 'point', castfunc => 'point(circle)',
+  castcontext => 'e', castmethod => 'f' },
+{ castsource => 'circle', casttarget => 'box', castfunc => 'box(circle)',
+  castcontext => 'e', castmethod => 'f' },
+{ castsource => 'circle', casttarget => 'polygon',
+  castfunc => 'polygon(circle)', castcontext => 'e', castmethod => 'f' },
+
+# MAC address category
+{ castsource => 'macaddr', casttarget => 'macaddr8', castfunc => 'macaddr8',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'macaddr8', casttarget => 'macaddr', castfunc => 'macaddr',
+  castcontext => 'i', castmethod => 'f' },
+
+# INET category
+{ castsource => 'cidr', casttarget => 'inet', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'inet', casttarget => 'cidr', castfunc => 'cidr',
+  castcontext => 'a', castmethod => 'f' },
+
+# BitString category
+{ castsource => 'bit', casttarget => 'varbit', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+{ castsource => 'varbit', casttarget => 'bit', castfunc => '0',
+  castcontext => 'i', castmethod => 'b' },
+
+# Cross-category casts between bit and int4, int8
+{ castsource => 'int8', casttarget => 'bit', castfunc => 'bit(int8,int4)',
+  castcontext => 'e', castmethod => 'f' },
+{ castsource => 'int4', casttarget => 'bit', castfunc => 'bit(int4,int4)',
+  castcontext => 'e', castmethod => 'f' },
+{ castsource => 'bit', casttarget => 'int8', castfunc => 'int8(bit)',
+  castcontext => 'e', castmethod => 'f' },
+{ castsource => 'bit', casttarget => 'int4', castfunc => 'int4(bit)',
+  castcontext => 'e', castmethod => 'f' },
+
+# Cross-category casts to and from TEXT
+# We need entries here only for a few specialized cases where the behavior
+# of the cast function differs from the datatype's I/O functions.  Otherwise,
+# parse_coerce.c will generate CoerceViaIO operations without any prompting.
+# Note that the castcontext values specified here should be no stronger than
+# parse_coerce.c's automatic casts ('a' to text, 'e' from text) else odd
+# behavior will ensue when the automatic cast is applied instead of the
+# pg_cast entry!
+{ castsource => 'cidr', casttarget => 'text', castfunc => 'text(inet)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'inet', casttarget => 'text', castfunc => 'text(inet)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'bool', casttarget => 'text', castfunc => 'text(bool)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'xml', casttarget => 'text', castfunc => '0',
+  castcontext => 'a', castmethod => 'b' },
+{ castsource => 'text', casttarget => 'xml', castfunc => 'xml',
+  castcontext => 'e', castmethod => 'f' },
+
+# Cross-category casts to and from VARCHAR
+# We support all the same casts as for TEXT.
+{ castsource => 'cidr', casttarget => 'varchar', castfunc => 'text(inet)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'inet', casttarget => 'varchar', castfunc => 'text(inet)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'bool', casttarget => 'varchar', castfunc => 'text(bool)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'xml', casttarget => 'varchar', castfunc => '0',
+  castcontext => 'a', castmethod => 'b' },
+{ castsource => 'varchar', casttarget => 'xml', castfunc => 'xml',
+  castcontext => 'e', castmethod => 'f' },
+
+# Cross-category casts to and from BPCHAR
+# We support all the same casts as for TEXT.
+{ castsource => 'cidr', casttarget => 'bpchar', castfunc => 'text(inet)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'inet', casttarget => 'bpchar', castfunc => 'text(inet)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'bool', casttarget => 'bpchar', castfunc => 'text(bool)',
+  castcontext => 'a', castmethod => 'f' },
+{ castsource => 'xml', casttarget => 'bpchar', castfunc => '0',
+  castcontext => 'a', castmethod => 'b' },
+{ castsource => 'bpchar', casttarget => 'xml', castfunc => 'xml',
+  castcontext => 'e', castmethod => 'f' },
+
+# Length-coercion functions
+{ castsource => 'bpchar', casttarget => 'bpchar',
+  castfunc => 'bpchar(bpchar,int4,bool)', castcontext => 'i',
+  castmethod => 'f' },
+{ castsource => 'varchar', casttarget => 'varchar',
+  castfunc => 'varchar(varchar,int4,bool)', castcontext => 'i',
+  castmethod => 'f' },
+{ castsource => 'time', casttarget => 'time', castfunc => 'time(time,int4)',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'timestamp', casttarget => 'timestamp',
+  castfunc => 'timestamp(timestamp,int4)', castcontext => 'i',
+  castmethod => 'f' },
+{ castsource => 'timestamptz', casttarget => 'timestamptz',
+  castfunc => 'timestamptz(timestamptz,int4)', castcontext => 'i',
+  castmethod => 'f' },
+{ castsource => 'interval', casttarget => 'interval',
+  castfunc => 'interval(interval,int4)', castcontext => 'i',
+  castmethod => 'f' },
+{ castsource => 'timetz', casttarget => 'timetz',
+  castfunc => 'timetz(timetz,int4)', castcontext => 'i', castmethod => 'f' },
+{ castsource => 'bit', casttarget => 'bit', castfunc => 'bit(bit,int4,bool)',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'varbit', casttarget => 'varbit', castfunc => 'varbit',
+  castcontext => 'i', castmethod => 'f' },
+{ castsource => 'numeric', casttarget => 'numeric',
+  castfunc => 'numeric(numeric,int4)', castcontext => 'i', castmethod => 'f' },
+
+# json to/from jsonb
+{ castsource => 'json', casttarget => 'jsonb', castfunc => '0',
+  castcontext => 'a', castmethod => 'i' },
+{ castsource => 'jsonb', casttarget => 'json', castfunc => '0',
+  castcontext => 'a', castmethod => 'i' },
+
+# jsonb to numeric and bool types
+{ castsource => 'jsonb', casttarget => 'bool', castfunc => 'bool(jsonb)',
+  castcontext => 'e', castmethod => 'f' },
+{ castsource => 'jsonb', casttarget => 'numeric', castfunc => 'numeric(jsonb)',
+  castcontext => 'e', castmethod => 'f' },
+{ castsource => 'jsonb', casttarget => 'int2', castfunc => 'int2(jsonb)',
+  castcontext => 'e', castmethod => 'f' },
+{ castsource => 'jsonb', casttarget => 'int4', castfunc => 'int4(jsonb)',
+  castcontext => 'e', castmethod => 'f' },
+{ castsource => 'jsonb', casttarget => 'int8', castfunc => 'int8(jsonb)',
+  castcontext => 'e', castmethod => 'f' },
+{ castsource => 'jsonb', casttarget => 'float4', castfunc => 'float4(jsonb)',
+  castcontext => 'e', castmethod => 'f' },
+{ castsource => 'jsonb', casttarget => 'float8', castfunc => 'float8(jsonb)',
+  castcontext => 'e', castmethod => 'f' },
+
+]
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_cast.h b/contrib/libs/postgresql/src/include/catalog/pg_cast.h
new file mode 100644
index 0000000000..2620ff40f0
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_cast.h
@@ -0,0 +1,99 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_cast.h
+ *	  definition of the "type casts" system catalog (pg_cast)
+ *
+ * As of Postgres 8.0, pg_cast describes not only type coercion functions
+ * but also length coercion functions.
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_cast.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_CAST_H
+#define PG_CAST_H
+
+#include "catalog/dependency.h"
+#include "catalog/genbki.h"
+#include "catalog/pg_cast_d.h"
+
+/* ----------------
+ *		pg_cast definition.  cpp turns this into
+ *		typedef struct FormData_pg_cast
+ * ----------------
+ */
+CATALOG(pg_cast,2605,CastRelationId)
+{
+	Oid			oid;			/* oid */
+
+	/* source datatype for cast */
+	Oid			castsource BKI_LOOKUP(pg_type);
+
+	/* destination datatype for cast */
+	Oid			casttarget BKI_LOOKUP(pg_type);
+
+	/* cast function; 0 = binary coercible */
+	Oid			castfunc BKI_LOOKUP(pg_proc);
+
+	/* contexts in which cast can be used */
+	char		castcontext;
+
+	/* cast method */
+	char		castmethod;
+} FormData_pg_cast;
+
+/* ----------------
+ *		Form_pg_cast corresponds to a pointer to a tuple with
+ *		the format of pg_cast relation.
+ * ----------------
+ */
+typedef FormData_pg_cast *Form_pg_cast;
+
+#ifdef EXPOSE_TO_CLIENT_CODE
+
+/*
+ * The allowable values for pg_cast.castcontext are specified by this enum.
+ * Since castcontext is stored as a "char", we use ASCII codes for human
+ * convenience in reading the table.  Note that internally to the backend,
+ * these values are converted to the CoercionContext enum (see primnodes.h),
+ * which is defined to sort in a convenient order; the ASCII codes don't
+ * have to sort in any special order.
+ */
+
+typedef enum CoercionCodes
+{
+	COERCION_CODE_IMPLICIT = 'i',	/* coercion in context of expression */
+	COERCION_CODE_ASSIGNMENT = 'a', /* coercion in context of assignment */
+	COERCION_CODE_EXPLICIT = 'e'	/* explicit cast operation */
+} CoercionCodes;
+
+/*
+ * The allowable values for pg_cast.castmethod are specified by this enum.
+ * Since castmethod is stored as a "char", we use ASCII codes for human
+ * convenience in reading the table.
+ */
+typedef enum CoercionMethod
+{
+	COERCION_METHOD_FUNCTION = 'f', /* use a function */
+	COERCION_METHOD_BINARY = 'b',	/* types are binary-compatible */
+	COERCION_METHOD_INOUT = 'i' /* use input/output functions */
+} CoercionMethod;
+
+#endif							/* EXPOSE_TO_CLIENT_CODE */
+
+
+extern ObjectAddress CastCreate(Oid sourcetypeid,
+								Oid targettypeid,
+								Oid funcid,
+								char castcontext,
+								char castmethod,
+								DependencyType behavior);
+
+#endif							/* PG_CAST_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_cast_d.h b/contrib/libs/postgresql/src/include/catalog/pg_cast_d.h
new file mode 100644
index 0000000000..c57c7aa932
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_cast_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_cast_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_class.dat b/contrib/libs/postgresql/src/include/catalog/pg_class.dat
new file mode 100644
index 0000000000..b28bba7cc3
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_class.dat
@@ -0,0 +1,28 @@
+#----------------------------------------------------------------------
+#
+# pg_class.dat
+#    Initial contents of the pg_class system catalog.
+#
+# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+# Portions Copyright (c) 1994, Regents of the University of California
+#
+# src/include/catalog/pg_class.dat
+#
+#----------------------------------------------------------------------
+
+[
+
+# Note: only bootstrap catalogs, ie those marked BKI_BOOTSTRAP, need to
+# have entries here.  Be sure that the OIDs listed here match those given in
+# their CATALOG and BKI_ROWTYPE_OID macros.
+
+{ oid => '1247',
+  relname => 'pg_type', reltype => 'pg_type' },
+{ oid => '1249',
+  relname => 'pg_attribute', reltype => 'pg_attribute' },
+{ oid => '1255',
+  relname => 'pg_proc', reltype => 'pg_proc' },
+{ oid => '1259',
+  relname => 'pg_class', reltype => 'pg_class' },
+
+]
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_class.h b/contrib/libs/postgresql/src/include/catalog/pg_class.h
new file mode 100644
index 0000000000..78b33b2a7f
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_class.h
@@ -0,0 +1,200 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_class.h
+ *	  definition of the "relation" system catalog (pg_class)
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_class.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_CLASS_H
+#define PG_CLASS_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_class_d.h"
+
+/* ----------------
+ *		pg_class definition.  cpp turns this into
+ *		typedef struct FormData_pg_class
+ *
+ * Note that the BKI_DEFAULT values below are only used for rows describing
+ * BKI_BOOTSTRAP catalogs, since only those rows appear in pg_class.dat.
+ * ----------------
+ */
+CATALOG(pg_class,1259,RelationRelationId) BKI_BOOTSTRAP BKI_ROWTYPE_OID(83,RelationRelation_Rowtype_Id) BKI_SCHEMA_MACRO
+{
+	/* oid */
+	Oid			oid;
+
+	/* class name */
+	NameData	relname;
+
+	/* OID of namespace containing this class */
+	Oid			relnamespace BKI_DEFAULT(PGNSP);
+
+	/* OID of entry in pg_type for table's implicit row type */
+	Oid			reltype BKI_LOOKUP(pg_type);
+
+	/* OID of entry in pg_type for underlying composite type */
+	Oid			reloftype BKI_DEFAULT(0) BKI_LOOKUP(pg_type);
+
+	/* class owner */
+	Oid			relowner BKI_DEFAULT(PGUID);
+
+	/* access method; 0 if not a table / index */
+	Oid			relam BKI_DEFAULT(heap) BKI_LOOKUP(pg_am);
+
+	/* identifier of physical storage file */
+	/* relfilenode == 0 means it is a "mapped" relation, see relmapper.c */
+	Oid			relfilenode BKI_DEFAULT(0);
+
+	/* identifier of table space for relation (0 means default for database) */
+	Oid			reltablespace BKI_DEFAULT(0) BKI_LOOKUP(pg_tablespace);
+
+	/* # of blocks (not always up-to-date) */
+	int32		relpages BKI_DEFAULT(0);
+
+	/* # of tuples (not always up-to-date) */
+	float4		reltuples BKI_DEFAULT(0);
+
+	/* # of all-visible blocks (not always up-to-date) */
+	int32		relallvisible BKI_DEFAULT(0);
+
+	/* OID of toast table; 0 if none */
+	Oid			reltoastrelid BKI_DEFAULT(0);
+
+	/* T if has (or has had) any indexes */
+	bool		relhasindex BKI_DEFAULT(f);
+
+	/* T if shared across databases */
+	bool		relisshared BKI_DEFAULT(f);
+
+	/* see RELPERSISTENCE_xxx constants below */
+	char		relpersistence BKI_DEFAULT(p);
+
+	/* see RELKIND_xxx constants below */
+	char		relkind BKI_DEFAULT(r);
+
+	/* number of user attributes */
+	int16		relnatts BKI_DEFAULT(0);	/* genbki.pl will fill this in */
+
+	/*
+	 * Class pg_attribute must contain exactly "relnatts" user attributes
+	 * (with attnums ranging from 1 to relnatts) for this class.  It may also
+	 * contain entries with negative attnums for system attributes.
+	 */
+
+	/* # of CHECK constraints for class */
+	int16		relchecks BKI_DEFAULT(0);
+
+	/* has (or has had) any rules */
+	bool		relhasrules BKI_DEFAULT(f);
+
+	/* has (or has had) any TRIGGERs */
+	bool		relhastriggers BKI_DEFAULT(f);
+
+	/* has (or has had) child tables or indexes */
+	bool		relhassubclass BKI_DEFAULT(f);
+
+	/* row security is enabled or not */
+	bool		relrowsecurity BKI_DEFAULT(f);
+
+	/* row security forced for owners or not */
+	bool		relforcerowsecurity BKI_DEFAULT(f);
+
+	/* matview currently holds query results */
+	bool		relispopulated BKI_DEFAULT(t);
+
+	/* see REPLICA_IDENTITY_xxx constants */
+	char		relreplident BKI_DEFAULT(n);
+
+	/* is relation a partition? */
+	bool		relispartition BKI_DEFAULT(f);
+
+	/* heap for rewrite during DDL, link to original rel */
+	Oid			relrewrite BKI_DEFAULT(0);
+
+	/* all Xids < this are frozen in this rel */
+	TransactionId relfrozenxid BKI_DEFAULT(3);	/* FirstNormalTransactionId */
+
+	/* all multixacts in this rel are >= this; it is really a MultiXactId */
+	TransactionId relminmxid BKI_DEFAULT(1);	/* FirstMultiXactId */
+
+#ifdef CATALOG_VARLEN			/* variable-length fields start here */
+	/* NOTE: These fields are not present in a relcache entry's rd_rel field. */
+	/* access permissions */
+	aclitem		relacl[1] BKI_DEFAULT(_null_);
+
+	/* access-method-specific options */
+	text		reloptions[1] BKI_DEFAULT(_null_);
+
+	/* partition bound node tree */
+	pg_node_tree relpartbound BKI_DEFAULT(_null_);
+#endif
+} FormData_pg_class;
+
+/* Size of fixed part of pg_class tuples, not counting var-length fields */
+#define CLASS_TUPLE_SIZE \
+	 (offsetof(FormData_pg_class,relminmxid) + sizeof(TransactionId))
+
+/* ----------------
+ *		Form_pg_class corresponds to a pointer to a tuple with
+ *		the format of pg_class relation.
+ * ----------------
+ */
+typedef FormData_pg_class *Form_pg_class;
+
+#ifdef EXPOSE_TO_CLIENT_CODE
+
+#define		  RELKIND_RELATION		  'r'	/* ordinary table */
+#define		  RELKIND_INDEX			  'i'	/* secondary index */
+#define		  RELKIND_SEQUENCE		  'S'	/* sequence object */
+#define		  RELKIND_TOASTVALUE	  't'	/* for out-of-line values */
+#define		  RELKIND_VIEW			  'v'	/* view */
+#define		  RELKIND_MATVIEW		  'm'	/* materialized view */
+#define		  RELKIND_COMPOSITE_TYPE  'c'	/* composite type */
+#define		  RELKIND_FOREIGN_TABLE   'f'	/* foreign table */
+#define		  RELKIND_PARTITIONED_TABLE 'p' /* partitioned table */
+#define		  RELKIND_PARTITIONED_INDEX 'I' /* partitioned index */
+
+#define		  RELPERSISTENCE_PERMANENT	'p' /* regular table */
+#define		  RELPERSISTENCE_UNLOGGED	'u' /* unlogged permanent table */
+#define		  RELPERSISTENCE_TEMP		't' /* temporary table */
+
+/* default selection for replica identity (primary key or nothing) */
+#define		  REPLICA_IDENTITY_DEFAULT	'd'
+/* no replica identity is logged for this relation */
+#define		  REPLICA_IDENTITY_NOTHING	'n'
+/* all columns are logged as replica identity */
+#define		  REPLICA_IDENTITY_FULL		'f'
+/*
+ * an explicitly chosen candidate key's columns are used as replica identity.
+ * Note this will still be set if the index has been dropped; in that case it
+ * has the same meaning as 'd'.
+ */
+#define		  REPLICA_IDENTITY_INDEX	'i'
+
+/*
+ * Relation kinds that have physical storage. These relations normally have
+ * relfilenode set to non-zero, but it can also be zero if the relation is
+ * mapped.
+ */
+#define RELKIND_HAS_STORAGE(relkind) \
+	((relkind) == RELKIND_RELATION || \
+	 (relkind) == RELKIND_INDEX || \
+	 (relkind) == RELKIND_SEQUENCE || \
+	 (relkind) == RELKIND_TOASTVALUE || \
+	 (relkind) == RELKIND_MATVIEW)
+
+
+#endif							/* EXPOSE_TO_CLIENT_CODE */
+
+#endif							/* PG_CLASS_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_class_d.h b/contrib/libs/postgresql/src/include/catalog/pg_class_d.h
new file mode 100644
index 0000000000..48f407763d
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_class_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_class_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_collation.dat b/contrib/libs/postgresql/src/include/catalog/pg_collation.dat
new file mode 100644
index 0000000000..ba1b3e201b
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_collation.dat
@@ -0,0 +1,31 @@
+#----------------------------------------------------------------------
+#
+# pg_collation.dat
+#    Initial contents of the pg_collation system catalog.
+#
+# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+# Portions Copyright (c) 1994, Regents of the University of California
+#
+# src/include/catalog/pg_collation.dat
+#
+#----------------------------------------------------------------------
+
+[
+
+{ oid => '100', oid_symbol => 'DEFAULT_COLLATION_OID',
+  descr => 'database\'s default collation',
+  collname => 'default', collnamespace => 'PGNSP', collowner => 'PGUID',
+  collprovider => 'd', collencoding => '-1', collcollate => '', collctype => '',
+  collversion => '_null_' },
+{ oid => '950', oid_symbol => 'C_COLLATION_OID',
+  descr => 'standard C collation',
+  collname => 'C', collnamespace => 'PGNSP', collowner => 'PGUID',
+  collprovider => 'c', collencoding => '-1', collcollate => 'C',
+  collctype => 'C', collversion => '_null_' },
+{ oid => '951', oid_symbol => 'POSIX_COLLATION_OID',
+  descr => 'standard POSIX collation',
+  collname => 'POSIX', collnamespace => 'PGNSP', collowner => 'PGUID',
+  collprovider => 'c', collencoding => '-1', collcollate => 'POSIX',
+  collctype => 'POSIX', collversion => '_null_' },
+
+]
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_collation.h b/contrib/libs/postgresql/src/include/catalog/pg_collation.h
new file mode 100644
index 0000000000..6955bb1273
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_collation.h
@@ -0,0 +1,73 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_collation.h
+ *	  definition of the "collation" system catalog (pg_collation)
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_collation.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_COLLATION_H
+#define PG_COLLATION_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_collation_d.h"
+
+/* ----------------
+ *		pg_collation definition.  cpp turns this into
+ *		typedef struct FormData_pg_collation
+ * ----------------
+ */
+CATALOG(pg_collation,3456,CollationRelationId)
+{
+	Oid			oid;			/* oid */
+	NameData	collname;		/* collation name */
+	Oid			collnamespace;	/* OID of namespace containing collation */
+	Oid			collowner;		/* owner of collation */
+	char		collprovider;	/* see constants below */
+	bool		collisdeterministic BKI_DEFAULT(t);
+	int32		collencoding;	/* encoding for this collation; -1 = "all" */
+	NameData	collcollate;	/* LC_COLLATE setting */
+	NameData	collctype;		/* LC_CTYPE setting */
+#ifdef CATALOG_VARLEN			/* variable-length fields start here */
+	text		collversion;	/* provider-dependent version of collation
+								 * data */
+#endif
+} FormData_pg_collation;
+
+/* ----------------
+ *		Form_pg_collation corresponds to a pointer to a row with
+ *		the format of pg_collation relation.
+ * ----------------
+ */
+typedef FormData_pg_collation *Form_pg_collation;
+
+#ifdef EXPOSE_TO_CLIENT_CODE
+
+#define COLLPROVIDER_DEFAULT	'd'
+#define COLLPROVIDER_ICU		'i'
+#define COLLPROVIDER_LIBC		'c'
+
+#endif							/* EXPOSE_TO_CLIENT_CODE */
+
+
+extern Oid	CollationCreate(const char *collname, Oid collnamespace,
+							Oid collowner,
+							char collprovider,
+							bool collisdeterministic,
+							int32 collencoding,
+							const char *collcollate, const char *collctype,
+							const char *collversion,
+							bool if_not_exists,
+							bool quiet);
+extern void RemoveCollationById(Oid collationOid);
+
+#endif							/* PG_COLLATION_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_collation_d.h b/contrib/libs/postgresql/src/include/catalog/pg_collation_d.h
new file mode 100644
index 0000000000..2ad4d6d60d
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_collation_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_collation_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_constraint.h b/contrib/libs/postgresql/src/include/catalog/pg_constraint.h
new file mode 100644
index 0000000000..9600ece93c
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_constraint.h
@@ -0,0 +1,247 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_constraint.h
+ *	  definition of the "constraint" system catalog (pg_constraint)
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_constraint.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_CONSTRAINT_H
+#define PG_CONSTRAINT_H
+
+#include "catalog/dependency.h"
+#include "catalog/genbki.h"
+#include "catalog/pg_constraint_d.h"
+#include "nodes/pg_list.h"
+
+/* ----------------
+ *		pg_constraint definition.  cpp turns this into
+ *		typedef struct FormData_pg_constraint
+ * ----------------
+ */
+CATALOG(pg_constraint,2606,ConstraintRelationId)
+{
+	Oid			oid;			/* oid */
+
+	/*
+	 * conname + connamespace is deliberately not unique; we allow, for
+	 * example, the same name to be used for constraints of different
+	 * relations.  This is partly for backwards compatibility with past
+	 * Postgres practice, and partly because we don't want to have to obtain a
+	 * global lock to generate a globally unique name for a nameless
+	 * constraint.  We associate a namespace with constraint names only for
+	 * SQL-spec compatibility.
+	 *
+	 * However, we do require conname to be unique among the constraints of a
+	 * single relation or domain.  This is enforced by a unique index on
+	 * conrelid + contypid + conname.
+	 */
+	NameData	conname;		/* name of this constraint */
+	Oid			connamespace;	/* OID of namespace containing constraint */
+	char		contype;		/* constraint type; see codes below */
+	bool		condeferrable;	/* deferrable constraint? */
+	bool		condeferred;	/* deferred by default? */
+	bool		convalidated;	/* constraint has been validated? */
+
+	/*
+	 * conrelid and conkey are only meaningful if the constraint applies to a
+	 * specific relation (this excludes domain constraints and assertions).
+	 * Otherwise conrelid is 0 and conkey is NULL.
+	 */
+	Oid			conrelid;		/* relation this constraint constrains */
+
+	/*
+	 * contypid links to the pg_type row for a domain if this is a domain
+	 * constraint.  Otherwise it's 0.
+	 *
+	 * For SQL-style global ASSERTIONs, both conrelid and contypid would be
+	 * zero. This is not presently supported, however.
+	 */
+	Oid			contypid;		/* domain this constraint constrains */
+
+	/*
+	 * conindid links to the index supporting the constraint, if any;
+	 * otherwise it's 0.  This is used for unique, primary-key, and exclusion
+	 * constraints, and less obviously for foreign-key constraints (where the
+	 * index is a unique index on the referenced relation's referenced
+	 * columns).  Notice that the index is on conrelid in the first case but
+	 * confrelid in the second.
+	 */
+	Oid			conindid;		/* index supporting this constraint */
+
+	/*
+	 * If this constraint is on a partition inherited from a partitioned
+	 * table, this is the OID of the corresponding constraint in the parent.
+	 */
+	Oid			conparentid;
+
+	/*
+	 * These fields, plus confkey, are only meaningful for a foreign-key
+	 * constraint.  Otherwise confrelid is 0 and the char fields are spaces.
+	 */
+	Oid			confrelid;		/* relation referenced by foreign key */
+	char		confupdtype;	/* foreign key's ON UPDATE action */
+	char		confdeltype;	/* foreign key's ON DELETE action */
+	char		confmatchtype;	/* foreign key's match type */
+
+	/* Has a local definition (hence, do not drop when coninhcount is 0) */
+	bool		conislocal;
+
+	/* Number of times inherited from direct parent relation(s) */
+	int32		coninhcount;
+
+	/* Has a local definition and cannot be inherited */
+	bool		connoinherit;
+
+#ifdef CATALOG_VARLEN			/* variable-length fields start here */
+
+	/*
+	 * Columns of conrelid that the constraint applies to, if known (this is
+	 * NULL for trigger constraints)
+	 */
+	int16		conkey[1];
+
+	/*
+	 * If a foreign key, the referenced columns of confrelid
+	 */
+	int16		confkey[1];
+
+	/*
+	 * If a foreign key, the OIDs of the PK = FK equality operators for each
+	 * column of the constraint
+	 */
+	Oid			conpfeqop[1];
+
+	/*
+	 * If a foreign key, the OIDs of the PK = PK equality operators for each
+	 * column of the constraint (i.e., equality for the referenced columns)
+	 */
+	Oid			conppeqop[1];
+
+	/*
+	 * If a foreign key, the OIDs of the FK = FK equality operators for each
+	 * column of the constraint (i.e., equality for the referencing columns)
+	 */
+	Oid			conffeqop[1];
+
+	/*
+	 * If an exclusion constraint, the OIDs of the exclusion operators for
+	 * each column of the constraint
+	 */
+	Oid			conexclop[1];
+
+	/*
+	 * If a check constraint, nodeToString representation of expression
+	 */
+	pg_node_tree conbin;
+#endif
+} FormData_pg_constraint;
+
+/* ----------------
+ *		Form_pg_constraint corresponds to a pointer to a tuple with
+ *		the format of pg_constraint relation.
+ * ----------------
+ */
+typedef FormData_pg_constraint *Form_pg_constraint;
+
+#ifdef EXPOSE_TO_CLIENT_CODE
+
+/* Valid values for contype */
+#define CONSTRAINT_CHECK			'c'
+#define CONSTRAINT_FOREIGN			'f'
+#define CONSTRAINT_PRIMARY			'p'
+#define CONSTRAINT_UNIQUE			'u'
+#define CONSTRAINT_TRIGGER			't'
+#define CONSTRAINT_EXCLUSION		'x'
+
+/*
+ * Valid values for confupdtype and confdeltype are the FKCONSTR_ACTION_xxx
+ * constants defined in parsenodes.h.  Valid values for confmatchtype are
+ * the FKCONSTR_MATCH_xxx constants defined in parsenodes.h.
+ */
+
+#endif							/* EXPOSE_TO_CLIENT_CODE */
+
+/*
+ * Identify constraint type for lookup purposes
+ */
+typedef enum ConstraintCategory
+{
+	CONSTRAINT_RELATION,
+	CONSTRAINT_DOMAIN,
+	CONSTRAINT_ASSERTION		/* for future expansion */
+} ConstraintCategory;
+
+
+extern Oid	CreateConstraintEntry(const char *constraintName,
+								  Oid constraintNamespace,
+								  char constraintType,
+								  bool isDeferrable,
+								  bool isDeferred,
+								  bool isValidated,
+								  Oid parentConstrId,
+								  Oid relId,
+								  const int16 *constraintKey,
+								  int constraintNKeys,
+								  int constraintNTotalKeys,
+								  Oid domainId,
+								  Oid indexRelId,
+								  Oid foreignRelId,
+								  const int16 *foreignKey,
+								  const Oid *pfEqOp,
+								  const Oid *ppEqOp,
+								  const Oid *ffEqOp,
+								  int foreignNKeys,
+								  char foreignUpdateType,
+								  char foreignDeleteType,
+								  char foreignMatchType,
+								  const Oid *exclOp,
+								  Node *conExpr,
+								  const char *conBin,
+								  bool conIsLocal,
+								  int conInhCount,
+								  bool conNoInherit,
+								  bool is_internal);
+
+extern void RemoveConstraintById(Oid conId);
+extern void RenameConstraintById(Oid conId, const char *newname);
+
+extern bool ConstraintNameIsUsed(ConstraintCategory conCat, Oid objId,
+								 const char *conname);
+extern bool ConstraintNameExists(const char *conname, Oid namespaceid);
+extern char *ChooseConstraintName(const char *name1, const char *name2,
+								  const char *label, Oid namespaceid,
+								  List *others);
+
+extern void AlterConstraintNamespaces(Oid ownerId, Oid oldNspId,
+									  Oid newNspId, bool isType, ObjectAddresses *objsMoved);
+extern void ConstraintSetParentConstraint(Oid childConstrId,
+										  Oid parentConstrId,
+										  Oid childTableId);
+extern Oid	get_relation_constraint_oid(Oid relid, const char *conname, bool missing_ok);
+extern Bitmapset *get_relation_constraint_attnos(Oid relid, const char *conname,
+												 bool missing_ok, Oid *constraintOid);
+extern Oid	get_domain_constraint_oid(Oid typid, const char *conname, bool missing_ok);
+extern Oid	get_relation_idx_constraint_oid(Oid relationId, Oid indexId);
+
+extern Bitmapset *get_primary_key_attnos(Oid relid, bool deferrableOk,
+										 Oid *constraintOid);
+extern void DeconstructFkConstraintRow(HeapTuple tuple, int *numfks,
+									   AttrNumber *conkey, AttrNumber *confkey,
+									   Oid *pf_eq_oprs, Oid *pp_eq_oprs, Oid *ff_eq_oprs);
+
+extern bool check_functional_grouping(Oid relid,
+									  Index varno, Index varlevelsup,
+									  List *grouping_columns,
+									  List **constraintDeps);
+
+#endif							/* PG_CONSTRAINT_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_constraint_d.h b/contrib/libs/postgresql/src/include/catalog/pg_constraint_d.h
new file mode 100644
index 0000000000..34106f4933
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_constraint_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_constraint_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_control.h b/contrib/libs/postgresql/src/include/catalog/pg_control.h
new file mode 100644
index 0000000000..9201330160
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_control.h
@@ -0,0 +1,252 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_control.h
+ *	  The system control file "pg_control" is not a heap relation.
+ *	  However, we define it here so that the format is documented.
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_control.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_CONTROL_H
+#define PG_CONTROL_H
+
+#include "access/transam.h"
+#include "access/xlogdefs.h"
+#include "pgtime.h"				/* for pg_time_t */
+#include "port/pg_crc32c.h"
+
+
+/* Version identifier for this pg_control format */
+#define PG_CONTROL_VERSION	1300
+
+/* Nonce key length, see below */
+#define MOCK_AUTH_NONCE_LEN		32
+
+/*
+ * Body of CheckPoint XLOG records.  This is declared here because we keep
+ * a copy of the latest one in pg_control for possible disaster recovery.
+ * Changing this struct requires a PG_CONTROL_VERSION bump.
+ */
+typedef struct CheckPoint
+{
+	XLogRecPtr	redo;			/* next RecPtr available when we began to
+								 * create CheckPoint (i.e. REDO start point) */
+	TimeLineID	ThisTimeLineID; /* current TLI */
+	TimeLineID	PrevTimeLineID; /* previous TLI, if this record begins a new
+								 * timeline (equals ThisTimeLineID otherwise) */
+	bool		fullPageWrites; /* current full_page_writes */
+	FullTransactionId nextFullXid;	/* next free full transaction ID */
+	Oid			nextOid;		/* next free OID */
+	MultiXactId nextMulti;		/* next free MultiXactId */
+	MultiXactOffset nextMultiOffset;	/* next free MultiXact offset */
+	TransactionId oldestXid;	/* cluster-wide minimum datfrozenxid */
+	Oid			oldestXidDB;	/* database with minimum datfrozenxid */
+	MultiXactId oldestMulti;	/* cluster-wide minimum datminmxid */
+	Oid			oldestMultiDB;	/* database with minimum datminmxid */
+	pg_time_t	time;			/* time stamp of checkpoint */
+	TransactionId oldestCommitTsXid;	/* oldest Xid with valid commit
+										 * timestamp */
+	TransactionId newestCommitTsXid;	/* newest Xid with valid commit
+										 * timestamp */
+
+	/*
+	 * Oldest XID still running. This is only needed to initialize hot standby
+	 * mode from an online checkpoint, so we only bother calculating this for
+	 * online checkpoints and only when wal_level is replica. Otherwise it's
+	 * set to InvalidTransactionId.
+	 */
+	TransactionId oldestActiveXid;
+} CheckPoint;
+
+/* XLOG info values for XLOG rmgr */
+#define XLOG_CHECKPOINT_SHUTDOWN		0x00
+#define XLOG_CHECKPOINT_ONLINE			0x10
+#define XLOG_NOOP						0x20
+#define XLOG_NEXTOID					0x30
+#define XLOG_SWITCH						0x40
+#define XLOG_BACKUP_END					0x50
+#define XLOG_PARAMETER_CHANGE			0x60
+#define XLOG_RESTORE_POINT				0x70
+#define XLOG_FPW_CHANGE					0x80
+#define XLOG_END_OF_RECOVERY			0x90
+#define XLOG_FPI_FOR_HINT				0xA0
+#define XLOG_FPI						0xB0
+/* 0xC0 is used in Postgres 9.5-11 */
+#define XLOG_OVERWRITE_CONTRECORD		0xD0
+
+
+/*
+ * System status indicator.  Note this is stored in pg_control; if you change
+ * it, you must bump PG_CONTROL_VERSION
+ */
+typedef enum DBState
+{
+	DB_STARTUP = 0,
+	DB_SHUTDOWNED,
+	DB_SHUTDOWNED_IN_RECOVERY,
+	DB_SHUTDOWNING,
+	DB_IN_CRASH_RECOVERY,
+	DB_IN_ARCHIVE_RECOVERY,
+	DB_IN_PRODUCTION
+} DBState;
+
+/*
+ * Contents of pg_control.
+ */
+
+typedef struct ControlFileData
+{
+	/*
+	 * Unique system identifier --- to ensure we match up xlog files with the
+	 * installation that produced them.
+	 */
+	uint64		system_identifier;
+
+	/*
+	 * Version identifier information.  Keep these fields at the same offset,
+	 * especially pg_control_version; they won't be real useful if they move
+	 * around.  (For historical reasons they must be 8 bytes into the file
+	 * rather than immediately at the front.)
+	 *
+	 * pg_control_version identifies the format of pg_control itself.
+	 * catalog_version_no identifies the format of the system catalogs.
+	 *
+	 * There are additional version identifiers in individual files; for
+	 * example, WAL logs contain per-page magic numbers that can serve as
+	 * version cues for the WAL log.
+	 */
+	uint32		pg_control_version; /* PG_CONTROL_VERSION */
+	uint32		catalog_version_no; /* see catversion.h */
+
+	/*
+	 * System status data
+	 */
+	DBState		state;			/* see enum above */
+	pg_time_t	time;			/* time stamp of last pg_control update */
+	XLogRecPtr	checkPoint;		/* last check point record ptr */
+
+	CheckPoint	checkPointCopy; /* copy of last check point record */
+
+	XLogRecPtr	unloggedLSN;	/* current fake LSN value, for unlogged rels */
+
+	/*
+	 * These two values determine the minimum point we must recover up to
+	 * before starting up:
+	 *
+	 * minRecoveryPoint is updated to the latest replayed LSN whenever we
+	 * flush a data change during archive recovery. That guards against
+	 * starting archive recovery, aborting it, and restarting with an earlier
+	 * stop location. If we've already flushed data changes from WAL record X
+	 * to disk, we mustn't start up until we reach X again. Zero when not
+	 * doing archive recovery.
+	 *
+	 * backupStartPoint is the redo pointer of the backup start checkpoint, if
+	 * we are recovering from an online backup and haven't reached the end of
+	 * backup yet. It is reset to zero when the end of backup is reached, and
+	 * we mustn't start up before that. A boolean would suffice otherwise, but
+	 * we use the redo pointer as a cross-check when we see an end-of-backup
+	 * record, to make sure the end-of-backup record corresponds the base
+	 * backup we're recovering from.
+	 *
+	 * backupEndPoint is the backup end location, if we are recovering from an
+	 * online backup which was taken from the standby and haven't reached the
+	 * end of backup yet. It is initialized to the minimum recovery point in
+	 * pg_control which was backed up last. It is reset to zero when the end
+	 * of backup is reached, and we mustn't start up before that.
+	 *
+	 * If backupEndRequired is true, we know for sure that we're restoring
+	 * from a backup, and must see a backup-end record before we can safely
+	 * start up. If it's false, but backupStartPoint is set, a backup_label
+	 * file was found at startup but it may have been a leftover from a stray
+	 * pg_start_backup() call, not accompanied by pg_stop_backup().
+	 */
+	XLogRecPtr	minRecoveryPoint;
+	TimeLineID	minRecoveryPointTLI;
+	XLogRecPtr	backupStartPoint;
+	XLogRecPtr	backupEndPoint;
+	bool		backupEndRequired;
+
+	/*
+	 * Parameter settings that determine if the WAL can be used for archival
+	 * or hot standby.
+	 */
+	int			wal_level;
+	bool		wal_log_hints;
+	int			MaxConnections;
+	int			max_worker_processes;
+	int			max_wal_senders;
+	int			max_prepared_xacts;
+	int			max_locks_per_xact;
+	bool		track_commit_timestamp;
+
+	/*
+	 * This data is used to check for hardware-architecture compatibility of
+	 * the database and the backend executable.  We need not check endianness
+	 * explicitly, since the pg_control version will surely look wrong to a
+	 * machine of different endianness, but we do need to worry about MAXALIGN
+	 * and floating-point format.  (Note: storage layout nominally also
+	 * depends on SHORTALIGN and INTALIGN, but in practice these are the same
+	 * on all architectures of interest.)
+	 *
+	 * Testing just one double value is not a very bulletproof test for
+	 * floating-point compatibility, but it will catch most cases.
+	 */
+	uint32		maxAlign;		/* alignment requirement for tuples */
+	double		floatFormat;	/* constant 1234567.0 */
+#define FLOATFORMAT_VALUE	1234567.0
+
+	/*
+	 * This data is used to make sure that configuration of this database is
+	 * compatible with the backend executable.
+	 */
+	uint32		blcksz;			/* data block size for this DB */
+	uint32		relseg_size;	/* blocks per segment of large relation */
+
+	uint32		xlog_blcksz;	/* block size within WAL files */
+	uint32		xlog_seg_size;	/* size of each WAL segment */
+
+	uint32		nameDataLen;	/* catalog name field width */
+	uint32		indexMaxKeys;	/* max number of columns in an index */
+
+	uint32		toast_max_chunk_size;	/* chunk size in TOAST tables */
+	uint32		loblksize;		/* chunk size in pg_largeobject */
+
+	bool		float8ByVal;	/* float8, int8, etc pass-by-value? */
+
+	/* Are data pages protected by checksums? Zero if no checksum version */
+	uint32		data_checksum_version;
+
+	/*
+	 * Random nonce, used in authentication requests that need to proceed
+	 * based on values that are cluster-unique, like a SASL exchange that
+	 * failed at an early stage.
+	 */
+	char		mock_authentication_nonce[MOCK_AUTH_NONCE_LEN];
+
+	/* CRC of all above ... MUST BE LAST! */
+	pg_crc32c	crc;
+} ControlFileData;
+
+/*
+ * Maximum safe value of sizeof(ControlFileData).  For reliability's sake,
+ * it's critical that pg_control updates be atomic writes.  That generally
+ * means the active data can't be more than one disk sector, which is 512
+ * bytes on common hardware.  Be very careful about raising this limit.
+ */
+#define PG_CONTROL_MAX_SAFE_SIZE	512
+
+/*
+ * Physical size of the pg_control file.  Note that this is considerably
+ * bigger than the actually used size (ie, sizeof(ControlFileData)).
+ * The idea is to keep the physical size constant independent of format
+ * changes, so that ReadControlFile will deliver a suitable wrong-version
+ * message instead of a read error if it's looking at an incompatible file.
+ */
+#define PG_CONTROL_FILE_SIZE		8192
+
+#endif							/* PG_CONTROL_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_conversion.dat b/contrib/libs/postgresql/src/include/catalog/pg_conversion.dat
new file mode 100644
index 0000000000..d7120f2fb0
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_conversion.dat
@@ -0,0 +1,405 @@
+#----------------------------------------------------------------------
+#
+# pg_conversion.dat
+#    Initial contents of the pg_conversion system catalog.
+#
+# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+# Portions Copyright (c) 1994, Regents of the University of California
+#
+# src/include/catalog/pg_conversion.dat
+#
+#----------------------------------------------------------------------
+
+# Note: conforencoding and contoencoding must match the spelling of
+# the labels used in the enum pg_enc in mb/pg_wchar.h.
+
+[
+
+{ oid => '4402', descr => 'conversion for KOI8R to MULE_INTERNAL',
+  conname => 'koi8_r_to_mic', conforencoding => 'PG_KOI8R',
+  contoencoding => 'PG_MULE_INTERNAL', conproc => 'koi8r_to_mic' },
+{ oid => '4403', descr => 'conversion for MULE_INTERNAL to KOI8R',
+  conname => 'mic_to_koi8_r', conforencoding => 'PG_MULE_INTERNAL',
+  contoencoding => 'PG_KOI8R', conproc => 'mic_to_koi8r' },
+{ oid => '4404', descr => 'conversion for ISO-8859-5 to MULE_INTERNAL',
+  conname => 'iso_8859_5_to_mic', conforencoding => 'PG_ISO_8859_5',
+  contoencoding => 'PG_MULE_INTERNAL', conproc => 'iso_to_mic' },
+{ oid => '4405', descr => 'conversion for MULE_INTERNAL to ISO-8859-5',
+  conname => 'mic_to_iso_8859_5', conforencoding => 'PG_MULE_INTERNAL',
+  contoencoding => 'PG_ISO_8859_5', conproc => 'mic_to_iso' },
+{ oid => '4406', descr => 'conversion for WIN1251 to MULE_INTERNAL',
+  conname => 'windows_1251_to_mic', conforencoding => 'PG_WIN1251',
+  contoencoding => 'PG_MULE_INTERNAL', conproc => 'win1251_to_mic' },
+{ oid => '4407', descr => 'conversion for MULE_INTERNAL to WIN1251',
+  conname => 'mic_to_windows_1251', conforencoding => 'PG_MULE_INTERNAL',
+  contoencoding => 'PG_WIN1251', conproc => 'mic_to_win1251' },
+{ oid => '4408', descr => 'conversion for WIN866 to MULE_INTERNAL',
+  conname => 'windows_866_to_mic', conforencoding => 'PG_WIN866',
+  contoencoding => 'PG_MULE_INTERNAL', conproc => 'win866_to_mic' },
+{ oid => '4409', descr => 'conversion for MULE_INTERNAL to WIN866',
+  conname => 'mic_to_windows_866', conforencoding => 'PG_MULE_INTERNAL',
+  contoencoding => 'PG_WIN866', conproc => 'mic_to_win866' },
+{ oid => '4410', descr => 'conversion for KOI8R to WIN1251',
+  conname => 'koi8_r_to_windows_1251', conforencoding => 'PG_KOI8R',
+  contoencoding => 'PG_WIN1251', conproc => 'koi8r_to_win1251' },
+{ oid => '4411', descr => 'conversion for WIN1251 to KOI8R',
+  conname => 'windows_1251_to_koi8_r', conforencoding => 'PG_WIN1251',
+  contoencoding => 'PG_KOI8R', conproc => 'win1251_to_koi8r' },
+{ oid => '4412', descr => 'conversion for KOI8R to WIN866',
+  conname => 'koi8_r_to_windows_866', conforencoding => 'PG_KOI8R',
+  contoencoding => 'PG_WIN866', conproc => 'koi8r_to_win866' },
+{ oid => '4413', descr => 'conversion for WIN866 to KOI8R',
+  conname => 'windows_866_to_koi8_r', conforencoding => 'PG_WIN866',
+  contoencoding => 'PG_KOI8R', conproc => 'win866_to_koi8r' },
+{ oid => '4414', descr => 'conversion for WIN866 to WIN1251',
+  conname => 'windows_866_to_windows_1251', conforencoding => 'PG_WIN866',
+  contoencoding => 'PG_WIN1251', conproc => 'win866_to_win1251' },
+{ oid => '4415', descr => 'conversion for WIN1251 to WIN866',
+  conname => 'windows_1251_to_windows_866', conforencoding => 'PG_WIN1251',
+  contoencoding => 'PG_WIN866', conproc => 'win1251_to_win866' },
+{ oid => '4416', descr => 'conversion for ISO-8859-5 to KOI8R',
+  conname => 'iso_8859_5_to_koi8_r', conforencoding => 'PG_ISO_8859_5',
+  contoencoding => 'PG_KOI8R', conproc => 'iso_to_koi8r' },
+{ oid => '4417', descr => 'conversion for KOI8R to ISO-8859-5',
+  conname => 'koi8_r_to_iso_8859_5', conforencoding => 'PG_KOI8R',
+  contoencoding => 'PG_ISO_8859_5', conproc => 'koi8r_to_iso' },
+{ oid => '4418', descr => 'conversion for ISO-8859-5 to WIN1251',
+  conname => 'iso_8859_5_to_windows_1251', conforencoding => 'PG_ISO_8859_5',
+  contoencoding => 'PG_WIN1251', conproc => 'iso_to_win1251' },
+{ oid => '4419', descr => 'conversion for WIN1251 to ISO-8859-5',
+  conname => 'windows_1251_to_iso_8859_5', conforencoding => 'PG_WIN1251',
+  contoencoding => 'PG_ISO_8859_5', conproc => 'win1251_to_iso' },
+{ oid => '4420', descr => 'conversion for ISO-8859-5 to WIN866',
+  conname => 'iso_8859_5_to_windows_866', conforencoding => 'PG_ISO_8859_5',
+  contoencoding => 'PG_WIN866', conproc => 'iso_to_win866' },
+{ oid => '4421', descr => 'conversion for WIN866 to ISO-8859-5',
+  conname => 'windows_866_to_iso_8859_5', conforencoding => 'PG_WIN866',
+  contoencoding => 'PG_ISO_8859_5', conproc => 'win866_to_iso' },
+{ oid => '4422', descr => 'conversion for EUC_CN to MULE_INTERNAL',
+  conname => 'euc_cn_to_mic', conforencoding => 'PG_EUC_CN',
+  contoencoding => 'PG_MULE_INTERNAL', conproc => 'euc_cn_to_mic' },
+{ oid => '4423', descr => 'conversion for MULE_INTERNAL to EUC_CN',
+  conname => 'mic_to_euc_cn', conforencoding => 'PG_MULE_INTERNAL',
+  contoencoding => 'PG_EUC_CN', conproc => 'mic_to_euc_cn' },
+{ oid => '4424', descr => 'conversion for EUC_JP to SJIS',
+  conname => 'euc_jp_to_sjis', conforencoding => 'PG_EUC_JP',
+  contoencoding => 'PG_SJIS', conproc => 'euc_jp_to_sjis' },
+{ oid => '4425', descr => 'conversion for SJIS to EUC_JP',
+  conname => 'sjis_to_euc_jp', conforencoding => 'PG_SJIS',
+  contoencoding => 'PG_EUC_JP', conproc => 'sjis_to_euc_jp' },
+{ oid => '4426', descr => 'conversion for EUC_JP to MULE_INTERNAL',
+  conname => 'euc_jp_to_mic', conforencoding => 'PG_EUC_JP',
+  contoencoding => 'PG_MULE_INTERNAL', conproc => 'euc_jp_to_mic' },
+{ oid => '4427', descr => 'conversion for SJIS to MULE_INTERNAL',
+  conname => 'sjis_to_mic', conforencoding => 'PG_SJIS',
+  contoencoding => 'PG_MULE_INTERNAL', conproc => 'sjis_to_mic' },
+{ oid => '4428', descr => 'conversion for MULE_INTERNAL to EUC_JP',
+  conname => 'mic_to_euc_jp', conforencoding => 'PG_MULE_INTERNAL',
+  contoencoding => 'PG_EUC_JP', conproc => 'mic_to_euc_jp' },
+{ oid => '4429', descr => 'conversion for MULE_INTERNAL to SJIS',
+  conname => 'mic_to_sjis', conforencoding => 'PG_MULE_INTERNAL',
+  contoencoding => 'PG_SJIS', conproc => 'mic_to_sjis' },
+{ oid => '4430', descr => 'conversion for EUC_KR to MULE_INTERNAL',
+  conname => 'euc_kr_to_mic', conforencoding => 'PG_EUC_KR',
+  contoencoding => 'PG_MULE_INTERNAL', conproc => 'euc_kr_to_mic' },
+{ oid => '4431', descr => 'conversion for MULE_INTERNAL to EUC_KR',
+  conname => 'mic_to_euc_kr', conforencoding => 'PG_MULE_INTERNAL',
+  contoencoding => 'PG_EUC_KR', conproc => 'mic_to_euc_kr' },
+{ oid => '4432', descr => 'conversion for EUC_TW to BIG5',
+  conname => 'euc_tw_to_big5', conforencoding => 'PG_EUC_TW',
+  contoencoding => 'PG_BIG5', conproc => 'euc_tw_to_big5' },
+{ oid => '4433', descr => 'conversion for BIG5 to EUC_TW',
+  conname => 'big5_to_euc_tw', conforencoding => 'PG_BIG5',
+  contoencoding => 'PG_EUC_TW', conproc => 'big5_to_euc_tw' },
+{ oid => '4434', descr => 'conversion for EUC_TW to MULE_INTERNAL',
+  conname => 'euc_tw_to_mic', conforencoding => 'PG_EUC_TW',
+  contoencoding => 'PG_MULE_INTERNAL', conproc => 'euc_tw_to_mic' },
+{ oid => '4435', descr => 'conversion for BIG5 to MULE_INTERNAL',
+  conname => 'big5_to_mic', conforencoding => 'PG_BIG5',
+  contoencoding => 'PG_MULE_INTERNAL', conproc => 'big5_to_mic' },
+{ oid => '4436', descr => 'conversion for MULE_INTERNAL to EUC_TW',
+  conname => 'mic_to_euc_tw', conforencoding => 'PG_MULE_INTERNAL',
+  contoencoding => 'PG_EUC_TW', conproc => 'mic_to_euc_tw' },
+{ oid => '4437', descr => 'conversion for MULE_INTERNAL to BIG5',
+  conname => 'mic_to_big5', conforencoding => 'PG_MULE_INTERNAL',
+  contoencoding => 'PG_BIG5', conproc => 'mic_to_big5' },
+{ oid => '4438', descr => 'conversion for LATIN2 to MULE_INTERNAL',
+  conname => 'iso_8859_2_to_mic', conforencoding => 'PG_LATIN2',
+  contoencoding => 'PG_MULE_INTERNAL', conproc => 'latin2_to_mic' },
+{ oid => '4439', descr => 'conversion for MULE_INTERNAL to LATIN2',
+  conname => 'mic_to_iso_8859_2', conforencoding => 'PG_MULE_INTERNAL',
+  contoencoding => 'PG_LATIN2', conproc => 'mic_to_latin2' },
+{ oid => '4440', descr => 'conversion for WIN1250 to MULE_INTERNAL',
+  conname => 'windows_1250_to_mic', conforencoding => 'PG_WIN1250',
+  contoencoding => 'PG_MULE_INTERNAL', conproc => 'win1250_to_mic' },
+{ oid => '4441', descr => 'conversion for MULE_INTERNAL to WIN1250',
+  conname => 'mic_to_windows_1250', conforencoding => 'PG_MULE_INTERNAL',
+  contoencoding => 'PG_WIN1250', conproc => 'mic_to_win1250' },
+{ oid => '4442', descr => 'conversion for LATIN2 to WIN1250',
+  conname => 'iso_8859_2_to_windows_1250', conforencoding => 'PG_LATIN2',
+  contoencoding => 'PG_WIN1250', conproc => 'latin2_to_win1250' },
+{ oid => '4443', descr => 'conversion for WIN1250 to LATIN2',
+  conname => 'windows_1250_to_iso_8859_2', conforencoding => 'PG_WIN1250',
+  contoencoding => 'PG_LATIN2', conproc => 'win1250_to_latin2' },
+{ oid => '4444', descr => 'conversion for LATIN1 to MULE_INTERNAL',
+  conname => 'iso_8859_1_to_mic', conforencoding => 'PG_LATIN1',
+  contoencoding => 'PG_MULE_INTERNAL', conproc => 'latin1_to_mic' },
+{ oid => '4445', descr => 'conversion for MULE_INTERNAL to LATIN1',
+  conname => 'mic_to_iso_8859_1', conforencoding => 'PG_MULE_INTERNAL',
+  contoencoding => 'PG_LATIN1', conproc => 'mic_to_latin1' },
+{ oid => '4446', descr => 'conversion for LATIN3 to MULE_INTERNAL',
+  conname => 'iso_8859_3_to_mic', conforencoding => 'PG_LATIN3',
+  contoencoding => 'PG_MULE_INTERNAL', conproc => 'latin3_to_mic' },
+{ oid => '4447', descr => 'conversion for MULE_INTERNAL to LATIN3',
+  conname => 'mic_to_iso_8859_3', conforencoding => 'PG_MULE_INTERNAL',
+  contoencoding => 'PG_LATIN3', conproc => 'mic_to_latin3' },
+{ oid => '4448', descr => 'conversion for LATIN4 to MULE_INTERNAL',
+  conname => 'iso_8859_4_to_mic', conforencoding => 'PG_LATIN4',
+  contoencoding => 'PG_MULE_INTERNAL', conproc => 'latin4_to_mic' },
+{ oid => '4449', descr => 'conversion for MULE_INTERNAL to LATIN4',
+  conname => 'mic_to_iso_8859_4', conforencoding => 'PG_MULE_INTERNAL',
+  contoencoding => 'PG_LATIN4', conproc => 'mic_to_latin4' },
+{ oid => '4452', descr => 'conversion for BIG5 to UTF8',
+  conname => 'big5_to_utf8', conforencoding => 'PG_BIG5',
+  contoencoding => 'PG_UTF8', conproc => 'big5_to_utf8' },
+{ oid => '4453', descr => 'conversion for UTF8 to BIG5',
+  conname => 'utf8_to_big5', conforencoding => 'PG_UTF8',
+  contoencoding => 'PG_BIG5', conproc => 'utf8_to_big5' },
+{ oid => '4454', descr => 'conversion for UTF8 to KOI8R',
+  conname => 'utf8_to_koi8_r', conforencoding => 'PG_UTF8',
+  contoencoding => 'PG_KOI8R', conproc => 'utf8_to_koi8r' },
+{ oid => '4455', descr => 'conversion for KOI8R to UTF8',
+  conname => 'koi8_r_to_utf8', conforencoding => 'PG_KOI8R',
+  contoencoding => 'PG_UTF8', conproc => 'koi8r_to_utf8' },
+{ oid => '4456', descr => 'conversion for UTF8 to KOI8U',
+  conname => 'utf8_to_koi8_u', conforencoding => 'PG_UTF8',
+  contoencoding => 'PG_KOI8U', conproc => 'utf8_to_koi8u' },
+{ oid => '4457', descr => 'conversion for KOI8U to UTF8',
+  conname => 'koi8_u_to_utf8', conforencoding => 'PG_KOI8U',
+  contoencoding => 'PG_UTF8', conproc => 'koi8u_to_utf8' },
+{ oid => '4458', descr => 'conversion for UTF8 to WIN866',
+  conname => 'utf8_to_windows_866', conforencoding => 'PG_UTF8',
+  contoencoding => 'PG_WIN866', conproc => 'utf8_to_win' },
+{ oid => '4459', descr => 'conversion for WIN866 to UTF8',
+  conname => 'windows_866_to_utf8', conforencoding => 'PG_WIN866',
+  contoencoding => 'PG_UTF8', conproc => 'win_to_utf8' },
+{ oid => '4460', descr => 'conversion for UTF8 to WIN874',
+  conname => 'utf8_to_windows_874', conforencoding => 'PG_UTF8',
+  contoencoding => 'PG_WIN874', conproc => 'utf8_to_win' },
+{ oid => '4461', descr => 'conversion for WIN874 to UTF8',
+  conname => 'windows_874_to_utf8', conforencoding => 'PG_WIN874',
+  contoencoding => 'PG_UTF8', conproc => 'win_to_utf8' },
+{ oid => '4462', descr => 'conversion for UTF8 to WIN1250',
+  conname => 'utf8_to_windows_1250', conforencoding => 'PG_UTF8',
+  contoencoding => 'PG_WIN1250', conproc => 'utf8_to_win' },
+{ oid => '4463', descr => 'conversion for WIN1250 to UTF8',
+  conname => 'windows_1250_to_utf8', conforencoding => 'PG_WIN1250',
+  contoencoding => 'PG_UTF8', conproc => 'win_to_utf8' },
+{ oid => '4464', descr => 'conversion for UTF8 to WIN1251',
+  conname => 'utf8_to_windows_1251', conforencoding => 'PG_UTF8',
+  contoencoding => 'PG_WIN1251', conproc => 'utf8_to_win' },
+{ oid => '4465', descr => 'conversion for WIN1251 to UTF8',
+  conname => 'windows_1251_to_utf8', conforencoding => 'PG_WIN1251',
+  contoencoding => 'PG_UTF8', conproc => 'win_to_utf8' },
+{ oid => '4466', descr => 'conversion for UTF8 to WIN1252',
+  conname => 'utf8_to_windows_1252', conforencoding => 'PG_UTF8',
+  contoencoding => 'PG_WIN1252', conproc => 'utf8_to_win' },
+{ oid => '4467', descr => 'conversion for WIN1252 to UTF8',
+  conname => 'windows_1252_to_utf8', conforencoding => 'PG_WIN1252',
+  contoencoding => 'PG_UTF8', conproc => 'win_to_utf8' },
+{ oid => '4468', descr => 'conversion for UTF8 to WIN1253',
+  conname => 'utf8_to_windows_1253', conforencoding => 'PG_UTF8',
+  contoencoding => 'PG_WIN1253', conproc => 'utf8_to_win' },
+{ oid => '4469', descr => 'conversion for WIN1253 to UTF8',
+  conname => 'windows_1253_to_utf8', conforencoding => 'PG_WIN1253',
+  contoencoding => 'PG_UTF8', conproc => 'win_to_utf8' },
+{ oid => '4470', descr => 'conversion for UTF8 to WIN1254',
+  conname => 'utf8_to_windows_1254', conforencoding => 'PG_UTF8',
+  contoencoding => 'PG_WIN1254', conproc => 'utf8_to_win' },
+{ oid => '4471', descr => 'conversion for WIN1254 to UTF8',
+  conname => 'windows_1254_to_utf8', conforencoding => 'PG_WIN1254',
+  contoencoding => 'PG_UTF8', conproc => 'win_to_utf8' },
+{ oid => '4472', descr => 'conversion for UTF8 to WIN1255',
+  conname => 'utf8_to_windows_1255', conforencoding => 'PG_UTF8',
+  contoencoding => 'PG_WIN1255', conproc => 'utf8_to_win' },
+{ oid => '4473', descr => 'conversion for WIN1255 to UTF8',
+  conname => 'windows_1255_to_utf8', conforencoding => 'PG_WIN1255',
+  contoencoding => 'PG_UTF8', conproc => 'win_to_utf8' },
+{ oid => '4474', descr => 'conversion for UTF8 to WIN1256',
+  conname => 'utf8_to_windows_1256', conforencoding => 'PG_UTF8',
+  contoencoding => 'PG_WIN1256', conproc => 'utf8_to_win' },
+{ oid => '4475', descr => 'conversion for WIN1256 to UTF8',
+  conname => 'windows_1256_to_utf8', conforencoding => 'PG_WIN1256',
+  contoencoding => 'PG_UTF8', conproc => 'win_to_utf8' },
+{ oid => '4476', descr => 'conversion for UTF8 to WIN1257',
+  conname => 'utf8_to_windows_1257', conforencoding => 'PG_UTF8',
+  contoencoding => 'PG_WIN1257', conproc => 'utf8_to_win' },
+{ oid => '4477', descr => 'conversion for WIN1257 to UTF8',
+  conname => 'windows_1257_to_utf8', conforencoding => 'PG_WIN1257',
+  contoencoding => 'PG_UTF8', conproc => 'win_to_utf8' },
+{ oid => '4478', descr => 'conversion for UTF8 to WIN1258',
+  conname => 'utf8_to_windows_1258', conforencoding => 'PG_UTF8',
+  contoencoding => 'PG_WIN1258', conproc => 'utf8_to_win' },
+{ oid => '4479', descr => 'conversion for WIN1258 to UTF8',
+  conname => 'windows_1258_to_utf8', conforencoding => 'PG_WIN1258',
+  contoencoding => 'PG_UTF8', conproc => 'win_to_utf8' },
+{ oid => '4480', descr => 'conversion for EUC_CN to UTF8',
+  conname => 'euc_cn_to_utf8', conforencoding => 'PG_EUC_CN',
+  contoencoding => 'PG_UTF8', conproc => 'euc_cn_to_utf8' },
+{ oid => '4481', descr => 'conversion for UTF8 to EUC_CN',
+  conname => 'utf8_to_euc_cn', conforencoding => 'PG_UTF8',
+  contoencoding => 'PG_EUC_CN', conproc => 'utf8_to_euc_cn' },
+{ oid => '4482', descr => 'conversion for EUC_JP to UTF8',
+  conname => 'euc_jp_to_utf8', conforencoding => 'PG_EUC_JP',
+  contoencoding => 'PG_UTF8', conproc => 'euc_jp_to_utf8' },
+{ oid => '4483', descr => 'conversion for UTF8 to EUC_JP',
+  conname => 'utf8_to_euc_jp', conforencoding => 'PG_UTF8',
+  contoencoding => 'PG_EUC_JP', conproc => 'utf8_to_euc_jp' },
+{ oid => '4484', descr => 'conversion for EUC_KR to UTF8',
+  conname => 'euc_kr_to_utf8', conforencoding => 'PG_EUC_KR',
+  contoencoding => 'PG_UTF8', conproc => 'euc_kr_to_utf8' },
+{ oid => '4485', descr => 'conversion for UTF8 to EUC_KR',
+  conname => 'utf8_to_euc_kr', conforencoding => 'PG_UTF8',
+  contoencoding => 'PG_EUC_KR', conproc => 'utf8_to_euc_kr' },
+{ oid => '4486', descr => 'conversion for EUC_TW to UTF8',
+  conname => 'euc_tw_to_utf8', conforencoding => 'PG_EUC_TW',
+  contoencoding => 'PG_UTF8', conproc => 'euc_tw_to_utf8' },
+{ oid => '4487', descr => 'conversion for UTF8 to EUC_TW',
+  conname => 'utf8_to_euc_tw', conforencoding => 'PG_UTF8',
+  contoencoding => 'PG_EUC_TW', conproc => 'utf8_to_euc_tw' },
+{ oid => '4488', descr => 'conversion for GB18030 to UTF8',
+  conname => 'gb18030_to_utf8', conforencoding => 'PG_GB18030',
+  contoencoding => 'PG_UTF8', conproc => 'gb18030_to_utf8' },
+{ oid => '4489', descr => 'conversion for UTF8 to GB18030',
+  conname => 'utf8_to_gb18030', conforencoding => 'PG_UTF8',
+  contoencoding => 'PG_GB18030', conproc => 'utf8_to_gb18030' },
+{ oid => '4490', descr => 'conversion for GBK to UTF8',
+  conname => 'gbk_to_utf8', conforencoding => 'PG_GBK',
+  contoencoding => 'PG_UTF8', conproc => 'gbk_to_utf8' },
+{ oid => '4491', descr => 'conversion for UTF8 to GBK',
+  conname => 'utf8_to_gbk', conforencoding => 'PG_UTF8',
+  contoencoding => 'PG_GBK', conproc => 'utf8_to_gbk' },
+{ oid => '4492', descr => 'conversion for UTF8 to LATIN2',
+  conname => 'utf8_to_iso_8859_2', conforencoding => 'PG_UTF8',
+  contoencoding => 'PG_LATIN2', conproc => 'utf8_to_iso8859' },
+{ oid => '4493', descr => 'conversion for LATIN2 to UTF8',
+  conname => 'iso_8859_2_to_utf8', conforencoding => 'PG_LATIN2',
+  contoencoding => 'PG_UTF8', conproc => 'iso8859_to_utf8' },
+{ oid => '4494', descr => 'conversion for UTF8 to LATIN3',
+  conname => 'utf8_to_iso_8859_3', conforencoding => 'PG_UTF8',
+  contoencoding => 'PG_LATIN3', conproc => 'utf8_to_iso8859' },
+{ oid => '4495', descr => 'conversion for LATIN3 to UTF8',
+  conname => 'iso_8859_3_to_utf8', conforencoding => 'PG_LATIN3',
+  contoencoding => 'PG_UTF8', conproc => 'iso8859_to_utf8' },
+{ oid => '4496', descr => 'conversion for UTF8 to LATIN4',
+  conname => 'utf8_to_iso_8859_4', conforencoding => 'PG_UTF8',
+  contoencoding => 'PG_LATIN4', conproc => 'utf8_to_iso8859' },
+{ oid => '4497', descr => 'conversion for LATIN4 to UTF8',
+  conname => 'iso_8859_4_to_utf8', conforencoding => 'PG_LATIN4',
+  contoencoding => 'PG_UTF8', conproc => 'iso8859_to_utf8' },
+{ oid => '4498', descr => 'conversion for UTF8 to LATIN5',
+  conname => 'utf8_to_iso_8859_9', conforencoding => 'PG_UTF8',
+  contoencoding => 'PG_LATIN5', conproc => 'utf8_to_iso8859' },
+{ oid => '4499', descr => 'conversion for LATIN5 to UTF8',
+  conname => 'iso_8859_9_to_utf8', conforencoding => 'PG_LATIN5',
+  contoencoding => 'PG_UTF8', conproc => 'iso8859_to_utf8' },
+{ oid => '4500', descr => 'conversion for UTF8 to LATIN6',
+  conname => 'utf8_to_iso_8859_10', conforencoding => 'PG_UTF8',
+  contoencoding => 'PG_LATIN6', conproc => 'utf8_to_iso8859' },
+{ oid => '4501', descr => 'conversion for LATIN6 to UTF8',
+  conname => 'iso_8859_10_to_utf8', conforencoding => 'PG_LATIN6',
+  contoencoding => 'PG_UTF8', conproc => 'iso8859_to_utf8' },
+{ oid => '4502', descr => 'conversion for UTF8 to LATIN7',
+  conname => 'utf8_to_iso_8859_13', conforencoding => 'PG_UTF8',
+  contoencoding => 'PG_LATIN7', conproc => 'utf8_to_iso8859' },
+{ oid => '4503', descr => 'conversion for LATIN7 to UTF8',
+  conname => 'iso_8859_13_to_utf8', conforencoding => 'PG_LATIN7',
+  contoencoding => 'PG_UTF8', conproc => 'iso8859_to_utf8' },
+{ oid => '4504', descr => 'conversion for UTF8 to LATIN8',
+  conname => 'utf8_to_iso_8859_14', conforencoding => 'PG_UTF8',
+  contoencoding => 'PG_LATIN8', conproc => 'utf8_to_iso8859' },
+{ oid => '4505', descr => 'conversion for LATIN8 to UTF8',
+  conname => 'iso_8859_14_to_utf8', conforencoding => 'PG_LATIN8',
+  contoencoding => 'PG_UTF8', conproc => 'iso8859_to_utf8' },
+{ oid => '4506', descr => 'conversion for UTF8 to LATIN9',
+  conname => 'utf8_to_iso_8859_15', conforencoding => 'PG_UTF8',
+  contoencoding => 'PG_LATIN9', conproc => 'utf8_to_iso8859' },
+{ oid => '4507', descr => 'conversion for LATIN9 to UTF8',
+  conname => 'iso_8859_15_to_utf8', conforencoding => 'PG_LATIN9',
+  contoencoding => 'PG_UTF8', conproc => 'iso8859_to_utf8' },
+{ oid => '4508', descr => 'conversion for UTF8 to LATIN10',
+  conname => 'utf8_to_iso_8859_16', conforencoding => 'PG_UTF8',
+  contoencoding => 'PG_LATIN10', conproc => 'utf8_to_iso8859' },
+{ oid => '4509', descr => 'conversion for LATIN10 to UTF8',
+  conname => 'iso_8859_16_to_utf8', conforencoding => 'PG_LATIN10',
+  contoencoding => 'PG_UTF8', conproc => 'iso8859_to_utf8' },
+{ oid => '4510', descr => 'conversion for UTF8 to ISO-8859-5',
+  conname => 'utf8_to_iso_8859_5', conforencoding => 'PG_UTF8',
+  contoencoding => 'PG_ISO_8859_5', conproc => 'utf8_to_iso8859' },
+{ oid => '4511', descr => 'conversion for ISO-8859-5 to UTF8',
+  conname => 'iso_8859_5_to_utf8', conforencoding => 'PG_ISO_8859_5',
+  contoencoding => 'PG_UTF8', conproc => 'iso8859_to_utf8' },
+{ oid => '4512', descr => 'conversion for UTF8 to ISO-8859-6',
+  conname => 'utf8_to_iso_8859_6', conforencoding => 'PG_UTF8',
+  contoencoding => 'PG_ISO_8859_6', conproc => 'utf8_to_iso8859' },
+{ oid => '4513', descr => 'conversion for ISO-8859-6 to UTF8',
+  conname => 'iso_8859_6_to_utf8', conforencoding => 'PG_ISO_8859_6',
+  contoencoding => 'PG_UTF8', conproc => 'iso8859_to_utf8' },
+{ oid => '4514', descr => 'conversion for UTF8 to ISO-8859-7',
+  conname => 'utf8_to_iso_8859_7', conforencoding => 'PG_UTF8',
+  contoencoding => 'PG_ISO_8859_7', conproc => 'utf8_to_iso8859' },
+{ oid => '4515', descr => 'conversion for ISO-8859-7 to UTF8',
+  conname => 'iso_8859_7_to_utf8', conforencoding => 'PG_ISO_8859_7',
+  contoencoding => 'PG_UTF8', conproc => 'iso8859_to_utf8' },
+{ oid => '4516', descr => 'conversion for UTF8 to ISO-8859-8',
+  conname => 'utf8_to_iso_8859_8', conforencoding => 'PG_UTF8',
+  contoencoding => 'PG_ISO_8859_8', conproc => 'utf8_to_iso8859' },
+{ oid => '4517', descr => 'conversion for ISO-8859-8 to UTF8',
+  conname => 'iso_8859_8_to_utf8', conforencoding => 'PG_ISO_8859_8',
+  contoencoding => 'PG_UTF8', conproc => 'iso8859_to_utf8' },
+{ oid => '4518', descr => 'conversion for LATIN1 to UTF8',
+  conname => 'iso_8859_1_to_utf8', conforencoding => 'PG_LATIN1',
+  contoencoding => 'PG_UTF8', conproc => 'iso8859_1_to_utf8' },
+{ oid => '4519', descr => 'conversion for UTF8 to LATIN1',
+  conname => 'utf8_to_iso_8859_1', conforencoding => 'PG_UTF8',
+  contoencoding => 'PG_LATIN1', conproc => 'utf8_to_iso8859_1' },
+{ oid => '4520', descr => 'conversion for JOHAB to UTF8',
+  conname => 'johab_to_utf8', conforencoding => 'PG_JOHAB',
+  contoencoding => 'PG_UTF8', conproc => 'johab_to_utf8' },
+{ oid => '4521', descr => 'conversion for UTF8 to JOHAB',
+  conname => 'utf8_to_johab', conforencoding => 'PG_UTF8',
+  contoencoding => 'PG_JOHAB', conproc => 'utf8_to_johab' },
+{ oid => '4522', descr => 'conversion for SJIS to UTF8',
+  conname => 'sjis_to_utf8', conforencoding => 'PG_SJIS',
+  contoencoding => 'PG_UTF8', conproc => 'sjis_to_utf8' },
+{ oid => '4523', descr => 'conversion for UTF8 to SJIS',
+  conname => 'utf8_to_sjis', conforencoding => 'PG_UTF8',
+  contoencoding => 'PG_SJIS', conproc => 'utf8_to_sjis' },
+{ oid => '4524', descr => 'conversion for UHC to UTF8',
+  conname => 'uhc_to_utf8', conforencoding => 'PG_UHC',
+  contoencoding => 'PG_UTF8', conproc => 'uhc_to_utf8' },
+{ oid => '4525', descr => 'conversion for UTF8 to UHC',
+  conname => 'utf8_to_uhc', conforencoding => 'PG_UTF8',
+  contoencoding => 'PG_UHC', conproc => 'utf8_to_uhc' },
+{ oid => '4526', descr => 'conversion for EUC_JIS_2004 to UTF8',
+  conname => 'euc_jis_2004_to_utf8', conforencoding => 'PG_EUC_JIS_2004',
+  contoencoding => 'PG_UTF8', conproc => 'euc_jis_2004_to_utf8' },
+{ oid => '4527', descr => 'conversion for UTF8 to EUC_JIS_2004',
+  conname => 'utf8_to_euc_jis_2004', conforencoding => 'PG_UTF8',
+  contoencoding => 'PG_EUC_JIS_2004', conproc => 'utf8_to_euc_jis_2004' },
+{ oid => '4528', descr => 'conversion for SHIFT_JIS_2004 to UTF8',
+  conname => 'shift_jis_2004_to_utf8', conforencoding => 'PG_SHIFT_JIS_2004',
+  contoencoding => 'PG_UTF8', conproc => 'shift_jis_2004_to_utf8' },
+{ oid => '4529', descr => 'conversion for UTF8 to SHIFT_JIS_2004',
+  conname => 'utf8_to_shift_jis_2004', conforencoding => 'PG_UTF8',
+  contoencoding => 'PG_SHIFT_JIS_2004', conproc => 'utf8_to_shift_jis_2004' },
+{ oid => '4530', descr => 'conversion for EUC_JIS_2004 to SHIFT_JIS_2004',
+  conname => 'euc_jis_2004_to_shift_jis_2004',
+  conforencoding => 'PG_EUC_JIS_2004', contoencoding => 'PG_SHIFT_JIS_2004',
+  conproc => 'euc_jis_2004_to_shift_jis_2004' },
+{ oid => '4531', descr => 'conversion for SHIFT_JIS_2004 to EUC_JIS_2004',
+  conname => 'shift_jis_2004_to_euc_jis_2004',
+  conforencoding => 'PG_SHIFT_JIS_2004', contoencoding => 'PG_EUC_JIS_2004',
+  conproc => 'shift_jis_2004_to_euc_jis_2004' },
+
+]
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_conversion.h b/contrib/libs/postgresql/src/include/catalog/pg_conversion.h
new file mode 100644
index 0000000000..0e7f13e1b6
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_conversion.h
@@ -0,0 +1,72 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_conversion.h
+ *	  definition of the "conversion" system catalog (pg_conversion)
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_conversion.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_CONVERSION_H
+#define PG_CONVERSION_H
+
+#include "catalog/genbki.h"
+#include "catalog/objectaddress.h"
+#include "catalog/pg_conversion_d.h"
+
+/* ----------------
+ *		pg_conversion definition.  cpp turns this into
+ *		typedef struct FormData_pg_conversion
+ * ----------------
+ */
+CATALOG(pg_conversion,2607,ConversionRelationId)
+{
+	/* oid */
+	Oid			oid;
+
+	/* name of the conversion */
+	NameData	conname;
+
+	/* namespace that the conversion belongs to */
+	Oid			connamespace BKI_DEFAULT(PGNSP);
+
+	/* owner of the conversion */
+	Oid			conowner BKI_DEFAULT(PGUID);
+
+	/* FOR encoding id */
+	int32		conforencoding BKI_LOOKUP(encoding);
+
+	/* TO encoding id */
+	int32		contoencoding BKI_LOOKUP(encoding);
+
+	/* OID of the conversion proc */
+	regproc		conproc BKI_LOOKUP(pg_proc);
+
+	/* true if this is a default conversion */
+	bool		condefault BKI_DEFAULT(t);
+} FormData_pg_conversion;
+
+/* ----------------
+ *		Form_pg_conversion corresponds to a pointer to a tuple with
+ *		the format of pg_conversion relation.
+ * ----------------
+ */
+typedef FormData_pg_conversion *Form_pg_conversion;
+
+
+extern ObjectAddress ConversionCreate(const char *conname, Oid connamespace,
+									  Oid conowner,
+									  int32 conforencoding, int32 contoencoding,
+									  Oid conproc, bool def);
+extern void RemoveConversionById(Oid conversionOid);
+extern Oid	FindDefaultConversion(Oid connamespace, int32 for_encoding,
+								  int32 to_encoding);
+
+#endif							/* PG_CONVERSION_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_conversion_d.h b/contrib/libs/postgresql/src/include/catalog/pg_conversion_d.h
new file mode 100644
index 0000000000..b8457ea209
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_conversion_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_conversion_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_database.dat b/contrib/libs/postgresql/src/include/catalog/pg_database.dat
new file mode 100644
index 0000000000..21cd6604f3
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_database.dat
@@ -0,0 +1,22 @@
+#----------------------------------------------------------------------
+#
+# pg_database.dat
+#    Initial contents of the pg_database system catalog.
+#
+# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+# Portions Copyright (c) 1994, Regents of the University of California
+#
+# src/include/catalog/pg_database.dat
+#
+#----------------------------------------------------------------------
+
+[
+
+{ oid => '1', oid_symbol => 'TemplateDbOid',
+  descr => 'default template for new databases',
+  datname => 'template1', encoding => 'ENCODING', datcollate => 'LC_COLLATE',
+  datctype => 'LC_CTYPE', datistemplate => 't', datallowconn => 't',
+  datconnlimit => '-1', datlastsysoid => '0', datfrozenxid => '0',
+  datminmxid => '1', dattablespace => 'pg_default', datacl => '_null_' },
+
+]
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_database.h b/contrib/libs/postgresql/src/include/catalog/pg_database.h
new file mode 100644
index 0000000000..f623ee81b7
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_database.h
@@ -0,0 +1,83 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_database.h
+ *	  definition of the "database" system catalog (pg_database)
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_database.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_DATABASE_H
+#define PG_DATABASE_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_database_d.h"
+
+/* ----------------
+ *		pg_database definition.  cpp turns this into
+ *		typedef struct FormData_pg_database
+ * ----------------
+ */
+CATALOG(pg_database,1262,DatabaseRelationId) BKI_SHARED_RELATION BKI_ROWTYPE_OID(1248,DatabaseRelation_Rowtype_Id) BKI_SCHEMA_MACRO
+{
+	/* oid */
+	Oid			oid;
+
+	/* database name */
+	NameData	datname;
+
+	/* owner of database */
+	Oid			datdba BKI_DEFAULT(PGUID);
+
+	/* character encoding */
+	int32		encoding;
+
+	/* LC_COLLATE setting */
+	NameData	datcollate;
+
+	/* LC_CTYPE setting */
+	NameData	datctype;
+
+	/* allowed as CREATE DATABASE template? */
+	bool		datistemplate;
+
+	/* new connections allowed? */
+	bool		datallowconn;
+
+	/* max connections allowed (-1=no limit) */
+	int32		datconnlimit;
+
+	/* highest OID to consider a system OID */
+	Oid			datlastsysoid;
+
+	/* all Xids < this are frozen in this DB */
+	TransactionId datfrozenxid;
+
+	/* all multixacts in the DB are >= this */
+	TransactionId datminmxid;
+
+	/* default table space for this DB */
+	Oid			dattablespace BKI_LOOKUP(pg_tablespace);
+
+#ifdef CATALOG_VARLEN			/* variable-length fields start here */
+	/* access permissions */
+	aclitem		datacl[1];
+#endif
+} FormData_pg_database;
+
+/* ----------------
+ *		Form_pg_database corresponds to a pointer to a tuple with
+ *		the format of pg_database relation.
+ * ----------------
+ */
+typedef FormData_pg_database *Form_pg_database;
+
+#endif							/* PG_DATABASE_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_database_d.h b/contrib/libs/postgresql/src/include/catalog/pg_database_d.h
new file mode 100644
index 0000000000..7c5ca52aa8
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_database_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_database_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_db_role_setting.h b/contrib/libs/postgresql/src/include/catalog/pg_db_role_setting.h
new file mode 100644
index 0000000000..5713fa2315
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_db_role_setting.h
@@ -0,0 +1,54 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_db_role_setting.h
+ *	  definition of the system catalog for per-database/per-user
+ *	  configuration settings (pg_db_role_setting)
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_db_role_setting.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_DB_ROLE_SETTING_H
+#define PG_DB_ROLE_SETTING_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_db_role_setting_d.h"
+
+#include "utils/guc.h"
+#include "utils/relcache.h"
+#include "utils/snapshot.h"
+
+/* ----------------
+ *		pg_db_role_setting definition.  cpp turns this into
+ *		typedef struct FormData_pg_db_role_setting
+ * ----------------
+ */
+CATALOG(pg_db_role_setting,2964,DbRoleSettingRelationId) BKI_SHARED_RELATION
+{
+	Oid			setdatabase;	/* database */
+	Oid			setrole;		/* role */
+
+#ifdef CATALOG_VARLEN			/* variable-length fields start here */
+	text		setconfig[1];	/* GUC settings to apply at login */
+#endif
+} FormData_pg_db_role_setting;
+
+typedef FormData_pg_db_role_setting * Form_pg_db_role_setting;
+
+/*
+ * prototypes for functions in pg_db_role_setting.h
+ */
+extern void AlterSetting(Oid databaseid, Oid roleid, VariableSetStmt *setstmt);
+extern void DropSetting(Oid databaseid, Oid roleid);
+extern void ApplySetting(Snapshot snapshot, Oid databaseid, Oid roleid,
+						 Relation relsetting, GucSource source);
+
+#endif							/* PG_DB_ROLE_SETTING_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_db_role_setting_d.h b/contrib/libs/postgresql/src/include/catalog/pg_db_role_setting_d.h
new file mode 100644
index 0000000000..5128cb7133
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_db_role_setting_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_db_role_setting_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_default_acl.h b/contrib/libs/postgresql/src/include/catalog/pg_default_acl.h
new file mode 100644
index 0000000000..2bac5e23e1
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_default_acl.h
@@ -0,0 +1,65 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_default_acl.h
+ *	  definition of the system catalog for default ACLs of new objects
+ *	  (pg_default_acl)
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_default_acl.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_DEFAULT_ACL_H
+#define PG_DEFAULT_ACL_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_default_acl_d.h"
+
+/* ----------------
+ *		pg_default_acl definition.  cpp turns this into
+ *		typedef struct FormData_pg_default_acl
+ * ----------------
+ */
+CATALOG(pg_default_acl,826,DefaultAclRelationId)
+{
+	Oid			oid;			/* oid */
+	Oid			defaclrole;		/* OID of role owning this ACL */
+	Oid			defaclnamespace;	/* OID of namespace, or 0 for all */
+	char		defaclobjtype;	/* see DEFACLOBJ_xxx constants below */
+
+#ifdef CATALOG_VARLEN			/* variable-length fields start here */
+	aclitem		defaclacl[1] BKI_FORCE_NOT_NULL;	/* permissions to add at
+													 * CREATE time */
+#endif
+} FormData_pg_default_acl;
+
+/* ----------------
+ *		Form_pg_default_acl corresponds to a pointer to a tuple with
+ *		the format of pg_default_acl relation.
+ * ----------------
+ */
+typedef FormData_pg_default_acl *Form_pg_default_acl;
+
+#ifdef EXPOSE_TO_CLIENT_CODE
+
+/*
+ * Types of objects for which the user is allowed to specify default
+ * permissions through pg_default_acl.  These codes are used in the
+ * defaclobjtype column.
+ */
+#define DEFACLOBJ_RELATION		'r' /* table, view */
+#define DEFACLOBJ_SEQUENCE		'S' /* sequence */
+#define DEFACLOBJ_FUNCTION		'f' /* function */
+#define DEFACLOBJ_TYPE			'T' /* type */
+#define DEFACLOBJ_NAMESPACE		'n' /* namespace */
+
+#endif							/* EXPOSE_TO_CLIENT_CODE */
+
+#endif							/* PG_DEFAULT_ACL_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_default_acl_d.h b/contrib/libs/postgresql/src/include/catalog/pg_default_acl_d.h
new file mode 100644
index 0000000000..c67a7f8e97
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_default_acl_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_default_acl_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_depend.h b/contrib/libs/postgresql/src/include/catalog/pg_depend.h
new file mode 100644
index 0000000000..ccf0a98330
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_depend.h
@@ -0,0 +1,73 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_depend.h
+ *	  definition of the "dependency" system catalog (pg_depend)
+ *
+ * pg_depend has no preloaded contents, so there is no pg_depend.dat
+ * file; system-defined dependencies are loaded into it during a late stage
+ * of the initdb process.
+ *
+ * NOTE: we do not represent all possible dependency pairs in pg_depend;
+ * for example, there's not much value in creating an explicit dependency
+ * from an attribute to its relation.  Usually we make a dependency for
+ * cases where the relationship is conditional rather than essential
+ * (for example, not all triggers are dependent on constraints, but all
+ * attributes are dependent on relations) or where the dependency is not
+ * convenient to find from the contents of other catalogs.
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_depend.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_DEPEND_H
+#define PG_DEPEND_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_depend_d.h"
+
+/* ----------------
+ *		pg_depend definition.  cpp turns this into
+ *		typedef struct FormData_pg_depend
+ * ----------------
+ */
+CATALOG(pg_depend,2608,DependRelationId)
+{
+	/*
+	 * Identification of the dependent (referencing) object.
+	 *
+	 * These fields are all zeroes for a DEPENDENCY_PIN entry.
+	 */
+	Oid			classid;		/* OID of table containing object */
+	Oid			objid;			/* OID of object itself */
+	int32		objsubid;		/* column number, or 0 if not used */
+
+	/*
+	 * Identification of the independent (referenced) object.
+	 */
+	Oid			refclassid;		/* OID of table containing object */
+	Oid			refobjid;		/* OID of object itself */
+	int32		refobjsubid;	/* column number, or 0 if not used */
+
+	/*
+	 * Precise semantics of the relationship are specified by the deptype
+	 * field.  See DependencyType in catalog/dependency.h.
+	 */
+	char		deptype;		/* see codes in dependency.h */
+} FormData_pg_depend;
+
+/* ----------------
+ *		Form_pg_depend corresponds to a pointer to a row with
+ *		the format of pg_depend relation.
+ * ----------------
+ */
+typedef FormData_pg_depend *Form_pg_depend;
+
+#endif							/* PG_DEPEND_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_depend_d.h b/contrib/libs/postgresql/src/include/catalog/pg_depend_d.h
new file mode 100644
index 0000000000..a25be9e0ab
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_depend_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_depend_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_description.h b/contrib/libs/postgresql/src/include/catalog/pg_description.h
new file mode 100644
index 0000000000..c40e8b7373
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_description.h
@@ -0,0 +1,66 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_description.h
+ *	  definition of the "description" system catalog (pg_description)
+ *
+ * Because the contents of this table are taken from the *.dat files
+ * of other catalogs, there is no pg_description.dat file. The initial
+ * contents are assembled by genbki.pl and loaded during initdb.
+ *
+ * NOTE: an object is identified by the OID of the row that primarily
+ * defines the object, plus the OID of the table that that row appears in.
+ * For example, a function is identified by the OID of its pg_proc row
+ * plus the pg_class OID of table pg_proc.  This allows unique identification
+ * of objects without assuming that OIDs are unique across tables.
+ *
+ * Since attributes don't have OIDs of their own, we identify an attribute
+ * comment by the objoid+classoid of its parent table, plus an "objsubid"
+ * giving the attribute column number.  "objsubid" must be zero in a comment
+ * for a table itself, so that it is distinct from any column comment.
+ * Currently, objsubid is unused and zero for all other kinds of objects,
+ * but perhaps it might be useful someday to associate comments with
+ * constituent elements of other kinds of objects (arguments of a function,
+ * for example).
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_description.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_DESCRIPTION_H
+#define PG_DESCRIPTION_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_description_d.h"
+
+/* ----------------
+ *		pg_description definition.  cpp turns this into
+ *		typedef struct FormData_pg_description
+ * ----------------
+ */
+CATALOG(pg_description,2609,DescriptionRelationId)
+{
+	Oid			objoid;			/* OID of object itself */
+	Oid			classoid;		/* OID of table containing object */
+	int32		objsubid;		/* column number, or 0 if not used */
+
+#ifdef CATALOG_VARLEN			/* variable-length fields start here */
+	text		description BKI_FORCE_NOT_NULL; /* description of object */
+#endif
+} FormData_pg_description;
+
+/* ----------------
+ *		Form_pg_description corresponds to a pointer to a tuple with
+ *		the format of pg_description relation.
+ * ----------------
+ */
+typedef FormData_pg_description * Form_pg_description;
+
+#endif							/* PG_DESCRIPTION_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_description_d.h b/contrib/libs/postgresql/src/include/catalog/pg_description_d.h
new file mode 100644
index 0000000000..72f10e1b92
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_description_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_description_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_enum.h b/contrib/libs/postgresql/src/include/catalog/pg_enum.h
new file mode 100644
index 0000000000..b28d441ba7
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_enum.h
@@ -0,0 +1,62 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_enum.h
+ *	  definition of the "enum" system catalog (pg_enum)
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_enum.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_ENUM_H
+#define PG_ENUM_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_enum_d.h"
+
+#include "nodes/pg_list.h"
+
+/* ----------------
+ *		pg_enum definition.  cpp turns this into
+ *		typedef struct FormData_pg_enum
+ * ----------------
+ */
+CATALOG(pg_enum,3501,EnumRelationId)
+{
+	Oid			oid;			/* oid */
+	Oid			enumtypid;		/* OID of owning enum type */
+	float4		enumsortorder;	/* sort position of this enum value */
+	NameData	enumlabel;		/* text representation of enum value */
+} FormData_pg_enum;
+
+/* ----------------
+ *		Form_pg_enum corresponds to a pointer to a tuple with
+ *		the format of pg_enum relation.
+ * ----------------
+ */
+typedef FormData_pg_enum *Form_pg_enum;
+
+/*
+ * prototypes for functions in pg_enum.c
+ */
+extern void EnumValuesCreate(Oid enumTypeOid, List *vals);
+extern void EnumValuesDelete(Oid enumTypeOid);
+extern void AddEnumLabel(Oid enumTypeOid, const char *newVal,
+						 const char *neighbor, bool newValIsAfter,
+						 bool skipIfExists);
+extern void RenameEnumLabel(Oid enumTypeOid,
+							const char *oldVal, const char *newVal);
+extern bool EnumBlacklisted(Oid enum_id);
+extern Size EstimateEnumBlacklistSpace(void);
+extern void SerializeEnumBlacklist(void *space, Size size);
+extern void RestoreEnumBlacklist(void *space);
+extern void AtEOXact_Enum(void);
+
+#endif							/* PG_ENUM_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_enum_d.h b/contrib/libs/postgresql/src/include/catalog/pg_enum_d.h
new file mode 100644
index 0000000000..5a10069294
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_enum_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_enum_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_event_trigger.h b/contrib/libs/postgresql/src/include/catalog/pg_event_trigger.h
new file mode 100644
index 0000000000..24e4b1a181
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_event_trigger.h
@@ -0,0 +1,51 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_event_trigger.h
+ *	  definition of the "event trigger" system catalog (pg_event_trigger)
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_event_trigger.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_EVENT_TRIGGER_H
+#define PG_EVENT_TRIGGER_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_event_trigger_d.h"
+
+/* ----------------
+ *		pg_event_trigger definition.    cpp turns this into
+ *		typedef struct FormData_pg_event_trigger
+ * ----------------
+ */
+CATALOG(pg_event_trigger,3466,EventTriggerRelationId)
+{
+	Oid			oid;			/* oid */
+	NameData	evtname;		/* trigger's name */
+	NameData	evtevent;		/* trigger's event */
+	Oid			evtowner;		/* trigger's owner */
+	Oid			evtfoid;		/* OID of function to be called */
+	char		evtenabled;		/* trigger's firing configuration WRT
+								 * session_replication_role */
+
+#ifdef CATALOG_VARLEN
+	text		evttags[1];		/* command TAGs this event trigger targets */
+#endif
+} FormData_pg_event_trigger;
+
+/* ----------------
+ *		Form_pg_event_trigger corresponds to a pointer to a tuple with
+ *		the format of pg_event_trigger relation.
+ * ----------------
+ */
+typedef FormData_pg_event_trigger *Form_pg_event_trigger;
+
+#endif							/* PG_EVENT_TRIGGER_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_event_trigger_d.h b/contrib/libs/postgresql/src/include/catalog/pg_event_trigger_d.h
new file mode 100644
index 0000000000..20d5bf4845
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_event_trigger_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_event_trigger_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_extension.h b/contrib/libs/postgresql/src/include/catalog/pg_extension.h
new file mode 100644
index 0000000000..b6f4128cf3
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_extension.h
@@ -0,0 +1,52 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_extension.h
+ *	  definition of the "extension" system catalog (pg_extension)
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_extension.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_EXTENSION_H
+#define PG_EXTENSION_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_extension_d.h"
+
+/* ----------------
+ *		pg_extension definition.  cpp turns this into
+ *		typedef struct FormData_pg_extension
+ * ----------------
+ */
+CATALOG(pg_extension,3079,ExtensionRelationId)
+{
+	Oid			oid;			/* oid */
+	NameData	extname;		/* extension name */
+	Oid			extowner;		/* extension owner */
+	Oid			extnamespace;	/* namespace of contained objects */
+	bool		extrelocatable; /* if true, allow ALTER EXTENSION SET SCHEMA */
+
+#ifdef CATALOG_VARLEN			/* variable-length fields start here */
+	/* extversion may never be null, but the others can be. */
+	text		extversion BKI_FORCE_NOT_NULL;	/* extension version name */
+	Oid			extconfig[1];	/* dumpable configuration tables */
+	text		extcondition[1];	/* WHERE clauses for config tables */
+#endif
+} FormData_pg_extension;
+
+/* ----------------
+ *		Form_pg_extension corresponds to a pointer to a tuple with
+ *		the format of pg_extension relation.
+ * ----------------
+ */
+typedef FormData_pg_extension *Form_pg_extension;
+
+#endif							/* PG_EXTENSION_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_extension_d.h b/contrib/libs/postgresql/src/include/catalog/pg_extension_d.h
new file mode 100644
index 0000000000..be632265be
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_extension_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_extension_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_foreign_data_wrapper.h b/contrib/libs/postgresql/src/include/catalog/pg_foreign_data_wrapper.h
new file mode 100644
index 0000000000..44d8558c41
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_foreign_data_wrapper.h
@@ -0,0 +1,50 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_foreign_data_wrapper.h
+ *	  definition of the "foreign-data wrapper" system catalog (pg_foreign_data_wrapper)
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_foreign_data_wrapper.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_FOREIGN_DATA_WRAPPER_H
+#define PG_FOREIGN_DATA_WRAPPER_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_foreign_data_wrapper_d.h"
+
+/* ----------------
+ *		pg_foreign_data_wrapper definition.  cpp turns this into
+ *		typedef struct FormData_pg_foreign_data_wrapper
+ * ----------------
+ */
+CATALOG(pg_foreign_data_wrapper,2328,ForeignDataWrapperRelationId)
+{
+	Oid			oid;			/* oid */
+	NameData	fdwname;		/* foreign-data wrapper name */
+	Oid			fdwowner;		/* FDW owner */
+	Oid			fdwhandler;		/* handler function, or 0 if none */
+	Oid			fdwvalidator;	/* option validation function, or 0 if none */
+
+#ifdef CATALOG_VARLEN			/* variable-length fields start here */
+	aclitem		fdwacl[1];		/* access permissions */
+	text		fdwoptions[1];	/* FDW options */
+#endif
+} FormData_pg_foreign_data_wrapper;
+
+/* ----------------
+ *		Form_pg_foreign_data_wrapper corresponds to a pointer to a tuple with
+ *		the format of pg_foreign_data_wrapper relation.
+ * ----------------
+ */
+typedef FormData_pg_foreign_data_wrapper *Form_pg_foreign_data_wrapper;
+
+#endif							/* PG_FOREIGN_DATA_WRAPPER_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_foreign_data_wrapper_d.h b/contrib/libs/postgresql/src/include/catalog/pg_foreign_data_wrapper_d.h
new file mode 100644
index 0000000000..7098c77d41
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_foreign_data_wrapper_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_foreign_data_wrapper_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_foreign_server.h b/contrib/libs/postgresql/src/include/catalog/pg_foreign_server.h
new file mode 100644
index 0000000000..5c17004151
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_foreign_server.h
@@ -0,0 +1,50 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_foreign_server.h
+ *	  definition of the "foreign server" system catalog (pg_foreign_server)
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_foreign_server.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_FOREIGN_SERVER_H
+#define PG_FOREIGN_SERVER_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_foreign_server_d.h"
+
+/* ----------------
+ *		pg_foreign_server definition.  cpp turns this into
+ *		typedef struct FormData_pg_foreign_server
+ * ----------------
+ */
+CATALOG(pg_foreign_server,1417,ForeignServerRelationId)
+{
+	Oid			oid;			/* oid */
+	NameData	srvname;		/* foreign server name */
+	Oid			srvowner;		/* server owner */
+	Oid			srvfdw;			/* server FDW */
+
+#ifdef CATALOG_VARLEN			/* variable-length fields start here */
+	text		srvtype;
+	text		srvversion;
+	aclitem		srvacl[1];		/* access permissions */
+	text		srvoptions[1];	/* FDW-specific options */
+#endif
+} FormData_pg_foreign_server;
+
+/* ----------------
+ *		Form_pg_foreign_server corresponds to a pointer to a tuple with
+ *		the format of pg_foreign_server relation.
+ * ----------------
+ */
+typedef FormData_pg_foreign_server *Form_pg_foreign_server;
+
+#endif							/* PG_FOREIGN_SERVER_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_foreign_server_d.h b/contrib/libs/postgresql/src/include/catalog/pg_foreign_server_d.h
new file mode 100644
index 0000000000..baddc2a76d
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_foreign_server_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_foreign_server_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_foreign_table.h b/contrib/libs/postgresql/src/include/catalog/pg_foreign_table.h
new file mode 100644
index 0000000000..31c1faed03
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_foreign_table.h
@@ -0,0 +1,45 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_foreign_table.h
+ *	  definition of the "foreign table" system catalog (pg_foreign_table)
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_foreign_table.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_FOREIGN_TABLE_H
+#define PG_FOREIGN_TABLE_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_foreign_table_d.h"
+
+/* ----------------
+ *		pg_foreign_table definition.  cpp turns this into
+ *		typedef struct FormData_pg_foreign_table
+ * ----------------
+ */
+CATALOG(pg_foreign_table,3118,ForeignTableRelationId)
+{
+	Oid			ftrelid;		/* OID of foreign table */
+	Oid			ftserver;		/* OID of foreign server */
+
+#ifdef CATALOG_VARLEN			/* variable-length fields start here */
+	text		ftoptions[1];	/* FDW-specific options */
+#endif
+} FormData_pg_foreign_table;
+
+/* ----------------
+ *		Form_pg_foreign_table corresponds to a pointer to a tuple with
+ *		the format of pg_foreign_table relation.
+ * ----------------
+ */
+typedef FormData_pg_foreign_table *Form_pg_foreign_table;
+
+#endif							/* PG_FOREIGN_TABLE_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_foreign_table_d.h b/contrib/libs/postgresql/src/include/catalog/pg_foreign_table_d.h
new file mode 100644
index 0000000000..a8822cbf34
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_foreign_table_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_foreign_table_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_index.h b/contrib/libs/postgresql/src/include/catalog/pg_index.h
new file mode 100644
index 0000000000..d3d7ea77fb
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_index.h
@@ -0,0 +1,80 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_index.h
+ *	  definition of the "index" system catalog (pg_index)
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_index.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_INDEX_H
+#define PG_INDEX_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_index_d.h"
+
+/* ----------------
+ *		pg_index definition.  cpp turns this into
+ *		typedef struct FormData_pg_index.
+ * ----------------
+ */
+CATALOG(pg_index,2610,IndexRelationId) BKI_SCHEMA_MACRO
+{
+	Oid			indexrelid;		/* OID of the index */
+	Oid			indrelid;		/* OID of the relation it indexes */
+	int16		indnatts;		/* total number of columns in index */
+	int16		indnkeyatts;	/* number of key columns in index */
+	bool		indisunique;	/* is this a unique index? */
+	bool		indisprimary;	/* is this index for primary key? */
+	bool		indisexclusion; /* is this index for exclusion constraint? */
+	bool		indimmediate;	/* is uniqueness enforced immediately? */
+	bool		indisclustered; /* is this the index last clustered by? */
+	bool		indisvalid;		/* is this index valid for use by queries? */
+	bool		indcheckxmin;	/* must we wait for xmin to be old? */
+	bool		indisready;		/* is this index ready for inserts? */
+	bool		indislive;		/* is this index alive at all? */
+	bool		indisreplident; /* is this index the identity for replication? */
+
+	/* variable-length fields start here, but we allow direct access to indkey */
+	int2vector	indkey;			/* column numbers of indexed cols, or 0 */
+
+#ifdef CATALOG_VARLEN
+	oidvector	indcollation;	/* collation identifiers */
+	oidvector	indclass;		/* opclass identifiers */
+	int2vector	indoption;		/* per-column flags (AM-specific meanings) */
+	pg_node_tree indexprs;		/* expression trees for index attributes that
+								 * are not simple column references; one for
+								 * each zero entry in indkey[] */
+	pg_node_tree indpred;		/* expression tree for predicate, if a partial
+								 * index; else NULL */
+#endif
+} FormData_pg_index;
+
+/* ----------------
+ *		Form_pg_index corresponds to a pointer to a tuple with
+ *		the format of pg_index relation.
+ * ----------------
+ */
+typedef FormData_pg_index *Form_pg_index;
+
+#ifdef EXPOSE_TO_CLIENT_CODE
+
+/*
+ * Index AMs that support ordered scans must support these two indoption
+ * bits.  Otherwise, the content of the per-column indoption fields is
+ * open for future definition.
+ */
+#define INDOPTION_DESC			0x0001	/* values are in reverse order */
+#define INDOPTION_NULLS_FIRST	0x0002	/* NULLs are first instead of last */
+
+#endif							/* EXPOSE_TO_CLIENT_CODE */
+
+#endif							/* PG_INDEX_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_index_d.h b/contrib/libs/postgresql/src/include/catalog/pg_index_d.h
new file mode 100644
index 0000000000..f503f4f562
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_index_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_index_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_inherits.h b/contrib/libs/postgresql/src/include/catalog/pg_inherits.h
new file mode 100644
index 0000000000..0432c3ab88
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_inherits.h
@@ -0,0 +1,57 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_inherits.h
+ *	  definition of the "inherits" system catalog (pg_inherits)
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_inherits.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_INHERITS_H
+#define PG_INHERITS_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_inherits_d.h"
+
+#include "nodes/pg_list.h"
+#include "storage/lock.h"
+
+/* ----------------
+ *		pg_inherits definition.  cpp turns this into
+ *		typedef struct FormData_pg_inherits
+ * ----------------
+ */
+CATALOG(pg_inherits,2611,InheritsRelationId)
+{
+	Oid			inhrelid;
+	Oid			inhparent;
+	int32		inhseqno;
+} FormData_pg_inherits;
+
+/* ----------------
+ *		Form_pg_inherits corresponds to a pointer to a tuple with
+ *		the format of pg_inherits relation.
+ * ----------------
+ */
+typedef FormData_pg_inherits *Form_pg_inherits;
+
+
+extern List *find_inheritance_children(Oid parentrelId, LOCKMODE lockmode);
+extern List *find_all_inheritors(Oid parentrelId, LOCKMODE lockmode,
+								 List **parents);
+extern bool has_subclass(Oid relationId);
+extern bool has_superclass(Oid relationId);
+extern bool typeInheritsFrom(Oid subclassTypeId, Oid superclassTypeId);
+extern void StoreSingleInheritance(Oid relationId, Oid parentOid,
+								   int32 seqNumber);
+extern bool DeleteInheritsTuple(Oid inhrelid, Oid inhparent);
+
+#endif							/* PG_INHERITS_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_inherits_d.h b/contrib/libs/postgresql/src/include/catalog/pg_inherits_d.h
new file mode 100644
index 0000000000..ce95d9c904
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_inherits_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_inherits_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_init_privs.h b/contrib/libs/postgresql/src/include/catalog/pg_init_privs.h
new file mode 100644
index 0000000000..7734b72c04
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_init_privs.h
@@ -0,0 +1,78 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_init_privs.h
+ *	  definition of the "initial privileges" system catalog (pg_init_privs)
+ *
+ * NOTE: an object is identified by the OID of the row that primarily
+ * defines the object, plus the OID of the table that that row appears in.
+ * For example, a function is identified by the OID of its pg_proc row
+ * plus the pg_class OID of table pg_proc.  This allows unique identification
+ * of objects without assuming that OIDs are unique across tables.
+ *
+ * Since attributes don't have OIDs of their own, we identify an attribute
+ * privilege by the objoid+classoid of its parent table, plus an "objsubid"
+ * giving the attribute column number.  "objsubid" must be zero in a privilege
+ * for a table itself, so that it is distinct from any column privilege.
+ * Currently, objsubid is unused and zero for all other kinds of objects.
+ *
+ * Because the contents of this table depend on what is done with the other
+ * objects in the system (and, in particular, may change due to changes in
+ * system_views.sql), there is no pg_init_privs.dat file. The initial contents
+ * are loaded near the end of initdb.
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_init_privs.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_INIT_PRIVS_H
+#define PG_INIT_PRIVS_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_init_privs_d.h"
+
+/* ----------------
+ *		pg_init_privs definition.  cpp turns this into
+ *		typedef struct FormData_pg_init_privs
+ * ----------------
+ */
+CATALOG(pg_init_privs,3394,InitPrivsRelationId)
+{
+	Oid			objoid;			/* OID of object itself */
+	Oid			classoid;		/* OID of table containing object */
+	int32		objsubid;		/* column number, or 0 if not used */
+	char		privtype;		/* from initdb or extension? */
+
+#ifdef CATALOG_VARLEN			/* variable-length fields start here */
+	aclitem		initprivs[1] BKI_FORCE_NOT_NULL;	/* initial privs on object */
+#endif
+} FormData_pg_init_privs;
+
+/* ----------------
+ *		Form_pg_init_privs corresponds to a pointer to a tuple with
+ *		the format of pg_init_privs relation.
+ * ----------------
+ */
+typedef FormData_pg_init_privs * Form_pg_init_privs;
+
+/*
+ * It is important to know if the initial privileges are from initdb or from an
+ * extension.  This enum is used to provide that differentiation and the two
+ * places which populate this table (initdb and during CREATE EXTENSION, see
+ * recordExtensionInitPriv()) know to use the correct values.
+ */
+
+typedef enum InitPrivsType
+{
+	INITPRIVS_INITDB = 'i',
+	INITPRIVS_EXTENSION = 'e'
+} InitPrivsType;
+
+#endif							/* PG_INIT_PRIVS_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_init_privs_d.h b/contrib/libs/postgresql/src/include/catalog/pg_init_privs_d.h
new file mode 100644
index 0000000000..267e64e304
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_init_privs_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_init_privs_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_language.dat b/contrib/libs/postgresql/src/include/catalog/pg_language.dat
new file mode 100644
index 0000000000..2e44a2730d
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_language.dat
@@ -0,0 +1,25 @@
+#----------------------------------------------------------------------
+#
+# pg_language.dat
+#    Initial contents of the pg_language system catalog.
+#
+# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+# Portions Copyright (c) 1994, Regents of the University of California
+#
+# src/include/catalog/pg_language.dat
+#
+#----------------------------------------------------------------------
+
+[
+
+{ oid => '12', oid_symbol => 'INTERNALlanguageId',
+  descr => 'built-in functions',
+  lanname => 'internal', lanvalidator => 'fmgr_internal_validator' },
+{ oid => '13', oid_symbol => 'ClanguageId',
+  descr => 'dynamically-loaded C functions',
+  lanname => 'c', lanvalidator => 'fmgr_c_validator' },
+{ oid => '14', oid_symbol => 'SQLlanguageId',
+  descr => 'SQL-language functions',
+  lanname => 'sql', lanpltrusted => 't', lanvalidator => 'fmgr_sql_validator' },
+
+]
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_language.h b/contrib/libs/postgresql/src/include/catalog/pg_language.h
new file mode 100644
index 0000000000..937bacbf98
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_language.h
@@ -0,0 +1,67 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_language.h
+ *	  definition of the "language" system catalog (pg_language)
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_language.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_LANGUAGE_H
+#define PG_LANGUAGE_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_language_d.h"
+
+/* ----------------
+ *		pg_language definition.  cpp turns this into
+ *		typedef struct FormData_pg_language
+ * ----------------
+ */
+CATALOG(pg_language,2612,LanguageRelationId)
+{
+	Oid			oid;			/* oid */
+
+	/* Language name */
+	NameData	lanname;
+
+	/* Language's owner */
+	Oid			lanowner BKI_DEFAULT(PGUID);
+
+	/* Is a procedural language */
+	bool		lanispl BKI_DEFAULT(f);
+
+	/* PL is trusted */
+	bool		lanpltrusted BKI_DEFAULT(f);
+
+	/* Call handler, if it's a PL */
+	Oid			lanplcallfoid BKI_DEFAULT(0) BKI_LOOKUP(pg_proc);
+
+	/* Optional anonymous-block handler function */
+	Oid			laninline BKI_DEFAULT(0) BKI_LOOKUP(pg_proc);
+
+	/* Optional validation function */
+	Oid			lanvalidator BKI_DEFAULT(0) BKI_LOOKUP(pg_proc);
+
+#ifdef CATALOG_VARLEN			/* variable-length fields start here */
+	/* Access privileges */
+	aclitem		lanacl[1] BKI_DEFAULT(_null_);
+#endif
+} FormData_pg_language;
+
+/* ----------------
+ *		Form_pg_language corresponds to a pointer to a tuple with
+ *		the format of pg_language relation.
+ * ----------------
+ */
+typedef FormData_pg_language *Form_pg_language;
+
+#endif							/* PG_LANGUAGE_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_language_d.h b/contrib/libs/postgresql/src/include/catalog/pg_language_d.h
new file mode 100644
index 0000000000..4cb0a127ed
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_language_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_language_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_largeobject.h b/contrib/libs/postgresql/src/include/catalog/pg_largeobject.h
new file mode 100644
index 0000000000..f64703ff8d
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_largeobject.h
@@ -0,0 +1,50 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_largeobject.h
+ *	  definition of the "large object" system catalog (pg_largeobject)
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_largeobject.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_LARGEOBJECT_H
+#define PG_LARGEOBJECT_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_largeobject_d.h"
+
+/* ----------------
+ *		pg_largeobject definition.  cpp turns this into
+ *		typedef struct FormData_pg_largeobject
+ * ----------------
+ */
+CATALOG(pg_largeobject,2613,LargeObjectRelationId)
+{
+	Oid			loid;			/* Identifier of large object */
+	int32		pageno;			/* Page number (starting from 0) */
+
+	/* data has variable length, but we allow direct access; see inv_api.c */
+	bytea		data BKI_FORCE_NOT_NULL;	/* Data for page (may be
+											 * zero-length) */
+} FormData_pg_largeobject;
+
+/* ----------------
+ *		Form_pg_largeobject corresponds to a pointer to a tuple with
+ *		the format of pg_largeobject relation.
+ * ----------------
+ */
+typedef FormData_pg_largeobject *Form_pg_largeobject;
+
+extern Oid	LargeObjectCreate(Oid loid);
+extern void LargeObjectDrop(Oid loid);
+extern bool LargeObjectExists(Oid loid);
+
+#endif							/* PG_LARGEOBJECT_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_largeobject_d.h b/contrib/libs/postgresql/src/include/catalog/pg_largeobject_d.h
new file mode 100644
index 0000000000..15d990ad91
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_largeobject_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_largeobject_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_largeobject_metadata.h b/contrib/libs/postgresql/src/include/catalog/pg_largeobject_metadata.h
new file mode 100644
index 0000000000..8f6b4720d4
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_largeobject_metadata.h
@@ -0,0 +1,48 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_largeobject_metadata.h
+ *	  definition of the "large object metadata" system catalog
+ *	  (pg_largeobject_metadata)
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_largeobject_metadata.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_LARGEOBJECT_METADATA_H
+#define PG_LARGEOBJECT_METADATA_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_largeobject_metadata_d.h"
+
+/* ----------------
+ *		pg_largeobject_metadata definition. cpp turns this into
+ *		typedef struct FormData_pg_largeobject_metadata
+ * ----------------
+ */
+CATALOG(pg_largeobject_metadata,2995,LargeObjectMetadataRelationId)
+{
+	Oid			oid;			/* oid */
+
+	Oid			lomowner;		/* OID of the largeobject owner */
+
+#ifdef CATALOG_VARLEN			/* variable-length fields start here */
+	aclitem		lomacl[1];		/* access permissions */
+#endif
+} FormData_pg_largeobject_metadata;
+
+/* ----------------
+ *		Form_pg_largeobject_metadata corresponds to a pointer to a tuple
+ *		with the format of pg_largeobject_metadata relation.
+ * ----------------
+ */
+typedef FormData_pg_largeobject_metadata *Form_pg_largeobject_metadata;
+
+#endif							/* PG_LARGEOBJECT_METADATA_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_largeobject_metadata_d.h b/contrib/libs/postgresql/src/include/catalog/pg_largeobject_metadata_d.h
new file mode 100644
index 0000000000..b7fea19e57
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_largeobject_metadata_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_largeobject_metadata_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_namespace.dat b/contrib/libs/postgresql/src/include/catalog/pg_namespace.dat
new file mode 100644
index 0000000000..63a61022ce
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_namespace.dat
@@ -0,0 +1,25 @@
+#----------------------------------------------------------------------
+#
+# pg_namespace.dat
+#    Initial contents of the pg_namespace system catalog.
+#
+# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+# Portions Copyright (c) 1994, Regents of the University of California
+#
+# src/include/catalog/pg_namespace.dat
+#
+#----------------------------------------------------------------------
+
+[
+
+{ oid => '11', oid_symbol => 'PG_CATALOG_NAMESPACE',
+  descr => 'system catalog schema',
+  nspname => 'pg_catalog', nspowner => 'PGUID', nspacl => '_null_' },
+{ oid => '99', oid_symbol => 'PG_TOAST_NAMESPACE',
+  descr => 'reserved schema for TOAST tables',
+  nspname => 'pg_toast', nspowner => 'PGUID', nspacl => '_null_' },
+{ oid => '2200', oid_symbol => 'PG_PUBLIC_NAMESPACE',
+  descr => 'standard public schema',
+  nspname => 'public', nspowner => 'PGUID', nspacl => '_null_' },
+
+]
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_namespace.h b/contrib/libs/postgresql/src/include/catalog/pg_namespace.h
new file mode 100644
index 0000000000..db93b27015
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_namespace.h
@@ -0,0 +1,59 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_namespace.h
+ *	  definition of the "namespace" system catalog (pg_namespace)
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_namespace.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_NAMESPACE_H
+#define PG_NAMESPACE_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_namespace_d.h"
+#include "utils/acl.h"
+
+/* ----------------------------------------------------------------
+ *		pg_namespace definition.
+ *
+ *		cpp turns this into typedef struct FormData_pg_namespace
+ *
+ *	nspname				name of the namespace
+ *	nspowner			owner (creator) of the namespace
+ *	nspacl				access privilege list
+ * ----------------------------------------------------------------
+ */
+CATALOG(pg_namespace,2615,NamespaceRelationId)
+{
+	Oid			oid;			/* oid */
+
+	NameData	nspname;
+	Oid			nspowner;
+
+#ifdef CATALOG_VARLEN			/* variable-length fields start here */
+	aclitem		nspacl[1];
+#endif
+} FormData_pg_namespace;
+
+/* ----------------
+ *		Form_pg_namespace corresponds to a pointer to a tuple with
+ *		the format of pg_namespace relation.
+ * ----------------
+ */
+typedef FormData_pg_namespace *Form_pg_namespace;
+
+/*
+ * prototypes for functions in pg_namespace.c
+ */
+extern Oid	NamespaceCreate(const char *nspName, Oid ownerId, bool isTemp);
+
+#endif							/* PG_NAMESPACE_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_namespace_d.h b/contrib/libs/postgresql/src/include/catalog/pg_namespace_d.h
new file mode 100644
index 0000000000..a6ec80c6b0
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_namespace_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_namespace_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_opclass.dat b/contrib/libs/postgresql/src/include/catalog/pg_opclass.dat
new file mode 100644
index 0000000000..f2342bb328
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_opclass.dat
@@ -0,0 +1,350 @@
+#----------------------------------------------------------------------
+#
+# pg_opclass.dat
+#    Initial contents of the pg_opclass system catalog.
+#
+# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+# Portions Copyright (c) 1994, Regents of the University of California
+#
+# src/include/catalog/pg_opclass.dat
+#
+#----------------------------------------------------------------------
+
+[
+
+# Note: we hard-wire an OID only for a few entries that have to be explicitly
+# referenced in the C code or in built-in catalog entries.  The rest get OIDs
+# assigned on-the-fly during initdb.
+
+{ opcmethod => 'btree', opcname => 'array_ops', opcfamily => 'btree/array_ops',
+  opcintype => 'anyarray' },
+{ opcmethod => 'hash', opcname => 'array_ops', opcfamily => 'hash/array_ops',
+  opcintype => 'anyarray' },
+{ opcmethod => 'btree', opcname => 'bit_ops', opcfamily => 'btree/bit_ops',
+  opcintype => 'bit' },
+{ opcmethod => 'btree', opcname => 'bool_ops', opcfamily => 'btree/bool_ops',
+  opcintype => 'bool' },
+{ opcmethod => 'btree', opcname => 'bpchar_ops',
+  opcfamily => 'btree/bpchar_ops', opcintype => 'bpchar' },
+{ opcmethod => 'hash', opcname => 'bpchar_ops', opcfamily => 'hash/bpchar_ops',
+  opcintype => 'bpchar' },
+{ opcmethod => 'btree', opcname => 'bytea_ops', opcfamily => 'btree/bytea_ops',
+  opcintype => 'bytea' },
+{ opcmethod => 'btree', opcname => 'char_ops', opcfamily => 'btree/char_ops',
+  opcintype => 'char' },
+{ opcmethod => 'hash', opcname => 'char_ops', opcfamily => 'hash/char_ops',
+  opcintype => 'char' },
+{ opcmethod => 'btree', opcname => 'cidr_ops', opcfamily => 'btree/network_ops',
+  opcintype => 'inet', opcdefault => 'f' },
+{ opcmethod => 'hash', opcname => 'cidr_ops', opcfamily => 'hash/network_ops',
+  opcintype => 'inet', opcdefault => 'f' },
+{ oid => '3122', oid_symbol => 'DATE_BTREE_OPS_OID',
+  opcmethod => 'btree', opcname => 'date_ops',
+  opcfamily => 'btree/datetime_ops', opcintype => 'date' },
+{ opcmethod => 'hash', opcname => 'date_ops', opcfamily => 'hash/date_ops',
+  opcintype => 'date' },
+{ opcmethod => 'btree', opcname => 'float4_ops', opcfamily => 'btree/float_ops',
+  opcintype => 'float4' },
+{ opcmethod => 'hash', opcname => 'float4_ops', opcfamily => 'hash/float_ops',
+  opcintype => 'float4' },
+{ oid => '3123', oid_symbol => 'FLOAT8_BTREE_OPS_OID',
+  opcmethod => 'btree', opcname => 'float8_ops', opcfamily => 'btree/float_ops',
+  opcintype => 'float8' },
+{ opcmethod => 'hash', opcname => 'float8_ops', opcfamily => 'hash/float_ops',
+  opcintype => 'float8' },
+{ opcmethod => 'btree', opcname => 'inet_ops', opcfamily => 'btree/network_ops',
+  opcintype => 'inet' },
+{ opcmethod => 'hash', opcname => 'inet_ops', opcfamily => 'hash/network_ops',
+  opcintype => 'inet' },
+{ opcmethod => 'gist', opcname => 'inet_ops', opcfamily => 'gist/network_ops',
+  opcintype => 'inet', opcdefault => 'f' },
+{ opcmethod => 'spgist', opcname => 'inet_ops',
+  opcfamily => 'spgist/network_ops', opcintype => 'inet' },
+{ oid => '1979', oid_symbol => 'INT2_BTREE_OPS_OID',
+  opcmethod => 'btree', opcname => 'int2_ops', opcfamily => 'btree/integer_ops',
+  opcintype => 'int2' },
+{ opcmethod => 'hash', opcname => 'int2_ops', opcfamily => 'hash/integer_ops',
+  opcintype => 'int2' },
+{ oid => '1978', oid_symbol => 'INT4_BTREE_OPS_OID',
+  opcmethod => 'btree', opcname => 'int4_ops', opcfamily => 'btree/integer_ops',
+  opcintype => 'int4' },
+{ opcmethod => 'hash', opcname => 'int4_ops', opcfamily => 'hash/integer_ops',
+  opcintype => 'int4' },
+{ oid => '3124', oid_symbol => 'INT8_BTREE_OPS_OID',
+  opcmethod => 'btree', opcname => 'int8_ops', opcfamily => 'btree/integer_ops',
+  opcintype => 'int8' },
+{ opcmethod => 'hash', opcname => 'int8_ops', opcfamily => 'hash/integer_ops',
+  opcintype => 'int8' },
+{ opcmethod => 'btree', opcname => 'interval_ops',
+  opcfamily => 'btree/interval_ops', opcintype => 'interval' },
+{ opcmethod => 'hash', opcname => 'interval_ops',
+  opcfamily => 'hash/interval_ops', opcintype => 'interval' },
+{ opcmethod => 'btree', opcname => 'macaddr_ops',
+  opcfamily => 'btree/macaddr_ops', opcintype => 'macaddr' },
+{ opcmethod => 'hash', opcname => 'macaddr_ops',
+  opcfamily => 'hash/macaddr_ops', opcintype => 'macaddr' },
+{ opcmethod => 'btree', opcname => 'macaddr8_ops',
+  opcfamily => 'btree/macaddr8_ops', opcintype => 'macaddr8' },
+{ opcmethod => 'hash', opcname => 'macaddr8_ops',
+  opcfamily => 'hash/macaddr8_ops', opcintype => 'macaddr8' },
+
+# Here's an ugly little hack to save space in the system catalog indexes.
+# btree doesn't ordinarily allow a storage type different from input type;
+# but cstring and name are the same thing except for trailing padding,
+# and we can safely omit that within an index entry.  So we declare the
+# btree opclass for name as using cstring storage type.
+{ opcmethod => 'btree', opcname => 'name_ops', opcfamily => 'btree/text_ops',
+  opcintype => 'name', opckeytype => 'cstring' },
+
+{ opcmethod => 'hash', opcname => 'name_ops', opcfamily => 'hash/text_ops',
+  opcintype => 'name' },
+{ oid => '3125', oid_symbol => 'NUMERIC_BTREE_OPS_OID',
+  opcmethod => 'btree', opcname => 'numeric_ops',
+  opcfamily => 'btree/numeric_ops', opcintype => 'numeric' },
+{ opcmethod => 'hash', opcname => 'numeric_ops',
+  opcfamily => 'hash/numeric_ops', opcintype => 'numeric' },
+{ oid => '1981', oid_symbol => 'OID_BTREE_OPS_OID',
+  opcmethod => 'btree', opcname => 'oid_ops', opcfamily => 'btree/oid_ops',
+  opcintype => 'oid' },
+{ opcmethod => 'hash', opcname => 'oid_ops', opcfamily => 'hash/oid_ops',
+  opcintype => 'oid' },
+{ opcmethod => 'btree', opcname => 'oidvector_ops',
+  opcfamily => 'btree/oidvector_ops', opcintype => 'oidvector' },
+{ opcmethod => 'hash', opcname => 'oidvector_ops',
+  opcfamily => 'hash/oidvector_ops', opcintype => 'oidvector' },
+{ opcmethod => 'btree', opcname => 'record_ops',
+  opcfamily => 'btree/record_ops', opcintype => 'record' },
+{ opcmethod => 'btree', opcname => 'record_image_ops',
+  opcfamily => 'btree/record_image_ops', opcintype => 'record',
+  opcdefault => 'f' },
+{ oid => '3126', oid_symbol => 'TEXT_BTREE_OPS_OID',
+  opcmethod => 'btree', opcname => 'text_ops', opcfamily => 'btree/text_ops',
+  opcintype => 'text' },
+{ opcmethod => 'hash', opcname => 'text_ops', opcfamily => 'hash/text_ops',
+  opcintype => 'text' },
+{ opcmethod => 'btree', opcname => 'time_ops', opcfamily => 'btree/time_ops',
+  opcintype => 'time' },
+{ opcmethod => 'hash', opcname => 'time_ops', opcfamily => 'hash/time_ops',
+  opcintype => 'time' },
+{ oid => '3127', oid_symbol => 'TIMESTAMPTZ_BTREE_OPS_OID',
+  opcmethod => 'btree', opcname => 'timestamptz_ops',
+  opcfamily => 'btree/datetime_ops', opcintype => 'timestamptz' },
+{ opcmethod => 'hash', opcname => 'timestamptz_ops',
+  opcfamily => 'hash/timestamptz_ops', opcintype => 'timestamptz' },
+{ opcmethod => 'btree', opcname => 'timetz_ops',
+  opcfamily => 'btree/timetz_ops', opcintype => 'timetz' },
+{ opcmethod => 'hash', opcname => 'timetz_ops', opcfamily => 'hash/timetz_ops',
+  opcintype => 'timetz' },
+{ opcmethod => 'btree', opcname => 'varbit_ops',
+  opcfamily => 'btree/varbit_ops', opcintype => 'varbit' },
+{ opcmethod => 'btree', opcname => 'varchar_ops', opcfamily => 'btree/text_ops',
+  opcintype => 'text', opcdefault => 'f' },
+{ opcmethod => 'hash', opcname => 'varchar_ops', opcfamily => 'hash/text_ops',
+  opcintype => 'text', opcdefault => 'f' },
+{ oid => '3128', oid_symbol => 'TIMESTAMP_BTREE_OPS_OID',
+  opcmethod => 'btree', opcname => 'timestamp_ops',
+  opcfamily => 'btree/datetime_ops', opcintype => 'timestamp' },
+{ opcmethod => 'hash', opcname => 'timestamp_ops',
+  opcfamily => 'hash/timestamp_ops', opcintype => 'timestamp' },
+{ oid => '4217', oid_symbol => 'TEXT_BTREE_PATTERN_OPS_OID',
+  opcmethod => 'btree', opcname => 'text_pattern_ops',
+  opcfamily => 'btree/text_pattern_ops', opcintype => 'text',
+  opcdefault => 'f' },
+{ oid => '4218', oid_symbol => 'VARCHAR_BTREE_PATTERN_OPS_OID',
+  opcmethod => 'btree', opcname => 'varchar_pattern_ops',
+  opcfamily => 'btree/text_pattern_ops', opcintype => 'text',
+  opcdefault => 'f' },
+{ oid => '4219', oid_symbol => 'BPCHAR_BTREE_PATTERN_OPS_OID',
+  opcmethod => 'btree', opcname => 'bpchar_pattern_ops',
+  opcfamily => 'btree/bpchar_pattern_ops', opcintype => 'bpchar',
+  opcdefault => 'f' },
+{ opcmethod => 'btree', opcname => 'money_ops', opcfamily => 'btree/money_ops',
+  opcintype => 'money' },
+{ opcmethod => 'hash', opcname => 'bool_ops', opcfamily => 'hash/bool_ops',
+  opcintype => 'bool' },
+{ opcmethod => 'hash', opcname => 'bytea_ops', opcfamily => 'hash/bytea_ops',
+  opcintype => 'bytea' },
+{ opcmethod => 'btree', opcname => 'tid_ops', opcfamily => 'btree/tid_ops',
+  opcintype => 'tid' },
+{ opcmethod => 'hash', opcname => 'xid_ops', opcfamily => 'hash/xid_ops',
+  opcintype => 'xid' },
+{ opcmethod => 'hash', opcname => 'xid8_ops', opcfamily => 'hash/xid8_ops',
+  opcintype => 'xid8' },
+{ opcmethod => 'btree', opcname => 'xid8_ops', opcfamily => 'btree/xid8_ops',
+  opcintype => 'xid8' },
+{ opcmethod => 'hash', opcname => 'cid_ops', opcfamily => 'hash/cid_ops',
+  opcintype => 'cid' },
+{ opcmethod => 'hash', opcname => 'tid_ops', opcfamily => 'hash/tid_ops',
+  opcintype => 'tid' },
+{ opcmethod => 'hash', opcname => 'text_pattern_ops',
+  opcfamily => 'hash/text_pattern_ops', opcintype => 'text',
+  opcdefault => 'f' },
+{ opcmethod => 'hash', opcname => 'varchar_pattern_ops',
+  opcfamily => 'hash/text_pattern_ops', opcintype => 'text',
+  opcdefault => 'f' },
+{ opcmethod => 'hash', opcname => 'bpchar_pattern_ops',
+  opcfamily => 'hash/bpchar_pattern_ops', opcintype => 'bpchar',
+  opcdefault => 'f' },
+{ opcmethod => 'hash', opcname => 'aclitem_ops',
+  opcfamily => 'hash/aclitem_ops', opcintype => 'aclitem' },
+{ opcmethod => 'gist', opcname => 'box_ops', opcfamily => 'gist/box_ops',
+  opcintype => 'box' },
+{ opcmethod => 'gist', opcname => 'point_ops', opcfamily => 'gist/point_ops',
+  opcintype => 'point', opckeytype => 'box' },
+{ opcmethod => 'gist', opcname => 'poly_ops', opcfamily => 'gist/poly_ops',
+  opcintype => 'polygon', opckeytype => 'box' },
+{ opcmethod => 'gist', opcname => 'circle_ops', opcfamily => 'gist/circle_ops',
+  opcintype => 'circle', opckeytype => 'box' },
+{ opcmethod => 'gin', opcname => 'array_ops', opcfamily => 'gin/array_ops',
+  opcintype => 'anyarray', opckeytype => 'anyelement' },
+{ opcmethod => 'btree', opcname => 'uuid_ops', opcfamily => 'btree/uuid_ops',
+  opcintype => 'uuid' },
+{ opcmethod => 'hash', opcname => 'uuid_ops', opcfamily => 'hash/uuid_ops',
+  opcintype => 'uuid' },
+{ opcmethod => 'btree', opcname => 'pg_lsn_ops',
+  opcfamily => 'btree/pg_lsn_ops', opcintype => 'pg_lsn' },
+{ opcmethod => 'hash', opcname => 'pg_lsn_ops', opcfamily => 'hash/pg_lsn_ops',
+  opcintype => 'pg_lsn' },
+{ opcmethod => 'btree', opcname => 'enum_ops', opcfamily => 'btree/enum_ops',
+  opcintype => 'anyenum' },
+{ opcmethod => 'hash', opcname => 'enum_ops', opcfamily => 'hash/enum_ops',
+  opcintype => 'anyenum' },
+{ opcmethod => 'btree', opcname => 'tsvector_ops',
+  opcfamily => 'btree/tsvector_ops', opcintype => 'tsvector' },
+{ opcmethod => 'gist', opcname => 'tsvector_ops',
+  opcfamily => 'gist/tsvector_ops', opcintype => 'tsvector',
+  opckeytype => 'gtsvector' },
+{ opcmethod => 'gin', opcname => 'tsvector_ops',
+  opcfamily => 'gin/tsvector_ops', opcintype => 'tsvector',
+  opckeytype => 'text' },
+{ opcmethod => 'btree', opcname => 'tsquery_ops',
+  opcfamily => 'btree/tsquery_ops', opcintype => 'tsquery' },
+{ opcmethod => 'gist', opcname => 'tsquery_ops',
+  opcfamily => 'gist/tsquery_ops', opcintype => 'tsquery',
+  opckeytype => 'int8' },
+{ opcmethod => 'btree', opcname => 'range_ops', opcfamily => 'btree/range_ops',
+  opcintype => 'anyrange' },
+{ opcmethod => 'hash', opcname => 'range_ops', opcfamily => 'hash/range_ops',
+  opcintype => 'anyrange' },
+{ opcmethod => 'gist', opcname => 'range_ops', opcfamily => 'gist/range_ops',
+  opcintype => 'anyrange' },
+{ opcmethod => 'spgist', opcname => 'range_ops',
+  opcfamily => 'spgist/range_ops', opcintype => 'anyrange' },
+{ opcmethod => 'spgist', opcname => 'box_ops', opcfamily => 'spgist/box_ops',
+  opcintype => 'box' },
+{ opcmethod => 'spgist', opcname => 'quad_point_ops',
+  opcfamily => 'spgist/quad_point_ops', opcintype => 'point' },
+{ opcmethod => 'spgist', opcname => 'kd_point_ops',
+  opcfamily => 'spgist/kd_point_ops', opcintype => 'point', opcdefault => 'f' },
+{ opcmethod => 'spgist', opcname => 'text_ops', opcfamily => 'spgist/text_ops',
+  opcintype => 'text' },
+{ opcmethod => 'spgist', opcname => 'poly_ops', opcfamily => 'spgist/poly_ops',
+  opcintype => 'polygon', opckeytype => 'box' },
+{ opcmethod => 'btree', opcname => 'jsonb_ops', opcfamily => 'btree/jsonb_ops',
+  opcintype => 'jsonb' },
+{ opcmethod => 'hash', opcname => 'jsonb_ops', opcfamily => 'hash/jsonb_ops',
+  opcintype => 'jsonb' },
+{ opcmethod => 'gin', opcname => 'jsonb_ops', opcfamily => 'gin/jsonb_ops',
+  opcintype => 'jsonb', opckeytype => 'text' },
+{ opcmethod => 'gin', opcname => 'jsonb_path_ops',
+  opcfamily => 'gin/jsonb_path_ops', opcintype => 'jsonb', opcdefault => 'f',
+  opckeytype => 'int4' },
+
+# BRIN operator classes
+
+# no brin opclass for bool
+
+{ opcmethod => 'brin', opcname => 'bytea_minmax_ops',
+  opcfamily => 'brin/bytea_minmax_ops', opcintype => 'bytea',
+  opckeytype => 'bytea' },
+{ opcmethod => 'brin', opcname => 'char_minmax_ops',
+  opcfamily => 'brin/char_minmax_ops', opcintype => 'char',
+  opckeytype => 'char' },
+{ opcmethod => 'brin', opcname => 'name_minmax_ops',
+  opcfamily => 'brin/name_minmax_ops', opcintype => 'name',
+  opckeytype => 'name' },
+{ opcmethod => 'brin', opcname => 'int8_minmax_ops',
+  opcfamily => 'brin/integer_minmax_ops', opcintype => 'int8',
+  opckeytype => 'int8' },
+{ opcmethod => 'brin', opcname => 'int2_minmax_ops',
+  opcfamily => 'brin/integer_minmax_ops', opcintype => 'int2',
+  opckeytype => 'int2' },
+{ opcmethod => 'brin', opcname => 'int4_minmax_ops',
+  opcfamily => 'brin/integer_minmax_ops', opcintype => 'int4',
+  opckeytype => 'int4' },
+{ opcmethod => 'brin', opcname => 'text_minmax_ops',
+  opcfamily => 'brin/text_minmax_ops', opcintype => 'text',
+  opckeytype => 'text' },
+{ opcmethod => 'brin', opcname => 'oid_minmax_ops',
+  opcfamily => 'brin/oid_minmax_ops', opcintype => 'oid', opckeytype => 'oid' },
+{ opcmethod => 'brin', opcname => 'tid_minmax_ops',
+  opcfamily => 'brin/tid_minmax_ops', opcintype => 'tid', opckeytype => 'tid' },
+{ opcmethod => 'brin', opcname => 'float4_minmax_ops',
+  opcfamily => 'brin/float_minmax_ops', opcintype => 'float4',
+  opckeytype => 'float4' },
+{ opcmethod => 'brin', opcname => 'float8_minmax_ops',
+  opcfamily => 'brin/float_minmax_ops', opcintype => 'float8',
+  opckeytype => 'float8' },
+{ opcmethod => 'brin', opcname => 'macaddr_minmax_ops',
+  opcfamily => 'brin/macaddr_minmax_ops', opcintype => 'macaddr',
+  opckeytype => 'macaddr' },
+{ opcmethod => 'brin', opcname => 'macaddr8_minmax_ops',
+  opcfamily => 'brin/macaddr8_minmax_ops', opcintype => 'macaddr8',
+  opckeytype => 'macaddr8' },
+{ opcmethod => 'brin', opcname => 'inet_minmax_ops',
+  opcfamily => 'brin/network_minmax_ops', opcintype => 'inet',
+  opcdefault => 'f', opckeytype => 'inet' },
+{ opcmethod => 'brin', opcname => 'inet_inclusion_ops',
+  opcfamily => 'brin/network_inclusion_ops', opcintype => 'inet',
+  opckeytype => 'inet' },
+{ opcmethod => 'brin', opcname => 'bpchar_minmax_ops',
+  opcfamily => 'brin/bpchar_minmax_ops', opcintype => 'bpchar',
+  opckeytype => 'bpchar' },
+{ opcmethod => 'brin', opcname => 'time_minmax_ops',
+  opcfamily => 'brin/time_minmax_ops', opcintype => 'time',
+  opckeytype => 'time' },
+{ opcmethod => 'brin', opcname => 'date_minmax_ops',
+  opcfamily => 'brin/datetime_minmax_ops', opcintype => 'date',
+  opckeytype => 'date' },
+{ opcmethod => 'brin', opcname => 'timestamp_minmax_ops',
+  opcfamily => 'brin/datetime_minmax_ops', opcintype => 'timestamp',
+  opckeytype => 'timestamp' },
+{ opcmethod => 'brin', opcname => 'timestamptz_minmax_ops',
+  opcfamily => 'brin/datetime_minmax_ops', opcintype => 'timestamptz',
+  opckeytype => 'timestamptz' },
+{ opcmethod => 'brin', opcname => 'interval_minmax_ops',
+  opcfamily => 'brin/interval_minmax_ops', opcintype => 'interval',
+  opckeytype => 'interval' },
+{ opcmethod => 'brin', opcname => 'timetz_minmax_ops',
+  opcfamily => 'brin/timetz_minmax_ops', opcintype => 'timetz',
+  opckeytype => 'timetz' },
+{ opcmethod => 'brin', opcname => 'bit_minmax_ops',
+  opcfamily => 'brin/bit_minmax_ops', opcintype => 'bit', opckeytype => 'bit' },
+{ opcmethod => 'brin', opcname => 'varbit_minmax_ops',
+  opcfamily => 'brin/varbit_minmax_ops', opcintype => 'varbit',
+  opckeytype => 'varbit' },
+{ opcmethod => 'brin', opcname => 'numeric_minmax_ops',
+  opcfamily => 'brin/numeric_minmax_ops', opcintype => 'numeric',
+  opckeytype => 'numeric' },
+
+# no brin opclass for record, anyarray
+
+{ opcmethod => 'brin', opcname => 'uuid_minmax_ops',
+  opcfamily => 'brin/uuid_minmax_ops', opcintype => 'uuid',
+  opckeytype => 'uuid' },
+{ opcmethod => 'brin', opcname => 'range_inclusion_ops',
+  opcfamily => 'brin/range_inclusion_ops', opcintype => 'anyrange',
+  opckeytype => 'anyrange' },
+{ opcmethod => 'brin', opcname => 'pg_lsn_minmax_ops',
+  opcfamily => 'brin/pg_lsn_minmax_ops', opcintype => 'pg_lsn',
+  opckeytype => 'pg_lsn' },
+
+# no brin opclass for enum, tsvector, tsquery, jsonb
+
+{ opcmethod => 'brin', opcname => 'box_inclusion_ops',
+  opcfamily => 'brin/box_inclusion_ops', opcintype => 'box',
+  opckeytype => 'box' },
+
+# no brin opclass for the geometric types except box
+
+]
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_opclass.h b/contrib/libs/postgresql/src/include/catalog/pg_opclass.h
new file mode 100644
index 0000000000..963ab3eae8
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_opclass.h
@@ -0,0 +1,85 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_opclass.h
+ *	  definition of the "operator class" system catalog (pg_opclass)
+ *
+ * The primary key for this table is <opcmethod, opcname, opcnamespace> ---
+ * that is, there is a row for each valid combination of opclass name and
+ * index access method type.  This row specifies the expected input data type
+ * for the opclass (the type of the heap column, or the expression output type
+ * in the case of an index expression).  Note that types binary-coercible to
+ * the specified type will be accepted too.
+ *
+ * For a given <opcmethod, opcintype> pair, there can be at most one row that
+ * has opcdefault = true; this row is the default opclass for such data in
+ * such an index.  (This is not currently enforced by an index, because we
+ * don't support partial indexes on system catalogs.)
+ *
+ * Normally opckeytype = InvalidOid (zero), indicating that the data stored
+ * in the index is the same as the data in the indexed column.  If opckeytype
+ * is nonzero then it indicates that a conversion step is needed to produce
+ * the stored index data, which will be of type opckeytype (which might be
+ * the same or different from the input datatype).  Performing such a
+ * conversion is the responsibility of the index access method --- not all
+ * AMs support this.
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_opclass.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_OPCLASS_H
+#define PG_OPCLASS_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_opclass_d.h"
+
+/* ----------------
+ *		pg_opclass definition.  cpp turns this into
+ *		typedef struct FormData_pg_opclass
+ * ----------------
+ */
+CATALOG(pg_opclass,2616,OperatorClassRelationId)
+{
+	Oid			oid;			/* oid */
+
+	/* index access method opclass is for */
+	Oid			opcmethod BKI_LOOKUP(pg_am);
+
+	/* name of this opclass */
+	NameData	opcname;
+
+	/* namespace of this opclass */
+	Oid			opcnamespace BKI_DEFAULT(PGNSP);
+
+	/* opclass owner */
+	Oid			opcowner BKI_DEFAULT(PGUID);
+
+	/* containing operator family */
+	Oid			opcfamily BKI_LOOKUP(pg_opfamily);
+
+	/* type of data indexed by opclass */
+	Oid			opcintype BKI_LOOKUP(pg_type);
+
+	/* T if opclass is default for opcintype */
+	bool		opcdefault BKI_DEFAULT(t);
+
+	/* type of data in index, or InvalidOid */
+	Oid			opckeytype BKI_DEFAULT(0) BKI_LOOKUP(pg_type);
+} FormData_pg_opclass;
+
+/* ----------------
+ *		Form_pg_opclass corresponds to a pointer to a tuple with
+ *		the format of pg_opclass relation.
+ * ----------------
+ */
+typedef FormData_pg_opclass *Form_pg_opclass;
+
+#endif							/* PG_OPCLASS_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_opclass_d.h b/contrib/libs/postgresql/src/include/catalog/pg_opclass_d.h
new file mode 100644
index 0000000000..113547a25a
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_opclass_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_opclass_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_operator.dat b/contrib/libs/postgresql/src/include/catalog/pg_operator.dat
new file mode 100644
index 0000000000..3b3eb955d4
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_operator.dat
@@ -0,0 +1,3331 @@
+#----------------------------------------------------------------------
+#
+# pg_operator.dat
+#    Initial contents of the pg_operator system catalog.
+#
+# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+# Portions Copyright (c) 1994, Regents of the University of California
+#
+# src/include/catalog/pg_operator.dat
+#
+#----------------------------------------------------------------------
+
+[
+
+# Note: every entry in pg_operator.dat is expected to have a 'descr' comment.
+# If the operator is a deprecated equivalent of some other entry, be sure
+# to comment it as such so that initdb doesn't think it's a preferred name
+# for the underlying function.
+
+{ oid => '15', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprcanhash => 't', oprleft => 'int4',
+  oprright => 'int8', oprresult => 'bool', oprcom => '=(int8,int4)',
+  oprnegate => '<>(int4,int8)', oprcode => 'int48eq', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+{ oid => '36', descr => 'not equal',
+  oprname => '<>', oprleft => 'int4', oprright => 'int8', oprresult => 'bool',
+  oprcom => '<>(int8,int4)', oprnegate => '=(int4,int8)', oprcode => 'int48ne',
+  oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+{ oid => '37', descr => 'less than',
+  oprname => '<', oprleft => 'int4', oprright => 'int8', oprresult => 'bool',
+  oprcom => '>(int8,int4)', oprnegate => '>=(int4,int8)', oprcode => 'int48lt',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '76', descr => 'greater than',
+  oprname => '>', oprleft => 'int4', oprright => 'int8', oprresult => 'bool',
+  oprcom => '<(int8,int4)', oprnegate => '<=(int4,int8)', oprcode => 'int48gt',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '80', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'int4', oprright => 'int8', oprresult => 'bool',
+  oprcom => '>=(int8,int4)', oprnegate => '>(int4,int8)', oprcode => 'int48le',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '82', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'int4', oprright => 'int8', oprresult => 'bool',
+  oprcom => '<=(int8,int4)', oprnegate => '<(int4,int8)', oprcode => 'int48ge',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+
+{ oid => '58', descr => 'less than',
+  oprname => '<', oprleft => 'bool', oprright => 'bool', oprresult => 'bool',
+  oprcom => '>(bool,bool)', oprnegate => '>=(bool,bool)', oprcode => 'boollt',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '59', descr => 'greater than',
+  oprname => '>', oprleft => 'bool', oprright => 'bool', oprresult => 'bool',
+  oprcom => '<(bool,bool)', oprnegate => '<=(bool,bool)', oprcode => 'boolgt',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '85', oid_symbol => 'BooleanNotEqualOperator', descr => 'not equal',
+  oprname => '<>', oprleft => 'bool', oprright => 'bool', oprresult => 'bool',
+  oprcom => '<>(bool,bool)', oprnegate => '=(bool,bool)', oprcode => 'boolne',
+  oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+{ oid => '91', oid_symbol => 'BooleanEqualOperator', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprcanhash => 't', oprleft => 'bool',
+  oprright => 'bool', oprresult => 'bool', oprcom => '=(bool,bool)',
+  oprnegate => '<>(bool,bool)', oprcode => 'booleq', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+{ oid => '1694', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'bool', oprright => 'bool', oprresult => 'bool',
+  oprcom => '>=(bool,bool)', oprnegate => '>(bool,bool)', oprcode => 'boolle',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '1695', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'bool', oprright => 'bool', oprresult => 'bool',
+  oprcom => '<=(bool,bool)', oprnegate => '<(bool,bool)', oprcode => 'boolge',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+
+{ oid => '92', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprcanhash => 't', oprleft => 'char',
+  oprright => 'char', oprresult => 'bool', oprcom => '=(char,char)',
+  oprnegate => '<>(char,char)', oprcode => 'chareq', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+{ oid => '93', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprcanhash => 't', oprleft => 'name',
+  oprright => 'name', oprresult => 'bool', oprcom => '=(name,name)',
+  oprnegate => '<>(name,name)', oprcode => 'nameeq', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+{ oid => '94', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprcanhash => 't', oprleft => 'int2',
+  oprright => 'int2', oprresult => 'bool', oprcom => '=(int2,int2)',
+  oprnegate => '<>(int2,int2)', oprcode => 'int2eq', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+{ oid => '95', descr => 'less than',
+  oprname => '<', oprleft => 'int2', oprright => 'int2', oprresult => 'bool',
+  oprcom => '>(int2,int2)', oprnegate => '>=(int2,int2)', oprcode => 'int2lt',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '96', oid_symbol => 'Int4EqualOperator', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprcanhash => 't', oprleft => 'int4',
+  oprright => 'int4', oprresult => 'bool', oprcom => '=(int4,int4)',
+  oprnegate => '<>(int4,int4)', oprcode => 'int4eq', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+{ oid => '97', oid_symbol => 'Int4LessOperator', descr => 'less than',
+  oprname => '<', oprleft => 'int4', oprright => 'int4', oprresult => 'bool',
+  oprcom => '>(int4,int4)', oprnegate => '>=(int4,int4)', oprcode => 'int4lt',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '98', oid_symbol => 'TextEqualOperator', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprcanhash => 't', oprleft => 'text',
+  oprright => 'text', oprresult => 'bool', oprcom => '=(text,text)',
+  oprnegate => '<>(text,text)', oprcode => 'texteq', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+{ oid => '3877', descr => 'starts with',
+  oprname => '^@', oprleft => 'text', oprright => 'text', oprresult => 'bool',
+  oprcode => 'starts_with', oprrest => 'prefixsel',
+  oprjoin => 'prefixjoinsel' },
+
+{ oid => '254', oid_symbol => 'NameEqualTextOperator', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprcanhash => 't', oprleft => 'name',
+  oprright => 'text', oprresult => 'bool', oprcom => '=(text,name)',
+  oprnegate => '<>(name,text)', oprcode => 'nameeqtext', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+{ oid => '255', oid_symbol => 'NameLessTextOperator', descr => 'less than',
+  oprname => '<', oprleft => 'name', oprright => 'text', oprresult => 'bool',
+  oprcom => '>(text,name)', oprnegate => '>=(name,text)',
+  oprcode => 'namelttext', oprrest => 'scalarltsel',
+  oprjoin => 'scalarltjoinsel' },
+{ oid => '256', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'name', oprright => 'text', oprresult => 'bool',
+  oprcom => '>=(text,name)', oprnegate => '>(name,text)',
+  oprcode => 'nameletext', oprrest => 'scalarlesel',
+  oprjoin => 'scalarlejoinsel' },
+{ oid => '257', oid_symbol => 'NameGreaterEqualTextOperator',
+  descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'name', oprright => 'text', oprresult => 'bool',
+  oprcom => '<=(text,name)', oprnegate => '<(name,text)',
+  oprcode => 'namegetext', oprrest => 'scalargesel',
+  oprjoin => 'scalargejoinsel' },
+{ oid => '258', descr => 'greater than',
+  oprname => '>', oprleft => 'name', oprright => 'text', oprresult => 'bool',
+  oprcom => '<(text,name)', oprnegate => '<=(name,text)',
+  oprcode => 'namegttext', oprrest => 'scalargtsel',
+  oprjoin => 'scalargtjoinsel' },
+{ oid => '259', descr => 'not equal',
+  oprname => '<>', oprleft => 'name', oprright => 'text', oprresult => 'bool',
+  oprcom => '<>(text,name)', oprnegate => '=(name,text)',
+  oprcode => 'namenetext', oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+{ oid => '260', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprcanhash => 't', oprleft => 'text',
+  oprright => 'name', oprresult => 'bool', oprcom => '=(name,text)',
+  oprnegate => '<>(text,name)', oprcode => 'texteqname', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+{ oid => '261', descr => 'less than',
+  oprname => '<', oprleft => 'text', oprright => 'name', oprresult => 'bool',
+  oprcom => '>(name,text)', oprnegate => '>=(text,name)',
+  oprcode => 'textltname', oprrest => 'scalarltsel',
+  oprjoin => 'scalarltjoinsel' },
+{ oid => '262', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'text', oprright => 'name', oprresult => 'bool',
+  oprcom => '>=(name,text)', oprnegate => '>(text,name)',
+  oprcode => 'textlename', oprrest => 'scalarlesel',
+  oprjoin => 'scalarlejoinsel' },
+{ oid => '263', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'text', oprright => 'name', oprresult => 'bool',
+  oprcom => '<=(name,text)', oprnegate => '<(text,name)',
+  oprcode => 'textgename', oprrest => 'scalargesel',
+  oprjoin => 'scalargejoinsel' },
+{ oid => '264', descr => 'greater than',
+  oprname => '>', oprleft => 'text', oprright => 'name', oprresult => 'bool',
+  oprcom => '<(name,text)', oprnegate => '<=(text,name)',
+  oprcode => 'textgtname', oprrest => 'scalargtsel',
+  oprjoin => 'scalargtjoinsel' },
+{ oid => '265', descr => 'not equal',
+  oprname => '<>', oprleft => 'text', oprright => 'name', oprresult => 'bool',
+  oprcom => '<>(name,text)', oprnegate => '=(text,name)',
+  oprcode => 'textnename', oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+
+{ oid => '349', descr => 'append element onto end of array',
+  oprname => '||', oprleft => 'anyarray', oprright => 'anyelement',
+  oprresult => 'anyarray', oprcode => 'array_append' },
+{ oid => '374', descr => 'prepend element onto front of array',
+  oprname => '||', oprleft => 'anyelement', oprright => 'anyarray',
+  oprresult => 'anyarray', oprcode => 'array_prepend' },
+{ oid => '375', descr => 'concatenate',
+  oprname => '||', oprleft => 'anyarray', oprright => 'anyarray',
+  oprresult => 'anyarray', oprcode => 'array_cat' },
+
+{ oid => '352', descr => 'equal',
+  oprname => '=', oprcanhash => 't', oprleft => 'xid', oprright => 'xid',
+  oprresult => 'bool', oprcom => '=(xid,xid)', oprnegate => '<>(xid,xid)',
+  oprcode => 'xideq', oprrest => 'eqsel', oprjoin => 'eqjoinsel' },
+{ oid => '353', descr => 'equal',
+  oprname => '=', oprleft => 'xid', oprright => 'int4', oprresult => 'bool',
+  oprnegate => '<>(xid,int4)', oprcode => 'xideqint4', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+{ oid => '3315', descr => 'not equal',
+  oprname => '<>', oprleft => 'xid', oprright => 'xid', oprresult => 'bool',
+  oprcom => '<>(xid,xid)', oprnegate => '=(xid,xid)', oprcode => 'xidneq',
+  oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+{ oid => '3316', descr => 'not equal',
+  oprname => '<>', oprleft => 'xid', oprright => 'int4', oprresult => 'bool',
+  oprnegate => '=(xid,int4)', oprcode => 'xidneqint4', oprrest => 'neqsel',
+  oprjoin => 'neqjoinsel' },
+{ oid => '5068', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprcanhash => 't', oprleft => 'xid8',
+  oprright => 'xid8', oprresult => 'bool', oprcom => '=(xid8,xid8)',
+  oprnegate => '<>(xid8,xid8)', oprcode => 'xid8eq', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+{ oid => '5072', descr => 'not equal',
+  oprname => '<>', oprleft => 'xid8', oprright => 'xid8', oprresult => 'bool',
+  oprcom => '<>(xid8,xid8)', oprnegate => '=(xid8,xid8)', oprcode => 'xid8ne',
+  oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+{ oid => '5073', descr => 'less than',
+  oprname => '<', oprleft => 'xid8', oprright => 'xid8', oprresult => 'bool',
+  oprcom => '>(xid8,xid8)', oprnegate => '>=(xid8,xid8)', oprcode => 'xid8lt',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '5074', descr => 'greater than',
+  oprname => '>', oprleft => 'xid8', oprright => 'xid8', oprresult => 'bool',
+  oprcom => '<(xid8,xid8)', oprnegate => '<=(xid8,xid8)', oprcode => 'xid8gt',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '5075', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'xid8', oprright => 'xid8', oprresult => 'bool',
+  oprcom => '>=(xid8,xid8)', oprnegate => '>(xid8,xid8)', oprcode => 'xid8le',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '5076', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'xid8', oprright => 'xid8', oprresult => 'bool',
+  oprcom => '<=(xid8,xid8)', oprnegate => '<(xid8,xid8)', oprcode => 'xid8ge',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+{ oid => '388', descr => 'deprecated, use factorial() instead',
+  oprname => '!', oprkind => 'r', oprleft => 'int8', oprright => '0',
+  oprresult => 'numeric', oprcode => 'numeric_fac' },
+{ oid => '389', descr => 'deprecated, use factorial() instead',
+  oprname => '!!', oprkind => 'l', oprleft => '0', oprright => 'int8',
+  oprresult => 'numeric', oprcode => 'numeric_fac' },
+{ oid => '385', descr => 'equal',
+  oprname => '=', oprcanhash => 't', oprleft => 'cid', oprright => 'cid',
+  oprresult => 'bool', oprcom => '=(cid,cid)', oprcode => 'cideq',
+  oprrest => 'eqsel', oprjoin => 'eqjoinsel' },
+
+{ oid => '387', oid_symbol => 'TIDEqualOperator', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprcanhash => 't', oprleft => 'tid',
+  oprright => 'tid', oprresult => 'bool', oprcom => '=(tid,tid)',
+  oprnegate => '<>(tid,tid)', oprcode => 'tideq', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+{ oid => '402', descr => 'not equal',
+  oprname => '<>', oprleft => 'tid', oprright => 'tid', oprresult => 'bool',
+  oprcom => '<>(tid,tid)', oprnegate => '=(tid,tid)', oprcode => 'tidne',
+  oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+{ oid => '2799', oid_symbol => 'TIDLessOperator', descr => 'less than',
+  oprname => '<', oprleft => 'tid', oprright => 'tid', oprresult => 'bool',
+  oprcom => '>(tid,tid)', oprnegate => '>=(tid,tid)', oprcode => 'tidlt',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '2800', descr => 'greater than',
+  oprname => '>', oprleft => 'tid', oprright => 'tid', oprresult => 'bool',
+  oprcom => '<(tid,tid)', oprnegate => '<=(tid,tid)', oprcode => 'tidgt',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '2801', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'tid', oprright => 'tid', oprresult => 'bool',
+  oprcom => '>=(tid,tid)', oprnegate => '>(tid,tid)', oprcode => 'tidle',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '2802', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'tid', oprright => 'tid', oprresult => 'bool',
+  oprcom => '<=(tid,tid)', oprnegate => '<(tid,tid)', oprcode => 'tidge',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+
+{ oid => '410', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprcanhash => 't', oprleft => 'int8',
+  oprright => 'int8', oprresult => 'bool', oprcom => '=(int8,int8)',
+  oprnegate => '<>(int8,int8)', oprcode => 'int8eq', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+{ oid => '411', descr => 'not equal',
+  oprname => '<>', oprleft => 'int8', oprright => 'int8', oprresult => 'bool',
+  oprcom => '<>(int8,int8)', oprnegate => '=(int8,int8)', oprcode => 'int8ne',
+  oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+{ oid => '412', oid_symbol => 'Int8LessOperator', descr => 'less than',
+  oprname => '<', oprleft => 'int8', oprright => 'int8', oprresult => 'bool',
+  oprcom => '>(int8,int8)', oprnegate => '>=(int8,int8)', oprcode => 'int8lt',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '413', descr => 'greater than',
+  oprname => '>', oprleft => 'int8', oprright => 'int8', oprresult => 'bool',
+  oprcom => '<(int8,int8)', oprnegate => '<=(int8,int8)', oprcode => 'int8gt',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '414', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'int8', oprright => 'int8', oprresult => 'bool',
+  oprcom => '>=(int8,int8)', oprnegate => '>(int8,int8)', oprcode => 'int8le',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '415', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'int8', oprright => 'int8', oprresult => 'bool',
+  oprcom => '<=(int8,int8)', oprnegate => '<(int8,int8)', oprcode => 'int8ge',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+
+{ oid => '416', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprcanhash => 't', oprleft => 'int8',
+  oprright => 'int4', oprresult => 'bool', oprcom => '=(int4,int8)',
+  oprnegate => '<>(int8,int4)', oprcode => 'int84eq', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+{ oid => '417', descr => 'not equal',
+  oprname => '<>', oprleft => 'int8', oprright => 'int4', oprresult => 'bool',
+  oprcom => '<>(int4,int8)', oprnegate => '=(int8,int4)', oprcode => 'int84ne',
+  oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+{ oid => '418', descr => 'less than',
+  oprname => '<', oprleft => 'int8', oprright => 'int4', oprresult => 'bool',
+  oprcom => '>(int4,int8)', oprnegate => '>=(int8,int4)', oprcode => 'int84lt',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '419', descr => 'greater than',
+  oprname => '>', oprleft => 'int8', oprright => 'int4', oprresult => 'bool',
+  oprcom => '<(int4,int8)', oprnegate => '<=(int8,int4)', oprcode => 'int84gt',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '420', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'int8', oprright => 'int4', oprresult => 'bool',
+  oprcom => '>=(int4,int8)', oprnegate => '>(int8,int4)', oprcode => 'int84le',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '430', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'int8', oprright => 'int4', oprresult => 'bool',
+  oprcom => '<=(int4,int8)', oprnegate => '<(int8,int4)', oprcode => 'int84ge',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+{ oid => '439', descr => 'modulus',
+  oprname => '%', oprleft => 'int8', oprright => 'int8', oprresult => 'int8',
+  oprcode => 'int8mod' },
+{ oid => '473', descr => 'absolute value',
+  oprname => '@', oprkind => 'l', oprleft => '0', oprright => 'int8',
+  oprresult => 'int8', oprcode => 'int8abs' },
+
+{ oid => '484', descr => 'negate',
+  oprname => '-', oprkind => 'l', oprleft => '0', oprright => 'int8',
+  oprresult => 'int8', oprcode => 'int8um' },
+{ oid => '485', descr => 'is left of',
+  oprname => '<<', oprleft => 'polygon', oprright => 'polygon',
+  oprresult => 'bool', oprcode => 'poly_left', oprrest => 'positionsel',
+  oprjoin => 'positionjoinsel' },
+{ oid => '486', descr => 'overlaps or is left of',
+  oprname => '&<', oprleft => 'polygon', oprright => 'polygon',
+  oprresult => 'bool', oprcode => 'poly_overleft', oprrest => 'positionsel',
+  oprjoin => 'positionjoinsel' },
+{ oid => '487', descr => 'overlaps or is right of',
+  oprname => '&>', oprleft => 'polygon', oprright => 'polygon',
+  oprresult => 'bool', oprcode => 'poly_overright', oprrest => 'positionsel',
+  oprjoin => 'positionjoinsel' },
+{ oid => '488', descr => 'is right of',
+  oprname => '>>', oprleft => 'polygon', oprright => 'polygon',
+  oprresult => 'bool', oprcode => 'poly_right', oprrest => 'positionsel',
+  oprjoin => 'positionjoinsel' },
+{ oid => '489', descr => 'is contained by',
+  oprname => '<@', oprleft => 'polygon', oprright => 'polygon',
+  oprresult => 'bool', oprcom => '@>(polygon,polygon)',
+  oprcode => 'poly_contained', oprrest => 'contsel', oprjoin => 'contjoinsel' },
+{ oid => '490', descr => 'contains',
+  oprname => '@>', oprleft => 'polygon', oprright => 'polygon',
+  oprresult => 'bool', oprcom => '<@(polygon,polygon)',
+  oprcode => 'poly_contain', oprrest => 'contsel', oprjoin => 'contjoinsel' },
+{ oid => '491', descr => 'same as',
+  oprname => '~=', oprleft => 'polygon', oprright => 'polygon',
+  oprresult => 'bool', oprcom => '~=(polygon,polygon)', oprcode => 'poly_same',
+  oprrest => 'eqsel', oprjoin => 'eqjoinsel' },
+{ oid => '492', descr => 'overlaps',
+  oprname => '&&', oprleft => 'polygon', oprright => 'polygon',
+  oprresult => 'bool', oprcom => '&&(polygon,polygon)',
+  oprcode => 'poly_overlap', oprrest => 'areasel', oprjoin => 'areajoinsel' },
+{ oid => '493', descr => 'is left of',
+  oprname => '<<', oprleft => 'box', oprright => 'box', oprresult => 'bool',
+  oprcode => 'box_left', oprrest => 'positionsel',
+  oprjoin => 'positionjoinsel' },
+{ oid => '494', descr => 'overlaps or is left of',
+  oprname => '&<', oprleft => 'box', oprright => 'box', oprresult => 'bool',
+  oprcode => 'box_overleft', oprrest => 'positionsel',
+  oprjoin => 'positionjoinsel' },
+{ oid => '495', descr => 'overlaps or is right of',
+  oprname => '&>', oprleft => 'box', oprright => 'box', oprresult => 'bool',
+  oprcode => 'box_overright', oprrest => 'positionsel',
+  oprjoin => 'positionjoinsel' },
+{ oid => '496', descr => 'is right of',
+  oprname => '>>', oprleft => 'box', oprright => 'box', oprresult => 'bool',
+  oprcode => 'box_right', oprrest => 'positionsel',
+  oprjoin => 'positionjoinsel' },
+{ oid => '497', descr => 'is contained by',
+  oprname => '<@', oprleft => 'box', oprright => 'box', oprresult => 'bool',
+  oprcom => '@>(box,box)', oprcode => 'box_contained', oprrest => 'contsel',
+  oprjoin => 'contjoinsel' },
+{ oid => '498', descr => 'contains',
+  oprname => '@>', oprleft => 'box', oprright => 'box', oprresult => 'bool',
+  oprcom => '<@(box,box)', oprcode => 'box_contain', oprrest => 'contsel',
+  oprjoin => 'contjoinsel' },
+{ oid => '499', descr => 'same as',
+  oprname => '~=', oprleft => 'box', oprright => 'box', oprresult => 'bool',
+  oprcom => '~=(box,box)', oprcode => 'box_same', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+{ oid => '500', descr => 'overlaps',
+  oprname => '&&', oprleft => 'box', oprright => 'box', oprresult => 'bool',
+  oprcom => '&&(box,box)', oprcode => 'box_overlap', oprrest => 'areasel',
+  oprjoin => 'areajoinsel' },
+{ oid => '501', descr => 'greater than or equal by area',
+  oprname => '>=', oprleft => 'box', oprright => 'box', oprresult => 'bool',
+  oprcom => '<=(box,box)', oprnegate => '<(box,box)', oprcode => 'box_ge',
+  oprrest => 'areasel', oprjoin => 'areajoinsel' },
+{ oid => '502', descr => 'greater than by area',
+  oprname => '>', oprleft => 'box', oprright => 'box', oprresult => 'bool',
+  oprcom => '<(box,box)', oprnegate => '<=(box,box)', oprcode => 'box_gt',
+  oprrest => 'areasel', oprjoin => 'areajoinsel' },
+{ oid => '503', descr => 'equal by area',
+  oprname => '=', oprleft => 'box', oprright => 'box', oprresult => 'bool',
+  oprcom => '=(box,box)', oprcode => 'box_eq', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+{ oid => '504', descr => 'less than by area',
+  oprname => '<', oprleft => 'box', oprright => 'box', oprresult => 'bool',
+  oprcom => '>(box,box)', oprnegate => '>=(box,box)', oprcode => 'box_lt',
+  oprrest => 'areasel', oprjoin => 'areajoinsel' },
+{ oid => '505', descr => 'less than or equal by area',
+  oprname => '<=', oprleft => 'box', oprright => 'box', oprresult => 'bool',
+  oprcom => '>=(box,box)', oprnegate => '>(box,box)', oprcode => 'box_le',
+  oprrest => 'areasel', oprjoin => 'areajoinsel' },
+{ oid => '506', descr => 'is above',
+  oprname => '>^', oprleft => 'point', oprright => 'point', oprresult => 'bool',
+  oprcode => 'point_above', oprrest => 'positionsel',
+  oprjoin => 'positionjoinsel' },
+{ oid => '507', descr => 'is left of',
+  oprname => '<<', oprleft => 'point', oprright => 'point', oprresult => 'bool',
+  oprcode => 'point_left', oprrest => 'positionsel',
+  oprjoin => 'positionjoinsel' },
+{ oid => '508', descr => 'is right of',
+  oprname => '>>', oprleft => 'point', oprright => 'point', oprresult => 'bool',
+  oprcode => 'point_right', oprrest => 'positionsel',
+  oprjoin => 'positionjoinsel' },
+{ oid => '509', descr => 'is below',
+  oprname => '<^', oprleft => 'point', oprright => 'point', oprresult => 'bool',
+  oprcode => 'point_below', oprrest => 'positionsel',
+  oprjoin => 'positionjoinsel' },
+{ oid => '510', descr => 'same as',
+  oprname => '~=', oprleft => 'point', oprright => 'point', oprresult => 'bool',
+  oprcom => '~=(point,point)', oprnegate => '<>(point,point)',
+  oprcode => 'point_eq', oprrest => 'eqsel', oprjoin => 'eqjoinsel' },
+{ oid => '511', descr => 'point inside box',
+  oprname => '<@', oprleft => 'point', oprright => 'box', oprresult => 'bool',
+  oprcom => '@>(box,point)', oprcode => 'on_pb', oprrest => 'contsel',
+  oprjoin => 'contjoinsel' },
+{ oid => '433', descr => 'contains',
+  oprname => '@>', oprleft => 'box', oprright => 'point', oprresult => 'bool',
+  oprcom => '<@(point,box)', oprcode => 'box_contain_pt', oprrest => 'contsel',
+  oprjoin => 'contjoinsel' },
+{ oid => '512', descr => 'point within closed path, or point on open path',
+  oprname => '<@', oprleft => 'point', oprright => 'path', oprresult => 'bool',
+  oprcom => '@>(path,point)', oprcode => 'on_ppath' },
+{ oid => '513', descr => 'center of',
+  oprname => '@@', oprkind => 'l', oprleft => '0', oprright => 'box',
+  oprresult => 'point', oprcode => 'box_center' },
+{ oid => '514', descr => 'multiply',
+  oprname => '*', oprleft => 'int4', oprright => 'int4', oprresult => 'int4',
+  oprcom => '*(int4,int4)', oprcode => 'int4mul' },
+{ oid => '517', descr => 'distance between',
+  oprname => '<->', oprleft => 'point', oprright => 'point',
+  oprresult => 'float8', oprcom => '<->(point,point)',
+  oprcode => 'point_distance' },
+{ oid => '518', descr => 'not equal',
+  oprname => '<>', oprleft => 'int4', oprright => 'int4', oprresult => 'bool',
+  oprcom => '<>(int4,int4)', oprnegate => '=(int4,int4)', oprcode => 'int4ne',
+  oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+{ oid => '519', descr => 'not equal',
+  oprname => '<>', oprleft => 'int2', oprright => 'int2', oprresult => 'bool',
+  oprcom => '<>(int2,int2)', oprnegate => '=(int2,int2)', oprcode => 'int2ne',
+  oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+{ oid => '520', descr => 'greater than',
+  oprname => '>', oprleft => 'int2', oprright => 'int2', oprresult => 'bool',
+  oprcom => '<(int2,int2)', oprnegate => '<=(int2,int2)', oprcode => 'int2gt',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '521', descr => 'greater than',
+  oprname => '>', oprleft => 'int4', oprright => 'int4', oprresult => 'bool',
+  oprcom => '<(int4,int4)', oprnegate => '<=(int4,int4)', oprcode => 'int4gt',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '522', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'int2', oprright => 'int2', oprresult => 'bool',
+  oprcom => '>=(int2,int2)', oprnegate => '>(int2,int2)', oprcode => 'int2le',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '523', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'int4', oprright => 'int4', oprresult => 'bool',
+  oprcom => '>=(int4,int4)', oprnegate => '>(int4,int4)', oprcode => 'int4le',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '524', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'int2', oprright => 'int2', oprresult => 'bool',
+  oprcom => '<=(int2,int2)', oprnegate => '<(int2,int2)', oprcode => 'int2ge',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+{ oid => '525', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'int4', oprright => 'int4', oprresult => 'bool',
+  oprcom => '<=(int4,int4)', oprnegate => '<(int4,int4)', oprcode => 'int4ge',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+{ oid => '526', descr => 'multiply',
+  oprname => '*', oprleft => 'int2', oprright => 'int2', oprresult => 'int2',
+  oprcom => '*(int2,int2)', oprcode => 'int2mul' },
+{ oid => '527', descr => 'divide',
+  oprname => '/', oprleft => 'int2', oprright => 'int2', oprresult => 'int2',
+  oprcode => 'int2div' },
+{ oid => '528', descr => 'divide',
+  oprname => '/', oprleft => 'int4', oprright => 'int4', oprresult => 'int4',
+  oprcode => 'int4div' },
+{ oid => '529', descr => 'modulus',
+  oprname => '%', oprleft => 'int2', oprright => 'int2', oprresult => 'int2',
+  oprcode => 'int2mod' },
+{ oid => '530', descr => 'modulus',
+  oprname => '%', oprleft => 'int4', oprright => 'int4', oprresult => 'int4',
+  oprcode => 'int4mod' },
+{ oid => '531', descr => 'not equal',
+  oprname => '<>', oprleft => 'text', oprright => 'text', oprresult => 'bool',
+  oprcom => '<>(text,text)', oprnegate => '=(text,text)', oprcode => 'textne',
+  oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+{ oid => '532', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprcanhash => 't', oprleft => 'int2',
+  oprright => 'int4', oprresult => 'bool', oprcom => '=(int4,int2)',
+  oprnegate => '<>(int2,int4)', oprcode => 'int24eq', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+{ oid => '533', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprcanhash => 't', oprleft => 'int4',
+  oprright => 'int2', oprresult => 'bool', oprcom => '=(int2,int4)',
+  oprnegate => '<>(int4,int2)', oprcode => 'int42eq', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+{ oid => '534', descr => 'less than',
+  oprname => '<', oprleft => 'int2', oprright => 'int4', oprresult => 'bool',
+  oprcom => '>(int4,int2)', oprnegate => '>=(int2,int4)', oprcode => 'int24lt',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '535', descr => 'less than',
+  oprname => '<', oprleft => 'int4', oprright => 'int2', oprresult => 'bool',
+  oprcom => '>(int2,int4)', oprnegate => '>=(int4,int2)', oprcode => 'int42lt',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '536', descr => 'greater than',
+  oprname => '>', oprleft => 'int2', oprright => 'int4', oprresult => 'bool',
+  oprcom => '<(int4,int2)', oprnegate => '<=(int2,int4)', oprcode => 'int24gt',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '537', descr => 'greater than',
+  oprname => '>', oprleft => 'int4', oprright => 'int2', oprresult => 'bool',
+  oprcom => '<(int2,int4)', oprnegate => '<=(int4,int2)', oprcode => 'int42gt',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '538', descr => 'not equal',
+  oprname => '<>', oprleft => 'int2', oprright => 'int4', oprresult => 'bool',
+  oprcom => '<>(int4,int2)', oprnegate => '=(int2,int4)', oprcode => 'int24ne',
+  oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+{ oid => '539', descr => 'not equal',
+  oprname => '<>', oprleft => 'int4', oprright => 'int2', oprresult => 'bool',
+  oprcom => '<>(int2,int4)', oprnegate => '=(int4,int2)', oprcode => 'int42ne',
+  oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+{ oid => '540', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'int2', oprright => 'int4', oprresult => 'bool',
+  oprcom => '>=(int4,int2)', oprnegate => '>(int2,int4)', oprcode => 'int24le',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '541', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'int4', oprright => 'int2', oprresult => 'bool',
+  oprcom => '>=(int2,int4)', oprnegate => '>(int4,int2)', oprcode => 'int42le',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '542', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'int2', oprright => 'int4', oprresult => 'bool',
+  oprcom => '<=(int4,int2)', oprnegate => '<(int2,int4)', oprcode => 'int24ge',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+{ oid => '543', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'int4', oprright => 'int2', oprresult => 'bool',
+  oprcom => '<=(int2,int4)', oprnegate => '<(int4,int2)', oprcode => 'int42ge',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+{ oid => '544', descr => 'multiply',
+  oprname => '*', oprleft => 'int2', oprright => 'int4', oprresult => 'int4',
+  oprcom => '*(int4,int2)', oprcode => 'int24mul' },
+{ oid => '545', descr => 'multiply',
+  oprname => '*', oprleft => 'int4', oprright => 'int2', oprresult => 'int4',
+  oprcom => '*(int2,int4)', oprcode => 'int42mul' },
+{ oid => '546', descr => 'divide',
+  oprname => '/', oprleft => 'int2', oprright => 'int4', oprresult => 'int4',
+  oprcode => 'int24div' },
+{ oid => '547', descr => 'divide',
+  oprname => '/', oprleft => 'int4', oprright => 'int2', oprresult => 'int4',
+  oprcode => 'int42div' },
+{ oid => '550', descr => 'add',
+  oprname => '+', oprleft => 'int2', oprright => 'int2', oprresult => 'int2',
+  oprcom => '+(int2,int2)', oprcode => 'int2pl' },
+{ oid => '551', descr => 'add',
+  oprname => '+', oprleft => 'int4', oprright => 'int4', oprresult => 'int4',
+  oprcom => '+(int4,int4)', oprcode => 'int4pl' },
+{ oid => '552', descr => 'add',
+  oprname => '+', oprleft => 'int2', oprright => 'int4', oprresult => 'int4',
+  oprcom => '+(int4,int2)', oprcode => 'int24pl' },
+{ oid => '553', descr => 'add',
+  oprname => '+', oprleft => 'int4', oprright => 'int2', oprresult => 'int4',
+  oprcom => '+(int2,int4)', oprcode => 'int42pl' },
+{ oid => '554', descr => 'subtract',
+  oprname => '-', oprleft => 'int2', oprright => 'int2', oprresult => 'int2',
+  oprcode => 'int2mi' },
+{ oid => '555', descr => 'subtract',
+  oprname => '-', oprleft => 'int4', oprright => 'int4', oprresult => 'int4',
+  oprcode => 'int4mi' },
+{ oid => '556', descr => 'subtract',
+  oprname => '-', oprleft => 'int2', oprright => 'int4', oprresult => 'int4',
+  oprcode => 'int24mi' },
+{ oid => '557', descr => 'subtract',
+  oprname => '-', oprleft => 'int4', oprright => 'int2', oprresult => 'int4',
+  oprcode => 'int42mi' },
+{ oid => '558', descr => 'negate',
+  oprname => '-', oprkind => 'l', oprleft => '0', oprright => 'int4',
+  oprresult => 'int4', oprcode => 'int4um' },
+{ oid => '559', descr => 'negate',
+  oprname => '-', oprkind => 'l', oprleft => '0', oprright => 'int2',
+  oprresult => 'int2', oprcode => 'int2um' },
+{ oid => '584', descr => 'negate',
+  oprname => '-', oprkind => 'l', oprleft => '0', oprright => 'float4',
+  oprresult => 'float4', oprcode => 'float4um' },
+{ oid => '585', descr => 'negate',
+  oprname => '-', oprkind => 'l', oprleft => '0', oprright => 'float8',
+  oprresult => 'float8', oprcode => 'float8um' },
+{ oid => '586', descr => 'add',
+  oprname => '+', oprleft => 'float4', oprright => 'float4',
+  oprresult => 'float4', oprcom => '+(float4,float4)', oprcode => 'float4pl' },
+{ oid => '587', descr => 'subtract',
+  oprname => '-', oprleft => 'float4', oprright => 'float4',
+  oprresult => 'float4', oprcode => 'float4mi' },
+{ oid => '588', descr => 'divide',
+  oprname => '/', oprleft => 'float4', oprright => 'float4',
+  oprresult => 'float4', oprcode => 'float4div' },
+{ oid => '589', descr => 'multiply',
+  oprname => '*', oprleft => 'float4', oprright => 'float4',
+  oprresult => 'float4', oprcom => '*(float4,float4)', oprcode => 'float4mul' },
+{ oid => '590', descr => 'absolute value',
+  oprname => '@', oprkind => 'l', oprleft => '0', oprright => 'float4',
+  oprresult => 'float4', oprcode => 'float4abs' },
+{ oid => '591', descr => 'add',
+  oprname => '+', oprleft => 'float8', oprright => 'float8',
+  oprresult => 'float8', oprcom => '+(float8,float8)', oprcode => 'float8pl' },
+{ oid => '592', descr => 'subtract',
+  oprname => '-', oprleft => 'float8', oprright => 'float8',
+  oprresult => 'float8', oprcode => 'float8mi' },
+{ oid => '593', descr => 'divide',
+  oprname => '/', oprleft => 'float8', oprright => 'float8',
+  oprresult => 'float8', oprcode => 'float8div' },
+{ oid => '594', descr => 'multiply',
+  oprname => '*', oprleft => 'float8', oprright => 'float8',
+  oprresult => 'float8', oprcom => '*(float8,float8)', oprcode => 'float8mul' },
+{ oid => '595', descr => 'absolute value',
+  oprname => '@', oprkind => 'l', oprleft => '0', oprright => 'float8',
+  oprresult => 'float8', oprcode => 'float8abs' },
+{ oid => '596', descr => 'square root',
+  oprname => '|/', oprkind => 'l', oprleft => '0', oprright => 'float8',
+  oprresult => 'float8', oprcode => 'dsqrt' },
+{ oid => '597', descr => 'cube root',
+  oprname => '||/', oprkind => 'l', oprleft => '0', oprright => 'float8',
+  oprresult => 'float8', oprcode => 'dcbrt' },
+
+{ oid => '607', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprcanhash => 't', oprleft => 'oid',
+  oprright => 'oid', oprresult => 'bool', oprcom => '=(oid,oid)',
+  oprnegate => '<>(oid,oid)', oprcode => 'oideq', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+{ oid => '608', descr => 'not equal',
+  oprname => '<>', oprleft => 'oid', oprright => 'oid', oprresult => 'bool',
+  oprcom => '<>(oid,oid)', oprnegate => '=(oid,oid)', oprcode => 'oidne',
+  oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+{ oid => '609', descr => 'less than',
+  oprname => '<', oprleft => 'oid', oprright => 'oid', oprresult => 'bool',
+  oprcom => '>(oid,oid)', oprnegate => '>=(oid,oid)', oprcode => 'oidlt',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '610', descr => 'greater than',
+  oprname => '>', oprleft => 'oid', oprright => 'oid', oprresult => 'bool',
+  oprcom => '<(oid,oid)', oprnegate => '<=(oid,oid)', oprcode => 'oidgt',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '611', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'oid', oprright => 'oid', oprresult => 'bool',
+  oprcom => '>=(oid,oid)', oprnegate => '>(oid,oid)', oprcode => 'oidle',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '612', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'oid', oprright => 'oid', oprresult => 'bool',
+  oprcom => '<=(oid,oid)', oprnegate => '<(oid,oid)', oprcode => 'oidge',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+
+{ oid => '644', descr => 'not equal',
+  oprname => '<>', oprleft => 'oidvector', oprright => 'oidvector',
+  oprresult => 'bool', oprcom => '<>(oidvector,oidvector)',
+  oprnegate => '=(oidvector,oidvector)', oprcode => 'oidvectorne',
+  oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+{ oid => '645', descr => 'less than',
+  oprname => '<', oprleft => 'oidvector', oprright => 'oidvector',
+  oprresult => 'bool', oprcom => '>(oidvector,oidvector)',
+  oprnegate => '>=(oidvector,oidvector)', oprcode => 'oidvectorlt',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '646', descr => 'greater than',
+  oprname => '>', oprleft => 'oidvector', oprright => 'oidvector',
+  oprresult => 'bool', oprcom => '<(oidvector,oidvector)',
+  oprnegate => '<=(oidvector,oidvector)', oprcode => 'oidvectorgt',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '647', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'oidvector', oprright => 'oidvector',
+  oprresult => 'bool', oprcom => '>=(oidvector,oidvector)',
+  oprnegate => '>(oidvector,oidvector)', oprcode => 'oidvectorle',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '648', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'oidvector', oprright => 'oidvector',
+  oprresult => 'bool', oprcom => '<=(oidvector,oidvector)',
+  oprnegate => '<(oidvector,oidvector)', oprcode => 'oidvectorge',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+{ oid => '649', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprcanhash => 't', oprleft => 'oidvector',
+  oprright => 'oidvector', oprresult => 'bool',
+  oprcom => '=(oidvector,oidvector)', oprnegate => '<>(oidvector,oidvector)',
+  oprcode => 'oidvectoreq', oprrest => 'eqsel', oprjoin => 'eqjoinsel' },
+
+{ oid => '613', descr => 'distance between',
+  oprname => '<->', oprleft => 'point', oprright => 'line',
+  oprresult => 'float8', oprcom => '<->(line,point)', oprcode => 'dist_pl' },
+{ oid => '760', descr => 'distance between',
+  oprname => '<->', oprleft => 'line', oprright => 'point',
+  oprresult => 'float8', oprcom => '<->(point,line)', oprcode => 'dist_lp' },
+{ oid => '614', descr => 'distance between',
+  oprname => '<->', oprleft => 'point', oprright => 'lseg',
+  oprresult => 'float8', oprcom => '<->(lseg,point)', oprcode => 'dist_ps' },
+{ oid => '761', descr => 'distance between',
+  oprname => '<->', oprleft => 'lseg', oprright => 'point',
+  oprresult => 'float8', oprcom => '<->(point,lseg)', oprcode => 'dist_sp' },
+{ oid => '615', descr => 'distance between',
+  oprname => '<->', oprleft => 'point', oprright => 'box',
+  oprresult => 'float8', oprcom => '<->(box,point)', oprcode => 'dist_pb' },
+{ oid => '606', descr => 'distance between',
+  oprname => '<->', oprleft => 'box', oprright => 'point',
+  oprresult => 'float8', oprcom => '<->(point,box)', oprcode => 'dist_bp' },
+{ oid => '616', descr => 'distance between',
+  oprname => '<->', oprleft => 'lseg', oprright => 'line',
+  oprresult => 'float8', oprcom => '<->(line,lseg)', oprcode => 'dist_sl' },
+{ oid => '762', descr => 'distance between',
+  oprname => '<->', oprleft => 'line', oprright => 'lseg',
+  oprresult => 'float8', oprcom => '<->(lseg,line)', oprcode => 'dist_ls' },
+{ oid => '617', descr => 'distance between',
+  oprname => '<->', oprleft => 'lseg', oprright => 'box', oprresult => 'float8',
+  oprcom => '<->(box,lseg)', oprcode => 'dist_sb' },
+{ oid => '763', descr => 'distance between',
+  oprname => '<->', oprleft => 'box', oprright => 'lseg', oprresult => 'float8',
+  oprcom => '<->(lseg,box)', oprcode => 'dist_bs' },
+{ oid => '618', descr => 'distance between',
+  oprname => '<->', oprleft => 'point', oprright => 'path',
+  oprresult => 'float8', oprcom => '<->(path,point)', oprcode => 'dist_ppath' },
+{ oid => '784', descr => 'distance between',
+  oprname => '<->', oprleft => 'path', oprright => 'point',
+  oprresult => 'float8', oprcom => '<->(point,path)', oprcode => 'dist_pathp' },
+
+{ oid => '620', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprcanhash => 't', oprleft => 'float4',
+  oprright => 'float4', oprresult => 'bool', oprcom => '=(float4,float4)',
+  oprnegate => '<>(float4,float4)', oprcode => 'float4eq', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+{ oid => '621', descr => 'not equal',
+  oprname => '<>', oprleft => 'float4', oprright => 'float4',
+  oprresult => 'bool', oprcom => '<>(float4,float4)',
+  oprnegate => '=(float4,float4)', oprcode => 'float4ne', oprrest => 'neqsel',
+  oprjoin => 'neqjoinsel' },
+{ oid => '622', descr => 'less than',
+  oprname => '<', oprleft => 'float4', oprright => 'float4',
+  oprresult => 'bool', oprcom => '>(float4,float4)',
+  oprnegate => '>=(float4,float4)', oprcode => 'float4lt',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '623', descr => 'greater than',
+  oprname => '>', oprleft => 'float4', oprright => 'float4',
+  oprresult => 'bool', oprcom => '<(float4,float4)',
+  oprnegate => '<=(float4,float4)', oprcode => 'float4gt',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '624', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'float4', oprright => 'float4',
+  oprresult => 'bool', oprcom => '>=(float4,float4)',
+  oprnegate => '>(float4,float4)', oprcode => 'float4le',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '625', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'float4', oprright => 'float4',
+  oprresult => 'bool', oprcom => '<=(float4,float4)',
+  oprnegate => '<(float4,float4)', oprcode => 'float4ge',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+{ oid => '630', descr => 'not equal',
+  oprname => '<>', oprleft => 'char', oprright => 'char', oprresult => 'bool',
+  oprcom => '<>(char,char)', oprnegate => '=(char,char)', oprcode => 'charne',
+  oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+
+{ oid => '631', descr => 'less than',
+  oprname => '<', oprleft => 'char', oprright => 'char', oprresult => 'bool',
+  oprcom => '>(char,char)', oprnegate => '>=(char,char)', oprcode => 'charlt',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '632', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'char', oprright => 'char', oprresult => 'bool',
+  oprcom => '>=(char,char)', oprnegate => '>(char,char)', oprcode => 'charle',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '633', descr => 'greater than',
+  oprname => '>', oprleft => 'char', oprright => 'char', oprresult => 'bool',
+  oprcom => '<(char,char)', oprnegate => '<=(char,char)', oprcode => 'chargt',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '634', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'char', oprright => 'char', oprresult => 'bool',
+  oprcom => '<=(char,char)', oprnegate => '<(char,char)', oprcode => 'charge',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+
+{ oid => '639', oid_symbol => 'OID_NAME_REGEXEQ_OP',
+  descr => 'matches regular expression, case-sensitive',
+  oprname => '~', oprleft => 'name', oprright => 'text', oprresult => 'bool',
+  oprnegate => '!~(name,text)', oprcode => 'nameregexeq',
+  oprrest => 'regexeqsel', oprjoin => 'regexeqjoinsel' },
+{ oid => '640', descr => 'does not match regular expression, case-sensitive',
+  oprname => '!~', oprleft => 'name', oprright => 'text', oprresult => 'bool',
+  oprnegate => '~(name,text)', oprcode => 'nameregexne',
+  oprrest => 'regexnesel', oprjoin => 'regexnejoinsel' },
+{ oid => '641', oid_symbol => 'OID_TEXT_REGEXEQ_OP',
+  descr => 'matches regular expression, case-sensitive',
+  oprname => '~', oprleft => 'text', oprright => 'text', oprresult => 'bool',
+  oprnegate => '!~(text,text)', oprcode => 'textregexeq',
+  oprrest => 'regexeqsel', oprjoin => 'regexeqjoinsel' },
+{ oid => '642', descr => 'does not match regular expression, case-sensitive',
+  oprname => '!~', oprleft => 'text', oprright => 'text', oprresult => 'bool',
+  oprnegate => '~(text,text)', oprcode => 'textregexne',
+  oprrest => 'regexnesel', oprjoin => 'regexnejoinsel' },
+{ oid => '643', descr => 'not equal',
+  oprname => '<>', oprleft => 'name', oprright => 'name', oprresult => 'bool',
+  oprcom => '<>(name,name)', oprnegate => '=(name,name)', oprcode => 'namene',
+  oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+{ oid => '654', descr => 'concatenate',
+  oprname => '||', oprleft => 'text', oprright => 'text', oprresult => 'text',
+  oprcode => 'textcat' },
+
+{ oid => '660', descr => 'less than',
+  oprname => '<', oprleft => 'name', oprright => 'name', oprresult => 'bool',
+  oprcom => '>(name,name)', oprnegate => '>=(name,name)', oprcode => 'namelt',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '661', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'name', oprright => 'name', oprresult => 'bool',
+  oprcom => '>=(name,name)', oprnegate => '>(name,name)', oprcode => 'namele',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '662', descr => 'greater than',
+  oprname => '>', oprleft => 'name', oprright => 'name', oprresult => 'bool',
+  oprcom => '<(name,name)', oprnegate => '<=(name,name)', oprcode => 'namegt',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '663', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'name', oprright => 'name', oprresult => 'bool',
+  oprcom => '<=(name,name)', oprnegate => '<(name,name)', oprcode => 'namege',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+{ oid => '664', oid_symbol => 'TextLessOperator', descr => 'less than',
+  oprname => '<', oprleft => 'text', oprright => 'text', oprresult => 'bool',
+  oprcom => '>(text,text)', oprnegate => '>=(text,text)', oprcode => 'text_lt',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '665', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'text', oprright => 'text', oprresult => 'bool',
+  oprcom => '>=(text,text)', oprnegate => '>(text,text)', oprcode => 'text_le',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '666', descr => 'greater than',
+  oprname => '>', oprleft => 'text', oprright => 'text', oprresult => 'bool',
+  oprcom => '<(text,text)', oprnegate => '<=(text,text)', oprcode => 'text_gt',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '667', oid_symbol => 'TextGreaterEqualOperator',
+  descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'text', oprright => 'text', oprresult => 'bool',
+  oprcom => '<=(text,text)', oprnegate => '<(text,text)', oprcode => 'text_ge',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+
+{ oid => '670', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprcanhash => 't', oprleft => 'float8',
+  oprright => 'float8', oprresult => 'bool', oprcom => '=(float8,float8)',
+  oprnegate => '<>(float8,float8)', oprcode => 'float8eq', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+{ oid => '671', descr => 'not equal',
+  oprname => '<>', oprleft => 'float8', oprright => 'float8',
+  oprresult => 'bool', oprcom => '<>(float8,float8)',
+  oprnegate => '=(float8,float8)', oprcode => 'float8ne', oprrest => 'neqsel',
+  oprjoin => 'neqjoinsel' },
+{ oid => '672', oid_symbol => 'Float8LessOperator', descr => 'less than',
+  oprname => '<', oprleft => 'float8', oprright => 'float8',
+  oprresult => 'bool', oprcom => '>(float8,float8)',
+  oprnegate => '>=(float8,float8)', oprcode => 'float8lt',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '673', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'float8', oprright => 'float8',
+  oprresult => 'bool', oprcom => '>=(float8,float8)',
+  oprnegate => '>(float8,float8)', oprcode => 'float8le',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '674', descr => 'greater than',
+  oprname => '>', oprleft => 'float8', oprright => 'float8',
+  oprresult => 'bool', oprcom => '<(float8,float8)',
+  oprnegate => '<=(float8,float8)', oprcode => 'float8gt',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '675', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'float8', oprright => 'float8',
+  oprresult => 'bool', oprcom => '<=(float8,float8)',
+  oprnegate => '<(float8,float8)', oprcode => 'float8ge',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+
+{ oid => '682', descr => 'absolute value',
+  oprname => '@', oprkind => 'l', oprleft => '0', oprright => 'int2',
+  oprresult => 'int2', oprcode => 'int2abs' },
+{ oid => '684', descr => 'add',
+  oprname => '+', oprleft => 'int8', oprright => 'int8', oprresult => 'int8',
+  oprcom => '+(int8,int8)', oprcode => 'int8pl' },
+{ oid => '685', descr => 'subtract',
+  oprname => '-', oprleft => 'int8', oprright => 'int8', oprresult => 'int8',
+  oprcode => 'int8mi' },
+{ oid => '686', descr => 'multiply',
+  oprname => '*', oprleft => 'int8', oprright => 'int8', oprresult => 'int8',
+  oprcom => '*(int8,int8)', oprcode => 'int8mul' },
+{ oid => '687', descr => 'divide',
+  oprname => '/', oprleft => 'int8', oprright => 'int8', oprresult => 'int8',
+  oprcode => 'int8div' },
+
+{ oid => '688', descr => 'add',
+  oprname => '+', oprleft => 'int8', oprright => 'int4', oprresult => 'int8',
+  oprcom => '+(int4,int8)', oprcode => 'int84pl' },
+{ oid => '689', descr => 'subtract',
+  oprname => '-', oprleft => 'int8', oprright => 'int4', oprresult => 'int8',
+  oprcode => 'int84mi' },
+{ oid => '690', descr => 'multiply',
+  oprname => '*', oprleft => 'int8', oprright => 'int4', oprresult => 'int8',
+  oprcom => '*(int4,int8)', oprcode => 'int84mul' },
+{ oid => '691', descr => 'divide',
+  oprname => '/', oprleft => 'int8', oprright => 'int4', oprresult => 'int8',
+  oprcode => 'int84div' },
+{ oid => '692', descr => 'add',
+  oprname => '+', oprleft => 'int4', oprright => 'int8', oprresult => 'int8',
+  oprcom => '+(int8,int4)', oprcode => 'int48pl' },
+{ oid => '693', descr => 'subtract',
+  oprname => '-', oprleft => 'int4', oprright => 'int8', oprresult => 'int8',
+  oprcode => 'int48mi' },
+{ oid => '694', descr => 'multiply',
+  oprname => '*', oprleft => 'int4', oprright => 'int8', oprresult => 'int8',
+  oprcom => '*(int8,int4)', oprcode => 'int48mul' },
+{ oid => '695', descr => 'divide',
+  oprname => '/', oprleft => 'int4', oprright => 'int8', oprresult => 'int8',
+  oprcode => 'int48div' },
+
+{ oid => '818', descr => 'add',
+  oprname => '+', oprleft => 'int8', oprright => 'int2', oprresult => 'int8',
+  oprcom => '+(int2,int8)', oprcode => 'int82pl' },
+{ oid => '819', descr => 'subtract',
+  oprname => '-', oprleft => 'int8', oprright => 'int2', oprresult => 'int8',
+  oprcode => 'int82mi' },
+{ oid => '820', descr => 'multiply',
+  oprname => '*', oprleft => 'int8', oprright => 'int2', oprresult => 'int8',
+  oprcom => '*(int2,int8)', oprcode => 'int82mul' },
+{ oid => '821', descr => 'divide',
+  oprname => '/', oprleft => 'int8', oprright => 'int2', oprresult => 'int8',
+  oprcode => 'int82div' },
+{ oid => '822', descr => 'add',
+  oprname => '+', oprleft => 'int2', oprright => 'int8', oprresult => 'int8',
+  oprcom => '+(int8,int2)', oprcode => 'int28pl' },
+{ oid => '823', descr => 'subtract',
+  oprname => '-', oprleft => 'int2', oprright => 'int8', oprresult => 'int8',
+  oprcode => 'int28mi' },
+{ oid => '824', descr => 'multiply',
+  oprname => '*', oprleft => 'int2', oprright => 'int8', oprresult => 'int8',
+  oprcom => '*(int8,int2)', oprcode => 'int28mul' },
+{ oid => '825', descr => 'divide',
+  oprname => '/', oprleft => 'int2', oprright => 'int8', oprresult => 'int8',
+  oprcode => 'int28div' },
+
+{ oid => '706', descr => 'distance between',
+  oprname => '<->', oprleft => 'box', oprright => 'box', oprresult => 'float8',
+  oprcom => '<->(box,box)', oprcode => 'box_distance' },
+{ oid => '707', descr => 'distance between',
+  oprname => '<->', oprleft => 'path', oprright => 'path',
+  oprresult => 'float8', oprcom => '<->(path,path)',
+  oprcode => 'path_distance' },
+{ oid => '708', descr => 'distance between',
+  oprname => '<->', oprleft => 'line', oprright => 'line',
+  oprresult => 'float8', oprcom => '<->(line,line)',
+  oprcode => 'line_distance' },
+{ oid => '709', descr => 'distance between',
+  oprname => '<->', oprleft => 'lseg', oprright => 'lseg',
+  oprresult => 'float8', oprcom => '<->(lseg,lseg)',
+  oprcode => 'lseg_distance' },
+{ oid => '712', descr => 'distance between',
+  oprname => '<->', oprleft => 'polygon', oprright => 'polygon',
+  oprresult => 'float8', oprcom => '<->(polygon,polygon)',
+  oprcode => 'poly_distance' },
+
+{ oid => '713', descr => 'not equal',
+  oprname => '<>', oprleft => 'point', oprright => 'point', oprresult => 'bool',
+  oprcom => '<>(point,point)', oprnegate => '~=(point,point)',
+  oprcode => 'point_ne', oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+
+# add translation/rotation/scaling operators for geometric types. - thomas 97/05/10
+{ oid => '731', descr => 'add points (translate)',
+  oprname => '+', oprleft => 'point', oprright => 'point', oprresult => 'point',
+  oprcom => '+(point,point)', oprcode => 'point_add' },
+{ oid => '732', descr => 'subtract points (translate)',
+  oprname => '-', oprleft => 'point', oprright => 'point', oprresult => 'point',
+  oprcode => 'point_sub' },
+{ oid => '733', descr => 'multiply points (scale/rotate)',
+  oprname => '*', oprleft => 'point', oprright => 'point', oprresult => 'point',
+  oprcom => '*(point,point)', oprcode => 'point_mul' },
+{ oid => '734', descr => 'divide points (scale/rotate)',
+  oprname => '/', oprleft => 'point', oprright => 'point', oprresult => 'point',
+  oprcode => 'point_div' },
+{ oid => '735', descr => 'concatenate',
+  oprname => '+', oprleft => 'path', oprright => 'path', oprresult => 'path',
+  oprcom => '+(path,path)', oprcode => 'path_add' },
+{ oid => '736', descr => 'add (translate path)',
+  oprname => '+', oprleft => 'path', oprright => 'point', oprresult => 'path',
+  oprcode => 'path_add_pt' },
+{ oid => '737', descr => 'subtract (translate path)',
+  oprname => '-', oprleft => 'path', oprright => 'point', oprresult => 'path',
+  oprcode => 'path_sub_pt' },
+{ oid => '738', descr => 'multiply (rotate/scale path)',
+  oprname => '*', oprleft => 'path', oprright => 'point', oprresult => 'path',
+  oprcode => 'path_mul_pt' },
+{ oid => '739', descr => 'divide (rotate/scale path)',
+  oprname => '/', oprleft => 'path', oprright => 'point', oprresult => 'path',
+  oprcode => 'path_div_pt' },
+{ oid => '755', descr => 'contains',
+  oprname => '@>', oprleft => 'path', oprright => 'point', oprresult => 'bool',
+  oprcom => '<@(point,path)', oprcode => 'path_contain_pt' },
+{ oid => '756', descr => 'is contained by',
+  oprname => '<@', oprleft => 'point', oprright => 'polygon',
+  oprresult => 'bool', oprcom => '@>(polygon,point)',
+  oprcode => 'pt_contained_poly', oprrest => 'contsel',
+  oprjoin => 'contjoinsel' },
+{ oid => '757', descr => 'contains',
+  oprname => '@>', oprleft => 'polygon', oprright => 'point',
+  oprresult => 'bool', oprcom => '<@(point,polygon)',
+  oprcode => 'poly_contain_pt', oprrest => 'contsel',
+  oprjoin => 'contjoinsel' },
+{ oid => '758', descr => 'is contained by',
+  oprname => '<@', oprleft => 'point', oprright => 'circle',
+  oprresult => 'bool', oprcom => '@>(circle,point)',
+  oprcode => 'pt_contained_circle', oprrest => 'contsel',
+  oprjoin => 'contjoinsel' },
+{ oid => '759', descr => 'contains',
+  oprname => '@>', oprleft => 'circle', oprright => 'point',
+  oprresult => 'bool', oprcom => '<@(point,circle)',
+  oprcode => 'circle_contain_pt', oprrest => 'contsel',
+  oprjoin => 'contjoinsel' },
+
+{ oid => '773', descr => 'absolute value',
+  oprname => '@', oprkind => 'l', oprleft => '0', oprright => 'int4',
+  oprresult => 'int4', oprcode => 'int4abs' },
+
+# additional operators for geometric types - thomas 1997-07-09
+{ oid => '792', descr => 'equal',
+  oprname => '=', oprleft => 'path', oprright => 'path', oprresult => 'bool',
+  oprcom => '=(path,path)', oprcode => 'path_n_eq', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+{ oid => '793', descr => 'less than',
+  oprname => '<', oprleft => 'path', oprright => 'path', oprresult => 'bool',
+  oprcom => '>(path,path)', oprcode => 'path_n_lt' },
+{ oid => '794', descr => 'greater than',
+  oprname => '>', oprleft => 'path', oprright => 'path', oprresult => 'bool',
+  oprcom => '<(path,path)', oprcode => 'path_n_gt' },
+{ oid => '795', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'path', oprright => 'path', oprresult => 'bool',
+  oprcom => '>=(path,path)', oprcode => 'path_n_le' },
+{ oid => '796', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'path', oprright => 'path', oprresult => 'bool',
+  oprcom => '<=(path,path)', oprcode => 'path_n_ge' },
+{ oid => '797', descr => 'number of points',
+  oprname => '#', oprkind => 'l', oprleft => '0', oprright => 'path',
+  oprresult => 'int4', oprcode => 'path_npoints' },
+{ oid => '798', descr => 'intersect',
+  oprname => '?#', oprleft => 'path', oprright => 'path', oprresult => 'bool',
+  oprcode => 'path_inter' },
+{ oid => '799', descr => 'sum of path segment lengths',
+  oprname => '@-@', oprkind => 'l', oprleft => '0', oprright => 'path',
+  oprresult => 'float8', oprcode => 'path_length' },
+{ oid => '800', descr => 'is above (allows touching)',
+  oprname => '>^', oprleft => 'box', oprright => 'box', oprresult => 'bool',
+  oprcode => 'box_above_eq', oprrest => 'positionsel',
+  oprjoin => 'positionjoinsel' },
+{ oid => '801', descr => 'is below (allows touching)',
+  oprname => '<^', oprleft => 'box', oprright => 'box', oprresult => 'bool',
+  oprcode => 'box_below_eq', oprrest => 'positionsel',
+  oprjoin => 'positionjoinsel' },
+{ oid => '802', descr => 'deprecated, use && instead',
+  oprname => '?#', oprleft => 'box', oprright => 'box', oprresult => 'bool',
+  oprcode => 'box_overlap', oprrest => 'areasel', oprjoin => 'areajoinsel' },
+{ oid => '803', descr => 'box intersection',
+  oprname => '#', oprleft => 'box', oprright => 'box', oprresult => 'box',
+  oprcode => 'box_intersect' },
+{ oid => '804', descr => 'add point to box (translate)',
+  oprname => '+', oprleft => 'box', oprright => 'point', oprresult => 'box',
+  oprcode => 'box_add' },
+{ oid => '805', descr => 'subtract point from box (translate)',
+  oprname => '-', oprleft => 'box', oprright => 'point', oprresult => 'box',
+  oprcode => 'box_sub' },
+{ oid => '806', descr => 'multiply box by point (scale)',
+  oprname => '*', oprleft => 'box', oprright => 'point', oprresult => 'box',
+  oprcode => 'box_mul' },
+{ oid => '807', descr => 'divide box by point (scale)',
+  oprname => '/', oprleft => 'box', oprright => 'point', oprresult => 'box',
+  oprcode => 'box_div' },
+{ oid => '808', descr => 'horizontally aligned',
+  oprname => '?-', oprleft => 'point', oprright => 'point', oprresult => 'bool',
+  oprcom => '?-(point,point)', oprcode => 'point_horiz' },
+{ oid => '809', descr => 'vertically aligned',
+  oprname => '?|', oprleft => 'point', oprright => 'point', oprresult => 'bool',
+  oprcom => '?|(point,point)', oprcode => 'point_vert' },
+
+{ oid => '843', descr => 'multiply',
+  oprname => '*', oprleft => 'money', oprright => 'float4',
+  oprresult => 'money', oprcom => '*(float4,money)',
+  oprcode => 'cash_mul_flt4' },
+{ oid => '844', descr => 'divide',
+  oprname => '/', oprleft => 'money', oprright => 'float4',
+  oprresult => 'money', oprcode => 'cash_div_flt4' },
+{ oid => '845', descr => 'multiply',
+  oprname => '*', oprleft => 'float4', oprright => 'money',
+  oprresult => 'money', oprcom => '*(money,float4)',
+  oprcode => 'flt4_mul_cash' },
+
+{ oid => '900', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprleft => 'money', oprright => 'money',
+  oprresult => 'bool', oprcom => '=(money,money)',
+  oprnegate => '<>(money,money)', oprcode => 'cash_eq', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+{ oid => '901', descr => 'not equal',
+  oprname => '<>', oprleft => 'money', oprright => 'money', oprresult => 'bool',
+  oprcom => '<>(money,money)', oprnegate => '=(money,money)',
+  oprcode => 'cash_ne', oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+{ oid => '902', descr => 'less than',
+  oprname => '<', oprleft => 'money', oprright => 'money', oprresult => 'bool',
+  oprcom => '>(money,money)', oprnegate => '>=(money,money)',
+  oprcode => 'cash_lt', oprrest => 'scalarltsel',
+  oprjoin => 'scalarltjoinsel' },
+{ oid => '903', descr => 'greater than',
+  oprname => '>', oprleft => 'money', oprright => 'money', oprresult => 'bool',
+  oprcom => '<(money,money)', oprnegate => '<=(money,money)',
+  oprcode => 'cash_gt', oprrest => 'scalargtsel',
+  oprjoin => 'scalargtjoinsel' },
+{ oid => '904', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'money', oprright => 'money', oprresult => 'bool',
+  oprcom => '>=(money,money)', oprnegate => '>(money,money)',
+  oprcode => 'cash_le', oprrest => 'scalarlesel',
+  oprjoin => 'scalarlejoinsel' },
+{ oid => '905', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'money', oprright => 'money', oprresult => 'bool',
+  oprcom => '<=(money,money)', oprnegate => '<(money,money)',
+  oprcode => 'cash_ge', oprrest => 'scalargesel',
+  oprjoin => 'scalargejoinsel' },
+{ oid => '906', descr => 'add',
+  oprname => '+', oprleft => 'money', oprright => 'money', oprresult => 'money',
+  oprcom => '+(money,money)', oprcode => 'cash_pl' },
+{ oid => '907', descr => 'subtract',
+  oprname => '-', oprleft => 'money', oprright => 'money', oprresult => 'money',
+  oprcode => 'cash_mi' },
+{ oid => '908', descr => 'multiply',
+  oprname => '*', oprleft => 'money', oprright => 'float8',
+  oprresult => 'money', oprcom => '*(float8,money)',
+  oprcode => 'cash_mul_flt8' },
+{ oid => '909', descr => 'divide',
+  oprname => '/', oprleft => 'money', oprright => 'float8',
+  oprresult => 'money', oprcode => 'cash_div_flt8' },
+{ oid => '3346', descr => 'multiply',
+  oprname => '*', oprleft => 'money', oprright => 'int8', oprresult => 'money',
+  oprcom => '*(int8,money)', oprcode => 'cash_mul_int8' },
+{ oid => '3347', descr => 'divide',
+  oprname => '/', oprleft => 'money', oprright => 'int8', oprresult => 'money',
+  oprcode => 'cash_div_int8' },
+{ oid => '912', descr => 'multiply',
+  oprname => '*', oprleft => 'money', oprright => 'int4', oprresult => 'money',
+  oprcom => '*(int4,money)', oprcode => 'cash_mul_int4' },
+{ oid => '913', descr => 'divide',
+  oprname => '/', oprleft => 'money', oprright => 'int4', oprresult => 'money',
+  oprcode => 'cash_div_int4' },
+{ oid => '914', descr => 'multiply',
+  oprname => '*', oprleft => 'money', oprright => 'int2', oprresult => 'money',
+  oprcom => '*(int2,money)', oprcode => 'cash_mul_int2' },
+{ oid => '915', descr => 'divide',
+  oprname => '/', oprleft => 'money', oprright => 'int2', oprresult => 'money',
+  oprcode => 'cash_div_int2' },
+{ oid => '916', descr => 'multiply',
+  oprname => '*', oprleft => 'float8', oprright => 'money',
+  oprresult => 'money', oprcom => '*(money,float8)',
+  oprcode => 'flt8_mul_cash' },
+{ oid => '3349', descr => 'multiply',
+  oprname => '*', oprleft => 'int8', oprright => 'money', oprresult => 'money',
+  oprcom => '*(money,int8)', oprcode => 'int8_mul_cash' },
+{ oid => '917', descr => 'multiply',
+  oprname => '*', oprleft => 'int4', oprright => 'money', oprresult => 'money',
+  oprcom => '*(money,int4)', oprcode => 'int4_mul_cash' },
+{ oid => '918', descr => 'multiply',
+  oprname => '*', oprleft => 'int2', oprright => 'money', oprresult => 'money',
+  oprcom => '*(money,int2)', oprcode => 'int2_mul_cash' },
+{ oid => '3825', descr => 'divide',
+  oprname => '/', oprleft => 'money', oprright => 'money',
+  oprresult => 'float8', oprcode => 'cash_div_cash' },
+
+{ oid => '965', descr => 'exponentiation',
+  oprname => '^', oprleft => 'float8', oprright => 'float8',
+  oprresult => 'float8', oprcode => 'dpow' },
+{ oid => '966', descr => 'add/update ACL item',
+  oprname => '+', oprleft => '_aclitem', oprright => 'aclitem',
+  oprresult => '_aclitem', oprcode => 'aclinsert' },
+{ oid => '967', descr => 'remove ACL item',
+  oprname => '-', oprleft => '_aclitem', oprright => 'aclitem',
+  oprresult => '_aclitem', oprcode => 'aclremove' },
+{ oid => '968', descr => 'contains',
+  oprname => '@>', oprleft => '_aclitem', oprright => 'aclitem',
+  oprresult => 'bool', oprcode => 'aclcontains' },
+{ oid => '974', descr => 'equal',
+  oprname => '=', oprcanhash => 't', oprleft => 'aclitem',
+  oprright => 'aclitem', oprresult => 'bool', oprcom => '=(aclitem,aclitem)',
+  oprcode => 'aclitemeq', oprrest => 'eqsel', oprjoin => 'eqjoinsel' },
+
+# additional geometric operators - thomas 1997-07-09
+{ oid => '969', descr => 'center of',
+  oprname => '@@', oprkind => 'l', oprleft => '0', oprright => 'lseg',
+  oprresult => 'point', oprcode => 'lseg_center' },
+{ oid => '970', descr => 'center of',
+  oprname => '@@', oprkind => 'l', oprleft => '0', oprright => 'path',
+  oprresult => 'point', oprcode => 'path_center' },
+{ oid => '971', descr => 'center of',
+  oprname => '@@', oprkind => 'l', oprleft => '0', oprright => 'polygon',
+  oprresult => 'point', oprcode => 'poly_center' },
+
+{ oid => '1054', oid_symbol => 'BpcharEqualOperator', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprcanhash => 't', oprleft => 'bpchar',
+  oprright => 'bpchar', oprresult => 'bool', oprcom => '=(bpchar,bpchar)',
+  oprnegate => '<>(bpchar,bpchar)', oprcode => 'bpchareq', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+
+{ oid => '1055', oid_symbol => 'OID_BPCHAR_REGEXEQ_OP',
+  descr => 'matches regular expression, case-sensitive',
+  oprname => '~', oprleft => 'bpchar', oprright => 'text', oprresult => 'bool',
+  oprnegate => '!~(bpchar,text)', oprcode => 'bpcharregexeq',
+  oprrest => 'regexeqsel', oprjoin => 'regexeqjoinsel' },
+{ oid => '1056', descr => 'does not match regular expression, case-sensitive',
+  oprname => '!~', oprleft => 'bpchar', oprright => 'text', oprresult => 'bool',
+  oprnegate => '~(bpchar,text)', oprcode => 'bpcharregexne',
+  oprrest => 'regexnesel', oprjoin => 'regexnejoinsel' },
+{ oid => '1057', descr => 'not equal',
+  oprname => '<>', oprleft => 'bpchar', oprright => 'bpchar',
+  oprresult => 'bool', oprcom => '<>(bpchar,bpchar)',
+  oprnegate => '=(bpchar,bpchar)', oprcode => 'bpcharne', oprrest => 'neqsel',
+  oprjoin => 'neqjoinsel' },
+{ oid => '1058', oid_symbol => 'BpcharLessOperator', descr => 'less than',
+  oprname => '<', oprleft => 'bpchar', oprright => 'bpchar',
+  oprresult => 'bool', oprcom => '>(bpchar,bpchar)',
+  oprnegate => '>=(bpchar,bpchar)', oprcode => 'bpcharlt',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '1059', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'bpchar', oprright => 'bpchar',
+  oprresult => 'bool', oprcom => '>=(bpchar,bpchar)',
+  oprnegate => '>(bpchar,bpchar)', oprcode => 'bpcharle',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '1060', descr => 'greater than',
+  oprname => '>', oprleft => 'bpchar', oprright => 'bpchar',
+  oprresult => 'bool', oprcom => '<(bpchar,bpchar)',
+  oprnegate => '<=(bpchar,bpchar)', oprcode => 'bpchargt',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '1061', oid_symbol => 'BpcharGreaterEqualOperator',
+  descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'bpchar', oprright => 'bpchar',
+  oprresult => 'bool', oprcom => '<=(bpchar,bpchar)',
+  oprnegate => '<(bpchar,bpchar)', oprcode => 'bpcharge',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+
+# generic array comparison operators
+{ oid => '1070', oid_symbol => 'ARRAY_EQ_OP', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprcanhash => 't', oprleft => 'anyarray',
+  oprright => 'anyarray', oprresult => 'bool', oprcom => '=(anyarray,anyarray)',
+  oprnegate => '<>(anyarray,anyarray)', oprcode => 'array_eq',
+  oprrest => 'eqsel', oprjoin => 'eqjoinsel' },
+{ oid => '1071', descr => 'not equal',
+  oprname => '<>', oprleft => 'anyarray', oprright => 'anyarray',
+  oprresult => 'bool', oprcom => '<>(anyarray,anyarray)',
+  oprnegate => '=(anyarray,anyarray)', oprcode => 'array_ne',
+  oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+{ oid => '1072', oid_symbol => 'ARRAY_LT_OP', descr => 'less than',
+  oprname => '<', oprleft => 'anyarray', oprright => 'anyarray',
+  oprresult => 'bool', oprcom => '>(anyarray,anyarray)',
+  oprnegate => '>=(anyarray,anyarray)', oprcode => 'array_lt',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '1073', oid_symbol => 'ARRAY_GT_OP', descr => 'greater than',
+  oprname => '>', oprleft => 'anyarray', oprright => 'anyarray',
+  oprresult => 'bool', oprcom => '<(anyarray,anyarray)',
+  oprnegate => '<=(anyarray,anyarray)', oprcode => 'array_gt',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '1074', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'anyarray', oprright => 'anyarray',
+  oprresult => 'bool', oprcom => '>=(anyarray,anyarray)',
+  oprnegate => '>(anyarray,anyarray)', oprcode => 'array_le',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '1075', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'anyarray', oprright => 'anyarray',
+  oprresult => 'bool', oprcom => '<=(anyarray,anyarray)',
+  oprnegate => '<(anyarray,anyarray)', oprcode => 'array_ge',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+
+# date operators
+{ oid => '1076', descr => 'add',
+  oprname => '+', oprleft => 'date', oprright => 'interval',
+  oprresult => 'timestamp', oprcom => '+(interval,date)',
+  oprcode => 'date_pl_interval' },
+{ oid => '1077', descr => 'subtract',
+  oprname => '-', oprleft => 'date', oprright => 'interval',
+  oprresult => 'timestamp', oprcode => 'date_mi_interval' },
+{ oid => '1093', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprcanhash => 't', oprleft => 'date',
+  oprright => 'date', oprresult => 'bool', oprcom => '=(date,date)',
+  oprnegate => '<>(date,date)', oprcode => 'date_eq', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+{ oid => '1094', descr => 'not equal',
+  oprname => '<>', oprleft => 'date', oprright => 'date', oprresult => 'bool',
+  oprcom => '<>(date,date)', oprnegate => '=(date,date)', oprcode => 'date_ne',
+  oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+{ oid => '1095', descr => 'less than',
+  oprname => '<', oprleft => 'date', oprright => 'date', oprresult => 'bool',
+  oprcom => '>(date,date)', oprnegate => '>=(date,date)', oprcode => 'date_lt',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '1096', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'date', oprright => 'date', oprresult => 'bool',
+  oprcom => '>=(date,date)', oprnegate => '>(date,date)', oprcode => 'date_le',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '1097', descr => 'greater than',
+  oprname => '>', oprleft => 'date', oprright => 'date', oprresult => 'bool',
+  oprcom => '<(date,date)', oprnegate => '<=(date,date)', oprcode => 'date_gt',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '1098', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'date', oprright => 'date', oprresult => 'bool',
+  oprcom => '<=(date,date)', oprnegate => '<(date,date)', oprcode => 'date_ge',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+{ oid => '1099', descr => 'subtract',
+  oprname => '-', oprleft => 'date', oprright => 'date', oprresult => 'int4',
+  oprcode => 'date_mi' },
+{ oid => '1100', descr => 'add',
+  oprname => '+', oprleft => 'date', oprright => 'int4', oprresult => 'date',
+  oprcom => '+(int4,date)', oprcode => 'date_pli' },
+{ oid => '1101', descr => 'subtract',
+  oprname => '-', oprleft => 'date', oprright => 'int4', oprresult => 'date',
+  oprcode => 'date_mii' },
+
+# time operators
+{ oid => '1108', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprcanhash => 't', oprleft => 'time',
+  oprright => 'time', oprresult => 'bool', oprcom => '=(time,time)',
+  oprnegate => '<>(time,time)', oprcode => 'time_eq', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+{ oid => '1109', descr => 'not equal',
+  oprname => '<>', oprleft => 'time', oprright => 'time', oprresult => 'bool',
+  oprcom => '<>(time,time)', oprnegate => '=(time,time)', oprcode => 'time_ne',
+  oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+{ oid => '1110', descr => 'less than',
+  oprname => '<', oprleft => 'time', oprright => 'time', oprresult => 'bool',
+  oprcom => '>(time,time)', oprnegate => '>=(time,time)', oprcode => 'time_lt',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '1111', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'time', oprright => 'time', oprresult => 'bool',
+  oprcom => '>=(time,time)', oprnegate => '>(time,time)', oprcode => 'time_le',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '1112', descr => 'greater than',
+  oprname => '>', oprleft => 'time', oprright => 'time', oprresult => 'bool',
+  oprcom => '<(time,time)', oprnegate => '<=(time,time)', oprcode => 'time_gt',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '1113', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'time', oprright => 'time', oprresult => 'bool',
+  oprcom => '<=(time,time)', oprnegate => '<(time,time)', oprcode => 'time_ge',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+
+# timetz operators
+{ oid => '1550', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprcanhash => 't', oprleft => 'timetz',
+  oprright => 'timetz', oprresult => 'bool', oprcom => '=(timetz,timetz)',
+  oprnegate => '<>(timetz,timetz)', oprcode => 'timetz_eq', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+{ oid => '1551', descr => 'not equal',
+  oprname => '<>', oprleft => 'timetz', oprright => 'timetz',
+  oprresult => 'bool', oprcom => '<>(timetz,timetz)',
+  oprnegate => '=(timetz,timetz)', oprcode => 'timetz_ne', oprrest => 'neqsel',
+  oprjoin => 'neqjoinsel' },
+{ oid => '1552', descr => 'less than',
+  oprname => '<', oprleft => 'timetz', oprright => 'timetz',
+  oprresult => 'bool', oprcom => '>(timetz,timetz)',
+  oprnegate => '>=(timetz,timetz)', oprcode => 'timetz_lt',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '1553', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'timetz', oprright => 'timetz',
+  oprresult => 'bool', oprcom => '>=(timetz,timetz)',
+  oprnegate => '>(timetz,timetz)', oprcode => 'timetz_le',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '1554', descr => 'greater than',
+  oprname => '>', oprleft => 'timetz', oprright => 'timetz',
+  oprresult => 'bool', oprcom => '<(timetz,timetz)',
+  oprnegate => '<=(timetz,timetz)', oprcode => 'timetz_gt',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '1555', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'timetz', oprright => 'timetz',
+  oprresult => 'bool', oprcom => '<=(timetz,timetz)',
+  oprnegate => '<(timetz,timetz)', oprcode => 'timetz_ge',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+
+# float48 operators
+{ oid => '1116', descr => 'add',
+  oprname => '+', oprleft => 'float4', oprright => 'float8',
+  oprresult => 'float8', oprcom => '+(float8,float4)', oprcode => 'float48pl' },
+{ oid => '1117', descr => 'subtract',
+  oprname => '-', oprleft => 'float4', oprright => 'float8',
+  oprresult => 'float8', oprcode => 'float48mi' },
+{ oid => '1118', descr => 'divide',
+  oprname => '/', oprleft => 'float4', oprright => 'float8',
+  oprresult => 'float8', oprcode => 'float48div' },
+{ oid => '1119', descr => 'multiply',
+  oprname => '*', oprleft => 'float4', oprright => 'float8',
+  oprresult => 'float8', oprcom => '*(float8,float4)',
+  oprcode => 'float48mul' },
+{ oid => '1120', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprcanhash => 't', oprleft => 'float4',
+  oprright => 'float8', oprresult => 'bool', oprcom => '=(float8,float4)',
+  oprnegate => '<>(float4,float8)', oprcode => 'float48eq', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+{ oid => '1121', descr => 'not equal',
+  oprname => '<>', oprleft => 'float4', oprright => 'float8',
+  oprresult => 'bool', oprcom => '<>(float8,float4)',
+  oprnegate => '=(float4,float8)', oprcode => 'float48ne', oprrest => 'neqsel',
+  oprjoin => 'neqjoinsel' },
+{ oid => '1122', descr => 'less than',
+  oprname => '<', oprleft => 'float4', oprright => 'float8',
+  oprresult => 'bool', oprcom => '>(float8,float4)',
+  oprnegate => '>=(float4,float8)', oprcode => 'float48lt',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '1123', descr => 'greater than',
+  oprname => '>', oprleft => 'float4', oprright => 'float8',
+  oprresult => 'bool', oprcom => '<(float8,float4)',
+  oprnegate => '<=(float4,float8)', oprcode => 'float48gt',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '1124', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'float4', oprright => 'float8',
+  oprresult => 'bool', oprcom => '>=(float8,float4)',
+  oprnegate => '>(float4,float8)', oprcode => 'float48le',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '1125', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'float4', oprright => 'float8',
+  oprresult => 'bool', oprcom => '<=(float8,float4)',
+  oprnegate => '<(float4,float8)', oprcode => 'float48ge',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+
+# float84 operators
+{ oid => '1126', descr => 'add',
+  oprname => '+', oprleft => 'float8', oprright => 'float4',
+  oprresult => 'float8', oprcom => '+(float4,float8)', oprcode => 'float84pl' },
+{ oid => '1127', descr => 'subtract',
+  oprname => '-', oprleft => 'float8', oprright => 'float4',
+  oprresult => 'float8', oprcode => 'float84mi' },
+{ oid => '1128', descr => 'divide',
+  oprname => '/', oprleft => 'float8', oprright => 'float4',
+  oprresult => 'float8', oprcode => 'float84div' },
+{ oid => '1129', descr => 'multiply',
+  oprname => '*', oprleft => 'float8', oprright => 'float4',
+  oprresult => 'float8', oprcom => '*(float4,float8)',
+  oprcode => 'float84mul' },
+{ oid => '1130', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprcanhash => 't', oprleft => 'float8',
+  oprright => 'float4', oprresult => 'bool', oprcom => '=(float4,float8)',
+  oprnegate => '<>(float8,float4)', oprcode => 'float84eq', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+{ oid => '1131', descr => 'not equal',
+  oprname => '<>', oprleft => 'float8', oprright => 'float4',
+  oprresult => 'bool', oprcom => '<>(float4,float8)',
+  oprnegate => '=(float8,float4)', oprcode => 'float84ne', oprrest => 'neqsel',
+  oprjoin => 'neqjoinsel' },
+{ oid => '1132', descr => 'less than',
+  oprname => '<', oprleft => 'float8', oprright => 'float4',
+  oprresult => 'bool', oprcom => '>(float4,float8)',
+  oprnegate => '>=(float8,float4)', oprcode => 'float84lt',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '1133', descr => 'greater than',
+  oprname => '>', oprleft => 'float8', oprright => 'float4',
+  oprresult => 'bool', oprcom => '<(float4,float8)',
+  oprnegate => '<=(float8,float4)', oprcode => 'float84gt',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '1134', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'float8', oprright => 'float4',
+  oprresult => 'bool', oprcom => '>=(float4,float8)',
+  oprnegate => '>(float8,float4)', oprcode => 'float84le',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '1135', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'float8', oprright => 'float4',
+  oprresult => 'bool', oprcom => '<=(float4,float8)',
+  oprnegate => '<(float8,float4)', oprcode => 'float84ge',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+
+# LIKE hacks by Keith Parks.
+{ oid => '1207', oid_symbol => 'OID_NAME_LIKE_OP',
+  descr => 'matches LIKE expression',
+  oprname => '~~', oprleft => 'name', oprright => 'text', oprresult => 'bool',
+  oprnegate => '!~~(name,text)', oprcode => 'namelike', oprrest => 'likesel',
+  oprjoin => 'likejoinsel' },
+{ oid => '1208', descr => 'does not match LIKE expression',
+  oprname => '!~~', oprleft => 'name', oprright => 'text', oprresult => 'bool',
+  oprnegate => '~~(name,text)', oprcode => 'namenlike', oprrest => 'nlikesel',
+  oprjoin => 'nlikejoinsel' },
+{ oid => '1209', oid_symbol => 'OID_TEXT_LIKE_OP',
+  descr => 'matches LIKE expression',
+  oprname => '~~', oprleft => 'text', oprright => 'text', oprresult => 'bool',
+  oprnegate => '!~~(text,text)', oprcode => 'textlike', oprrest => 'likesel',
+  oprjoin => 'likejoinsel' },
+{ oid => '1210', descr => 'does not match LIKE expression',
+  oprname => '!~~', oprleft => 'text', oprright => 'text', oprresult => 'bool',
+  oprnegate => '~~(text,text)', oprcode => 'textnlike', oprrest => 'nlikesel',
+  oprjoin => 'nlikejoinsel' },
+{ oid => '1211', oid_symbol => 'OID_BPCHAR_LIKE_OP',
+  descr => 'matches LIKE expression',
+  oprname => '~~', oprleft => 'bpchar', oprright => 'text', oprresult => 'bool',
+  oprnegate => '!~~(bpchar,text)', oprcode => 'bpcharlike',
+  oprrest => 'likesel', oprjoin => 'likejoinsel' },
+{ oid => '1212', descr => 'does not match LIKE expression',
+  oprname => '!~~', oprleft => 'bpchar', oprright => 'text',
+  oprresult => 'bool', oprnegate => '~~(bpchar,text)', oprcode => 'bpcharnlike',
+  oprrest => 'nlikesel', oprjoin => 'nlikejoinsel' },
+
+# case-insensitive regex hacks
+{ oid => '1226', oid_symbol => 'OID_NAME_ICREGEXEQ_OP',
+  descr => 'matches regular expression, case-insensitive',
+  oprname => '~*', oprleft => 'name', oprright => 'text', oprresult => 'bool',
+  oprnegate => '!~*(name,text)', oprcode => 'nameicregexeq',
+  oprrest => 'icregexeqsel', oprjoin => 'icregexeqjoinsel' },
+{ oid => '1227',
+  descr => 'does not match regular expression, case-insensitive',
+  oprname => '!~*', oprleft => 'name', oprright => 'text', oprresult => 'bool',
+  oprnegate => '~*(name,text)', oprcode => 'nameicregexne',
+  oprrest => 'icregexnesel', oprjoin => 'icregexnejoinsel' },
+{ oid => '1228', oid_symbol => 'OID_TEXT_ICREGEXEQ_OP',
+  descr => 'matches regular expression, case-insensitive',
+  oprname => '~*', oprleft => 'text', oprright => 'text', oprresult => 'bool',
+  oprnegate => '!~*(text,text)', oprcode => 'texticregexeq',
+  oprrest => 'icregexeqsel', oprjoin => 'icregexeqjoinsel' },
+{ oid => '1229',
+  descr => 'does not match regular expression, case-insensitive',
+  oprname => '!~*', oprleft => 'text', oprright => 'text', oprresult => 'bool',
+  oprnegate => '~*(text,text)', oprcode => 'texticregexne',
+  oprrest => 'icregexnesel', oprjoin => 'icregexnejoinsel' },
+{ oid => '1234', oid_symbol => 'OID_BPCHAR_ICREGEXEQ_OP',
+  descr => 'matches regular expression, case-insensitive',
+  oprname => '~*', oprleft => 'bpchar', oprright => 'text', oprresult => 'bool',
+  oprnegate => '!~*(bpchar,text)', oprcode => 'bpcharicregexeq',
+  oprrest => 'icregexeqsel', oprjoin => 'icregexeqjoinsel' },
+{ oid => '1235',
+  descr => 'does not match regular expression, case-insensitive',
+  oprname => '!~*', oprleft => 'bpchar', oprright => 'text',
+  oprresult => 'bool', oprnegate => '~*(bpchar,text)',
+  oprcode => 'bpcharicregexne', oprrest => 'icregexnesel',
+  oprjoin => 'icregexnejoinsel' },
+
+# timestamptz operators
+{ oid => '1320', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprcanhash => 't',
+  oprleft => 'timestamptz', oprright => 'timestamptz', oprresult => 'bool',
+  oprcom => '=(timestamptz,timestamptz)',
+  oprnegate => '<>(timestamptz,timestamptz)', oprcode => 'timestamptz_eq',
+  oprrest => 'eqsel', oprjoin => 'eqjoinsel' },
+{ oid => '1321', descr => 'not equal',
+  oprname => '<>', oprleft => 'timestamptz', oprright => 'timestamptz',
+  oprresult => 'bool', oprcom => '<>(timestamptz,timestamptz)',
+  oprnegate => '=(timestamptz,timestamptz)', oprcode => 'timestamptz_ne',
+  oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+{ oid => '1322', descr => 'less than',
+  oprname => '<', oprleft => 'timestamptz', oprright => 'timestamptz',
+  oprresult => 'bool', oprcom => '>(timestamptz,timestamptz)',
+  oprnegate => '>=(timestamptz,timestamptz)', oprcode => 'timestamptz_lt',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '1323', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'timestamptz', oprright => 'timestamptz',
+  oprresult => 'bool', oprcom => '>=(timestamptz,timestamptz)',
+  oprnegate => '>(timestamptz,timestamptz)', oprcode => 'timestamptz_le',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '1324', descr => 'greater than',
+  oprname => '>', oprleft => 'timestamptz', oprright => 'timestamptz',
+  oprresult => 'bool', oprcom => '<(timestamptz,timestamptz)',
+  oprnegate => '<=(timestamptz,timestamptz)', oprcode => 'timestamptz_gt',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '1325', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'timestamptz', oprright => 'timestamptz',
+  oprresult => 'bool', oprcom => '<=(timestamptz,timestamptz)',
+  oprnegate => '<(timestamptz,timestamptz)', oprcode => 'timestamptz_ge',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+{ oid => '1327', descr => 'add',
+  oprname => '+', oprleft => 'timestamptz', oprright => 'interval',
+  oprresult => 'timestamptz', oprcom => '+(interval,timestamptz)',
+  oprcode => 'timestamptz_pl_interval' },
+{ oid => '1328', descr => 'subtract',
+  oprname => '-', oprleft => 'timestamptz', oprright => 'timestamptz',
+  oprresult => 'interval', oprcode => 'timestamptz_mi' },
+{ oid => '1329', descr => 'subtract',
+  oprname => '-', oprleft => 'timestamptz', oprright => 'interval',
+  oprresult => 'timestamptz', oprcode => 'timestamptz_mi_interval' },
+
+# interval operators
+{ oid => '1330', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprcanhash => 't', oprleft => 'interval',
+  oprright => 'interval', oprresult => 'bool', oprcom => '=(interval,interval)',
+  oprnegate => '<>(interval,interval)', oprcode => 'interval_eq',
+  oprrest => 'eqsel', oprjoin => 'eqjoinsel' },
+{ oid => '1331', descr => 'not equal',
+  oprname => '<>', oprleft => 'interval', oprright => 'interval',
+  oprresult => 'bool', oprcom => '<>(interval,interval)',
+  oprnegate => '=(interval,interval)', oprcode => 'interval_ne',
+  oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+{ oid => '1332', descr => 'less than',
+  oprname => '<', oprleft => 'interval', oprright => 'interval',
+  oprresult => 'bool', oprcom => '>(interval,interval)',
+  oprnegate => '>=(interval,interval)', oprcode => 'interval_lt',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '1333', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'interval', oprright => 'interval',
+  oprresult => 'bool', oprcom => '>=(interval,interval)',
+  oprnegate => '>(interval,interval)', oprcode => 'interval_le',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '1334', descr => 'greater than',
+  oprname => '>', oprleft => 'interval', oprright => 'interval',
+  oprresult => 'bool', oprcom => '<(interval,interval)',
+  oprnegate => '<=(interval,interval)', oprcode => 'interval_gt',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '1335', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'interval', oprright => 'interval',
+  oprresult => 'bool', oprcom => '<=(interval,interval)',
+  oprnegate => '<(interval,interval)', oprcode => 'interval_ge',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+
+{ oid => '1336', descr => 'negate',
+  oprname => '-', oprkind => 'l', oprleft => '0', oprright => 'interval',
+  oprresult => 'interval', oprcode => 'interval_um' },
+{ oid => '1337', descr => 'add',
+  oprname => '+', oprleft => 'interval', oprright => 'interval',
+  oprresult => 'interval', oprcom => '+(interval,interval)',
+  oprcode => 'interval_pl' },
+{ oid => '1338', descr => 'subtract',
+  oprname => '-', oprleft => 'interval', oprright => 'interval',
+  oprresult => 'interval', oprcode => 'interval_mi' },
+
+{ oid => '1360', descr => 'convert date and time to timestamp',
+  oprname => '+', oprleft => 'date', oprright => 'time',
+  oprresult => 'timestamp', oprcom => '+(time,date)',
+  oprcode => 'datetime_pl' },
+{ oid => '1361',
+  descr => 'convert date and time with time zone to timestamp with time zone',
+  oprname => '+', oprleft => 'date', oprright => 'timetz',
+  oprresult => 'timestamptz', oprcom => '+(timetz,date)',
+  oprcode => 'datetimetz_pl' },
+{ oid => '1363', descr => 'convert time and date to timestamp',
+  oprname => '+', oprleft => 'time', oprright => 'date',
+  oprresult => 'timestamp', oprcom => '+(date,time)',
+  oprcode => 'timedate_pl' },
+{ oid => '1366',
+  descr => 'convert time with time zone and date to timestamp with time zone',
+  oprname => '+', oprleft => 'timetz', oprright => 'date',
+  oprresult => 'timestamptz', oprcom => '+(date,timetz)',
+  oprcode => 'timetzdate_pl' },
+
+{ oid => '1399', descr => 'subtract',
+  oprname => '-', oprleft => 'time', oprright => 'time',
+  oprresult => 'interval', oprcode => 'time_mi_time' },
+
+# additional geometric operators - thomas 97/04/18
+{ oid => '1420', descr => 'center of',
+  oprname => '@@', oprkind => 'l', oprleft => '0', oprright => 'circle',
+  oprresult => 'point', oprcode => 'circle_center' },
+{ oid => '1500', descr => 'equal by area',
+  oprname => '=', oprleft => 'circle', oprright => 'circle',
+  oprresult => 'bool', oprcom => '=(circle,circle)',
+  oprnegate => '<>(circle,circle)', oprcode => 'circle_eq', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+{ oid => '1501', descr => 'not equal by area',
+  oprname => '<>', oprleft => 'circle', oprright => 'circle',
+  oprresult => 'bool', oprcom => '<>(circle,circle)',
+  oprnegate => '=(circle,circle)', oprcode => 'circle_ne', oprrest => 'neqsel',
+  oprjoin => 'neqjoinsel' },
+{ oid => '1502', descr => 'less than by area',
+  oprname => '<', oprleft => 'circle', oprright => 'circle',
+  oprresult => 'bool', oprcom => '>(circle,circle)',
+  oprnegate => '>=(circle,circle)', oprcode => 'circle_lt',
+  oprrest => 'areasel', oprjoin => 'areajoinsel' },
+{ oid => '1503', descr => 'greater than by area',
+  oprname => '>', oprleft => 'circle', oprright => 'circle',
+  oprresult => 'bool', oprcom => '<(circle,circle)',
+  oprnegate => '<=(circle,circle)', oprcode => 'circle_gt',
+  oprrest => 'areasel', oprjoin => 'areajoinsel' },
+{ oid => '1504', descr => 'less than or equal by area',
+  oprname => '<=', oprleft => 'circle', oprright => 'circle',
+  oprresult => 'bool', oprcom => '>=(circle,circle)',
+  oprnegate => '>(circle,circle)', oprcode => 'circle_le', oprrest => 'areasel',
+  oprjoin => 'areajoinsel' },
+{ oid => '1505', descr => 'greater than or equal by area',
+  oprname => '>=', oprleft => 'circle', oprright => 'circle',
+  oprresult => 'bool', oprcom => '<=(circle,circle)',
+  oprnegate => '<(circle,circle)', oprcode => 'circle_ge', oprrest => 'areasel',
+  oprjoin => 'areajoinsel' },
+
+{ oid => '1506', descr => 'is left of',
+  oprname => '<<', oprleft => 'circle', oprright => 'circle',
+  oprresult => 'bool', oprcode => 'circle_left', oprrest => 'positionsel',
+  oprjoin => 'positionjoinsel' },
+{ oid => '1507', descr => 'overlaps or is left of',
+  oprname => '&<', oprleft => 'circle', oprright => 'circle',
+  oprresult => 'bool', oprcode => 'circle_overleft', oprrest => 'positionsel',
+  oprjoin => 'positionjoinsel' },
+{ oid => '1508', descr => 'overlaps or is right of',
+  oprname => '&>', oprleft => 'circle', oprright => 'circle',
+  oprresult => 'bool', oprcode => 'circle_overright', oprrest => 'positionsel',
+  oprjoin => 'positionjoinsel' },
+{ oid => '1509', descr => 'is right of',
+  oprname => '>>', oprleft => 'circle', oprright => 'circle',
+  oprresult => 'bool', oprcode => 'circle_right', oprrest => 'positionsel',
+  oprjoin => 'positionjoinsel' },
+{ oid => '1510', descr => 'is contained by',
+  oprname => '<@', oprleft => 'circle', oprright => 'circle',
+  oprresult => 'bool', oprcom => '@>(circle,circle)',
+  oprcode => 'circle_contained', oprrest => 'contsel',
+  oprjoin => 'contjoinsel' },
+{ oid => '1511', descr => 'contains',
+  oprname => '@>', oprleft => 'circle', oprright => 'circle',
+  oprresult => 'bool', oprcom => '<@(circle,circle)',
+  oprcode => 'circle_contain', oprrest => 'contsel', oprjoin => 'contjoinsel' },
+{ oid => '1512', descr => 'same as',
+  oprname => '~=', oprleft => 'circle', oprright => 'circle',
+  oprresult => 'bool', oprcom => '~=(circle,circle)', oprcode => 'circle_same',
+  oprrest => 'eqsel', oprjoin => 'eqjoinsel' },
+{ oid => '1513', descr => 'overlaps',
+  oprname => '&&', oprleft => 'circle', oprright => 'circle',
+  oprresult => 'bool', oprcom => '&&(circle,circle)',
+  oprcode => 'circle_overlap', oprrest => 'areasel', oprjoin => 'areajoinsel' },
+{ oid => '1514', descr => 'is above',
+  oprname => '|>>', oprleft => 'circle', oprright => 'circle',
+  oprresult => 'bool', oprcode => 'circle_above', oprrest => 'positionsel',
+  oprjoin => 'positionjoinsel' },
+{ oid => '1515', descr => 'is below',
+  oprname => '<<|', oprleft => 'circle', oprright => 'circle',
+  oprresult => 'bool', oprcode => 'circle_below', oprrest => 'positionsel',
+  oprjoin => 'positionjoinsel' },
+
+{ oid => '1516', descr => 'add',
+  oprname => '+', oprleft => 'circle', oprright => 'point',
+  oprresult => 'circle', oprcode => 'circle_add_pt' },
+{ oid => '1517', descr => 'subtract',
+  oprname => '-', oprleft => 'circle', oprright => 'point',
+  oprresult => 'circle', oprcode => 'circle_sub_pt' },
+{ oid => '1518', descr => 'multiply',
+  oprname => '*', oprleft => 'circle', oprright => 'point',
+  oprresult => 'circle', oprcode => 'circle_mul_pt' },
+{ oid => '1519', descr => 'divide',
+  oprname => '/', oprleft => 'circle', oprright => 'point',
+  oprresult => 'circle', oprcode => 'circle_div_pt' },
+
+{ oid => '1520', descr => 'distance between',
+  oprname => '<->', oprleft => 'circle', oprright => 'circle',
+  oprresult => 'float8', oprcom => '<->(circle,circle)',
+  oprcode => 'circle_distance' },
+{ oid => '1521', descr => 'number of points',
+  oprname => '#', oprkind => 'l', oprleft => '0', oprright => 'polygon',
+  oprresult => 'int4', oprcode => 'poly_npoints' },
+{ oid => '1522', descr => 'distance between',
+  oprname => '<->', oprleft => 'point', oprright => 'circle',
+  oprresult => 'float8', oprcom => '<->(circle,point)', oprcode => 'dist_pc' },
+{ oid => '3291', descr => 'distance between',
+  oprname => '<->', oprleft => 'circle', oprright => 'point',
+  oprresult => 'float8', oprcom => '<->(point,circle)',
+  oprcode => 'dist_cpoint' },
+{ oid => '3276', descr => 'distance between',
+  oprname => '<->', oprleft => 'point', oprright => 'polygon',
+  oprresult => 'float8', oprcom => '<->(polygon,point)',
+  oprcode => 'dist_ppoly' },
+{ oid => '3289', descr => 'distance between',
+  oprname => '<->', oprleft => 'polygon', oprright => 'point',
+  oprresult => 'float8', oprcom => '<->(point,polygon)',
+  oprcode => 'dist_polyp' },
+{ oid => '1523', descr => 'distance between',
+  oprname => '<->', oprleft => 'circle', oprright => 'polygon',
+  oprresult => 'float8', oprcom => '<->(polygon,circle)',
+  oprcode => 'dist_cpoly' },
+{ oid => '1383', descr => 'distance between',
+  oprname => '<->', oprleft => 'polygon', oprright => 'circle',
+  oprresult => 'float8', oprcom => '<->(circle,polygon)',
+  oprcode => 'dist_polyc' },
+
+# additional geometric operators - thomas 1997-07-09
+{ oid => '1524', descr => 'distance between',
+  oprname => '<->', oprleft => 'line', oprright => 'box', oprresult => 'float8',
+  oprcom => '<->(box,line)', oprcode => 'dist_lb' },
+{ oid => '1382', descr => 'distance between',
+  oprname => '<->', oprleft => 'box', oprright => 'line', oprresult => 'float8',
+  oprcom => '<->(line,box)', oprcode => 'dist_bl' },
+
+{ oid => '1525', descr => 'intersect',
+  oprname => '?#', oprleft => 'lseg', oprright => 'lseg', oprresult => 'bool',
+  oprcom => '?#(lseg,lseg)', oprcode => 'lseg_intersect' },
+{ oid => '1526', descr => 'parallel',
+  oprname => '?||', oprleft => 'lseg', oprright => 'lseg', oprresult => 'bool',
+  oprcom => '?||(lseg,lseg)', oprcode => 'lseg_parallel' },
+{ oid => '1527', descr => 'perpendicular',
+  oprname => '?-|', oprleft => 'lseg', oprright => 'lseg', oprresult => 'bool',
+  oprcom => '?-|(lseg,lseg)', oprcode => 'lseg_perp' },
+{ oid => '1528', descr => 'horizontal',
+  oprname => '?-', oprkind => 'l', oprleft => '0', oprright => 'lseg',
+  oprresult => 'bool', oprcode => 'lseg_horizontal' },
+{ oid => '1529', descr => 'vertical',
+  oprname => '?|', oprkind => 'l', oprleft => '0', oprright => 'lseg',
+  oprresult => 'bool', oprcode => 'lseg_vertical' },
+{ oid => '1535', descr => 'equal',
+  oprname => '=', oprleft => 'lseg', oprright => 'lseg', oprresult => 'bool',
+  oprcom => '=(lseg,lseg)', oprnegate => '<>(lseg,lseg)', oprcode => 'lseg_eq',
+  oprrest => 'eqsel', oprjoin => 'eqjoinsel' },
+{ oid => '1536', descr => 'intersection point',
+  oprname => '#', oprleft => 'lseg', oprright => 'lseg', oprresult => 'point',
+  oprcom => '#(lseg,lseg)', oprcode => 'lseg_interpt' },
+{ oid => '1537', descr => 'intersect',
+  oprname => '?#', oprleft => 'lseg', oprright => 'line', oprresult => 'bool',
+  oprcode => 'inter_sl' },
+{ oid => '1538', descr => 'intersect',
+  oprname => '?#', oprleft => 'lseg', oprright => 'box', oprresult => 'bool',
+  oprcode => 'inter_sb' },
+{ oid => '1539', descr => 'intersect',
+  oprname => '?#', oprleft => 'line', oprright => 'box', oprresult => 'bool',
+  oprcode => 'inter_lb' },
+
+{ oid => '1546', descr => 'point on line',
+  oprname => '<@', oprleft => 'point', oprright => 'line', oprresult => 'bool',
+  oprcode => 'on_pl' },
+{ oid => '1547', descr => 'is contained by',
+  oprname => '<@', oprleft => 'point', oprright => 'lseg', oprresult => 'bool',
+  oprcode => 'on_ps' },
+{ oid => '1548', descr => 'lseg on line',
+  oprname => '<@', oprleft => 'lseg', oprright => 'line', oprresult => 'bool',
+  oprcode => 'on_sl' },
+{ oid => '1549', descr => 'is contained by',
+  oprname => '<@', oprleft => 'lseg', oprright => 'box', oprresult => 'bool',
+  oprcode => 'on_sb' },
+
+{ oid => '1557', descr => 'closest point to A on B',
+  oprname => '##', oprleft => 'point', oprright => 'line', oprresult => 'point',
+  oprcode => 'close_pl' },
+{ oid => '1558', descr => 'closest point to A on B',
+  oprname => '##', oprleft => 'point', oprright => 'lseg', oprresult => 'point',
+  oprcode => 'close_ps' },
+{ oid => '1559', descr => 'closest point to A on B',
+  oprname => '##', oprleft => 'point', oprright => 'box', oprresult => 'point',
+  oprcode => 'close_pb' },
+
+{ oid => '1566', descr => 'closest point to A on B',
+  oprname => '##', oprleft => 'lseg', oprright => 'line', oprresult => 'point',
+  oprcode => 'close_sl' },
+{ oid => '1567', descr => 'closest point to A on B',
+  oprname => '##', oprleft => 'lseg', oprright => 'box', oprresult => 'point',
+  oprcode => 'close_sb' },
+{ oid => '1568', descr => 'closest point to A on B',
+  oprname => '##', oprleft => 'line', oprright => 'box', oprresult => 'point',
+  oprcode => 'close_lb' },
+{ oid => '1577', descr => 'closest point to A on B',
+  oprname => '##', oprleft => 'line', oprright => 'lseg', oprresult => 'point',
+  oprcode => 'close_ls' },
+{ oid => '1578', descr => 'closest point to A on B',
+  oprname => '##', oprleft => 'lseg', oprright => 'lseg', oprresult => 'point',
+  oprcode => 'close_lseg' },
+{ oid => '1583', descr => 'multiply',
+  oprname => '*', oprleft => 'interval', oprright => 'float8',
+  oprresult => 'interval', oprcom => '*(float8,interval)',
+  oprcode => 'interval_mul' },
+{ oid => '1584', descr => 'multiply',
+  oprname => '*', oprleft => 'float8', oprright => 'interval',
+  oprresult => 'interval', oprcom => '*(interval,float8)',
+  oprcode => 'mul_d_interval' },
+{ oid => '1585', descr => 'divide',
+  oprname => '/', oprleft => 'interval', oprright => 'float8',
+  oprresult => 'interval', oprcode => 'interval_div' },
+
+{ oid => '1586', descr => 'not equal',
+  oprname => '<>', oprleft => 'lseg', oprright => 'lseg', oprresult => 'bool',
+  oprcom => '<>(lseg,lseg)', oprnegate => '=(lseg,lseg)', oprcode => 'lseg_ne',
+  oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+{ oid => '1587', descr => 'less than by length',
+  oprname => '<', oprleft => 'lseg', oprright => 'lseg', oprresult => 'bool',
+  oprcom => '>(lseg,lseg)', oprnegate => '>=(lseg,lseg)',
+  oprcode => 'lseg_lt' },
+{ oid => '1588', descr => 'less than or equal by length',
+  oprname => '<=', oprleft => 'lseg', oprright => 'lseg', oprresult => 'bool',
+  oprcom => '>=(lseg,lseg)', oprnegate => '>(lseg,lseg)',
+  oprcode => 'lseg_le' },
+{ oid => '1589', descr => 'greater than by length',
+  oprname => '>', oprleft => 'lseg', oprright => 'lseg', oprresult => 'bool',
+  oprcom => '<(lseg,lseg)', oprnegate => '<=(lseg,lseg)',
+  oprcode => 'lseg_gt' },
+{ oid => '1590', descr => 'greater than or equal by length',
+  oprname => '>=', oprleft => 'lseg', oprright => 'lseg', oprresult => 'bool',
+  oprcom => '<=(lseg,lseg)', oprnegate => '<(lseg,lseg)',
+  oprcode => 'lseg_ge' },
+
+{ oid => '1591', descr => 'distance between endpoints',
+  oprname => '@-@', oprkind => 'l', oprleft => '0', oprright => 'lseg',
+  oprresult => 'float8', oprcode => 'lseg_length' },
+
+{ oid => '1611', descr => 'intersect',
+  oprname => '?#', oprleft => 'line', oprright => 'line', oprresult => 'bool',
+  oprcom => '?#(line,line)', oprcode => 'line_intersect' },
+{ oid => '1612', descr => 'parallel',
+  oprname => '?||', oprleft => 'line', oprright => 'line', oprresult => 'bool',
+  oprcom => '?||(line,line)', oprcode => 'line_parallel' },
+{ oid => '1613', descr => 'perpendicular',
+  oprname => '?-|', oprleft => 'line', oprright => 'line', oprresult => 'bool',
+  oprcom => '?-|(line,line)', oprcode => 'line_perp' },
+{ oid => '1614', descr => 'horizontal',
+  oprname => '?-', oprkind => 'l', oprleft => '0', oprright => 'line',
+  oprresult => 'bool', oprcode => 'line_horizontal' },
+{ oid => '1615', descr => 'vertical',
+  oprname => '?|', oprkind => 'l', oprleft => '0', oprright => 'line',
+  oprresult => 'bool', oprcode => 'line_vertical' },
+{ oid => '1616', descr => 'equal',
+  oprname => '=', oprleft => 'line', oprright => 'line', oprresult => 'bool',
+  oprcom => '=(line,line)', oprcode => 'line_eq', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+{ oid => '1617', descr => 'intersection point',
+  oprname => '#', oprleft => 'line', oprright => 'line', oprresult => 'point',
+  oprcom => '#(line,line)', oprcode => 'line_interpt' },
+
+# MACADDR type
+{ oid => '1220', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprcanhash => 't', oprleft => 'macaddr',
+  oprright => 'macaddr', oprresult => 'bool', oprcom => '=(macaddr,macaddr)',
+  oprnegate => '<>(macaddr,macaddr)', oprcode => 'macaddr_eq',
+  oprrest => 'eqsel', oprjoin => 'eqjoinsel' },
+{ oid => '1221', descr => 'not equal',
+  oprname => '<>', oprleft => 'macaddr', oprright => 'macaddr',
+  oprresult => 'bool', oprcom => '<>(macaddr,macaddr)',
+  oprnegate => '=(macaddr,macaddr)', oprcode => 'macaddr_ne',
+  oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+{ oid => '1222', descr => 'less than',
+  oprname => '<', oprleft => 'macaddr', oprright => 'macaddr',
+  oprresult => 'bool', oprcom => '>(macaddr,macaddr)',
+  oprnegate => '>=(macaddr,macaddr)', oprcode => 'macaddr_lt',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '1223', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'macaddr', oprright => 'macaddr',
+  oprresult => 'bool', oprcom => '>=(macaddr,macaddr)',
+  oprnegate => '>(macaddr,macaddr)', oprcode => 'macaddr_le',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '1224', descr => 'greater than',
+  oprname => '>', oprleft => 'macaddr', oprright => 'macaddr',
+  oprresult => 'bool', oprcom => '<(macaddr,macaddr)',
+  oprnegate => '<=(macaddr,macaddr)', oprcode => 'macaddr_gt',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '1225', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'macaddr', oprright => 'macaddr',
+  oprresult => 'bool', oprcom => '<=(macaddr,macaddr)',
+  oprnegate => '<(macaddr,macaddr)', oprcode => 'macaddr_ge',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+
+{ oid => '3147', descr => 'bitwise not',
+  oprname => '~', oprkind => 'l', oprleft => '0', oprright => 'macaddr',
+  oprresult => 'macaddr', oprcode => 'macaddr_not' },
+{ oid => '3148', descr => 'bitwise and',
+  oprname => '&', oprleft => 'macaddr', oprright => 'macaddr',
+  oprresult => 'macaddr', oprcode => 'macaddr_and' },
+{ oid => '3149', descr => 'bitwise or',
+  oprname => '|', oprleft => 'macaddr', oprright => 'macaddr',
+  oprresult => 'macaddr', oprcode => 'macaddr_or' },
+
+# MACADDR8 type
+{ oid => '3362', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprcanhash => 't', oprleft => 'macaddr8',
+  oprright => 'macaddr8', oprresult => 'bool', oprcom => '=(macaddr8,macaddr8)',
+  oprnegate => '<>(macaddr8,macaddr8)', oprcode => 'macaddr8_eq',
+  oprrest => 'eqsel', oprjoin => 'eqjoinsel' },
+{ oid => '3363', descr => 'not equal',
+  oprname => '<>', oprleft => 'macaddr8', oprright => 'macaddr8',
+  oprresult => 'bool', oprcom => '<>(macaddr8,macaddr8)',
+  oprnegate => '=(macaddr8,macaddr8)', oprcode => 'macaddr8_ne',
+  oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+{ oid => '3364', descr => 'less than',
+  oprname => '<', oprleft => 'macaddr8', oprright => 'macaddr8',
+  oprresult => 'bool', oprcom => '>(macaddr8,macaddr8)',
+  oprnegate => '>=(macaddr8,macaddr8)', oprcode => 'macaddr8_lt',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '3365', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'macaddr8', oprright => 'macaddr8',
+  oprresult => 'bool', oprcom => '>=(macaddr8,macaddr8)',
+  oprnegate => '>(macaddr8,macaddr8)', oprcode => 'macaddr8_le',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '3366', descr => 'greater than',
+  oprname => '>', oprleft => 'macaddr8', oprright => 'macaddr8',
+  oprresult => 'bool', oprcom => '<(macaddr8,macaddr8)',
+  oprnegate => '<=(macaddr8,macaddr8)', oprcode => 'macaddr8_gt',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '3367', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'macaddr8', oprright => 'macaddr8',
+  oprresult => 'bool', oprcom => '<=(macaddr8,macaddr8)',
+  oprnegate => '<(macaddr8,macaddr8)', oprcode => 'macaddr8_ge',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+
+{ oid => '3368', descr => 'bitwise not',
+  oprname => '~', oprkind => 'l', oprleft => '0', oprright => 'macaddr8',
+  oprresult => 'macaddr8', oprcode => 'macaddr8_not' },
+{ oid => '3369', descr => 'bitwise and',
+  oprname => '&', oprleft => 'macaddr8', oprright => 'macaddr8',
+  oprresult => 'macaddr8', oprcode => 'macaddr8_and' },
+{ oid => '3370', descr => 'bitwise or',
+  oprname => '|', oprleft => 'macaddr8', oprright => 'macaddr8',
+  oprresult => 'macaddr8', oprcode => 'macaddr8_or' },
+
+# INET type (these also support CIDR via implicit cast)
+{ oid => '1201', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprcanhash => 't', oprleft => 'inet',
+  oprright => 'inet', oprresult => 'bool', oprcom => '=(inet,inet)',
+  oprnegate => '<>(inet,inet)', oprcode => 'network_eq', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+{ oid => '1202', descr => 'not equal',
+  oprname => '<>', oprleft => 'inet', oprright => 'inet', oprresult => 'bool',
+  oprcom => '<>(inet,inet)', oprnegate => '=(inet,inet)',
+  oprcode => 'network_ne', oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+{ oid => '1203', descr => 'less than',
+  oprname => '<', oprleft => 'inet', oprright => 'inet', oprresult => 'bool',
+  oprcom => '>(inet,inet)', oprnegate => '>=(inet,inet)',
+  oprcode => 'network_lt', oprrest => 'scalarltsel',
+  oprjoin => 'scalarltjoinsel' },
+{ oid => '1204', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'inet', oprright => 'inet', oprresult => 'bool',
+  oprcom => '>=(inet,inet)', oprnegate => '>(inet,inet)',
+  oprcode => 'network_le', oprrest => 'scalarlesel',
+  oprjoin => 'scalarlejoinsel' },
+{ oid => '1205', descr => 'greater than',
+  oprname => '>', oprleft => 'inet', oprright => 'inet', oprresult => 'bool',
+  oprcom => '<(inet,inet)', oprnegate => '<=(inet,inet)',
+  oprcode => 'network_gt', oprrest => 'scalargtsel',
+  oprjoin => 'scalargtjoinsel' },
+{ oid => '1206', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'inet', oprright => 'inet', oprresult => 'bool',
+  oprcom => '<=(inet,inet)', oprnegate => '<(inet,inet)',
+  oprcode => 'network_ge', oprrest => 'scalargesel',
+  oprjoin => 'scalargejoinsel' },
+{ oid => '931', oid_symbol => 'OID_INET_SUB_OP', descr => 'is subnet',
+  oprname => '<<', oprleft => 'inet', oprright => 'inet', oprresult => 'bool',
+  oprcom => '>>(inet,inet)', oprcode => 'network_sub', oprrest => 'networksel',
+  oprjoin => 'networkjoinsel' },
+{ oid => '932', oid_symbol => 'OID_INET_SUBEQ_OP',
+  descr => 'is subnet or equal',
+  oprname => '<<=', oprleft => 'inet', oprright => 'inet', oprresult => 'bool',
+  oprcom => '>>=(inet,inet)', oprcode => 'network_subeq',
+  oprrest => 'networksel', oprjoin => 'networkjoinsel' },
+{ oid => '933', oid_symbol => 'OID_INET_SUP_OP', descr => 'is supernet',
+  oprname => '>>', oprleft => 'inet', oprright => 'inet', oprresult => 'bool',
+  oprcom => '<<(inet,inet)', oprcode => 'network_sup', oprrest => 'networksel',
+  oprjoin => 'networkjoinsel' },
+{ oid => '934', oid_symbol => 'OID_INET_SUPEQ_OP',
+  descr => 'is supernet or equal',
+  oprname => '>>=', oprleft => 'inet', oprright => 'inet', oprresult => 'bool',
+  oprcom => '<<=(inet,inet)', oprcode => 'network_supeq',
+  oprrest => 'networksel', oprjoin => 'networkjoinsel' },
+{ oid => '3552', oid_symbol => 'OID_INET_OVERLAP_OP',
+  descr => 'overlaps (is subnet or supernet)',
+  oprname => '&&', oprleft => 'inet', oprright => 'inet', oprresult => 'bool',
+  oprcom => '&&(inet,inet)', oprcode => 'network_overlap',
+  oprrest => 'networksel', oprjoin => 'networkjoinsel' },
+
+{ oid => '2634', descr => 'bitwise not',
+  oprname => '~', oprkind => 'l', oprleft => '0', oprright => 'inet',
+  oprresult => 'inet', oprcode => 'inetnot' },
+{ oid => '2635', descr => 'bitwise and',
+  oprname => '&', oprleft => 'inet', oprright => 'inet', oprresult => 'inet',
+  oprcode => 'inetand' },
+{ oid => '2636', descr => 'bitwise or',
+  oprname => '|', oprleft => 'inet', oprright => 'inet', oprresult => 'inet',
+  oprcode => 'inetor' },
+{ oid => '2637', descr => 'add',
+  oprname => '+', oprleft => 'inet', oprright => 'int8', oprresult => 'inet',
+  oprcom => '+(int8,inet)', oprcode => 'inetpl' },
+{ oid => '2638', descr => 'add',
+  oprname => '+', oprleft => 'int8', oprright => 'inet', oprresult => 'inet',
+  oprcom => '+(inet,int8)', oprcode => 'int8pl_inet' },
+{ oid => '2639', descr => 'subtract',
+  oprname => '-', oprleft => 'inet', oprright => 'int8', oprresult => 'inet',
+  oprcode => 'inetmi_int8' },
+{ oid => '2640', descr => 'subtract',
+  oprname => '-', oprleft => 'inet', oprright => 'inet', oprresult => 'int8',
+  oprcode => 'inetmi' },
+
+# case-insensitive LIKE hacks
+{ oid => '1625', oid_symbol => 'OID_NAME_ICLIKE_OP',
+  descr => 'matches LIKE expression, case-insensitive',
+  oprname => '~~*', oprleft => 'name', oprright => 'text', oprresult => 'bool',
+  oprnegate => '!~~*(name,text)', oprcode => 'nameiclike',
+  oprrest => 'iclikesel', oprjoin => 'iclikejoinsel' },
+{ oid => '1626', descr => 'does not match LIKE expression, case-insensitive',
+  oprname => '!~~*', oprleft => 'name', oprright => 'text', oprresult => 'bool',
+  oprnegate => '~~*(name,text)', oprcode => 'nameicnlike',
+  oprrest => 'icnlikesel', oprjoin => 'icnlikejoinsel' },
+{ oid => '1627', oid_symbol => 'OID_TEXT_ICLIKE_OP',
+  descr => 'matches LIKE expression, case-insensitive',
+  oprname => '~~*', oprleft => 'text', oprright => 'text', oprresult => 'bool',
+  oprnegate => '!~~*(text,text)', oprcode => 'texticlike',
+  oprrest => 'iclikesel', oprjoin => 'iclikejoinsel' },
+{ oid => '1628', descr => 'does not match LIKE expression, case-insensitive',
+  oprname => '!~~*', oprleft => 'text', oprright => 'text', oprresult => 'bool',
+  oprnegate => '~~*(text,text)', oprcode => 'texticnlike',
+  oprrest => 'icnlikesel', oprjoin => 'icnlikejoinsel' },
+{ oid => '1629', oid_symbol => 'OID_BPCHAR_ICLIKE_OP',
+  descr => 'matches LIKE expression, case-insensitive',
+  oprname => '~~*', oprleft => 'bpchar', oprright => 'text',
+  oprresult => 'bool', oprnegate => '!~~*(bpchar,text)',
+  oprcode => 'bpchariclike', oprrest => 'iclikesel',
+  oprjoin => 'iclikejoinsel' },
+{ oid => '1630', descr => 'does not match LIKE expression, case-insensitive',
+  oprname => '!~~*', oprleft => 'bpchar', oprright => 'text',
+  oprresult => 'bool', oprnegate => '~~*(bpchar,text)',
+  oprcode => 'bpcharicnlike', oprrest => 'icnlikesel',
+  oprjoin => 'icnlikejoinsel' },
+
+# NUMERIC type - OID's 1700-1799
+{ oid => '1751', descr => 'negate',
+  oprname => '-', oprkind => 'l', oprleft => '0', oprright => 'numeric',
+  oprresult => 'numeric', oprcode => 'numeric_uminus' },
+{ oid => '1752', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprcanhash => 't', oprleft => 'numeric',
+  oprright => 'numeric', oprresult => 'bool', oprcom => '=(numeric,numeric)',
+  oprnegate => '<>(numeric,numeric)', oprcode => 'numeric_eq',
+  oprrest => 'eqsel', oprjoin => 'eqjoinsel' },
+{ oid => '1753', descr => 'not equal',
+  oprname => '<>', oprleft => 'numeric', oprright => 'numeric',
+  oprresult => 'bool', oprcom => '<>(numeric,numeric)',
+  oprnegate => '=(numeric,numeric)', oprcode => 'numeric_ne',
+  oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+{ oid => '1754', descr => 'less than',
+  oprname => '<', oprleft => 'numeric', oprright => 'numeric',
+  oprresult => 'bool', oprcom => '>(numeric,numeric)',
+  oprnegate => '>=(numeric,numeric)', oprcode => 'numeric_lt',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '1755', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'numeric', oprright => 'numeric',
+  oprresult => 'bool', oprcom => '>=(numeric,numeric)',
+  oprnegate => '>(numeric,numeric)', oprcode => 'numeric_le',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '1756', descr => 'greater than',
+  oprname => '>', oprleft => 'numeric', oprright => 'numeric',
+  oprresult => 'bool', oprcom => '<(numeric,numeric)',
+  oprnegate => '<=(numeric,numeric)', oprcode => 'numeric_gt',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '1757', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'numeric', oprright => 'numeric',
+  oprresult => 'bool', oprcom => '<=(numeric,numeric)',
+  oprnegate => '<(numeric,numeric)', oprcode => 'numeric_ge',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+{ oid => '1758', descr => 'add',
+  oprname => '+', oprleft => 'numeric', oprright => 'numeric',
+  oprresult => 'numeric', oprcom => '+(numeric,numeric)',
+  oprcode => 'numeric_add' },
+{ oid => '1759', descr => 'subtract',
+  oprname => '-', oprleft => 'numeric', oprright => 'numeric',
+  oprresult => 'numeric', oprcode => 'numeric_sub' },
+{ oid => '1760', descr => 'multiply',
+  oprname => '*', oprleft => 'numeric', oprright => 'numeric',
+  oprresult => 'numeric', oprcom => '*(numeric,numeric)',
+  oprcode => 'numeric_mul' },
+{ oid => '1761', descr => 'divide',
+  oprname => '/', oprleft => 'numeric', oprright => 'numeric',
+  oprresult => 'numeric', oprcode => 'numeric_div' },
+{ oid => '1762', descr => 'modulus',
+  oprname => '%', oprleft => 'numeric', oprright => 'numeric',
+  oprresult => 'numeric', oprcode => 'numeric_mod' },
+{ oid => '1038', descr => 'exponentiation',
+  oprname => '^', oprleft => 'numeric', oprright => 'numeric',
+  oprresult => 'numeric', oprcode => 'numeric_power' },
+{ oid => '1763', descr => 'absolute value',
+  oprname => '@', oprkind => 'l', oprleft => '0', oprright => 'numeric',
+  oprresult => 'numeric', oprcode => 'numeric_abs' },
+
+{ oid => '1784', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprleft => 'bit', oprright => 'bit',
+  oprresult => 'bool', oprcom => '=(bit,bit)', oprnegate => '<>(bit,bit)',
+  oprcode => 'biteq', oprrest => 'eqsel', oprjoin => 'eqjoinsel' },
+{ oid => '1785', descr => 'not equal',
+  oprname => '<>', oprleft => 'bit', oprright => 'bit', oprresult => 'bool',
+  oprcom => '<>(bit,bit)', oprnegate => '=(bit,bit)', oprcode => 'bitne',
+  oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+{ oid => '1786', descr => 'less than',
+  oprname => '<', oprleft => 'bit', oprright => 'bit', oprresult => 'bool',
+  oprcom => '>(bit,bit)', oprnegate => '>=(bit,bit)', oprcode => 'bitlt',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '1787', descr => 'greater than',
+  oprname => '>', oprleft => 'bit', oprright => 'bit', oprresult => 'bool',
+  oprcom => '<(bit,bit)', oprnegate => '<=(bit,bit)', oprcode => 'bitgt',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '1788', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'bit', oprright => 'bit', oprresult => 'bool',
+  oprcom => '>=(bit,bit)', oprnegate => '>(bit,bit)', oprcode => 'bitle',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '1789', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'bit', oprright => 'bit', oprresult => 'bool',
+  oprcom => '<=(bit,bit)', oprnegate => '<(bit,bit)', oprcode => 'bitge',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+{ oid => '1791', descr => 'bitwise and',
+  oprname => '&', oprleft => 'bit', oprright => 'bit', oprresult => 'bit',
+  oprcom => '&(bit,bit)', oprcode => 'bitand' },
+{ oid => '1792', descr => 'bitwise or',
+  oprname => '|', oprleft => 'bit', oprright => 'bit', oprresult => 'bit',
+  oprcom => '|(bit,bit)', oprcode => 'bitor' },
+{ oid => '1793', descr => 'bitwise exclusive or',
+  oprname => '#', oprleft => 'bit', oprright => 'bit', oprresult => 'bit',
+  oprcom => '#(bit,bit)', oprcode => 'bitxor' },
+{ oid => '1794', descr => 'bitwise not',
+  oprname => '~', oprkind => 'l', oprleft => '0', oprright => 'bit',
+  oprresult => 'bit', oprcode => 'bitnot' },
+{ oid => '1795', descr => 'bitwise shift left',
+  oprname => '<<', oprleft => 'bit', oprright => 'int4', oprresult => 'bit',
+  oprcode => 'bitshiftleft' },
+{ oid => '1796', descr => 'bitwise shift right',
+  oprname => '>>', oprleft => 'bit', oprright => 'int4', oprresult => 'bit',
+  oprcode => 'bitshiftright' },
+{ oid => '1797', descr => 'concatenate',
+  oprname => '||', oprleft => 'varbit', oprright => 'varbit',
+  oprresult => 'varbit', oprcode => 'bitcat' },
+
+{ oid => '1800', descr => 'add',
+  oprname => '+', oprleft => 'time', oprright => 'interval',
+  oprresult => 'time', oprcom => '+(interval,time)',
+  oprcode => 'time_pl_interval' },
+{ oid => '1801', descr => 'subtract',
+  oprname => '-', oprleft => 'time', oprright => 'interval',
+  oprresult => 'time', oprcode => 'time_mi_interval' },
+{ oid => '1802', descr => 'add',
+  oprname => '+', oprleft => 'timetz', oprright => 'interval',
+  oprresult => 'timetz', oprcom => '+(interval,timetz)',
+  oprcode => 'timetz_pl_interval' },
+{ oid => '1803', descr => 'subtract',
+  oprname => '-', oprleft => 'timetz', oprright => 'interval',
+  oprresult => 'timetz', oprcode => 'timetz_mi_interval' },
+
+{ oid => '1804', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprleft => 'varbit', oprright => 'varbit',
+  oprresult => 'bool', oprcom => '=(varbit,varbit)',
+  oprnegate => '<>(varbit,varbit)', oprcode => 'varbiteq', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+{ oid => '1805', descr => 'not equal',
+  oprname => '<>', oprleft => 'varbit', oprright => 'varbit',
+  oprresult => 'bool', oprcom => '<>(varbit,varbit)',
+  oprnegate => '=(varbit,varbit)', oprcode => 'varbitne', oprrest => 'neqsel',
+  oprjoin => 'neqjoinsel' },
+{ oid => '1806', descr => 'less than',
+  oprname => '<', oprleft => 'varbit', oprright => 'varbit',
+  oprresult => 'bool', oprcom => '>(varbit,varbit)',
+  oprnegate => '>=(varbit,varbit)', oprcode => 'varbitlt',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '1807', descr => 'greater than',
+  oprname => '>', oprleft => 'varbit', oprright => 'varbit',
+  oprresult => 'bool', oprcom => '<(varbit,varbit)',
+  oprnegate => '<=(varbit,varbit)', oprcode => 'varbitgt',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '1808', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'varbit', oprright => 'varbit',
+  oprresult => 'bool', oprcom => '>=(varbit,varbit)',
+  oprnegate => '>(varbit,varbit)', oprcode => 'varbitle',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '1809', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'varbit', oprright => 'varbit',
+  oprresult => 'bool', oprcom => '<=(varbit,varbit)',
+  oprnegate => '<(varbit,varbit)', oprcode => 'varbitge',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+
+{ oid => '1849', descr => 'add',
+  oprname => '+', oprleft => 'interval', oprright => 'time',
+  oprresult => 'time', oprcom => '+(time,interval)',
+  oprcode => 'interval_pl_time' },
+
+{ oid => '1862', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprcanhash => 't', oprleft => 'int2',
+  oprright => 'int8', oprresult => 'bool', oprcom => '=(int8,int2)',
+  oprnegate => '<>(int2,int8)', oprcode => 'int28eq', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+{ oid => '1863', descr => 'not equal',
+  oprname => '<>', oprleft => 'int2', oprright => 'int8', oprresult => 'bool',
+  oprcom => '<>(int8,int2)', oprnegate => '=(int2,int8)', oprcode => 'int28ne',
+  oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+{ oid => '1864', descr => 'less than',
+  oprname => '<', oprleft => 'int2', oprright => 'int8', oprresult => 'bool',
+  oprcom => '>(int8,int2)', oprnegate => '>=(int2,int8)', oprcode => 'int28lt',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '1865', descr => 'greater than',
+  oprname => '>', oprleft => 'int2', oprright => 'int8', oprresult => 'bool',
+  oprcom => '<(int8,int2)', oprnegate => '<=(int2,int8)', oprcode => 'int28gt',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '1866', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'int2', oprright => 'int8', oprresult => 'bool',
+  oprcom => '>=(int8,int2)', oprnegate => '>(int2,int8)', oprcode => 'int28le',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '1867', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'int2', oprright => 'int8', oprresult => 'bool',
+  oprcom => '<=(int8,int2)', oprnegate => '<(int2,int8)', oprcode => 'int28ge',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+
+{ oid => '1868', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprcanhash => 't', oprleft => 'int8',
+  oprright => 'int2', oprresult => 'bool', oprcom => '=(int2,int8)',
+  oprnegate => '<>(int8,int2)', oprcode => 'int82eq', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+{ oid => '1869', descr => 'not equal',
+  oprname => '<>', oprleft => 'int8', oprright => 'int2', oprresult => 'bool',
+  oprcom => '<>(int2,int8)', oprnegate => '=(int8,int2)', oprcode => 'int82ne',
+  oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+{ oid => '1870', descr => 'less than',
+  oprname => '<', oprleft => 'int8', oprright => 'int2', oprresult => 'bool',
+  oprcom => '>(int2,int8)', oprnegate => '>=(int8,int2)', oprcode => 'int82lt',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '1871', descr => 'greater than',
+  oprname => '>', oprleft => 'int8', oprright => 'int2', oprresult => 'bool',
+  oprcom => '<(int2,int8)', oprnegate => '<=(int8,int2)', oprcode => 'int82gt',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '1872', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'int8', oprright => 'int2', oprresult => 'bool',
+  oprcom => '>=(int2,int8)', oprnegate => '>(int8,int2)', oprcode => 'int82le',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '1873', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'int8', oprright => 'int2', oprresult => 'bool',
+  oprcom => '<=(int2,int8)', oprnegate => '<(int8,int2)', oprcode => 'int82ge',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+
+{ oid => '1874', descr => 'bitwise and',
+  oprname => '&', oprleft => 'int2', oprright => 'int2', oprresult => 'int2',
+  oprcom => '&(int2,int2)', oprcode => 'int2and' },
+{ oid => '1875', descr => 'bitwise or',
+  oprname => '|', oprleft => 'int2', oprright => 'int2', oprresult => 'int2',
+  oprcom => '|(int2,int2)', oprcode => 'int2or' },
+{ oid => '1876', descr => 'bitwise exclusive or',
+  oprname => '#', oprleft => 'int2', oprright => 'int2', oprresult => 'int2',
+  oprcom => '#(int2,int2)', oprcode => 'int2xor' },
+{ oid => '1877', descr => 'bitwise not',
+  oprname => '~', oprkind => 'l', oprleft => '0', oprright => 'int2',
+  oprresult => 'int2', oprcode => 'int2not' },
+{ oid => '1878', descr => 'bitwise shift left',
+  oprname => '<<', oprleft => 'int2', oprright => 'int4', oprresult => 'int2',
+  oprcode => 'int2shl' },
+{ oid => '1879', descr => 'bitwise shift right',
+  oprname => '>>', oprleft => 'int2', oprright => 'int4', oprresult => 'int2',
+  oprcode => 'int2shr' },
+
+{ oid => '1880', descr => 'bitwise and',
+  oprname => '&', oprleft => 'int4', oprright => 'int4', oprresult => 'int4',
+  oprcom => '&(int4,int4)', oprcode => 'int4and' },
+{ oid => '1881', descr => 'bitwise or',
+  oprname => '|', oprleft => 'int4', oprright => 'int4', oprresult => 'int4',
+  oprcom => '|(int4,int4)', oprcode => 'int4or' },
+{ oid => '1882', descr => 'bitwise exclusive or',
+  oprname => '#', oprleft => 'int4', oprright => 'int4', oprresult => 'int4',
+  oprcom => '#(int4,int4)', oprcode => 'int4xor' },
+{ oid => '1883', descr => 'bitwise not',
+  oprname => '~', oprkind => 'l', oprleft => '0', oprright => 'int4',
+  oprresult => 'int4', oprcode => 'int4not' },
+{ oid => '1884', descr => 'bitwise shift left',
+  oprname => '<<', oprleft => 'int4', oprright => 'int4', oprresult => 'int4',
+  oprcode => 'int4shl' },
+{ oid => '1885', descr => 'bitwise shift right',
+  oprname => '>>', oprleft => 'int4', oprright => 'int4', oprresult => 'int4',
+  oprcode => 'int4shr' },
+
+{ oid => '1886', descr => 'bitwise and',
+  oprname => '&', oprleft => 'int8', oprright => 'int8', oprresult => 'int8',
+  oprcom => '&(int8,int8)', oprcode => 'int8and' },
+{ oid => '1887', descr => 'bitwise or',
+  oprname => '|', oprleft => 'int8', oprright => 'int8', oprresult => 'int8',
+  oprcom => '|(int8,int8)', oprcode => 'int8or' },
+{ oid => '1888', descr => 'bitwise exclusive or',
+  oprname => '#', oprleft => 'int8', oprright => 'int8', oprresult => 'int8',
+  oprcom => '#(int8,int8)', oprcode => 'int8xor' },
+{ oid => '1889', descr => 'bitwise not',
+  oprname => '~', oprkind => 'l', oprleft => '0', oprright => 'int8',
+  oprresult => 'int8', oprcode => 'int8not' },
+{ oid => '1890', descr => 'bitwise shift left',
+  oprname => '<<', oprleft => 'int8', oprright => 'int4', oprresult => 'int8',
+  oprcode => 'int8shl' },
+{ oid => '1891', descr => 'bitwise shift right',
+  oprname => '>>', oprleft => 'int8', oprright => 'int4', oprresult => 'int8',
+  oprcode => 'int8shr' },
+
+{ oid => '1916', descr => 'unary plus',
+  oprname => '+', oprkind => 'l', oprleft => '0', oprright => 'int8',
+  oprresult => 'int8', oprcode => 'int8up' },
+{ oid => '1917', descr => 'unary plus',
+  oprname => '+', oprkind => 'l', oprleft => '0', oprright => 'int2',
+  oprresult => 'int2', oprcode => 'int2up' },
+{ oid => '1918', descr => 'unary plus',
+  oprname => '+', oprkind => 'l', oprleft => '0', oprright => 'int4',
+  oprresult => 'int4', oprcode => 'int4up' },
+{ oid => '1919', descr => 'unary plus',
+  oprname => '+', oprkind => 'l', oprleft => '0', oprright => 'float4',
+  oprresult => 'float4', oprcode => 'float4up' },
+{ oid => '1920', descr => 'unary plus',
+  oprname => '+', oprkind => 'l', oprleft => '0', oprright => 'float8',
+  oprresult => 'float8', oprcode => 'float8up' },
+{ oid => '1921', descr => 'unary plus',
+  oprname => '+', oprkind => 'l', oprleft => '0', oprright => 'numeric',
+  oprresult => 'numeric', oprcode => 'numeric_uplus' },
+
+# bytea operators
+{ oid => '1955', oid_symbol => 'ByteaEqualOperator', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprcanhash => 't', oprleft => 'bytea',
+  oprright => 'bytea', oprresult => 'bool', oprcom => '=(bytea,bytea)',
+  oprnegate => '<>(bytea,bytea)', oprcode => 'byteaeq', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+{ oid => '1956', descr => 'not equal',
+  oprname => '<>', oprleft => 'bytea', oprright => 'bytea', oprresult => 'bool',
+  oprcom => '<>(bytea,bytea)', oprnegate => '=(bytea,bytea)',
+  oprcode => 'byteane', oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+{ oid => '1957', oid_symbol => 'ByteaLessOperator', descr => 'less than',
+  oprname => '<', oprleft => 'bytea', oprright => 'bytea', oprresult => 'bool',
+  oprcom => '>(bytea,bytea)', oprnegate => '>=(bytea,bytea)',
+  oprcode => 'bytealt', oprrest => 'scalarltsel',
+  oprjoin => 'scalarltjoinsel' },
+{ oid => '1958', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'bytea', oprright => 'bytea', oprresult => 'bool',
+  oprcom => '>=(bytea,bytea)', oprnegate => '>(bytea,bytea)',
+  oprcode => 'byteale', oprrest => 'scalarlesel',
+  oprjoin => 'scalarlejoinsel' },
+{ oid => '1959', descr => 'greater than',
+  oprname => '>', oprleft => 'bytea', oprright => 'bytea', oprresult => 'bool',
+  oprcom => '<(bytea,bytea)', oprnegate => '<=(bytea,bytea)',
+  oprcode => 'byteagt', oprrest => 'scalargtsel',
+  oprjoin => 'scalargtjoinsel' },
+{ oid => '1960', oid_symbol => 'ByteaGreaterEqualOperator',
+  descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'bytea', oprright => 'bytea', oprresult => 'bool',
+  oprcom => '<=(bytea,bytea)', oprnegate => '<(bytea,bytea)',
+  oprcode => 'byteage', oprrest => 'scalargesel',
+  oprjoin => 'scalargejoinsel' },
+
+{ oid => '2016', oid_symbol => 'OID_BYTEA_LIKE_OP',
+  descr => 'matches LIKE expression',
+  oprname => '~~', oprleft => 'bytea', oprright => 'bytea', oprresult => 'bool',
+  oprnegate => '!~~(bytea,bytea)', oprcode => 'bytealike', oprrest => 'likesel',
+  oprjoin => 'likejoinsel' },
+{ oid => '2017', descr => 'does not match LIKE expression',
+  oprname => '!~~', oprleft => 'bytea', oprright => 'bytea',
+  oprresult => 'bool', oprnegate => '~~(bytea,bytea)', oprcode => 'byteanlike',
+  oprrest => 'nlikesel', oprjoin => 'nlikejoinsel' },
+{ oid => '2018', descr => 'concatenate',
+  oprname => '||', oprleft => 'bytea', oprright => 'bytea',
+  oprresult => 'bytea', oprcode => 'byteacat' },
+
+# timestamp operators
+{ oid => '2060', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprcanhash => 't', oprleft => 'timestamp',
+  oprright => 'timestamp', oprresult => 'bool',
+  oprcom => '=(timestamp,timestamp)', oprnegate => '<>(timestamp,timestamp)',
+  oprcode => 'timestamp_eq', oprrest => 'eqsel', oprjoin => 'eqjoinsel' },
+{ oid => '2061', descr => 'not equal',
+  oprname => '<>', oprleft => 'timestamp', oprright => 'timestamp',
+  oprresult => 'bool', oprcom => '<>(timestamp,timestamp)',
+  oprnegate => '=(timestamp,timestamp)', oprcode => 'timestamp_ne',
+  oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+{ oid => '2062', descr => 'less than',
+  oprname => '<', oprleft => 'timestamp', oprright => 'timestamp',
+  oprresult => 'bool', oprcom => '>(timestamp,timestamp)',
+  oprnegate => '>=(timestamp,timestamp)', oprcode => 'timestamp_lt',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '2063', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'timestamp', oprright => 'timestamp',
+  oprresult => 'bool', oprcom => '>=(timestamp,timestamp)',
+  oprnegate => '>(timestamp,timestamp)', oprcode => 'timestamp_le',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '2064', descr => 'greater than',
+  oprname => '>', oprleft => 'timestamp', oprright => 'timestamp',
+  oprresult => 'bool', oprcom => '<(timestamp,timestamp)',
+  oprnegate => '<=(timestamp,timestamp)', oprcode => 'timestamp_gt',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '2065', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'timestamp', oprright => 'timestamp',
+  oprresult => 'bool', oprcom => '<=(timestamp,timestamp)',
+  oprnegate => '<(timestamp,timestamp)', oprcode => 'timestamp_ge',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+{ oid => '2066', descr => 'add',
+  oprname => '+', oprleft => 'timestamp', oprright => 'interval',
+  oprresult => 'timestamp', oprcom => '+(interval,timestamp)',
+  oprcode => 'timestamp_pl_interval' },
+{ oid => '2067', descr => 'subtract',
+  oprname => '-', oprleft => 'timestamp', oprright => 'timestamp',
+  oprresult => 'interval', oprcode => 'timestamp_mi' },
+{ oid => '2068', descr => 'subtract',
+  oprname => '-', oprleft => 'timestamp', oprright => 'interval',
+  oprresult => 'timestamp', oprcode => 'timestamp_mi_interval' },
+
+# character-by-character (not collation order) comparison operators for character types
+{ oid => '2314', oid_symbol => 'TextPatternLessOperator',
+  descr => 'less than',
+  oprname => '~<~', oprleft => 'text', oprright => 'text', oprresult => 'bool',
+  oprcom => '~>~(text,text)', oprnegate => '~>=~(text,text)',
+  oprcode => 'text_pattern_lt', oprrest => 'scalarltsel',
+  oprjoin => 'scalarltjoinsel' },
+{ oid => '2315', descr => 'less than or equal',
+  oprname => '~<=~', oprleft => 'text', oprright => 'text', oprresult => 'bool',
+  oprcom => '~>=~(text,text)', oprnegate => '~>~(text,text)',
+  oprcode => 'text_pattern_le', oprrest => 'scalarlesel',
+  oprjoin => 'scalarlejoinsel' },
+{ oid => '2317', oid_symbol => 'TextPatternGreaterEqualOperator',
+  descr => 'greater than or equal',
+  oprname => '~>=~', oprleft => 'text', oprright => 'text', oprresult => 'bool',
+  oprcom => '~<=~(text,text)', oprnegate => '~<~(text,text)',
+  oprcode => 'text_pattern_ge', oprrest => 'scalargesel',
+  oprjoin => 'scalargejoinsel' },
+{ oid => '2318', descr => 'greater than',
+  oprname => '~>~', oprleft => 'text', oprright => 'text', oprresult => 'bool',
+  oprcom => '~<~(text,text)', oprnegate => '~<=~(text,text)',
+  oprcode => 'text_pattern_gt', oprrest => 'scalargtsel',
+  oprjoin => 'scalargtjoinsel' },
+
+{ oid => '2326', oid_symbol => 'BpcharPatternLessOperator',
+  descr => 'less than',
+  oprname => '~<~', oprleft => 'bpchar', oprright => 'bpchar',
+  oprresult => 'bool', oprcom => '~>~(bpchar,bpchar)',
+  oprnegate => '~>=~(bpchar,bpchar)', oprcode => 'bpchar_pattern_lt',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '2327', descr => 'less than or equal',
+  oprname => '~<=~', oprleft => 'bpchar', oprright => 'bpchar',
+  oprresult => 'bool', oprcom => '~>=~(bpchar,bpchar)',
+  oprnegate => '~>~(bpchar,bpchar)', oprcode => 'bpchar_pattern_le',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '2329', oid_symbol => 'BpcharPatternGreaterEqualOperator',
+  descr => 'greater than or equal',
+  oprname => '~>=~', oprleft => 'bpchar', oprright => 'bpchar',
+  oprresult => 'bool', oprcom => '~<=~(bpchar,bpchar)',
+  oprnegate => '~<~(bpchar,bpchar)', oprcode => 'bpchar_pattern_ge',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+{ oid => '2330', descr => 'greater than',
+  oprname => '~>~', oprleft => 'bpchar', oprright => 'bpchar',
+  oprresult => 'bool', oprcom => '~<~(bpchar,bpchar)',
+  oprnegate => '~<=~(bpchar,bpchar)', oprcode => 'bpchar_pattern_gt',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+
+# crosstype operations for date vs. timestamp and timestamptz
+{ oid => '2345', descr => 'less than',
+  oprname => '<', oprleft => 'date', oprright => 'timestamp',
+  oprresult => 'bool', oprcom => '>(timestamp,date)',
+  oprnegate => '>=(date,timestamp)', oprcode => 'date_lt_timestamp',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '2346', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'date', oprright => 'timestamp',
+  oprresult => 'bool', oprcom => '>=(timestamp,date)',
+  oprnegate => '>(date,timestamp)', oprcode => 'date_le_timestamp',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '2347', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprleft => 'date',
+  oprright => 'timestamp', oprresult => 'bool', oprcom => '=(timestamp,date)',
+  oprnegate => '<>(date,timestamp)', oprcode => 'date_eq_timestamp',
+  oprrest => 'eqsel', oprjoin => 'eqjoinsel' },
+{ oid => '2348', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'date', oprright => 'timestamp',
+  oprresult => 'bool', oprcom => '<=(timestamp,date)',
+  oprnegate => '<(date,timestamp)', oprcode => 'date_ge_timestamp',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+{ oid => '2349', descr => 'greater than',
+  oprname => '>', oprleft => 'date', oprright => 'timestamp',
+  oprresult => 'bool', oprcom => '<(timestamp,date)',
+  oprnegate => '<=(date,timestamp)', oprcode => 'date_gt_timestamp',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '2350', descr => 'not equal',
+  oprname => '<>', oprleft => 'date', oprright => 'timestamp',
+  oprresult => 'bool', oprcom => '<>(timestamp,date)',
+  oprnegate => '=(date,timestamp)', oprcode => 'date_ne_timestamp',
+  oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+
+{ oid => '2358', descr => 'less than',
+  oprname => '<', oprleft => 'date', oprright => 'timestamptz',
+  oprresult => 'bool', oprcom => '>(timestamptz,date)',
+  oprnegate => '>=(date,timestamptz)', oprcode => 'date_lt_timestamptz',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '2359', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'date', oprright => 'timestamptz',
+  oprresult => 'bool', oprcom => '>=(timestamptz,date)',
+  oprnegate => '>(date,timestamptz)', oprcode => 'date_le_timestamptz',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '2360', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprleft => 'date',
+  oprright => 'timestamptz', oprresult => 'bool',
+  oprcom => '=(timestamptz,date)', oprnegate => '<>(date,timestamptz)',
+  oprcode => 'date_eq_timestamptz', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+{ oid => '2361', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'date', oprright => 'timestamptz',
+  oprresult => 'bool', oprcom => '<=(timestamptz,date)',
+  oprnegate => '<(date,timestamptz)', oprcode => 'date_ge_timestamptz',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+{ oid => '2362', descr => 'greater than',
+  oprname => '>', oprleft => 'date', oprright => 'timestamptz',
+  oprresult => 'bool', oprcom => '<(timestamptz,date)',
+  oprnegate => '<=(date,timestamptz)', oprcode => 'date_gt_timestamptz',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '2363', descr => 'not equal',
+  oprname => '<>', oprleft => 'date', oprright => 'timestamptz',
+  oprresult => 'bool', oprcom => '<>(timestamptz,date)',
+  oprnegate => '=(date,timestamptz)', oprcode => 'date_ne_timestamptz',
+  oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+
+{ oid => '2371', descr => 'less than',
+  oprname => '<', oprleft => 'timestamp', oprright => 'date',
+  oprresult => 'bool', oprcom => '>(date,timestamp)',
+  oprnegate => '>=(timestamp,date)', oprcode => 'timestamp_lt_date',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '2372', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'timestamp', oprright => 'date',
+  oprresult => 'bool', oprcom => '>=(date,timestamp)',
+  oprnegate => '>(timestamp,date)', oprcode => 'timestamp_le_date',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '2373', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprleft => 'timestamp',
+  oprright => 'date', oprresult => 'bool', oprcom => '=(date,timestamp)',
+  oprnegate => '<>(timestamp,date)', oprcode => 'timestamp_eq_date',
+  oprrest => 'eqsel', oprjoin => 'eqjoinsel' },
+{ oid => '2374', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'timestamp', oprright => 'date',
+  oprresult => 'bool', oprcom => '<=(date,timestamp)',
+  oprnegate => '<(timestamp,date)', oprcode => 'timestamp_ge_date',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+{ oid => '2375', descr => 'greater than',
+  oprname => '>', oprleft => 'timestamp', oprright => 'date',
+  oprresult => 'bool', oprcom => '<(date,timestamp)',
+  oprnegate => '<=(timestamp,date)', oprcode => 'timestamp_gt_date',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '2376', descr => 'not equal',
+  oprname => '<>', oprleft => 'timestamp', oprright => 'date',
+  oprresult => 'bool', oprcom => '<>(date,timestamp)',
+  oprnegate => '=(timestamp,date)', oprcode => 'timestamp_ne_date',
+  oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+
+{ oid => '2384', descr => 'less than',
+  oprname => '<', oprleft => 'timestamptz', oprright => 'date',
+  oprresult => 'bool', oprcom => '>(date,timestamptz)',
+  oprnegate => '>=(timestamptz,date)', oprcode => 'timestamptz_lt_date',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '2385', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'timestamptz', oprright => 'date',
+  oprresult => 'bool', oprcom => '>=(date,timestamptz)',
+  oprnegate => '>(timestamptz,date)', oprcode => 'timestamptz_le_date',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '2386', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprleft => 'timestamptz',
+  oprright => 'date', oprresult => 'bool', oprcom => '=(date,timestamptz)',
+  oprnegate => '<>(timestamptz,date)', oprcode => 'timestamptz_eq_date',
+  oprrest => 'eqsel', oprjoin => 'eqjoinsel' },
+{ oid => '2387', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'timestamptz', oprright => 'date',
+  oprresult => 'bool', oprcom => '<=(date,timestamptz)',
+  oprnegate => '<(timestamptz,date)', oprcode => 'timestamptz_ge_date',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+{ oid => '2388', descr => 'greater than',
+  oprname => '>', oprleft => 'timestamptz', oprright => 'date',
+  oprresult => 'bool', oprcom => '<(date,timestamptz)',
+  oprnegate => '<=(timestamptz,date)', oprcode => 'timestamptz_gt_date',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '2389', descr => 'not equal',
+  oprname => '<>', oprleft => 'timestamptz', oprright => 'date',
+  oprresult => 'bool', oprcom => '<>(date,timestamptz)',
+  oprnegate => '=(timestamptz,date)', oprcode => 'timestamptz_ne_date',
+  oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+
+# crosstype operations for timestamp vs. timestamptz
+{ oid => '2534', descr => 'less than',
+  oprname => '<', oprleft => 'timestamp', oprright => 'timestamptz',
+  oprresult => 'bool', oprcom => '>(timestamptz,timestamp)',
+  oprnegate => '>=(timestamp,timestamptz)',
+  oprcode => 'timestamp_lt_timestamptz', oprrest => 'scalarltsel',
+  oprjoin => 'scalarltjoinsel' },
+{ oid => '2535', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'timestamp', oprright => 'timestamptz',
+  oprresult => 'bool', oprcom => '>=(timestamptz,timestamp)',
+  oprnegate => '>(timestamp,timestamptz)',
+  oprcode => 'timestamp_le_timestamptz', oprrest => 'scalarlesel',
+  oprjoin => 'scalarlejoinsel' },
+{ oid => '2536', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprleft => 'timestamp',
+  oprright => 'timestamptz', oprresult => 'bool',
+  oprcom => '=(timestamptz,timestamp)',
+  oprnegate => '<>(timestamp,timestamptz)',
+  oprcode => 'timestamp_eq_timestamptz', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+{ oid => '2537', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'timestamp', oprright => 'timestamptz',
+  oprresult => 'bool', oprcom => '<=(timestamptz,timestamp)',
+  oprnegate => '<(timestamp,timestamptz)',
+  oprcode => 'timestamp_ge_timestamptz', oprrest => 'scalargesel',
+  oprjoin => 'scalargejoinsel' },
+{ oid => '2538', descr => 'greater than',
+  oprname => '>', oprleft => 'timestamp', oprright => 'timestamptz',
+  oprresult => 'bool', oprcom => '<(timestamptz,timestamp)',
+  oprnegate => '<=(timestamp,timestamptz)',
+  oprcode => 'timestamp_gt_timestamptz', oprrest => 'scalargtsel',
+  oprjoin => 'scalargtjoinsel' },
+{ oid => '2539', descr => 'not equal',
+  oprname => '<>', oprleft => 'timestamp', oprright => 'timestamptz',
+  oprresult => 'bool', oprcom => '<>(timestamptz,timestamp)',
+  oprnegate => '=(timestamp,timestamptz)',
+  oprcode => 'timestamp_ne_timestamptz', oprrest => 'neqsel',
+  oprjoin => 'neqjoinsel' },
+
+{ oid => '2540', descr => 'less than',
+  oprname => '<', oprleft => 'timestamptz', oprright => 'timestamp',
+  oprresult => 'bool', oprcom => '>(timestamp,timestamptz)',
+  oprnegate => '>=(timestamptz,timestamp)',
+  oprcode => 'timestamptz_lt_timestamp', oprrest => 'scalarltsel',
+  oprjoin => 'scalarltjoinsel' },
+{ oid => '2541', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'timestamptz', oprright => 'timestamp',
+  oprresult => 'bool', oprcom => '>=(timestamp,timestamptz)',
+  oprnegate => '>(timestamptz,timestamp)',
+  oprcode => 'timestamptz_le_timestamp', oprrest => 'scalarlesel',
+  oprjoin => 'scalarlejoinsel' },
+{ oid => '2542', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprleft => 'timestamptz',
+  oprright => 'timestamp', oprresult => 'bool',
+  oprcom => '=(timestamp,timestamptz)',
+  oprnegate => '<>(timestamptz,timestamp)',
+  oprcode => 'timestamptz_eq_timestamp', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+{ oid => '2543', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'timestamptz', oprright => 'timestamp',
+  oprresult => 'bool', oprcom => '<=(timestamp,timestamptz)',
+  oprnegate => '<(timestamptz,timestamp)',
+  oprcode => 'timestamptz_ge_timestamp', oprrest => 'scalargesel',
+  oprjoin => 'scalargejoinsel' },
+{ oid => '2544', descr => 'greater than',
+  oprname => '>', oprleft => 'timestamptz', oprright => 'timestamp',
+  oprresult => 'bool', oprcom => '<(timestamp,timestamptz)',
+  oprnegate => '<=(timestamptz,timestamp)',
+  oprcode => 'timestamptz_gt_timestamp', oprrest => 'scalargtsel',
+  oprjoin => 'scalargtjoinsel' },
+{ oid => '2545', descr => 'not equal',
+  oprname => '<>', oprleft => 'timestamptz', oprright => 'timestamp',
+  oprresult => 'bool', oprcom => '<>(timestamp,timestamptz)',
+  oprnegate => '=(timestamptz,timestamp)',
+  oprcode => 'timestamptz_ne_timestamp', oprrest => 'neqsel',
+  oprjoin => 'neqjoinsel' },
+
+# formerly-missing interval + datetime operators
+{ oid => '2551', descr => 'add',
+  oprname => '+', oprleft => 'interval', oprright => 'date',
+  oprresult => 'timestamp', oprcom => '+(date,interval)',
+  oprcode => 'interval_pl_date' },
+{ oid => '2552', descr => 'add',
+  oprname => '+', oprleft => 'interval', oprright => 'timetz',
+  oprresult => 'timetz', oprcom => '+(timetz,interval)',
+  oprcode => 'interval_pl_timetz' },
+{ oid => '2553', descr => 'add',
+  oprname => '+', oprleft => 'interval', oprright => 'timestamp',
+  oprresult => 'timestamp', oprcom => '+(timestamp,interval)',
+  oprcode => 'interval_pl_timestamp' },
+{ oid => '2554', descr => 'add',
+  oprname => '+', oprleft => 'interval', oprright => 'timestamptz',
+  oprresult => 'timestamptz', oprcom => '+(timestamptz,interval)',
+  oprcode => 'interval_pl_timestamptz' },
+{ oid => '2555', descr => 'add',
+  oprname => '+', oprleft => 'int4', oprright => 'date', oprresult => 'date',
+  oprcom => '+(date,int4)', oprcode => 'integer_pl_date' },
+
+# new operators for Y-direction rtree opfamilies
+{ oid => '2570', descr => 'is below',
+  oprname => '<<|', oprleft => 'box', oprright => 'box', oprresult => 'bool',
+  oprcode => 'box_below', oprrest => 'positionsel',
+  oprjoin => 'positionjoinsel' },
+{ oid => '2571', descr => 'overlaps or is below',
+  oprname => '&<|', oprleft => 'box', oprright => 'box', oprresult => 'bool',
+  oprcode => 'box_overbelow', oprrest => 'positionsel',
+  oprjoin => 'positionjoinsel' },
+{ oid => '2572', descr => 'overlaps or is above',
+  oprname => '|&>', oprleft => 'box', oprright => 'box', oprresult => 'bool',
+  oprcode => 'box_overabove', oprrest => 'positionsel',
+  oprjoin => 'positionjoinsel' },
+{ oid => '2573', descr => 'is above',
+  oprname => '|>>', oprleft => 'box', oprright => 'box', oprresult => 'bool',
+  oprcode => 'box_above', oprrest => 'positionsel',
+  oprjoin => 'positionjoinsel' },
+{ oid => '2574', descr => 'is below',
+  oprname => '<<|', oprleft => 'polygon', oprright => 'polygon',
+  oprresult => 'bool', oprcode => 'poly_below', oprrest => 'positionsel',
+  oprjoin => 'positionjoinsel' },
+{ oid => '2575', descr => 'overlaps or is below',
+  oprname => '&<|', oprleft => 'polygon', oprright => 'polygon',
+  oprresult => 'bool', oprcode => 'poly_overbelow', oprrest => 'positionsel',
+  oprjoin => 'positionjoinsel' },
+{ oid => '2576', descr => 'overlaps or is above',
+  oprname => '|&>', oprleft => 'polygon', oprright => 'polygon',
+  oprresult => 'bool', oprcode => 'poly_overabove', oprrest => 'positionsel',
+  oprjoin => 'positionjoinsel' },
+{ oid => '2577', descr => 'is above',
+  oprname => '|>>', oprleft => 'polygon', oprright => 'polygon',
+  oprresult => 'bool', oprcode => 'poly_above', oprrest => 'positionsel',
+  oprjoin => 'positionjoinsel' },
+{ oid => '2589', descr => 'overlaps or is below',
+  oprname => '&<|', oprleft => 'circle', oprright => 'circle',
+  oprresult => 'bool', oprcode => 'circle_overbelow', oprrest => 'positionsel',
+  oprjoin => 'positionjoinsel' },
+{ oid => '2590', descr => 'overlaps or is above',
+  oprname => '|&>', oprleft => 'circle', oprright => 'circle',
+  oprresult => 'bool', oprcode => 'circle_overabove', oprrest => 'positionsel',
+  oprjoin => 'positionjoinsel' },
+
+# overlap/contains/contained for arrays
+{ oid => '2750', oid_symbol => 'OID_ARRAY_OVERLAP_OP', descr => 'overlaps',
+  oprname => '&&', oprleft => 'anyarray', oprright => 'anyarray',
+  oprresult => 'bool', oprcom => '&&(anyarray,anyarray)',
+  oprcode => 'arrayoverlap', oprrest => 'arraycontsel',
+  oprjoin => 'arraycontjoinsel' },
+{ oid => '2751', oid_symbol => 'OID_ARRAY_CONTAINS_OP', descr => 'contains',
+  oprname => '@>', oprleft => 'anyarray', oprright => 'anyarray',
+  oprresult => 'bool', oprcom => '<@(anyarray,anyarray)',
+  oprcode => 'arraycontains', oprrest => 'arraycontsel',
+  oprjoin => 'arraycontjoinsel' },
+{ oid => '2752', oid_symbol => 'OID_ARRAY_CONTAINED_OP',
+  descr => 'is contained by',
+  oprname => '<@', oprleft => 'anyarray', oprright => 'anyarray',
+  oprresult => 'bool', oprcom => '@>(anyarray,anyarray)',
+  oprcode => 'arraycontained', oprrest => 'arraycontsel',
+  oprjoin => 'arraycontjoinsel' },
+
+# capturing operators to preserve pre-8.3 behavior of text concatenation
+{ oid => '2779', descr => 'concatenate',
+  oprname => '||', oprleft => 'text', oprright => 'anynonarray',
+  oprresult => 'text', oprcode => 'textanycat' },
+{ oid => '2780', descr => 'concatenate',
+  oprname => '||', oprleft => 'anynonarray', oprright => 'text',
+  oprresult => 'text', oprcode => 'anytextcat' },
+
+# obsolete names for contains/contained-by operators; remove these someday
+{ oid => '2860', descr => 'deprecated, use <@ instead',
+  oprname => '@', oprleft => 'polygon', oprright => 'polygon',
+  oprresult => 'bool', oprcom => '~(polygon,polygon)',
+  oprcode => 'poly_contained', oprrest => 'contsel', oprjoin => 'contjoinsel' },
+{ oid => '2861', descr => 'deprecated, use @> instead',
+  oprname => '~', oprleft => 'polygon', oprright => 'polygon',
+  oprresult => 'bool', oprcom => '@(polygon,polygon)',
+  oprcode => 'poly_contain', oprrest => 'contsel', oprjoin => 'contjoinsel' },
+{ oid => '2862', descr => 'deprecated, use <@ instead',
+  oprname => '@', oprleft => 'box', oprright => 'box', oprresult => 'bool',
+  oprcom => '~(box,box)', oprcode => 'box_contained', oprrest => 'contsel',
+  oprjoin => 'contjoinsel' },
+{ oid => '2863', descr => 'deprecated, use @> instead',
+  oprname => '~', oprleft => 'box', oprright => 'box', oprresult => 'bool',
+  oprcom => '@(box,box)', oprcode => 'box_contain', oprrest => 'contsel',
+  oprjoin => 'contjoinsel' },
+{ oid => '2864', descr => 'deprecated, use <@ instead',
+  oprname => '@', oprleft => 'circle', oprright => 'circle',
+  oprresult => 'bool', oprcom => '~(circle,circle)',
+  oprcode => 'circle_contained', oprrest => 'contsel',
+  oprjoin => 'contjoinsel' },
+{ oid => '2865', descr => 'deprecated, use @> instead',
+  oprname => '~', oprleft => 'circle', oprright => 'circle',
+  oprresult => 'bool', oprcom => '@(circle,circle)',
+  oprcode => 'circle_contain', oprrest => 'contsel', oprjoin => 'contjoinsel' },
+{ oid => '2866', descr => 'deprecated, use <@ instead',
+  oprname => '@', oprleft => 'point', oprright => 'box', oprresult => 'bool',
+  oprcode => 'on_pb' },
+{ oid => '2867', descr => 'deprecated, use <@ instead',
+  oprname => '@', oprleft => 'point', oprright => 'path', oprresult => 'bool',
+  oprcom => '~(path,point)', oprcode => 'on_ppath' },
+{ oid => '2868', descr => 'deprecated, use @> instead',
+  oprname => '~', oprleft => 'path', oprright => 'point', oprresult => 'bool',
+  oprcom => '@(point,path)', oprcode => 'path_contain_pt' },
+{ oid => '2869', descr => 'deprecated, use <@ instead',
+  oprname => '@', oprleft => 'point', oprright => 'polygon',
+  oprresult => 'bool', oprcom => '~(polygon,point)',
+  oprcode => 'pt_contained_poly' },
+{ oid => '2870', descr => 'deprecated, use @> instead',
+  oprname => '~', oprleft => 'polygon', oprright => 'point',
+  oprresult => 'bool', oprcom => '@(point,polygon)',
+  oprcode => 'poly_contain_pt' },
+{ oid => '2871', descr => 'deprecated, use <@ instead',
+  oprname => '@', oprleft => 'point', oprright => 'circle', oprresult => 'bool',
+  oprcom => '~(circle,point)', oprcode => 'pt_contained_circle' },
+{ oid => '2872', descr => 'deprecated, use @> instead',
+  oprname => '~', oprleft => 'circle', oprright => 'point', oprresult => 'bool',
+  oprcom => '@(point,circle)', oprcode => 'circle_contain_pt' },
+{ oid => '2873', descr => 'deprecated, use <@ instead',
+  oprname => '@', oprleft => 'point', oprright => 'line', oprresult => 'bool',
+  oprcode => 'on_pl' },
+{ oid => '2874', descr => 'deprecated, use <@ instead',
+  oprname => '@', oprleft => 'point', oprright => 'lseg', oprresult => 'bool',
+  oprcode => 'on_ps' },
+{ oid => '2875', descr => 'deprecated, use <@ instead',
+  oprname => '@', oprleft => 'lseg', oprright => 'line', oprresult => 'bool',
+  oprcode => 'on_sl' },
+{ oid => '2876', descr => 'deprecated, use <@ instead',
+  oprname => '@', oprleft => 'lseg', oprright => 'box', oprresult => 'bool',
+  oprcode => 'on_sb' },
+{ oid => '2877', descr => 'deprecated, use @> instead',
+  oprname => '~', oprleft => '_aclitem', oprright => 'aclitem',
+  oprresult => 'bool', oprcode => 'aclcontains' },
+
+# uuid operators
+{ oid => '2972', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprcanhash => 't', oprleft => 'uuid',
+  oprright => 'uuid', oprresult => 'bool', oprcom => '=(uuid,uuid)',
+  oprnegate => '<>(uuid,uuid)', oprcode => 'uuid_eq', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+{ oid => '2973', descr => 'not equal',
+  oprname => '<>', oprleft => 'uuid', oprright => 'uuid', oprresult => 'bool',
+  oprcom => '<>(uuid,uuid)', oprnegate => '=(uuid,uuid)', oprcode => 'uuid_ne',
+  oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+{ oid => '2974', descr => 'less than',
+  oprname => '<', oprleft => 'uuid', oprright => 'uuid', oprresult => 'bool',
+  oprcom => '>(uuid,uuid)', oprnegate => '>=(uuid,uuid)', oprcode => 'uuid_lt',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '2975', descr => 'greater than',
+  oprname => '>', oprleft => 'uuid', oprright => 'uuid', oprresult => 'bool',
+  oprcom => '<(uuid,uuid)', oprnegate => '<=(uuid,uuid)', oprcode => 'uuid_gt',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '2976', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'uuid', oprright => 'uuid', oprresult => 'bool',
+  oprcom => '>=(uuid,uuid)', oprnegate => '>(uuid,uuid)', oprcode => 'uuid_le',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '2977', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'uuid', oprright => 'uuid', oprresult => 'bool',
+  oprcom => '<=(uuid,uuid)', oprnegate => '<(uuid,uuid)', oprcode => 'uuid_ge',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+
+# pg_lsn operators
+{ oid => '3222', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprcanhash => 't', oprleft => 'pg_lsn',
+  oprright => 'pg_lsn', oprresult => 'bool', oprcom => '=(pg_lsn,pg_lsn)',
+  oprnegate => '<>(pg_lsn,pg_lsn)', oprcode => 'pg_lsn_eq', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+{ oid => '3223', descr => 'not equal',
+  oprname => '<>', oprleft => 'pg_lsn', oprright => 'pg_lsn',
+  oprresult => 'bool', oprcom => '<>(pg_lsn,pg_lsn)',
+  oprnegate => '=(pg_lsn,pg_lsn)', oprcode => 'pg_lsn_ne', oprrest => 'neqsel',
+  oprjoin => 'neqjoinsel' },
+{ oid => '3224', descr => 'less than',
+  oprname => '<', oprleft => 'pg_lsn', oprright => 'pg_lsn',
+  oprresult => 'bool', oprcom => '>(pg_lsn,pg_lsn)',
+  oprnegate => '>=(pg_lsn,pg_lsn)', oprcode => 'pg_lsn_lt',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '3225', descr => 'greater than',
+  oprname => '>', oprleft => 'pg_lsn', oprright => 'pg_lsn',
+  oprresult => 'bool', oprcom => '<(pg_lsn,pg_lsn)',
+  oprnegate => '<=(pg_lsn,pg_lsn)', oprcode => 'pg_lsn_gt',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '3226', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'pg_lsn', oprright => 'pg_lsn',
+  oprresult => 'bool', oprcom => '>=(pg_lsn,pg_lsn)',
+  oprnegate => '>(pg_lsn,pg_lsn)', oprcode => 'pg_lsn_le',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '3227', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'pg_lsn', oprright => 'pg_lsn',
+  oprresult => 'bool', oprcom => '<=(pg_lsn,pg_lsn)',
+  oprnegate => '<(pg_lsn,pg_lsn)', oprcode => 'pg_lsn_ge',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+{ oid => '3228', descr => 'minus',
+  oprname => '-', oprleft => 'pg_lsn', oprright => 'pg_lsn',
+  oprresult => 'numeric', oprcode => 'pg_lsn_mi' },
+
+# enum operators
+{ oid => '3516', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprcanhash => 't', oprleft => 'anyenum',
+  oprright => 'anyenum', oprresult => 'bool', oprcom => '=(anyenum,anyenum)',
+  oprnegate => '<>(anyenum,anyenum)', oprcode => 'enum_eq', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+{ oid => '3517', descr => 'not equal',
+  oprname => '<>', oprleft => 'anyenum', oprright => 'anyenum',
+  oprresult => 'bool', oprcom => '<>(anyenum,anyenum)',
+  oprnegate => '=(anyenum,anyenum)', oprcode => 'enum_ne', oprrest => 'neqsel',
+  oprjoin => 'neqjoinsel' },
+{ oid => '3518', descr => 'less than',
+  oprname => '<', oprleft => 'anyenum', oprright => 'anyenum',
+  oprresult => 'bool', oprcom => '>(anyenum,anyenum)',
+  oprnegate => '>=(anyenum,anyenum)', oprcode => 'enum_lt',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '3519', descr => 'greater than',
+  oprname => '>', oprleft => 'anyenum', oprright => 'anyenum',
+  oprresult => 'bool', oprcom => '<(anyenum,anyenum)',
+  oprnegate => '<=(anyenum,anyenum)', oprcode => 'enum_gt',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '3520', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'anyenum', oprright => 'anyenum',
+  oprresult => 'bool', oprcom => '>=(anyenum,anyenum)',
+  oprnegate => '>(anyenum,anyenum)', oprcode => 'enum_le',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '3521', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'anyenum', oprright => 'anyenum',
+  oprresult => 'bool', oprcom => '<=(anyenum,anyenum)',
+  oprnegate => '<(anyenum,anyenum)', oprcode => 'enum_ge',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+
+# tsearch operations
+{ oid => '3627', descr => 'less than',
+  oprname => '<', oprleft => 'tsvector', oprright => 'tsvector',
+  oprresult => 'bool', oprcom => '>(tsvector,tsvector)',
+  oprnegate => '>=(tsvector,tsvector)', oprcode => 'tsvector_lt',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '3628', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'tsvector', oprright => 'tsvector',
+  oprresult => 'bool', oprcom => '>=(tsvector,tsvector)',
+  oprnegate => '>(tsvector,tsvector)', oprcode => 'tsvector_le',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '3629', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprleft => 'tsvector',
+  oprright => 'tsvector', oprresult => 'bool', oprcom => '=(tsvector,tsvector)',
+  oprnegate => '<>(tsvector,tsvector)', oprcode => 'tsvector_eq',
+  oprrest => 'eqsel', oprjoin => 'eqjoinsel' },
+{ oid => '3630', descr => 'not equal',
+  oprname => '<>', oprleft => 'tsvector', oprright => 'tsvector',
+  oprresult => 'bool', oprcom => '<>(tsvector,tsvector)',
+  oprnegate => '=(tsvector,tsvector)', oprcode => 'tsvector_ne',
+  oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+{ oid => '3631', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'tsvector', oprright => 'tsvector',
+  oprresult => 'bool', oprcom => '<=(tsvector,tsvector)',
+  oprnegate => '<(tsvector,tsvector)', oprcode => 'tsvector_ge',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+{ oid => '3632', descr => 'greater than',
+  oprname => '>', oprleft => 'tsvector', oprright => 'tsvector',
+  oprresult => 'bool', oprcom => '<(tsvector,tsvector)',
+  oprnegate => '<=(tsvector,tsvector)', oprcode => 'tsvector_gt',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '3633', descr => 'concatenate',
+  oprname => '||', oprleft => 'tsvector', oprright => 'tsvector',
+  oprresult => 'tsvector', oprcode => 'tsvector_concat' },
+{ oid => '3636', descr => 'text search match',
+  oprname => '@@', oprleft => 'tsvector', oprright => 'tsquery',
+  oprresult => 'bool', oprcom => '@@(tsquery,tsvector)',
+  oprcode => 'ts_match_vq', oprrest => 'tsmatchsel',
+  oprjoin => 'tsmatchjoinsel' },
+{ oid => '3637', descr => 'text search match',
+  oprname => '@@', oprleft => 'tsquery', oprright => 'tsvector',
+  oprresult => 'bool', oprcom => '@@(tsvector,tsquery)',
+  oprcode => 'ts_match_qv', oprrest => 'tsmatchsel',
+  oprjoin => 'tsmatchjoinsel' },
+{ oid => '3660', descr => 'deprecated, use @@ instead',
+  oprname => '@@@', oprleft => 'tsvector', oprright => 'tsquery',
+  oprresult => 'bool', oprcom => '@@@(tsquery,tsvector)',
+  oprcode => 'ts_match_vq', oprrest => 'tsmatchsel',
+  oprjoin => 'tsmatchjoinsel' },
+{ oid => '3661', descr => 'deprecated, use @@ instead',
+  oprname => '@@@', oprleft => 'tsquery', oprright => 'tsvector',
+  oprresult => 'bool', oprcom => '@@@(tsvector,tsquery)',
+  oprcode => 'ts_match_qv', oprrest => 'tsmatchsel',
+  oprjoin => 'tsmatchjoinsel' },
+{ oid => '3674', descr => 'less than',
+  oprname => '<', oprleft => 'tsquery', oprright => 'tsquery',
+  oprresult => 'bool', oprcom => '>(tsquery,tsquery)',
+  oprnegate => '>=(tsquery,tsquery)', oprcode => 'tsquery_lt',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '3675', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'tsquery', oprright => 'tsquery',
+  oprresult => 'bool', oprcom => '>=(tsquery,tsquery)',
+  oprnegate => '>(tsquery,tsquery)', oprcode => 'tsquery_le',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '3676', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprleft => 'tsquery',
+  oprright => 'tsquery', oprresult => 'bool', oprcom => '=(tsquery,tsquery)',
+  oprnegate => '<>(tsquery,tsquery)', oprcode => 'tsquery_eq',
+  oprrest => 'eqsel', oprjoin => 'eqjoinsel' },
+{ oid => '3677', descr => 'not equal',
+  oprname => '<>', oprleft => 'tsquery', oprright => 'tsquery',
+  oprresult => 'bool', oprcom => '<>(tsquery,tsquery)',
+  oprnegate => '=(tsquery,tsquery)', oprcode => 'tsquery_ne',
+  oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+{ oid => '3678', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'tsquery', oprright => 'tsquery',
+  oprresult => 'bool', oprcom => '<=(tsquery,tsquery)',
+  oprnegate => '<(tsquery,tsquery)', oprcode => 'tsquery_ge',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+{ oid => '3679', descr => 'greater than',
+  oprname => '>', oprleft => 'tsquery', oprright => 'tsquery',
+  oprresult => 'bool', oprcom => '<(tsquery,tsquery)',
+  oprnegate => '<=(tsquery,tsquery)', oprcode => 'tsquery_gt',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '3680', descr => 'AND-concatenate',
+  oprname => '&&', oprleft => 'tsquery', oprright => 'tsquery',
+  oprresult => 'tsquery', oprcode => 'tsquery_and' },
+{ oid => '3681', descr => 'OR-concatenate',
+  oprname => '||', oprleft => 'tsquery', oprright => 'tsquery',
+  oprresult => 'tsquery', oprcode => 'tsquery_or' },
+{ oid => '5005', descr => 'phrase-concatenate',
+  oprname => '<->', oprleft => 'tsquery', oprright => 'tsquery',
+  oprresult => 'tsquery', oprcode => 'tsquery_phrase(tsquery,tsquery)' },
+{ oid => '3682', descr => 'NOT tsquery',
+  oprname => '!!', oprkind => 'l', oprleft => '0', oprright => 'tsquery',
+  oprresult => 'tsquery', oprcode => 'tsquery_not' },
+{ oid => '3693', descr => 'contains',
+  oprname => '@>', oprleft => 'tsquery', oprright => 'tsquery',
+  oprresult => 'bool', oprcom => '<@(tsquery,tsquery)',
+  oprcode => 'tsq_mcontains', oprrest => 'matchingsel',
+  oprjoin => 'matchingjoinsel' },
+{ oid => '3694', descr => 'is contained by',
+  oprname => '<@', oprleft => 'tsquery', oprright => 'tsquery',
+  oprresult => 'bool', oprcom => '@>(tsquery,tsquery)',
+  oprcode => 'tsq_mcontained', oprrest => 'matchingsel',
+  oprjoin => 'matchingjoinsel' },
+{ oid => '3762', descr => 'text search match',
+  oprname => '@@', oprleft => 'text', oprright => 'text', oprresult => 'bool',
+  oprcode => 'ts_match_tt', oprrest => 'matchingsel',
+  oprjoin => 'matchingjoinsel' },
+{ oid => '3763', descr => 'text search match',
+  oprname => '@@', oprleft => 'text', oprright => 'tsquery',
+  oprresult => 'bool', oprcode => 'ts_match_tq', oprrest => 'matchingsel',
+  oprjoin => 'matchingjoinsel' },
+
+# generic record comparison operators
+{ oid => '2988', oid_symbol => 'RECORD_EQ_OP', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprleft => 'record', oprright => 'record',
+  oprresult => 'bool', oprcom => '=(record,record)',
+  oprnegate => '<>(record,record)', oprcode => 'record_eq', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+{ oid => '2989', descr => 'not equal',
+  oprname => '<>', oprleft => 'record', oprright => 'record',
+  oprresult => 'bool', oprcom => '<>(record,record)',
+  oprnegate => '=(record,record)', oprcode => 'record_ne', oprrest => 'neqsel',
+  oprjoin => 'neqjoinsel' },
+{ oid => '2990', oid_symbol => 'RECORD_LT_OP', descr => 'less than',
+  oprname => '<', oprleft => 'record', oprright => 'record',
+  oprresult => 'bool', oprcom => '>(record,record)',
+  oprnegate => '>=(record,record)', oprcode => 'record_lt',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '2991', oid_symbol => 'RECORD_GT_OP', descr => 'greater than',
+  oprname => '>', oprleft => 'record', oprright => 'record',
+  oprresult => 'bool', oprcom => '<(record,record)',
+  oprnegate => '<=(record,record)', oprcode => 'record_gt',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '2992', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'record', oprright => 'record',
+  oprresult => 'bool', oprcom => '>=(record,record)',
+  oprnegate => '>(record,record)', oprcode => 'record_le',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '2993', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'record', oprright => 'record',
+  oprresult => 'bool', oprcom => '<=(record,record)',
+  oprnegate => '<(record,record)', oprcode => 'record_ge',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+
+# byte-oriented tests for identical rows and fast sorting
+{ oid => '3188', descr => 'identical',
+  oprname => '*=', oprcanmerge => 't', oprleft => 'record',
+  oprright => 'record', oprresult => 'bool', oprcom => '*=(record,record)',
+  oprnegate => '*<>(record,record)', oprcode => 'record_image_eq',
+  oprrest => 'eqsel', oprjoin => 'eqjoinsel' },
+{ oid => '3189', descr => 'not identical',
+  oprname => '*<>', oprleft => 'record', oprright => 'record',
+  oprresult => 'bool', oprcom => '*<>(record,record)',
+  oprnegate => '*=(record,record)', oprcode => 'record_image_ne',
+  oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+{ oid => '3190', descr => 'less than',
+  oprname => '*<', oprleft => 'record', oprright => 'record',
+  oprresult => 'bool', oprcom => '*>(record,record)',
+  oprnegate => '*>=(record,record)', oprcode => 'record_image_lt',
+  oprrest => 'scalarltsel', oprjoin => 'scalarltjoinsel' },
+{ oid => '3191', descr => 'greater than',
+  oprname => '*>', oprleft => 'record', oprright => 'record',
+  oprresult => 'bool', oprcom => '*<(record,record)',
+  oprnegate => '*<=(record,record)', oprcode => 'record_image_gt',
+  oprrest => 'scalargtsel', oprjoin => 'scalargtjoinsel' },
+{ oid => '3192', descr => 'less than or equal',
+  oprname => '*<=', oprleft => 'record', oprright => 'record',
+  oprresult => 'bool', oprcom => '*>=(record,record)',
+  oprnegate => '*>(record,record)', oprcode => 'record_image_le',
+  oprrest => 'scalarlesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '3193', descr => 'greater than or equal',
+  oprname => '*>=', oprleft => 'record', oprright => 'record',
+  oprresult => 'bool', oprcom => '*<=(record,record)',
+  oprnegate => '*<(record,record)', oprcode => 'record_image_ge',
+  oprrest => 'scalargesel', oprjoin => 'scalargejoinsel' },
+
+# generic range type operators
+{ oid => '3882', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprcanhash => 't', oprleft => 'anyrange',
+  oprright => 'anyrange', oprresult => 'bool', oprcom => '=(anyrange,anyrange)',
+  oprnegate => '<>(anyrange,anyrange)', oprcode => 'range_eq',
+  oprrest => 'eqsel', oprjoin => 'eqjoinsel' },
+{ oid => '3883', descr => 'not equal',
+  oprname => '<>', oprleft => 'anyrange', oprright => 'anyrange',
+  oprresult => 'bool', oprcom => '<>(anyrange,anyrange)',
+  oprnegate => '=(anyrange,anyrange)', oprcode => 'range_ne',
+  oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+{ oid => '3884', oid_symbol => 'OID_RANGE_LESS_OP', descr => 'less than',
+  oprname => '<', oprleft => 'anyrange', oprright => 'anyrange',
+  oprresult => 'bool', oprcom => '>(anyrange,anyrange)',
+  oprnegate => '>=(anyrange,anyrange)', oprcode => 'range_lt',
+  oprrest => 'rangesel', oprjoin => 'scalarltjoinsel' },
+{ oid => '3885', oid_symbol => 'OID_RANGE_LESS_EQUAL_OP',
+  descr => 'less than or equal',
+  oprname => '<=', oprleft => 'anyrange', oprright => 'anyrange',
+  oprresult => 'bool', oprcom => '>=(anyrange,anyrange)',
+  oprnegate => '>(anyrange,anyrange)', oprcode => 'range_le',
+  oprrest => 'rangesel', oprjoin => 'scalarlejoinsel' },
+{ oid => '3886', oid_symbol => 'OID_RANGE_GREATER_EQUAL_OP',
+  descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'anyrange', oprright => 'anyrange',
+  oprresult => 'bool', oprcom => '<=(anyrange,anyrange)',
+  oprnegate => '<(anyrange,anyrange)', oprcode => 'range_ge',
+  oprrest => 'rangesel', oprjoin => 'scalargejoinsel' },
+{ oid => '3887', oid_symbol => 'OID_RANGE_GREATER_OP',
+  descr => 'greater than',
+  oprname => '>', oprleft => 'anyrange', oprright => 'anyrange',
+  oprresult => 'bool', oprcom => '<(anyrange,anyrange)',
+  oprnegate => '<=(anyrange,anyrange)', oprcode => 'range_gt',
+  oprrest => 'rangesel', oprjoin => 'scalargtjoinsel' },
+{ oid => '3888', oid_symbol => 'OID_RANGE_OVERLAP_OP', descr => 'overlaps',
+  oprname => '&&', oprleft => 'anyrange', oprright => 'anyrange',
+  oprresult => 'bool', oprcom => '&&(anyrange,anyrange)',
+  oprcode => 'range_overlaps', oprrest => 'rangesel',
+  oprjoin => 'areajoinsel' },
+{ oid => '3889', oid_symbol => 'OID_RANGE_CONTAINS_ELEM_OP',
+  descr => 'contains',
+  oprname => '@>', oprleft => 'anyrange', oprright => 'anyelement',
+  oprresult => 'bool', oprcom => '<@(anyelement,anyrange)',
+  oprcode => 'range_contains_elem', oprrest => 'rangesel',
+  oprjoin => 'contjoinsel' },
+{ oid => '3890', oid_symbol => 'OID_RANGE_CONTAINS_OP', descr => 'contains',
+  oprname => '@>', oprleft => 'anyrange', oprright => 'anyrange',
+  oprresult => 'bool', oprcom => '<@(anyrange,anyrange)',
+  oprcode => 'range_contains', oprrest => 'rangesel',
+  oprjoin => 'contjoinsel' },
+{ oid => '3891', oid_symbol => 'OID_RANGE_ELEM_CONTAINED_OP',
+  descr => 'is contained by',
+  oprname => '<@', oprleft => 'anyelement', oprright => 'anyrange',
+  oprresult => 'bool', oprcom => '@>(anyrange,anyelement)',
+  oprcode => 'elem_contained_by_range', oprrest => 'rangesel',
+  oprjoin => 'contjoinsel' },
+{ oid => '3892', oid_symbol => 'OID_RANGE_CONTAINED_OP',
+  descr => 'is contained by',
+  oprname => '<@', oprleft => 'anyrange', oprright => 'anyrange',
+  oprresult => 'bool', oprcom => '@>(anyrange,anyrange)',
+  oprcode => 'range_contained_by', oprrest => 'rangesel',
+  oprjoin => 'contjoinsel' },
+{ oid => '3893', oid_symbol => 'OID_RANGE_LEFT_OP', descr => 'is left of',
+  oprname => '<<', oprleft => 'anyrange', oprright => 'anyrange',
+  oprresult => 'bool', oprcom => '>>(anyrange,anyrange)',
+  oprcode => 'range_before', oprrest => 'rangesel',
+  oprjoin => 'scalarltjoinsel' },
+{ oid => '3894', oid_symbol => 'OID_RANGE_RIGHT_OP', descr => 'is right of',
+  oprname => '>>', oprleft => 'anyrange', oprright => 'anyrange',
+  oprresult => 'bool', oprcom => '<<(anyrange,anyrange)',
+  oprcode => 'range_after', oprrest => 'rangesel',
+  oprjoin => 'scalargtjoinsel' },
+{ oid => '3895', oid_symbol => 'OID_RANGE_OVERLAPS_LEFT_OP',
+  descr => 'overlaps or is left of',
+  oprname => '&<', oprleft => 'anyrange', oprright => 'anyrange',
+  oprresult => 'bool', oprcode => 'range_overleft', oprrest => 'rangesel',
+  oprjoin => 'scalarltjoinsel' },
+{ oid => '3896', oid_symbol => 'OID_RANGE_OVERLAPS_RIGHT_OP',
+  descr => 'overlaps or is right of',
+  oprname => '&>', oprleft => 'anyrange', oprright => 'anyrange',
+  oprresult => 'bool', oprcode => 'range_overright', oprrest => 'rangesel',
+  oprjoin => 'scalargtjoinsel' },
+{ oid => '3897', descr => 'is adjacent to',
+  oprname => '-|-', oprleft => 'anyrange', oprright => 'anyrange',
+  oprresult => 'bool', oprcom => '-|-(anyrange,anyrange)',
+  oprcode => 'range_adjacent', oprrest => 'matchingsel',
+  oprjoin => 'matchingjoinsel' },
+{ oid => '3898', descr => 'range union',
+  oprname => '+', oprleft => 'anyrange', oprright => 'anyrange',
+  oprresult => 'anyrange', oprcom => '+(anyrange,anyrange)',
+  oprcode => 'range_union' },
+{ oid => '3899', descr => 'range difference',
+  oprname => '-', oprleft => 'anyrange', oprright => 'anyrange',
+  oprresult => 'anyrange', oprcode => 'range_minus' },
+{ oid => '3900', descr => 'range intersection',
+  oprname => '*', oprleft => 'anyrange', oprright => 'anyrange',
+  oprresult => 'anyrange', oprcom => '*(anyrange,anyrange)',
+  oprcode => 'range_intersect' },
+{ oid => '3962', descr => 'get json object field',
+  oprname => '->', oprleft => 'json', oprright => 'text', oprresult => 'json',
+  oprcode => 'json_object_field' },
+{ oid => '3963', descr => 'get json object field as text',
+  oprname => '->>', oprleft => 'json', oprright => 'text', oprresult => 'text',
+  oprcode => 'json_object_field_text' },
+{ oid => '3964', descr => 'get json array element',
+  oprname => '->', oprleft => 'json', oprright => 'int4', oprresult => 'json',
+  oprcode => 'json_array_element' },
+{ oid => '3965', descr => 'get json array element as text',
+  oprname => '->>', oprleft => 'json', oprright => 'int4', oprresult => 'text',
+  oprcode => 'json_array_element_text' },
+{ oid => '3966', descr => 'get value from json with path elements',
+  oprname => '#>', oprleft => 'json', oprright => '_text', oprresult => 'json',
+  oprcode => 'json_extract_path' },
+{ oid => '3967', descr => 'get value from json as text with path elements',
+  oprname => '#>>', oprleft => 'json', oprright => '_text', oprresult => 'text',
+  oprcode => 'json_extract_path_text' },
+{ oid => '3211', descr => 'get jsonb object field',
+  oprname => '->', oprleft => 'jsonb', oprright => 'text', oprresult => 'jsonb',
+  oprcode => 'jsonb_object_field' },
+{ oid => '3477', descr => 'get jsonb object field as text',
+  oprname => '->>', oprleft => 'jsonb', oprright => 'text', oprresult => 'text',
+  oprcode => 'jsonb_object_field_text' },
+{ oid => '3212', descr => 'get jsonb array element',
+  oprname => '->', oprleft => 'jsonb', oprright => 'int4', oprresult => 'jsonb',
+  oprcode => 'jsonb_array_element' },
+{ oid => '3481', descr => 'get jsonb array element as text',
+  oprname => '->>', oprleft => 'jsonb', oprright => 'int4', oprresult => 'text',
+  oprcode => 'jsonb_array_element_text' },
+{ oid => '3213', descr => 'get value from jsonb with path elements',
+  oprname => '#>', oprleft => 'jsonb', oprright => '_text',
+  oprresult => 'jsonb', oprcode => 'jsonb_extract_path' },
+{ oid => '3206', descr => 'get value from jsonb as text with path elements',
+  oprname => '#>>', oprleft => 'jsonb', oprright => '_text',
+  oprresult => 'text', oprcode => 'jsonb_extract_path_text' },
+{ oid => '3240', descr => 'equal',
+  oprname => '=', oprcanmerge => 't', oprcanhash => 't', oprleft => 'jsonb',
+  oprright => 'jsonb', oprresult => 'bool', oprcom => '=(jsonb,jsonb)',
+  oprnegate => '<>(jsonb,jsonb)', oprcode => 'jsonb_eq', oprrest => 'eqsel',
+  oprjoin => 'eqjoinsel' },
+{ oid => '3241', descr => 'not equal',
+  oprname => '<>', oprleft => 'jsonb', oprright => 'jsonb', oprresult => 'bool',
+  oprcom => '<>(jsonb,jsonb)', oprnegate => '=(jsonb,jsonb)',
+  oprcode => 'jsonb_ne', oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+{ oid => '3242', descr => 'less than',
+  oprname => '<', oprleft => 'jsonb', oprright => 'jsonb', oprresult => 'bool',
+  oprcom => '>(jsonb,jsonb)', oprnegate => '>=(jsonb,jsonb)',
+  oprcode => 'jsonb_lt', oprrest => 'scalarltsel',
+  oprjoin => 'scalarltjoinsel' },
+{ oid => '3243', descr => 'greater than',
+  oprname => '>', oprleft => 'jsonb', oprright => 'jsonb', oprresult => 'bool',
+  oprcom => '<(jsonb,jsonb)', oprnegate => '<=(jsonb,jsonb)',
+  oprcode => 'jsonb_gt', oprrest => 'scalargtsel',
+  oprjoin => 'scalargtjoinsel' },
+{ oid => '3244', descr => 'less than or equal',
+  oprname => '<=', oprleft => 'jsonb', oprright => 'jsonb', oprresult => 'bool',
+  oprcom => '>=(jsonb,jsonb)', oprnegate => '>(jsonb,jsonb)',
+  oprcode => 'jsonb_le', oprrest => 'scalarlesel',
+  oprjoin => 'scalarlejoinsel' },
+{ oid => '3245', descr => 'greater than or equal',
+  oprname => '>=', oprleft => 'jsonb', oprright => 'jsonb', oprresult => 'bool',
+  oprcom => '<=(jsonb,jsonb)', oprnegate => '<(jsonb,jsonb)',
+  oprcode => 'jsonb_ge', oprrest => 'scalargesel',
+  oprjoin => 'scalargejoinsel' },
+{ oid => '3246', descr => 'contains',
+  oprname => '@>', oprleft => 'jsonb', oprright => 'jsonb', oprresult => 'bool',
+  oprcom => '<@(jsonb,jsonb)', oprcode => 'jsonb_contains',
+  oprrest => 'matchingsel', oprjoin => 'matchingjoinsel' },
+{ oid => '3247', descr => 'key exists',
+  oprname => '?', oprleft => 'jsonb', oprright => 'text', oprresult => 'bool',
+  oprcode => 'jsonb_exists', oprrest => 'matchingsel',
+  oprjoin => 'matchingjoinsel' },
+{ oid => '3248', descr => 'any key exists',
+  oprname => '?|', oprleft => 'jsonb', oprright => '_text', oprresult => 'bool',
+  oprcode => 'jsonb_exists_any', oprrest => 'matchingsel',
+  oprjoin => 'matchingjoinsel' },
+{ oid => '3249', descr => 'all keys exist',
+  oprname => '?&', oprleft => 'jsonb', oprright => '_text', oprresult => 'bool',
+  oprcode => 'jsonb_exists_all', oprrest => 'matchingsel',
+  oprjoin => 'matchingjoinsel' },
+{ oid => '3250', descr => 'is contained by',
+  oprname => '<@', oprleft => 'jsonb', oprright => 'jsonb', oprresult => 'bool',
+  oprcom => '@>(jsonb,jsonb)', oprcode => 'jsonb_contained',
+  oprrest => 'matchingsel', oprjoin => 'matchingjoinsel' },
+{ oid => '3284', descr => 'concatenate',
+  oprname => '||', oprleft => 'jsonb', oprright => 'jsonb',
+  oprresult => 'jsonb', oprcode => 'jsonb_concat' },
+{ oid => '3285', descr => 'delete object field',
+  oprname => '-', oprleft => 'jsonb', oprright => 'text', oprresult => 'jsonb',
+  oprcode => 'jsonb_delete(jsonb,text)' },
+{ oid => '3398', descr => 'delete object fields',
+  oprname => '-', oprleft => 'jsonb', oprright => '_text', oprresult => 'jsonb',
+  oprcode => 'jsonb_delete(jsonb,_text)' },
+{ oid => '3286', descr => 'delete array element',
+  oprname => '-', oprleft => 'jsonb', oprright => 'int4', oprresult => 'jsonb',
+  oprcode => 'jsonb_delete(jsonb,int4)' },
+{ oid => '3287', descr => 'delete path',
+  oprname => '#-', oprleft => 'jsonb', oprright => '_text',
+  oprresult => 'jsonb', oprcode => 'jsonb_delete_path' },
+{ oid => '4012', descr => 'jsonpath exists',
+  oprname => '@?', oprleft => 'jsonb', oprright => 'jsonpath',
+  oprresult => 'bool', oprcode => 'jsonb_path_exists_opr(jsonb,jsonpath)',
+  oprrest => 'matchingsel', oprjoin => 'matchingjoinsel' },
+{ oid => '4013', descr => 'jsonpath match',
+  oprname => '@@', oprleft => 'jsonb', oprright => 'jsonpath',
+  oprresult => 'bool', oprcode => 'jsonb_path_match_opr(jsonb,jsonpath)',
+  oprrest => 'matchingsel', oprjoin => 'matchingjoinsel' },
+
+]
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_operator.h b/contrib/libs/postgresql/src/include/catalog/pg_operator.h
new file mode 100644
index 0000000000..5aaa02e8a9
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_operator.h
@@ -0,0 +1,104 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_operator.h
+ *	  definition of the "operator" system catalog (pg_operator)
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_operator.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_OPERATOR_H
+#define PG_OPERATOR_H
+
+#include "catalog/genbki.h"
+#include "catalog/objectaddress.h"
+#include "catalog/pg_operator_d.h"
+#include "nodes/pg_list.h"
+
+/* ----------------
+ *		pg_operator definition.  cpp turns this into
+ *		typedef struct FormData_pg_operator
+ * ----------------
+ */
+CATALOG(pg_operator,2617,OperatorRelationId)
+{
+	Oid			oid;			/* oid */
+
+	/* name of operator */
+	NameData	oprname;
+
+	/* OID of namespace containing this oper */
+	Oid			oprnamespace BKI_DEFAULT(PGNSP);
+
+	/* operator owner */
+	Oid			oprowner BKI_DEFAULT(PGUID);
+
+	/* 'l', 'r', or 'b' */
+	char		oprkind BKI_DEFAULT(b);
+
+	/* can be used in merge join? */
+	bool		oprcanmerge BKI_DEFAULT(f);
+
+	/* can be used in hash join? */
+	bool		oprcanhash BKI_DEFAULT(f);
+
+	/* left arg type, or 0 if 'l' oprkind */
+	Oid			oprleft BKI_LOOKUP(pg_type);
+
+	/* right arg type, or 0 if 'r' oprkind */
+	Oid			oprright BKI_LOOKUP(pg_type);
+
+	/* result datatype */
+	Oid			oprresult BKI_LOOKUP(pg_type);
+
+	/* OID of commutator oper, or 0 if none */
+	Oid			oprcom BKI_DEFAULT(0) BKI_LOOKUP(pg_operator);
+
+	/* OID of negator oper, or 0 if none */
+	Oid			oprnegate BKI_DEFAULT(0) BKI_LOOKUP(pg_operator);
+
+	/* OID of underlying function */
+	regproc		oprcode BKI_LOOKUP(pg_proc);
+
+	/* OID of restriction estimator, or 0 */
+	regproc		oprrest BKI_DEFAULT(-) BKI_LOOKUP(pg_proc);
+
+	/* OID of join estimator, or 0 */
+	regproc		oprjoin BKI_DEFAULT(-) BKI_LOOKUP(pg_proc);
+} FormData_pg_operator;
+
+/* ----------------
+ *		Form_pg_operator corresponds to a pointer to a tuple with
+ *		the format of pg_operator relation.
+ * ----------------
+ */
+typedef FormData_pg_operator *Form_pg_operator;
+
+
+extern ObjectAddress OperatorCreate(const char *operatorName,
+									Oid operatorNamespace,
+									Oid leftTypeId,
+									Oid rightTypeId,
+									Oid procedureId,
+									List *commutatorName,
+									List *negatorName,
+									Oid restrictionId,
+									Oid joinId,
+									bool canMerge,
+									bool canHash);
+
+extern ObjectAddress makeOperatorDependencies(HeapTuple tuple,
+											  bool makeExtensionDep,
+											  bool isUpdate);
+
+extern void OperatorUpd(Oid baseId, Oid commId, Oid negId, bool isDelete);
+
+#endif							/* PG_OPERATOR_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_operator_d.h b/contrib/libs/postgresql/src/include/catalog/pg_operator_d.h
new file mode 100644
index 0000000000..a06e90b848
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_operator_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_operator_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_opfamily.dat b/contrib/libs/postgresql/src/include/catalog/pg_opfamily.dat
new file mode 100644
index 0000000000..cf0fb325b3
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_opfamily.dat
@@ -0,0 +1,234 @@
+#----------------------------------------------------------------------
+#
+# pg_opfamily.dat
+#    Initial contents of the pg_opfamily system catalog.
+#
+# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+# Portions Copyright (c) 1994, Regents of the University of California
+#
+# src/include/catalog/pg_opfamily.dat
+#
+#----------------------------------------------------------------------
+
+[
+
+{ oid => '397',
+  opfmethod => 'btree', opfname => 'array_ops' },
+{ oid => '627',
+  opfmethod => 'hash', opfname => 'array_ops' },
+{ oid => '423',
+  opfmethod => 'btree', opfname => 'bit_ops' },
+{ oid => '424', oid_symbol => 'BOOL_BTREE_FAM_OID',
+  opfmethod => 'btree', opfname => 'bool_ops' },
+{ oid => '426', oid_symbol => 'BPCHAR_BTREE_FAM_OID',
+  opfmethod => 'btree', opfname => 'bpchar_ops' },
+{ oid => '427',
+  opfmethod => 'hash', opfname => 'bpchar_ops' },
+{ oid => '428', oid_symbol => 'BYTEA_BTREE_FAM_OID',
+  opfmethod => 'btree', opfname => 'bytea_ops' },
+{ oid => '429',
+  opfmethod => 'btree', opfname => 'char_ops' },
+{ oid => '431',
+  opfmethod => 'hash', opfname => 'char_ops' },
+{ oid => '434',
+  opfmethod => 'btree', opfname => 'datetime_ops' },
+{ oid => '435',
+  opfmethod => 'hash', opfname => 'date_ops' },
+{ oid => '1970',
+  opfmethod => 'btree', opfname => 'float_ops' },
+{ oid => '1971',
+  opfmethod => 'hash', opfname => 'float_ops' },
+{ oid => '1974', oid_symbol => 'NETWORK_BTREE_FAM_OID',
+  opfmethod => 'btree', opfname => 'network_ops' },
+{ oid => '1975',
+  opfmethod => 'hash', opfname => 'network_ops' },
+{ oid => '3550',
+  opfmethod => 'gist', opfname => 'network_ops' },
+{ oid => '3794',
+  opfmethod => 'spgist', opfname => 'network_ops' },
+{ oid => '1976', oid_symbol => 'INTEGER_BTREE_FAM_OID',
+  opfmethod => 'btree', opfname => 'integer_ops' },
+{ oid => '1977',
+  opfmethod => 'hash', opfname => 'integer_ops' },
+{ oid => '1982',
+  opfmethod => 'btree', opfname => 'interval_ops' },
+{ oid => '1983',
+  opfmethod => 'hash', opfname => 'interval_ops' },
+{ oid => '1984',
+  opfmethod => 'btree', opfname => 'macaddr_ops' },
+{ oid => '1985',
+  opfmethod => 'hash', opfname => 'macaddr_ops' },
+{ oid => '3371',
+  opfmethod => 'btree', opfname => 'macaddr8_ops' },
+{ oid => '3372',
+  opfmethod => 'hash', opfname => 'macaddr8_ops' },
+{ oid => '1988',
+  opfmethod => 'btree', opfname => 'numeric_ops' },
+{ oid => '1998',
+  opfmethod => 'hash', opfname => 'numeric_ops' },
+{ oid => '1989', oid_symbol => 'OID_BTREE_FAM_OID',
+  opfmethod => 'btree', opfname => 'oid_ops' },
+{ oid => '1990',
+  opfmethod => 'hash', opfname => 'oid_ops' },
+{ oid => '1991',
+  opfmethod => 'btree', opfname => 'oidvector_ops' },
+{ oid => '1992',
+  opfmethod => 'hash', opfname => 'oidvector_ops' },
+{ oid => '2994',
+  opfmethod => 'btree', opfname => 'record_ops' },
+{ oid => '3194',
+  opfmethod => 'btree', opfname => 'record_image_ops' },
+{ oid => '1994', oid_symbol => 'TEXT_BTREE_FAM_OID',
+  opfmethod => 'btree', opfname => 'text_ops' },
+{ oid => '1995',
+  opfmethod => 'hash', opfname => 'text_ops' },
+{ oid => '1996',
+  opfmethod => 'btree', opfname => 'time_ops' },
+{ oid => '1997',
+  opfmethod => 'hash', opfname => 'time_ops' },
+{ oid => '1999',
+  opfmethod => 'hash', opfname => 'timestamptz_ops' },
+{ oid => '2000',
+  opfmethod => 'btree', opfname => 'timetz_ops' },
+{ oid => '2001',
+  opfmethod => 'hash', opfname => 'timetz_ops' },
+{ oid => '2002',
+  opfmethod => 'btree', opfname => 'varbit_ops' },
+{ oid => '2040',
+  opfmethod => 'hash', opfname => 'timestamp_ops' },
+{ oid => '2095', oid_symbol => 'TEXT_PATTERN_BTREE_FAM_OID',
+  opfmethod => 'btree', opfname => 'text_pattern_ops' },
+{ oid => '2097', oid_symbol => 'BPCHAR_PATTERN_BTREE_FAM_OID',
+  opfmethod => 'btree', opfname => 'bpchar_pattern_ops' },
+{ oid => '2099',
+  opfmethod => 'btree', opfname => 'money_ops' },
+{ oid => '2222', oid_symbol => 'BOOL_HASH_FAM_OID',
+  opfmethod => 'hash', opfname => 'bool_ops' },
+{ oid => '2223',
+  opfmethod => 'hash', opfname => 'bytea_ops' },
+{ oid => '2789',
+  opfmethod => 'btree', opfname => 'tid_ops' },
+{ oid => '2225',
+  opfmethod => 'hash', opfname => 'xid_ops' },
+{ oid => '5032',
+  opfmethod => 'hash', opfname => 'xid8_ops' },
+{ oid => '5067',
+  opfmethod => 'btree', opfname => 'xid8_ops' },
+{ oid => '2226',
+  opfmethod => 'hash', opfname => 'cid_ops' },
+{ oid => '2227',
+  opfmethod => 'hash', opfname => 'tid_ops' },
+{ oid => '2229',
+  opfmethod => 'hash', opfname => 'text_pattern_ops' },
+{ oid => '2231',
+  opfmethod => 'hash', opfname => 'bpchar_pattern_ops' },
+{ oid => '2235',
+  opfmethod => 'hash', opfname => 'aclitem_ops' },
+{ oid => '2593',
+  opfmethod => 'gist', opfname => 'box_ops' },
+{ oid => '2594',
+  opfmethod => 'gist', opfname => 'poly_ops' },
+{ oid => '2595',
+  opfmethod => 'gist', opfname => 'circle_ops' },
+{ oid => '1029',
+  opfmethod => 'gist', opfname => 'point_ops' },
+{ oid => '2745',
+  opfmethod => 'gin', opfname => 'array_ops' },
+{ oid => '2968',
+  opfmethod => 'btree', opfname => 'uuid_ops' },
+{ oid => '2969',
+  opfmethod => 'hash', opfname => 'uuid_ops' },
+{ oid => '3253',
+  opfmethod => 'btree', opfname => 'pg_lsn_ops' },
+{ oid => '3254',
+  opfmethod => 'hash', opfname => 'pg_lsn_ops' },
+{ oid => '3522',
+  opfmethod => 'btree', opfname => 'enum_ops' },
+{ oid => '3523',
+  opfmethod => 'hash', opfname => 'enum_ops' },
+{ oid => '3626',
+  opfmethod => 'btree', opfname => 'tsvector_ops' },
+{ oid => '3655',
+  opfmethod => 'gist', opfname => 'tsvector_ops' },
+{ oid => '3659',
+  opfmethod => 'gin', opfname => 'tsvector_ops' },
+{ oid => '3683',
+  opfmethod => 'btree', opfname => 'tsquery_ops' },
+{ oid => '3702',
+  opfmethod => 'gist', opfname => 'tsquery_ops' },
+{ oid => '3901',
+  opfmethod => 'btree', opfname => 'range_ops' },
+{ oid => '3903',
+  opfmethod => 'hash', opfname => 'range_ops' },
+{ oid => '3919',
+  opfmethod => 'gist', opfname => 'range_ops' },
+{ oid => '3474',
+  opfmethod => 'spgist', opfname => 'range_ops' },
+{ oid => '4015',
+  opfmethod => 'spgist', opfname => 'quad_point_ops' },
+{ oid => '4016',
+  opfmethod => 'spgist', opfname => 'kd_point_ops' },
+{ oid => '4017', oid_symbol => 'TEXT_SPGIST_FAM_OID',
+  opfmethod => 'spgist', opfname => 'text_ops' },
+{ oid => '4033',
+  opfmethod => 'btree', opfname => 'jsonb_ops' },
+{ oid => '4034',
+  opfmethod => 'hash', opfname => 'jsonb_ops' },
+{ oid => '4036',
+  opfmethod => 'gin', opfname => 'jsonb_ops' },
+{ oid => '4037',
+  opfmethod => 'gin', opfname => 'jsonb_path_ops' },
+{ oid => '4054',
+  opfmethod => 'brin', opfname => 'integer_minmax_ops' },
+{ oid => '4055',
+  opfmethod => 'brin', opfname => 'numeric_minmax_ops' },
+{ oid => '4056',
+  opfmethod => 'brin', opfname => 'text_minmax_ops' },
+{ oid => '4058',
+  opfmethod => 'brin', opfname => 'timetz_minmax_ops' },
+{ oid => '4059',
+  opfmethod => 'brin', opfname => 'datetime_minmax_ops' },
+{ oid => '4062',
+  opfmethod => 'brin', opfname => 'char_minmax_ops' },
+{ oid => '4064',
+  opfmethod => 'brin', opfname => 'bytea_minmax_ops' },
+{ oid => '4065',
+  opfmethod => 'brin', opfname => 'name_minmax_ops' },
+{ oid => '4068',
+  opfmethod => 'brin', opfname => 'oid_minmax_ops' },
+{ oid => '4069',
+  opfmethod => 'brin', opfname => 'tid_minmax_ops' },
+{ oid => '4070',
+  opfmethod => 'brin', opfname => 'float_minmax_ops' },
+{ oid => '4074',
+  opfmethod => 'brin', opfname => 'macaddr_minmax_ops' },
+{ oid => '4109',
+  opfmethod => 'brin', opfname => 'macaddr8_minmax_ops' },
+{ oid => '4075',
+  opfmethod => 'brin', opfname => 'network_minmax_ops' },
+{ oid => '4102',
+  opfmethod => 'brin', opfname => 'network_inclusion_ops' },
+{ oid => '4076',
+  opfmethod => 'brin', opfname => 'bpchar_minmax_ops' },
+{ oid => '4077',
+  opfmethod => 'brin', opfname => 'time_minmax_ops' },
+{ oid => '4078',
+  opfmethod => 'brin', opfname => 'interval_minmax_ops' },
+{ oid => '4079',
+  opfmethod => 'brin', opfname => 'bit_minmax_ops' },
+{ oid => '4080',
+  opfmethod => 'brin', opfname => 'varbit_minmax_ops' },
+{ oid => '4081',
+  opfmethod => 'brin', opfname => 'uuid_minmax_ops' },
+{ oid => '4103',
+  opfmethod => 'brin', opfname => 'range_inclusion_ops' },
+{ oid => '4082',
+  opfmethod => 'brin', opfname => 'pg_lsn_minmax_ops' },
+{ oid => '4104',
+  opfmethod => 'brin', opfname => 'box_inclusion_ops' },
+{ oid => '5000',
+  opfmethod => 'spgist', opfname => 'box_ops' },
+{ oid => '5008',
+  opfmethod => 'spgist', opfname => 'poly_ops' },
+
+]
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_opfamily.h b/contrib/libs/postgresql/src/include/catalog/pg_opfamily.h
new file mode 100644
index 0000000000..503f0d2fd3
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_opfamily.h
@@ -0,0 +1,60 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_opfamily.h
+ *	  definition of the "operator family" system catalog (pg_opfamily)
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_opfamily.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_OPFAMILY_H
+#define PG_OPFAMILY_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_opfamily_d.h"
+
+/* ----------------
+ *		pg_opfamily definition. cpp turns this into
+ *		typedef struct FormData_pg_opfamily
+ * ----------------
+ */
+CATALOG(pg_opfamily,2753,OperatorFamilyRelationId)
+{
+	Oid			oid;			/* oid */
+
+	/* index access method opfamily is for */
+	Oid			opfmethod BKI_LOOKUP(pg_am);
+
+	/* name of this opfamily */
+	NameData	opfname;
+
+	/* namespace of this opfamily */
+	Oid			opfnamespace BKI_DEFAULT(PGNSP);
+
+	/* opfamily owner */
+	Oid			opfowner BKI_DEFAULT(PGUID);
+} FormData_pg_opfamily;
+
+/* ----------------
+ *		Form_pg_opfamily corresponds to a pointer to a tuple with
+ *		the format of pg_opfamily relation.
+ * ----------------
+ */
+typedef FormData_pg_opfamily *Form_pg_opfamily;
+
+#ifdef EXPOSE_TO_CLIENT_CODE
+
+#define IsBooleanOpfamily(opfamily) \
+	((opfamily) == BOOL_BTREE_FAM_OID || (opfamily) == BOOL_HASH_FAM_OID)
+
+#endif							/* EXPOSE_TO_CLIENT_CODE */
+
+#endif							/* PG_OPFAMILY_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_opfamily_d.h b/contrib/libs/postgresql/src/include/catalog/pg_opfamily_d.h
new file mode 100644
index 0000000000..5b36e673e8
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_opfamily_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_opfamily_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_partitioned_table.h b/contrib/libs/postgresql/src/include/catalog/pg_partitioned_table.h
new file mode 100644
index 0000000000..a73cd0d3a4
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_partitioned_table.h
@@ -0,0 +1,63 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_partitioned_table.h
+ *	  definition of the "partitioned table" system catalog
+ *	  (pg_partitioned_table)
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_partitioned_table.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_PARTITIONED_TABLE_H
+#define PG_PARTITIONED_TABLE_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_partitioned_table_d.h"
+
+/* ----------------
+ *		pg_partitioned_table definition.  cpp turns this into
+ *		typedef struct FormData_pg_partitioned_table
+ * ----------------
+ */
+CATALOG(pg_partitioned_table,3350,PartitionedRelationId)
+{
+	Oid			partrelid;		/* partitioned table oid */
+	char		partstrat;		/* partitioning strategy */
+	int16		partnatts;		/* number of partition key columns */
+	Oid			partdefid;		/* default partition oid; InvalidOid if there
+								 * isn't one */
+
+	/*
+	 * variable-length fields start here, but we allow direct access to
+	 * partattrs via the C struct.  That's because the first variable-length
+	 * field of a heap tuple can be reliably accessed using its C struct
+	 * offset, as previous fields are all non-nullable fixed-length fields.
+	 */
+	int2vector	partattrs;		/* each member of the array is the attribute
+								 * number of a partition key column, or 0 if
+								 * the column is actually an expression */
+
+#ifdef CATALOG_VARLEN
+	oidvector	partclass;		/* operator class to compare keys */
+	oidvector	partcollation;	/* user-specified collation for keys */
+	pg_node_tree partexprs;		/* list of expressions in the partition key;
+								 * one item for each zero entry in partattrs[] */
+#endif
+} FormData_pg_partitioned_table;
+
+/* ----------------
+ *		Form_pg_partitioned_table corresponds to a pointer to a tuple with
+ *		the format of pg_partitioned_table relation.
+ * ----------------
+ */
+typedef FormData_pg_partitioned_table *Form_pg_partitioned_table;
+
+#endif							/* PG_PARTITIONED_TABLE_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_partitioned_table_d.h b/contrib/libs/postgresql/src/include/catalog/pg_partitioned_table_d.h
new file mode 100644
index 0000000000..41b48e7dfc
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_partitioned_table_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_partitioned_table_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_policy.h b/contrib/libs/postgresql/src/include/catalog/pg_policy.h
new file mode 100644
index 0000000000..97954cdc8a
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_policy.h
@@ -0,0 +1,52 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_policy.h
+ *	  definition of the "policy" system catalog (pg_policy)
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_policy.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_POLICY_H
+#define PG_POLICY_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_policy_d.h"
+
+/* ----------------
+ *		pg_policy definition. cpp turns this into
+ *		typedef struct FormData_pg_policy
+ * ----------------
+ */
+CATALOG(pg_policy,3256,PolicyRelationId)
+{
+	Oid			oid;			/* oid */
+	NameData	polname;		/* Policy name. */
+	Oid			polrelid;		/* Oid of the relation with policy. */
+	char		polcmd;			/* One of ACL_*_CHR, or '*' for all */
+	bool		polpermissive;	/* restrictive or permissive policy */
+
+#ifdef CATALOG_VARLEN
+	Oid			polroles[1] BKI_FORCE_NOT_NULL; /* Roles associated with
+												 * policy */
+	pg_node_tree polqual;		/* Policy quals. */
+	pg_node_tree polwithcheck;	/* WITH CHECK quals. */
+#endif
+} FormData_pg_policy;
+
+/* ----------------
+ *		Form_pg_policy corresponds to a pointer to a row with
+ *		the format of pg_policy relation.
+ * ----------------
+ */
+typedef FormData_pg_policy *Form_pg_policy;
+
+#endif							/* PG_POLICY_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_policy_d.h b/contrib/libs/postgresql/src/include/catalog/pg_policy_d.h
new file mode 100644
index 0000000000..ea2594c794
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_policy_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_policy_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_proc.dat b/contrib/libs/postgresql/src/include/catalog/pg_proc.dat
new file mode 100644
index 0000000000..c2287273a9
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_proc.dat
@@ -0,0 +1,10940 @@
+#----------------------------------------------------------------------
+#
+# pg_proc.dat
+#    Initial contents of the pg_proc system catalog.
+#
+# Portions Copyright (c) 1996-2020, 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
+
+# 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.
+
+# 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 => '5070', descr => 'I/O',
+  proname => 'xid8in', prorettype => 'xid8', proargtypes => 'cstring',
+  prosrc => 'xid8in' },
+{ oid => '5081', descr => 'I/O',
+  proname => 'xid8out', prorettype => 'cstring', proargtypes => 'xid8',
+  prosrc => 'xid8out' },
+{ oid => '5082', descr => 'I/O',
+  proname => 'xid8recv', prorettype => 'xid8', proargtypes => 'internal',
+  prosrc => 'xid8recv' },
+{ oid => '5083', descr => 'I/O',
+  proname => 'xid8send', prorettype => 'bytea', proargtypes => 'xid8',
+  prosrc => 'xid8send' },
+{ 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 => '5084',
+  proname => 'xid8eq', proleakproof => 't', prorettype => 'bool',
+  proargtypes => 'xid8 xid8', prosrc => 'xid8eq' },
+{ oid => '5085',
+  proname => 'xid8ne', proleakproof => 't', prorettype => 'bool',
+  proargtypes => 'xid8 xid8', prosrc => 'xid8ne' },
+{ oid => '5034',
+  proname => 'xid8lt', proleakproof => 't', prorettype => 'bool',
+  proargtypes => 'xid8 xid8', prosrc => 'xid8lt' },
+{ oid => '5035',
+  proname => 'xid8gt', proleakproof => 't', prorettype => 'bool',
+  proargtypes => 'xid8 xid8', prosrc => 'xid8gt' },
+{ oid => '5036',
+  proname => 'xid8le', proleakproof => 't', prorettype => 'bool',
+  proargtypes => 'xid8 xid8', prosrc => 'xid8le' },
+{ oid => '5037',
+  proname => 'xid8ge', proleakproof => 't', prorettype => 'bool',
+  proargtypes => 'xid8 xid8', prosrc => 'xid8ge' },
+{ oid => '5096', descr => 'less-equal-greater',
+  proname => 'xid8cmp', proleakproof => 't', prorettype => 'int4',
+  proargtypes => 'xid8 xid8', prosrc => 'xid8cmp' },
+{ oid => '5071', descr => 'convert xid8 to xid',
+  proname => 'xid', prorettype => 'xid', proargtypes => 'xid8',
+  prosrc => 'xid8toxid' },
+{ 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', prosupport => 'textregexeq_support',
+  prorettype => 'bool', proargtypes => 'name text', prosrc => 'nameregexeq' },
+{ oid => '1252',
+  proname => 'nameregexne', prorettype => 'bool', proargtypes => 'name text',
+  prosrc => 'nameregexne' },
+{ oid => '1254',
+  proname => 'textregexeq', prosupport => 'textregexeq_support',
+  prorettype => 'bool', proargtypes => 'text text', prosrc => 'textregexeq' },
+{ oid => '1256',
+  proname => 'textregexne', prorettype => 'bool', proargtypes => 'text text',
+  prosrc => 'textregexne' },
+{ oid => '1364', descr => 'planner support for textregexeq',
+  proname => 'textregexeq_support', prorettype => 'internal',
+  proargtypes => 'internal', prosrc => 'textregexeq_support' },
+
+{ 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',
+  descr => 'implementation of deprecated ! and !! factorial operators',
+  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' },
+
+{ 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' },
+
+{ oid => '266', descr => 'concatenate name and oid',
+  proname => 'nameconcatoid', prorettype => 'name', proargtypes => 'name oid',
+  prosrc => 'nameconcatoid' },
+
+{ 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' },
+
+# Table access method handlers
+{ oid => '3', oid_symbol => 'HEAP_TABLE_AM_HANDLER_OID',
+  descr => 'row-oriented heap table access method handler',
+  proname => 'heap_tableam_handler', provolatile => 'v',
+  prorettype => 'table_am_handler', proargtypes => 'internal',
+  prosrc => 'heap_tableam_handler' },
+
+# 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 => '676', descr => 'return name of given index build phase',
+  proname => 'pg_indexam_progress_phasename', prorettype => 'text',
+  proargtypes => 'oid int8', prosrc => 'pg_indexam_progress_phasename' },
+
+{ 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',
+  proname => 'btint2cmp', proleakproof => 't', prorettype => 'int4',
+  proargtypes => 'int2 int2', prosrc => 'btint2cmp' },
+{ oid => '3129', descr => 'sort support',
+  proname => 'btint2sortsupport', prorettype => 'void',
+  proargtypes => 'internal', prosrc => 'btint2sortsupport' },
+{ oid => '351', descr => 'less-equal-greater',
+  proname => 'btint4cmp', proleakproof => 't', prorettype => 'int4',
+  proargtypes => 'int4 int4', prosrc => 'btint4cmp' },
+{ oid => '3130', descr => 'sort support',
+  proname => 'btint4sortsupport', prorettype => 'void',
+  proargtypes => 'internal', prosrc => 'btint4sortsupport' },
+{ oid => '842', descr => 'less-equal-greater',
+  proname => 'btint8cmp', proleakproof => 't', prorettype => 'int4',
+  proargtypes => 'int8 int8', prosrc => 'btint8cmp' },
+{ oid => '3131', descr => 'sort support',
+  proname => 'btint8sortsupport', prorettype => 'void',
+  proargtypes => 'internal', prosrc => 'btint8sortsupport' },
+{ oid => '354', descr => 'less-equal-greater',
+  proname => 'btfloat4cmp', proleakproof => 't', prorettype => 'int4',
+  proargtypes => 'float4 float4', prosrc => 'btfloat4cmp' },
+{ oid => '3132', descr => 'sort support',
+  proname => 'btfloat4sortsupport', prorettype => 'void',
+  proargtypes => 'internal', prosrc => 'btfloat4sortsupport' },
+{ oid => '355', descr => 'less-equal-greater',
+  proname => 'btfloat8cmp', proleakproof => 't', prorettype => 'int4',
+  proargtypes => 'float8 float8', prosrc => 'btfloat8cmp' },
+{ oid => '3133', descr => 'sort support',
+  proname => 'btfloat8sortsupport', prorettype => 'void',
+  proargtypes => 'internal', prosrc => 'btfloat8sortsupport' },
+{ oid => '356', descr => 'less-equal-greater',
+  proname => 'btoidcmp', proleakproof => 't', prorettype => 'int4',
+  proargtypes => 'oid oid', prosrc => 'btoidcmp' },
+{ oid => '3134', descr => 'sort support',
+  proname => 'btoidsortsupport', prorettype => 'void',
+  proargtypes => 'internal', prosrc => 'btoidsortsupport' },
+{ oid => '404', descr => 'less-equal-greater',
+  proname => 'btoidvectorcmp', proleakproof => 't', prorettype => 'int4',
+  proargtypes => 'oidvector oidvector', prosrc => 'btoidvectorcmp' },
+{ oid => '358', descr => 'less-equal-greater',
+  proname => 'btcharcmp', proleakproof => 't', prorettype => 'int4',
+  proargtypes => 'char char', prosrc => 'btcharcmp' },
+{ oid => '359', descr => 'less-equal-greater',
+  proname => 'btnamecmp', proleakproof => 't', prorettype => 'int4',
+  proargtypes => 'name name', prosrc => 'btnamecmp' },
+{ oid => '3135', descr => 'sort support',
+  proname => 'btnamesortsupport', prorettype => 'void',
+  proargtypes => 'internal', prosrc => 'btnamesortsupport' },
+{ oid => '360', descr => 'less-equal-greater',
+  proname => 'bttextcmp', proleakproof => 't', prorettype => 'int4',
+  proargtypes => 'text text', prosrc => 'bttextcmp' },
+{ oid => '3255', descr => 'sort support',
+  proname => 'bttextsortsupport', prorettype => 'void',
+  proargtypes => 'internal', prosrc => 'bttextsortsupport' },
+{ oid => '5050', descr => 'equal image',
+  proname => 'btvarstrequalimage', prorettype => 'bool', proargtypes => 'oid',
+  prosrc => 'btvarstrequalimage' },
+{ oid => '377', descr => 'less-equal-greater',
+  proname => 'cash_cmp', proleakproof => 't', prorettype => 'int4',
+  proargtypes => 'money money', prosrc => 'cash_cmp' },
+{ 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 => '380',
+  proname => 'dist_sp', prorettype => 'float8', proargtypes => 'lseg point',
+  prosrc => 'dist_sp' },
+{ oid => '364',
+  proname => 'dist_pb', prorettype => 'float8', proargtypes => 'point box',
+  prosrc => 'dist_pb' },
+{ oid => '357',
+  proname => 'dist_bp', prorettype => 'float8', proargtypes => 'box point',
+  prosrc => 'dist_bp' },
+{ oid => '365',
+  proname => 'dist_sb', prorettype => 'float8', proargtypes => 'lseg box',
+  prosrc => 'dist_sb' },
+{ oid => '381',
+  proname => 'dist_bs', prorettype => 'float8', proargtypes => 'box lseg',
+  prosrc => 'dist_bs' },
+{ 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 => '421',
+  proname => 'dist_pathp', prorettype => 'float8', proargtypes => 'path point',
+  prosrc => 'dist_pathp' },
+{ 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', proleakproof => 't', prorettype => 'text',
+  proargtypes => 'text text', prosrc => 'text_larger' },
+{ oid => '459', descr => 'smaller of two',
+  proname => 'text_smaller', proleakproof => 't', 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 => 'planner support for varchar length coercion',
+  proname => 'varchar_support', prorettype => 'internal',
+  proargtypes => 'internal', prosrc => 'varchar_support' },
+{ oid => '669', descr => 'adjust varchar() to typmod length',
+  proname => 'varchar', prosupport => 'varchar_support',
+  prorettype => 'varchar', proargtypes => 'varchar int4 bool',
+  prosrc => 'varchar' },
+
+{ oid => '619',
+  proname => 'oidvectorne', proleakproof => 't', prorettype => 'bool',
+  proargtypes => 'oidvector oidvector', prosrc => 'oidvectorne' },
+{ oid => '677',
+  proname => 'oidvectorlt', proleakproof => 't', prorettype => 'bool',
+  proargtypes => 'oidvector oidvector', prosrc => 'oidvectorlt' },
+{ oid => '678',
+  proname => 'oidvectorle', proleakproof => 't', prorettype => 'bool',
+  proargtypes => 'oidvector oidvector', prosrc => 'oidvectorle' },
+{ oid => '679',
+  proname => 'oidvectoreq', proleakproof => 't', prorettype => 'bool',
+  proargtypes => 'oidvector oidvector', prosrc => 'oidvectoreq' },
+{ oid => '680',
+  proname => 'oidvectorge', proleakproof => 't', prorettype => 'bool',
+  proargtypes => 'oidvector oidvector', prosrc => 'oidvectorge' },
+{ oid => '681',
+  proname => 'oidvectorgt', proleakproof => 't', 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 int8',
+  prosrc => 'byteaGetBit' },
+{ oid => '724', descr => 'set bit',
+  proname => 'set_bit', prorettype => 'bytea', proargtypes => 'bytea int8 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 => '702',
+  proname => 'dist_lp', prorettype => 'float8', proargtypes => 'line point',
+  prosrc => 'dist_lp' },
+{ oid => '726',
+  proname => 'dist_lb', prorettype => 'float8', proargtypes => 'line box',
+  prosrc => 'dist_lb' },
+{ oid => '703',
+  proname => 'dist_bl', prorettype => 'float8', proargtypes => 'box line',
+  prosrc => 'dist_bl' },
+{ oid => '727',
+  proname => 'dist_sl', prorettype => 'float8', proargtypes => 'lseg line',
+  prosrc => 'dist_sl' },
+{ oid => '704',
+  proname => 'dist_ls', prorettype => 'float8', proargtypes => 'line lseg',
+  prosrc => 'dist_ls' },
+
+{ oid => '728',
+  proname => 'dist_cpoly', prorettype => 'float8',
+  proargtypes => 'circle polygon', prosrc => 'dist_cpoly' },
+{ oid => '785',
+  proname => 'dist_polyc', prorettype => 'float8',
+  proargtypes => 'polygon circle', prosrc => 'dist_polyc' },
+{ 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', proleakproof => 't', prorettype => 'bool',
+  proargtypes => 'text text', prosrc => 'text_lt' },
+{ oid => '741',
+  proname => 'text_le', proleakproof => 't', prorettype => 'bool',
+  proargtypes => 'text text', prosrc => 'text_le' },
+{ oid => '742',
+  proname => 'text_gt', proleakproof => 't', prorettype => 'bool',
+  proargtypes => 'text text', prosrc => 'text_gt' },
+{ oid => '743',
+  proname => 'text_ge', proleakproof => 't', 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', prosupport => 'array_unnest_support',
+  proretset => 't', prorettype => 'anyelement', proargtypes => 'anyarray',
+  prosrc => 'array_unnest' },
+{ oid => '3996', descr => 'planner support for array_unnest',
+  proname => 'array_unnest_support', prorettype => 'internal',
+  proargtypes => 'internal', prosrc => 'array_unnest_support' },
+{ 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 => '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', prosupport => 'textlike_support', prorettype => 'bool',
+  proargtypes => 'text text', prosrc => 'textlike' },
+{ oid => '1023', descr => 'planner support for textlike',
+  proname => 'textlike_support', prorettype => 'internal',
+  proargtypes => 'internal', prosrc => 'textlike_support' },
+{ 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', prosupport => 'textlike_support', 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 => '5044', descr => 'greatest common divisor',
+  proname => 'gcd', prorettype => 'int4', proargtypes => 'int4 int4',
+  prosrc => 'int4gcd' },
+{ oid => '5045', descr => 'greatest common divisor',
+  proname => 'gcd', prorettype => 'int8', proargtypes => 'int8 int8',
+  prosrc => 'int8gcd' },
+
+{ oid => '5046', descr => 'least common multiple',
+  proname => 'lcm', prorettype => 'int4', proargtypes => 'int4 int4',
+  prosrc => 'int4lcm' },
+{ oid => '5047', descr => 'least common multiple',
+  proname => 'lcm', prorettype => 'int8', proargtypes => 'int8 int8',
+  prosrc => 'int8lcm' },
+
+{ 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 => '1026', descr => 'adjust timestamp to new time zone',
+  proname => 'timezone', 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' },
+{ oid => '3943',
+  descr => 'show hardwired default privileges, primarily for use by the information schema',
+  proname => 'acldefault', prorettype => '_aclitem', proargtypes => 'char oid',
+  prosrc => 'acldefault_sql' },
+{ oid => '1689',
+  descr => 'convert ACL item array to table, primarily for use by information schema',
+  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', proleakproof => 't', prorettype => 'bool',
+  proargtypes => 'bpchar bpchar', prosrc => 'bpcharlt' },
+{ oid => '1050',
+  proname => 'bpcharle', proleakproof => 't', prorettype => 'bool',
+  proargtypes => 'bpchar bpchar', prosrc => 'bpcharle' },
+{ oid => '1051',
+  proname => 'bpchargt', proleakproof => 't', prorettype => 'bool',
+  proargtypes => 'bpchar bpchar', prosrc => 'bpchargt' },
+{ oid => '1052',
+  proname => 'bpcharge', proleakproof => 't', 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', proleakproof => 't', prorettype => 'bpchar',
+  proargtypes => 'bpchar bpchar', prosrc => 'bpchar_larger' },
+{ oid => '1064', descr => 'smaller of two',
+  proname => 'bpchar_smaller', proleakproof => 't', prorettype => 'bpchar',
+  proargtypes => 'bpchar bpchar', prosrc => 'bpchar_smaller' },
+{ oid => '1078', descr => 'less-equal-greater',
+  proname => 'bpcharcmp', proleakproof => 't', 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',
+  proname => 'date_cmp', proleakproof => 't', prorettype => 'int4',
+  proargtypes => 'date date', prosrc => 'date_cmp' },
+{ 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',
+  proname => 'time_cmp', proleakproof => 't', prorettype => 'int4',
+  proargtypes => 'time time', prosrc => 'time_cmp' },
+{ 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 => '1159', descr => 'adjust timestamp to new time zone',
+  proname => 'timezone', 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 => 'sql', 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 => 'planner support for interval length coercion',
+  proname => 'interval_support', prorettype => 'internal',
+  proargtypes => 'internal', prosrc => 'interval_support' },
+{ oid => '1200', descr => 'adjust interval precision',
+  proname => 'interval', prosupport => 'interval_support',
+  prorettype => 'interval', proargtypes => 'interval int4',
+  prosrc => 'interval_scale' },
+
+{ oid => '1215', descr => 'get description for object id and catalog name',
+  proname => 'obj_description', prolang => 'sql', 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 => 'sql', procost => '100',
+  provolatile => 's', prorettype => 'text', proargtypes => 'oid int4',
+  prosrc => 'select description from pg_catalog.pg_description where objoid = $1 and classoid = \'pg_catalog.pg_class\'::pg_catalog.regclass and objsubid = $2' },
+{ oid => '1993',
+  descr => 'get description for object id and shared catalog name',
+  proname => 'shobj_description', prolang => 'sql', 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' },
+{ 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' },
+{ 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', prosupport => 'texticregexeq_support',
+  prorettype => 'bool', proargtypes => 'text text', prosrc => 'texticregexeq' },
+{ oid => '1024', descr => 'planner support for texticregexeq',
+  proname => 'texticregexeq_support', prorettype => 'internal',
+  proargtypes => 'internal', prosrc => 'texticregexeq_support' },
+{ oid => '1239',
+  proname => 'texticregexne', prorettype => 'bool', proargtypes => 'text text',
+  prosrc => 'texticregexne' },
+{ oid => '1240',
+  proname => 'nameicregexeq', prosupport => 'texticregexeq_support',
+  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',
+  proname => 'bttidcmp', proleakproof => 't', prorettype => 'int4',
+  proargtypes => 'tid tid', prosrc => 'bttidcmp' },
+{ 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' },
+{ 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' },
+
+{ oid => '1296',
+  proname => 'timedate_pl', prolang => 'sql', 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 => 'sql', prorettype => 'timestamptz',
+  proargtypes => 'timetz date', prosrc => 'select ($2 + $1)' },
+{ oid => '1299', descr => 'current transaction time',
+  proname => 'now', provolatile => 's', prorettype => 'timestamptz',
+  proargtypes => '', prosrc => 'now' },
+{ oid => '2647', descr => 'current transaction time',
+  proname => 'transaction_timestamp', provolatile => 's',
+  prorettype => 'timestamptz', proargtypes => '', prosrc => 'now' },
+{ oid => '2648', descr => 'current statement time',
+  proname => 'statement_timestamp', provolatile => 's',
+  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 => 'sql', 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 => 'sql', 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 => 'sql', 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 => 'sql', 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 => 'sql', 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 => 'sql', 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',
+  proname => 'timestamptz_cmp', proleakproof => 't', prorettype => 'int4',
+  proargtypes => 'timestamptz timestamptz', prosrc => 'timestamp_cmp' },
+{ oid => '1315', descr => 'less-equal-greater',
+  proname => 'interval_cmp', proleakproof => 't', prorettype => 'int4',
+  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 => '1194', descr => 'base 10 logarithm',
+  proname => 'log10', 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 => 'sql', 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',
+  proname => 'timetz_cmp', proleakproof => 't', prorettype => 'int4',
+  proargtypes => 'timetz timetz', prosrc => 'timetz_cmp' },
+{ 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 => 'sql', 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 => 'sql', 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', proparallel => 'u',
+  prorettype => 'name', proargtypes => '', prosrc => 'current_schema' },
+{ oid => '1403', descr => 'current schema search list',
+  proname => 'current_schemas', provolatile => 's', proparallel => 'u',
+  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 => 'sql', 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 => 'sql', 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', prosupport => 'textlike_support', 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', prosupport => 'textlike_support', 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' },
+
+{ 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' },
+
+{ 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',
+  proname => 'bitcmp', proleakproof => 't', prorettype => 'int4',
+  proargtypes => 'bit bit', prosrc => 'bitcmp' },
+
+{ 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 => '2462', descr => 'hyperbolic sine',
+  proname => 'sinh', prorettype => 'float8', proargtypes => 'float8',
+  prosrc => 'dsinh' },
+{ oid => '2463', descr => 'hyperbolic cosine',
+  proname => 'cosh', prorettype => 'float8', proargtypes => 'float8',
+  prosrc => 'dcosh' },
+{ oid => '2464', descr => 'hyperbolic tangent',
+  proname => 'tanh', prorettype => 'float8', proargtypes => 'float8',
+  prosrc => 'dtanh' },
+{ oid => '2465', descr => 'inverse hyperbolic sine',
+  proname => 'asinh', prorettype => 'float8', proargtypes => 'float8',
+  prosrc => 'dasinh' },
+{ oid => '2466', descr => 'inverse hyperbolic cosine',
+  proname => 'acosh', prorettype => 'float8', proargtypes => 'float8',
+  prosrc => 'dacosh' },
+{ oid => '2467', descr => 'inverse hyperbolic tangent',
+  proname => 'atanh', prorettype => 'float8', proargtypes => 'float8',
+  prosrc => 'datanh' },
+
+{ 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 SQL regexp pattern to POSIX style',
+  proname => 'similar_escape', proisstrict => 'f', prorettype => 'text',
+  proargtypes => 'text text', prosrc => 'similar_escape' },
+{ oid => '1986', descr => 'convert SQL regexp pattern to POSIX style',
+  proname => 'similar_to_escape', prorettype => 'text',
+  proargtypes => 'text text', prosrc => 'similar_to_escape_2' },
+{ oid => '1987', descr => 'convert SQL regexp pattern to POSIX style',
+  proname => 'similar_to_escape', prorettype => 'text', proargtypes => 'text',
+  prosrc => 'similar_to_escape_1' },
+
+{ oid => '1624',
+  proname => 'mul_d_interval', prorettype => 'interval',
+  proargtypes => 'float8 interval', prosrc => 'mul_d_interval' },
+
+{ oid => '1631',
+  proname => 'bpcharlike', prosupport => 'textlike_support',
+  prorettype => 'bool', proargtypes => 'bpchar text', prosrc => 'textlike' },
+{ oid => '1632',
+  proname => 'bpcharnlike', prorettype => 'bool', proargtypes => 'bpchar text',
+  prosrc => 'textnlike' },
+
+{ oid => '1633',
+  proname => 'texticlike', prosupport => 'texticlike_support',
+  prorettype => 'bool', proargtypes => 'text text', prosrc => 'texticlike' },
+{ oid => '1025', descr => 'planner support for texticlike',
+  proname => 'texticlike_support', prorettype => 'internal',
+  proargtypes => 'internal', prosrc => 'texticlike_support' },
+{ oid => '1634',
+  proname => 'texticnlike', prorettype => 'bool', proargtypes => 'text text',
+  prosrc => 'texticnlike' },
+{ oid => '1635',
+  proname => 'nameiclike', prosupport => 'texticlike_support',
+  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', prosupport => 'texticregexeq_support',
+  prorettype => 'bool', proargtypes => 'bpchar text',
+  prosrc => 'texticregexeq' },
+{ oid => '1657',
+  proname => 'bpcharicregexne', prorettype => 'bool',
+  proargtypes => 'bpchar text', prosrc => 'texticregexne' },
+{ oid => '1658',
+  proname => 'bpcharregexeq', prosupport => 'textregexeq_support',
+  prorettype => 'bool', proargtypes => 'bpchar text', prosrc => 'textregexeq' },
+{ oid => '1659',
+  proname => 'bpcharregexne', prorettype => 'bool',
+  proargtypes => 'bpchar text', prosrc => 'textregexne' },
+{ oid => '1660',
+  proname => 'bpchariclike', prosupport => 'texticlike_support',
+  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 => 'sql', prorettype => 'text',
+  proargtypes => 'text int4',
+  prosrc => 'select pg_catalog.lpad($1, $2, \' \')' },
+{ oid => '880', descr => 'right-pad string to length',
+  proname => 'rpad', prolang => 'sql', prorettype => 'text',
+  proargtypes => 'text int4',
+  prosrc => 'select pg_catalog.rpad($1, $2, \' \')' },
+{ 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',
+  proname => 'varbitcmp', proleakproof => 't', prorettype => 'int4',
+  proargtypes => 'varbit varbit', prosrc => 'bitcmp' },
+
+# 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 => 'planner support for varbit length coercion',
+  proname => 'varbit_support', prorettype => 'internal',
+  proargtypes => 'internal', prosrc => 'varbit_support' },
+{ oid => '1687', descr => 'adjust varbit() to typmod length',
+  proname => 'varbit', prosupport => 'varbit_support', 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',
+  proname => 'macaddr_cmp', proleakproof => 't', prorettype => 'int4',
+  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',
+  proname => 'macaddr8_cmp', proleakproof => 't', prorettype => 'int4',
+  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',
+  proname => 'network_cmp', proleakproof => 't', prorettype => 'int4',
+  proargtypes => 'inet inet', prosrc => 'network_cmp' },
+{ oid => '927',
+  proname => 'network_sub', prosupport => 'network_subset_support',
+  prorettype => 'bool', proargtypes => 'inet inet', prosrc => 'network_sub' },
+{ oid => '928',
+  proname => 'network_subeq', prosupport => 'network_subset_support',
+  prorettype => 'bool', proargtypes => 'inet inet', prosrc => 'network_subeq' },
+{ oid => '929',
+  proname => 'network_sup', prosupport => 'network_subset_support',
+  prorettype => 'bool', proargtypes => 'inet inet', prosrc => 'network_sup' },
+{ oid => '930',
+  proname => 'network_supeq', prosupport => 'network_subset_support',
+  prorettype => 'bool', proargtypes => 'inet inet', prosrc => 'network_supeq' },
+{ oid => '1173', descr => 'planner support for network_sub/superset',
+  proname => 'network_subset_support', prorettype => 'internal',
+  proargtypes => 'internal', prosrc => 'network_subset_support' },
+
+{ oid => '3551',
+  proname => 'network_overlap', prorettype => 'bool',
+  proargtypes => 'inet inet', prosrc => 'network_overlap' },
+{ oid => '5033', descr => 'sort support',
+  proname => 'network_sortsupport', prorettype => 'void',
+  proargtypes => 'internal', prosrc => 'network_sortsupport' },
+
+# 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 => 'sql', 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',
+  proname => 'btboolcmp', proleakproof => 't', prorettype => 'int4',
+  proargtypes => 'bool bool', prosrc => 'btboolcmp' },
+
+{ 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 => 'planner support for numeric length coercion',
+  proname => 'numeric_support', prorettype => 'internal',
+  proargtypes => 'internal', prosrc => 'numeric_support' },
+{ oid => '1703', descr => 'adjust numeric to typmod precision/scale',
+  proname => 'numeric', prosupport => 'numeric_support',
+  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 => 'sql', 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 => 'sql', 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 => '5048', descr => 'greatest common divisor',
+  proname => 'gcd', prorettype => 'numeric', proargtypes => 'numeric numeric',
+  prosrc => 'numeric_gcd' },
+{ oid => '5049', descr => 'least common multiple',
+  proname => 'lcm', prorettype => 'numeric', proargtypes => 'numeric numeric',
+  prosrc => 'numeric_lcm' },
+{ 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 => '5042', descr => 'minimum scale needed to represent the value',
+  proname => 'min_scale', prorettype => 'int4', proargtypes => 'numeric',
+  prosrc => 'numeric_min_scale' },
+{ oid => '5043',
+  descr => 'numeric with minimum scale needed to represent the value',
+  proname => 'trim_scale', prorettype => 'numeric', proargtypes => 'numeric',
+  prosrc => 'numeric_trim_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 => 'sql', prorettype => 'numeric',
+  proargtypes => 'numeric', prosrc => 'select pg_catalog.log(10, $1)' },
+{ oid => '1481', descr => 'base 10 logarithm',
+  proname => 'log10', prolang => 'sql', 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 => 'sql', 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 => 'sql', 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 => 'sql', prorettype => 'int4',
+  proargtypes => 'bytea', prosrc => 'select pg_catalog.octet_length($1) * 8' },
+{ oid => '1811', descr => 'length in bits',
+  proname => 'bit_length', prolang => 'sql', prorettype => 'int4',
+  proargtypes => 'text', prosrc => 'select pg_catalog.octet_length($1) * 8' },
+{ oid => '1812', descr => 'length in bits',
+  proname => 'bit_length', prolang => 'sql', 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 => 'sql', 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 => '5018', descr => 'I/O',
+  proname => 'pg_mcv_list_in', prorettype => 'pg_mcv_list',
+  proargtypes => 'cstring', prosrc => 'pg_mcv_list_in' },
+{ oid => '5019', descr => 'I/O',
+  proname => 'pg_mcv_list_out', prorettype => 'cstring',
+  proargtypes => 'pg_mcv_list', prosrc => 'pg_mcv_list_out' },
+{ oid => '5020', descr => 'I/O',
+  proname => 'pg_mcv_list_recv', provolatile => 's',
+  prorettype => 'pg_mcv_list', proargtypes => 'internal',
+  prosrc => 'pg_mcv_list_recv' },
+{ oid => '5021', descr => 'I/O',
+  proname => 'pg_mcv_list_send', provolatile => 's', prorettype => 'bytea',
+  proargtypes => 'pg_mcv_list', prosrc => 'pg_mcv_list_send' },
+
+{ oid => '3427', descr => 'details about MCV list items',
+  proname => 'pg_mcv_list_items', prorows => '1000', proretset => 't',
+  provolatile => 's', prorettype => 'record', proargtypes => 'pg_mcv_list',
+  proallargtypes => '{pg_mcv_list,int4,_text,_bool,float8,float8}',
+  proargmodes => '{i,o,o,o,o,o}',
+  proargnames => '{mcv_list,index,values,nulls,frequency,base_frequency}',
+  prosrc => 'pg_stats_ext_mcvlist_items' },
+
+{ 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 => '5053',
+  descr => 'statistics: number of tuples inserted since last vacuum',
+  proname => 'pg_stat_get_ins_since_vacuum', provolatile => 's',
+  proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
+  prosrc => 'pg_stat_get_ins_since_vacuum' },
+{ 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,numeric,text,bool,text,bool,int4}',
+  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,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,ssl_client_dn,ssl_client_serial,ssl_issuer_dn,gss_auth,gss_princ,gss_enc,leader_pid}',
+  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,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,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,param11,param12,param13,param14,param15,param16,param17,param18,param19,param20}',
+  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 => '',
+  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}',
+  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,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,o}',
+  proargnames => '{pid,status,receive_start_lsn,receive_start_tli,written_lsn,flushed_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 => '3426',
+  descr => 'statistics: checksum failures detected in database',
+  proname => 'pg_stat_get_db_checksum_failures', provolatile => 's',
+  proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
+  prosrc => 'pg_stat_get_db_checksum_failures' },
+{ oid => '3428',
+  descr => 'statistics: when last checksum failure was detected in database',
+  proname => 'pg_stat_get_db_checksum_last_failure', provolatile => 's',
+  proparallel => 'r', prorettype => 'timestamptz', proargtypes => 'oid',
+  prosrc => 'pg_stat_get_db_checksum_last_failure' },
+{ 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 => '2306', descr => 'statistics: information about SLRU caches',
+  proname => 'pg_stat_get_slru', prorows => '100', proisstrict => 'f',
+  proretset => 't', provolatile => 's', proparallel => 'r',
+  prorettype => 'record', proargtypes => '',
+  proallargtypes => '{text,int8,int8,int8,int8,int8,int8,int8,timestamptz}',
+  proargmodes => '{o,o,o,o,o,o,o,o,o}',
+  proargnames => '{name,blks_zeroed,blks_hit,blks_read,blks_written,blks_exists,flushes,truncates,stats_reset}',
+  prosrc => 'pg_stat_get_slru' },
+
+{ 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 => '2307',
+  descr => 'statistics: reset collected statistics for a single SLRU',
+  proname => 'pg_stat_reset_slru', proisstrict => 'f', provolatile => 'v',
+  prorettype => 'void', proargtypes => 'text', prosrc => 'pg_stat_reset_slru' },
+
+{ 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',
+  proname => 'byteacmp', proleakproof => 't', prorettype => 'int4',
+  proargtypes => 'bytea bytea', prosrc => 'byteacmp' },
+{ oid => '3331', descr => 'sort support',
+  proname => 'bytea_sortsupport', prorettype => 'void',
+  proargtypes => 'internal', prosrc => 'bytea_sortsupport' },
+
+{ oid => '3917', descr => 'planner support for timestamp length coercion',
+  proname => 'timestamp_support', prorettype => 'internal',
+  proargtypes => 'internal', prosrc => 'timestamp_support' },
+{ oid => '3944', descr => 'planner support for time length coercion',
+  proname => 'time_support', prorettype => 'internal',
+  proargtypes => 'internal', prosrc => 'time_support' },
+
+{ oid => '1961', descr => 'adjust timestamp precision',
+  proname => 'timestamp', prosupport => 'timestamp_support',
+  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', prosupport => 'timestamp_support',
+  prorettype => 'timestamptz', proargtypes => 'timestamptz int4',
+  prosrc => 'timestamptz_scale' },
+{ oid => '1968', descr => 'adjust time precision',
+  proname => 'time', prosupport => 'time_support', prorettype => 'time',
+  proargtypes => 'time int4', prosrc => 'time_scale' },
+{ oid => '1969', descr => 'adjust time with time zone precision',
+  proname => 'timetz', prosupport => 'time_support', prorettype => 'timetz',
+  proargtypes => 'timetz int4', prosrc => 'timetz_scale' },
+
+{ oid => '2003',
+  proname => 'textanycat', prolang => 'sql', provolatile => 's',
+  prorettype => 'text', proargtypes => 'text anynonarray',
+  prosrc => 'select $1 || $2::pg_catalog.text' },
+{ oid => '2004',
+  proname => 'anytextcat', prolang => 'sql', provolatile => 's',
+  prorettype => 'text', proargtypes => 'anynonarray text',
+  prosrc => 'select $1::pg_catalog.text || $2' },
+
+{ oid => '2005',
+  proname => 'bytealike', prosupport => 'textlike_support',
+  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', prosupport => 'textlike_support', 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 => 'sql', 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 => 'sql', 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 => 'sql', proisstrict => 'f',
+  prorettype => 'bool', proargtypes => 'timestamp interval timestamp timestamp',
+  prosrc => 'select ($1, ($1 + $2)) overlaps ($3, $4)' },
+{ oid => '2045', descr => 'less-equal-greater',
+  proname => 'timestamp_cmp', proleakproof => 't', prorettype => 'int4',
+  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 => 'sql', 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', prorettype => 'timestamptz',
+  proargtypes => 'text timestamp', prosrc => 'timestamp_zone' },
+{ oid => '2070', descr => 'adjust timestamp to new time zone',
+  proname => 'timezone', 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 SQL regular expression',
+  proname => 'substring', prolang => 'sql', prorettype => 'text',
+  proargtypes => 'text text text',
+  prosrc => 'select pg_catalog.substring($1, pg_catalog.similar_to_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}',
+  proargnames => '{type,object_names,object_args,classid,objid,objsubid}',
+  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' },
+{ oid => '3436', descr => 'promote standby server',
+  proname => 'pg_promote', provolatile => 'v', prorettype => 'bool',
+  proargtypes => 'bool int4', proargnames => '{wait,wait_seconds}',
+  prosrc => 'pg_promote' },
+{ 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 => 'sql', 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 => 'sql', 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 => '4189', descr => 'maximum value of all pg_lsn input values',
+  proname => 'max', prokind => 'a', proisstrict => 'f', prorettype => 'pg_lsn',
+  proargtypes => 'pg_lsn', 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' },
+{ oid => '4190', descr => 'minimum value of all pg_lsn input values',
+  proname => 'min', prokind => 'a', proisstrict => 'f', prorettype => 'pg_lsn',
+  proargtypes => 'pg_lsn', 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', proleakproof => 't', prorettype => 'bool',
+  proargtypes => 'text text', prosrc => 'text_pattern_lt' },
+{ oid => '2161',
+  proname => 'text_pattern_le', proleakproof => 't', prorettype => 'bool',
+  proargtypes => 'text text', prosrc => 'text_pattern_le' },
+{ oid => '2163',
+  proname => 'text_pattern_ge', proleakproof => 't', prorettype => 'bool',
+  proargtypes => 'text text', prosrc => 'text_pattern_ge' },
+{ oid => '2164',
+  proname => 'text_pattern_gt', proleakproof => 't', prorettype => 'bool',
+  proargtypes => 'text text', prosrc => 'text_pattern_gt' },
+{ oid => '2166', descr => 'less-equal-greater',
+  proname => 'bttext_pattern_cmp', proleakproof => 't', 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', proleakproof => 't', prorettype => 'bool',
+  proargtypes => 'bpchar bpchar', prosrc => 'bpchar_pattern_lt' },
+{ oid => '2175',
+  proname => 'bpchar_pattern_le', proleakproof => 't', prorettype => 'bool',
+  proargtypes => 'bpchar bpchar', prosrc => 'bpchar_pattern_le' },
+{ oid => '2177',
+  proname => 'bpchar_pattern_ge', proleakproof => 't', prorettype => 'bool',
+  proargtypes => 'bpchar bpchar', prosrc => 'bpchar_pattern_ge' },
+{ oid => '2178',
+  proname => 'bpchar_pattern_gt', proleakproof => 't', prorettype => 'bool',
+  proargtypes => 'bpchar bpchar', prosrc => 'bpchar_pattern_gt' },
+{ oid => '2180', descr => 'less-equal-greater',
+  proname => 'btbpchar_pattern_cmp', proleakproof => 't', 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',
+  proname => 'btint48cmp', proleakproof => 't', prorettype => 'int4',
+  proargtypes => 'int4 int8', prosrc => 'btint48cmp' },
+{ oid => '2189', descr => 'less-equal-greater',
+  proname => 'btint84cmp', proleakproof => 't', prorettype => 'int4',
+  proargtypes => 'int8 int4', prosrc => 'btint84cmp' },
+{ oid => '2190', descr => 'less-equal-greater',
+  proname => 'btint24cmp', proleakproof => 't', prorettype => 'int4',
+  proargtypes => 'int2 int4', prosrc => 'btint24cmp' },
+{ oid => '2191', descr => 'less-equal-greater',
+  proname => 'btint42cmp', proleakproof => 't', prorettype => 'int4',
+  proargtypes => 'int4 int2', prosrc => 'btint42cmp' },
+{ oid => '2192', descr => 'less-equal-greater',
+  proname => 'btint28cmp', proleakproof => 't', prorettype => 'int4',
+  proargtypes => 'int2 int8', prosrc => 'btint28cmp' },
+{ oid => '2193', descr => 'less-equal-greater',
+  proname => 'btint82cmp', proleakproof => 't', prorettype => 'int4',
+  proargtypes => 'int8 int2', prosrc => 'btint82cmp' },
+{ oid => '2194', descr => 'less-equal-greater',
+  proname => 'btfloat48cmp', proleakproof => 't', prorettype => 'int4',
+  proargtypes => 'float4 float8', prosrc => 'btfloat48cmp' },
+{ oid => '2195', descr => 'less-equal-greater',
+  proname => 'btfloat84cmp', proleakproof => 't', prorettype => 'int4',
+  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 => '4193', descr => 'I/O',
+  proname => 'regcollationin', provolatile => 's', prorettype => 'regcollation',
+  proargtypes => 'cstring', prosrc => 'regcollationin' },
+{ oid => '4194', descr => 'I/O',
+  proname => 'regcollationout', provolatile => 's', prorettype => 'cstring',
+  proargtypes => 'regcollation', prosrc => 'regcollationout' },
+{ oid => '4195', descr => 'convert classname to regcollation',
+  proname => 'to_regcollation', provolatile => 's',
+  prorettype => 'regcollation', proargtypes => 'text',
+  prosrc => 'to_regcollation' },
+{ 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 => 'sql', provolatile => 'v',
+  prorettype => 'int8', proargtypes => 'regclass',
+  prosrc => 'select pg_catalog.pg_relation_size($1, \'main\')' },
+{ 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 => '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 => 'void',
+  proargtypes => 'cstring', prosrc => 'shell_in' },
+{ oid => '2399', descr => 'I/O',
+  proname => 'shell_out', prorettype => 'cstring', proargtypes => 'void',
+  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' },
+{ oid => '267', descr => 'I/O',
+  proname => 'table_am_handler_in', proisstrict => 'f',
+  prorettype => 'table_am_handler', proargtypes => 'cstring',
+  prosrc => 'table_am_handler_in' },
+{ oid => '268', descr => 'I/O',
+  proname => 'table_am_handler_out', prorettype => 'cstring',
+  proargtypes => 'table_am_handler', prosrc => 'table_am_handler_out' },
+{ oid => '5086', descr => 'I/O',
+  proname => 'anycompatible_in', prorettype => 'anycompatible',
+  proargtypes => 'cstring', prosrc => 'anycompatible_in' },
+{ oid => '5087', descr => 'I/O',
+  proname => 'anycompatible_out', prorettype => 'cstring',
+  proargtypes => 'anycompatible', prosrc => 'anycompatible_out' },
+{ oid => '5088', descr => 'I/O',
+  proname => 'anycompatiblearray_in', prorettype => 'anycompatiblearray',
+  proargtypes => 'cstring', prosrc => 'anycompatiblearray_in' },
+{ oid => '5089', descr => 'I/O',
+  proname => 'anycompatiblearray_out', provolatile => 's',
+  prorettype => 'cstring', proargtypes => 'anycompatiblearray',
+  prosrc => 'anycompatiblearray_out' },
+{ oid => '5090', descr => 'I/O',
+  proname => 'anycompatiblearray_recv', provolatile => 's',
+  prorettype => 'anycompatiblearray', proargtypes => 'internal',
+  prosrc => 'anycompatiblearray_recv' },
+{ oid => '5091', descr => 'I/O',
+  proname => 'anycompatiblearray_send', provolatile => 's',
+  prorettype => 'bytea', proargtypes => 'anycompatiblearray',
+  prosrc => 'anycompatiblearray_send' },
+{ oid => '5092', descr => 'I/O',
+  proname => 'anycompatiblenonarray_in', prorettype => 'anycompatiblenonarray',
+  proargtypes => 'cstring', prosrc => 'anycompatiblenonarray_in' },
+{ oid => '5093', descr => 'I/O',
+  proname => 'anycompatiblenonarray_out', prorettype => 'cstring',
+  proargtypes => 'anycompatiblenonarray',
+  prosrc => 'anycompatiblenonarray_out' },
+{ oid => '5094', descr => 'I/O',
+  proname => 'anycompatiblerange_in', provolatile => 's',
+  prorettype => 'anycompatiblerange', proargtypes => 'cstring oid int4',
+  prosrc => 'anycompatiblerange_in' },
+{ oid => '5095', descr => 'I/O',
+  proname => 'anycompatiblerange_out', provolatile => 's',
+  prorettype => 'cstring', proargtypes => 'anycompatiblerange',
+  prosrc => 'anycompatiblerange_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 => '4196', descr => 'I/O',
+  proname => 'regcollationrecv', prorettype => 'regcollation',
+  proargtypes => 'internal', prosrc => 'regcollationrecv' },
+{ oid => '4197', descr => 'I/O',
+  proname => 'regcollationsend', prorettype => 'bytea',
+  proargtypes => 'regcollation', prosrc => 'regcollationsend' },
+{ 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',
+  proparallel => 'r', prorettype => 'float8', proargtypes => '',
+  prosrc => 'pg_notification_queue_usage' },
+
+# shared memory usage
+{ oid => '5052', descr => 'allocations from the main shared memory segment',
+  proname => 'pg_get_shmem_allocations', prorows => '50', proretset => 't',
+  provolatile => 'v', prorettype => 'record', proargtypes => '',
+  proallargtypes => '{text,int8,int8,int8}', proargmodes => '{o,o,o,o}',
+  proargnames => '{name,off,size,allocated_size}',
+  prosrc => 'pg_get_shmem_allocations' },
+
+# non-persistent series generator
+{ oid => '1066', descr => 'non-persistent series generator',
+  proname => 'generate_series', prorows => '1000',
+  prosupport => 'generate_series_int4_support', 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',
+  prosupport => 'generate_series_int4_support', proretset => 't',
+  prorettype => 'int4', proargtypes => 'int4 int4',
+  prosrc => 'generate_series_int4' },
+{ oid => '3994', descr => 'planner support for generate_series',
+  proname => 'generate_series_int4_support', prorettype => 'internal',
+  proargtypes => 'internal', prosrc => 'generate_series_int4_support' },
+{ oid => '1068', descr => 'non-persistent series generator',
+  proname => 'generate_series', prorows => '1000',
+  prosupport => 'generate_series_int8_support', 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',
+  prosupport => 'generate_series_int8_support', proretset => 't',
+  prorettype => 'int8', proargtypes => 'int8 int8',
+  prosrc => 'generate_series_int8' },
+{ oid => '3995', descr => 'planner support for generate_series',
+  proname => 'generate_series_int8_support', prorettype => 'internal',
+  proargtypes => 'internal', prosrc => 'generate_series_int8_support' },
+{ 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 => 'sql', prorettype => 'timestamp',
+  proargtypes => 'interval date', prosrc => 'select $2 + $1' },
+{ oid => '2547',
+  proname => 'interval_pl_timetz', prolang => 'sql', prorettype => 'timetz',
+  proargtypes => 'interval timetz', prosrc => 'select $2 + $1' },
+{ oid => '2548',
+  proname => 'interval_pl_timestamp', prolang => 'sql',
+  prorettype => 'timestamp', proargtypes => 'interval timestamp',
+  prosrc => 'select $2 + $1' },
+{ oid => '2549',
+  proname => 'interval_pl_timestamptz', prolang => 'sql', provolatile => 's',
+  prorettype => 'timestamptz', proargtypes => 'interval timestamptz',
+  prosrc => 'select $2 + $1' },
+{ oid => '2550',
+  proname => 'integer_pl_date', prolang => 'sql', 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 => '3998', descr => 'GiST support',
+  proname => 'gist_box_distance', prorettype => 'float8',
+  proargtypes => 'internal box int2 oid internal',
+  prosrc => 'gist_box_distance' },
+{ 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 => 'r',
+  prorettype => 'void', proargtypes => 'int8',
+  prosrc => 'pg_advisory_lock_int8' },
+{ oid => '3089', descr => 'obtain exclusive advisory lock',
+  proname => 'pg_advisory_xact_lock', provolatile => 'v', proparallel => 'r',
+  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 => 'r',
+  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 => 'r', 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 => 'r',
+  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 => 'r', 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 => 'r', 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 => 'r', 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 => 'r',
+  prorettype => 'bool', proargtypes => 'int8',
+  prosrc => 'pg_advisory_unlock_int8' },
+{ oid => '2885', descr => 'release shared advisory lock',
+  proname => 'pg_advisory_unlock_shared', provolatile => 'v',
+  proparallel => 'r', prorettype => 'bool', proargtypes => 'int8',
+  prosrc => 'pg_advisory_unlock_shared_int8' },
+{ oid => '2886', descr => 'obtain exclusive advisory lock',
+  proname => 'pg_advisory_lock', provolatile => 'v', proparallel => 'r',
+  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 => 'r',
+  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 => 'r',
+  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 => 'r', 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 => 'r',
+  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 => 'r', 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 => 'r', 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 => 'r', 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 => 'r',
+  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 => 'r', 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 => 'r',
+  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 => 'sql', prorettype => '_xml',
+  proargtypes => 'text xml',
+  prosrc => 'select pg_catalog.xpath($1, $2, \'{}\'::pg_catalog.text[])' },
+
+{ 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 => 'sql', prorettype => 'bool',
+  proargtypes => 'text xml',
+  prosrc => 'select pg_catalog.xpath_exists($1, $2, \'{}\'::pg_catalog.text[])' },
+{ 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',
+  proname => 'uuid_cmp', proleakproof => 't', prorettype => 'int4',
+  proargtypes => 'uuid uuid', prosrc => 'uuid_cmp' },
+{ 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' },
+{ oid => '3432', descr => 'generate random UUID',
+  proname => 'gen_random_uuid', proleakproof => 't', provolatile => 'v',
+  prorettype => 'uuid', proargtypes => '', prosrc => 'gen_random_uuid' },
+
+# 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', proleakproof => 't', prorettype => 'bool',
+  proargtypes => 'pg_lsn pg_lsn', prosrc => 'pg_lsn_lt' },
+{ oid => '3232',
+  proname => 'pg_lsn_le', proleakproof => 't', prorettype => 'bool',
+  proargtypes => 'pg_lsn pg_lsn', prosrc => 'pg_lsn_le' },
+{ oid => '3233',
+  proname => 'pg_lsn_eq', proleakproof => 't', prorettype => 'bool',
+  proargtypes => 'pg_lsn pg_lsn', prosrc => 'pg_lsn_eq' },
+{ oid => '3234',
+  proname => 'pg_lsn_ge', proleakproof => 't', prorettype => 'bool',
+  proargtypes => 'pg_lsn pg_lsn', prosrc => 'pg_lsn_ge' },
+{ oid => '3235',
+  proname => 'pg_lsn_gt', proleakproof => 't', prorettype => 'bool',
+  proargtypes => 'pg_lsn pg_lsn', prosrc => 'pg_lsn_gt' },
+{ oid => '3236',
+  proname => 'pg_lsn_ne', proleakproof => 't', 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', proleakproof => 't', 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' },
+{ oid => '4187', descr => 'larger of two',
+  proname => 'pg_lsn_larger', prorettype => 'pg_lsn',
+  proargtypes => 'pg_lsn pg_lsn', prosrc => 'pg_lsn_larger' },
+{ oid => '4188', descr => 'smaller of two',
+  proname => 'pg_lsn_smaller', prorettype => 'pg_lsn',
+  proargtypes => 'pg_lsn pg_lsn', prosrc => 'pg_lsn_smaller' },
+
+# 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 => '3434', descr => 'GiST tsvector support',
+  proname => 'gtsvector_options', proisstrict => 'f', prorettype => 'void',
+  proargtypes => 'internal', prosrc => 'gtsvector_options' },
+
+{ 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' },
+{ oid => '5007', descr => 'transform to tsquery',
+  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' },
+{ oid => '5009', descr => 'transform to tsquery',
+  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 => '5054', descr => 'Set part of a jsonb, handle NULL value',
+  proname => 'jsonb_set_lax', proisstrict => 'f', prorettype => 'jsonb',
+  proargtypes => 'jsonb _text jsonb bool text', prosrc => 'jsonb_set_lax' },
+{ 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' },
+
+# jsonpath
+{ oid => '4001', descr => 'I/O',
+  proname => 'jsonpath_in', prorettype => 'jsonpath', proargtypes => 'cstring',
+  prosrc => 'jsonpath_in' },
+{ oid => '4002', descr => 'I/O',
+  proname => 'jsonpath_recv', prorettype => 'jsonpath',
+  proargtypes => 'internal', prosrc => 'jsonpath_recv' },
+{ oid => '4003', descr => 'I/O',
+  proname => 'jsonpath_out', prorettype => 'cstring', proargtypes => 'jsonpath',
+  prosrc => 'jsonpath_out' },
+{ oid => '4004', descr => 'I/O',
+  proname => 'jsonpath_send', prorettype => 'bytea', proargtypes => 'jsonpath',
+  prosrc => 'jsonpath_send' },
+
+{ oid => '4005', descr => 'jsonpath exists test',
+  proname => 'jsonb_path_exists', prorettype => 'bool',
+  proargtypes => 'jsonb jsonpath jsonb bool', prosrc => 'jsonb_path_exists' },
+{ oid => '4006', descr => 'jsonpath query',
+  proname => 'jsonb_path_query', prorows => '1000', proretset => 't',
+  prorettype => 'jsonb', proargtypes => 'jsonb jsonpath jsonb bool',
+  prosrc => 'jsonb_path_query' },
+{ oid => '4007', descr => 'jsonpath query wrapped into array',
+  proname => 'jsonb_path_query_array', prorettype => 'jsonb',
+  proargtypes => 'jsonb jsonpath jsonb bool',
+  prosrc => 'jsonb_path_query_array' },
+{ oid => '4008', descr => 'jsonpath query first item',
+  proname => 'jsonb_path_query_first', prorettype => 'jsonb',
+  proargtypes => 'jsonb jsonpath jsonb bool',
+  prosrc => 'jsonb_path_query_first' },
+{ oid => '4009', descr => 'jsonpath match',
+  proname => 'jsonb_path_match', prorettype => 'bool',
+  proargtypes => 'jsonb jsonpath jsonb bool', prosrc => 'jsonb_path_match' },
+
+{ oid => '1177', descr => 'jsonpath exists test with timezone',
+  proname => 'jsonb_path_exists_tz', provolatile => 's', prorettype => 'bool',
+  proargtypes => 'jsonb jsonpath jsonb bool',
+  prosrc => 'jsonb_path_exists_tz' },
+{ oid => '1179', descr => 'jsonpath query with timezone',
+  proname => 'jsonb_path_query_tz', prorows => '1000', proretset => 't',
+  provolatile => 's', prorettype => 'jsonb',
+  proargtypes => 'jsonb jsonpath jsonb bool', prosrc => 'jsonb_path_query_tz' },
+{ oid => '1180', descr => 'jsonpath query wrapped into array with timezone',
+  proname => 'jsonb_path_query_array_tz', provolatile => 's',
+  prorettype => 'jsonb', proargtypes => 'jsonb jsonpath jsonb bool',
+  prosrc => 'jsonb_path_query_array_tz' },
+{ oid => '2023', descr => 'jsonpath query first item with timezone',
+  proname => 'jsonb_path_query_first_tz', provolatile => 's',
+  prorettype => 'jsonb', proargtypes => 'jsonb jsonpath jsonb bool',
+  prosrc => 'jsonb_path_query_first_tz' },
+{ oid => '2030', descr => 'jsonpath match with timezone',
+  proname => 'jsonb_path_match_tz', provolatile => 's', prorettype => 'bool',
+  proargtypes => 'jsonb jsonpath jsonb bool', prosrc => 'jsonb_path_match_tz' },
+
+{ oid => '4010', descr => 'implementation of @? operator',
+  proname => 'jsonb_path_exists_opr', prorettype => 'bool',
+  proargtypes => 'jsonb jsonpath', prosrc => 'jsonb_path_exists_opr' },
+{ oid => '4011', descr => 'implementation of @@ operator',
+  proname => 'jsonb_path_match_opr', prorettype => 'bool',
+  proargtypes => 'jsonb jsonpath', prosrc => 'jsonb_path_match_opr' },
+
+# historical int8/txid_snapshot variants of xid8 functions
+{ oid => '2939', descr => 'I/O',
+  proname => 'txid_snapshot_in', prorettype => 'txid_snapshot',
+  proargtypes => 'cstring', prosrc => 'pg_snapshot_in' },
+{ oid => '2940', descr => 'I/O',
+  proname => 'txid_snapshot_out', prorettype => 'cstring',
+  proargtypes => 'txid_snapshot', prosrc => 'pg_snapshot_out' },
+{ oid => '2941', descr => 'I/O',
+  proname => 'txid_snapshot_recv', prorettype => 'txid_snapshot',
+  proargtypes => 'internal', prosrc => 'pg_snapshot_recv' },
+{ oid => '2942', descr => 'I/O',
+  proname => 'txid_snapshot_send', prorettype => 'bytea',
+  proargtypes => 'txid_snapshot', prosrc => 'pg_snapshot_send' },
+{ oid => '2943', descr => 'get current transaction ID',
+  proname => 'txid_current', provolatile => 's', proparallel => 'u',
+  prorettype => 'int8', proargtypes => '', prosrc => 'pg_current_xact_id' },
+{ oid => '3348', descr => 'get current transaction ID',
+  proname => 'txid_current_if_assigned', provolatile => 's', proparallel => 'u',
+  prorettype => 'int8', proargtypes => '',
+  prosrc => 'pg_current_xact_id_if_assigned' },
+{ oid => '2944', descr => 'get current snapshot',
+  proname => 'txid_current_snapshot', provolatile => 's',
+  prorettype => 'txid_snapshot', proargtypes => '',
+  prosrc => 'pg_current_snapshot' },
+{ oid => '2945', descr => 'get xmin of snapshot',
+  proname => 'txid_snapshot_xmin', prorettype => 'int8',
+  proargtypes => 'txid_snapshot', prosrc => 'pg_snapshot_xmin' },
+{ oid => '2946', descr => 'get xmax of snapshot',
+  proname => 'txid_snapshot_xmax', prorettype => 'int8',
+  proargtypes => 'txid_snapshot', prosrc => 'pg_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 => 'pg_snapshot_xip' },
+{ oid => '2948', descr => 'is txid visible in snapshot?',
+  proname => 'txid_visible_in_snapshot', prorettype => 'bool',
+  proargtypes => 'int8 txid_snapshot', prosrc => 'pg_visible_in_snapshot' },
+{ oid => '3360', descr => 'commit status of transaction',
+  proname => 'txid_status', provolatile => 'v', prorettype => 'text',
+  proargtypes => 'int8', prosrc => 'pg_xact_status' },
+
+# pg_snapshot functions
+{ oid => '5055', descr => 'I/O',
+  proname => 'pg_snapshot_in', prorettype => 'pg_snapshot',
+  proargtypes => 'cstring', prosrc => 'pg_snapshot_in' },
+{ oid => '5056', descr => 'I/O',
+  proname => 'pg_snapshot_out', prorettype => 'cstring',
+  proargtypes => 'pg_snapshot', prosrc => 'pg_snapshot_out' },
+{ oid => '5057', descr => 'I/O',
+  proname => 'pg_snapshot_recv', prorettype => 'pg_snapshot',
+  proargtypes => 'internal', prosrc => 'pg_snapshot_recv' },
+{ oid => '5058', descr => 'I/O',
+  proname => 'pg_snapshot_send', prorettype => 'bytea',
+  proargtypes => 'pg_snapshot', prosrc => 'pg_snapshot_send' },
+{ oid => '5061', descr => 'get current snapshot',
+  proname => 'pg_current_snapshot', provolatile => 's',
+  prorettype => 'pg_snapshot', proargtypes => '',
+  prosrc => 'pg_current_snapshot' },
+{ oid => '5062', descr => 'get xmin of snapshot',
+  proname => 'pg_snapshot_xmin', prorettype => 'xid8',
+  proargtypes => 'pg_snapshot', prosrc => 'pg_snapshot_xmin' },
+{ oid => '5063', descr => 'get xmax of snapshot',
+  proname => 'pg_snapshot_xmax', prorettype => 'xid8',
+  proargtypes => 'pg_snapshot', prosrc => 'pg_snapshot_xmax' },
+{ oid => '5064', descr => 'get set of in-progress transactions in snapshot',
+  proname => 'pg_snapshot_xip', prorows => '50', proretset => 't',
+  prorettype => 'xid8', proargtypes => 'pg_snapshot',
+  prosrc => 'pg_snapshot_xip' },
+{ oid => '5065', descr => 'is xid8 visible in snapshot?',
+  proname => 'pg_visible_in_snapshot', prorettype => 'bool',
+  proargtypes => 'xid8 pg_snapshot', prosrc => 'pg_visible_in_snapshot' },
+
+# transaction ID and status functions
+{ oid => '5059', descr => 'get current transaction ID',
+  proname => 'pg_current_xact_id', provolatile => 's', proparallel => 'u',
+  prorettype => 'xid8', proargtypes => '', prosrc => 'pg_current_xact_id' },
+{ oid => '5060', descr => 'get current transaction ID',
+  proname => 'pg_current_xact_id_if_assigned', provolatile => 's',
+  proparallel => 'u', prorettype => 'xid8', proargtypes => '',
+  prosrc => 'pg_current_xact_id_if_assigned' },
+{ oid => '5066', descr => 'commit status of transaction',
+  proname => 'pg_xact_status', provolatile => 'v', prorettype => 'text',
+  proargtypes => 'xid8', prosrc => 'pg_xact_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' },
+{ oid => '5051', descr => 'equal image',
+  proname => 'btequalimage', prorettype => 'bool', proargtypes => 'oid',
+  prosrc => 'btequalimage' },
+
+# 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,bool,name,_name,text}',
+  proargmodes => '{o,o,o,o,o,o,o,o}',
+  proargnames => '{name,version,superuser,trusted,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 => '4220',
+  descr => 'copy a physical replication slot, changing temporality',
+  proname => 'pg_copy_physical_replication_slot', provolatile => 'v',
+  proparallel => 'u', prorettype => 'record', proargtypes => 'name name bool',
+  proallargtypes => '{name,name,bool,name,pg_lsn}',
+  proargmodes => '{i,i,i,o,o}',
+  proargnames => '{src_slot_name,dst_slot_name,temporary,slot_name,lsn}',
+  prosrc => 'pg_copy_physical_replication_slot_a' },
+{ oid => '4221', descr => 'copy a physical replication slot',
+  proname => 'pg_copy_physical_replication_slot', provolatile => 'v',
+  proparallel => 'u', prorettype => 'record', proargtypes => 'name name',
+  proallargtypes => '{name,name,name,pg_lsn}', proargmodes => '{i,i,o,o}',
+  proargnames => '{src_slot_name,dst_slot_name,slot_name,lsn}',
+  prosrc => 'pg_copy_physical_replication_slot_b' },
+{ 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,text,int8}',
+  proargmodes => '{o,o,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,wal_status,safe_wal_size}',
+  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',
+  proallargtypes => '{name,name,bool,name,pg_lsn}',
+  proargmodes => '{i,i,i,o,o}',
+  proargnames => '{slot_name,plugin,temporary,slot_name,lsn}',
+  prosrc => 'pg_create_logical_replication_slot' },
+{ oid => '4222',
+  descr => 'copy a logical replication slot, changing temporality and plugin',
+  proname => 'pg_copy_logical_replication_slot', provolatile => 'v',
+  proparallel => 'u', prorettype => 'record',
+  proargtypes => 'name name bool name',
+  proallargtypes => '{name,name,bool,name,name,pg_lsn}',
+  proargmodes => '{i,i,i,i,o,o}',
+  proargnames => '{src_slot_name,dst_slot_name,temporary,plugin,slot_name,lsn}',
+  prosrc => 'pg_copy_logical_replication_slot_a' },
+{ oid => '4223',
+  descr => 'copy a logical replication slot, changing temporality',
+  proname => 'pg_copy_logical_replication_slot', provolatile => 'v',
+  proparallel => 'u', prorettype => 'record', proargtypes => 'name name bool',
+  proallargtypes => '{name,name,bool,name,pg_lsn}',
+  proargmodes => '{i,i,i,o,o}',
+  proargnames => '{src_slot_name,dst_slot_name,temporary,slot_name,lsn}',
+  prosrc => 'pg_copy_logical_replication_slot_b' },
+{ oid => '4224', descr => 'copy a logical replication slot',
+  proname => 'pg_copy_logical_replication_slot', provolatile => 'v',
+  proparallel => 'u', prorettype => 'record', proargtypes => 'name name',
+  proallargtypes => '{name,name,name,pg_lsn}', proargmodes => '{i,i,o,o}',
+  proargnames => '{src_slot_name,dst_slot_name,slot_name,lsn}',
+  prosrc => 'pg_copy_logical_replication_slot_c' },
+{ 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' },
+{ oid => '4101', descr => 'for use by pg_upgrade',
+  proname => 'binary_upgrade_set_missing_value', provolatile => 'v',
+  proparallel => 'u', prorettype => 'void', proargtypes => 'oid text text',
+  prosrc => 'binary_upgrade_set_missing_value' },
+
+# conversion functions
+{ oid => '4302',
+  descr => 'internal conversion function for KOI8R to MULE_INTERNAL',
+  proname => 'koi8r_to_mic', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'koi8r_to_mic',
+  probin => '$libdir/cyrillic_and_mic' },
+{ oid => '4303',
+  descr => 'internal conversion function for MULE_INTERNAL to KOI8R',
+  proname => 'mic_to_koi8r', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'mic_to_koi8r',
+  probin => '$libdir/cyrillic_and_mic' },
+{ oid => '4304',
+  descr => 'internal conversion function for ISO-8859-5 to MULE_INTERNAL',
+  proname => 'iso_to_mic', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'iso_to_mic',
+  probin => '$libdir/cyrillic_and_mic' },
+{ oid => '4305',
+  descr => 'internal conversion function for MULE_INTERNAL to ISO-8859-5',
+  proname => 'mic_to_iso', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'mic_to_iso',
+  probin => '$libdir/cyrillic_and_mic' },
+{ oid => '4306',
+  descr => 'internal conversion function for WIN1251 to MULE_INTERNAL',
+  proname => 'win1251_to_mic', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'win1251_to_mic',
+  probin => '$libdir/cyrillic_and_mic' },
+{ oid => '4307',
+  descr => 'internal conversion function for MULE_INTERNAL to WIN1251',
+  proname => 'mic_to_win1251', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'mic_to_win1251',
+  probin => '$libdir/cyrillic_and_mic' },
+{ oid => '4308',
+  descr => 'internal conversion function for WIN866 to MULE_INTERNAL',
+  proname => 'win866_to_mic', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'win866_to_mic',
+  probin => '$libdir/cyrillic_and_mic' },
+{ oid => '4309',
+  descr => 'internal conversion function for MULE_INTERNAL to WIN866',
+  proname => 'mic_to_win866', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'mic_to_win866',
+  probin => '$libdir/cyrillic_and_mic' },
+{ oid => '4310', descr => 'internal conversion function for KOI8R to WIN1251',
+  proname => 'koi8r_to_win1251', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4',
+  prosrc => 'koi8r_to_win1251', probin => '$libdir/cyrillic_and_mic' },
+{ oid => '4311', descr => 'internal conversion function for WIN1251 to KOI8R',
+  proname => 'win1251_to_koi8r', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4',
+  prosrc => 'win1251_to_koi8r', probin => '$libdir/cyrillic_and_mic' },
+{ oid => '4312', descr => 'internal conversion function for KOI8R to WIN866',
+  proname => 'koi8r_to_win866', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'koi8r_to_win866',
+  probin => '$libdir/cyrillic_and_mic' },
+{ oid => '4313', descr => 'internal conversion function for WIN866 to KOI8R',
+  proname => 'win866_to_koi8r', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'win866_to_koi8r',
+  probin => '$libdir/cyrillic_and_mic' },
+{ oid => '4314',
+  descr => 'internal conversion function for WIN866 to WIN1251',
+  proname => 'win866_to_win1251', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4',
+  prosrc => 'win866_to_win1251', probin => '$libdir/cyrillic_and_mic' },
+{ oid => '4315',
+  descr => 'internal conversion function for WIN1251 to WIN866',
+  proname => 'win1251_to_win866', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4',
+  prosrc => 'win1251_to_win866', probin => '$libdir/cyrillic_and_mic' },
+{ oid => '4316',
+  descr => 'internal conversion function for ISO-8859-5 to KOI8R',
+  proname => 'iso_to_koi8r', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'iso_to_koi8r',
+  probin => '$libdir/cyrillic_and_mic' },
+{ oid => '4317',
+  descr => 'internal conversion function for KOI8R to ISO-8859-5',
+  proname => 'koi8r_to_iso', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'koi8r_to_iso',
+  probin => '$libdir/cyrillic_and_mic' },
+{ oid => '4318',
+  descr => 'internal conversion function for ISO-8859-5 to WIN1251',
+  proname => 'iso_to_win1251', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'iso_to_win1251',
+  probin => '$libdir/cyrillic_and_mic' },
+{ oid => '4319',
+  descr => 'internal conversion function for WIN1251 to ISO-8859-5',
+  proname => 'win1251_to_iso', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'win1251_to_iso',
+  probin => '$libdir/cyrillic_and_mic' },
+{ oid => '4320',
+  descr => 'internal conversion function for ISO-8859-5 to WIN866',
+  proname => 'iso_to_win866', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'iso_to_win866',
+  probin => '$libdir/cyrillic_and_mic' },
+{ oid => '4321',
+  descr => 'internal conversion function for WIN866 to ISO-8859-5',
+  proname => 'win866_to_iso', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'win866_to_iso',
+  probin => '$libdir/cyrillic_and_mic' },
+{ oid => '4322',
+  descr => 'internal conversion function for EUC_CN to MULE_INTERNAL',
+  proname => 'euc_cn_to_mic', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'euc_cn_to_mic',
+  probin => '$libdir/euc_cn_and_mic' },
+{ oid => '4323',
+  descr => 'internal conversion function for MULE_INTERNAL to EUC_CN',
+  proname => 'mic_to_euc_cn', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'mic_to_euc_cn',
+  probin => '$libdir/euc_cn_and_mic' },
+{ oid => '4324', descr => 'internal conversion function for EUC_JP to SJIS',
+  proname => 'euc_jp_to_sjis', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'euc_jp_to_sjis',
+  probin => '$libdir/euc_jp_and_sjis' },
+{ oid => '4325', descr => 'internal conversion function for SJIS to EUC_JP',
+  proname => 'sjis_to_euc_jp', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'sjis_to_euc_jp',
+  probin => '$libdir/euc_jp_and_sjis' },
+{ oid => '4326',
+  descr => 'internal conversion function for EUC_JP to MULE_INTERNAL',
+  proname => 'euc_jp_to_mic', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'euc_jp_to_mic',
+  probin => '$libdir/euc_jp_and_sjis' },
+{ oid => '4327',
+  descr => 'internal conversion function for SJIS to MULE_INTERNAL',
+  proname => 'sjis_to_mic', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'sjis_to_mic',
+  probin => '$libdir/euc_jp_and_sjis' },
+{ oid => '4328',
+  descr => 'internal conversion function for MULE_INTERNAL to EUC_JP',
+  proname => 'mic_to_euc_jp', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'mic_to_euc_jp',
+  probin => '$libdir/euc_jp_and_sjis' },
+{ oid => '4329',
+  descr => 'internal conversion function for MULE_INTERNAL to SJIS',
+  proname => 'mic_to_sjis', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'mic_to_sjis',
+  probin => '$libdir/euc_jp_and_sjis' },
+{ oid => '4330',
+  descr => 'internal conversion function for EUC_KR to MULE_INTERNAL',
+  proname => 'euc_kr_to_mic', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'euc_kr_to_mic',
+  probin => '$libdir/euc_kr_and_mic' },
+{ oid => '4331',
+  descr => 'internal conversion function for MULE_INTERNAL to EUC_KR',
+  proname => 'mic_to_euc_kr', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'mic_to_euc_kr',
+  probin => '$libdir/euc_kr_and_mic' },
+{ oid => '4332', descr => 'internal conversion function for EUC_TW to BIG5',
+  proname => 'euc_tw_to_big5', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'euc_tw_to_big5',
+  probin => '$libdir/euc_tw_and_big5' },
+{ oid => '4333', descr => 'internal conversion function for BIG5 to EUC_TW',
+  proname => 'big5_to_euc_tw', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'big5_to_euc_tw',
+  probin => '$libdir/euc_tw_and_big5' },
+{ oid => '4334',
+  descr => 'internal conversion function for EUC_TW to MULE_INTERNAL',
+  proname => 'euc_tw_to_mic', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'euc_tw_to_mic',
+  probin => '$libdir/euc_tw_and_big5' },
+{ oid => '4335',
+  descr => 'internal conversion function for BIG5 to MULE_INTERNAL',
+  proname => 'big5_to_mic', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'big5_to_mic',
+  probin => '$libdir/euc_tw_and_big5' },
+{ oid => '4336',
+  descr => 'internal conversion function for MULE_INTERNAL to EUC_TW',
+  proname => 'mic_to_euc_tw', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'mic_to_euc_tw',
+  probin => '$libdir/euc_tw_and_big5' },
+{ oid => '4337',
+  descr => 'internal conversion function for MULE_INTERNAL to BIG5',
+  proname => 'mic_to_big5', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'mic_to_big5',
+  probin => '$libdir/euc_tw_and_big5' },
+{ oid => '4338',
+  descr => 'internal conversion function for LATIN2 to MULE_INTERNAL',
+  proname => 'latin2_to_mic', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'latin2_to_mic',
+  probin => '$libdir/latin2_and_win1250' },
+{ oid => '4339',
+  descr => 'internal conversion function for MULE_INTERNAL to LATIN2',
+  proname => 'mic_to_latin2', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'mic_to_latin2',
+  probin => '$libdir/latin2_and_win1250' },
+{ oid => '4340',
+  descr => 'internal conversion function for WIN1250 to MULE_INTERNAL',
+  proname => 'win1250_to_mic', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'win1250_to_mic',
+  probin => '$libdir/latin2_and_win1250' },
+{ oid => '4341',
+  descr => 'internal conversion function for MULE_INTERNAL to WIN1250',
+  proname => 'mic_to_win1250', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'mic_to_win1250',
+  probin => '$libdir/latin2_and_win1250' },
+{ oid => '4342',
+  descr => 'internal conversion function for LATIN2 to WIN1250',
+  proname => 'latin2_to_win1250', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4',
+  prosrc => 'latin2_to_win1250', probin => '$libdir/latin2_and_win1250' },
+{ oid => '4343',
+  descr => 'internal conversion function for WIN1250 to LATIN2',
+  proname => 'win1250_to_latin2', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4',
+  prosrc => 'win1250_to_latin2', probin => '$libdir/latin2_and_win1250' },
+{ oid => '4344',
+  descr => 'internal conversion function for LATIN1 to MULE_INTERNAL',
+  proname => 'latin1_to_mic', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'latin1_to_mic',
+  probin => '$libdir/latin_and_mic' },
+{ oid => '4345',
+  descr => 'internal conversion function for MULE_INTERNAL to LATIN1',
+  proname => 'mic_to_latin1', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'mic_to_latin1',
+  probin => '$libdir/latin_and_mic' },
+{ oid => '4346',
+  descr => 'internal conversion function for LATIN3 to MULE_INTERNAL',
+  proname => 'latin3_to_mic', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'latin3_to_mic',
+  probin => '$libdir/latin_and_mic' },
+{ oid => '4347',
+  descr => 'internal conversion function for MULE_INTERNAL to LATIN3',
+  proname => 'mic_to_latin3', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'mic_to_latin3',
+  probin => '$libdir/latin_and_mic' },
+{ oid => '4348',
+  descr => 'internal conversion function for LATIN4 to MULE_INTERNAL',
+  proname => 'latin4_to_mic', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'latin4_to_mic',
+  probin => '$libdir/latin_and_mic' },
+{ oid => '4349',
+  descr => 'internal conversion function for MULE_INTERNAL to LATIN4',
+  proname => 'mic_to_latin4', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'mic_to_latin4',
+  probin => '$libdir/latin_and_mic' },
+{ oid => '4352', descr => 'internal conversion function for BIG5 to UTF8',
+  proname => 'big5_to_utf8', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'big5_to_utf8',
+  probin => '$libdir/utf8_and_big5' },
+{ oid => '4353', descr => 'internal conversion function for UTF8 to BIG5',
+  proname => 'utf8_to_big5', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'utf8_to_big5',
+  probin => '$libdir/utf8_and_big5' },
+{ oid => '4354', descr => 'internal conversion function for UTF8 to KOI8R',
+  proname => 'utf8_to_koi8r', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'utf8_to_koi8r',
+  probin => '$libdir/utf8_and_cyrillic' },
+{ oid => '4355', descr => 'internal conversion function for KOI8R to UTF8',
+  proname => 'koi8r_to_utf8', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'koi8r_to_utf8',
+  probin => '$libdir/utf8_and_cyrillic' },
+{ oid => '4356', descr => 'internal conversion function for UTF8 to KOI8U',
+  proname => 'utf8_to_koi8u', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'utf8_to_koi8u',
+  probin => '$libdir/utf8_and_cyrillic' },
+{ oid => '4357', descr => 'internal conversion function for KOI8U to UTF8',
+  proname => 'koi8u_to_utf8', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'koi8u_to_utf8',
+  probin => '$libdir/utf8_and_cyrillic' },
+{ oid => '4358', descr => 'internal conversion function for UTF8 to WIN',
+  proname => 'utf8_to_win', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'utf8_to_win',
+  probin => '$libdir/utf8_and_win' },
+{ oid => '4359', descr => 'internal conversion function for WIN to UTF8',
+  proname => 'win_to_utf8', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'win_to_utf8',
+  probin => '$libdir/utf8_and_win' },
+{ oid => '4360', descr => 'internal conversion function for EUC_CN to UTF8',
+  proname => 'euc_cn_to_utf8', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'euc_cn_to_utf8',
+  probin => '$libdir/utf8_and_euc_cn' },
+{ oid => '4361', descr => 'internal conversion function for UTF8 to EUC_CN',
+  proname => 'utf8_to_euc_cn', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'utf8_to_euc_cn',
+  probin => '$libdir/utf8_and_euc_cn' },
+{ oid => '4362', descr => 'internal conversion function for EUC_JP to UTF8',
+  proname => 'euc_jp_to_utf8', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'euc_jp_to_utf8',
+  probin => '$libdir/utf8_and_euc_jp' },
+{ oid => '4363', descr => 'internal conversion function for UTF8 to EUC_JP',
+  proname => 'utf8_to_euc_jp', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'utf8_to_euc_jp',
+  probin => '$libdir/utf8_and_euc_jp' },
+{ oid => '4364', descr => 'internal conversion function for EUC_KR to UTF8',
+  proname => 'euc_kr_to_utf8', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'euc_kr_to_utf8',
+  probin => '$libdir/utf8_and_euc_kr' },
+{ oid => '4365', descr => 'internal conversion function for UTF8 to EUC_KR',
+  proname => 'utf8_to_euc_kr', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'utf8_to_euc_kr',
+  probin => '$libdir/utf8_and_euc_kr' },
+{ oid => '4366', descr => 'internal conversion function for EUC_TW to UTF8',
+  proname => 'euc_tw_to_utf8', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'euc_tw_to_utf8',
+  probin => '$libdir/utf8_and_euc_tw' },
+{ oid => '4367', descr => 'internal conversion function for UTF8 to EUC_TW',
+  proname => 'utf8_to_euc_tw', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'utf8_to_euc_tw',
+  probin => '$libdir/utf8_and_euc_tw' },
+{ oid => '4368', descr => 'internal conversion function for GB18030 to UTF8',
+  proname => 'gb18030_to_utf8', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'gb18030_to_utf8',
+  probin => '$libdir/utf8_and_gb18030' },
+{ oid => '4369', descr => 'internal conversion function for UTF8 to GB18030',
+  proname => 'utf8_to_gb18030', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'utf8_to_gb18030',
+  probin => '$libdir/utf8_and_gb18030' },
+{ oid => '4370', descr => 'internal conversion function for GBK to UTF8',
+  proname => 'gbk_to_utf8', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'gbk_to_utf8',
+  probin => '$libdir/utf8_and_gbk' },
+{ oid => '4371', descr => 'internal conversion function for UTF8 to GBK',
+  proname => 'utf8_to_gbk', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'utf8_to_gbk',
+  probin => '$libdir/utf8_and_gbk' },
+{ oid => '4372',
+  descr => 'internal conversion function for UTF8 to ISO-8859 2-16',
+  proname => 'utf8_to_iso8859', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'utf8_to_iso8859',
+  probin => '$libdir/utf8_and_iso8859' },
+{ oid => '4373',
+  descr => 'internal conversion function for ISO-8859 2-16 to UTF8',
+  proname => 'iso8859_to_utf8', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'iso8859_to_utf8',
+  probin => '$libdir/utf8_and_iso8859' },
+{ oid => '4374', descr => 'internal conversion function for LATIN1 to UTF8',
+  proname => 'iso8859_1_to_utf8', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4',
+  prosrc => 'iso8859_1_to_utf8', probin => '$libdir/utf8_and_iso8859_1' },
+{ oid => '4375', descr => 'internal conversion function for UTF8 to LATIN1',
+  proname => 'utf8_to_iso8859_1', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4',
+  prosrc => 'utf8_to_iso8859_1', probin => '$libdir/utf8_and_iso8859_1' },
+{ oid => '4376', descr => 'internal conversion function for JOHAB to UTF8',
+  proname => 'johab_to_utf8', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'johab_to_utf8',
+  probin => '$libdir/utf8_and_johab' },
+{ oid => '4377', descr => 'internal conversion function for UTF8 to JOHAB',
+  proname => 'utf8_to_johab', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'utf8_to_johab',
+  probin => '$libdir/utf8_and_johab' },
+{ oid => '4378', descr => 'internal conversion function for SJIS to UTF8',
+  proname => 'sjis_to_utf8', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'sjis_to_utf8',
+  probin => '$libdir/utf8_and_sjis' },
+{ oid => '4379', descr => 'internal conversion function for UTF8 to SJIS',
+  proname => 'utf8_to_sjis', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'utf8_to_sjis',
+  probin => '$libdir/utf8_and_sjis' },
+{ oid => '4380', descr => 'internal conversion function for UHC to UTF8',
+  proname => 'uhc_to_utf8', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'uhc_to_utf8',
+  probin => '$libdir/utf8_and_uhc' },
+{ oid => '4381', descr => 'internal conversion function for UTF8 to UHC',
+  proname => 'utf8_to_uhc', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4', prosrc => 'utf8_to_uhc',
+  probin => '$libdir/utf8_and_uhc' },
+{ oid => '4382',
+  descr => 'internal conversion function for EUC_JIS_2004 to UTF8',
+  proname => 'euc_jis_2004_to_utf8', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4',
+  prosrc => 'euc_jis_2004_to_utf8', probin => '$libdir/utf8_and_euc2004' },
+{ oid => '4383',
+  descr => 'internal conversion function for UTF8 to EUC_JIS_2004',
+  proname => 'utf8_to_euc_jis_2004', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4',
+  prosrc => 'utf8_to_euc_jis_2004', probin => '$libdir/utf8_and_euc2004' },
+{ oid => '4384',
+  descr => 'internal conversion function for SHIFT_JIS_2004 to UTF8',
+  proname => 'shift_jis_2004_to_utf8', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4',
+  prosrc => 'shift_jis_2004_to_utf8', probin => '$libdir/utf8_and_sjis2004' },
+{ oid => '4385',
+  descr => 'internal conversion function for UTF8 to SHIFT_JIS_2004',
+  proname => 'utf8_to_shift_jis_2004', prolang => 'c', prorettype => 'void',
+  proargtypes => 'int4 int4 cstring internal int4',
+  prosrc => 'utf8_to_shift_jis_2004', probin => '$libdir/utf8_and_sjis2004' },
+{ oid => '4386',
+  descr => 'internal conversion function for EUC_JIS_2004 to SHIFT_JIS_2004',
+  proname => 'euc_jis_2004_to_shift_jis_2004', prolang => 'c',
+  prorettype => 'void', proargtypes => 'int4 int4 cstring internal int4',
+  prosrc => 'euc_jis_2004_to_shift_jis_2004',
+  probin => '$libdir/euc2004_sjis2004' },
+{ oid => '4387',
+  descr => 'internal conversion function for SHIFT_JIS_2004 to EUC_JIS_2004',
+  proname => 'shift_jis_2004_to_euc_jis_2004', prolang => 'c',
+  prorettype => 'void', proargtypes => 'int4 int4 cstring internal int4',
+  prosrc => 'shift_jis_2004_to_euc_jis_2004',
+  probin => '$libdir/euc2004_sjis2004' },
+
+{ oid => '5040',
+  descr => 'restriction selectivity for generic matching operators',
+  proname => 'matchingsel', provolatile => 's', prorettype => 'float8',
+  proargtypes => 'internal oid internal int4', prosrc => 'matchingsel' },
+{ oid => '5041', descr => 'join selectivity for generic matching operators',
+  proname => 'matchingjoinsel', provolatile => 's', prorettype => 'float8',
+  proargtypes => 'internal oid internal int2 internal',
+  prosrc => 'matchingjoinsel' },
+
+# 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 origin 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', provolatile => 's',
+  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,int4}',
+  proargmodes => '{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,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' },
+{ oid => '5031', descr => 'list of files in the archive_status directory',
+  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' },
+{ 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}',
+  proargnames => '{tablespace,name,size,modification}',
+  prosrc => 'pg_ls_tmpdir_1arg' },
+
+# 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' },
+
+# 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}',
+  prosrc => 'pg_partition_tree' },
+{ oid => '3425', descr => 'view ancestors of the partition',
+  proname => 'pg_partition_ancestors', prorows => '10', proretset => 't',
+  provolatile => 'v', prorettype => 'regclass', proargtypes => 'regclass',
+  proallargtypes => '{regclass,regclass}', proargmodes => '{i,o}',
+  proargnames => '{partitionid,relid}', prosrc => 'pg_partition_ancestors' },
+
+# function to get the top-most partition root parent
+{ oid => '3424', descr => 'get top-most partition root parent',
+  proname => 'pg_partition_root', prorettype => 'regclass',
+  proargtypes => 'regclass', prosrc => 'pg_partition_root' },
+
+{ oid => '4350', descr => 'Unicode normalization',
+  proname => 'normalize', prorettype => 'text', proargtypes => 'text text',
+  prosrc => 'unicode_normalize_func' },
+
+{ oid => '4351', descr => 'check Unicode normalization',
+  proname => 'is_normalized', prorettype => 'bool', proargtypes => 'text text',
+  prosrc => 'unicode_is_normalized' },
+
+]
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_proc.h b/contrib/libs/postgresql/src/include/catalog/pg_proc.h
new file mode 100644
index 0000000000..ee3959da09
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_proc.h
@@ -0,0 +1,211 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_proc.h
+ *	  definition of the "procedure" system catalog (pg_proc)
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_proc.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_PROC_H
+#define PG_PROC_H
+
+#include "catalog/genbki.h"
+#include "catalog/objectaddress.h"
+#include "catalog/pg_proc_d.h"
+#include "nodes/pg_list.h"
+
+/* ----------------
+ *		pg_proc definition.  cpp turns this into
+ *		typedef struct FormData_pg_proc
+ * ----------------
+ */
+CATALOG(pg_proc,1255,ProcedureRelationId) BKI_BOOTSTRAP BKI_ROWTYPE_OID(81,ProcedureRelation_Rowtype_Id) BKI_SCHEMA_MACRO
+{
+	Oid			oid;			/* oid */
+
+	/* procedure name */
+	NameData	proname;
+
+	/* OID of namespace containing this proc */
+	Oid			pronamespace BKI_DEFAULT(PGNSP);
+
+	/* procedure owner */
+	Oid			proowner BKI_DEFAULT(PGUID);
+
+	/* OID of pg_language entry */
+	Oid			prolang BKI_DEFAULT(internal) BKI_LOOKUP(pg_language);
+
+	/* estimated execution cost */
+	float4		procost BKI_DEFAULT(1);
+
+	/* estimated # of rows out (if proretset) */
+	float4		prorows BKI_DEFAULT(0);
+
+	/* element type of variadic array, or 0 */
+	Oid			provariadic BKI_DEFAULT(0) BKI_LOOKUP(pg_type);
+
+	/* planner support function for this function, or 0 if none */
+	regproc		prosupport BKI_DEFAULT(0) BKI_LOOKUP(pg_proc);
+
+	/* see PROKIND_ categories below */
+	char		prokind BKI_DEFAULT(f);
+
+	/* security definer */
+	bool		prosecdef BKI_DEFAULT(f);
+
+	/* is it a leak-proof function? */
+	bool		proleakproof BKI_DEFAULT(f);
+
+	/* strict with respect to NULLs? */
+	bool		proisstrict BKI_DEFAULT(t);
+
+	/* returns a set? */
+	bool		proretset BKI_DEFAULT(f);
+
+	/* see PROVOLATILE_ categories below */
+	char		provolatile BKI_DEFAULT(i);
+
+	/* see PROPARALLEL_ categories below */
+	char		proparallel BKI_DEFAULT(s);
+
+	/* number of arguments */
+	/* Note: need not be given in pg_proc.dat; genbki.pl will compute it */
+	int16		pronargs;
+
+	/* number of arguments with defaults */
+	int16		pronargdefaults BKI_DEFAULT(0);
+
+	/* OID of result type */
+	Oid			prorettype BKI_LOOKUP(pg_type);
+
+	/*
+	 * variable-length fields start here, but we allow direct access to
+	 * proargtypes
+	 */
+
+	/* parameter types (excludes OUT params) */
+	oidvector	proargtypes BKI_LOOKUP(pg_type);
+
+#ifdef CATALOG_VARLEN
+
+	/* all param types (NULL if IN only) */
+	Oid			proallargtypes[1] BKI_DEFAULT(_null_) BKI_LOOKUP(pg_type);
+
+	/* parameter modes (NULL if IN only) */
+	char		proargmodes[1] BKI_DEFAULT(_null_);
+
+	/* parameter names (NULL if no names) */
+	text		proargnames[1] BKI_DEFAULT(_null_);
+
+	/* list of expression trees for argument defaults (NULL if none) */
+	pg_node_tree proargdefaults BKI_DEFAULT(_null_);
+
+	/* types for which to apply transforms */
+	Oid			protrftypes[1] BKI_DEFAULT(_null_);
+
+	/* procedure source text */
+	text		prosrc BKI_FORCE_NOT_NULL;
+
+	/* secondary procedure info (can be NULL) */
+	text		probin BKI_DEFAULT(_null_);
+
+	/* procedure-local GUC settings */
+	text		proconfig[1] BKI_DEFAULT(_null_);
+
+	/* access permissions */
+	aclitem		proacl[1] BKI_DEFAULT(_null_);
+#endif
+} FormData_pg_proc;
+
+/* ----------------
+ *		Form_pg_proc corresponds to a pointer to a tuple with
+ *		the format of pg_proc relation.
+ * ----------------
+ */
+typedef FormData_pg_proc *Form_pg_proc;
+
+#ifdef EXPOSE_TO_CLIENT_CODE
+
+/*
+ * Symbolic values for prokind column
+ */
+#define PROKIND_FUNCTION 'f'
+#define PROKIND_AGGREGATE 'a'
+#define PROKIND_WINDOW 'w'
+#define PROKIND_PROCEDURE 'p'
+
+/*
+ * Symbolic values for provolatile column: these indicate whether the result
+ * of a function is dependent *only* on the values of its explicit arguments,
+ * or can change due to outside factors (such as parameter variables or
+ * table contents).  NOTE: functions having side-effects, such as setval(),
+ * must be labeled volatile to ensure they will not get optimized away,
+ * even if the actual return value is not changeable.
+ */
+#define PROVOLATILE_IMMUTABLE	'i' /* never changes for given input */
+#define PROVOLATILE_STABLE		's' /* does not change within a scan */
+#define PROVOLATILE_VOLATILE	'v' /* can change even within a scan */
+
+/*
+ * Symbolic values for proparallel column: these indicate whether a function
+ * can be safely be run in a parallel backend, during parallelism but
+ * necessarily in the master, or only in non-parallel mode.
+ */
+#define PROPARALLEL_SAFE		's' /* can run in worker or master */
+#define PROPARALLEL_RESTRICTED	'r' /* can run in parallel master only */
+#define PROPARALLEL_UNSAFE		'u' /* banned while in parallel mode */
+
+/*
+ * Symbolic values for proargmodes column.  Note that these must agree with
+ * the FunctionParameterMode enum in parsenodes.h; we declare them here to
+ * be accessible from either header.
+ */
+#define PROARGMODE_IN		'i'
+#define PROARGMODE_OUT		'o'
+#define PROARGMODE_INOUT	'b'
+#define PROARGMODE_VARIADIC 'v'
+#define PROARGMODE_TABLE	't'
+
+#endif							/* EXPOSE_TO_CLIENT_CODE */
+
+
+extern ObjectAddress ProcedureCreate(const char *procedureName,
+									 Oid procNamespace,
+									 bool replace,
+									 bool returnsSet,
+									 Oid returnType,
+									 Oid proowner,
+									 Oid languageObjectId,
+									 Oid languageValidator,
+									 const char *prosrc,
+									 const char *probin,
+									 char prokind,
+									 bool security_definer,
+									 bool isLeakProof,
+									 bool isStrict,
+									 char volatility,
+									 char parallel,
+									 oidvector *parameterTypes,
+									 Datum allParameterTypes,
+									 Datum parameterModes,
+									 Datum parameterNames,
+									 List *parameterDefaults,
+									 Datum trftypes,
+									 Datum proconfig,
+									 Oid prosupport,
+									 float4 procost,
+									 float4 prorows);
+
+extern bool function_parse_error_transpose(const char *prosrc);
+
+extern List *oid_array_to_list(Datum datum);
+
+#endif							/* PG_PROC_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_proc_d.h b/contrib/libs/postgresql/src/include/catalog/pg_proc_d.h
new file mode 100644
index 0000000000..bf5d3d97ee
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_proc_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_proc_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_publication.h b/contrib/libs/postgresql/src/include/catalog/pg_publication.h
new file mode 100644
index 0000000000..c876085a49
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_publication.h
@@ -0,0 +1,118 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_publication.h
+ *	  definition of the "publication" system catalog (pg_publication)
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_publication.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_PUBLICATION_H
+#define PG_PUBLICATION_H
+
+#include "catalog/genbki.h"
+#include "catalog/objectaddress.h"
+#include "catalog/pg_publication_d.h"
+
+/* ----------------
+ *		pg_publication definition.  cpp turns this into
+ *		typedef struct FormData_pg_publication
+ * ----------------
+ */
+CATALOG(pg_publication,6104,PublicationRelationId)
+{
+	Oid			oid;			/* oid */
+
+	NameData	pubname;		/* name of the publication */
+
+	Oid			pubowner;		/* publication owner */
+
+	/*
+	 * indicates that this is special publication which should encompass all
+	 * tables in the database (except for the unlogged and temp ones)
+	 */
+	bool		puballtables;
+
+	/* true if inserts are published */
+	bool		pubinsert;
+
+	/* true if updates are published */
+	bool		pubupdate;
+
+	/* true if deletes are published */
+	bool		pubdelete;
+
+	/* true if truncates are published */
+	bool		pubtruncate;
+
+	/* true if partition changes are published using root schema */
+	bool		pubviaroot;
+} FormData_pg_publication;
+
+/* ----------------
+ *		Form_pg_publication corresponds to a pointer to a tuple with
+ *		the format of pg_publication relation.
+ * ----------------
+ */
+typedef FormData_pg_publication *Form_pg_publication;
+
+typedef struct PublicationActions
+{
+	bool		pubinsert;
+	bool		pubupdate;
+	bool		pubdelete;
+	bool		pubtruncate;
+} PublicationActions;
+
+typedef struct Publication
+{
+	Oid			oid;
+	char	   *name;
+	bool		alltables;
+	bool		pubviaroot;
+	PublicationActions pubactions;
+} Publication;
+
+extern Publication *GetPublication(Oid pubid);
+extern Publication *GetPublicationByName(const char *pubname, bool missing_ok);
+extern List *GetRelationPublications(Oid relid);
+
+/*---------
+ * Expected values for pub_partopt parameter of GetRelationPublications(),
+ * which allows callers to specify which partitions of partitioned tables
+ * mentioned in the publication they expect to see.
+ *
+ *	ROOT:	only the table explicitly mentioned in the publication
+ *	LEAF:	only leaf partitions in given tree
+ *	ALL:	all partitions in given tree
+ */
+typedef enum PublicationPartOpt
+{
+	PUBLICATION_PART_ROOT,
+	PUBLICATION_PART_LEAF,
+	PUBLICATION_PART_ALL,
+} PublicationPartOpt;
+
+extern List *GetPublicationRelations(Oid pubid, PublicationPartOpt pub_partopt);
+extern List *GetAllTablesPublications(void);
+extern List *GetAllTablesPublicationRelations(bool pubviaroot);
+
+extern bool is_publishable_relation(Relation rel);
+extern ObjectAddress publication_add_relation(Oid pubid, Relation targetrel,
+											  bool if_not_exists);
+extern List *GetPubPartitionOptionRelations(List *result,
+											PublicationPartOpt pub_partopt,
+											Oid relid);
+
+extern Oid	get_publication_oid(const char *pubname, bool missing_ok);
+extern char *get_publication_name(Oid pubid, bool missing_ok);
+
+
+#endif							/* PG_PUBLICATION_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_publication_d.h b/contrib/libs/postgresql/src/include/catalog/pg_publication_d.h
new file mode 100644
index 0000000000..f78caa1ac2
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_publication_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_publication_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_publication_rel.h b/contrib/libs/postgresql/src/include/catalog/pg_publication_rel.h
new file mode 100644
index 0000000000..8ab226e4c0
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_publication_rel.h
@@ -0,0 +1,43 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_publication_rel.h
+ *	  definition of the system catalog for mappings between relations and
+ *	  publications (pg_publication_rel)
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_publication_rel.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_PUBLICATION_REL_H
+#define PG_PUBLICATION_REL_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_publication_rel_d.h"
+
+/* ----------------
+ *		pg_publication_rel definition.  cpp turns this into
+ *		typedef struct FormData_pg_publication_rel
+ * ----------------
+ */
+CATALOG(pg_publication_rel,6106,PublicationRelRelationId)
+{
+	Oid			oid;			/* oid */
+	Oid			prpubid;		/* Oid of the publication */
+	Oid			prrelid;		/* Oid of the relation */
+} FormData_pg_publication_rel;
+
+/* ----------------
+ *		Form_pg_publication_rel corresponds to a pointer to a tuple with
+ *		the format of pg_publication_rel relation.
+ * ----------------
+ */
+typedef FormData_pg_publication_rel *Form_pg_publication_rel;
+
+#endif							/* PG_PUBLICATION_REL_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_publication_rel_d.h b/contrib/libs/postgresql/src/include/catalog/pg_publication_rel_d.h
new file mode 100644
index 0000000000..0604b4b1a3
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_publication_rel_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_publication_rel_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_range.dat b/contrib/libs/postgresql/src/include/catalog/pg_range.dat
new file mode 100644
index 0000000000..479754c245
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_range.dat
@@ -0,0 +1,31 @@
+#----------------------------------------------------------------------
+#
+# pg_range.dat
+#    Initial contents of the pg_range system catalog.
+#
+# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+# Portions Copyright (c) 1994, Regents of the University of California
+#
+# src/include/catalog/pg_range.dat
+#
+#----------------------------------------------------------------------
+
+[
+
+{ rngtypid => 'int4range', rngsubtype => 'int4', rngsubopc => 'btree/int4_ops',
+  rngcanonical => 'int4range_canonical', rngsubdiff => 'int4range_subdiff' },
+{ rngtypid => 'numrange', rngsubtype => 'numeric',
+  rngsubopc => 'btree/numeric_ops', rngcanonical => '-',
+  rngsubdiff => 'numrange_subdiff' },
+{ rngtypid => 'tsrange', rngsubtype => 'timestamp',
+  rngsubopc => 'btree/timestamp_ops', rngcanonical => '-',
+  rngsubdiff => 'tsrange_subdiff' },
+{ rngtypid => 'tstzrange', rngsubtype => 'timestamptz',
+  rngsubopc => 'btree/timestamptz_ops', rngcanonical => '-',
+  rngsubdiff => 'tstzrange_subdiff' },
+{ rngtypid => 'daterange', rngsubtype => 'date', rngsubopc => 'btree/date_ops',
+  rngcanonical => 'daterange_canonical', rngsubdiff => 'daterange_subdiff' },
+{ rngtypid => 'int8range', rngsubtype => 'int8', rngsubopc => 'btree/int8_ops',
+  rngcanonical => 'int8range_canonical', rngsubdiff => 'int8range_subdiff' },
+
+]
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_range.h b/contrib/libs/postgresql/src/include/catalog/pg_range.h
new file mode 100644
index 0000000000..98172bb1b6
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_range.h
@@ -0,0 +1,66 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_range.h
+ *	  definition of the "range type" system catalog (pg_range)
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_range.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_RANGE_H
+#define PG_RANGE_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_range_d.h"
+
+/* ----------------
+ *		pg_range definition.  cpp turns this into
+ *		typedef struct FormData_pg_range
+ * ----------------
+ */
+CATALOG(pg_range,3541,RangeRelationId)
+{
+	/* OID of owning range type */
+	Oid			rngtypid BKI_LOOKUP(pg_type);
+
+	/* OID of range's element type (subtype) */
+	Oid			rngsubtype BKI_LOOKUP(pg_type);
+
+	/* collation for this range type, or 0 */
+	Oid			rngcollation BKI_DEFAULT(0);
+
+	/* subtype's btree opclass */
+	Oid			rngsubopc BKI_LOOKUP(pg_opclass);
+
+	/* canonicalize range, or 0 */
+	regproc		rngcanonical BKI_LOOKUP(pg_proc);
+
+	/* subtype difference as a float8, or 0 */
+	regproc		rngsubdiff BKI_LOOKUP(pg_proc);
+} FormData_pg_range;
+
+/* ----------------
+ *		Form_pg_range corresponds to a pointer to a tuple with
+ *		the format of pg_range relation.
+ * ----------------
+ */
+typedef FormData_pg_range *Form_pg_range;
+
+/*
+ * prototypes for functions in pg_range.c
+ */
+
+extern void RangeCreate(Oid rangeTypeOid, Oid rangeSubType, Oid rangeCollation,
+						Oid rangeSubOpclass, RegProcedure rangeCanonical,
+						RegProcedure rangeSubDiff);
+extern void RangeDelete(Oid rangeTypeOid);
+
+#endif							/* PG_RANGE_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_range_d.h b/contrib/libs/postgresql/src/include/catalog/pg_range_d.h
new file mode 100644
index 0000000000..be0ad6f521
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_range_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_range_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_replication_origin.h b/contrib/libs/postgresql/src/include/catalog/pg_replication_origin.h
new file mode 100644
index 0000000000..7477ce49cc
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_replication_origin.h
@@ -0,0 +1,57 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_replication_origin.h
+ *	  definition of the "replication origin" system catalog
+ *	  (pg_replication_origin)
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_replication_origin.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_REPLICATION_ORIGIN_H
+#define PG_REPLICATION_ORIGIN_H
+
+#include "access/xlogdefs.h"
+#include "catalog/genbki.h"
+#include "catalog/pg_replication_origin_d.h"
+
+/* ----------------
+ *		pg_replication_origin.  cpp turns this into
+ *		typedef struct FormData_pg_replication_origin
+ * ----------------
+ */
+CATALOG(pg_replication_origin,6000,ReplicationOriginRelationId) BKI_SHARED_RELATION
+{
+	/*
+	 * Locally known id that get included into WAL.
+	 *
+	 * This should never leave the system.
+	 *
+	 * Needs to fit into an uint16, so we don't waste too much space in WAL
+	 * records. For this reason we don't use a normal Oid column here, since
+	 * we need to handle allocation of new values manually.
+	 */
+	Oid			roident;
+
+	/*
+	 * Variable-length fields start here, but we allow direct access to
+	 * roname.
+	 */
+
+	/* external, free-format, name */
+	text		roname BKI_FORCE_NOT_NULL;
+
+#ifdef CATALOG_VARLEN			/* further variable-length fields */
+#endif
+} FormData_pg_replication_origin;
+
+typedef FormData_pg_replication_origin *Form_pg_replication_origin;
+
+#endif							/* PG_REPLICATION_ORIGIN_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_replication_origin_d.h b/contrib/libs/postgresql/src/include/catalog/pg_replication_origin_d.h
new file mode 100644
index 0000000000..f42fe89aac
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_replication_origin_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_replication_origin_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_rewrite.h b/contrib/libs/postgresql/src/include/catalog/pg_rewrite.h
new file mode 100644
index 0000000000..4369fc87c6
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_rewrite.h
@@ -0,0 +1,54 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_rewrite.h
+ *	  definition of the "rewrite rule" system catalog (pg_rewrite)
+ *
+ * As of Postgres 7.3, the primary key for this table is <ev_class, rulename>
+ * --- ie, rule names are only unique among the rules of a given table.
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_rewrite.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_REWRITE_H
+#define PG_REWRITE_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_rewrite_d.h"
+
+/* ----------------
+ *		pg_rewrite definition.  cpp turns this into
+ *		typedef struct FormData_pg_rewrite
+ * ----------------
+ */
+CATALOG(pg_rewrite,2618,RewriteRelationId)
+{
+	Oid			oid;			/* oid */
+	NameData	rulename;
+	Oid			ev_class;
+	char		ev_type;
+	char		ev_enabled;
+	bool		is_instead;
+
+#ifdef CATALOG_VARLEN			/* variable-length fields start here */
+	pg_node_tree ev_qual BKI_FORCE_NOT_NULL;
+	pg_node_tree ev_action BKI_FORCE_NOT_NULL;
+#endif
+} FormData_pg_rewrite;
+
+/* ----------------
+ *		Form_pg_rewrite corresponds to a pointer to a tuple with
+ *		the format of pg_rewrite relation.
+ * ----------------
+ */
+typedef FormData_pg_rewrite *Form_pg_rewrite;
+
+#endif							/* PG_REWRITE_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_rewrite_d.h b/contrib/libs/postgresql/src/include/catalog/pg_rewrite_d.h
new file mode 100644
index 0000000000..633a69fd37
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_rewrite_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_rewrite_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_seclabel.h b/contrib/libs/postgresql/src/include/catalog/pg_seclabel.h
new file mode 100644
index 0000000000..07d4bff119
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_seclabel.h
@@ -0,0 +1,40 @@
+/* -------------------------------------------------------------------------
+ *
+ * pg_seclabel.h
+ *	  definition of the "security label" system catalog (pg_seclabel)
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_seclabel.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ * -------------------------------------------------------------------------
+ */
+#ifndef PG_SECLABEL_H
+#define PG_SECLABEL_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_seclabel_d.h"
+
+/* ----------------
+ *		pg_seclabel definition.  cpp turns this into
+ *		typedef struct FormData_pg_seclabel
+ * ----------------
+ */
+CATALOG(pg_seclabel,3596,SecLabelRelationId)
+{
+	Oid			objoid;			/* OID of the object itself */
+	Oid			classoid;		/* OID of table containing the object */
+	int32		objsubid;		/* column number, or 0 if not used */
+
+#ifdef CATALOG_VARLEN			/* variable-length fields start here */
+	text		provider BKI_FORCE_NOT_NULL;	/* name of label provider */
+	text		label BKI_FORCE_NOT_NULL;	/* security label of the object */
+#endif
+} FormData_pg_seclabel;
+
+#endif							/* PG_SECLABEL_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_seclabel_d.h b/contrib/libs/postgresql/src/include/catalog/pg_seclabel_d.h
new file mode 100644
index 0000000000..e8c167dfe1
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_seclabel_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_seclabel_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_sequence.h b/contrib/libs/postgresql/src/include/catalog/pg_sequence.h
new file mode 100644
index 0000000000..9459edd95b
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_sequence.h
@@ -0,0 +1,42 @@
+/* -------------------------------------------------------------------------
+ *
+ * pg_sequence.h
+ *	  definition of the "sequence" system catalog (pg_sequence)
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_sequence.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ * -------------------------------------------------------------------------
+ */
+#ifndef PG_SEQUENCE_H
+#define PG_SEQUENCE_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_sequence_d.h"
+
+CATALOG(pg_sequence,2224,SequenceRelationId)
+{
+	Oid			seqrelid;
+	Oid			seqtypid;
+	int64		seqstart;
+	int64		seqincrement;
+	int64		seqmax;
+	int64		seqmin;
+	int64		seqcache;
+	bool		seqcycle;
+} FormData_pg_sequence;
+
+/* ----------------
+ *		Form_pg_sequence corresponds to a pointer to a tuple with
+ *		the format of pg_sequence relation.
+ * ----------------
+ */
+typedef FormData_pg_sequence *Form_pg_sequence;
+
+#endif							/* PG_SEQUENCE_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_sequence_d.h b/contrib/libs/postgresql/src/include/catalog/pg_sequence_d.h
new file mode 100644
index 0000000000..70f7a70258
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_sequence_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_sequence_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_shdepend.h b/contrib/libs/postgresql/src/include/catalog/pg_shdepend.h
new file mode 100644
index 0000000000..7c3fd5b08e
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_shdepend.h
@@ -0,0 +1,72 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_shdepend.h
+ *	  definition of the "shared dependency" system catalog (pg_shdepend)
+ *
+ * pg_shdepend has no preloaded contents, so there is no pg_shdepend.dat
+ * file; system-defined dependencies are loaded into it during a late stage
+ * of the initdb process.
+ *
+ * NOTE: we do not represent all possible dependency pairs in pg_shdepend;
+ * for example, there's not much value in creating an explicit dependency
+ * from a relation to its database.  Currently, only dependencies on roles
+ * are explicitly stored in pg_shdepend.
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_shdepend.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_SHDEPEND_H
+#define PG_SHDEPEND_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_shdepend_d.h"
+
+/* ----------------
+ *		pg_shdepend definition.  cpp turns this into
+ *		typedef struct FormData_pg_shdepend
+ * ----------------
+ */
+CATALOG(pg_shdepend,1214,SharedDependRelationId) BKI_SHARED_RELATION
+{
+	/*
+	 * Identification of the dependent (referencing) object.
+	 *
+	 * These fields are all zeroes for a DEPENDENCY_PIN entry.  Also, dbid can
+	 * be zero to denote a shared object.
+	 */
+	Oid			dbid;			/* OID of database containing object */
+	Oid			classid;		/* OID of table containing object */
+	Oid			objid;			/* OID of object itself */
+	int32		objsubid;		/* column number, or 0 if not used */
+
+	/*
+	 * Identification of the independent (referenced) object.  This is always
+	 * a shared object, so we need no database ID field.  We don't bother with
+	 * a sub-object ID either.
+	 */
+	Oid			refclassid;		/* OID of table containing object */
+	Oid			refobjid;		/* OID of object itself */
+
+	/*
+	 * Precise semantics of the relationship are specified by the deptype
+	 * field.  See SharedDependencyType in catalog/dependency.h.
+	 */
+	char		deptype;		/* see codes in dependency.h */
+} FormData_pg_shdepend;
+
+/* ----------------
+ *		Form_pg_shdepend corresponds to a pointer to a row with
+ *		the format of pg_shdepend relation.
+ * ----------------
+ */
+typedef FormData_pg_shdepend *Form_pg_shdepend;
+
+#endif							/* PG_SHDEPEND_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_shdepend_d.h b/contrib/libs/postgresql/src/include/catalog/pg_shdepend_d.h
new file mode 100644
index 0000000000..b3b9f33f27
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_shdepend_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_shdepend_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_shdescription.h b/contrib/libs/postgresql/src/include/catalog/pg_shdescription.h
new file mode 100644
index 0000000000..a8238aa793
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_shdescription.h
@@ -0,0 +1,58 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_shdescription.h
+ *	  definition of the "shared description" system catalog
+ *	  (pg_shdescription)
+ *
+ * Because the contents of this table are taken from the *.dat files
+ * of other catalogs, there is no pg_shdescription.dat file. The initial
+ * contents are assembled by genbki.pl and loaded during initdb.
+ *
+ * NOTE: an object is identified by the OID of the row that primarily
+ * defines the object, plus the OID of the table that that row appears in.
+ * For example, a database is identified by the OID of its pg_database row
+ * plus the pg_class OID of table pg_database.  This allows unique
+ * identification of objects without assuming that OIDs are unique
+ * across tables.
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_shdescription.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_SHDESCRIPTION_H
+#define PG_SHDESCRIPTION_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_shdescription_d.h"
+
+/* ----------------
+ *		pg_shdescription definition.    cpp turns this into
+ *		typedef struct FormData_pg_shdescription
+ * ----------------
+ */
+CATALOG(pg_shdescription,2396,SharedDescriptionRelationId) BKI_SHARED_RELATION
+{
+	Oid			objoid;			/* OID of object itself */
+	Oid			classoid;		/* OID of table containing object */
+
+#ifdef CATALOG_VARLEN			/* variable-length fields start here */
+	text		description BKI_FORCE_NOT_NULL; /* description of object */
+#endif
+} FormData_pg_shdescription;
+
+/* ----------------
+ *		Form_pg_shdescription corresponds to a pointer to a tuple with
+ *		the format of pg_shdescription relation.
+ * ----------------
+ */
+typedef FormData_pg_shdescription * Form_pg_shdescription;
+
+#endif							/* PG_SHDESCRIPTION_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_shdescription_d.h b/contrib/libs/postgresql/src/include/catalog/pg_shdescription_d.h
new file mode 100644
index 0000000000..4981c86b7c
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_shdescription_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_shdescription_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_shseclabel.h b/contrib/libs/postgresql/src/include/catalog/pg_shseclabel.h
new file mode 100644
index 0000000000..331e066448
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_shseclabel.h
@@ -0,0 +1,41 @@
+/* -------------------------------------------------------------------------
+ *
+ * pg_shseclabel.h
+ *	  definition of the "shared security label" system catalog (pg_shseclabel)
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_shseclabel.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ * -------------------------------------------------------------------------
+ */
+#ifndef PG_SHSECLABEL_H
+#define PG_SHSECLABEL_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_shseclabel_d.h"
+
+/* ----------------
+ *		pg_shseclabel definition. cpp turns this into
+ *		typedef struct FormData_pg_shseclabel
+ * ----------------
+ */
+CATALOG(pg_shseclabel,3592,SharedSecLabelRelationId) BKI_SHARED_RELATION BKI_ROWTYPE_OID(4066,SharedSecLabelRelation_Rowtype_Id) BKI_SCHEMA_MACRO
+{
+	Oid			objoid;			/* OID of the shared object itself */
+	Oid			classoid;		/* OID of table containing the shared object */
+
+#ifdef CATALOG_VARLEN			/* variable-length fields start here */
+	text		provider BKI_FORCE_NOT_NULL;	/* name of label provider */
+	text		label BKI_FORCE_NOT_NULL;	/* security label of the object */
+#endif
+} FormData_pg_shseclabel;
+
+typedef FormData_pg_shseclabel * Form_pg_shseclabel;
+
+#endif							/* PG_SHSECLABEL_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_shseclabel_d.h b/contrib/libs/postgresql/src/include/catalog/pg_shseclabel_d.h
new file mode 100644
index 0000000000..56688085b5
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_shseclabel_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_shseclabel_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_statistic.h b/contrib/libs/postgresql/src/include/catalog/pg_statistic.h
new file mode 100644
index 0000000000..40a7260165
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_statistic.h
@@ -0,0 +1,275 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_statistic.h
+ *	  definition of the "statistics" system catalog (pg_statistic)
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_statistic.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_STATISTIC_H
+#define PG_STATISTIC_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_statistic_d.h"
+
+/* ----------------
+ *		pg_statistic definition.  cpp turns this into
+ *		typedef struct FormData_pg_statistic
+ * ----------------
+ */
+CATALOG(pg_statistic,2619,StatisticRelationId)
+{
+	/* These fields form the unique key for the entry: */
+	Oid			starelid;		/* relation containing attribute */
+	int16		staattnum;		/* attribute (column) stats are for */
+	bool		stainherit;		/* true if inheritance children are included */
+
+	/* the fraction of the column's entries that are NULL: */
+	float4		stanullfrac;
+
+	/*
+	 * stawidth is the average width in bytes of non-null entries.  For
+	 * fixed-width datatypes this is of course the same as the typlen, but for
+	 * var-width types it is more useful.  Note that this is the average width
+	 * of the data as actually stored, post-TOASTing (eg, for a
+	 * moved-out-of-line value, only the size of the pointer object is
+	 * counted).  This is the appropriate definition for the primary use of
+	 * the statistic, which is to estimate sizes of in-memory hash tables of
+	 * tuples.
+	 */
+	int32		stawidth;
+
+	/* ----------------
+	 * stadistinct indicates the (approximate) number of distinct non-null
+	 * data values in the column.  The interpretation is:
+	 *		0		unknown or not computed
+	 *		> 0		actual number of distinct values
+	 *		< 0		negative of multiplier for number of rows
+	 * The special negative case allows us to cope with columns that are
+	 * unique (stadistinct = -1) or nearly so (for example, a column in which
+	 * non-null values appear about twice on the average could be represented
+	 * by stadistinct = -0.5 if there are no nulls, or -0.4 if 20% of the
+	 * column is nulls).  Because the number-of-rows statistic in pg_class may
+	 * be updated more frequently than pg_statistic is, it's important to be
+	 * able to describe such situations as a multiple of the number of rows,
+	 * rather than a fixed number of distinct values.  But in other cases a
+	 * fixed number is correct (eg, a boolean column).
+	 * ----------------
+	 */
+	float4		stadistinct;
+
+	/* ----------------
+	 * To allow keeping statistics on different kinds of datatypes,
+	 * we do not hard-wire any particular meaning for the remaining
+	 * statistical fields.  Instead, we provide several "slots" in which
+	 * statistical data can be placed.  Each slot includes:
+	 *		kind			integer code identifying kind of data (see below)
+	 *		op				OID of associated operator, if needed
+	 *		coll			OID of relevant collation, or 0 if none
+	 *		numbers			float4 array (for statistical values)
+	 *		values			anyarray (for representations of data values)
+	 * The ID, operator, and collation fields are never NULL; they are zeroes
+	 * in an unused slot.  The numbers and values fields are NULL in an
+	 * unused slot, and might also be NULL in a used slot if the slot kind
+	 * has no need for one or the other.
+	 * ----------------
+	 */
+
+	int16		stakind1;
+	int16		stakind2;
+	int16		stakind3;
+	int16		stakind4;
+	int16		stakind5;
+
+	Oid			staop1;
+	Oid			staop2;
+	Oid			staop3;
+	Oid			staop4;
+	Oid			staop5;
+
+	Oid			stacoll1;
+	Oid			stacoll2;
+	Oid			stacoll3;
+	Oid			stacoll4;
+	Oid			stacoll5;
+
+#ifdef CATALOG_VARLEN			/* variable-length fields start here */
+	float4		stanumbers1[1];
+	float4		stanumbers2[1];
+	float4		stanumbers3[1];
+	float4		stanumbers4[1];
+	float4		stanumbers5[1];
+
+	/*
+	 * Values in these arrays are values of the column's data type, or of some
+	 * related type such as an array element type.  We presently have to cheat
+	 * quite a bit to allow polymorphic arrays of this kind, but perhaps
+	 * someday it'll be a less bogus facility.
+	 */
+	anyarray	stavalues1;
+	anyarray	stavalues2;
+	anyarray	stavalues3;
+	anyarray	stavalues4;
+	anyarray	stavalues5;
+#endif
+} FormData_pg_statistic;
+
+#define STATISTIC_NUM_SLOTS  5
+
+
+/* ----------------
+ *		Form_pg_statistic corresponds to a pointer to a tuple with
+ *		the format of pg_statistic relation.
+ * ----------------
+ */
+typedef FormData_pg_statistic *Form_pg_statistic;
+
+#ifdef EXPOSE_TO_CLIENT_CODE
+
+/*
+ * Several statistical slot "kinds" are defined by core PostgreSQL, as
+ * documented below.  Also, custom data types can define their own "kind"
+ * codes by mutual agreement between a custom typanalyze routine and the
+ * selectivity estimation functions of the type's operators.
+ *
+ * Code reading the pg_statistic relation should not assume that a particular
+ * data "kind" will appear in any particular slot.  Instead, search the
+ * stakind fields to see if the desired data is available.  (The standard
+ * function get_attstatsslot() may be used for this.)
+ */
+
+/*
+ * The present allocation of "kind" codes is:
+ *
+ *	1-99:		reserved for assignment by the core PostgreSQL project
+ *				(values in this range will be documented in this file)
+ *	100-199:	reserved for assignment by the PostGIS project
+ *				(values to be documented in PostGIS documentation)
+ *	200-299:	reserved for assignment by the ESRI ST_Geometry project
+ *				(values to be documented in ESRI ST_Geometry documentation)
+ *	300-9999:	reserved for future public assignments
+ *
+ * For private use you may choose a "kind" code at random in the range
+ * 10000-30000.  However, for code that is to be widely disseminated it is
+ * better to obtain a publicly defined "kind" code by request from the
+ * PostgreSQL Global Development Group.
+ */
+
+/*
+ * In a "most common values" slot, staop is the OID of the "=" operator
+ * used to decide whether values are the same or not, and stacoll is the
+ * collation used (same as column's collation).  stavalues contains
+ * the K most common non-null values appearing in the column, and stanumbers
+ * contains their frequencies (fractions of total row count).  The values
+ * shall be ordered in decreasing frequency.  Note that since the arrays are
+ * variable-size, K may be chosen by the statistics collector.  Values should
+ * not appear in MCV unless they have been observed to occur more than once;
+ * a unique column will have no MCV slot.
+ */
+#define STATISTIC_KIND_MCV	1
+
+/*
+ * A "histogram" slot describes the distribution of scalar data.  staop is
+ * the OID of the "<" operator that describes the sort ordering, and stacoll
+ * is the relevant collation.  (In theory more than one histogram could appear,
+ * if a datatype has more than one useful sort operator or we care about more
+ * than one collation.  Currently the collation will always be that of the
+ * underlying column.)  stavalues contains M (>=2) non-null values that
+ * divide the non-null column data values into M-1 bins of approximately equal
+ * population.  The first stavalues item is the MIN and the last is the MAX.
+ * stanumbers is not used and should be NULL.  IMPORTANT POINT: if an MCV
+ * slot is also provided, then the histogram describes the data distribution
+ * *after removing the values listed in MCV* (thus, it's a "compressed
+ * histogram" in the technical parlance).  This allows a more accurate
+ * representation of the distribution of a column with some very-common
+ * values.  In a column with only a few distinct values, it's possible that
+ * the MCV list describes the entire data population; in this case the
+ * histogram reduces to empty and should be omitted.
+ */
+#define STATISTIC_KIND_HISTOGRAM  2
+
+/*
+ * A "correlation" slot describes the correlation between the physical order
+ * of table tuples and the ordering of data values of this column, as seen
+ * by the "<" operator identified by staop with the collation identified by
+ * stacoll.  (As with the histogram, more than one entry could theoretically
+ * appear.)  stavalues is not used and should be NULL.  stanumbers contains
+ * a single entry, the correlation coefficient between the sequence of data
+ * values and the sequence of their actual tuple positions.  The coefficient
+ * ranges from +1 to -1.
+ */
+#define STATISTIC_KIND_CORRELATION	3
+
+/*
+ * A "most common elements" slot is similar to a "most common values" slot,
+ * except that it stores the most common non-null *elements* of the column
+ * values.  This is useful when the column datatype is an array or some other
+ * type with identifiable elements (for instance, tsvector).  staop contains
+ * the equality operator appropriate to the element type, and stacoll
+ * contains the collation to use with it.  stavalues contains
+ * the most common element values, and stanumbers their frequencies.  Unlike
+ * MCV slots, frequencies are measured as the fraction of non-null rows the
+ * element value appears in, not the frequency of all rows.  Also unlike
+ * MCV slots, the values are sorted into the element type's default order
+ * (to support binary search for a particular value).  Since this puts the
+ * minimum and maximum frequencies at unpredictable spots in stanumbers,
+ * there are two extra members of stanumbers, holding copies of the minimum
+ * and maximum frequencies.  Optionally, there can be a third extra member,
+ * which holds the frequency of null elements (expressed in the same terms:
+ * the fraction of non-null rows that contain at least one null element).  If
+ * this member is omitted, the column is presumed to contain no null elements.
+ *
+ * Note: in current usage for tsvector columns, the stavalues elements are of
+ * type text, even though their representation within tsvector is not
+ * exactly text.
+ */
+#define STATISTIC_KIND_MCELEM  4
+
+/*
+ * A "distinct elements count histogram" slot describes the distribution of
+ * the number of distinct element values present in each row of an array-type
+ * column.  Only non-null rows are considered, and only non-null elements.
+ * staop contains the equality operator appropriate to the element type,
+ * and stacoll contains the collation to use with it.
+ * stavalues is not used and should be NULL.  The last member of stanumbers is
+ * the average count of distinct element values over all non-null rows.  The
+ * preceding M (>=2) members form a histogram that divides the population of
+ * distinct-elements counts into M-1 bins of approximately equal population.
+ * The first of these is the minimum observed count, and the last the maximum.
+ */
+#define STATISTIC_KIND_DECHIST	5
+
+/*
+ * A "length histogram" slot describes the distribution of range lengths in
+ * rows of a range-type column. stanumbers contains a single entry, the
+ * fraction of empty ranges. stavalues is a histogram of non-empty lengths, in
+ * a format similar to STATISTIC_KIND_HISTOGRAM: it contains M (>=2) range
+ * values that divide the column data values into M-1 bins of approximately
+ * equal population. The lengths are stored as float8s, as measured by the
+ * range type's subdiff function. Only non-null rows are considered.
+ */
+#define STATISTIC_KIND_RANGE_LENGTH_HISTOGRAM  6
+
+/*
+ * A "bounds histogram" slot is similar to STATISTIC_KIND_HISTOGRAM, but for
+ * a range-type column.  stavalues contains M (>=2) range values that divide
+ * the column data values into M-1 bins of approximately equal population.
+ * Unlike a regular scalar histogram, this is actually two histograms combined
+ * into a single array, with the lower bounds of each value forming a
+ * histogram of lower bounds, and the upper bounds a histogram of upper
+ * bounds.  Only non-NULL, non-empty ranges are included.
+ */
+#define STATISTIC_KIND_BOUNDS_HISTOGRAM  7
+
+#endif							/* EXPOSE_TO_CLIENT_CODE */
+
+#endif							/* PG_STATISTIC_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_statistic_d.h b/contrib/libs/postgresql/src/include/catalog/pg_statistic_d.h
new file mode 100644
index 0000000000..25f8ba5d26
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_statistic_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_statistic_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_statistic_ext.h b/contrib/libs/postgresql/src/include/catalog/pg_statistic_ext.h
new file mode 100644
index 0000000000..a8cb16997a
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_statistic_ext.h
@@ -0,0 +1,74 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_statistic_ext.h
+ *	  definition of the "extended statistics" system catalog
+ *	  (pg_statistic_ext)
+ *
+ * Note that pg_statistic_ext contains the definitions of extended statistics
+ * objects, created by CREATE STATISTICS, but not the actual statistical data,
+ * created by running ANALYZE.
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_statistic_ext.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_STATISTIC_EXT_H
+#define PG_STATISTIC_EXT_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_statistic_ext_d.h"
+
+/* ----------------
+ *		pg_statistic_ext definition.  cpp turns this into
+ *		typedef struct FormData_pg_statistic_ext
+ * ----------------
+ */
+CATALOG(pg_statistic_ext,3381,StatisticExtRelationId)
+{
+	Oid			oid;			/* oid */
+
+	Oid			stxrelid;		/* relation containing attributes */
+
+	/* These two fields form the unique key for the entry: */
+	NameData	stxname;		/* statistics object name */
+	Oid			stxnamespace;	/* OID of statistics object's namespace */
+
+	Oid			stxowner;		/* statistics object's owner */
+	int32		stxstattarget BKI_DEFAULT(-1);	/* statistics target */
+
+	/*
+	 * variable-length fields start here, but we allow direct access to
+	 * stxkeys
+	 */
+	int2vector	stxkeys;		/* array of column keys */
+
+#ifdef CATALOG_VARLEN
+	char		stxkind[1] BKI_FORCE_NOT_NULL;	/* statistics kinds requested
+												 * to build */
+#endif
+
+} FormData_pg_statistic_ext;
+
+/* ----------------
+ *		Form_pg_statistic_ext corresponds to a pointer to a tuple with
+ *		the format of pg_statistic_ext relation.
+ * ----------------
+ */
+typedef FormData_pg_statistic_ext *Form_pg_statistic_ext;
+
+#ifdef EXPOSE_TO_CLIENT_CODE
+
+#define STATS_EXT_NDISTINCT			'd'
+#define STATS_EXT_DEPENDENCIES		'f'
+#define STATS_EXT_MCV				'm'
+
+#endif							/* EXPOSE_TO_CLIENT_CODE */
+
+#endif							/* PG_STATISTIC_EXT_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_statistic_ext_d.h b/contrib/libs/postgresql/src/include/catalog/pg_statistic_ext_d.h
new file mode 100644
index 0000000000..e472ec19af
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_statistic_ext_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_statistic_ext_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_statistic_ext_data.h b/contrib/libs/postgresql/src/include/catalog/pg_statistic_ext_data.h
new file mode 100644
index 0000000000..0ef4ecb64a
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_statistic_ext_data.h
@@ -0,0 +1,52 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_statistic_ext_data.h
+ *	  definition of the "extended statistics data" system catalog
+ *	  (pg_statistic_ext_data)
+ *
+ * This catalog stores the statistical data for extended statistics objects.
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_statistic_ext_data.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_STATISTIC_EXT_DATA_H
+#define PG_STATISTIC_EXT_DATA_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_statistic_ext_data_d.h"
+
+/* ----------------
+ *		pg_statistic_ext_data definition.  cpp turns this into
+ *		typedef struct FormData_pg_statistic_ext_data
+ * ----------------
+ */
+CATALOG(pg_statistic_ext_data,3429,StatisticExtDataRelationId)
+{
+	Oid			stxoid;			/* statistics object this data is for */
+
+#ifdef CATALOG_VARLEN			/* variable-length fields start here */
+
+	pg_ndistinct stxdndistinct; /* ndistinct coefficients (serialized) */
+	pg_dependencies stxddependencies;	/* dependencies (serialized) */
+	pg_mcv_list stxdmcv;		/* MCV (serialized) */
+
+#endif
+
+} FormData_pg_statistic_ext_data;
+
+/* ----------------
+ *		Form_pg_statistic_ext_data corresponds to a pointer to a tuple with
+ *		the format of pg_statistic_ext_data relation.
+ * ----------------
+ */
+typedef FormData_pg_statistic_ext_data * Form_pg_statistic_ext_data;
+
+#endif							/* PG_STATISTIC_EXT_DATA_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_statistic_ext_data_d.h b/contrib/libs/postgresql/src/include/catalog/pg_statistic_ext_data_d.h
new file mode 100644
index 0000000000..7782f447fc
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_statistic_ext_data_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_statistic_ext_data_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_subscription.h b/contrib/libs/postgresql/src/include/catalog/pg_subscription.h
new file mode 100644
index 0000000000..e3288ad76e
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_subscription.h
@@ -0,0 +1,89 @@
+/* -------------------------------------------------------------------------
+ *
+ * pg_subscription.h
+ *	  definition of the "subscription" system catalog (pg_subscription)
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_subscription.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ * -------------------------------------------------------------------------
+ */
+#ifndef PG_SUBSCRIPTION_H
+#define PG_SUBSCRIPTION_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_subscription_d.h"
+
+#include "nodes/pg_list.h"
+
+/* ----------------
+ *		pg_subscription definition. cpp turns this into
+ *		typedef struct FormData_pg_subscription
+ * ----------------
+ */
+
+/*
+ * Technically, the subscriptions live inside the database, so a shared catalog
+ * seems weird, but the replication launcher process needs to access all of
+ * them to be able to start the workers, so we have to put them in a shared,
+ * nailed catalog.
+ *
+ * NOTE:  When adding a column, also update system_views.sql.
+ */
+CATALOG(pg_subscription,6100,SubscriptionRelationId) BKI_SHARED_RELATION BKI_ROWTYPE_OID(6101,SubscriptionRelation_Rowtype_Id) BKI_SCHEMA_MACRO
+{
+	Oid			oid;			/* oid */
+
+	Oid			subdbid;		/* Database the subscription is in. */
+	NameData	subname;		/* Name of the subscription */
+
+	Oid			subowner;		/* Owner of the subscription */
+
+	bool		subenabled;		/* True if the subscription is enabled (the
+								 * worker should be running) */
+
+#ifdef CATALOG_VARLEN			/* variable-length fields start here */
+	/* Connection string to the publisher */
+	text		subconninfo BKI_FORCE_NOT_NULL;
+
+	/* Slot name on publisher */
+	NameData	subslotname BKI_FORCE_NULL;
+
+	/* Synchronous commit setting for worker */
+	text		subsynccommit BKI_FORCE_NOT_NULL;
+
+	/* List of publications subscribed to */
+	text		subpublications[1] BKI_FORCE_NOT_NULL;
+#endif
+} FormData_pg_subscription;
+
+typedef FormData_pg_subscription *Form_pg_subscription;
+
+typedef struct Subscription
+{
+	Oid			oid;			/* Oid of the subscription */
+	Oid			dbid;			/* Oid of the database which subscription is
+								 * in */
+	char	   *name;			/* Name of the subscription */
+	Oid			owner;			/* Oid of the subscription owner */
+	bool		enabled;		/* Indicates if the subscription is enabled */
+	char	   *conninfo;		/* Connection string to the publisher */
+	char	   *slotname;		/* Name of the replication slot */
+	char	   *synccommit;		/* Synchronous commit setting for worker */
+	List	   *publications;	/* List of publication names to subscribe to */
+} Subscription;
+
+extern Subscription *GetSubscription(Oid subid, bool missing_ok);
+extern void FreeSubscription(Subscription *sub);
+extern Oid	get_subscription_oid(const char *subname, bool missing_ok);
+extern char *get_subscription_name(Oid subid, bool missing_ok);
+
+extern int	CountDBSubscriptions(Oid dbid);
+
+#endif							/* PG_SUBSCRIPTION_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_subscription_d.h b/contrib/libs/postgresql/src/include/catalog/pg_subscription_d.h
new file mode 100644
index 0000000000..2f0718c2d7
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_subscription_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_subscription_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_subscription_rel.h b/contrib/libs/postgresql/src/include/catalog/pg_subscription_rel.h
new file mode 100644
index 0000000000..f384f4e7fa
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_subscription_rel.h
@@ -0,0 +1,90 @@
+/* -------------------------------------------------------------------------
+ *
+ * pg_subscription_rel.h
+ *	  definition of the system catalog containing the state for each
+ *	  replicated table in each subscription (pg_subscription_rel)
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_subscription_rel.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ * -------------------------------------------------------------------------
+ */
+#ifndef PG_SUBSCRIPTION_REL_H
+#define PG_SUBSCRIPTION_REL_H
+
+#include "access/xlogdefs.h"
+#include "catalog/genbki.h"
+#include "catalog/pg_subscription_rel_d.h"
+#include "nodes/pg_list.h"
+
+/* ----------------
+ *		pg_subscription_rel definition. cpp turns this into
+ *		typedef struct FormData_pg_subscription_rel
+ * ----------------
+ */
+CATALOG(pg_subscription_rel,6102,SubscriptionRelRelationId)
+{
+	Oid			srsubid;		/* Oid of subscription */
+	Oid			srrelid;		/* Oid of relation */
+	char		srsubstate;		/* state of the relation in subscription */
+
+	/*
+	 * Although srsublsn is a fixed-width type, it is allowed to be NULL, so
+	 * we prevent direct C code access to it just as for a varlena field.
+	 */
+#ifdef CATALOG_VARLEN			/* variable-length fields start here */
+
+	XLogRecPtr	srsublsn BKI_FORCE_NULL;	/* remote LSN of the state change
+											 * used for synchronization
+											 * coordination, or NULL if not
+											 * valid */
+#endif
+} FormData_pg_subscription_rel;
+
+typedef FormData_pg_subscription_rel *Form_pg_subscription_rel;
+
+#ifdef EXPOSE_TO_CLIENT_CODE
+
+/* ----------------
+ *		substate constants
+ * ----------------
+ */
+#define SUBREL_STATE_INIT		'i' /* initializing (sublsn NULL) */
+#define SUBREL_STATE_DATASYNC	'd' /* data is being synchronized (sublsn
+									 * NULL) */
+#define SUBREL_STATE_SYNCDONE	's' /* synchronization finished in front of
+									 * apply (sublsn set) */
+#define SUBREL_STATE_READY		'r' /* ready (sublsn set) */
+
+/* These are never stored in the catalog, we only use them for IPC. */
+#define SUBREL_STATE_UNKNOWN	'\0'	/* unknown state */
+#define SUBREL_STATE_SYNCWAIT	'w' /* waiting for sync */
+#define SUBREL_STATE_CATCHUP	'c' /* catching up with apply */
+
+#endif							/* EXPOSE_TO_CLIENT_CODE */
+
+typedef struct SubscriptionRelState
+{
+	Oid			relid;
+	XLogRecPtr	lsn;
+	char		state;
+} SubscriptionRelState;
+
+extern void AddSubscriptionRelState(Oid subid, Oid relid, char state,
+									XLogRecPtr sublsn);
+extern void UpdateSubscriptionRelState(Oid subid, Oid relid, char state,
+									   XLogRecPtr sublsn);
+extern char GetSubscriptionRelState(Oid subid, Oid relid,
+									XLogRecPtr *sublsn, bool missing_ok);
+extern void RemoveSubscriptionRel(Oid subid, Oid relid);
+
+extern List *GetSubscriptionRelations(Oid subid);
+extern List *GetSubscriptionNotReadyRelations(Oid subid);
+
+#endif							/* PG_SUBSCRIPTION_REL_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_subscription_rel_d.h b/contrib/libs/postgresql/src/include/catalog/pg_subscription_rel_d.h
new file mode 100644
index 0000000000..d865437594
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_subscription_rel_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_subscription_rel_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_tablespace.dat b/contrib/libs/postgresql/src/include/catalog/pg_tablespace.dat
new file mode 100644
index 0000000000..bb0dec08ef
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_tablespace.dat
@@ -0,0 +1,22 @@
+#----------------------------------------------------------------------
+#
+# pg_tablespace.dat
+#    Initial contents of the pg_tablespace system catalog.
+#
+# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+# Portions Copyright (c) 1994, Regents of the University of California
+#
+# src/include/catalog/pg_tablespace.dat
+#
+#----------------------------------------------------------------------
+
+[
+
+{ oid => '1663', oid_symbol => 'DEFAULTTABLESPACE_OID',
+  spcname => 'pg_default', spcowner => 'PGUID', spcacl => '_null_',
+  spcoptions => '_null_' },
+{ oid => '1664', oid_symbol => 'GLOBALTABLESPACE_OID',
+  spcname => 'pg_global', spcowner => 'PGUID', spcacl => '_null_',
+  spcoptions => '_null_' },
+
+]
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_tablespace.h b/contrib/libs/postgresql/src/include/catalog/pg_tablespace.h
new file mode 100644
index 0000000000..1daf2dd9c2
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_tablespace.h
@@ -0,0 +1,48 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_tablespace.h
+ *	  definition of the "tablespace" system catalog (pg_tablespace)
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_tablespace.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_TABLESPACE_H
+#define PG_TABLESPACE_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_tablespace_d.h"
+
+/* ----------------
+ *		pg_tablespace definition.  cpp turns this into
+ *		typedef struct FormData_pg_tablespace
+ * ----------------
+ */
+CATALOG(pg_tablespace,1213,TableSpaceRelationId) BKI_SHARED_RELATION
+{
+	Oid			oid;			/* oid */
+	NameData	spcname;		/* tablespace name */
+	Oid			spcowner;		/* owner of tablespace */
+
+#ifdef CATALOG_VARLEN			/* variable-length fields start here */
+	aclitem		spcacl[1];		/* access permissions */
+	text		spcoptions[1];	/* per-tablespace options */
+#endif
+} FormData_pg_tablespace;
+
+/* ----------------
+ *		Form_pg_tablespace corresponds to a pointer to a tuple with
+ *		the format of pg_tablespace relation.
+ * ----------------
+ */
+typedef FormData_pg_tablespace *Form_pg_tablespace;
+
+#endif							/* PG_TABLESPACE_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_tablespace_d.h b/contrib/libs/postgresql/src/include/catalog/pg_tablespace_d.h
new file mode 100644
index 0000000000..b388ac1169
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_tablespace_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_tablespace_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_transform.h b/contrib/libs/postgresql/src/include/catalog/pg_transform.h
new file mode 100644
index 0000000000..05f3e276fc
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_transform.h
@@ -0,0 +1,45 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_transform.h
+ *	  definition of the "transform" system catalog (pg_transform)
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_transform.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_TRANSFORM_H
+#define PG_TRANSFORM_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_transform_d.h"
+
+/* ----------------
+ *		pg_transform definition.  cpp turns this into
+ *		typedef struct FormData_pg_transform
+ * ----------------
+ */
+CATALOG(pg_transform,3576,TransformRelationId)
+{
+	Oid			oid;			/* oid */
+	Oid			trftype;
+	Oid			trflang;
+	regproc		trffromsql;
+	regproc		trftosql;
+} FormData_pg_transform;
+
+/* ----------------
+ *		Form_pg_transform corresponds to a pointer to a tuple with
+ *		the format of pg_transform relation.
+ * ----------------
+ */
+typedef FormData_pg_transform *Form_pg_transform;
+
+#endif							/* PG_TRANSFORM_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_transform_d.h b/contrib/libs/postgresql/src/include/catalog/pg_transform_d.h
new file mode 100644
index 0000000000..e2d1984992
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_transform_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_transform_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_trigger.h b/contrib/libs/postgresql/src/include/catalog/pg_trigger.h
new file mode 100644
index 0000000000..9612b9bdd6
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_trigger.h
@@ -0,0 +1,137 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_trigger.h
+ *	  definition of the "trigger" system catalog (pg_trigger)
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_trigger.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_TRIGGER_H
+#define PG_TRIGGER_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_trigger_d.h"
+
+/* ----------------
+ *		pg_trigger definition.  cpp turns this into
+ *		typedef struct FormData_pg_trigger
+ *
+ * Note: when tgconstraint is nonzero, tgconstrrelid, tgconstrindid,
+ * tgdeferrable, and tginitdeferred are largely redundant with the referenced
+ * pg_constraint entry.  However, it is possible for a non-deferrable trigger
+ * to be associated with a deferrable constraint.
+ * ----------------
+ */
+CATALOG(pg_trigger,2620,TriggerRelationId)
+{
+	Oid			oid;			/* oid */
+	Oid			tgrelid;		/* relation trigger is attached to */
+	Oid			tgparentid;		/* OID of parent trigger, if any */
+	NameData	tgname;			/* trigger's name */
+	Oid			tgfoid;			/* OID of function to be called */
+	int16		tgtype;			/* BEFORE/AFTER/INSTEAD, UPDATE/DELETE/INSERT,
+								 * ROW/STATEMENT; see below */
+	char		tgenabled;		/* trigger's firing configuration WRT
+								 * session_replication_role */
+	bool		tgisinternal;	/* trigger is system-generated */
+	Oid			tgconstrrelid;	/* constraint's FROM table, if any */
+	Oid			tgconstrindid;	/* constraint's supporting index, if any */
+	Oid			tgconstraint;	/* associated pg_constraint entry, if any */
+	bool		tgdeferrable;	/* constraint trigger is deferrable */
+	bool		tginitdeferred; /* constraint trigger is deferred initially */
+	int16		tgnargs;		/* # of extra arguments in tgargs */
+
+	/*
+	 * Variable-length fields start here, but we allow direct access to
+	 * tgattr. Note: tgattr and tgargs must not be null.
+	 */
+	int2vector	tgattr;			/* column numbers, if trigger is on columns */
+
+#ifdef CATALOG_VARLEN
+	bytea		tgargs BKI_FORCE_NOT_NULL;	/* first\000second\000tgnargs\000 */
+	pg_node_tree tgqual;		/* WHEN expression, or NULL if none */
+	NameData	tgoldtable;		/* old transition table, or NULL if none */
+	NameData	tgnewtable;		/* new transition table, or NULL if none */
+#endif
+} FormData_pg_trigger;
+
+/* ----------------
+ *		Form_pg_trigger corresponds to a pointer to a tuple with
+ *		the format of pg_trigger relation.
+ * ----------------
+ */
+typedef FormData_pg_trigger *Form_pg_trigger;
+
+#ifdef EXPOSE_TO_CLIENT_CODE
+
+/* Bits within tgtype */
+#define TRIGGER_TYPE_ROW				(1 << 0)
+#define TRIGGER_TYPE_BEFORE				(1 << 1)
+#define TRIGGER_TYPE_INSERT				(1 << 2)
+#define TRIGGER_TYPE_DELETE				(1 << 3)
+#define TRIGGER_TYPE_UPDATE				(1 << 4)
+#define TRIGGER_TYPE_TRUNCATE			(1 << 5)
+#define TRIGGER_TYPE_INSTEAD			(1 << 6)
+
+#define TRIGGER_TYPE_LEVEL_MASK			(TRIGGER_TYPE_ROW)
+#define TRIGGER_TYPE_STATEMENT			0
+
+/* Note bits within TRIGGER_TYPE_TIMING_MASK aren't adjacent */
+#define TRIGGER_TYPE_TIMING_MASK \
+	(TRIGGER_TYPE_BEFORE | TRIGGER_TYPE_INSTEAD)
+#define TRIGGER_TYPE_AFTER				0
+
+#define TRIGGER_TYPE_EVENT_MASK \
+	(TRIGGER_TYPE_INSERT | TRIGGER_TYPE_DELETE | TRIGGER_TYPE_UPDATE | TRIGGER_TYPE_TRUNCATE)
+
+/* Macros for manipulating tgtype */
+#define TRIGGER_CLEAR_TYPE(type)		((type) = 0)
+
+#define TRIGGER_SETT_ROW(type)			((type) |= TRIGGER_TYPE_ROW)
+#define TRIGGER_SETT_STATEMENT(type)	((type) |= TRIGGER_TYPE_STATEMENT)
+#define TRIGGER_SETT_BEFORE(type)		((type) |= TRIGGER_TYPE_BEFORE)
+#define TRIGGER_SETT_AFTER(type)		((type) |= TRIGGER_TYPE_AFTER)
+#define TRIGGER_SETT_INSTEAD(type)		((type) |= TRIGGER_TYPE_INSTEAD)
+#define TRIGGER_SETT_INSERT(type)		((type) |= TRIGGER_TYPE_INSERT)
+#define TRIGGER_SETT_DELETE(type)		((type) |= TRIGGER_TYPE_DELETE)
+#define TRIGGER_SETT_UPDATE(type)		((type) |= TRIGGER_TYPE_UPDATE)
+#define TRIGGER_SETT_TRUNCATE(type)		((type) |= TRIGGER_TYPE_TRUNCATE)
+
+#define TRIGGER_FOR_ROW(type)			((type) & TRIGGER_TYPE_ROW)
+#define TRIGGER_FOR_BEFORE(type)		(((type) & TRIGGER_TYPE_TIMING_MASK) == TRIGGER_TYPE_BEFORE)
+#define TRIGGER_FOR_AFTER(type)			(((type) & TRIGGER_TYPE_TIMING_MASK) == TRIGGER_TYPE_AFTER)
+#define TRIGGER_FOR_INSTEAD(type)		(((type) & TRIGGER_TYPE_TIMING_MASK) == TRIGGER_TYPE_INSTEAD)
+#define TRIGGER_FOR_INSERT(type)		((type) & TRIGGER_TYPE_INSERT)
+#define TRIGGER_FOR_DELETE(type)		((type) & TRIGGER_TYPE_DELETE)
+#define TRIGGER_FOR_UPDATE(type)		((type) & TRIGGER_TYPE_UPDATE)
+#define TRIGGER_FOR_TRUNCATE(type)		((type) & TRIGGER_TYPE_TRUNCATE)
+
+/*
+ * Efficient macro for checking if tgtype matches a particular level
+ * (TRIGGER_TYPE_ROW or TRIGGER_TYPE_STATEMENT), timing (TRIGGER_TYPE_BEFORE,
+ * TRIGGER_TYPE_AFTER or TRIGGER_TYPE_INSTEAD), and event (TRIGGER_TYPE_INSERT,
+ * TRIGGER_TYPE_DELETE, TRIGGER_TYPE_UPDATE, or TRIGGER_TYPE_TRUNCATE).  Note
+ * that a tgtype can match more than one event, but only one level or timing.
+ */
+#define TRIGGER_TYPE_MATCHES(type, level, timing, event) \
+	(((type) & (TRIGGER_TYPE_LEVEL_MASK | TRIGGER_TYPE_TIMING_MASK | (event))) == ((level) | (timing) | (event)))
+
+/*
+ * Macro to determine whether tgnewtable or tgoldtable has been specified for
+ * a trigger.
+ */
+#define TRIGGER_USES_TRANSITION_TABLE(namepointer) \
+	((namepointer) != (char *) NULL)
+
+#endif							/* EXPOSE_TO_CLIENT_CODE */
+
+#endif							/* PG_TRIGGER_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_trigger_d.h b/contrib/libs/postgresql/src/include/catalog/pg_trigger_d.h
new file mode 100644
index 0000000000..0b1c9e3bee
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_trigger_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_trigger_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_ts_config.dat b/contrib/libs/postgresql/src/include/catalog/pg_ts_config.dat
new file mode 100644
index 0000000000..44281675db
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_ts_config.dat
@@ -0,0 +1,18 @@
+#----------------------------------------------------------------------
+#
+# pg_ts_config.dat
+#    Initial contents of the pg_ts_config system catalog.
+#
+# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+# Portions Copyright (c) 1994, Regents of the University of California
+#
+# src/include/catalog/pg_ts_config.dat
+#
+#----------------------------------------------------------------------
+
+[
+
+{ oid => '3748', descr => 'simple configuration',
+  cfgname => 'simple', cfgparser => 'default' },
+
+]
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_ts_config.h b/contrib/libs/postgresql/src/include/catalog/pg_ts_config.h
new file mode 100644
index 0000000000..0d9c5e3590
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_ts_config.h
@@ -0,0 +1,50 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_ts_config.h
+ *	  definition of the "text search configuration" system catalog
+ *	  (pg_ts_config)
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_ts_config.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_TS_CONFIG_H
+#define PG_TS_CONFIG_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_ts_config_d.h"
+
+/* ----------------
+ *		pg_ts_config definition.  cpp turns this into
+ *		typedef struct FormData_pg_ts_config
+ * ----------------
+ */
+CATALOG(pg_ts_config,3602,TSConfigRelationId)
+{
+	/* oid */
+	Oid			oid;
+
+	/* name of configuration */
+	NameData	cfgname;
+
+	/* name space */
+	Oid			cfgnamespace BKI_DEFAULT(PGNSP);
+
+	/* owner */
+	Oid			cfgowner BKI_DEFAULT(PGUID);
+
+	/* OID of parser */
+	Oid			cfgparser BKI_LOOKUP(pg_ts_parser);
+} FormData_pg_ts_config;
+
+typedef FormData_pg_ts_config *Form_pg_ts_config;
+
+#endif							/* PG_TS_CONFIG_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_ts_config_d.h b/contrib/libs/postgresql/src/include/catalog/pg_ts_config_d.h
new file mode 100644
index 0000000000..9fe42b01ae
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_ts_config_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_ts_config_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_ts_config_map.dat b/contrib/libs/postgresql/src/include/catalog/pg_ts_config_map.dat
new file mode 100644
index 0000000000..f3a593326e
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_ts_config_map.dat
@@ -0,0 +1,54 @@
+#----------------------------------------------------------------------
+#
+# pg_ts_config_map.dat
+#    Initial contents of the pg_ts_config_map system catalog.
+#
+# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+# Portions Copyright (c) 1994, Regents of the University of California
+#
+# src/include/catalog/pg_ts_config_map.dat
+#
+#----------------------------------------------------------------------
+
+[
+
+{ mapcfg => 'simple', maptokentype => '1', mapseqno => '1',
+  mapdict => 'simple' },
+{ mapcfg => 'simple', maptokentype => '2', mapseqno => '1',
+  mapdict => 'simple' },
+{ mapcfg => 'simple', maptokentype => '3', mapseqno => '1',
+  mapdict => 'simple' },
+{ mapcfg => 'simple', maptokentype => '4', mapseqno => '1',
+  mapdict => 'simple' },
+{ mapcfg => 'simple', maptokentype => '5', mapseqno => '1',
+  mapdict => 'simple' },
+{ mapcfg => 'simple', maptokentype => '6', mapseqno => '1',
+  mapdict => 'simple' },
+{ mapcfg => 'simple', maptokentype => '7', mapseqno => '1',
+  mapdict => 'simple' },
+{ mapcfg => 'simple', maptokentype => '8', mapseqno => '1',
+  mapdict => 'simple' },
+{ mapcfg => 'simple', maptokentype => '9', mapseqno => '1',
+  mapdict => 'simple' },
+{ mapcfg => 'simple', maptokentype => '10', mapseqno => '1',
+  mapdict => 'simple' },
+{ mapcfg => 'simple', maptokentype => '11', mapseqno => '1',
+  mapdict => 'simple' },
+{ mapcfg => 'simple', maptokentype => '15', mapseqno => '1',
+  mapdict => 'simple' },
+{ mapcfg => 'simple', maptokentype => '16', mapseqno => '1',
+  mapdict => 'simple' },
+{ mapcfg => 'simple', maptokentype => '17', mapseqno => '1',
+  mapdict => 'simple' },
+{ mapcfg => 'simple', maptokentype => '18', mapseqno => '1',
+  mapdict => 'simple' },
+{ mapcfg => 'simple', maptokentype => '19', mapseqno => '1',
+  mapdict => 'simple' },
+{ mapcfg => 'simple', maptokentype => '20', mapseqno => '1',
+  mapdict => 'simple' },
+{ mapcfg => 'simple', maptokentype => '21', mapseqno => '1',
+  mapdict => 'simple' },
+{ mapcfg => 'simple', maptokentype => '22', mapseqno => '1',
+  mapdict => 'simple' },
+
+]
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_ts_config_map.h b/contrib/libs/postgresql/src/include/catalog/pg_ts_config_map.h
new file mode 100644
index 0000000000..46aef63faa
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_ts_config_map.h
@@ -0,0 +1,47 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_ts_config_map.h
+ *	  definition of the system catalog for text search token mappings
+ *	  (pg_ts_config_map)
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_ts_config_map.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_TS_CONFIG_MAP_H
+#define PG_TS_CONFIG_MAP_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_ts_config_map_d.h"
+
+/* ----------------
+ *		pg_ts_config_map definition.  cpp turns this into
+ *		typedef struct FormData_pg_ts_config_map
+ * ----------------
+ */
+CATALOG(pg_ts_config_map,3603,TSConfigMapRelationId)
+{
+	/* OID of configuration owning this entry */
+	Oid			mapcfg BKI_LOOKUP(pg_ts_config);
+
+	/* token type from parser */
+	int32		maptokentype;
+
+	/* order in which to consult dictionaries */
+	int32		mapseqno;
+
+	/* dictionary to consult */
+	Oid			mapdict BKI_LOOKUP(pg_ts_dict);
+} FormData_pg_ts_config_map;
+
+typedef FormData_pg_ts_config_map *Form_pg_ts_config_map;
+
+#endif							/* PG_TS_CONFIG_MAP_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_ts_config_map_d.h b/contrib/libs/postgresql/src/include/catalog/pg_ts_config_map_d.h
new file mode 100644
index 0000000000..5d32856d67
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_ts_config_map_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_ts_config_map_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_ts_dict.dat b/contrib/libs/postgresql/src/include/catalog/pg_ts_dict.dat
new file mode 100644
index 0000000000..abeec0ccae
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_ts_dict.dat
@@ -0,0 +1,19 @@
+#----------------------------------------------------------------------
+#
+# pg_ts_dict.dat
+#    Initial contents of the pg_ts_dict system catalog.
+#
+# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+# Portions Copyright (c) 1994, Regents of the University of California
+#
+# src/include/catalog/pg_ts_dict.dat
+#
+#----------------------------------------------------------------------
+
+[
+
+{ oid => '3765',
+  descr => 'simple dictionary: just lower case and check for stopword',
+  dictname => 'simple', dicttemplate => 'simple', dictinitoption => '_null_' },
+
+]
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_ts_dict.h b/contrib/libs/postgresql/src/include/catalog/pg_ts_dict.h
new file mode 100644
index 0000000000..38128a313f
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_ts_dict.h
@@ -0,0 +1,54 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_ts_dict.h
+ *	  definition of the "text search dictionary" system catalog (pg_ts_dict)
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_ts_dict.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_TS_DICT_H
+#define PG_TS_DICT_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_ts_dict_d.h"
+
+/* ----------------
+ *		pg_ts_dict definition.  cpp turns this into
+ *		typedef struct FormData_pg_ts_dict
+ * ----------------
+ */
+CATALOG(pg_ts_dict,3600,TSDictionaryRelationId)
+{
+	/* oid */
+	Oid			oid;
+
+	/* dictionary name */
+	NameData	dictname;
+
+	/* name space */
+	Oid			dictnamespace BKI_DEFAULT(PGNSP);
+
+	/* owner */
+	Oid			dictowner BKI_DEFAULT(PGUID);
+
+	/* dictionary's template */
+	Oid			dicttemplate BKI_LOOKUP(pg_ts_template);
+
+#ifdef CATALOG_VARLEN			/* variable-length fields start here */
+	/* options passed to dict_init() */
+	text		dictinitoption;
+#endif
+} FormData_pg_ts_dict;
+
+typedef FormData_pg_ts_dict *Form_pg_ts_dict;
+
+#endif							/* PG_TS_DICT_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_ts_dict_d.h b/contrib/libs/postgresql/src/include/catalog/pg_ts_dict_d.h
new file mode 100644
index 0000000000..131abf7c93
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_ts_dict_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_ts_dict_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_ts_parser.dat b/contrib/libs/postgresql/src/include/catalog/pg_ts_parser.dat
new file mode 100644
index 0000000000..f23aa8c541
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_ts_parser.dat
@@ -0,0 +1,20 @@
+#----------------------------------------------------------------------
+#
+# pg_ts_parser.dat
+#    Initial contents of the pg_ts_parser system catalog.
+#
+# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+# Portions Copyright (c) 1994, Regents of the University of California
+#
+# src/include/catalog/pg_ts_parser.dat
+#
+#----------------------------------------------------------------------
+
+[
+
+{ oid => '3722', descr => 'default word parser',
+  prsname => 'default', prsstart => 'prsd_start', prstoken => 'prsd_nexttoken',
+  prsend => 'prsd_end', prsheadline => 'prsd_headline',
+  prslextype => 'prsd_lextype' },
+
+]
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_ts_parser.h b/contrib/libs/postgresql/src/include/catalog/pg_ts_parser.h
new file mode 100644
index 0000000000..641c6b6cb1
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_ts_parser.h
@@ -0,0 +1,57 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_ts_parser.h
+ *	  definition of the "text search parser" system catalog (pg_ts_parser)
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_ts_parser.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_TS_PARSER_H
+#define PG_TS_PARSER_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_ts_parser_d.h"
+
+/* ----------------
+ *		pg_ts_parser definition.  cpp turns this into
+ *		typedef struct FormData_pg_ts_parser
+ * ----------------
+ */
+CATALOG(pg_ts_parser,3601,TSParserRelationId)
+{
+	Oid			oid;			/* oid */
+
+	/* parser's name */
+	NameData	prsname;
+
+	/* name space */
+	Oid			prsnamespace BKI_DEFAULT(PGNSP);
+
+	/* init parsing session */
+	regproc		prsstart BKI_LOOKUP(pg_proc);
+
+	/* return next token */
+	regproc		prstoken BKI_LOOKUP(pg_proc);
+
+	/* finalize parsing session */
+	regproc		prsend BKI_LOOKUP(pg_proc);
+
+	/* return data for headline creation */
+	regproc		prsheadline BKI_LOOKUP(pg_proc);
+
+	/* return descriptions of lexeme's types */
+	regproc		prslextype BKI_LOOKUP(pg_proc);
+} FormData_pg_ts_parser;
+
+typedef FormData_pg_ts_parser *Form_pg_ts_parser;
+
+#endif							/* PG_TS_PARSER_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_ts_parser_d.h b/contrib/libs/postgresql/src/include/catalog/pg_ts_parser_d.h
new file mode 100644
index 0000000000..0bbdd2d357
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_ts_parser_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_ts_parser_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_ts_template.dat b/contrib/libs/postgresql/src/include/catalog/pg_ts_template.dat
new file mode 100644
index 0000000000..297a8b38fc
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_ts_template.dat
@@ -0,0 +1,30 @@
+#----------------------------------------------------------------------
+#
+# pg_ts_template.dat
+#    Initial contents of the pg_ts_template system catalog.
+#
+# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+# Portions Copyright (c) 1994, Regents of the University of California
+#
+# src/include/catalog/pg_ts_template.dat
+#
+#----------------------------------------------------------------------
+
+[
+
+{ oid => '3727',
+  descr => 'simple dictionary: just lower case and check for stopword',
+  tmplname => 'simple', tmplinit => 'dsimple_init',
+  tmpllexize => 'dsimple_lexize' },
+{ oid => '3730', descr => 'synonym dictionary: replace word by its synonym',
+  tmplname => 'synonym', tmplinit => 'dsynonym_init',
+  tmpllexize => 'dsynonym_lexize' },
+{ oid => '3733', descr => 'ispell dictionary',
+  tmplname => 'ispell', tmplinit => 'dispell_init',
+  tmpllexize => 'dispell_lexize' },
+{ oid => '3742',
+  descr => 'thesaurus dictionary: phrase by phrase substitution',
+  tmplname => 'thesaurus', tmplinit => 'thesaurus_init',
+  tmpllexize => 'thesaurus_lexize' },
+
+]
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_ts_template.h b/contrib/libs/postgresql/src/include/catalog/pg_ts_template.h
new file mode 100644
index 0000000000..f610225ba2
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_ts_template.h
@@ -0,0 +1,48 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_ts_template.h
+ *	  definition of the "text search template" system catalog (pg_ts_template)
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_ts_template.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_TS_TEMPLATE_H
+#define PG_TS_TEMPLATE_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_ts_template_d.h"
+
+/* ----------------
+ *		pg_ts_template definition.  cpp turns this into
+ *		typedef struct FormData_pg_ts_template
+ * ----------------
+ */
+CATALOG(pg_ts_template,3764,TSTemplateRelationId)
+{
+	Oid			oid;			/* oid */
+
+	/* template name */
+	NameData	tmplname;
+
+	/* name space */
+	Oid			tmplnamespace BKI_DEFAULT(PGNSP);
+
+	/* initialization method of dict (may be 0) */
+	regproc		tmplinit BKI_LOOKUP(pg_proc);
+
+	/* base method of dictionary */
+	regproc		tmpllexize BKI_LOOKUP(pg_proc);
+} FormData_pg_ts_template;
+
+typedef FormData_pg_ts_template *Form_pg_ts_template;
+
+#endif							/* PG_TS_TEMPLATE_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_ts_template_d.h b/contrib/libs/postgresql/src/include/catalog/pg_ts_template_d.h
new file mode 100644
index 0000000000..b539cd72d8
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_ts_template_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_ts_template_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_type.dat b/contrib/libs/postgresql/src/include/catalog/pg_type.dat
new file mode 100644
index 0000000000..e8be000835
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_type.dat
@@ -0,0 +1,633 @@
+#----------------------------------------------------------------------
+#
+# pg_type.dat
+#    Initial contents of the pg_type system catalog.
+#
+# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+# Portions Copyright (c) 1994, Regents of the University of California
+#
+# src/include/catalog/pg_type.dat
+#
+#----------------------------------------------------------------------
+
+[
+
+# For types used in the system catalogs, make sure the values here match
+# TypInfo[] in bootstrap.c.
+
+# OID symbol macro names for pg_type OIDs are generated by genbki.pl
+# according to the following rule, so you don't need to specify them
+# here:
+#  foo_bar  ->  FOO_BAROID
+# _foo_bar  ->  FOO_BARARRAYOID
+#
+# The only oid_symbol entries in this file are for names that don't match
+# this rule, and are grandfathered in.
+
+# To autogenerate an array type, add 'array_type_oid => 'nnnn' to the element
+# type, which will instruct genbki.pl to generate a BKI entry for it.
+# In a few cases, the array type's properties don't match the normal pattern
+# so it can't be autogenerated; in such cases do not write array_type_oid.
+
+# 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 => '16', array_type_oid => '1000',
+  descr => 'boolean, \'true\'/\'false\'',
+  typname => 'bool', typlen => '1', typbyval => 't', typcategory => 'B',
+  typispreferred => 't', typinput => 'boolin', typoutput => 'boolout',
+  typreceive => 'boolrecv', typsend => 'boolsend', typalign => 'c' },
+{ oid => '17', array_type_oid => '1001',
+  descr => 'variable-length string, binary values escaped',
+  typname => 'bytea', typlen => '-1', typbyval => 'f', typcategory => 'U',
+  typinput => 'byteain', typoutput => 'byteaout', typreceive => 'bytearecv',
+  typsend => 'byteasend', typalign => 'i', typstorage => 'x' },
+{ oid => '18', array_type_oid => '1002', descr => 'single character',
+  typname => 'char', typlen => '1', typbyval => 't', typcategory => 'S',
+  typinput => 'charin', typoutput => 'charout', typreceive => 'charrecv',
+  typsend => 'charsend', typalign => 'c' },
+{ oid => '19', array_type_oid => '1003',
+  descr => '63-byte type for storing system identifiers',
+  typname => 'name', typlen => 'NAMEDATALEN', typbyval => 'f',
+  typcategory => 'S', typelem => 'char', typinput => 'namein',
+  typoutput => 'nameout', typreceive => 'namerecv', typsend => 'namesend',
+  typalign => 'c', typcollation => 'C' },
+{ oid => '20', array_type_oid => '1016',
+  descr => '~18 digit integer, 8-byte storage',
+  typname => 'int8', typlen => '8', typbyval => 'FLOAT8PASSBYVAL',
+  typcategory => 'N', typinput => 'int8in', typoutput => 'int8out',
+  typreceive => 'int8recv', typsend => 'int8send', typalign => 'd' },
+{ oid => '21', array_type_oid => '1005',
+  descr => '-32 thousand to 32 thousand, 2-byte storage',
+  typname => 'int2', typlen => '2', typbyval => 't', typcategory => 'N',
+  typinput => 'int2in', typoutput => 'int2out', typreceive => 'int2recv',
+  typsend => 'int2send', typalign => 's' },
+{ oid => '22', array_type_oid => '1006',
+  descr => 'array of int2, used in system tables',
+  typname => 'int2vector', typlen => '-1', typbyval => 'f', typcategory => 'A',
+  typelem => 'int2', typinput => 'int2vectorin', typoutput => 'int2vectorout',
+  typreceive => 'int2vectorrecv', typsend => 'int2vectorsend',
+  typalign => 'i' },
+{ oid => '23', array_type_oid => '1007',
+  descr => '-2 billion to 2 billion integer, 4-byte storage',
+  typname => 'int4', typlen => '4', typbyval => 't', typcategory => 'N',
+  typinput => 'int4in', typoutput => 'int4out', typreceive => 'int4recv',
+  typsend => 'int4send', typalign => 'i' },
+{ oid => '24', array_type_oid => '1008', descr => 'registered procedure',
+  typname => 'regproc', typlen => '4', typbyval => 't', typcategory => 'N',
+  typinput => 'regprocin', typoutput => 'regprocout',
+  typreceive => 'regprocrecv', typsend => 'regprocsend', typalign => 'i' },
+{ oid => '25', array_type_oid => '1009',
+  descr => 'variable-length string, no limit specified',
+  typname => 'text', typlen => '-1', typbyval => 'f', typcategory => 'S',
+  typispreferred => 't', typinput => 'textin', typoutput => 'textout',
+  typreceive => 'textrecv', typsend => 'textsend', typalign => 'i',
+  typstorage => 'x', typcollation => 'default' },
+{ oid => '26', array_type_oid => '1028',
+  descr => 'object identifier(oid), maximum 4 billion',
+  typname => 'oid', typlen => '4', typbyval => 't', typcategory => 'N',
+  typispreferred => 't', typinput => 'oidin', typoutput => 'oidout',
+  typreceive => 'oidrecv', typsend => 'oidsend', typalign => 'i' },
+{ oid => '27', array_type_oid => '1010',
+  descr => '(block, offset), physical location of tuple',
+  typname => 'tid', typlen => '6', typbyval => 'f', typcategory => 'U',
+  typinput => 'tidin', typoutput => 'tidout', typreceive => 'tidrecv',
+  typsend => 'tidsend', typalign => 's' },
+{ oid => '28', array_type_oid => '1011', descr => 'transaction id',
+  typname => 'xid', typlen => '4', typbyval => 't', typcategory => 'U',
+  typinput => 'xidin', typoutput => 'xidout', typreceive => 'xidrecv',
+  typsend => 'xidsend', typalign => 'i' },
+{ oid => '29', array_type_oid => '1012',
+  descr => 'command identifier type, sequence in transaction id',
+  typname => 'cid', typlen => '4', typbyval => 't', typcategory => 'U',
+  typinput => 'cidin', typoutput => 'cidout', typreceive => 'cidrecv',
+  typsend => 'cidsend', typalign => 'i' },
+{ oid => '30', array_type_oid => '1013',
+  descr => 'array of oids, used in system tables',
+  typname => 'oidvector', typlen => '-1', typbyval => 'f', typcategory => 'A',
+  typelem => 'oid', typinput => 'oidvectorin', typoutput => 'oidvectorout',
+  typreceive => 'oidvectorrecv', typsend => 'oidvectorsend', typalign => 'i' },
+
+# hand-built rowtype entries for bootstrapped catalogs
+# NB: OIDs assigned here must match the BKI_ROWTYPE_OID declarations
+{ oid => '71',
+  typname => 'pg_type', typlen => '-1', typbyval => 'f', typtype => 'c',
+  typcategory => 'C', typrelid => 'pg_type', typinput => 'record_in',
+  typoutput => 'record_out', typreceive => 'record_recv',
+  typsend => 'record_send', typalign => 'd', typstorage => 'x' },
+{ oid => '75',
+  typname => 'pg_attribute', typlen => '-1', typbyval => 'f', typtype => 'c',
+  typcategory => 'C', typrelid => 'pg_attribute', typinput => 'record_in',
+  typoutput => 'record_out', typreceive => 'record_recv',
+  typsend => 'record_send', typalign => 'd', typstorage => 'x' },
+{ oid => '81',
+  typname => 'pg_proc', typlen => '-1', typbyval => 'f', typtype => 'c',
+  typcategory => 'C', typrelid => 'pg_proc', typinput => 'record_in',
+  typoutput => 'record_out', typreceive => 'record_recv',
+  typsend => 'record_send', typalign => 'd', typstorage => 'x' },
+{ oid => '83',
+  typname => 'pg_class', typlen => '-1', typbyval => 'f', typtype => 'c',
+  typcategory => 'C', typrelid => 'pg_class', typinput => 'record_in',
+  typoutput => 'record_out', typreceive => 'record_recv',
+  typsend => 'record_send', typalign => 'd', typstorage => 'x' },
+
+# OIDS 100 - 199
+
+{ oid => '114', array_type_oid => '199', descr => 'JSON stored as text',
+  typname => 'json', typlen => '-1', typbyval => 'f', typcategory => 'U',
+  typinput => 'json_in', typoutput => 'json_out', typreceive => 'json_recv',
+  typsend => 'json_send', typalign => 'i', typstorage => 'x' },
+{ oid => '142', array_type_oid => '143', descr => 'XML content',
+  typname => 'xml', typlen => '-1', typbyval => 'f', typcategory => 'U',
+  typinput => 'xml_in', typoutput => 'xml_out', typreceive => 'xml_recv',
+  typsend => 'xml_send', typalign => 'i', typstorage => 'x' },
+{ oid => '194', oid_symbol => 'PGNODETREEOID',
+  descr => 'string representing an internal node tree',
+  typname => 'pg_node_tree', typlen => '-1', typbyval => 'f',
+  typcategory => 'S', typinput => 'pg_node_tree_in',
+  typoutput => 'pg_node_tree_out', typreceive => 'pg_node_tree_recv',
+  typsend => 'pg_node_tree_send', typalign => 'i', typstorage => 'x',
+  typcollation => 'default' },
+{ oid => '3361', oid_symbol => 'PGNDISTINCTOID',
+  descr => 'multivariate ndistinct coefficients',
+  typname => 'pg_ndistinct', typlen => '-1', typbyval => 'f',
+  typcategory => 'S', typinput => 'pg_ndistinct_in',
+  typoutput => 'pg_ndistinct_out', typreceive => 'pg_ndistinct_recv',
+  typsend => 'pg_ndistinct_send', typalign => 'i', typstorage => 'x',
+  typcollation => 'default' },
+{ oid => '3402', oid_symbol => 'PGDEPENDENCIESOID',
+  descr => 'multivariate dependencies',
+  typname => 'pg_dependencies', typlen => '-1', typbyval => 'f',
+  typcategory => 'S', typinput => 'pg_dependencies_in',
+  typoutput => 'pg_dependencies_out', typreceive => 'pg_dependencies_recv',
+  typsend => 'pg_dependencies_send', typalign => 'i', typstorage => 'x',
+  typcollation => 'default' },
+{ oid => '5017', oid_symbol => 'PGMCVLISTOID',
+  descr => 'multivariate MCV list',
+  typname => 'pg_mcv_list', typlen => '-1', typbyval => 'f', typcategory => 'S',
+  typinput => 'pg_mcv_list_in', typoutput => 'pg_mcv_list_out',
+  typreceive => 'pg_mcv_list_recv', typsend => 'pg_mcv_list_send',
+  typalign => 'i', typstorage => 'x', typcollation => 'default' },
+{ oid => '32', oid_symbol => 'PGDDLCOMMANDOID',
+  descr => 'internal type for passing CollectedCommand',
+  typname => 'pg_ddl_command', typlen => 'SIZEOF_POINTER', typbyval => 't',
+  typtype => 'p', typcategory => 'P', typinput => 'pg_ddl_command_in',
+  typoutput => 'pg_ddl_command_out', typreceive => 'pg_ddl_command_recv',
+  typsend => 'pg_ddl_command_send', typalign => 'ALIGNOF_POINTER' },
+{ oid => '5069', array_type_oid => '271', descr => 'full transaction id',
+  typname => 'xid8', typlen => '8', typbyval => 'FLOAT8PASSBYVAL',
+  typcategory => 'U', typinput => 'xid8in', typoutput => 'xid8out',
+  typreceive => 'xid8recv', typsend => 'xid8send', typalign => 'd' },
+
+# OIDS 600 - 699
+
+{ oid => '600', array_type_oid => '1017',
+  descr => 'geometric point \'(x, y)\'',
+  typname => 'point', typlen => '16', typbyval => 'f', typcategory => 'G',
+  typelem => 'float8', typinput => 'point_in', typoutput => 'point_out',
+  typreceive => 'point_recv', typsend => 'point_send', typalign => 'd' },
+{ oid => '601', array_type_oid => '1018',
+  descr => 'geometric line segment \'(pt1,pt2)\'',
+  typname => 'lseg', typlen => '32', typbyval => 'f', typcategory => 'G',
+  typelem => 'point', typinput => 'lseg_in', typoutput => 'lseg_out',
+  typreceive => 'lseg_recv', typsend => 'lseg_send', typalign => 'd' },
+{ oid => '602', array_type_oid => '1019',
+  descr => 'geometric path \'(pt1,...)\'',
+  typname => 'path', typlen => '-1', typbyval => 'f', typcategory => 'G',
+  typinput => 'path_in', typoutput => 'path_out', typreceive => 'path_recv',
+  typsend => 'path_send', typalign => 'd', typstorage => 'x' },
+{ oid => '603', array_type_oid => '1020',
+  descr => 'geometric box \'(lower left,upper right)\'',
+  typname => 'box', typlen => '32', typbyval => 'f', typcategory => 'G',
+  typdelim => ';', typelem => 'point', typinput => 'box_in',
+  typoutput => 'box_out', typreceive => 'box_recv', typsend => 'box_send',
+  typalign => 'd' },
+{ oid => '604', array_type_oid => '1027',
+  descr => 'geometric polygon \'(pt1,...)\'',
+  typname => 'polygon', typlen => '-1', typbyval => 'f', typcategory => 'G',
+  typinput => 'poly_in', typoutput => 'poly_out', typreceive => 'poly_recv',
+  typsend => 'poly_send', typalign => 'd', typstorage => 'x' },
+{ oid => '628', array_type_oid => '629', descr => 'geometric line',
+  typname => 'line', typlen => '24', typbyval => 'f', typcategory => 'G',
+  typelem => 'float8', typinput => 'line_in', typoutput => 'line_out',
+  typreceive => 'line_recv', typsend => 'line_send', typalign => 'd' },
+
+# OIDS 700 - 799
+
+{ oid => '700', array_type_oid => '1021',
+  descr => 'single-precision floating point number, 4-byte storage',
+  typname => 'float4', typlen => '4', typbyval => 't', typcategory => 'N',
+  typinput => 'float4in', typoutput => 'float4out', typreceive => 'float4recv',
+  typsend => 'float4send', typalign => 'i' },
+{ oid => '701', array_type_oid => '1022',
+  descr => 'double-precision floating point number, 8-byte storage',
+  typname => 'float8', typlen => '8', typbyval => 'FLOAT8PASSBYVAL',
+  typcategory => 'N', typispreferred => 't', typinput => 'float8in',
+  typoutput => 'float8out', typreceive => 'float8recv', typsend => 'float8send',
+  typalign => 'd' },
+{ oid => '705', descr => 'pseudo-type representing an undetermined type',
+  typname => 'unknown', typlen => '-2', typbyval => 'f', typtype => 'p',
+  typcategory => 'X', typinput => 'unknownin', typoutput => 'unknownout',
+  typreceive => 'unknownrecv', typsend => 'unknownsend', typalign => 'c' },
+{ oid => '718', array_type_oid => '719',
+  descr => 'geometric circle \'(center,radius)\'',
+  typname => 'circle', typlen => '24', typbyval => 'f', typcategory => 'G',
+  typinput => 'circle_in', typoutput => 'circle_out',
+  typreceive => 'circle_recv', typsend => 'circle_send', typalign => 'd' },
+{ oid => '790', oid_symbol => 'CASHOID', array_type_oid => '791',
+  descr => 'monetary amounts, $d,ddd.cc',
+  typname => 'money', typlen => '8', typbyval => 'FLOAT8PASSBYVAL',
+  typcategory => 'N', typinput => 'cash_in', typoutput => 'cash_out',
+  typreceive => 'cash_recv', typsend => 'cash_send', typalign => 'd' },
+
+# OIDS 800 - 899
+
+{ oid => '829', array_type_oid => '1040',
+  descr => 'XX:XX:XX:XX:XX:XX, MAC address',
+  typname => 'macaddr', typlen => '6', typbyval => 'f', typcategory => 'U',
+  typinput => 'macaddr_in', typoutput => 'macaddr_out',
+  typreceive => 'macaddr_recv', typsend => 'macaddr_send', typalign => 'i' },
+{ oid => '869', array_type_oid => '1041',
+  descr => 'IP address/netmask, host address, netmask optional',
+  typname => 'inet', typlen => '-1', typbyval => 'f', typcategory => 'I',
+  typispreferred => 't', typinput => 'inet_in', typoutput => 'inet_out',
+  typreceive => 'inet_recv', typsend => 'inet_send', typalign => 'i',
+  typstorage => 'm' },
+{ oid => '650', array_type_oid => '651',
+  descr => 'network IP address/netmask, network address',
+  typname => 'cidr', typlen => '-1', typbyval => 'f', typcategory => 'I',
+  typinput => 'cidr_in', typoutput => 'cidr_out', typreceive => 'cidr_recv',
+  typsend => 'cidr_send', typalign => 'i', typstorage => 'm' },
+{ oid => '774', array_type_oid => '775',
+  descr => 'XX:XX:XX:XX:XX:XX:XX:XX, MAC address',
+  typname => 'macaddr8', typlen => '8', typbyval => 'f', typcategory => 'U',
+  typinput => 'macaddr8_in', typoutput => 'macaddr8_out',
+  typreceive => 'macaddr8_recv', typsend => 'macaddr8_send', typalign => 'i' },
+
+# OIDS 1000 - 1099
+
+{ oid => '1033', array_type_oid => '1034', descr => 'access control list',
+  typname => 'aclitem', typlen => '12', typbyval => 'f', typcategory => 'U',
+  typinput => 'aclitemin', typoutput => 'aclitemout', typreceive => '-',
+  typsend => '-', typalign => 'i' },
+{ oid => '1042', array_type_oid => '1014',
+  descr => 'char(length), blank-padded string, fixed storage length',
+  typname => 'bpchar', typlen => '-1', typbyval => 'f', typcategory => 'S',
+  typinput => 'bpcharin', typoutput => 'bpcharout', typreceive => 'bpcharrecv',
+  typsend => 'bpcharsend', typmodin => 'bpchartypmodin',
+  typmodout => 'bpchartypmodout', typalign => 'i', typstorage => 'x',
+  typcollation => 'default' },
+{ oid => '1043', array_type_oid => '1015',
+  descr => 'varchar(length), non-blank-padded string, variable storage length',
+  typname => 'varchar', typlen => '-1', typbyval => 'f', typcategory => 'S',
+  typinput => 'varcharin', typoutput => 'varcharout',
+  typreceive => 'varcharrecv', typsend => 'varcharsend',
+  typmodin => 'varchartypmodin', typmodout => 'varchartypmodout',
+  typalign => 'i', typstorage => 'x', typcollation => 'default' },
+{ oid => '1082', array_type_oid => '1182', descr => 'date',
+  typname => 'date', typlen => '4', typbyval => 't', typcategory => 'D',
+  typinput => 'date_in', typoutput => 'date_out', typreceive => 'date_recv',
+  typsend => 'date_send', typalign => 'i' },
+{ oid => '1083', array_type_oid => '1183', descr => 'time of day',
+  typname => 'time', typlen => '8', typbyval => 'FLOAT8PASSBYVAL',
+  typcategory => 'D', typinput => 'time_in', typoutput => 'time_out',
+  typreceive => 'time_recv', typsend => 'time_send', typmodin => 'timetypmodin',
+  typmodout => 'timetypmodout', typalign => 'd' },
+
+# OIDS 1100 - 1199
+
+{ oid => '1114', array_type_oid => '1115', descr => 'date and time',
+  typname => 'timestamp', typlen => '8', typbyval => 'FLOAT8PASSBYVAL',
+  typcategory => 'D', typinput => 'timestamp_in', typoutput => 'timestamp_out',
+  typreceive => 'timestamp_recv', typsend => 'timestamp_send',
+  typmodin => 'timestamptypmodin', typmodout => 'timestamptypmodout',
+  typalign => 'd' },
+{ oid => '1184', array_type_oid => '1185',
+  descr => 'date and time with time zone',
+  typname => 'timestamptz', typlen => '8', typbyval => 'FLOAT8PASSBYVAL',
+  typcategory => 'D', typispreferred => 't', typinput => 'timestamptz_in',
+  typoutput => 'timestamptz_out', typreceive => 'timestamptz_recv',
+  typsend => 'timestamptz_send', typmodin => 'timestamptztypmodin',
+  typmodout => 'timestamptztypmodout', typalign => 'd' },
+{ oid => '1186', array_type_oid => '1187',
+  descr => '@ <number> <units>, time interval',
+  typname => 'interval', typlen => '16', typbyval => 'f', typcategory => 'T',
+  typispreferred => 't', typinput => 'interval_in', typoutput => 'interval_out',
+  typreceive => 'interval_recv', typsend => 'interval_send',
+  typmodin => 'intervaltypmodin', typmodout => 'intervaltypmodout',
+  typalign => 'd' },
+
+# OIDS 1200 - 1299
+
+{ oid => '1266', array_type_oid => '1270',
+  descr => 'time of day with time zone',
+  typname => 'timetz', typlen => '12', typbyval => 'f', typcategory => 'D',
+  typinput => 'timetz_in', typoutput => 'timetz_out',
+  typreceive => 'timetz_recv', typsend => 'timetz_send',
+  typmodin => 'timetztypmodin', typmodout => 'timetztypmodout',
+  typalign => 'd' },
+
+# OIDS 1500 - 1599
+
+{ oid => '1560', array_type_oid => '1561', descr => 'fixed-length bit string',
+  typname => 'bit', typlen => '-1', typbyval => 'f', typcategory => 'V',
+  typinput => 'bit_in', typoutput => 'bit_out', typreceive => 'bit_recv',
+  typsend => 'bit_send', typmodin => 'bittypmodin', typmodout => 'bittypmodout',
+  typalign => 'i', typstorage => 'x' },
+{ oid => '1562', array_type_oid => '1563',
+  descr => 'variable-length bit string',
+  typname => 'varbit', typlen => '-1', typbyval => 'f', typcategory => 'V',
+  typispreferred => 't', typinput => 'varbit_in', typoutput => 'varbit_out',
+  typreceive => 'varbit_recv', typsend => 'varbit_send',
+  typmodin => 'varbittypmodin', typmodout => 'varbittypmodout', typalign => 'i',
+  typstorage => 'x' },
+
+# OIDS 1700 - 1799
+
+{ oid => '1700', array_type_oid => '1231',
+  descr => 'numeric(precision, decimal), arbitrary precision number',
+  typname => 'numeric', typlen => '-1', typbyval => 'f', typcategory => 'N',
+  typinput => 'numeric_in', typoutput => 'numeric_out',
+  typreceive => 'numeric_recv', typsend => 'numeric_send',
+  typmodin => 'numerictypmodin', typmodout => 'numerictypmodout',
+  typalign => 'i', typstorage => 'm' },
+
+{ oid => '1790', array_type_oid => '2201',
+  descr => 'reference to cursor (portal name)',
+  typname => 'refcursor', typlen => '-1', typbyval => 'f', typcategory => 'U',
+  typinput => 'textin', typoutput => 'textout', typreceive => 'textrecv',
+  typsend => 'textsend', typalign => 'i', typstorage => 'x' },
+
+# OIDS 2200 - 2299
+
+{ oid => '2202', array_type_oid => '2207',
+  descr => 'registered procedure (with args)',
+  typname => 'regprocedure', typlen => '4', typbyval => 't', typcategory => 'N',
+  typinput => 'regprocedurein', typoutput => 'regprocedureout',
+  typreceive => 'regprocedurerecv', typsend => 'regproceduresend',
+  typalign => 'i' },
+{ oid => '2203', array_type_oid => '2208', descr => 'registered operator',
+  typname => 'regoper', typlen => '4', typbyval => 't', typcategory => 'N',
+  typinput => 'regoperin', typoutput => 'regoperout',
+  typreceive => 'regoperrecv', typsend => 'regopersend', typalign => 'i' },
+{ oid => '2204', array_type_oid => '2209',
+  descr => 'registered operator (with args)',
+  typname => 'regoperator', typlen => '4', typbyval => 't', typcategory => 'N',
+  typinput => 'regoperatorin', typoutput => 'regoperatorout',
+  typreceive => 'regoperatorrecv', typsend => 'regoperatorsend',
+  typalign => 'i' },
+{ oid => '2205', array_type_oid => '2210', descr => 'registered class',
+  typname => 'regclass', typlen => '4', typbyval => 't', typcategory => 'N',
+  typinput => 'regclassin', typoutput => 'regclassout',
+  typreceive => 'regclassrecv', typsend => 'regclasssend', typalign => 'i' },
+{ oid => '4191', array_type_oid => '4192', descr => 'registered collation',
+  typname => 'regcollation', typlen => '4', typbyval => 't', typcategory => 'N',
+  typinput => 'regcollationin', typoutput => 'regcollationout',
+  typreceive => 'regcollationrecv', typsend => 'regcollationsend',
+  typalign => 'i' },
+{ oid => '2206', array_type_oid => '2211', descr => 'registered type',
+  typname => 'regtype', typlen => '4', typbyval => 't', typcategory => 'N',
+  typinput => 'regtypein', typoutput => 'regtypeout',
+  typreceive => 'regtyperecv', typsend => 'regtypesend', typalign => 'i' },
+{ oid => '4096', array_type_oid => '4097', descr => 'registered role',
+  typname => 'regrole', typlen => '4', typbyval => 't', typcategory => 'N',
+  typinput => 'regrolein', typoutput => 'regroleout',
+  typreceive => 'regrolerecv', typsend => 'regrolesend', typalign => 'i' },
+{ oid => '4089', array_type_oid => '4090', descr => 'registered namespace',
+  typname => 'regnamespace', typlen => '4', typbyval => 't', typcategory => 'N',
+  typinput => 'regnamespacein', typoutput => 'regnamespaceout',
+  typreceive => 'regnamespacerecv', typsend => 'regnamespacesend',
+  typalign => 'i' },
+
+# uuid
+{ oid => '2950', array_type_oid => '2951', descr => 'UUID datatype',
+  typname => 'uuid', typlen => '16', typbyval => 'f', typcategory => 'U',
+  typinput => 'uuid_in', typoutput => 'uuid_out', typreceive => 'uuid_recv',
+  typsend => 'uuid_send', typalign => 'c' },
+
+# pg_lsn
+{ oid => '3220', oid_symbol => 'LSNOID', array_type_oid => '3221',
+  descr => 'PostgreSQL LSN datatype',
+  typname => 'pg_lsn', typlen => '8', typbyval => 'FLOAT8PASSBYVAL',
+  typcategory => 'U', typinput => 'pg_lsn_in', typoutput => 'pg_lsn_out',
+  typreceive => 'pg_lsn_recv', typsend => 'pg_lsn_send', typalign => 'd' },
+
+# text search
+{ oid => '3614', array_type_oid => '3643',
+  descr => 'text representation for text search',
+  typname => 'tsvector', typlen => '-1', typbyval => 'f', typcategory => 'U',
+  typinput => 'tsvectorin', typoutput => 'tsvectorout',
+  typreceive => 'tsvectorrecv', typsend => 'tsvectorsend',
+  typanalyze => 'ts_typanalyze', typalign => 'i', typstorage => 'x' },
+{ oid => '3642', array_type_oid => '3644',
+  descr => 'GiST index internal text representation for text search',
+  typname => 'gtsvector', typlen => '-1', typbyval => 'f', typcategory => 'U',
+  typinput => 'gtsvectorin', typoutput => 'gtsvectorout', typreceive => '-',
+  typsend => '-', typalign => 'i' },
+{ oid => '3615', array_type_oid => '3645',
+  descr => 'query representation for text search',
+  typname => 'tsquery', typlen => '-1', typbyval => 'f', typcategory => 'U',
+  typinput => 'tsqueryin', typoutput => 'tsqueryout',
+  typreceive => 'tsqueryrecv', typsend => 'tsquerysend', typalign => 'i' },
+{ oid => '3734', array_type_oid => '3735',
+  descr => 'registered text search configuration',
+  typname => 'regconfig', typlen => '4', typbyval => 't', typcategory => 'N',
+  typinput => 'regconfigin', typoutput => 'regconfigout',
+  typreceive => 'regconfigrecv', typsend => 'regconfigsend', typalign => 'i' },
+{ oid => '3769', array_type_oid => '3770',
+  descr => 'registered text search dictionary',
+  typname => 'regdictionary', typlen => '4', typbyval => 't',
+  typcategory => 'N', typinput => 'regdictionaryin',
+  typoutput => 'regdictionaryout', typreceive => 'regdictionaryrecv',
+  typsend => 'regdictionarysend', typalign => 'i' },
+
+# jsonb
+{ oid => '3802', array_type_oid => '3807', descr => 'Binary JSON',
+  typname => 'jsonb', typlen => '-1', typbyval => 'f', typcategory => 'U',
+  typinput => 'jsonb_in', typoutput => 'jsonb_out', typreceive => 'jsonb_recv',
+  typsend => 'jsonb_send', typalign => 'i', typstorage => 'x' },
+{ oid => '4072', array_type_oid => '4073', descr => 'JSON path',
+  typname => 'jsonpath', typlen => '-1', typbyval => 'f', typcategory => 'U',
+  typinput => 'jsonpath_in', typoutput => 'jsonpath_out',
+  typreceive => 'jsonpath_recv', typsend => 'jsonpath_send', typalign => 'i',
+  typstorage => 'x' },
+
+{ oid => '2970', array_type_oid => '2949', descr => 'txid snapshot',
+  typname => 'txid_snapshot', typlen => '-1', typbyval => 'f',
+  typcategory => 'U', typinput => 'txid_snapshot_in',
+  typoutput => 'txid_snapshot_out', typreceive => 'txid_snapshot_recv',
+  typsend => 'txid_snapshot_send', typalign => 'd', typstorage => 'x' },
+{ oid => '5038', array_type_oid => '5039', descr => 'snapshot',
+  typname => 'pg_snapshot', typlen => '-1', typbyval => 'f', typcategory => 'U',
+  typinput => 'pg_snapshot_in', typoutput => 'pg_snapshot_out',
+  typreceive => 'pg_snapshot_recv', typsend => 'pg_snapshot_send',
+  typalign => 'd', typstorage => 'x' },
+
+# range types
+{ oid => '3904', array_type_oid => '3905', descr => 'range of integers',
+  typname => 'int4range', typlen => '-1', typbyval => 'f', typtype => 'r',
+  typcategory => 'R', typinput => 'range_in', typoutput => 'range_out',
+  typreceive => 'range_recv', typsend => 'range_send',
+  typanalyze => 'range_typanalyze', typalign => 'i', typstorage => 'x' },
+{ oid => '3906', array_type_oid => '3907', descr => 'range of numerics',
+  typname => 'numrange', typlen => '-1', typbyval => 'f', typtype => 'r',
+  typcategory => 'R', typinput => 'range_in', typoutput => 'range_out',
+  typreceive => 'range_recv', typsend => 'range_send',
+  typanalyze => 'range_typanalyze', typalign => 'i', typstorage => 'x' },
+{ oid => '3908', array_type_oid => '3909',
+  descr => 'range of timestamps without time zone',
+  typname => 'tsrange', typlen => '-1', typbyval => 'f', typtype => 'r',
+  typcategory => 'R', typinput => 'range_in', typoutput => 'range_out',
+  typreceive => 'range_recv', typsend => 'range_send',
+  typanalyze => 'range_typanalyze', typalign => 'd', typstorage => 'x' },
+{ oid => '3910', array_type_oid => '3911',
+  descr => 'range of timestamps with time zone',
+  typname => 'tstzrange', typlen => '-1', typbyval => 'f', typtype => 'r',
+  typcategory => 'R', typinput => 'range_in', typoutput => 'range_out',
+  typreceive => 'range_recv', typsend => 'range_send',
+  typanalyze => 'range_typanalyze', typalign => 'd', typstorage => 'x' },
+{ oid => '3912', array_type_oid => '3913', descr => 'range of dates',
+  typname => 'daterange', typlen => '-1', typbyval => 'f', typtype => 'r',
+  typcategory => 'R', typinput => 'range_in', typoutput => 'range_out',
+  typreceive => 'range_recv', typsend => 'range_send',
+  typanalyze => 'range_typanalyze', typalign => 'i', typstorage => 'x' },
+{ oid => '3926', array_type_oid => '3927', descr => 'range of bigints',
+  typname => 'int8range', typlen => '-1', typbyval => 'f', typtype => 'r',
+  typcategory => 'R', typinput => 'range_in', typoutput => 'range_out',
+  typreceive => 'range_recv', typsend => 'range_send',
+  typanalyze => 'range_typanalyze', typalign => 'd', typstorage => 'x' },
+
+# pseudo-types
+# types with typtype='p' represent various special cases in the type system.
+# These cannot be used to define table columns, but are valid as function
+# argument and result types (if supported by the function's implementation
+# language).
+# Note: cstring is a borderline case; it is still considered a pseudo-type,
+# but there is now support for it in records and arrays.  Perhaps we should
+# just treat it as a regular base type?
+
+{ oid => '2249', descr => 'pseudo-type representing any composite type',
+  typname => 'record', typlen => '-1', typbyval => 'f', typtype => 'p',
+  typcategory => 'P', typarray => '_record', typinput => 'record_in',
+  typoutput => 'record_out', typreceive => 'record_recv',
+  typsend => 'record_send', typalign => 'd', typstorage => 'x' },
+# Arrays of records have typcategory P, so they can't be autogenerated.
+{ oid => '2287',
+  typname => '_record', typlen => '-1', typbyval => 'f', typtype => 'p',
+  typcategory => 'P', typelem => 'record', typinput => 'array_in',
+  typoutput => 'array_out', typreceive => 'array_recv', typsend => 'array_send',
+  typanalyze => 'array_typanalyze', typalign => 'd', typstorage => 'x' },
+{ oid => '2275', array_type_oid => '1263', descr => 'C-style string',
+  typname => 'cstring', typlen => '-2', typbyval => 'f', typtype => 'p',
+  typcategory => 'P', typinput => 'cstring_in', typoutput => 'cstring_out',
+  typreceive => 'cstring_recv', typsend => 'cstring_send', typalign => 'c' },
+{ oid => '2276', descr => 'pseudo-type representing any type',
+  typname => 'any', typlen => '4', typbyval => 't', typtype => 'p',
+  typcategory => 'P', typinput => 'any_in', typoutput => 'any_out',
+  typreceive => '-', typsend => '-', typalign => 'i' },
+{ oid => '2277', descr => 'pseudo-type representing a polymorphic array type',
+  typname => 'anyarray', typlen => '-1', typbyval => 'f', typtype => 'p',
+  typcategory => 'P', typinput => 'anyarray_in', typoutput => 'anyarray_out',
+  typreceive => 'anyarray_recv', typsend => 'anyarray_send', typalign => 'd',
+  typstorage => 'x' },
+{ oid => '2278',
+  descr => 'pseudo-type for the result of a function with no real result',
+  typname => 'void', typlen => '4', typbyval => 't', typtype => 'p',
+  typcategory => 'P', typinput => 'void_in', typoutput => 'void_out',
+  typreceive => 'void_recv', typsend => 'void_send', typalign => 'i' },
+{ oid => '2279', descr => 'pseudo-type for the result of a trigger function',
+  typname => 'trigger', typlen => '4', typbyval => 't', typtype => 'p',
+  typcategory => 'P', typinput => 'trigger_in', typoutput => 'trigger_out',
+  typreceive => '-', typsend => '-', typalign => 'i' },
+{ oid => '3838', oid_symbol => 'EVTTRIGGEROID',
+  descr => 'pseudo-type for the result of an event trigger function',
+  typname => 'event_trigger', typlen => '4', typbyval => 't', typtype => 'p',
+  typcategory => 'P', typinput => 'event_trigger_in',
+  typoutput => 'event_trigger_out', typreceive => '-', typsend => '-',
+  typalign => 'i' },
+{ oid => '2280',
+  descr => 'pseudo-type for the result of a language handler function',
+  typname => 'language_handler', typlen => '4', typbyval => 't', typtype => 'p',
+  typcategory => 'P', typinput => 'language_handler_in',
+  typoutput => 'language_handler_out', typreceive => '-', typsend => '-',
+  typalign => 'i' },
+{ oid => '2281',
+  descr => 'pseudo-type representing an internal data structure',
+  typname => 'internal', typlen => 'SIZEOF_POINTER', typbyval => 't',
+  typtype => 'p', typcategory => 'P', typinput => 'internal_in',
+  typoutput => 'internal_out', typreceive => '-', typsend => '-',
+  typalign => 'ALIGNOF_POINTER' },
+{ oid => '2283', descr => 'pseudo-type representing a polymorphic base type',
+  typname => 'anyelement', typlen => '4', typbyval => 't', typtype => 'p',
+  typcategory => 'P', typinput => 'anyelement_in',
+  typoutput => 'anyelement_out', typreceive => '-', typsend => '-',
+  typalign => 'i' },
+{ oid => '2776',
+  descr => 'pseudo-type representing a polymorphic base type that is not an array',
+  typname => 'anynonarray', typlen => '4', typbyval => 't', typtype => 'p',
+  typcategory => 'P', typinput => 'anynonarray_in',
+  typoutput => 'anynonarray_out', typreceive => '-', typsend => '-',
+  typalign => 'i' },
+{ oid => '3500',
+  descr => 'pseudo-type representing a polymorphic base type that is an enum',
+  typname => 'anyenum', typlen => '4', typbyval => 't', typtype => 'p',
+  typcategory => 'P', typinput => 'anyenum_in', typoutput => 'anyenum_out',
+  typreceive => '-', typsend => '-', typalign => 'i' },
+{ oid => '3115',
+  descr => 'pseudo-type for the result of an FDW handler function',
+  typname => 'fdw_handler', typlen => '4', typbyval => 't', typtype => 'p',
+  typcategory => 'P', typinput => 'fdw_handler_in',
+  typoutput => 'fdw_handler_out', typreceive => '-', typsend => '-',
+  typalign => 'i' },
+{ oid => '325',
+  descr => 'pseudo-type for the result of an index AM handler function',
+  typname => 'index_am_handler', typlen => '4', typbyval => 't', typtype => 'p',
+  typcategory => 'P', typinput => 'index_am_handler_in',
+  typoutput => 'index_am_handler_out', typreceive => '-', typsend => '-',
+  typalign => 'i' },
+{ oid => '3310',
+  descr => 'pseudo-type for the result of a tablesample method function',
+  typname => 'tsm_handler', typlen => '4', typbyval => 't', typtype => 'p',
+  typcategory => 'P', typinput => 'tsm_handler_in',
+  typoutput => 'tsm_handler_out', typreceive => '-', typsend => '-',
+  typalign => 'i' },
+{ oid => '269',
+  typname => 'table_am_handler', typlen => '4', typbyval => 't', typtype => 'p',
+  typcategory => 'P', typinput => 'table_am_handler_in',
+  typoutput => 'table_am_handler_out', typreceive => '-', typsend => '-',
+  typalign => 'i' },
+{ oid => '3831',
+  descr => 'pseudo-type representing a range over a polymorphic base type',
+  typname => 'anyrange', typlen => '-1', typbyval => 'f', typtype => 'p',
+  typcategory => 'P', typinput => 'anyrange_in', typoutput => 'anyrange_out',
+  typreceive => '-', typsend => '-', typalign => 'd', typstorage => 'x' },
+{ oid => '5077',
+  descr => 'pseudo-type representing a polymorphic common type',
+  typname => 'anycompatible', typlen => '4', typbyval => 't', typtype => 'p',
+  typcategory => 'P', typinput => 'anycompatible_in',
+  typoutput => 'anycompatible_out', typreceive => '-', typsend => '-',
+  typalign => 'i' },
+{ oid => '5078',
+  descr => 'pseudo-type representing an array of polymorphic common type elements',
+  typname => 'anycompatiblearray', typlen => '-1', typbyval => 'f',
+  typtype => 'p', typcategory => 'P', typinput => 'anycompatiblearray_in',
+  typoutput => 'anycompatiblearray_out',
+  typreceive => 'anycompatiblearray_recv', typsend => 'anycompatiblearray_send',
+  typalign => 'd', typstorage => 'x' },
+{ oid => '5079',
+  descr => 'pseudo-type representing a polymorphic common type that is not an array',
+  typname => 'anycompatiblenonarray', typlen => '4', typbyval => 't',
+  typtype => 'p', typcategory => 'P', typinput => 'anycompatiblenonarray_in',
+  typoutput => 'anycompatiblenonarray_out', typreceive => '-', typsend => '-',
+  typalign => 'i' },
+{ oid => '5080',
+  descr => 'pseudo-type representing a range over a polymorphic common type',
+  typname => 'anycompatiblerange', typlen => '-1', typbyval => 'f',
+  typtype => 'p', typcategory => 'P', typinput => 'anycompatiblerange_in',
+  typoutput => 'anycompatiblerange_out', typreceive => '-', typsend => '-',
+  typalign => 'd', typstorage => 'x' },
+
+]
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_type.h b/contrib/libs/postgresql/src/include/catalog/pg_type.h
new file mode 100644
index 0000000000..ebde49dafb
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_type.h
@@ -0,0 +1,373 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_type.h
+ *	  definition of the "type" system catalog (pg_type)
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_type.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_TYPE_H
+#define PG_TYPE_H
+
+#include "catalog/genbki.h"
+#include "catalog/objectaddress.h"
+#include "catalog/pg_type_d.h"
+#include "nodes/nodes.h"
+
+/* ----------------
+ *		pg_type definition.  cpp turns this into
+ *		typedef struct FormData_pg_type
+ *
+ *		Some of the values in a pg_type instance are copied into
+ *		pg_attribute instances.  Some parts of Postgres use the pg_type copy,
+ *		while others use the pg_attribute copy, so they must match.
+ *		See struct FormData_pg_attribute for details.
+ * ----------------
+ */
+CATALOG(pg_type,1247,TypeRelationId) BKI_BOOTSTRAP BKI_ROWTYPE_OID(71,TypeRelation_Rowtype_Id) BKI_SCHEMA_MACRO
+{
+	Oid			oid;			/* oid */
+
+	/* type name */
+	NameData	typname;
+
+	/* OID of namespace containing this type */
+	Oid			typnamespace BKI_DEFAULT(PGNSP);
+
+	/* type owner */
+	Oid			typowner BKI_DEFAULT(PGUID);
+
+	/*
+	 * For a fixed-size type, typlen is the number of bytes we use to
+	 * represent a value of this type, e.g. 4 for an int4.  But for a
+	 * variable-length type, typlen is negative.  We use -1 to indicate a
+	 * "varlena" type (one that has a length word), -2 to indicate a
+	 * null-terminated C string.
+	 */
+	int16		typlen BKI_ARRAY_DEFAULT(-1);
+
+	/*
+	 * typbyval determines whether internal Postgres routines pass a value of
+	 * this type by value or by reference.  typbyval had better be false if
+	 * the length is not 1, 2, or 4 (or 8 on 8-byte-Datum machines).
+	 * Variable-length types are always passed by reference. Note that
+	 * typbyval can be false even if the length would allow pass-by-value; for
+	 * example, type macaddr8 is pass-by-ref even when Datum is 8 bytes.
+	 */
+	bool		typbyval BKI_ARRAY_DEFAULT(f);
+
+	/*
+	 * typtype is 'b' for a base type, 'c' for a composite type (e.g., a
+	 * table's rowtype), 'd' for a domain, 'e' for an enum type, 'p' for a
+	 * pseudo-type, or 'r' for a range type. (Use the TYPTYPE macros below.)
+	 *
+	 * If typtype is 'c', typrelid is the OID of the class' entry in pg_class.
+	 */
+	char		typtype BKI_DEFAULT(b) BKI_ARRAY_DEFAULT(b);
+
+	/*
+	 * typcategory and typispreferred help the parser distinguish preferred
+	 * and non-preferred coercions.  The category can be any single ASCII
+	 * character (but not \0).  The categories used for built-in types are
+	 * identified by the TYPCATEGORY macros below.
+	 */
+
+	/* arbitrary type classification */
+	char		typcategory BKI_ARRAY_DEFAULT(A);
+
+	/* is type "preferred" within its category? */
+	bool		typispreferred BKI_DEFAULT(f) BKI_ARRAY_DEFAULT(f);
+
+	/*
+	 * If typisdefined is false, the entry is only a placeholder (forward
+	 * reference).  We know the type's name and owner, but not yet anything
+	 * else about it.
+	 */
+	bool		typisdefined BKI_DEFAULT(t);
+
+	/* delimiter for arrays of this type */
+	char		typdelim BKI_DEFAULT(',');
+
+	/* associated pg_class OID if a composite type, else 0 */
+	Oid			typrelid BKI_DEFAULT(0) BKI_ARRAY_DEFAULT(0) BKI_LOOKUP(pg_class);
+
+	/*
+	 * If typelem is not 0 then it identifies another row in pg_type. The
+	 * current type can then be subscripted like an array yielding values of
+	 * type typelem. A non-zero typelem does not guarantee this type to be a
+	 * "real" array type; some ordinary fixed-length types can also be
+	 * subscripted (e.g., name, point). Variable-length types can *not* be
+	 * turned into pseudo-arrays like that. Hence, the way to determine
+	 * whether a type is a "true" array type is if:
+	 *
+	 * typelem != 0 and typlen == -1.
+	 */
+	Oid			typelem BKI_DEFAULT(0) BKI_LOOKUP(pg_type);
+
+	/*
+	 * If there is a "true" array type having this type as element type,
+	 * typarray links to it.  Zero if no associated "true" array type.
+	 */
+	Oid			typarray BKI_DEFAULT(0) BKI_ARRAY_DEFAULT(0) BKI_LOOKUP(pg_type);
+
+	/*
+	 * I/O conversion procedures for the datatype.
+	 */
+
+	/* text format (required) */
+	regproc		typinput BKI_ARRAY_DEFAULT(array_in) BKI_LOOKUP(pg_proc);
+	regproc		typoutput BKI_ARRAY_DEFAULT(array_out) BKI_LOOKUP(pg_proc);
+
+	/* binary format (optional) */
+	regproc		typreceive BKI_ARRAY_DEFAULT(array_recv) BKI_LOOKUP(pg_proc);
+	regproc		typsend BKI_ARRAY_DEFAULT(array_send) BKI_LOOKUP(pg_proc);
+
+	/*
+	 * I/O functions for optional type modifiers.
+	 */
+	regproc		typmodin BKI_DEFAULT(-) BKI_LOOKUP(pg_proc);
+	regproc		typmodout BKI_DEFAULT(-) BKI_LOOKUP(pg_proc);
+
+	/*
+	 * Custom ANALYZE procedure for the datatype (0 selects the default).
+	 */
+	regproc		typanalyze BKI_DEFAULT(-) BKI_ARRAY_DEFAULT(array_typanalyze) BKI_LOOKUP(pg_proc);
+
+	/* ----------------
+	 * typalign is the alignment required when storing a value of this
+	 * type.  It applies to storage on disk as well as most
+	 * representations of the value inside Postgres.  When multiple values
+	 * are stored consecutively, such as in the representation of a
+	 * complete row on disk, padding is inserted before a datum of this
+	 * type so that it begins on the specified boundary.  The alignment
+	 * reference is the beginning of the first datum in the sequence.
+	 *
+	 * 'c' = CHAR alignment, ie no alignment needed.
+	 * 's' = SHORT alignment (2 bytes on most machines).
+	 * 'i' = INT alignment (4 bytes on most machines).
+	 * 'd' = DOUBLE alignment (8 bytes on many machines, but by no means all).
+	 * (Use the TYPALIGN macros below for these.)
+	 *
+	 * See include/access/tupmacs.h for the macros that compute these
+	 * alignment requirements.  Note also that we allow the nominal alignment
+	 * to be violated when storing "packed" varlenas; the TOAST mechanism
+	 * takes care of hiding that from most code.
+	 *
+	 * NOTE: for types used in system tables, it is critical that the
+	 * size and alignment defined in pg_type agree with the way that the
+	 * compiler will lay out the field in a struct representing a table row.
+	 * ----------------
+	 */
+	char		typalign;
+
+	/* ----------------
+	 * typstorage tells if the type is prepared for toasting and what
+	 * the default strategy for attributes of this type should be.
+	 *
+	 * 'p' PLAIN	  type not prepared for toasting
+	 * 'e' EXTERNAL   external storage possible, don't try to compress
+	 * 'x' EXTENDED   try to compress and store external if required
+	 * 'm' MAIN		  like 'x' but try to keep in main tuple
+	 * (Use the TYPSTORAGE macros below for these.)
+	 *
+	 * Note that 'm' fields can also be moved out to secondary storage,
+	 * but only as a last resort ('e' and 'x' fields are moved first).
+	 * ----------------
+	 */
+	char		typstorage BKI_DEFAULT(p) BKI_ARRAY_DEFAULT(x);
+
+	/*
+	 * This flag represents a "NOT NULL" constraint against this datatype.
+	 *
+	 * If true, the attnotnull column for a corresponding table column using
+	 * this datatype will always enforce the NOT NULL constraint.
+	 *
+	 * Used primarily for domain types.
+	 */
+	bool		typnotnull BKI_DEFAULT(f);
+
+	/*
+	 * Domains use typbasetype to show the base (or domain) type that the
+	 * domain is based on.  Zero if the type is not a domain.
+	 */
+	Oid			typbasetype BKI_DEFAULT(0);
+
+	/*
+	 * Domains use typtypmod to record the typmod to be applied to their base
+	 * type (-1 if base type does not use a typmod).  -1 if this type is not a
+	 * domain.
+	 */
+	int32		typtypmod BKI_DEFAULT(-1);
+
+	/*
+	 * typndims is the declared number of dimensions for an array domain type
+	 * (i.e., typbasetype is an array type).  Otherwise zero.
+	 */
+	int32		typndims BKI_DEFAULT(0);
+
+	/*
+	 * Collation: 0 if type cannot use collations, nonzero (typically
+	 * DEFAULT_COLLATION_OID) for collatable base types, possibly some other
+	 * OID for domains over collatable types
+	 */
+	Oid			typcollation BKI_DEFAULT(0) BKI_LOOKUP(pg_collation);
+
+#ifdef CATALOG_VARLEN			/* variable-length fields start here */
+
+	/*
+	 * If typdefaultbin is not NULL, it is the nodeToString representation of
+	 * a default expression for the type.  Currently this is only used for
+	 * domains.
+	 */
+	pg_node_tree typdefaultbin BKI_DEFAULT(_null_) BKI_ARRAY_DEFAULT(_null_);
+
+	/*
+	 * typdefault is NULL if the type has no associated default value. If
+	 * typdefaultbin is not NULL, typdefault must contain a human-readable
+	 * version of the default expression represented by typdefaultbin. If
+	 * typdefaultbin is NULL and typdefault is not, then typdefault is the
+	 * external representation of the type's default value, which may be fed
+	 * to the type's input converter to produce a constant.
+	 */
+	text		typdefault BKI_DEFAULT(_null_) BKI_ARRAY_DEFAULT(_null_);
+
+	/*
+	 * Access permissions
+	 */
+	aclitem		typacl[1] BKI_DEFAULT(_null_);
+#endif
+} FormData_pg_type;
+
+/* ----------------
+ *		Form_pg_type corresponds to a pointer to a row with
+ *		the format of pg_type relation.
+ * ----------------
+ */
+typedef FormData_pg_type *Form_pg_type;
+
+#ifdef EXPOSE_TO_CLIENT_CODE
+
+/*
+ * macros for values of poor-mans-enumerated-type columns
+ */
+#define  TYPTYPE_BASE		'b' /* base type (ordinary scalar type) */
+#define  TYPTYPE_COMPOSITE	'c' /* composite (e.g., table's rowtype) */
+#define  TYPTYPE_DOMAIN		'd' /* domain over another type */
+#define  TYPTYPE_ENUM		'e' /* enumerated type */
+#define  TYPTYPE_PSEUDO		'p' /* pseudo-type */
+#define  TYPTYPE_RANGE		'r' /* range type */
+
+#define  TYPCATEGORY_INVALID	'\0'	/* not an allowed category */
+#define  TYPCATEGORY_ARRAY		'A'
+#define  TYPCATEGORY_BOOLEAN	'B'
+#define  TYPCATEGORY_COMPOSITE	'C'
+#define  TYPCATEGORY_DATETIME	'D'
+#define  TYPCATEGORY_ENUM		'E'
+#define  TYPCATEGORY_GEOMETRIC	'G'
+#define  TYPCATEGORY_NETWORK	'I' /* think INET */
+#define  TYPCATEGORY_NUMERIC	'N'
+#define  TYPCATEGORY_PSEUDOTYPE 'P'
+#define  TYPCATEGORY_RANGE		'R'
+#define  TYPCATEGORY_STRING		'S'
+#define  TYPCATEGORY_TIMESPAN	'T'
+#define  TYPCATEGORY_USER		'U'
+#define  TYPCATEGORY_BITSTRING	'V' /* er ... "varbit"? */
+#define  TYPCATEGORY_UNKNOWN	'X'
+
+#define  TYPALIGN_CHAR			'c' /* char alignment (i.e. unaligned) */
+#define  TYPALIGN_SHORT			's' /* short alignment (typically 2 bytes) */
+#define  TYPALIGN_INT			'i' /* int alignment (typically 4 bytes) */
+#define  TYPALIGN_DOUBLE		'd' /* double alignment (often 8 bytes) */
+
+#define  TYPSTORAGE_PLAIN		'p' /* type not prepared for toasting */
+#define  TYPSTORAGE_EXTERNAL	'e' /* toastable, don't try to compress */
+#define  TYPSTORAGE_EXTENDED	'x' /* fully toastable */
+#define  TYPSTORAGE_MAIN		'm' /* like 'x' but try to store inline */
+
+/* Is a type OID a polymorphic pseudotype?	(Beware of multiple evaluation) */
+#define IsPolymorphicType(typid)  \
+	(IsPolymorphicTypeFamily1(typid) || \
+	 IsPolymorphicTypeFamily2(typid))
+
+/* Code not part of polymorphic type resolution should not use these macros: */
+#define IsPolymorphicTypeFamily1(typid)  \
+	((typid) == ANYELEMENTOID || \
+	 (typid) == ANYARRAYOID || \
+	 (typid) == ANYNONARRAYOID || \
+	 (typid) == ANYENUMOID || \
+	 (typid) == ANYRANGEOID)
+
+#define IsPolymorphicTypeFamily2(typid)  \
+	((typid) == ANYCOMPATIBLEOID || \
+	 (typid) == ANYCOMPATIBLEARRAYOID || \
+	 (typid) == ANYCOMPATIBLENONARRAYOID || \
+	 (typid) == ANYCOMPATIBLERANGEOID)
+
+#endif							/* EXPOSE_TO_CLIENT_CODE */
+
+
+extern ObjectAddress TypeShellMake(const char *typeName,
+								   Oid typeNamespace,
+								   Oid ownerId);
+
+extern ObjectAddress TypeCreate(Oid newTypeOid,
+								const char *typeName,
+								Oid typeNamespace,
+								Oid relationOid,
+								char relationKind,
+								Oid ownerId,
+								int16 internalSize,
+								char typeType,
+								char typeCategory,
+								bool typePreferred,
+								char typDelim,
+								Oid inputProcedure,
+								Oid outputProcedure,
+								Oid receiveProcedure,
+								Oid sendProcedure,
+								Oid typmodinProcedure,
+								Oid typmodoutProcedure,
+								Oid analyzeProcedure,
+								Oid elementType,
+								bool isImplicitArray,
+								Oid arrayType,
+								Oid baseType,
+								const char *defaultTypeValue,
+								char *defaultTypeBin,
+								bool passedByValue,
+								char alignment,
+								char storage,
+								int32 typeMod,
+								int32 typNDims,
+								bool typeNotNull,
+								Oid typeCollation);
+
+extern void GenerateTypeDependencies(HeapTuple typeTuple,
+									 Relation typeCatalog,
+									 Node *defaultExpr,
+									 void *typacl,
+									 char relationKind, /* only for relation
+														 * rowtypes */
+									 bool isImplicitArray,
+									 bool isDependentType,
+									 bool makeExtensionDep,
+									 bool rebuild);
+
+extern void RenameTypeInternal(Oid typeOid, const char *newTypeName,
+							   Oid typeNamespace);
+
+extern char *makeArrayTypeName(const char *typeName, Oid typeNamespace);
+
+extern bool moveArrayTypeName(Oid typeOid, const char *typeName,
+							  Oid typeNamespace);
+
+#endif							/* PG_TYPE_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_type_d.h b/contrib/libs/postgresql/src/include/catalog/pg_type_d.h
new file mode 100644
index 0000000000..681ec78b84
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_type_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_type_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_user_mapping.h b/contrib/libs/postgresql/src/include/catalog/pg_user_mapping.h
new file mode 100644
index 0000000000..f5ccdb857a
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_user_mapping.h
@@ -0,0 +1,48 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_user_mapping.h
+ *	  definition of the "user mapping" system catalog (pg_user_mapping)
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_user_mapping.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_USER_MAPPING_H
+#define PG_USER_MAPPING_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_user_mapping_d.h"
+
+/* ----------------
+ *		pg_user_mapping definition.  cpp turns this into
+ *		typedef struct FormData_pg_user_mapping
+ * ----------------
+ */
+CATALOG(pg_user_mapping,1418,UserMappingRelationId)
+{
+	Oid			oid;			/* oid */
+
+	Oid			umuser;			/* Id of the user, InvalidOid if PUBLIC is
+								 * wanted */
+	Oid			umserver;		/* server of this mapping */
+
+#ifdef CATALOG_VARLEN			/* variable-length fields start here */
+	text		umoptions[1];	/* user mapping options */
+#endif
+} FormData_pg_user_mapping;
+
+/* ----------------
+ *		Form_pg_user_mapping corresponds to a pointer to a tuple with
+ *		the format of pg_user_mapping relation.
+ * ----------------
+ */
+typedef FormData_pg_user_mapping *Form_pg_user_mapping;
+
+#endif							/* PG_USER_MAPPING_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/pg_user_mapping_d.h b/contrib/libs/postgresql/src/include/catalog/pg_user_mapping_d.h
new file mode 100644
index 0000000000..0f3c9a413f
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/pg_user_mapping_d.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/pg_user_mapping_d.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/schemapg.h b/contrib/libs/postgresql/src/include/catalog/schemapg.h
new file mode 100644
index 0000000000..7943644b9b
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/schemapg.h
@@ -0,0 +1 @@
+#include "../../backend/catalog/schemapg.h" /* inclink generated by yamaker */
diff --git a/contrib/libs/postgresql/src/include/catalog/storage.h b/contrib/libs/postgresql/src/include/catalog/storage.h
new file mode 100644
index 0000000000..30c38e0ca6
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/storage.h
@@ -0,0 +1,48 @@
+/*-------------------------------------------------------------------------
+ *
+ * storage.h
+ *	  prototypes for functions in backend/catalog/storage.c
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/storage.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef STORAGE_H
+#define STORAGE_H
+
+#include "storage/block.h"
+#include "storage/relfilenode.h"
+#include "storage/smgr.h"
+#include "utils/relcache.h"
+
+/* GUC variables */
+extern int	wal_skip_threshold;
+
+extern SMgrRelation RelationCreateStorage(RelFileNode rnode, char relpersistence);
+extern void RelationDropStorage(Relation rel);
+extern void RelationPreserveStorage(RelFileNode rnode, bool atCommit);
+extern void RelationPreTruncate(Relation rel);
+extern void RelationTruncate(Relation rel, BlockNumber nblocks);
+extern void RelationCopyStorage(SMgrRelation src, SMgrRelation dst,
+								ForkNumber forkNum, char relpersistence);
+extern bool RelFileNodeSkippingWAL(RelFileNode rnode);
+extern Size EstimatePendingSyncsSpace(void);
+extern void SerializePendingSyncs(Size maxSize, char *startAddress);
+extern void RestorePendingSyncs(char *startAddress);
+
+/*
+ * These functions used to be in storage/smgr/smgr.c, which explains the
+ * naming
+ */
+extern void smgrDoPendingDeletes(bool isCommit);
+extern void smgrDoPendingSyncs(bool isCommit, bool isParallelWorker);
+extern int	smgrGetPendingDeletes(bool forCommit, RelFileNode **ptr);
+extern void AtSubCommit_smgr(void);
+extern void AtSubAbort_smgr(void);
+extern void PostPrepare_smgr(void);
+
+#endif							/* STORAGE_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/storage_xlog.h b/contrib/libs/postgresql/src/include/catalog/storage_xlog.h
new file mode 100644
index 0000000000..7b21cab2e0
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/storage_xlog.h
@@ -0,0 +1,59 @@
+/*-------------------------------------------------------------------------
+ *
+ * storage_xlog.h
+ *	  prototypes for XLog support for backend/catalog/storage.c
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/storage_xlog.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef STORAGE_XLOG_H
+#define STORAGE_XLOG_H
+
+#include "access/xlogreader.h"
+#include "lib/stringinfo.h"
+#include "storage/block.h"
+#include "storage/relfilenode.h"
+
+/*
+ * Declarations for smgr-related XLOG records
+ *
+ * Note: we log file creation and truncation here, but logging of deletion
+ * actions is handled by xact.c, because it is part of transaction commit.
+ */
+
+/* XLOG gives us high 4 bits */
+#define XLOG_SMGR_CREATE	0x10
+#define XLOG_SMGR_TRUNCATE	0x20
+
+typedef struct xl_smgr_create
+{
+	RelFileNode rnode;
+	ForkNumber	forkNum;
+} xl_smgr_create;
+
+/* flags for xl_smgr_truncate */
+#define SMGR_TRUNCATE_HEAP		0x0001
+#define SMGR_TRUNCATE_VM		0x0002
+#define SMGR_TRUNCATE_FSM		0x0004
+#define SMGR_TRUNCATE_ALL		\
+	(SMGR_TRUNCATE_HEAP|SMGR_TRUNCATE_VM|SMGR_TRUNCATE_FSM)
+
+typedef struct xl_smgr_truncate
+{
+	BlockNumber blkno;
+	RelFileNode rnode;
+	int			flags;
+} xl_smgr_truncate;
+
+extern void log_smgrcreate(const RelFileNode *rnode, ForkNumber forkNum);
+
+extern void smgr_redo(XLogReaderState *record);
+extern void smgr_desc(StringInfo buf, XLogReaderState *record);
+extern const char *smgr_identify(uint8 info);
+
+#endif							/* STORAGE_XLOG_H */
diff --git a/contrib/libs/postgresql/src/include/catalog/toasting.h b/contrib/libs/postgresql/src/include/catalog/toasting.h
new file mode 100644
index 0000000000..bde14263a1
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/catalog/toasting.h
@@ -0,0 +1,105 @@
+/*-------------------------------------------------------------------------
+ *
+ * toasting.h
+ *	  This file provides some definitions to support creation of toast tables
+ *
+ * Caution: all #define's with numeric values in this file had better be
+ * object OIDs, else renumber_oids.pl might change them inappropriately.
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/toasting.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef TOASTING_H
+#define TOASTING_H
+
+#include "storage/lock.h"
+
+/*
+ * toasting.c prototypes
+ */
+extern void NewRelationCreateToastTable(Oid relOid, Datum reloptions);
+extern void NewHeapCreateToastTable(Oid relOid, Datum reloptions,
+									LOCKMODE lockmode, Oid OIDOldToast);
+extern void AlterTableCreateToastTable(Oid relOid, Datum reloptions,
+									   LOCKMODE lockmode);
+extern void BootstrapToastTable(char *relName,
+								Oid toastOid, Oid toastIndexOid);
+
+
+/*
+ * This macro is just to keep the C compiler from spitting up on the
+ * upcoming commands for Catalog.pm.
+ */
+#define DECLARE_TOAST(name,toastoid,indexoid) extern int no_such_variable
+
+
+/*
+ * What follows are lines processed by genbki.pl to create the statements
+ * the bootstrap parser will turn into BootstrapToastTable commands.
+ * Each line specifies the system catalog that needs a toast table,
+ * the OID to assign to the toast table, and the OID to assign to the
+ * toast table's index.  The reason we hard-wire these OIDs is that we
+ * need stable OIDs for shared relations, and that includes toast tables
+ * of shared relations.
+ */
+
+/* normal catalogs */
+DECLARE_TOAST(pg_aggregate, 4159, 4160);
+DECLARE_TOAST(pg_attrdef, 2830, 2831);
+DECLARE_TOAST(pg_collation, 4161, 4162);
+DECLARE_TOAST(pg_constraint, 2832, 2833);
+DECLARE_TOAST(pg_default_acl, 4143, 4144);
+DECLARE_TOAST(pg_description, 2834, 2835);
+DECLARE_TOAST(pg_event_trigger, 4145, 4146);
+DECLARE_TOAST(pg_extension, 4147, 4148);
+DECLARE_TOAST(pg_foreign_data_wrapper, 4149, 4150);
+DECLARE_TOAST(pg_foreign_server, 4151, 4152);
+DECLARE_TOAST(pg_foreign_table, 4153, 4154);
+DECLARE_TOAST(pg_init_privs, 4155, 4156);
+DECLARE_TOAST(pg_language, 4157, 4158);
+DECLARE_TOAST(pg_namespace, 4163, 4164);
+DECLARE_TOAST(pg_partitioned_table, 4165, 4166);
+DECLARE_TOAST(pg_policy, 4167, 4168);
+DECLARE_TOAST(pg_proc, 2836, 2837);
+DECLARE_TOAST(pg_rewrite, 2838, 2839);
+DECLARE_TOAST(pg_seclabel, 3598, 3599);
+DECLARE_TOAST(pg_statistic, 2840, 2841);
+DECLARE_TOAST(pg_statistic_ext, 3439, 3440);
+DECLARE_TOAST(pg_statistic_ext_data, 3430, 3431);
+DECLARE_TOAST(pg_trigger, 2336, 2337);
+DECLARE_TOAST(pg_ts_dict, 4169, 4170);
+DECLARE_TOAST(pg_type, 4171, 4172);
+DECLARE_TOAST(pg_user_mapping, 4173, 4174);
+
+/* shared catalogs */
+DECLARE_TOAST(pg_authid, 4175, 4176);
+#define PgAuthidToastTable 4175
+#define PgAuthidToastIndex 4176
+DECLARE_TOAST(pg_database, 4177, 4178);
+#define PgDatabaseToastTable 4177
+#define PgDatabaseToastIndex 4178
+DECLARE_TOAST(pg_db_role_setting, 2966, 2967);
+#define PgDbRoleSettingToastTable 2966
+#define PgDbRoleSettingToastIndex 2967
+DECLARE_TOAST(pg_replication_origin, 4181, 4182);
+#define PgReplicationOriginToastTable 4181
+#define PgReplicationOriginToastIndex 4182
+DECLARE_TOAST(pg_shdescription, 2846, 2847);
+#define PgShdescriptionToastTable 2846
+#define PgShdescriptionToastIndex 2847
+DECLARE_TOAST(pg_shseclabel, 4060, 4061);
+#define PgShseclabelToastTable 4060
+#define PgShseclabelToastIndex 4061
+DECLARE_TOAST(pg_subscription, 4183, 4184);
+#define PgSubscriptionToastTable 4183
+#define PgSubscriptionToastIndex 4184
+DECLARE_TOAST(pg_tablespace, 4185, 4186);
+#define PgTablespaceToastTable 4185
+#define PgTablespaceToastIndex 4186
+
+#endif							/* TOASTING_H */
diff --git a/contrib/libs/postgresql/src/include/fmgr.h b/contrib/libs/postgresql/src/include/fmgr.h
new file mode 100644
index 0000000000..d349510b7c
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/fmgr.h
@@ -0,0 +1,775 @@
+/*-------------------------------------------------------------------------
+ *
+ * fmgr.h
+ *	  Definitions for the Postgres function manager and function-call
+ *	  interface.
+ *
+ * This file must be included by all Postgres modules that either define
+ * or call fmgr-callable functions.
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/fmgr.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef FMGR_H
+#define FMGR_H
+
+/* We don't want to include primnodes.h here, so make some stub references */
+typedef struct Node *fmNodePtr;
+typedef struct Aggref *fmAggrefPtr;
+
+/* Likewise, avoid including execnodes.h here */
+typedef void (*fmExprContextCallbackFunction) (Datum arg);
+
+/* Likewise, avoid including stringinfo.h here */
+typedef struct StringInfoData *fmStringInfo;
+
+
+/*
+ * All functions that can be called directly by fmgr must have this signature.
+ * (Other functions can be called by using a handler that does have this
+ * signature.)
+ */
+
+typedef struct FunctionCallInfoBaseData *FunctionCallInfo;
+
+typedef Datum (*PGFunction) (FunctionCallInfo fcinfo);
+
+/*
+ * This struct holds the system-catalog information that must be looked up
+ * before a function can be called through fmgr.  If the same function is
+ * to be called multiple times, the lookup need be done only once and the
+ * info struct saved for re-use.
+ *
+ * Note that fn_expr really is parse-time-determined information about the
+ * arguments, rather than about the function itself.  But it's convenient to
+ * store it here rather than in FunctionCallInfoBaseData, where it might more
+ * logically belong.
+ *
+ * fn_extra is available for use by the called function; all other fields
+ * should be treated as read-only after the struct is created.
+ */
+typedef struct FmgrInfo
+{
+	PGFunction	fn_addr;		/* pointer to function or handler to be called */
+	Oid			fn_oid;			/* OID of function (NOT of handler, if any) */
+	short		fn_nargs;		/* number of input args (0..FUNC_MAX_ARGS) */
+	bool		fn_strict;		/* function is "strict" (NULL in => NULL out) */
+	bool		fn_retset;		/* function returns a set */
+	unsigned char fn_stats;		/* collect stats if track_functions > this */
+	void	   *fn_extra;		/* extra space for use by handler */
+	MemoryContext fn_mcxt;		/* memory context to store fn_extra in */
+	fmNodePtr	fn_expr;		/* expression parse tree for call, or NULL */
+} FmgrInfo;
+
+/*
+ * This struct is the data actually passed to an fmgr-called function.
+ *
+ * The called function is expected to set isnull, and possibly resultinfo or
+ * fields in whatever resultinfo points to.  It should not change any other
+ * fields.  (In particular, scribbling on the argument arrays is a bad idea,
+ * since some callers assume they can re-call with the same arguments.)
+ *
+ * Note that enough space for arguments needs to be provided, either by using
+ * SizeForFunctionCallInfo() in dynamic allocations, or by using
+ * LOCAL_FCINFO() for on-stack allocations.
+ *
+ * This struct is named *BaseData, rather than *Data, to break pre v12 code
+ * that allocated FunctionCallInfoData itself, as it'd often silently break
+ * old code due to no space for arguments being provided.
+ */
+typedef struct FunctionCallInfoBaseData
+{
+	FmgrInfo   *flinfo;			/* ptr to lookup info used for this call */
+	fmNodePtr	context;		/* pass info about context of call */
+	fmNodePtr	resultinfo;		/* pass or return extra info about result */
+	Oid			fncollation;	/* collation for function to use */
+#define FIELDNO_FUNCTIONCALLINFODATA_ISNULL 4
+	bool		isnull;			/* function must set true if result is NULL */
+	short		nargs;			/* # arguments actually passed */
+#define FIELDNO_FUNCTIONCALLINFODATA_ARGS 6
+	NullableDatum args[FLEXIBLE_ARRAY_MEMBER];
+} FunctionCallInfoBaseData;
+
+/*
+ * Space needed for a FunctionCallInfoBaseData struct with sufficient space
+ * for `nargs` arguments.
+ */
+#define SizeForFunctionCallInfo(nargs) \
+	(offsetof(FunctionCallInfoBaseData, args) + \
+	 sizeof(NullableDatum) * (nargs))
+
+/*
+ * This macro ensures that `name` points to a stack-allocated
+ * FunctionCallInfoBaseData struct with sufficient space for `nargs` arguments.
+ */
+#define LOCAL_FCINFO(name, nargs) \
+	/* use union with FunctionCallInfoBaseData to guarantee alignment */ \
+	union \
+	{ \
+		FunctionCallInfoBaseData fcinfo; \
+		/* ensure enough space for nargs args is available */ \
+		char fcinfo_data[SizeForFunctionCallInfo(nargs)]; \
+	} name##data; \
+	FunctionCallInfo name = &name##data.fcinfo
+
+/*
+ * This routine fills a FmgrInfo struct, given the OID
+ * of the function to be called.
+ */
+extern void fmgr_info(Oid functionId, FmgrInfo *finfo);
+
+/*
+ * Same, when the FmgrInfo struct is in a memory context longer-lived than
+ * CurrentMemoryContext.  The specified context will be set as fn_mcxt
+ * and used to hold all subsidiary data of finfo.
+ */
+extern void fmgr_info_cxt(Oid functionId, FmgrInfo *finfo,
+						  MemoryContext mcxt);
+
+/* Convenience macro for setting the fn_expr field */
+#define fmgr_info_set_expr(expr, finfo) \
+	((finfo)->fn_expr = (expr))
+
+/*
+ * Copy an FmgrInfo struct
+ */
+extern void fmgr_info_copy(FmgrInfo *dstinfo, FmgrInfo *srcinfo,
+						   MemoryContext destcxt);
+
+extern void fmgr_symbol(Oid functionId, char **mod, char **fn);
+
+/*
+ * This macro initializes all the fields of a FunctionCallInfoBaseData except
+ * for the args[] array.
+ */
+#define InitFunctionCallInfoData(Fcinfo, Flinfo, Nargs, Collation, Context, Resultinfo) \
+	do { \
+		(Fcinfo).flinfo = (Flinfo); \
+		(Fcinfo).context = (Context); \
+		(Fcinfo).resultinfo = (Resultinfo); \
+		(Fcinfo).fncollation = (Collation); \
+		(Fcinfo).isnull = false; \
+		(Fcinfo).nargs = (Nargs); \
+	} while (0)
+
+/*
+ * This macro invokes a function given a filled-in FunctionCallInfoBaseData
+ * struct.  The macro result is the returned Datum --- but note that
+ * caller must still check fcinfo->isnull!	Also, if function is strict,
+ * it is caller's responsibility to verify that no null arguments are present
+ * before calling.
+ *
+ * Some code performs multiple calls without redoing InitFunctionCallInfoData,
+ * possibly altering the argument values.  This is okay, but be sure to reset
+ * the fcinfo->isnull flag before each call, since callees are permitted to
+ * assume that starts out false.
+ */
+#define FunctionCallInvoke(fcinfo)	((* (fcinfo)->flinfo->fn_addr) (fcinfo))
+
+
+/*-------------------------------------------------------------------------
+ *		Support macros to ease writing fmgr-compatible functions
+ *
+ * A C-coded fmgr-compatible function should be declared as
+ *
+ *		Datum
+ *		function_name(PG_FUNCTION_ARGS)
+ *		{
+ *			...
+ *		}
+ *
+ * It should access its arguments using appropriate PG_GETARG_xxx macros
+ * and should return its result using PG_RETURN_xxx.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+/* Standard parameter list for fmgr-compatible functions */
+#define PG_FUNCTION_ARGS	FunctionCallInfo fcinfo
+
+/*
+ * Get collation function should use.
+ */
+#define PG_GET_COLLATION()	(fcinfo->fncollation)
+
+/*
+ * Get number of arguments passed to function.
+ */
+#define PG_NARGS() (fcinfo->nargs)
+
+/*
+ * If function is not marked "proisstrict" in pg_proc, it must check for
+ * null arguments using this macro.  Do not try to GETARG a null argument!
+ */
+#define PG_ARGISNULL(n)  (fcinfo->args[n].isnull)
+
+/*
+ * Support for fetching detoasted copies of toastable datatypes (all of
+ * which are varlena types).  pg_detoast_datum() gives you either the input
+ * datum (if not toasted) or a detoasted copy allocated with palloc().
+ * pg_detoast_datum_copy() always gives you a palloc'd copy --- use it
+ * if you need a modifiable copy of the input.  Caller is expected to have
+ * checked for null inputs first, if necessary.
+ *
+ * pg_detoast_datum_packed() will return packed (1-byte header) datums
+ * unmodified.  It will still expand an externally toasted or compressed datum.
+ * The resulting datum can be accessed using VARSIZE_ANY() and VARDATA_ANY()
+ * (beware of multiple evaluations in those macros!)
+ *
+ * In consumers oblivious to data alignment, call PG_DETOAST_DATUM_PACKED(),
+ * VARDATA_ANY(), VARSIZE_ANY() and VARSIZE_ANY_EXHDR().  Elsewhere, call
+ * PG_DETOAST_DATUM(), VARDATA() and VARSIZE().  Directly fetching an int16,
+ * int32 or wider field in the struct representing the datum layout requires
+ * aligned data.  memcpy() is alignment-oblivious, as are most operations on
+ * datatypes, such as text, whose layout struct contains only char fields.
+ *
+ * Note: it'd be nice if these could be macros, but I see no way to do that
+ * without evaluating the arguments multiple times, which is NOT acceptable.
+ */
+extern struct varlena *pg_detoast_datum(struct varlena *datum);
+extern struct varlena *pg_detoast_datum_copy(struct varlena *datum);
+extern struct varlena *pg_detoast_datum_slice(struct varlena *datum,
+											  int32 first, int32 count);
+extern struct varlena *pg_detoast_datum_packed(struct varlena *datum);
+
+#define PG_DETOAST_DATUM(datum) \
+	pg_detoast_datum((struct varlena *) DatumGetPointer(datum))
+#define PG_DETOAST_DATUM_COPY(datum) \
+	pg_detoast_datum_copy((struct varlena *) DatumGetPointer(datum))
+#define PG_DETOAST_DATUM_SLICE(datum,f,c) \
+		pg_detoast_datum_slice((struct varlena *) DatumGetPointer(datum), \
+		(int32) (f), (int32) (c))
+/* WARNING -- unaligned pointer */
+#define PG_DETOAST_DATUM_PACKED(datum) \
+	pg_detoast_datum_packed((struct varlena *) DatumGetPointer(datum))
+
+/*
+ * Support for cleaning up detoasted copies of inputs.  This must only
+ * be used for pass-by-ref datatypes, and normally would only be used
+ * for toastable types.  If the given pointer is different from the
+ * original argument, assume it's a palloc'd detoasted copy, and pfree it.
+ * NOTE: most functions on toastable types do not have to worry about this,
+ * but we currently require that support functions for indexes not leak
+ * memory.
+ */
+#define PG_FREE_IF_COPY(ptr,n) \
+	do { \
+		if ((Pointer) (ptr) != PG_GETARG_POINTER(n)) \
+			pfree(ptr); \
+	} while (0)
+
+/* Macros for fetching arguments of standard types */
+
+#define PG_GETARG_DATUM(n)	 (fcinfo->args[n].value)
+#define PG_GETARG_INT32(n)	 DatumGetInt32(PG_GETARG_DATUM(n))
+#define PG_GETARG_UINT32(n)  DatumGetUInt32(PG_GETARG_DATUM(n))
+#define PG_GETARG_INT16(n)	 DatumGetInt16(PG_GETARG_DATUM(n))
+#define PG_GETARG_UINT16(n)  DatumGetUInt16(PG_GETARG_DATUM(n))
+#define PG_GETARG_CHAR(n)	 DatumGetChar(PG_GETARG_DATUM(n))
+#define PG_GETARG_BOOL(n)	 DatumGetBool(PG_GETARG_DATUM(n))
+#define PG_GETARG_OID(n)	 DatumGetObjectId(PG_GETARG_DATUM(n))
+#define PG_GETARG_POINTER(n) DatumGetPointer(PG_GETARG_DATUM(n))
+#define PG_GETARG_CSTRING(n) DatumGetCString(PG_GETARG_DATUM(n))
+#define PG_GETARG_NAME(n)	 DatumGetName(PG_GETARG_DATUM(n))
+/* these macros hide the pass-by-reference-ness of the datatype: */
+#define PG_GETARG_FLOAT4(n)  DatumGetFloat4(PG_GETARG_DATUM(n))
+#define PG_GETARG_FLOAT8(n)  DatumGetFloat8(PG_GETARG_DATUM(n))
+#define PG_GETARG_INT64(n)	 DatumGetInt64(PG_GETARG_DATUM(n))
+/* use this if you want the raw, possibly-toasted input datum: */
+#define PG_GETARG_RAW_VARLENA_P(n)	((struct varlena *) PG_GETARG_POINTER(n))
+/* use this if you want the input datum de-toasted: */
+#define PG_GETARG_VARLENA_P(n) PG_DETOAST_DATUM(PG_GETARG_DATUM(n))
+/* and this if you can handle 1-byte-header datums: */
+#define PG_GETARG_VARLENA_PP(n) PG_DETOAST_DATUM_PACKED(PG_GETARG_DATUM(n))
+/* DatumGetFoo macros for varlena types will typically look like this: */
+#define DatumGetByteaPP(X)			((bytea *) PG_DETOAST_DATUM_PACKED(X))
+#define DatumGetTextPP(X)			((text *) PG_DETOAST_DATUM_PACKED(X))
+#define DatumGetBpCharPP(X)			((BpChar *) PG_DETOAST_DATUM_PACKED(X))
+#define DatumGetVarCharPP(X)		((VarChar *) PG_DETOAST_DATUM_PACKED(X))
+#define DatumGetHeapTupleHeader(X)	((HeapTupleHeader) PG_DETOAST_DATUM(X))
+/* And we also offer variants that return an OK-to-write copy */
+#define DatumGetByteaPCopy(X)		((bytea *) PG_DETOAST_DATUM_COPY(X))
+#define DatumGetTextPCopy(X)		((text *) PG_DETOAST_DATUM_COPY(X))
+#define DatumGetBpCharPCopy(X)		((BpChar *) PG_DETOAST_DATUM_COPY(X))
+#define DatumGetVarCharPCopy(X)		((VarChar *) PG_DETOAST_DATUM_COPY(X))
+#define DatumGetHeapTupleHeaderCopy(X)	((HeapTupleHeader) PG_DETOAST_DATUM_COPY(X))
+/* Variants which return n bytes starting at pos. m */
+#define DatumGetByteaPSlice(X,m,n)	((bytea *) PG_DETOAST_DATUM_SLICE(X,m,n))
+#define DatumGetTextPSlice(X,m,n)	((text *) PG_DETOAST_DATUM_SLICE(X,m,n))
+#define DatumGetBpCharPSlice(X,m,n) ((BpChar *) PG_DETOAST_DATUM_SLICE(X,m,n))
+#define DatumGetVarCharPSlice(X,m,n) ((VarChar *) PG_DETOAST_DATUM_SLICE(X,m,n))
+/* GETARG macros for varlena types will typically look like this: */
+#define PG_GETARG_BYTEA_PP(n)		DatumGetByteaPP(PG_GETARG_DATUM(n))
+#define PG_GETARG_TEXT_PP(n)		DatumGetTextPP(PG_GETARG_DATUM(n))
+#define PG_GETARG_BPCHAR_PP(n)		DatumGetBpCharPP(PG_GETARG_DATUM(n))
+#define PG_GETARG_VARCHAR_PP(n)		DatumGetVarCharPP(PG_GETARG_DATUM(n))
+#define PG_GETARG_HEAPTUPLEHEADER(n)	DatumGetHeapTupleHeader(PG_GETARG_DATUM(n))
+/* And we also offer variants that return an OK-to-write copy */
+#define PG_GETARG_BYTEA_P_COPY(n)	DatumGetByteaPCopy(PG_GETARG_DATUM(n))
+#define PG_GETARG_TEXT_P_COPY(n)	DatumGetTextPCopy(PG_GETARG_DATUM(n))
+#define PG_GETARG_BPCHAR_P_COPY(n)	DatumGetBpCharPCopy(PG_GETARG_DATUM(n))
+#define PG_GETARG_VARCHAR_P_COPY(n) DatumGetVarCharPCopy(PG_GETARG_DATUM(n))
+#define PG_GETARG_HEAPTUPLEHEADER_COPY(n)	DatumGetHeapTupleHeaderCopy(PG_GETARG_DATUM(n))
+/* And a b-byte slice from position a -also OK to write */
+#define PG_GETARG_BYTEA_P_SLICE(n,a,b) DatumGetByteaPSlice(PG_GETARG_DATUM(n),a,b)
+#define PG_GETARG_TEXT_P_SLICE(n,a,b)  DatumGetTextPSlice(PG_GETARG_DATUM(n),a,b)
+#define PG_GETARG_BPCHAR_P_SLICE(n,a,b) DatumGetBpCharPSlice(PG_GETARG_DATUM(n),a,b)
+#define PG_GETARG_VARCHAR_P_SLICE(n,a,b) DatumGetVarCharPSlice(PG_GETARG_DATUM(n),a,b)
+/*
+ * Obsolescent variants that guarantee INT alignment for the return value.
+ * Few operations on these particular types need alignment, mainly operations
+ * that cast the VARDATA pointer to a type like int16[].  Most code should use
+ * the ...PP(X) counterpart.  Nonetheless, these appear frequently in code
+ * predating the PostgreSQL 8.3 introduction of the ...PP(X) variants.
+ */
+#define DatumGetByteaP(X)			((bytea *) PG_DETOAST_DATUM(X))
+#define DatumGetTextP(X)			((text *) PG_DETOAST_DATUM(X))
+#define DatumGetBpCharP(X)			((BpChar *) PG_DETOAST_DATUM(X))
+#define DatumGetVarCharP(X)			((VarChar *) PG_DETOAST_DATUM(X))
+#define PG_GETARG_BYTEA_P(n)		DatumGetByteaP(PG_GETARG_DATUM(n))
+#define PG_GETARG_TEXT_P(n)			DatumGetTextP(PG_GETARG_DATUM(n))
+#define PG_GETARG_BPCHAR_P(n)		DatumGetBpCharP(PG_GETARG_DATUM(n))
+#define PG_GETARG_VARCHAR_P(n)		DatumGetVarCharP(PG_GETARG_DATUM(n))
+
+/* To access options from opclass support functions use this: */
+#define PG_HAS_OPCLASS_OPTIONS()	has_fn_opclass_options(fcinfo->flinfo)
+#define PG_GET_OPCLASS_OPTIONS()	get_fn_opclass_options(fcinfo->flinfo)
+
+/* To return a NULL do this: */
+#define PG_RETURN_NULL()  \
+	do { fcinfo->isnull = true; return (Datum) 0; } while (0)
+
+/* A few internal functions return void (which is not the same as NULL!) */
+#define PG_RETURN_VOID()	 return (Datum) 0
+
+/* Macros for returning results of standard types */
+
+#define PG_RETURN_DATUM(x)	 return (x)
+#define PG_RETURN_INT32(x)	 return Int32GetDatum(x)
+#define PG_RETURN_UINT32(x)  return UInt32GetDatum(x)
+#define PG_RETURN_INT16(x)	 return Int16GetDatum(x)
+#define PG_RETURN_UINT16(x)  return UInt16GetDatum(x)
+#define PG_RETURN_CHAR(x)	 return CharGetDatum(x)
+#define PG_RETURN_BOOL(x)	 return BoolGetDatum(x)
+#define PG_RETURN_OID(x)	 return ObjectIdGetDatum(x)
+#define PG_RETURN_POINTER(x) return PointerGetDatum(x)
+#define PG_RETURN_CSTRING(x) return CStringGetDatum(x)
+#define PG_RETURN_NAME(x)	 return NameGetDatum(x)
+/* these macros hide the pass-by-reference-ness of the datatype: */
+#define PG_RETURN_FLOAT4(x)  return Float4GetDatum(x)
+#define PG_RETURN_FLOAT8(x)  return Float8GetDatum(x)
+#define PG_RETURN_INT64(x)	 return Int64GetDatum(x)
+#define PG_RETURN_UINT64(x)  return UInt64GetDatum(x)
+/* RETURN macros for other pass-by-ref types will typically look like this: */
+#define PG_RETURN_BYTEA_P(x)   PG_RETURN_POINTER(x)
+#define PG_RETURN_TEXT_P(x)    PG_RETURN_POINTER(x)
+#define PG_RETURN_BPCHAR_P(x)  PG_RETURN_POINTER(x)
+#define PG_RETURN_VARCHAR_P(x) PG_RETURN_POINTER(x)
+#define PG_RETURN_HEAPTUPLEHEADER(x)  return HeapTupleHeaderGetDatum(x)
+
+
+/*-------------------------------------------------------------------------
+ *		Support for detecting call convention of dynamically-loaded functions
+ *
+ * Dynamically loaded functions currently can only use the version-1 ("new
+ * style") calling convention.  Version-0 ("old style") is not supported
+ * anymore.  Version 1 is the call convention defined in this header file, and
+ * must be accompanied by the macro call
+ *
+ *		PG_FUNCTION_INFO_V1(function_name);
+ *
+ * Note that internal functions do not need this decoration since they are
+ * assumed to be version-1.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+typedef struct
+{
+	int			api_version;	/* specifies call convention version number */
+	/* More fields may be added later, for version numbers > 1. */
+} Pg_finfo_record;
+
+/* Expected signature of an info function */
+typedef const Pg_finfo_record *(*PGFInfoFunction) (void);
+
+/*
+ *	Macro to build an info function associated with the given function name.
+ *
+ *	As a convenience, also provide an "extern" declaration for the given
+ *	function name, so that writers of C functions need not write that too.
+ *
+ *	On Windows, the function and info function must be exported.  Our normal
+ *	build processes take care of that via .DEF files or --export-all-symbols.
+ *	Module authors using a different build process might need to manually
+ *	declare the function PGDLLEXPORT.  We do that automatically here for the
+ *	info function, since authors shouldn't need to be explicitly aware of it.
+ */
+#define PG_FUNCTION_INFO_V1(funcname) \
+extern Datum funcname(PG_FUNCTION_ARGS); \
+extern PGDLLEXPORT const Pg_finfo_record * CppConcat(pg_finfo_,funcname)(void); \
+const Pg_finfo_record * \
+CppConcat(pg_finfo_,funcname) (void) \
+{ \
+	static const Pg_finfo_record my_finfo = { 1 }; \
+	return &my_finfo; \
+} \
+extern int no_such_variable
+
+
+/*-------------------------------------------------------------------------
+ *		Support for verifying backend compatibility of loaded modules
+ *
+ * We require dynamically-loaded modules to include the macro call
+ *		PG_MODULE_MAGIC;
+ * so that we can check for obvious incompatibility, such as being compiled
+ * for a different major PostgreSQL version.
+ *
+ * To compile with versions of PostgreSQL that do not support this,
+ * you may put an #ifdef/#endif test around it.  Note that in a multiple-
+ * source-file module, the macro call should only appear once.
+ *
+ * The specific items included in the magic block are intended to be ones that
+ * are custom-configurable and especially likely to break dynamically loaded
+ * modules if they were compiled with other values.  Also, the length field
+ * can be used to detect definition changes.
+ *
+ * Note: we compare magic blocks with memcmp(), so there had better not be
+ * any alignment pad bytes in them.
+ *
+ * Note: when changing the contents of magic blocks, be sure to adjust the
+ * incompatible_module_error() function in dfmgr.c.
+ *-------------------------------------------------------------------------
+ */
+
+/* Definition of the magic block structure */
+typedef struct
+{
+	int			len;			/* sizeof(this struct) */
+	int			version;		/* PostgreSQL major version */
+	int			funcmaxargs;	/* FUNC_MAX_ARGS */
+	int			indexmaxkeys;	/* INDEX_MAX_KEYS */
+	int			namedatalen;	/* NAMEDATALEN */
+	int			float8byval;	/* FLOAT8PASSBYVAL */
+} Pg_magic_struct;
+
+/* The actual data block contents */
+#define PG_MODULE_MAGIC_DATA \
+{ \
+	sizeof(Pg_magic_struct), \
+	PG_VERSION_NUM / 100, \
+	FUNC_MAX_ARGS, \
+	INDEX_MAX_KEYS, \
+	NAMEDATALEN, \
+	FLOAT8PASSBYVAL \
+}
+
+/*
+ * Declare the module magic function.  It needs to be a function as the dlsym
+ * in the backend is only guaranteed to work on functions, not data
+ */
+typedef const Pg_magic_struct *(*PGModuleMagicFunction) (void);
+
+#define PG_MAGIC_FUNCTION_NAME Pg_magic_func
+#define PG_MAGIC_FUNCTION_NAME_STRING "Pg_magic_func"
+
+#define PG_MODULE_MAGIC \
+extern PGDLLEXPORT const Pg_magic_struct *PG_MAGIC_FUNCTION_NAME(void); \
+const Pg_magic_struct * \
+PG_MAGIC_FUNCTION_NAME(void) \
+{ \
+	static const Pg_magic_struct Pg_magic_data = PG_MODULE_MAGIC_DATA; \
+	return &Pg_magic_data; \
+} \
+extern int no_such_variable
+
+
+/*-------------------------------------------------------------------------
+ *		Support routines and macros for callers of fmgr-compatible functions
+ *-------------------------------------------------------------------------
+ */
+
+/* These are for invocation of a specifically named function with a
+ * directly-computed parameter list.  Note that neither arguments nor result
+ * are allowed to be NULL.  Also, the function cannot be one that needs to
+ * look at FmgrInfo, since there won't be any.
+ */
+extern Datum DirectFunctionCall1Coll(PGFunction func, Oid collation,
+									 Datum arg1);
+extern Datum DirectFunctionCall2Coll(PGFunction func, Oid collation,
+									 Datum arg1, Datum arg2);
+extern Datum DirectFunctionCall3Coll(PGFunction func, Oid collation,
+									 Datum arg1, Datum arg2,
+									 Datum arg3);
+extern Datum DirectFunctionCall4Coll(PGFunction func, Oid collation,
+									 Datum arg1, Datum arg2,
+									 Datum arg3, Datum arg4);
+extern Datum DirectFunctionCall5Coll(PGFunction func, Oid collation,
+									 Datum arg1, Datum arg2,
+									 Datum arg3, Datum arg4, Datum arg5);
+extern Datum DirectFunctionCall6Coll(PGFunction func, Oid collation,
+									 Datum arg1, Datum arg2,
+									 Datum arg3, Datum arg4, Datum arg5,
+									 Datum arg6);
+extern Datum DirectFunctionCall7Coll(PGFunction func, Oid collation,
+									 Datum arg1, Datum arg2,
+									 Datum arg3, Datum arg4, Datum arg5,
+									 Datum arg6, Datum arg7);
+extern Datum DirectFunctionCall8Coll(PGFunction func, Oid collation,
+									 Datum arg1, Datum arg2,
+									 Datum arg3, Datum arg4, Datum arg5,
+									 Datum arg6, Datum arg7, Datum arg8);
+extern Datum DirectFunctionCall9Coll(PGFunction func, Oid collation,
+									 Datum arg1, Datum arg2,
+									 Datum arg3, Datum arg4, Datum arg5,
+									 Datum arg6, Datum arg7, Datum arg8,
+									 Datum arg9);
+
+/*
+ * These functions work like the DirectFunctionCall functions except that
+ * they use the flinfo parameter to initialise the fcinfo for the call.
+ * It's recommended that the callee only use the fn_extra and fn_mcxt
+ * fields, as other fields will typically describe the calling function
+ * not the callee.  Conversely, the calling function should not have
+ * used fn_extra, unless its use is known to be compatible with the callee's.
+ */
+extern Datum CallerFInfoFunctionCall1(PGFunction func, FmgrInfo *flinfo,
+									  Oid collation, Datum arg1);
+extern Datum CallerFInfoFunctionCall2(PGFunction func, FmgrInfo *flinfo,
+									  Oid collation, Datum arg1, Datum arg2);
+
+/* These are for invocation of a previously-looked-up function with a
+ * directly-computed parameter list.  Note that neither arguments nor result
+ * are allowed to be NULL.
+ */
+extern Datum FunctionCall0Coll(FmgrInfo *flinfo, Oid collation);
+extern Datum FunctionCall1Coll(FmgrInfo *flinfo, Oid collation,
+							   Datum arg1);
+extern Datum FunctionCall2Coll(FmgrInfo *flinfo, Oid collation,
+							   Datum arg1, Datum arg2);
+extern Datum FunctionCall3Coll(FmgrInfo *flinfo, Oid collation,
+							   Datum arg1, Datum arg2,
+							   Datum arg3);
+extern Datum FunctionCall4Coll(FmgrInfo *flinfo, Oid collation,
+							   Datum arg1, Datum arg2,
+							   Datum arg3, Datum arg4);
+extern Datum FunctionCall5Coll(FmgrInfo *flinfo, Oid collation,
+							   Datum arg1, Datum arg2,
+							   Datum arg3, Datum arg4, Datum arg5);
+extern Datum FunctionCall6Coll(FmgrInfo *flinfo, Oid collation,
+							   Datum arg1, Datum arg2,
+							   Datum arg3, Datum arg4, Datum arg5,
+							   Datum arg6);
+extern Datum FunctionCall7Coll(FmgrInfo *flinfo, Oid collation,
+							   Datum arg1, Datum arg2,
+							   Datum arg3, Datum arg4, Datum arg5,
+							   Datum arg6, Datum arg7);
+extern Datum FunctionCall8Coll(FmgrInfo *flinfo, Oid collation,
+							   Datum arg1, Datum arg2,
+							   Datum arg3, Datum arg4, Datum arg5,
+							   Datum arg6, Datum arg7, Datum arg8);
+extern Datum FunctionCall9Coll(FmgrInfo *flinfo, Oid collation,
+							   Datum arg1, Datum arg2,
+							   Datum arg3, Datum arg4, Datum arg5,
+							   Datum arg6, Datum arg7, Datum arg8,
+							   Datum arg9);
+
+/* These are for invocation of a function identified by OID with a
+ * directly-computed parameter list.  Note that neither arguments nor result
+ * are allowed to be NULL.  These are essentially fmgr_info() followed by
+ * FunctionCallN().  If the same function is to be invoked repeatedly, do the
+ * fmgr_info() once and then use FunctionCallN().
+ */
+extern Datum OidFunctionCall0Coll(Oid functionId, Oid collation);
+extern Datum OidFunctionCall1Coll(Oid functionId, Oid collation,
+								  Datum arg1);
+extern Datum OidFunctionCall2Coll(Oid functionId, Oid collation,
+								  Datum arg1, Datum arg2);
+extern Datum OidFunctionCall3Coll(Oid functionId, Oid collation,
+								  Datum arg1, Datum arg2,
+								  Datum arg3);
+extern Datum OidFunctionCall4Coll(Oid functionId, Oid collation,
+								  Datum arg1, Datum arg2,
+								  Datum arg3, Datum arg4);
+extern Datum OidFunctionCall5Coll(Oid functionId, Oid collation,
+								  Datum arg1, Datum arg2,
+								  Datum arg3, Datum arg4, Datum arg5);
+extern Datum OidFunctionCall6Coll(Oid functionId, Oid collation,
+								  Datum arg1, Datum arg2,
+								  Datum arg3, Datum arg4, Datum arg5,
+								  Datum arg6);
+extern Datum OidFunctionCall7Coll(Oid functionId, Oid collation,
+								  Datum arg1, Datum arg2,
+								  Datum arg3, Datum arg4, Datum arg5,
+								  Datum arg6, Datum arg7);
+extern Datum OidFunctionCall8Coll(Oid functionId, Oid collation,
+								  Datum arg1, Datum arg2,
+								  Datum arg3, Datum arg4, Datum arg5,
+								  Datum arg6, Datum arg7, Datum arg8);
+extern Datum OidFunctionCall9Coll(Oid functionId, Oid collation,
+								  Datum arg1, Datum arg2,
+								  Datum arg3, Datum arg4, Datum arg5,
+								  Datum arg6, Datum arg7, Datum arg8,
+								  Datum arg9);
+
+/* These macros allow the collation argument to be omitted (with a default of
+ * InvalidOid, ie, no collation).  They exist mostly for backwards
+ * compatibility of source code.
+ */
+#define DirectFunctionCall1(func, arg1) \
+	DirectFunctionCall1Coll(func, InvalidOid, arg1)
+#define DirectFunctionCall2(func, arg1, arg2) \
+	DirectFunctionCall2Coll(func, InvalidOid, arg1, arg2)
+#define DirectFunctionCall3(func, arg1, arg2, arg3) \
+	DirectFunctionCall3Coll(func, InvalidOid, arg1, arg2, arg3)
+#define DirectFunctionCall4(func, arg1, arg2, arg3, arg4) \
+	DirectFunctionCall4Coll(func, InvalidOid, arg1, arg2, arg3, arg4)
+#define DirectFunctionCall5(func, arg1, arg2, arg3, arg4, arg5) \
+	DirectFunctionCall5Coll(func, InvalidOid, arg1, arg2, arg3, arg4, arg5)
+#define DirectFunctionCall6(func, arg1, arg2, arg3, arg4, arg5, arg6) \
+	DirectFunctionCall6Coll(func, InvalidOid, arg1, arg2, arg3, arg4, arg5, arg6)
+#define DirectFunctionCall7(func, arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
+	DirectFunctionCall7Coll(func, InvalidOid, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
+#define DirectFunctionCall8(func, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) \
+	DirectFunctionCall8Coll(func, InvalidOid, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
+#define DirectFunctionCall9(func, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) \
+	DirectFunctionCall9Coll(func, InvalidOid, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
+#define FunctionCall1(flinfo, arg1) \
+	FunctionCall1Coll(flinfo, InvalidOid, arg1)
+#define FunctionCall2(flinfo, arg1, arg2) \
+	FunctionCall2Coll(flinfo, InvalidOid, arg1, arg2)
+#define FunctionCall3(flinfo, arg1, arg2, arg3) \
+	FunctionCall3Coll(flinfo, InvalidOid, arg1, arg2, arg3)
+#define FunctionCall4(flinfo, arg1, arg2, arg3, arg4) \
+	FunctionCall4Coll(flinfo, InvalidOid, arg1, arg2, arg3, arg4)
+#define FunctionCall5(flinfo, arg1, arg2, arg3, arg4, arg5) \
+	FunctionCall5Coll(flinfo, InvalidOid, arg1, arg2, arg3, arg4, arg5)
+#define FunctionCall6(flinfo, arg1, arg2, arg3, arg4, arg5, arg6) \
+	FunctionCall6Coll(flinfo, InvalidOid, arg1, arg2, arg3, arg4, arg5, arg6)
+#define FunctionCall7(flinfo, arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
+	FunctionCall7Coll(flinfo, InvalidOid, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
+#define FunctionCall8(flinfo, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) \
+	FunctionCall8Coll(flinfo, InvalidOid, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
+#define FunctionCall9(flinfo, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) \
+	FunctionCall9Coll(flinfo, InvalidOid, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
+#define OidFunctionCall0(functionId) \
+	OidFunctionCall0Coll(functionId, InvalidOid)
+#define OidFunctionCall1(functionId, arg1) \
+	OidFunctionCall1Coll(functionId, InvalidOid, arg1)
+#define OidFunctionCall2(functionId, arg1, arg2) \
+	OidFunctionCall2Coll(functionId, InvalidOid, arg1, arg2)
+#define OidFunctionCall3(functionId, arg1, arg2, arg3) \
+	OidFunctionCall3Coll(functionId, InvalidOid, arg1, arg2, arg3)
+#define OidFunctionCall4(functionId, arg1, arg2, arg3, arg4) \
+	OidFunctionCall4Coll(functionId, InvalidOid, arg1, arg2, arg3, arg4)
+#define OidFunctionCall5(functionId, arg1, arg2, arg3, arg4, arg5) \
+	OidFunctionCall5Coll(functionId, InvalidOid, arg1, arg2, arg3, arg4, arg5)
+#define OidFunctionCall6(functionId, arg1, arg2, arg3, arg4, arg5, arg6) \
+	OidFunctionCall6Coll(functionId, InvalidOid, arg1, arg2, arg3, arg4, arg5, arg6)
+#define OidFunctionCall7(functionId, arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
+	OidFunctionCall7Coll(functionId, InvalidOid, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
+#define OidFunctionCall8(functionId, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) \
+	OidFunctionCall8Coll(functionId, InvalidOid, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
+#define OidFunctionCall9(functionId, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) \
+	OidFunctionCall9Coll(functionId, InvalidOid, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
+
+
+/* Special cases for convenient invocation of datatype I/O functions. */
+extern Datum InputFunctionCall(FmgrInfo *flinfo, char *str,
+							   Oid typioparam, int32 typmod);
+extern Datum OidInputFunctionCall(Oid functionId, char *str,
+								  Oid typioparam, int32 typmod);
+extern char *OutputFunctionCall(FmgrInfo *flinfo, Datum val);
+extern char *OidOutputFunctionCall(Oid functionId, Datum val);
+extern Datum ReceiveFunctionCall(FmgrInfo *flinfo, fmStringInfo buf,
+								 Oid typioparam, int32 typmod);
+extern Datum OidReceiveFunctionCall(Oid functionId, fmStringInfo buf,
+									Oid typioparam, int32 typmod);
+extern bytea *SendFunctionCall(FmgrInfo *flinfo, Datum val);
+extern bytea *OidSendFunctionCall(Oid functionId, Datum val);
+
+
+/*
+ * Routines in fmgr.c
+ */
+extern const Pg_finfo_record *fetch_finfo_record(void *filehandle, const char *funcname);
+extern void clear_external_function_hash(void *filehandle);
+extern Oid	fmgr_internal_function(const char *proname);
+extern Oid	get_fn_expr_rettype(FmgrInfo *flinfo);
+extern Oid	get_fn_expr_argtype(FmgrInfo *flinfo, int argnum);
+extern Oid	get_call_expr_argtype(fmNodePtr expr, int argnum);
+extern bool get_fn_expr_arg_stable(FmgrInfo *flinfo, int argnum);
+extern bool get_call_expr_arg_stable(fmNodePtr expr, int argnum);
+extern bool get_fn_expr_variadic(FmgrInfo *flinfo);
+extern bytea *get_fn_opclass_options(FmgrInfo *flinfo);
+extern bool has_fn_opclass_options(FmgrInfo *flinfo);
+extern void set_fn_opclass_options(FmgrInfo *flinfo, bytea *options);
+extern bool CheckFunctionValidatorAccess(Oid validatorOid, Oid functionOid);
+
+/*
+ * Routines in dfmgr.c
+ */
+extern char *Dynamic_library_path;
+
+extern PGFunction load_external_function(const char *filename, const char *funcname,
+										 bool signalNotFound, void **filehandle);
+extern PGFunction lookup_external_function(void *filehandle, const char *funcname);
+extern void load_file(const char *filename, bool restricted);
+extern void **find_rendezvous_variable(const char *varName);
+extern Size EstimateLibraryStateSpace(void);
+extern void SerializeLibraryState(Size maxsize, char *start_address);
+extern void RestoreLibraryState(char *start_address);
+
+/*
+ * Support for aggregate functions
+ *
+ * These are actually in executor/nodeAgg.c, but we declare them here since
+ * the whole point is for callers to not be overly friendly with nodeAgg.
+ */
+
+/* AggCheckCallContext can return one of the following codes, or 0: */
+#define AGG_CONTEXT_AGGREGATE	1	/* regular aggregate */
+#define AGG_CONTEXT_WINDOW		2	/* window function */
+
+extern int	AggCheckCallContext(FunctionCallInfo fcinfo,
+								MemoryContext *aggcontext);
+extern fmAggrefPtr AggGetAggref(FunctionCallInfo fcinfo);
+extern MemoryContext AggGetTempMemoryContext(FunctionCallInfo fcinfo);
+extern bool AggStateIsShared(FunctionCallInfo fcinfo);
+extern void AggRegisterCallback(FunctionCallInfo fcinfo,
+								fmExprContextCallbackFunction func,
+								Datum arg);
+
+/*
+ * We allow plugin modules to hook function entry/exit.  This is intended
+ * as support for loadable security policy modules, which may want to
+ * perform additional privilege checks on function entry or exit, or to do
+ * other internal bookkeeping.  To make this possible, such modules must be
+ * able not only to support normal function entry and exit, but also to trap
+ * the case where we bail out due to an error; and they must also be able to
+ * prevent inlining.
+ */
+typedef enum FmgrHookEventType
+{
+	FHET_START,
+	FHET_END,
+	FHET_ABORT
+} FmgrHookEventType;
+
+typedef bool (*needs_fmgr_hook_type) (Oid fn_oid);
+
+typedef void (*fmgr_hook_type) (FmgrHookEventType event,
+								FmgrInfo *flinfo, Datum *arg);
+
+extern PGDLLIMPORT needs_fmgr_hook_type needs_fmgr_hook;
+extern PGDLLIMPORT fmgr_hook_type fmgr_hook;
+
+#define FmgrHookIsNeeded(fn_oid)							\
+	(!needs_fmgr_hook ? false : (*needs_fmgr_hook)(fn_oid))
+
+#endif							/* FMGR_H */
diff --git a/contrib/libs/postgresql/src/include/funcapi.h b/contrib/libs/postgresql/src/include/funcapi.h
new file mode 100644
index 0000000000..b047acdc1a
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/funcapi.h
@@ -0,0 +1,348 @@
+/*-------------------------------------------------------------------------
+ *
+ * funcapi.h
+ *	  Definitions for functions which return composite type and/or sets
+ *	  or work on VARIADIC inputs.
+ *
+ * This file must be included by all Postgres modules that either define
+ * or call FUNCAPI-callable functions or macros.
+ *
+ *
+ * Copyright (c) 2002-2020, PostgreSQL Global Development Group
+ *
+ * src/include/funcapi.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef FUNCAPI_H
+#define FUNCAPI_H
+
+#include "access/tupdesc.h"
+#include "executor/executor.h"
+#include "executor/tuptable.h"
+#include "fmgr.h"
+
+/*-------------------------------------------------------------------------
+ *	Support to ease writing Functions returning composite types
+ *-------------------------------------------------------------------------
+ *
+ * This struct holds arrays of individual attribute information
+ * needed to create a tuple from raw C strings. It also requires
+ * a copy of the TupleDesc. The information carried here
+ * is derived from the TupleDesc, but it is stored here to
+ * avoid redundant cpu cycles on each call to an SRF.
+ */
+typedef struct AttInMetadata
+{
+	/* full TupleDesc */
+	TupleDesc	tupdesc;
+
+	/* array of attribute type input function finfo */
+	FmgrInfo   *attinfuncs;
+
+	/* array of attribute type i/o parameter OIDs */
+	Oid		   *attioparams;
+
+	/* array of attribute typmod */
+	int32	   *atttypmods;
+} AttInMetadata;
+
+/*-------------------------------------------------------------------------
+ *		Support struct to ease writing Set Returning Functions (SRFs)
+ *-------------------------------------------------------------------------
+ *
+ * This struct holds function context for Set Returning Functions.
+ * Use fn_extra to hold a pointer to it across calls
+ */
+typedef struct FuncCallContext
+{
+	/*
+	 * Number of times we've been called before
+	 *
+	 * call_cntr is initialized to 0 for you by SRF_FIRSTCALL_INIT(), and
+	 * incremented for you every time SRF_RETURN_NEXT() is called.
+	 */
+	uint64		call_cntr;
+
+	/*
+	 * OPTIONAL maximum number of calls
+	 *
+	 * max_calls is here for convenience only and setting it is optional. If
+	 * not set, you must provide alternative means to know when the function
+	 * is done.
+	 */
+	uint64		max_calls;
+
+	/*
+	 * OPTIONAL pointer to miscellaneous user-provided context information
+	 *
+	 * user_fctx is for use as a pointer to your own struct to retain
+	 * arbitrary context information between calls of your function.
+	 */
+	void	   *user_fctx;
+
+	/*
+	 * OPTIONAL pointer to struct containing attribute type input metadata
+	 *
+	 * attinmeta is for use when returning tuples (i.e. composite data types)
+	 * and is not used when returning base data types. It is only needed if
+	 * you intend to use BuildTupleFromCStrings() to create the return tuple.
+	 */
+	AttInMetadata *attinmeta;
+
+	/*
+	 * memory context used for structures that must live for multiple calls
+	 *
+	 * multi_call_memory_ctx is set by SRF_FIRSTCALL_INIT() for you, and used
+	 * by SRF_RETURN_DONE() for cleanup. It is the most appropriate memory
+	 * context for any memory that is to be reused across multiple calls of
+	 * the SRF.
+	 */
+	MemoryContext multi_call_memory_ctx;
+
+	/*
+	 * OPTIONAL pointer to struct containing tuple description
+	 *
+	 * tuple_desc is for use when returning tuples (i.e. composite data types)
+	 * and is only needed if you are going to build the tuples with
+	 * heap_form_tuple() rather than with BuildTupleFromCStrings(). Note that
+	 * the TupleDesc pointer stored here should usually have been run through
+	 * BlessTupleDesc() first.
+	 */
+	TupleDesc	tuple_desc;
+
+} FuncCallContext;
+
+/*----------
+ *	Support to ease writing functions returning composite types
+ *
+ * External declarations:
+ * get_call_result_type:
+ *		Given a function's call info record, determine the kind of datatype
+ *		it is supposed to return.  If resultTypeId isn't NULL, *resultTypeId
+ *		receives the actual datatype OID (this is mainly useful for scalar
+ *		result types).  If resultTupleDesc isn't NULL, *resultTupleDesc
+ *		receives a pointer to a TupleDesc when the result is of a composite
+ *		type, or NULL when it's a scalar result or the rowtype could not be
+ *		determined.  NB: the tupledesc should be copied if it is to be
+ *		accessed over a long period.
+ * get_expr_result_type:
+ *		Given an expression node, return the same info as for
+ *		get_call_result_type.  Note: the cases in which rowtypes cannot be
+ *		determined are different from the cases for get_call_result_type.
+ * get_func_result_type:
+ *		Given only a function's OID, return the same info as for
+ *		get_call_result_type.  Note: the cases in which rowtypes cannot be
+ *		determined are different from the cases for get_call_result_type.
+ *		Do *not* use this if you can use one of the others.
+ *
+ * See also get_expr_result_tupdesc(), which is a convenient wrapper around
+ * get_expr_result_type() for use when the caller only cares about
+ * determinable-rowtype cases.
+ *----------
+ */
+
+/* Type categories for get_call_result_type and siblings */
+typedef enum TypeFuncClass
+{
+	TYPEFUNC_SCALAR,			/* scalar result type */
+	TYPEFUNC_COMPOSITE,			/* determinable rowtype result */
+	TYPEFUNC_COMPOSITE_DOMAIN,	/* domain over determinable rowtype result */
+	TYPEFUNC_RECORD,			/* indeterminate rowtype result */
+	TYPEFUNC_OTHER				/* bogus type, eg pseudotype */
+} TypeFuncClass;
+
+extern TypeFuncClass get_call_result_type(FunctionCallInfo fcinfo,
+										  Oid *resultTypeId,
+										  TupleDesc *resultTupleDesc);
+extern TypeFuncClass get_expr_result_type(Node *expr,
+										  Oid *resultTypeId,
+										  TupleDesc *resultTupleDesc);
+extern TypeFuncClass get_func_result_type(Oid functionId,
+										  Oid *resultTypeId,
+										  TupleDesc *resultTupleDesc);
+
+extern TupleDesc get_expr_result_tupdesc(Node *expr, bool noError);
+
+extern bool resolve_polymorphic_argtypes(int numargs, Oid *argtypes,
+										 char *argmodes,
+										 Node *call_expr);
+
+extern int	get_func_arg_info(HeapTuple procTup,
+							  Oid **p_argtypes, char ***p_argnames,
+							  char **p_argmodes);
+
+extern int	get_func_input_arg_names(Datum proargnames, Datum proargmodes,
+									 char ***arg_names);
+
+extern int	get_func_trftypes(HeapTuple procTup, Oid **p_trftypes);
+extern char *get_func_result_name(Oid functionId);
+
+extern TupleDesc build_function_result_tupdesc_d(char prokind,
+												 Datum proallargtypes,
+												 Datum proargmodes,
+												 Datum proargnames);
+extern TupleDesc build_function_result_tupdesc_t(HeapTuple procTuple);
+
+
+/*----------
+ *	Support to ease writing functions returning composite types
+ *
+ * External declarations:
+ * TupleDesc BlessTupleDesc(TupleDesc tupdesc) - "Bless" a completed tuple
+ *		descriptor so that it can be used to return properly labeled tuples.
+ *		You need to call this if you are going to use heap_form_tuple directly.
+ *		TupleDescGetAttInMetadata does it for you, however, so no need to call
+ *		it if you call TupleDescGetAttInMetadata.
+ * AttInMetadata *TupleDescGetAttInMetadata(TupleDesc tupdesc) - Build an
+ *		AttInMetadata struct based on the given TupleDesc. AttInMetadata can
+ *		be used in conjunction with C strings to produce a properly formed
+ *		tuple.
+ * HeapTuple BuildTupleFromCStrings(AttInMetadata *attinmeta, char **values) -
+ *		build a HeapTuple given user data in C string form. values is an array
+ *		of C strings, one for each attribute of the return tuple.
+ * Datum HeapTupleHeaderGetDatum(HeapTupleHeader tuple) - convert a
+ *		HeapTupleHeader to a Datum.
+ *
+ * Macro declarations:
+ * HeapTupleGetDatum(HeapTuple tuple) - convert a HeapTuple to a Datum.
+ *
+ * Obsolete routines and macros:
+ * TupleDesc RelationNameGetTupleDesc(const char *relname) - Use to get a
+ *		TupleDesc based on a named relation.
+ * TupleDesc TypeGetTupleDesc(Oid typeoid, List *colaliases) - Use to get a
+ *		TupleDesc based on a type OID.
+ * TupleGetDatum(TupleTableSlot *slot, HeapTuple tuple) - get a Datum
+ *		given a tuple and a slot.
+ *----------
+ */
+
+#define HeapTupleGetDatum(tuple)		HeapTupleHeaderGetDatum((tuple)->t_data)
+/* obsolete version of above */
+#define TupleGetDatum(_slot, _tuple)	HeapTupleGetDatum(_tuple)
+
+extern TupleDesc RelationNameGetTupleDesc(const char *relname);
+extern TupleDesc TypeGetTupleDesc(Oid typeoid, List *colaliases);
+
+/* from execTuples.c */
+extern TupleDesc BlessTupleDesc(TupleDesc tupdesc);
+extern AttInMetadata *TupleDescGetAttInMetadata(TupleDesc tupdesc);
+extern HeapTuple BuildTupleFromCStrings(AttInMetadata *attinmeta, char **values);
+extern Datum HeapTupleHeaderGetDatum(HeapTupleHeader tuple);
+
+
+/*----------
+ *		Support for Set Returning Functions (SRFs)
+ *
+ * The basic API for SRFs using ValuePerCall mode looks something like this:
+ *
+ * Datum
+ * my_Set_Returning_Function(PG_FUNCTION_ARGS)
+ * {
+ *	FuncCallContext    *funcctx;
+ *	Datum				result;
+ *	MemoryContext		oldcontext;
+ *	<user defined declarations>
+ *
+ *	if (SRF_IS_FIRSTCALL())
+ *	{
+ *		funcctx = SRF_FIRSTCALL_INIT();
+ *		// switch context when allocating stuff to be used in later calls
+ *		oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
+ *		<user defined code>
+ *		<if returning composite>
+ *			<build TupleDesc, and perhaps AttInMetadata>
+ *		<endif returning composite>
+ *		<user defined code>
+ *		// return to original context when allocating transient memory
+ *		MemoryContextSwitchTo(oldcontext);
+ *	}
+ *	<user defined code>
+ *	funcctx = SRF_PERCALL_SETUP();
+ *	<user defined code>
+ *
+ *	if (funcctx->call_cntr < funcctx->max_calls)
+ *	{
+ *		<user defined code>
+ *		<obtain result Datum>
+ *		SRF_RETURN_NEXT(funcctx, result);
+ *	}
+ *	else
+ *		SRF_RETURN_DONE(funcctx);
+ * }
+ *
+ * NOTE: there is no guarantee that a SRF using ValuePerCall mode will be
+ * run to completion; for example, a query with LIMIT might stop short of
+ * fetching all the rows.  Therefore, do not expect that you can do resource
+ * cleanup just before SRF_RETURN_DONE().  You need not worry about releasing
+ * memory allocated in multi_call_memory_ctx, but holding file descriptors or
+ * other non-memory resources open across calls is a bug.  SRFs that need
+ * such resources should not use these macros, but instead populate a
+ * tuplestore during a single call, and return that using SFRM_Materialize
+ * mode (see fmgr/README).  Alternatively, set up a callback to release
+ * resources at query shutdown, using RegisterExprContextCallback().
+ *
+ *----------
+ */
+
+/* from funcapi.c */
+extern FuncCallContext *init_MultiFuncCall(PG_FUNCTION_ARGS);
+extern FuncCallContext *per_MultiFuncCall(PG_FUNCTION_ARGS);
+extern void end_MultiFuncCall(PG_FUNCTION_ARGS, FuncCallContext *funcctx);
+
+#define SRF_IS_FIRSTCALL() (fcinfo->flinfo->fn_extra == NULL)
+
+#define SRF_FIRSTCALL_INIT() init_MultiFuncCall(fcinfo)
+
+#define SRF_PERCALL_SETUP() per_MultiFuncCall(fcinfo)
+
+#define SRF_RETURN_NEXT(_funcctx, _result) \
+	do { \
+		ReturnSetInfo	   *rsi; \
+		(_funcctx)->call_cntr++; \
+		rsi = (ReturnSetInfo *) fcinfo->resultinfo; \
+		rsi->isDone = ExprMultipleResult; \
+		PG_RETURN_DATUM(_result); \
+	} while (0)
+
+#define SRF_RETURN_NEXT_NULL(_funcctx) \
+	do { \
+		ReturnSetInfo	   *rsi; \
+		(_funcctx)->call_cntr++; \
+		rsi = (ReturnSetInfo *) fcinfo->resultinfo; \
+		rsi->isDone = ExprMultipleResult; \
+		PG_RETURN_NULL(); \
+	} while (0)
+
+#define  SRF_RETURN_DONE(_funcctx) \
+	do { \
+		ReturnSetInfo	   *rsi; \
+		end_MultiFuncCall(fcinfo, _funcctx); \
+		rsi = (ReturnSetInfo *) fcinfo->resultinfo; \
+		rsi->isDone = ExprEndResult; \
+		PG_RETURN_NULL(); \
+	} while (0)
+
+/*----------
+ *	Support to ease writing of functions dealing with VARIADIC inputs
+ *----------
+ *
+ * This function extracts a set of argument values, types and NULL markers
+ * for a given input function. This returns a set of data:
+ * - **values includes the set of Datum values extracted.
+ * - **types the data type OID for each element.
+ * - **nulls tracks if an element is NULL.
+ *
+ * variadic_start indicates the argument number where the VARIADIC argument
+ * starts.
+ * convert_unknown set to true will enforce the conversion of arguments
+ * with unknown data type to text.
+ *
+ * The return result is the number of elements stored, or -1 in the case of
+ * "VARIADIC NULL".
+ */
+extern int	extract_variadic_args(FunctionCallInfo fcinfo, int variadic_start,
+								  bool convert_unknown, Datum **values,
+								  Oid **types, bool **nulls);
+
+#endif							/* FUNCAPI_H */
diff --git a/contrib/libs/postgresql/src/include/getaddrinfo.h b/contrib/libs/postgresql/src/include/getaddrinfo.h
new file mode 100644
index 0000000000..38fa3b84e7
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/getaddrinfo.h
@@ -0,0 +1,162 @@
+/*-------------------------------------------------------------------------
+ *
+ * getaddrinfo.h
+ *	  Support getaddrinfo() on platforms that don't have it.
+ *
+ * Note: we use our own routines on platforms that don't HAVE_STRUCT_ADDRINFO,
+ * whether or not the library routine getaddrinfo() can be found.  This
+ * policy is needed because on some platforms a manually installed libbind.a
+ * may provide getaddrinfo(), yet the system headers may not provide the
+ * struct definitions needed to call it.  To avoid conflict with the libbind
+ * definition in such cases, we rename our routines to pg_xxx() via macros.
+ *
+ * This code will also work on platforms where struct addrinfo is defined
+ * in the system headers but no getaddrinfo() can be located.
+ *
+ * Copyright (c) 2003-2020, PostgreSQL Global Development Group
+ *
+ * src/include/getaddrinfo.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef GETADDRINFO_H
+#define GETADDRINFO_H
+
+#include <sys/socket.h>
+#include <netdb.h>
+
+
+/* Various macros that ought to be in <netdb.h>, but might not be */
+
+#ifndef EAI_FAIL
+#ifndef WIN32
+#define EAI_BADFLAGS	(-1)
+#define EAI_NONAME		(-2)
+#define EAI_AGAIN		(-3)
+#define EAI_FAIL		(-4)
+#define EAI_FAMILY		(-6)
+#define EAI_SOCKTYPE	(-7)
+#define EAI_SERVICE		(-8)
+#define EAI_MEMORY		(-10)
+#define EAI_SYSTEM		(-11)
+#else							/* WIN32 */
+#ifdef _MSC_VER
+#ifndef WSA_NOT_ENOUGH_MEMORY
+#define WSA_NOT_ENOUGH_MEMORY	(WSAENOBUFS)
+#endif
+#define WSATYPE_NOT_FOUND		(WSABASEERR+109)
+#endif
+#define EAI_AGAIN		WSATRY_AGAIN
+#define EAI_BADFLAGS	WSAEINVAL
+#define EAI_FAIL		WSANO_RECOVERY
+#define EAI_FAMILY		WSAEAFNOSUPPORT
+#define EAI_MEMORY		WSA_NOT_ENOUGH_MEMORY
+#define EAI_NODATA		WSANO_DATA
+#define EAI_NONAME		WSAHOST_NOT_FOUND
+#define EAI_SERVICE		WSATYPE_NOT_FOUND
+#define EAI_SOCKTYPE	WSAESOCKTNOSUPPORT
+#endif							/* !WIN32 */
+#endif							/* !EAI_FAIL */
+
+#ifndef AI_PASSIVE
+#define AI_PASSIVE		0x0001
+#endif
+
+#ifndef AI_NUMERICHOST
+/*
+ * some platforms don't support AI_NUMERICHOST; define as zero if using
+ * the system version of getaddrinfo...
+ */
+#if defined(HAVE_STRUCT_ADDRINFO) && defined(HAVE_GETADDRINFO)
+#define AI_NUMERICHOST	0
+#else
+#define AI_NUMERICHOST	0x0004
+#endif
+#endif
+
+#ifndef NI_NUMERICHOST
+#define NI_NUMERICHOST	1
+#endif
+#ifndef NI_NUMERICSERV
+#define NI_NUMERICSERV	2
+#endif
+#ifndef NI_NAMEREQD
+#define NI_NAMEREQD		4
+#endif
+
+#ifndef NI_MAXHOST
+#define NI_MAXHOST	1025
+#endif
+#ifndef NI_MAXSERV
+#define NI_MAXSERV	32
+#endif
+
+
+#ifndef HAVE_STRUCT_ADDRINFO
+
+#ifndef WIN32
+struct addrinfo
+{
+	int			ai_flags;
+	int			ai_family;
+	int			ai_socktype;
+	int			ai_protocol;
+	size_t		ai_addrlen;
+	struct sockaddr *ai_addr;
+	char	   *ai_canonname;
+	struct addrinfo *ai_next;
+};
+#else
+/*
+ *	The order of the structure elements on Win32 doesn't match the
+ *	order specified in the standard, but we have to match it for
+ *	IPv6 to work.
+ */
+struct addrinfo
+{
+	int			ai_flags;
+	int			ai_family;
+	int			ai_socktype;
+	int			ai_protocol;
+	size_t		ai_addrlen;
+	char	   *ai_canonname;
+	struct sockaddr *ai_addr;
+	struct addrinfo *ai_next;
+};
+#endif
+#endif							/* HAVE_STRUCT_ADDRINFO */
+
+
+#ifndef HAVE_GETADDRINFO
+
+/* Rename private copies per comments above */
+#ifdef getaddrinfo
+#undef getaddrinfo
+#endif
+#define getaddrinfo pg_getaddrinfo
+
+#ifdef freeaddrinfo
+#undef freeaddrinfo
+#endif
+#define freeaddrinfo pg_freeaddrinfo
+
+#ifdef gai_strerror
+#undef gai_strerror
+#endif
+#define gai_strerror pg_gai_strerror
+
+#ifdef getnameinfo
+#undef getnameinfo
+#endif
+#define getnameinfo pg_getnameinfo
+
+extern int	getaddrinfo(const char *node, const char *service,
+						const struct addrinfo *hints, struct addrinfo **res);
+extern void freeaddrinfo(struct addrinfo *res);
+extern const char *gai_strerror(int errcode);
+extern int	getnameinfo(const struct sockaddr *sa, int salen,
+						char *node, int nodelen,
+						char *service, int servicelen, int flags);
+#endif							/* HAVE_GETADDRINFO */
+
+#endif							/* GETADDRINFO_H */
diff --git a/contrib/libs/postgresql/src/include/miscadmin.h b/contrib/libs/postgresql/src/include/miscadmin.h
new file mode 100644
index 0000000000..6b2b4343a0
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/miscadmin.h
@@ -0,0 +1,489 @@
+/*-------------------------------------------------------------------------
+ *
+ * miscadmin.h
+ *	  This file contains general postgres administration and initialization
+ *	  stuff that used to be spread out between the following files:
+ *		globals.h						global variables
+ *		pdir.h							directory path crud
+ *		pinit.h							postgres initialization
+ *		pmod.h							processing modes
+ *	  Over time, this has also become the preferred place for widely known
+ *	  resource-limitation stuff, such as work_mem and check_stack_depth().
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/miscadmin.h
+ *
+ * NOTES
+ *	  some of the information in this file should be moved to other files.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef MISCADMIN_H
+#define MISCADMIN_H
+
+#include <signal.h>
+
+#include "datatype/timestamp.h" /* for TimestampTz */
+#include "pgtime.h"				/* for pg_time_t */
+
+
+#define InvalidPid				(-1)
+
+
+/*****************************************************************************
+ *	  System interrupt and critical section handling
+ *
+ * There are two types of interrupts that a running backend needs to accept
+ * without messing up its state: QueryCancel (SIGINT) and ProcDie (SIGTERM).
+ * In both cases, we need to be able to clean up the current transaction
+ * gracefully, so we can't respond to the interrupt instantaneously ---
+ * there's no guarantee that internal data structures would be self-consistent
+ * if the code is interrupted at an arbitrary instant.  Instead, the signal
+ * handlers set flags that are checked periodically during execution.
+ *
+ * The CHECK_FOR_INTERRUPTS() macro is called at strategically located spots
+ * where it is normally safe to accept a cancel or die interrupt.  In some
+ * cases, we invoke CHECK_FOR_INTERRUPTS() inside low-level subroutines that
+ * might sometimes be called in contexts that do *not* want to allow a cancel
+ * or die interrupt.  The HOLD_INTERRUPTS() and RESUME_INTERRUPTS() macros
+ * allow code to ensure that no cancel or die interrupt will be accepted,
+ * even if CHECK_FOR_INTERRUPTS() gets called in a subroutine.  The interrupt
+ * will be held off until CHECK_FOR_INTERRUPTS() is done outside any
+ * HOLD_INTERRUPTS() ... RESUME_INTERRUPTS() section.
+ *
+ * There is also a mechanism to prevent query cancel interrupts, while still
+ * allowing die interrupts: HOLD_CANCEL_INTERRUPTS() and
+ * RESUME_CANCEL_INTERRUPTS().
+ *
+ * Note that ProcessInterrupts() has also acquired a number of tasks that
+ * do not necessarily cause a query-cancel-or-die response.  Hence, it's
+ * possible that it will just clear InterruptPending and return.
+ *
+ * INTERRUPTS_PENDING_CONDITION() can be checked to see whether an
+ * interrupt needs to be serviced, without trying to do so immediately.
+ * Some callers are also interested in INTERRUPTS_CAN_BE_PROCESSED(),
+ * which tells whether ProcessInterrupts is sure to clear the interrupt.
+ *
+ * Special mechanisms are used to let an interrupt be accepted when we are
+ * waiting for a lock or when we are waiting for command input (but, of
+ * course, only if the interrupt holdoff counter is zero).  See the
+ * related code for details.
+ *
+ * A lost connection is handled similarly, although the loss of connection
+ * does not raise a signal, but is detected when we fail to write to the
+ * socket. If there was a signal for a broken connection, we could make use of
+ * it by setting ClientConnectionLost in the signal handler.
+ *
+ * A related, but conceptually distinct, mechanism is the "critical section"
+ * mechanism.  A critical section not only holds off cancel/die interrupts,
+ * but causes any ereport(ERROR) or ereport(FATAL) to become ereport(PANIC)
+ * --- that is, a system-wide reset is forced.  Needless to say, only really
+ * *critical* code should be marked as a critical section!	Currently, this
+ * mechanism is only used for XLOG-related code.
+ *
+ *****************************************************************************/
+
+/* in globals.c */
+/* these are marked volatile because they are set by signal handlers: */
+extern PGDLLIMPORT volatile sig_atomic_t InterruptPending;
+extern PGDLLIMPORT volatile sig_atomic_t QueryCancelPending;
+extern PGDLLIMPORT volatile sig_atomic_t ProcDiePending;
+extern PGDLLIMPORT volatile sig_atomic_t IdleInTransactionSessionTimeoutPending;
+extern PGDLLIMPORT volatile sig_atomic_t ProcSignalBarrierPending;
+
+extern PGDLLIMPORT volatile sig_atomic_t ClientConnectionLost;
+
+/* these are marked volatile because they are examined by signal handlers: */
+extern PGDLLIMPORT volatile uint32 InterruptHoldoffCount;
+extern PGDLLIMPORT volatile uint32 QueryCancelHoldoffCount;
+extern PGDLLIMPORT volatile uint32 CritSectionCount;
+
+/* in tcop/postgres.c */
+extern void ProcessInterrupts(void);
+
+/* Test whether an interrupt is pending */
+#ifndef WIN32
+#define INTERRUPTS_PENDING_CONDITION() \
+	(unlikely(InterruptPending))
+#else
+#define INTERRUPTS_PENDING_CONDITION() \
+	(unlikely(UNBLOCKED_SIGNAL_QUEUE()) ? pgwin32_dispatch_queued_signals() : 0, \
+	 unlikely(InterruptPending))
+#endif
+
+/* Service interrupt, if one is pending and it's safe to service it now */
+#define CHECK_FOR_INTERRUPTS() \
+do { \
+	if (INTERRUPTS_PENDING_CONDITION()) \
+		ProcessInterrupts(); \
+} while(0)
+
+/* Is ProcessInterrupts() guaranteed to clear InterruptPending? */
+#define INTERRUPTS_CAN_BE_PROCESSED() \
+	(InterruptHoldoffCount == 0 && CritSectionCount == 0 && \
+	 QueryCancelHoldoffCount == 0)
+
+#define HOLD_INTERRUPTS()  (InterruptHoldoffCount++)
+
+#define RESUME_INTERRUPTS() \
+do { \
+	Assert(InterruptHoldoffCount > 0); \
+	InterruptHoldoffCount--; \
+} while(0)
+
+#define HOLD_CANCEL_INTERRUPTS()  (QueryCancelHoldoffCount++)
+
+#define RESUME_CANCEL_INTERRUPTS() \
+do { \
+	Assert(QueryCancelHoldoffCount > 0); \
+	QueryCancelHoldoffCount--; \
+} while(0)
+
+#define START_CRIT_SECTION()  (CritSectionCount++)
+
+#define END_CRIT_SECTION() \
+do { \
+	Assert(CritSectionCount > 0); \
+	CritSectionCount--; \
+} while(0)
+
+
+/*****************************************************************************
+ *	  globals.h --															 *
+ *****************************************************************************/
+
+/*
+ * from utils/init/globals.c
+ */
+extern PGDLLIMPORT pid_t PostmasterPid;
+extern PGDLLIMPORT bool IsPostmasterEnvironment;
+extern PGDLLIMPORT bool IsUnderPostmaster;
+extern PGDLLIMPORT bool IsBackgroundWorker;
+extern PGDLLIMPORT bool IsBinaryUpgrade;
+
+extern PGDLLIMPORT bool ExitOnAnyError;
+
+extern PGDLLIMPORT char *DataDir;
+extern PGDLLIMPORT int data_directory_mode;
+
+extern PGDLLIMPORT int NBuffers;
+extern PGDLLIMPORT int MaxBackends;
+extern PGDLLIMPORT int MaxConnections;
+extern PGDLLIMPORT int max_worker_processes;
+extern PGDLLIMPORT int max_parallel_workers;
+
+extern PGDLLIMPORT int MyProcPid;
+extern PGDLLIMPORT pg_time_t MyStartTime;
+extern PGDLLIMPORT TimestampTz MyStartTimestamp;
+extern PGDLLIMPORT struct Port *MyProcPort;
+extern PGDLLIMPORT struct Latch *MyLatch;
+extern int32 MyCancelKey;
+extern int	MyPMChildSlot;
+
+extern char OutputFileName[];
+extern PGDLLIMPORT char my_exec_path[];
+extern char pkglib_path[];
+
+#ifdef EXEC_BACKEND
+extern char postgres_exec_path[];
+#endif
+
+/*
+ * done in storage/backendid.h for now.
+ *
+ * extern BackendId    MyBackendId;
+ */
+extern PGDLLIMPORT Oid MyDatabaseId;
+
+extern PGDLLIMPORT Oid MyDatabaseTableSpace;
+
+/*
+ * Date/Time Configuration
+ *
+ * DateStyle defines the output formatting choice for date/time types:
+ *	USE_POSTGRES_DATES specifies traditional Postgres format
+ *	USE_ISO_DATES specifies ISO-compliant format
+ *	USE_SQL_DATES specifies Oracle/Ingres-compliant format
+ *	USE_GERMAN_DATES specifies German-style dd.mm/yyyy
+ *
+ * DateOrder defines the field order to be assumed when reading an
+ * ambiguous date (anything not in YYYY-MM-DD format, with a four-digit
+ * year field first, is taken to be ambiguous):
+ *	DATEORDER_YMD specifies field order yy-mm-dd
+ *	DATEORDER_DMY specifies field order dd-mm-yy ("European" convention)
+ *	DATEORDER_MDY specifies field order mm-dd-yy ("US" convention)
+ *
+ * In the Postgres and SQL DateStyles, DateOrder also selects output field
+ * order: day comes before month in DMY style, else month comes before day.
+ *
+ * The user-visible "DateStyle" run-time parameter subsumes both of these.
+ */
+
+/* valid DateStyle values */
+#define USE_POSTGRES_DATES		0
+#define USE_ISO_DATES			1
+#define USE_SQL_DATES			2
+#define USE_GERMAN_DATES		3
+#define USE_XSD_DATES			4
+
+/* valid DateOrder values */
+#define DATEORDER_YMD			0
+#define DATEORDER_DMY			1
+#define DATEORDER_MDY			2
+
+extern PGDLLIMPORT int DateStyle;
+extern PGDLLIMPORT int DateOrder;
+
+/*
+ * IntervalStyles
+ *	 INTSTYLE_POSTGRES			   Like Postgres < 8.4 when DateStyle = 'iso'
+ *	 INTSTYLE_POSTGRES_VERBOSE	   Like Postgres < 8.4 when DateStyle != 'iso'
+ *	 INTSTYLE_SQL_STANDARD		   SQL standard interval literals
+ *	 INTSTYLE_ISO_8601			   ISO-8601-basic formatted intervals
+ */
+#define INTSTYLE_POSTGRES			0
+#define INTSTYLE_POSTGRES_VERBOSE	1
+#define INTSTYLE_SQL_STANDARD		2
+#define INTSTYLE_ISO_8601			3
+
+extern PGDLLIMPORT int IntervalStyle;
+
+#define MAXTZLEN		10		/* max TZ name len, not counting tr. null */
+
+extern bool enableFsync;
+extern PGDLLIMPORT bool allowSystemTableMods;
+extern PGDLLIMPORT int work_mem;
+extern PGDLLIMPORT double hash_mem_multiplier;
+extern PGDLLIMPORT int maintenance_work_mem;
+extern PGDLLIMPORT int max_parallel_maintenance_workers;
+
+extern int	VacuumCostPageHit;
+extern int	VacuumCostPageMiss;
+extern int	VacuumCostPageDirty;
+extern int	VacuumCostLimit;
+extern double VacuumCostDelay;
+
+extern int64 VacuumPageHit;
+extern int64 VacuumPageMiss;
+extern int64 VacuumPageDirty;
+
+extern int	VacuumCostBalance;
+extern bool VacuumCostActive;
+
+extern double vacuum_cleanup_index_scale_factor;
+
+
+/* in tcop/postgres.c */
+
+#if defined(__ia64__) || defined(__ia64)
+typedef struct
+{
+	char	   *stack_base_ptr;
+	char	   *register_stack_base_ptr;
+} pg_stack_base_t;
+#else
+typedef char *pg_stack_base_t;
+#endif
+
+extern pg_stack_base_t set_stack_base(void);
+extern void restore_stack_base(pg_stack_base_t base);
+extern void check_stack_depth(void);
+extern bool stack_is_too_deep(void);
+
+/* in tcop/utility.c */
+extern void PreventCommandIfReadOnly(const char *cmdname);
+extern void PreventCommandIfParallelMode(const char *cmdname);
+extern void PreventCommandDuringRecovery(const char *cmdname);
+
+/* in utils/misc/guc.c */
+extern int	trace_recovery_messages;
+extern int	trace_recovery(int trace_level);
+
+/*****************************************************************************
+ *	  pdir.h --																 *
+ *			POSTGRES directory path definitions.                             *
+ *****************************************************************************/
+
+/* flags to be OR'd to form sec_context */
+#define SECURITY_LOCAL_USERID_CHANGE	0x0001
+#define SECURITY_RESTRICTED_OPERATION	0x0002
+#define SECURITY_NOFORCE_RLS			0x0004
+
+extern char *DatabasePath;
+
+/* now in utils/init/miscinit.c */
+extern void InitPostmasterChild(void);
+extern void InitStandaloneProcess(const char *argv0);
+extern void SwitchToSharedLatch(void);
+extern void SwitchBackToLocalLatch(void);
+
+typedef enum BackendType
+{
+	B_INVALID = 0,
+	B_AUTOVAC_LAUNCHER,
+	B_AUTOVAC_WORKER,
+	B_BACKEND,
+	B_BG_WORKER,
+	B_BG_WRITER,
+	B_CHECKPOINTER,
+	B_STARTUP,
+	B_WAL_RECEIVER,
+	B_WAL_SENDER,
+	B_WAL_WRITER,
+	B_ARCHIVER,
+	B_STATS_COLLECTOR,
+	B_LOGGER,
+} BackendType;
+
+extern BackendType MyBackendType;
+
+extern const char *GetBackendTypeDesc(BackendType backendType);
+
+extern void SetDatabasePath(const char *path);
+extern void checkDataDir(void);
+extern void SetDataDir(const char *dir);
+extern void ChangeToDataDir(void);
+
+extern char *GetUserNameFromId(Oid roleid, bool noerr);
+extern Oid	GetUserId(void);
+extern Oid	GetOuterUserId(void);
+extern Oid	GetSessionUserId(void);
+extern Oid	GetAuthenticatedUserId(void);
+extern void GetUserIdAndSecContext(Oid *userid, int *sec_context);
+extern void SetUserIdAndSecContext(Oid userid, int sec_context);
+extern bool InLocalUserIdChange(void);
+extern bool InSecurityRestrictedOperation(void);
+extern bool InNoForceRLSOperation(void);
+extern void GetUserIdAndContext(Oid *userid, bool *sec_def_context);
+extern void SetUserIdAndContext(Oid userid, bool sec_def_context);
+extern void InitializeSessionUserId(const char *rolename, Oid useroid);
+extern void InitializeSessionUserIdStandalone(void);
+extern void SetSessionAuthorization(Oid userid, bool is_superuser);
+extern Oid	GetCurrentRoleId(void);
+extern void SetCurrentRoleId(Oid roleid, bool is_superuser);
+
+/* in utils/misc/superuser.c */
+extern bool superuser(void);	/* current user is superuser */
+extern bool superuser_arg(Oid roleid);	/* given user is superuser */
+
+
+/*****************************************************************************
+ *	  pmod.h --																 *
+ *			POSTGRES processing mode definitions.                            *
+ *****************************************************************************/
+
+/*
+ * Description:
+ *		There are three processing modes in POSTGRES.  They are
+ * BootstrapProcessing or "bootstrap," InitProcessing or
+ * "initialization," and NormalProcessing or "normal."
+ *
+ * The first two processing modes are used during special times. When the
+ * system state indicates bootstrap processing, transactions are all given
+ * transaction id "one" and are consequently guaranteed to commit. This mode
+ * is used during the initial generation of template databases.
+ *
+ * Initialization mode: used while starting a backend, until all normal
+ * initialization is complete.  Some code behaves differently when executed
+ * in this mode to enable system bootstrapping.
+ *
+ * If a POSTGRES backend process is in normal mode, then all code may be
+ * executed normally.
+ */
+
+typedef enum ProcessingMode
+{
+	BootstrapProcessing,		/* bootstrap creation of template database */
+	InitProcessing,				/* initializing system */
+	NormalProcessing			/* normal processing */
+} ProcessingMode;
+
+extern ProcessingMode Mode;
+
+#define IsBootstrapProcessingMode() (Mode == BootstrapProcessing)
+#define IsInitProcessingMode()		(Mode == InitProcessing)
+#define IsNormalProcessingMode()	(Mode == NormalProcessing)
+
+#define GetProcessingMode() Mode
+
+#define SetProcessingMode(mode) \
+	do { \
+		AssertArg((mode) == BootstrapProcessing || \
+				  (mode) == InitProcessing || \
+				  (mode) == NormalProcessing); \
+		Mode = (mode); \
+	} while(0)
+
+
+/*
+ * Auxiliary-process type identifiers.  These used to be in bootstrap.h
+ * but it seems saner to have them here, with the ProcessingMode stuff.
+ * The MyAuxProcType global is defined and set in bootstrap.c.
+ */
+
+typedef enum
+{
+	NotAnAuxProcess = -1,
+	CheckerProcess = 0,
+	BootstrapProcess,
+	StartupProcess,
+	BgWriterProcess,
+	CheckpointerProcess,
+	WalWriterProcess,
+	WalReceiverProcess,
+
+	NUM_AUXPROCTYPES			/* Must be last! */
+} AuxProcType;
+
+extern AuxProcType MyAuxProcType;
+
+#define AmBootstrapProcess()		(MyAuxProcType == BootstrapProcess)
+#define AmStartupProcess()			(MyAuxProcType == StartupProcess)
+#define AmBackgroundWriterProcess() (MyAuxProcType == BgWriterProcess)
+#define AmCheckpointerProcess()		(MyAuxProcType == CheckpointerProcess)
+#define AmWalWriterProcess()		(MyAuxProcType == WalWriterProcess)
+#define AmWalReceiverProcess()		(MyAuxProcType == WalReceiverProcess)
+
+
+/*****************************************************************************
+ *	  pinit.h --															 *
+ *			POSTGRES initialization and cleanup definitions.                 *
+ *****************************************************************************/
+
+/* in utils/init/postinit.c */
+extern void pg_split_opts(char **argv, int *argcp, const char *optstr);
+extern void InitializeMaxBackends(void);
+extern void InitPostgres(const char *in_dbname, Oid dboid, const char *username,
+						 Oid useroid, char *out_dbname, bool override_allow_connections);
+extern void BaseInit(void);
+
+/* in utils/init/miscinit.c */
+extern bool IgnoreSystemIndexes;
+extern PGDLLIMPORT bool process_shared_preload_libraries_in_progress;
+extern char *session_preload_libraries_string;
+extern char *shared_preload_libraries_string;
+extern char *local_preload_libraries_string;
+
+extern void CreateDataDirLockFile(bool amPostmaster);
+extern void CreateSocketLockFile(const char *socketfile, bool amPostmaster,
+								 const char *socketDir);
+extern void TouchSocketLockFiles(void);
+extern void AddToDataDirLockFile(int target_line, const char *str);
+extern bool RecheckDataDirLockFile(void);
+extern void ValidatePgVersion(const char *path);
+extern void process_shared_preload_libraries(void);
+extern void process_session_preload_libraries(void);
+extern void pg_bindtextdomain(const char *domain);
+extern bool has_rolreplication(Oid roleid);
+
+/* in access/transam/xlog.c */
+extern bool BackupInProgress(void);
+extern void CancelBackup(void);
+
+/* in executor/nodeHash.c */
+extern size_t get_hash_memory_limit(void);
+extern int	get_hash_mem(void);
+
+#endif							/* MISCADMIN_H */
diff --git a/contrib/libs/postgresql/src/include/pg_config-linux.h b/contrib/libs/postgresql/src/include/pg_config-linux.h
new file mode 100644
index 0000000000..30c8422e97
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/pg_config-linux.h
@@ -0,0 +1,981 @@
+/* src/include/pg_config.h.  Generated from pg_config.h.in by configure.  */
+/* src/include/pg_config.h.in.  Generated from configure.in by autoheader.  */
+
+/* Define to the type of arg 1 of 'accept' */
+#define ACCEPT_TYPE_ARG1 int
+
+/* Define to the type of arg 2 of 'accept' */
+#define ACCEPT_TYPE_ARG2 struct sockaddr *
+
+/* Define to the type of arg 3 of 'accept' */
+#define ACCEPT_TYPE_ARG3 socklen_t
+
+/* Define to the return type of 'accept' */
+#define ACCEPT_TYPE_RETURN int
+
+/* Define if building universal (internal helper macro) */
+/* #undef AC_APPLE_UNIVERSAL_BUILD */
+
+/* The normal alignment of `double', in bytes. */
+#define ALIGNOF_DOUBLE 8
+
+/* The normal alignment of `int', in bytes. */
+#define ALIGNOF_INT 4
+
+/* The normal alignment of `long', in bytes. */
+#define ALIGNOF_LONG 8
+
+/* The normal alignment of `long long int', in bytes. */
+/* #undef ALIGNOF_LONG_LONG_INT */
+
+/* The normal alignment of `PG_INT128_TYPE', in bytes. */
+#define ALIGNOF_PG_INT128_TYPE 16
+
+/* The normal alignment of `short', in bytes. */
+#define ALIGNOF_SHORT 2
+
+/* Size of a disk block --- this also limits the size of a tuple. You can set
+   it bigger if you need bigger tuples (although TOAST should reduce the need
+   to have large tuples, since fields can be spread across multiple tuples).
+   BLCKSZ must be a power of 2. The maximum possible value of BLCKSZ is
+   currently 2^15 (32768). This is determined by the 15-bit widths of the
+   lp_off and lp_len fields in ItemIdData (see include/storage/itemid.h).
+   Changing BLCKSZ requires an initdb. */
+#define BLCKSZ 8192
+
+/* Saved arguments from configure */
+#define CONFIGURE_ARGS " '--prefix=/var/empty/postgresql-13.5' '--with-openssl' '--with-libxml' '--sysconfdir=/etc' '--libdir=$(lib)/lib' '--with-system-tzdata=/var/empty/tzdata-2021c/share/zoneinfo' '--enable-debug' '--with-systemd' '--with-ossp-uuid' '--with-icu' '--with-gssapi' '--without-gssapi' '--without-systemd' 'CC=cc' 'CXX=g++' 'PKG_CONFIG=pkg-config' 'PKG_CONFIG_PATH=/var/empty/zlib-1.2.11-dev/lib/pkgconfig:/var/empty/ncurses-6.2-dev/lib/pkgconfig:/var/empty/openssl-1.1.1l-dev/lib/pkgconfig:/var/empty/libxml2-2.9.12-dev/lib/pkgconfig:/var/empty/icu4c-70.1-dev/lib/pkgconfig:/var/empty/systemd-249.5-dev/lib/pkgconfig:/var/empty/systemd-249.5-dev/share/pkgconfig:/var/empty/libkrb5-1.18-dev/lib/pkgconfig:/var/empty/libossp-uuid-1.6.2/lib/pkgconfig'"
+
+/* Define to the default TCP port number on which the server listens and to
+   which clients will try to connect. This can be overridden at run-time, but
+   it's convenient if your clients have the right default compiled in.
+   (--with-pgport=PORTNUM) */
+#define DEF_PGPORT 5432
+
+/* Define to the default TCP port number as a string constant. */
+#define DEF_PGPORT_STR "5432"
+
+/* Define to build with GSSAPI support. (--with-gssapi) */
+/* #undef ENABLE_GSS */
+
+/* Define to 1 if you want National Language Support. (--enable-nls) */
+/* #undef ENABLE_NLS */
+
+/* Define to 1 to build client libraries as thread-safe code.
+   (--enable-thread-safety) */
+#define ENABLE_THREAD_SAFETY 1
+
+/* Define to 1 if gettimeofday() takes only 1 argument. */
+/* #undef GETTIMEOFDAY_1ARG */
+
+#ifdef GETTIMEOFDAY_1ARG
+# define gettimeofday(a,b) gettimeofday(a)
+#endif
+
+/* Define to 1 if you have the `append_history' function. */
+#define HAVE_APPEND_HISTORY 1
+
+/* Define to 1 if you have the `ASN1_STRING_get0_data' function. */
+#define HAVE_ASN1_STRING_GET0_DATA 1
+
+/* Define to 1 if you want to use atomics if available. */
+#define HAVE_ATOMICS 1
+
+/* Define to 1 if you have the <atomic.h> header file. */
+/* #undef HAVE_ATOMIC_H */
+
+/* Define to 1 if you have the `backtrace_symbols' function. */
+#define HAVE_BACKTRACE_SYMBOLS 1
+
+/* Define to 1 if you have the `BIO_get_data' function. */
+#define HAVE_BIO_GET_DATA 1
+
+/* Define to 1 if you have the `BIO_meth_new' function. */
+#define HAVE_BIO_METH_NEW 1
+
+/* Define to 1 if you have the `clock_gettime' function. */
+#define HAVE_CLOCK_GETTIME 1
+
+/* Define to 1 if your compiler handles computed gotos. */
+#define HAVE_COMPUTED_GOTO 1
+
+/* Define to 1 if you have the `copyfile' function. */
+/* #undef HAVE_COPYFILE */
+
+/* Define to 1 if you have the <copyfile.h> header file. */
+/* #undef HAVE_COPYFILE_H */
+
+/* Define to 1 if you have the <crtdefs.h> header file. */
+/* #undef HAVE_CRTDEFS_H */
+
+/* Define to 1 if you have the `CRYPTO_lock' function. */
+/* #undef HAVE_CRYPTO_LOCK */
+
+/* Define to 1 if you have the declaration of `fdatasync', and to 0 if you
+   don't. */
+#define HAVE_DECL_FDATASYNC 1
+
+/* Define to 1 if you have the declaration of `F_FULLFSYNC', and to 0 if you
+   don't. */
+#define HAVE_DECL_F_FULLFSYNC 0
+
+/* Define to 1 if you have the declaration of
+   `LLVMCreateGDBRegistrationListener', and to 0 if you don't. */
+/* #undef HAVE_DECL_LLVMCREATEGDBREGISTRATIONLISTENER */
+
+/* Define to 1 if you have the declaration of
+   `LLVMCreatePerfJITEventListener', and to 0 if you don't. */
+/* #undef HAVE_DECL_LLVMCREATEPERFJITEVENTLISTENER */
+
+/* Define to 1 if you have the declaration of `LLVMGetHostCPUFeatures', and to
+   0 if you don't. */
+/* #undef HAVE_DECL_LLVMGETHOSTCPUFEATURES */
+
+/* Define to 1 if you have the declaration of `LLVMGetHostCPUName', and to 0
+   if you don't. */
+/* #undef HAVE_DECL_LLVMGETHOSTCPUNAME */
+
+/* Define to 1 if you have the declaration of `LLVMOrcGetSymbolAddressIn', and
+   to 0 if you don't. */
+/* #undef HAVE_DECL_LLVMORCGETSYMBOLADDRESSIN */
+
+/* Define to 1 if you have the declaration of `posix_fadvise', and to 0 if you
+   don't. */
+#define HAVE_DECL_POSIX_FADVISE 1
+
+/* Define to 1 if you have the declaration of `RTLD_GLOBAL', and to 0 if you
+   don't. */
+#define HAVE_DECL_RTLD_GLOBAL 1
+
+/* Define to 1 if you have the declaration of `RTLD_NOW', and to 0 if you
+   don't. */
+#define HAVE_DECL_RTLD_NOW 1
+
+/* Define to 1 if you have the declaration of `strlcat', and to 0 if you
+   don't. */
+#define HAVE_DECL_STRLCAT 0
+
+/* Define to 1 if you have the declaration of `strlcpy', and to 0 if you
+   don't. */
+#define HAVE_DECL_STRLCPY 0
+
+/* Define to 1 if you have the declaration of `strnlen', and to 0 if you
+   don't. */
+#define HAVE_DECL_STRNLEN 1
+
+/* Define to 1 if you have the declaration of `strtoll', and to 0 if you
+   don't. */
+#define HAVE_DECL_STRTOLL 1
+
+/* Define to 1 if you have the declaration of `strtoull', and to 0 if you
+   don't. */
+#define HAVE_DECL_STRTOULL 1
+
+/* Define to 1 if you have the `dlopen' function. */
+#define HAVE_DLOPEN 1
+
+/* Define to 1 if you have the <editline/history.h> header file. */
+/* #undef HAVE_EDITLINE_HISTORY_H */
+
+/* Define to 1 if you have the <editline/readline.h> header file. */
+/* #undef HAVE_EDITLINE_READLINE_H */
+
+/* Define to 1 if you have the <execinfo.h> header file. */
+#define HAVE_EXECINFO_H 1
+
+/* Define to 1 if you have the `explicit_bzero' function. */
+#define HAVE_EXPLICIT_BZERO 1
+
+/* Define to 1 if you have the `fdatasync' function. */
+#define HAVE_FDATASYNC 1
+
+/* Define to 1 if you have the `fls' function. */
+/* #undef HAVE_FLS */
+
+/* Define to 1 if fseeko (and presumably ftello) exists and is declared. */
+#define HAVE_FSEEKO 1
+
+/* Define to 1 if your compiler understands __func__. */
+#define HAVE_FUNCNAME__FUNC 1
+
+/* Define to 1 if your compiler understands __FUNCTION__. */
+/* #undef HAVE_FUNCNAME__FUNCTION */
+
+/* Define to 1 if you have __atomic_compare_exchange_n(int *, int *, int). */
+#define HAVE_GCC__ATOMIC_INT32_CAS 1
+
+/* Define to 1 if you have __atomic_compare_exchange_n(int64 *, int64 *,
+   int64). */
+#define HAVE_GCC__ATOMIC_INT64_CAS 1
+
+/* Define to 1 if you have __sync_lock_test_and_set(char *) and friends. */
+#define HAVE_GCC__SYNC_CHAR_TAS 1
+
+/* Define to 1 if you have __sync_val_compare_and_swap(int *, int, int). */
+#define HAVE_GCC__SYNC_INT32_CAS 1
+
+/* Define to 1 if you have __sync_lock_test_and_set(int *) and friends. */
+#define HAVE_GCC__SYNC_INT32_TAS 1
+
+/* Define to 1 if you have __sync_val_compare_and_swap(int64 *, int64, int64).
+   */
+#define HAVE_GCC__SYNC_INT64_CAS 1
+
+/* Define to 1 if you have the `getaddrinfo' function. */
+#define HAVE_GETADDRINFO 1
+
+/* Define to 1 if you have the `gethostbyname_r' function. */
+#define HAVE_GETHOSTBYNAME_R 1
+
+/* Define to 1 if you have the `getifaddrs' function. */
+#define HAVE_GETIFADDRS 1
+
+/* Define to 1 if you have the `getopt' function. */
+#define HAVE_GETOPT 1
+
+/* Define to 1 if you have the <getopt.h> header file. */
+#define HAVE_GETOPT_H 1
+
+/* Define to 1 if you have the `getopt_long' function. */
+#define HAVE_GETOPT_LONG 1
+
+/* Define to 1 if you have the `getpeereid' function. */
+/* #undef HAVE_GETPEEREID */
+
+/* Define to 1 if you have the `getpeerucred' function. */
+/* #undef HAVE_GETPEERUCRED */
+
+/* Define to 1 if you have the `getpwuid_r' function. */
+#define HAVE_GETPWUID_R 1
+
+/* Define to 1 if you have the `getrlimit' function. */
+#define HAVE_GETRLIMIT 1
+
+/* Define to 1 if you have the `getrusage' function. */
+#define HAVE_GETRUSAGE 1
+
+/* Define to 1 if you have the `gettimeofday' function. */
+/* #undef HAVE_GETTIMEOFDAY */
+
+/* Define to 1 if you have the <gssapi/gssapi.h> header file. */
+/* #undef HAVE_GSSAPI_GSSAPI_H */
+
+/* Define to 1 if you have the <gssapi.h> header file. */
+/* #undef HAVE_GSSAPI_H */
+
+/* Define to 1 if you have the <history.h> header file. */
+/* #undef HAVE_HISTORY_H */
+
+/* Define to 1 if you have the `history_truncate_file' function. */
+#define HAVE_HISTORY_TRUNCATE_FILE 1
+
+/* Define to 1 if you have the <ifaddrs.h> header file. */
+#define HAVE_IFADDRS_H 1
+
+/* Define to 1 if you have the `inet_aton' function. */
+#define HAVE_INET_ATON 1
+
+/* Define to 1 if the system has the type `int64'. */
+/* #undef HAVE_INT64 */
+
+/* Define to 1 if the system has the type `int8'. */
+/* #undef HAVE_INT8 */
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#define HAVE_INTTYPES_H 1
+
+/* Define to 1 if you have the global variable 'int opterr'. */
+#define HAVE_INT_OPTERR 1
+
+/* Define to 1 if you have the global variable 'int optreset'. */
+/* #undef HAVE_INT_OPTRESET */
+
+/* Define to 1 if you have the global variable 'int timezone'. */
+#define HAVE_INT_TIMEZONE 1
+
+/* Define to 1 if you have support for IPv6. */
+#define HAVE_IPV6 1
+
+/* Define to 1 if __builtin_constant_p(x) implies "i"(x) acceptance. */
+/* #undef HAVE_I_CONSTRAINT__BUILTIN_CONSTANT_P */
+
+/* Define to 1 if you have the `kqueue' function. */
+/* #undef HAVE_KQUEUE */
+
+/* Define to 1 if you have the <langinfo.h> header file. */
+#define HAVE_LANGINFO_H 1
+
+/* Define to 1 if you have the <ldap.h> header file. */
+/* #undef HAVE_LDAP_H */
+
+/* Define to 1 if you have the `ldap_initialize' function. */
+/* #undef HAVE_LDAP_INITIALIZE */
+
+/* Define to 1 if you have the `crypto' library (-lcrypto). */
+#define HAVE_LIBCRYPTO 1
+
+/* Define to 1 if you have the `ldap' library (-lldap). */
+/* #undef HAVE_LIBLDAP */
+
+/* Define to 1 if you have the `m' library (-lm). */
+#define HAVE_LIBM 1
+
+/* Define to 1 if you have the `pam' library (-lpam). */
+/* #undef HAVE_LIBPAM */
+
+/* Define if you have a function readline library */
+#define HAVE_LIBREADLINE 1
+
+/* Define to 1 if you have the `selinux' library (-lselinux). */
+/* #undef HAVE_LIBSELINUX */
+
+/* Define to 1 if you have the `ssl' library (-lssl). */
+#define HAVE_LIBSSL 1
+
+/* Define to 1 if you have the `wldap32' library (-lwldap32). */
+/* #undef HAVE_LIBWLDAP32 */
+
+/* Define to 1 if you have the `xml2' library (-lxml2). */
+#define HAVE_LIBXML2 1
+
+/* Define to 1 if you have the `xslt' library (-lxslt). */
+/* #undef HAVE_LIBXSLT */
+
+/* Define to 1 if you have the `z' library (-lz). */
+#define HAVE_LIBZ 1
+
+/* Define to 1 if you have the `link' function. */
+#define HAVE_LINK 1
+
+/* Define to 1 if the system has the type `locale_t'. */
+#define HAVE_LOCALE_T 1
+
+/* Define to 1 if `long int' works and is 64 bits. */
+#define HAVE_LONG_INT_64 1
+
+/* Define to 1 if `long long int' works and is 64 bits. */
+/* #undef HAVE_LONG_LONG_INT_64 */
+
+/* Define to 1 if you have the <mbarrier.h> header file. */
+/* #undef HAVE_MBARRIER_H */
+
+/* Define to 1 if you have the `mbstowcs_l' function. */
+/* #undef HAVE_MBSTOWCS_L */
+
+/* Define to 1 if you have the <memory.h> header file. */
+#define HAVE_MEMORY_H 1
+
+/* Define to 1 if you have the `memset_s' function. */
+/* #undef HAVE_MEMSET_S */
+
+/* Define to 1 if the system has the type `MINIDUMP_TYPE'. */
+/* #undef HAVE_MINIDUMP_TYPE */
+
+/* Define to 1 if you have the `mkdtemp' function. */
+#define HAVE_MKDTEMP 1
+
+/* Define to 1 if you have the <netinet/tcp.h> header file. */
+#define HAVE_NETINET_TCP_H 1
+
+/* Define to 1 if you have the <net/if.h> header file. */
+#define HAVE_NET_IF_H 1
+
+/* Define to 1 if you have the `OPENSSL_init_ssl' function. */
+#define HAVE_OPENSSL_INIT_SSL 1
+
+/* Define to 1 if you have the <ossp/uuid.h> header file. */
+/* #undef HAVE_OSSP_UUID_H */
+
+/* Define to 1 if you have the <pam/pam_appl.h> header file. */
+/* #undef HAVE_PAM_PAM_APPL_H */
+
+/* Define to 1 if you have the `poll' function. */
+#define HAVE_POLL 1
+
+/* Define to 1 if you have the <poll.h> header file. */
+#define HAVE_POLL_H 1
+
+/* Define to 1 if you have the `posix_fadvise' function. */
+#define HAVE_POSIX_FADVISE 1
+
+/* Define to 1 if you have the `posix_fallocate' function. */
+#define HAVE_POSIX_FALLOCATE 1
+
+/* Define to 1 if the assembler supports PPC's LWARX mutex hint bit. */
+/* #undef HAVE_PPC_LWARX_MUTEX_HINT */
+
+/* Define to 1 if you have the `ppoll' function. */
+#define HAVE_PPOLL 1
+
+/* Define to 1 if you have the `pread' function. */
+#define HAVE_PREAD 1
+
+/* Define to 1 if you have the `pstat' function. */
+/* #undef HAVE_PSTAT */
+
+/* Define to 1 if the PS_STRINGS thing exists. */
+/* #undef HAVE_PS_STRINGS */
+
+/* Define if you have POSIX threads libraries and header files. */
+#define HAVE_PTHREAD 1
+
+/* Define to 1 if you have the `pthread_is_threaded_np' function. */
+/* #undef HAVE_PTHREAD_IS_THREADED_NP */
+
+/* Have PTHREAD_PRIO_INHERIT. */
+#define HAVE_PTHREAD_PRIO_INHERIT 1
+
+/* Define to 1 if you have the `pwrite' function. */
+#define HAVE_PWRITE 1
+
+/* Define to 1 if you have the `random' function. */
+#define HAVE_RANDOM 1
+
+/* Define to 1 if you have the <readline.h> header file. */
+/* #undef HAVE_READLINE_H */
+
+/* Define to 1 if you have the <readline/history.h> header file. */
+#define HAVE_READLINE_HISTORY_H 1
+
+/* Define to 1 if you have the <readline/readline.h> header file. */
+#define HAVE_READLINE_READLINE_H 1
+
+/* Define to 1 if you have the `readlink' function. */
+#define HAVE_READLINK 1
+
+/* Define to 1 if you have the global variable
+   'rl_completion_append_character'. */
+#define HAVE_RL_COMPLETION_APPEND_CHARACTER 1
+
+/* Define to 1 if you have the `rl_completion_matches' function. */
+#define HAVE_RL_COMPLETION_MATCHES 1
+
+/* Define to 1 if you have the global variable 'rl_completion_suppress_quote'.
+   */
+#define HAVE_RL_COMPLETION_SUPPRESS_QUOTE 1
+
+/* Define to 1 if you have the `rl_filename_completion_function' function. */
+#define HAVE_RL_FILENAME_COMPLETION_FUNCTION 1
+
+/* Define to 1 if you have the global variable 'rl_filename_quote_characters'.
+   */
+#define HAVE_RL_FILENAME_QUOTE_CHARACTERS 1
+
+/* Define to 1 if you have the global variable 'rl_filename_quoting_function'.
+   */
+#define HAVE_RL_FILENAME_QUOTING_FUNCTION 1
+
+/* Define to 1 if you have the `rl_reset_screen_size' function. */
+#define HAVE_RL_RESET_SCREEN_SIZE 1
+
+/* Define to 1 if you have the <security/pam_appl.h> header file. */
+/* #undef HAVE_SECURITY_PAM_APPL_H */
+
+/* Define to 1 if you have the `setenv' function. */
+#define HAVE_SETENV 1
+
+/* Define to 1 if you have the `setproctitle' function. */
+/* #undef HAVE_SETPROCTITLE */
+
+/* Define to 1 if you have the `setproctitle_fast' function. */
+/* #undef HAVE_SETPROCTITLE_FAST */
+
+/* Define to 1 if you have the `setsid' function. */
+#define HAVE_SETSID 1
+
+/* Define to 1 if you have the `shm_open' function. */
+#define HAVE_SHM_OPEN 1
+
+/* Define to 1 if you have spinlocks. */
+#define HAVE_SPINLOCKS 1
+
+/* Define to 1 if you have the `srandom' function. */
+#define HAVE_SRANDOM 1
+
+/* Define to 1 if stdbool.h conforms to C99. */
+#define HAVE_STDBOOL_H 1
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#define HAVE_STDINT_H 1
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#define HAVE_STDLIB_H 1
+
+/* Define to 1 if you have the `strchrnul' function. */
+#define HAVE_STRCHRNUL 1
+
+/* Define to 1 if you have the `strerror_r' function. */
+#define HAVE_STRERROR_R 1
+
+/* Define to 1 if you have the <strings.h> header file. */
+#define HAVE_STRINGS_H 1
+
+/* Define to 1 if you have the <string.h> header file. */
+#define HAVE_STRING_H 1
+
+/* Define to 1 if you have the `strlcat' function. */
+/* #undef HAVE_STRLCAT */
+
+/* Define to 1 if you have the `strlcpy' function. */
+/* #undef HAVE_STRLCPY */
+
+/* Define to 1 if you have the `strnlen' function. */
+#define HAVE_STRNLEN 1
+
+/* Define to 1 if you have the `strsignal' function. */
+#define HAVE_STRSIGNAL 1
+
+/* Define to 1 if you have the `strtof' function. */
+#define HAVE_STRTOF 1
+
+/* Define to 1 if you have the `strtoll' function. */
+#define HAVE_STRTOLL 1
+
+/* Define to 1 if you have the `strtoq' function. */
+/* #undef HAVE_STRTOQ */
+
+/* Define to 1 if you have the `strtoull' function. */
+#define HAVE_STRTOULL 1
+
+/* Define to 1 if you have the `strtouq' function. */
+/* #undef HAVE_STRTOUQ */
+
+/* Define to 1 if the system has the type `struct addrinfo'. */
+#define HAVE_STRUCT_ADDRINFO 1
+
+/* Define to 1 if the system has the type `struct cmsgcred'. */
+/* #undef HAVE_STRUCT_CMSGCRED */
+
+/* Define to 1 if the system has the type `struct option'. */
+#define HAVE_STRUCT_OPTION 1
+
+/* Define to 1 if `sa_len' is a member of `struct sockaddr'. */
+/* #undef HAVE_STRUCT_SOCKADDR_SA_LEN */
+
+/* Define to 1 if the system has the type `struct sockaddr_storage'. */
+#define HAVE_STRUCT_SOCKADDR_STORAGE 1
+
+/* Define to 1 if `ss_family' is a member of `struct sockaddr_storage'. */
+#define HAVE_STRUCT_SOCKADDR_STORAGE_SS_FAMILY 1
+
+/* Define to 1 if `ss_len' is a member of `struct sockaddr_storage'. */
+/* #undef HAVE_STRUCT_SOCKADDR_STORAGE_SS_LEN */
+
+/* Define to 1 if `__ss_family' is a member of `struct sockaddr_storage'. */
+/* #undef HAVE_STRUCT_SOCKADDR_STORAGE___SS_FAMILY */
+
+/* Define to 1 if `__ss_len' is a member of `struct sockaddr_storage'. */
+/* #undef HAVE_STRUCT_SOCKADDR_STORAGE___SS_LEN */
+
+/* Define to 1 if the system has the type `struct sockaddr_un'. */
+#define HAVE_STRUCT_SOCKADDR_UN 1
+
+/* Define to 1 if `tm_zone' is a member of `struct tm'. */
+#define HAVE_STRUCT_TM_TM_ZONE 1
+
+/* Define to 1 if you have the `symlink' function. */
+#define HAVE_SYMLINK 1
+
+/* Define to 1 if you have the `sync_file_range' function. */
+#define HAVE_SYNC_FILE_RANGE 1
+
+/* Define to 1 if you have the syslog interface. */
+#define HAVE_SYSLOG 1
+
+/* Define to 1 if you have the <sys/epoll.h> header file. */
+#define HAVE_SYS_EPOLL_H 1
+
+/* Define to 1 if you have the <sys/event.h> header file. */
+/* #undef HAVE_SYS_EVENT_H */
+
+/* Define to 1 if you have the <sys/ipc.h> header file. */
+#define HAVE_SYS_IPC_H 1
+
+/* Define to 1 if you have the <sys/prctl.h> header file. */
+#define HAVE_SYS_PRCTL_H 1
+
+/* Define to 1 if you have the <sys/procctl.h> header file. */
+/* #undef HAVE_SYS_PROCCTL_H */
+
+/* Define to 1 if you have the <sys/pstat.h> header file. */
+/* #undef HAVE_SYS_PSTAT_H */
+
+/* Define to 1 if you have the <sys/resource.h> header file. */
+#define HAVE_SYS_RESOURCE_H 1
+
+/* Define to 1 if you have the <sys/select.h> header file. */
+#define HAVE_SYS_SELECT_H 1
+
+/* Define to 1 if you have the <sys/sem.h> header file. */
+#define HAVE_SYS_SEM_H 1
+
+/* Define to 1 if you have the <sys/shm.h> header file. */
+#define HAVE_SYS_SHM_H 1
+
+/* Define to 1 if you have the <sys/sockio.h> header file. */
+/* #undef HAVE_SYS_SOCKIO_H */
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#define HAVE_SYS_STAT_H 1
+
+/* Define to 1 if you have the <sys/tas.h> header file. */
+/* #undef HAVE_SYS_TAS_H */
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#define HAVE_SYS_TYPES_H 1
+
+/* Define to 1 if you have the <sys/ucred.h> header file. */
+/* #undef HAVE_SYS_UCRED_H */
+
+/* Define to 1 if you have the <sys/un.h> header file. */
+#define HAVE_SYS_UN_H 1
+
+/* Define to 1 if you have the <termios.h> header file. */
+#define HAVE_TERMIOS_H 1
+
+/* Define to 1 if your compiler understands `typeof' or something similar. */
+#define HAVE_TYPEOF 1
+
+/* Define to 1 if you have the <ucred.h> header file. */
+/* #undef HAVE_UCRED_H */
+
+/* Define to 1 if the system has the type `uint64'. */
+/* #undef HAVE_UINT64 */
+
+/* Define to 1 if the system has the type `uint8'. */
+/* #undef HAVE_UINT8 */
+
+/* Define to 1 if the system has the type `union semun'. */
+/* #undef HAVE_UNION_SEMUN */
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#define HAVE_UNISTD_H 1
+
+/* Define to 1 if you have the `unsetenv' function. */
+#define HAVE_UNSETENV 1
+
+/* Define to 1 if you have the `uselocale' function. */
+#define HAVE_USELOCALE 1
+
+/* Define to 1 if you have BSD UUID support. */
+/* #undef HAVE_UUID_BSD */
+
+/* Define to 1 if you have E2FS UUID support. */
+/* #undef HAVE_UUID_E2FS */
+
+/* Define to 1 if you have the <uuid.h> header file. */
+#define HAVE_UUID_H 1
+
+/* Define to 1 if you have OSSP UUID support. */
+#define HAVE_UUID_OSSP 1
+
+/* Define to 1 if you have the <uuid/uuid.h> header file. */
+/* #undef HAVE_UUID_UUID_H */
+
+/* Define to 1 if you have the `wcstombs_l' function. */
+/* #undef HAVE_WCSTOMBS_L */
+
+/* Define to 1 if you have the <wctype.h> header file. */
+#define HAVE_WCTYPE_H 1
+
+/* Define to 1 if you have the <winldap.h> header file. */
+/* #undef HAVE_WINLDAP_H */
+
+/* Define to 1 if you have the `X509_get_signature_nid' function. */
+#define HAVE_X509_GET_SIGNATURE_NID 1
+
+/* Define to 1 if the assembler supports X86_64's POPCNTQ instruction. */
+#define HAVE_X86_64_POPCNTQ 1
+
+/* Define to 1 if the system has the type `_Bool'. */
+#define HAVE__BOOL 1
+
+/* Define to 1 if your compiler understands __builtin_bswap16. */
+#define HAVE__BUILTIN_BSWAP16 1
+
+/* Define to 1 if your compiler understands __builtin_bswap32. */
+#define HAVE__BUILTIN_BSWAP32 1
+
+/* Define to 1 if your compiler understands __builtin_bswap64. */
+#define HAVE__BUILTIN_BSWAP64 1
+
+/* Define to 1 if your compiler understands __builtin_clz. */
+#define HAVE__BUILTIN_CLZ 1
+
+/* Define to 1 if your compiler understands __builtin_constant_p. */
+#define HAVE__BUILTIN_CONSTANT_P 1
+
+/* Define to 1 if your compiler understands __builtin_ctz. */
+#define HAVE__BUILTIN_CTZ 1
+
+/* Define to 1 if your compiler understands __builtin_$op_overflow. */
+#define HAVE__BUILTIN_OP_OVERFLOW 1
+
+/* Define to 1 if your compiler understands __builtin_popcount. */
+#define HAVE__BUILTIN_POPCOUNT 1
+
+/* Define to 1 if your compiler understands __builtin_types_compatible_p. */
+#define HAVE__BUILTIN_TYPES_COMPATIBLE_P 1
+
+/* Define to 1 if your compiler understands __builtin_unreachable. */
+#define HAVE__BUILTIN_UNREACHABLE 1
+
+/* Define to 1 if you have the `_configthreadlocale' function. */
+/* #undef HAVE__CONFIGTHREADLOCALE */
+
+/* Define to 1 if you have __cpuid. */
+/* #undef HAVE__CPUID */
+
+/* Define to 1 if you have __get_cpuid. */
+#define HAVE__GET_CPUID 1
+
+/* Define to 1 if your compiler understands _Static_assert. */
+#define HAVE__STATIC_ASSERT 1
+
+/* Define to 1 if you have the `__strtoll' function. */
+/* #undef HAVE___STRTOLL */
+
+/* Define to 1 if you have the `__strtoull' function. */
+/* #undef HAVE___STRTOULL */
+
+/* Define to the appropriate printf length modifier for 64-bit ints. */
+#define INT64_MODIFIER "l"
+
+/* Define to 1 if `locale_t' requires <xlocale.h>. */
+/* #undef LOCALE_T_IN_XLOCALE */
+
+/* Define as the maximum alignment requirement of any C data type. */
+#define MAXIMUM_ALIGNOF 8
+
+/* Define bytes to use libc memset(). */
+#define MEMSET_LOOP_LIMIT 1024
+
+/* Define to the address where bug reports for this package should be sent. */
+#define PACKAGE_BUGREPORT "pgsql-bugs@lists.postgresql.org"
+
+/* Define to the full name of this package. */
+#define PACKAGE_NAME "PostgreSQL"
+
+/* Define to the full name and version of this package. */
+#define PACKAGE_STRING "PostgreSQL 13.5"
+
+/* Define to the one symbol short name of this package. */
+#define PACKAGE_TARNAME "postgresql"
+
+/* Define to the home page for this package. */
+#define PACKAGE_URL "https://www.postgresql.org/"
+
+/* Define to the version of this package. */
+#define PACKAGE_VERSION "13.5"
+
+/* Define to the name of a signed 128-bit integer type. */
+#define PG_INT128_TYPE __int128
+
+/* Define to the name of a signed 64-bit integer type. */
+#define PG_INT64_TYPE long int
+
+/* Define to the name of the default PostgreSQL service principal in Kerberos
+   (GSSAPI). (--with-krb-srvnam=NAME) */
+#define PG_KRB_SRVNAM "postgres"
+
+/* PostgreSQL major version as a string */
+#define PG_MAJORVERSION "13"
+
+/* PostgreSQL major version number */
+#define PG_MAJORVERSION_NUM 13
+
+/* PostgreSQL minor version number */
+#define PG_MINORVERSION_NUM 5
+
+/* Define to best printf format archetype, usually gnu_printf if available. */
+#define PG_PRINTF_ATTRIBUTE gnu_printf
+
+/* Define to 1 to use <stdbool.h> to define type bool. */
+#define PG_USE_STDBOOL 1
+
+/* PostgreSQL version as a string */
+#define PG_VERSION "13.5"
+
+/* PostgreSQL version as a number */
+#define PG_VERSION_NUM 130005
+
+/* A string containing the version number, platform, and C compiler */
+#define PG_VERSION_STR "PostgreSQL 13.5 on x86_64-pc-linux-gnu, compiled by gcc (GCC) 10.3.0, 64-bit"
+
+/* Define to 1 to allow profiling output to be saved separately for each
+   process. */
+/* #undef PROFILE_PID_DIR */
+
+/* Define to necessary symbol if this constant uses a non-standard name on
+   your system. */
+/* #undef PTHREAD_CREATE_JOINABLE */
+
+/* RELSEG_SIZE is the maximum number of blocks allowed in one disk file. Thus,
+   the maximum size of a single file is RELSEG_SIZE * BLCKSZ; relations bigger
+   than that are divided into multiple files. RELSEG_SIZE * BLCKSZ must be
+   less than your OS' limit on file size. This is often 2 GB or 4GB in a
+   32-bit operating system, unless you have large file support enabled. By
+   default, we make the limit 1 GB to avoid any possible integer-overflow
+   problems within the OS. A limit smaller than necessary only means we divide
+   a large relation into more chunks than necessary, so it seems best to err
+   in the direction of a small limit. A power-of-2 value is recommended to
+   save a few cycles in md.c, but is not absolutely required. Changing
+   RELSEG_SIZE requires an initdb. */
+#define RELSEG_SIZE 131072
+
+/* The size of `bool', as computed by sizeof. */
+#define SIZEOF_BOOL 1
+
+/* The size of `long', as computed by sizeof. */
+#define SIZEOF_LONG 8
+
+/* The size of `off_t', as computed by sizeof. */
+#define SIZEOF_OFF_T 8
+
+/* The size of `size_t', as computed by sizeof. */
+#define SIZEOF_SIZE_T 8
+
+/* The size of `void *', as computed by sizeof. */
+#define SIZEOF_VOID_P 8
+
+/* Define to 1 if you have the ANSI C header files. */
+#define STDC_HEADERS 1
+
+/* Define to 1 if strerror_r() returns int. */
+/* #undef STRERROR_R_INT */
+
+/* Define to 1 to use ARMv8 CRC Extension. */
+/* #undef USE_ARMV8_CRC32C */
+
+/* Define to 1 to use ARMv8 CRC Extension with a runtime check. */
+/* #undef USE_ARMV8_CRC32C_WITH_RUNTIME_CHECK */
+
+/* Define to 1 to build with assertion checks. (--enable-cassert) */
+/* #undef USE_ASSERT_CHECKING */
+
+/* Define to 1 to build with Bonjour support. (--with-bonjour) */
+/* #undef USE_BONJOUR */
+
+/* Define to 1 to build with BSD Authentication support. (--with-bsd-auth) */
+/* #undef USE_BSD_AUTH */
+
+/* Define to use /dev/urandom for random number generation */
+/* #undef USE_DEV_URANDOM */
+
+/* Define to build with ICU support. (--with-icu) */
+#define USE_ICU 1
+
+/* Define to 1 to build with LDAP support. (--with-ldap) */
+/* #undef USE_LDAP */
+
+/* Define to 1 to build with XML support. (--with-libxml) */
+#define USE_LIBXML 1
+
+/* Define to 1 to use XSLT support when building contrib/xml2.
+   (--with-libxslt) */
+/* #undef USE_LIBXSLT */
+
+/* Define to 1 to build with LLVM based JIT support. (--with-llvm) */
+/* #undef USE_LLVM */
+
+/* Define to select named POSIX semaphores. */
+/* #undef USE_NAMED_POSIX_SEMAPHORES */
+
+/* Define to build with OpenSSL support. (--with-openssl) */
+#define USE_OPENSSL 1
+
+/* Define to use OpenSSL for random number generation */
+#define USE_OPENSSL_RANDOM 1
+
+/* Define to 1 to build with PAM support. (--with-pam) */
+/* #undef USE_PAM */
+
+/* Define to 1 to use software CRC-32C implementation (slicing-by-8). */
+/* #undef USE_SLICING_BY_8_CRC32C */
+
+/* Define to 1 use Intel SSE 4.2 CRC instructions. */
+/* #undef USE_SSE42_CRC32C */
+
+/* Define to 1 to use Intel SSE 4.2 CRC instructions with a runtime check. */
+#define USE_SSE42_CRC32C_WITH_RUNTIME_CHECK 1
+
+/* Define to build with systemd support. (--with-systemd) */
+/* #undef USE_SYSTEMD */
+
+/* Define to select SysV-style semaphores. */
+/* #undef USE_SYSV_SEMAPHORES */
+
+/* Define to select SysV-style shared memory. */
+#define USE_SYSV_SHARED_MEMORY 1
+
+/* Define to select unnamed POSIX semaphores. */
+#define USE_UNNAMED_POSIX_SEMAPHORES 1
+
+/* Define to use native Windows API for random number generation */
+/* #undef USE_WIN32_RANDOM */
+
+/* Define to select Win32-style semaphores. */
+/* #undef USE_WIN32_SEMAPHORES */
+
+/* Define to select Win32-style shared memory. */
+/* #undef USE_WIN32_SHARED_MEMORY */
+
+/* Define to 1 if `wcstombs_l' requires <xlocale.h>. */
+/* #undef WCSTOMBS_L_IN_XLOCALE */
+
+/* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
+   significant byte first (like Motorola and SPARC, unlike Intel). */
+#if defined AC_APPLE_UNIVERSAL_BUILD
+# if defined __BIG_ENDIAN__
+#  define WORDS_BIGENDIAN 1
+# endif
+#else
+# ifndef WORDS_BIGENDIAN
+/* #  undef WORDS_BIGENDIAN */
+# endif
+#endif
+
+/* Size of a WAL file block. This need have no particular relation to BLCKSZ.
+   XLOG_BLCKSZ must be a power of 2, and if your system supports O_DIRECT I/O,
+   XLOG_BLCKSZ must be a multiple of the alignment requirement for direct-I/O
+   buffers, else direct I/O may fail. Changing XLOG_BLCKSZ requires an initdb.
+   */
+#define XLOG_BLCKSZ 8192
+
+
+
+/* Number of bits in a file offset, on hosts where this is settable. */
+/* #undef _FILE_OFFSET_BITS */
+
+/* Define to 1 to make fseeko visible on some hosts (e.g. glibc 2.2). */
+/* #undef _LARGEFILE_SOURCE */
+
+/* Define for large files, on AIX-style hosts. */
+/* #undef _LARGE_FILES */
+
+/* Define to `__inline__' or `__inline' if that's what the C compiler
+   calls it, or to nothing if 'inline' is not supported under any name.  */
+#ifndef __cplusplus
+/* #undef inline */
+#endif
+
+/* Define to keyword to use for C99 restrict support, or to nothing if not
+   supported */
+#define pg_restrict __restrict
+
+/* Define to the equivalent of the C99 'restrict' keyword, or to
+   nothing if this is not supported.  Do not define if restrict is
+   supported directly.  */
+#define restrict __restrict
+/* Work around a bug in Sun C++: it does not support _Restrict or
+   __restrict__, even though the corresponding Sun C compiler ends up with
+   "#define restrict _Restrict" or "#define restrict __restrict__" in the
+   previous line.  Perhaps some future version of Sun C++ will work with
+   restrict; if so, hopefully it defines __RESTRICT like Sun C does.  */
+#if defined __SUNPRO_CC && !defined __RESTRICT
+# define _Restrict
+# define __restrict__
+#endif
+
+/* Define to how the compiler spells `typeof'. */
+/* #undef typeof */
diff --git a/contrib/libs/postgresql/src/include/pg_config-osx.h b/contrib/libs/postgresql/src/include/pg_config-osx.h
new file mode 100644
index 0000000000..7ffb92c467
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/pg_config-osx.h
@@ -0,0 +1,31 @@
+#pragma once
+
+#include "pg_config-linux.h"
+
+/* Define to 1 if you have the declaration of `strlcat', and to 0 if you
+   don't. */
+#undef HAVE_DECL_STRLCAT
+#define HAVE_DECL_STRLCAT 1
+
+/* Define to 1 if you have the declaration of `strlcpy', and to 0 if you
+   don't. */
+#undef HAVE_DECL_STRLCPY
+#define HAVE_DECL_STRLCPY 1
+
+/* Define to 1 if the system has the type `locale_t'. */
+#undef HAVE_LOCALE_T
+
+/* Define to 1 if you have the <sys/prctl.h> header file. */
+#undef HAVE_SYS_PRCTL_H
+
+/* Define to 1 if you have the `sync_file_range' function. */
+#undef HAVE_SYNC_FILE_RANGE
+
+/* Define to 1 if you have the <sys/ucred.h> header file. */
+#define HAVE_SYS_UCRED_H 1
+
+/* Define to 1 if you have the <sys/epoll.h> header file. */
+#undef HAVE_SYS_EPOLL_H
+
+/* Define to 1 if you have the `strchrnul' function. */
+#undef HAVE_STRCHRNUL
\ No newline at end of file
diff --git a/contrib/libs/postgresql/src/include/pg_config-win.h b/contrib/libs/postgresql/src/include/pg_config-win.h
new file mode 100644
index 0000000000..ed526bebfd
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/pg_config-win.h
@@ -0,0 +1,173 @@
+#pragma once
+
+#include "pg_config-linux.h"
+
+/* Define to 1 if you have the <strings.h> header file. */
+#undef HAVE_STRINGS_H
+
+/* Define to 1 if you have the <sys/un.h> header file. */
+#undef HAVE_SYS_UN_H
+
+/* Define to 1 if you have the <termios.h> header file. */
+#undef HAVE_TERMIOS_H
+
+/* Define to 1 if you have the `inet_aton' function. */
+#undef HAVE_INET_ATON
+
+/* Define to 1 if you have the <sys/select.h> header file. */
+#undef HAVE_SYS_SELECT_H
+
+/* Define to 1 if you have the <sys/prctl.h> header file. */
+#undef HAVE_SYS_PRCTL_H
+
+/* Define to 1 if you have the <netinet/tcp.h> header file. */
+#undef HAVE_NETINET_TCP_H
+
+/* Define to 1 if you have the <sys/resource.h> header file. */
+#undef HAVE_SYS_RESOURCE_H
+
+/* Define to 1 if you have the `dlopen' function. */
+#undef HAVE_DLOPEN
+
+/* Define to 1 if you have the syslog interface. */
+#undef HAVE_SYSLOG
+
+/* Define to 1 if you have the <getopt.h> header file. */
+#undef HAVE_GETOPT_H
+
+/* Define to 1 if you have the <execinfo.h> header file. */
+#undef HAVE_EXECINFO_H
+
+/* Define to 1 if you have the `sync_file_range' function. */
+#undef HAVE_SYNC_FILE_RANGE
+
+/* Define to 1 if you have the <sys/epoll.h> header file. */
+#undef HAVE_SYS_EPOLL_H
+
+/* Define to 1 if you have the <poll.h> header file. */
+#undef HAVE_POLL_H
+
+/* Define to 1 if you have the `poll' function. */
+#undef HAVE_POLL
+
+/* Define to 1 if you have the <sys/ipc.h> header file. */
+#undef HAVE_SYS_IPC_H
+
+/* Define to 1 if you have the <langinfo.h> header file. */
+#undef HAVE_LANGINFO_H
+
+/* Define to 1 if you have the <sys/shm.h> header file. */
+#undef HAVE_SYS_SHM_H
+
+/* Define to 1 if the assembler supports X86_64's POPCNTQ instruction. */
+#undef HAVE_X86_64_POPCNTQ
+
+/* Define to 1 if you have the declaration of `RTLD_GLOBAL', and to 0 if you
+   don't. */
+#undef HAVE_DECL_RTLD_GLOBAL
+
+/* Define to 1 if you have the declaration of `RTLD_NOW', and to 0 if you
+   don't. */
+#undef HAVE_DECL_RTLD_NOW
+
+/* Define to 1 if you have the `getrlimit' function. */
+#undef HAVE_GETRLIMIT
+
+/* Define to 1 if you have the `getrusage' function. */
+#undef HAVE_GETRUSAGE
+
+/* Define to 1 if your compiler understands _Static_assert. */
+#undef HAVE__STATIC_ASSERT
+
+/* Define to 1 if you have the global variable 'int opterr'. */
+#undef HAVE_INT_OPTERR
+
+/* Define to 1 if you have the `strchrnul' function. */
+#undef HAVE_STRCHRNUL
+
+/* Define to 1 if you have the `backtrace_symbols' function. */
+#undef HAVE_BACKTRACE_SYMBOLS
+
+/* Define to 1 if you have the `setsid' function. */
+#undef HAVE_SETSID
+
+/* Define to 1 if you have the `fdatasync' function. */
+#undef HAVE_FDATASYNC
+
+/* Define to 1 if the system has the type `locale_t'. */
+#undef HAVE_LOCALE_T
+
+/* Define to 1 if you have the `strerror_r' function. */
+#undef HAVE_STRERROR_R
+
+/* Define to 1 if you have the `getaddrinfo' function. */
+#undef HAVE_GETADDRINFO
+
+/* Define to use OpenSSL for random number generation */
+#undef USE_OPENSSL_RANDOM
+
+/* Define to use native Windows API for random number generation */
+#define USE_WIN32_RANDOM 1
+
+/* Define to 1 if the system has the type `_Bool'. */
+#undef HAVE__BOOL
+
+/* Define to 1 if your compiler understands __builtin_bswap16. */
+#undef HAVE__BUILTIN_BSWAP16
+
+/* Define to 1 if your compiler understands __builtin_bswap32. */
+#undef HAVE__BUILTIN_BSWAP32
+
+/* Define to 1 if your compiler understands __builtin_bswap64. */
+#undef HAVE__BUILTIN_BSWAP64
+
+/* Define to 1 if your compiler understands __builtin_clz. */
+#undef HAVE__BUILTIN_CLZ
+
+/* Define to 1 if your compiler understands __builtin_constant_p. */
+#undef HAVE__BUILTIN_CONSTANT_P
+
+/* Define to 1 if your compiler understands __builtin_ctz. */
+#undef HAVE__BUILTIN_CTZ
+
+/* Define to 1 if your compiler understands __builtin_$op_overflow. */
+#undef HAVE__BUILTIN_OP_OVERFLOW
+
+/* Define to 1 if your compiler understands __builtin_popcount. */
+#undef HAVE__BUILTIN_POPCOUNT
+
+/* Define to 1 if your compiler understands __builtin_types_compatible_p. */
+#undef HAVE__BUILTIN_TYPES_COMPATIBLE_P
+
+/* Define to 1 if your compiler understands __builtin_unreachable. */
+#undef HAVE__BUILTIN_UNREACHABLE
+
+/* Define to 1 if you have the `_configthreadlocale' function. */
+#define HAVE__CONFIGTHREADLOCALE 1
+
+/* Define to 1 if you have __cpuid. */
+#define HAVE__CPUID 1
+
+/* Define to 1 if you have __get_cpuid. */
+#undef HAVE__GET_CPUID
+
+/* Define to 1 if your compiler understands `typeof' or something similar. */
+#undef HAVE_TYPEOF
+
+/* Define to 1 if your compiler handles computed gotos. */
+#undef HAVE_COMPUTED_GOTO
+
+/* Define to 1 if you have the `readlink' function. */
+#undef HAVE_READLINK
+
+
+
+/* PostgreSQL's CFLAG for windows. */
+#define WIN32_STACK_RLIMIT 4194304
+
+/* NO GOOD WAY WAS FOUND TO PROVIDE DEFINITIONS FOR random AND srandom. */
+/* rand is PostgreSQL's implementation of random from stdlib.h for windows. */
+#define random rand
+
+/* srand is PostgreSQL's implementation of srandom from stdlib.h for windows. */
+#define srandom srand
diff --git a/contrib/libs/postgresql/src/include/pg_config.h b/contrib/libs/postgresql/src/include/pg_config.h
new file mode 100644
index 0000000000..d18cad5285
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/pg_config.h
@@ -0,0 +1,9 @@
+#pragma once
+
+#if defined(__APPLE__)
+#   include "pg_config-osx.h"
+#elif defined(_MSC_VER)
+#   include "pg_config-win.h"
+#else
+#   include "pg_config-linux.h"
+#endif
diff --git a/contrib/libs/postgresql/src/include/pg_config_ext.h b/contrib/libs/postgresql/src/include/pg_config_ext.h
new file mode 100644
index 0000000000..b4c07dd857
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/pg_config_ext.h
@@ -0,0 +1,8 @@
+/* src/include/pg_config_ext.h.  Generated from pg_config_ext.h.in by configure.  */
+/*
+ * src/include/pg_config_ext.h.in.  This is generated manually, not by
+ * autoheader, since we want to limit which symbols get defined here.
+ */
+
+/* Define to the name of a signed 64-bit integer type. */
+#define PG_INT64_TYPE long int
diff --git a/contrib/libs/postgresql/src/include/pg_config_manual.h b/contrib/libs/postgresql/src/include/pg_config_manual.h
new file mode 100644
index 0000000000..91818326a4
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/pg_config_manual.h
@@ -0,0 +1,357 @@
+/*------------------------------------------------------------------------
+ * PostgreSQL manual configuration settings
+ *
+ * This file contains various configuration symbols and limits.  In
+ * all cases, changing them is only useful in very rare situations or
+ * for developers.  If you edit any of these, be sure to do a *full*
+ * rebuild (and an initdb if noted).
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/pg_config_manual.h
+ *------------------------------------------------------------------------
+ */
+
+/*
+ * This is the default value for wal_segment_size to be used when initdb is run
+ * without the --wal-segsize option.  It must be a valid segment size.
+ */
+#define DEFAULT_XLOG_SEG_SIZE	(16*1024*1024)
+
+/*
+ * Maximum length for identifiers (e.g. table names, column names,
+ * function names).  Names actually are limited to one less byte than this,
+ * because the length must include a trailing zero byte.
+ *
+ * Changing this requires an initdb.
+ */
+#define NAMEDATALEN 64
+
+/*
+ * Maximum number of arguments to a function.
+ *
+ * The minimum value is 8 (GIN indexes use 8-argument support functions).
+ * The maximum possible value is around 600 (limited by index tuple size in
+ * pg_proc's index; BLCKSZ larger than 8K would allow more).  Values larger
+ * than needed will waste memory and processing time, but do not directly
+ * cost disk space.
+ *
+ * Changing this does not require an initdb, but it does require a full
+ * backend recompile (including any user-defined C functions).
+ */
+#define FUNC_MAX_ARGS		100
+
+/*
+ * Maximum number of columns in an index.  There is little point in making
+ * this anything but a multiple of 32, because the main cost is associated
+ * with index tuple header size (see access/itup.h).
+ *
+ * Changing this requires an initdb.
+ */
+#define INDEX_MAX_KEYS		32
+
+/*
+ * Maximum number of columns in a partition key
+ */
+#define PARTITION_MAX_KEYS	32
+
+/*
+ * Decide whether built-in 8-byte types, including float8, int8, and
+ * timestamp, are passed by value.  This is on by default if sizeof(Datum) >=
+ * 8 (that is, on 64-bit platforms).  If sizeof(Datum) < 8 (32-bit platforms),
+ * this must be off.  We keep this here as an option so that it is easy to
+ * test the pass-by-reference code paths on 64-bit platforms.
+ *
+ * Changing this requires an initdb.
+ */
+#if SIZEOF_VOID_P >= 8
+#define USE_FLOAT8_BYVAL 1
+#endif
+
+/*
+ * When we don't have native spinlocks, we use semaphores to simulate them.
+ * Decreasing this value reduces consumption of OS resources; increasing it
+ * may improve performance, but supplying a real spinlock implementation is
+ * probably far better.
+ */
+#define NUM_SPINLOCK_SEMAPHORES		128
+
+/*
+ * When we have neither spinlocks nor atomic operations support we're
+ * implementing atomic operations on top of spinlock on top of semaphores. To
+ * be safe against atomic operations while holding a spinlock separate
+ * semaphores have to be used.
+ */
+#define NUM_ATOMICS_SEMAPHORES		64
+
+/*
+ * MAXPGPATH: standard size of a pathname buffer in PostgreSQL (hence,
+ * maximum usable pathname length is one less).
+ *
+ * We'd use a standard system header symbol for this, if there weren't
+ * so many to choose from: MAXPATHLEN, MAX_PATH, PATH_MAX are all
+ * defined by different "standards", and often have different values
+ * on the same platform!  So we just punt and use a reasonably
+ * generous setting here.
+ */
+#define MAXPGPATH		1024
+
+/*
+ * PG_SOMAXCONN: maximum accept-queue length limit passed to
+ * listen(2).  You'd think we should use SOMAXCONN from
+ * <sys/socket.h>, but on many systems that symbol is much smaller
+ * than the kernel's actual limit.  In any case, this symbol need be
+ * twiddled only if you have a kernel that refuses large limit values,
+ * rather than silently reducing the value to what it can handle
+ * (which is what most if not all Unixen do).
+ */
+#define PG_SOMAXCONN	10000
+
+/*
+ * You can try changing this if you have a machine with bytes of
+ * another size, but no guarantee...
+ */
+#define BITS_PER_BYTE		8
+
+/*
+ * Preferred alignment for disk I/O buffers.  On some CPUs, copies between
+ * user space and kernel space are significantly faster if the user buffer
+ * is aligned on a larger-than-MAXALIGN boundary.  Ideally this should be
+ * a platform-dependent value, but for now we just hard-wire it.
+ */
+#define ALIGNOF_BUFFER	32
+
+/*
+ * If EXEC_BACKEND is defined, the postmaster uses an alternative method for
+ * starting subprocesses: Instead of simply using fork(), as is standard on
+ * Unix platforms, it uses fork()+exec() or something equivalent on Windows,
+ * as well as lots of extra code to bring the required global state to those
+ * new processes.  This must be enabled on Windows (because there is no
+ * fork()).  On other platforms, it's only useful for verifying those
+ * otherwise Windows-specific code paths.
+ */
+#if defined(WIN32) && !defined(__CYGWIN__)
+#define EXEC_BACKEND
+#endif
+
+/*
+ * Define this if your operating system supports link()
+ */
+#if !defined(WIN32) && !defined(__CYGWIN__)
+#define HAVE_WORKING_LINK 1
+#endif
+
+/*
+ * USE_POSIX_FADVISE controls whether Postgres will attempt to use the
+ * posix_fadvise() kernel call.  Usually the automatic configure tests are
+ * sufficient, but some older Linux distributions had broken versions of
+ * posix_fadvise().  If necessary you can remove the #define here.
+ */
+#if HAVE_DECL_POSIX_FADVISE && defined(HAVE_POSIX_FADVISE)
+#define USE_POSIX_FADVISE
+#endif
+
+/*
+ * USE_PREFETCH code should be compiled only if we have a way to implement
+ * prefetching.  (This is decoupled from USE_POSIX_FADVISE because there
+ * might in future be support for alternative low-level prefetch APIs.
+ * If you change this, you probably need to adjust the error message in
+ * check_effective_io_concurrency.)
+ */
+#ifdef USE_POSIX_FADVISE
+#define USE_PREFETCH
+#endif
+
+/*
+ * Default and maximum values for backend_flush_after, bgwriter_flush_after
+ * and checkpoint_flush_after; measured in blocks.  Currently, these are
+ * enabled by default if sync_file_range() exists, ie, only on Linux.  Perhaps
+ * we could also enable by default if we have mmap and msync(MS_ASYNC)?
+ */
+#ifdef HAVE_SYNC_FILE_RANGE
+#define DEFAULT_BACKEND_FLUSH_AFTER 0	/* never enabled by default */
+#define DEFAULT_BGWRITER_FLUSH_AFTER 64
+#define DEFAULT_CHECKPOINT_FLUSH_AFTER 32
+#else
+#define DEFAULT_BACKEND_FLUSH_AFTER 0
+#define DEFAULT_BGWRITER_FLUSH_AFTER 0
+#define DEFAULT_CHECKPOINT_FLUSH_AFTER 0
+#endif
+/* upper limit for all three variables */
+#define WRITEBACK_MAX_PENDING_FLUSHES 256
+
+/*
+ * USE_SSL code should be compiled only when compiling with an SSL
+ * implementation.  (Currently, only OpenSSL is supported, but we might add
+ * more implementations in the future.)
+ */
+#ifdef USE_OPENSSL
+#define USE_SSL
+#endif
+
+/*
+ * This is the default directory in which AF_UNIX socket files are
+ * placed.  Caution: changing this risks breaking your existing client
+ * applications, which are likely to continue to look in the old
+ * directory.  But if you just hate the idea of sockets in /tmp,
+ * here's where to twiddle it.  You can also override this at runtime
+ * with the postmaster's -k switch.
+ *
+ * If set to an empty string, then AF_UNIX sockets are not used by default: A
+ * server will not create an AF_UNIX socket unless the run-time configuration
+ * is changed, a client will connect via TCP/IP by default and will only use
+ * an AF_UNIX socket if one is explicitly specified.
+ *
+ * This is done by default on Windows because there is no good standard
+ * location for AF_UNIX sockets and many installations on Windows don't
+ * support them yet.
+ */
+#ifndef WIN32
+#define DEFAULT_PGSOCKET_DIR  "/run/postgresql"
+#else
+#define DEFAULT_PGSOCKET_DIR ""
+#endif
+
+/*
+ * This is the default event source for Windows event log.
+ */
+#define DEFAULT_EVENT_SOURCE  "PostgreSQL"
+
+/*
+ * The random() function is expected to yield values between 0 and
+ * MAX_RANDOM_VALUE.  Currently, all known implementations yield
+ * 0..2^31-1, so we just hardwire this constant.  We could do a
+ * configure test if it proves to be necessary.  CAUTION: Think not to
+ * replace this with RAND_MAX.  RAND_MAX defines the maximum value of
+ * the older rand() function, which is often different from --- and
+ * considerably inferior to --- random().
+ */
+#define MAX_RANDOM_VALUE  PG_INT32_MAX
+
+/*
+ * On PPC machines, decide whether to use the mutex hint bit in LWARX
+ * instructions.  Setting the hint bit will slightly improve spinlock
+ * performance on POWER6 and later machines, but does nothing before that,
+ * and will result in illegal-instruction failures on some pre-POWER4
+ * machines.  By default we use the hint bit when building for 64-bit PPC,
+ * which should be safe in nearly all cases.  You might want to override
+ * this if you are building 32-bit code for a known-recent PPC machine.
+ */
+#ifdef HAVE_PPC_LWARX_MUTEX_HINT	/* must have assembler support in any case */
+#if defined(__ppc64__) || defined(__powerpc64__)
+#define USE_PPC_LWARX_MUTEX_HINT
+#endif
+#endif
+
+/*
+ * On PPC machines, decide whether to use LWSYNC instructions in place of
+ * ISYNC and SYNC.  This provides slightly better performance, but will
+ * result in illegal-instruction failures on some pre-POWER4 machines.
+ * By default we use LWSYNC when building for 64-bit PPC, which should be
+ * safe in nearly all cases.
+ */
+#if defined(__ppc64__) || defined(__powerpc64__)
+#define USE_PPC_LWSYNC
+#endif
+
+/*
+ * Assumed cache line size. This doesn't affect correctness, but can be used
+ * for low-level optimizations. Currently, this is used to pad some data
+ * structures in xlog.c, to ensure that highly-contended fields are on
+ * different cache lines. Too small a value can hurt performance due to false
+ * sharing, while the only downside of too large a value is a few bytes of
+ * wasted memory. The default is 128, which should be large enough for all
+ * supported platforms.
+ */
+#define PG_CACHE_LINE_SIZE		128
+
+/*
+ *------------------------------------------------------------------------
+ * The following symbols are for enabling debugging code, not for
+ * controlling user-visible features or resource limits.
+ *------------------------------------------------------------------------
+ */
+
+/*
+ * Include Valgrind "client requests", mostly in the memory allocator, so
+ * Valgrind understands PostgreSQL memory contexts.  This permits detecting
+ * memory errors that Valgrind would not detect on a vanilla build.  See also
+ * src/tools/valgrind.supp.  "make installcheck" runs 20-30x longer under
+ * Valgrind.  Note that USE_VALGRIND slowed older versions of Valgrind by an
+ * additional order of magnitude; Valgrind 3.8.1 does not have this problem.
+ * The client requests fall in hot code paths, so USE_VALGRIND also slows
+ * native execution by a few percentage points.
+ *
+ * You should normally use MEMORY_CONTEXT_CHECKING with USE_VALGRIND;
+ * instrumentation of repalloc() is inferior without it.
+ */
+/* #define USE_VALGRIND */
+
+/*
+ * Define this to cause pfree()'d memory to be cleared immediately, to
+ * facilitate catching bugs that refer to already-freed values.
+ * Right now, this gets defined automatically if --enable-cassert.
+ */
+#ifdef USE_ASSERT_CHECKING
+#define CLOBBER_FREED_MEMORY
+#endif
+
+/*
+ * Define this to check memory allocation errors (scribbling on more
+ * bytes than were allocated).  Right now, this gets defined
+ * automatically if --enable-cassert or USE_VALGRIND.
+ */
+#if defined(USE_ASSERT_CHECKING) || defined(USE_VALGRIND)
+#define MEMORY_CONTEXT_CHECKING
+#endif
+
+/*
+ * Define this to cause palloc()'d memory to be filled with random data, to
+ * facilitate catching code that depends on the contents of uninitialized
+ * memory.  Caution: this is horrendously expensive.
+ */
+/* #define RANDOMIZE_ALLOCATED_MEMORY */
+
+/*
+ * Define this to force all parse and plan trees to be passed through
+ * copyObject(), to facilitate catching errors and omissions in
+ * copyObject().
+ */
+/* #define COPY_PARSE_PLAN_TREES */
+
+/*
+ * Define this to force all parse and plan trees to be passed through
+ * outfuncs.c/readfuncs.c, to facilitate catching errors and omissions in
+ * those modules.
+ */
+/* #define WRITE_READ_PARSE_PLAN_TREES */
+
+/*
+ * Define this to force all raw parse trees for DML statements to be scanned
+ * by raw_expression_tree_walker(), to facilitate catching errors and
+ * omissions in that function.
+ */
+/* #define RAW_EXPRESSION_COVERAGE_TEST */
+
+/*
+ * Enable debugging print statements for lock-related operations.
+ */
+/* #define LOCK_DEBUG */
+
+/*
+ * Enable debugging print statements for WAL-related operations; see
+ * also the wal_debug GUC var.
+ */
+/* #define WAL_DEBUG */
+
+/*
+ * Enable tracing of resource consumption during sort operations;
+ * see also the trace_sort GUC var.  For 8.1 this is enabled by default.
+ */
+#define TRACE_SORT 1
+
+/*
+ * Enable tracing of syncscan operations (see also the trace_syncscan GUC var).
+ */
+/* #define TRACE_SYNCSCAN */
diff --git a/contrib/libs/postgresql/src/include/pg_config_os-linux.h b/contrib/libs/postgresql/src/include/pg_config_os-linux.h
new file mode 100644
index 0000000000..331e1b2cf1
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/pg_config_os-linux.h
@@ -0,0 +1 @@
+#include <contrib/libs/libpq/src/include/port/linux.h>
diff --git a/contrib/libs/postgresql/src/include/pg_config_os-osx.h b/contrib/libs/postgresql/src/include/pg_config_os-osx.h
new file mode 100644
index 0000000000..f77fb9d4da
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/pg_config_os-osx.h
@@ -0,0 +1 @@
+#include <contrib/libs/libpq/src/include/port/darwin.h>
diff --git a/contrib/libs/postgresql/src/include/pg_config_os-win.h b/contrib/libs/postgresql/src/include/pg_config_os-win.h
new file mode 100644
index 0000000000..e26ba92209
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/pg_config_os-win.h
@@ -0,0 +1 @@
+#include <contrib/libs/libpq/src/include/port/win32.h>
diff --git a/contrib/libs/postgresql/src/include/pg_config_os.h b/contrib/libs/postgresql/src/include/pg_config_os.h
new file mode 100644
index 0000000000..86db251be2
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/pg_config_os.h
@@ -0,0 +1,9 @@
+#pragma once
+
+#if defined(__APPLE__)
+#   include "pg_config_os-osx.h"
+#elif defined(_MSC_VER)
+#   include "pg_config_os-win.h"
+#else
+#   include "pg_config_os-linux.h"
+#endif
diff --git a/contrib/libs/postgresql/src/include/pg_getopt.h b/contrib/libs/postgresql/src/include/pg_getopt.h
new file mode 100644
index 0000000000..e646fc3419
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/pg_getopt.h
@@ -0,0 +1,56 @@
+/*
+ * Postgres files that use getopt(3) always include this file.
+ * We must cope with three different scenarios:
+ * 1. We're using the platform's getopt(), and we should just import the
+ *    appropriate declarations.
+ * 2. The platform lacks getopt(), and we must declare everything.
+ * 3. The platform has getopt(), but we're not using it because we don't
+ *    like its behavior.  The declarations we make here must be compatible
+ *    with both the platform's getopt() and our src/port/getopt.c.
+ *
+ * Portions Copyright (c) 1987, 1993, 1994
+ * The Regents of the University of California.  All rights reserved.
+ *
+ * Portions Copyright (c) 2003-2020, PostgreSQL Global Development Group
+ *
+ * src/include/pg_getopt.h
+ */
+#ifndef PG_GETOPT_H
+#define PG_GETOPT_H
+
+/* POSIX says getopt() is provided by unistd.h */
+#include <unistd.h>
+
+/* rely on the system's getopt.h if present */
+#ifdef HAVE_GETOPT_H
+#include <getopt.h>
+#endif
+
+/*
+ * If we have <getopt.h>, assume it declares these variables, else do that
+ * ourselves.  (We used to just declare them unconditionally, but Cygwin
+ * doesn't like that.)
+ */
+#ifndef HAVE_GETOPT_H
+
+extern char *optarg;
+extern int	optind;
+extern int	opterr;
+extern int	optopt;
+
+#endif							/* HAVE_GETOPT_H */
+
+/*
+ * Some platforms have optreset but fail to declare it in <getopt.h>, so cope.
+ * Cygwin, however, doesn't like this either.
+ */
+#if defined(HAVE_INT_OPTRESET) && !defined(__CYGWIN__)
+extern int	optreset;
+#endif
+
+/* Provide getopt() declaration if the platform doesn't have it */
+#ifndef HAVE_GETOPT
+extern int	getopt(int nargc, char *const *nargv, const char *ostr);
+#endif
+
+#endif							/* PG_GETOPT_H */
diff --git a/contrib/libs/postgresql/src/include/pg_trace.h b/contrib/libs/postgresql/src/include/pg_trace.h
new file mode 100644
index 0000000000..cf212aeabd
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/pg_trace.h
@@ -0,0 +1,17 @@
+/* ----------
+ *	pg_trace.h
+ *
+ *	Definitions for the PostgreSQL tracing framework
+ *
+ *	Copyright (c) 2006-2020, PostgreSQL Global Development Group
+ *
+ *	src/include/pg_trace.h
+ * ----------
+ */
+
+#ifndef PG_TRACE_H
+#define PG_TRACE_H
+
+#include "utils/probes.h"		/* pgrminclude ignore */
+
+#endif							/* PG_TRACE_H */
diff --git a/contrib/libs/postgresql/src/include/pgstat.h b/contrib/libs/postgresql/src/include/pgstat.h
new file mode 100644
index 0000000000..c55dc1481c
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/pgstat.h
@@ -0,0 +1,1487 @@
+/* ----------
+ *	pgstat.h
+ *
+ *	Definitions for the PostgreSQL statistics collector daemon.
+ *
+ *	Copyright (c) 2001-2020, PostgreSQL Global Development Group
+ *
+ *	src/include/pgstat.h
+ * ----------
+ */
+#ifndef PGSTAT_H
+#define PGSTAT_H
+
+#include "datatype/timestamp.h"
+#include "libpq/pqcomm.h"
+#include "miscadmin.h"
+#include "port/atomics.h"
+#include "portability/instr_time.h"
+#include "postmaster/pgarch.h"
+#include "storage/proc.h"
+#include "utils/hsearch.h"
+#include "utils/relcache.h"
+
+
+/* ----------
+ * Paths for the statistics files (relative to installation's $PGDATA).
+ * ----------
+ */
+#define PGSTAT_STAT_PERMANENT_DIRECTORY		"pg_stat"
+#define PGSTAT_STAT_PERMANENT_FILENAME		"pg_stat/global.stat"
+#define PGSTAT_STAT_PERMANENT_TMPFILE		"pg_stat/global.tmp"
+
+/* Default directory to store temporary statistics data in */
+#define PG_STAT_TMP_DIR		"pg_stat_tmp"
+
+/* Values for track_functions GUC variable --- order is significant! */
+typedef enum TrackFunctionsLevel
+{
+	TRACK_FUNC_OFF,
+	TRACK_FUNC_PL,
+	TRACK_FUNC_ALL
+}			TrackFunctionsLevel;
+
+/* ----------
+ * The types of backend -> collector messages
+ * ----------
+ */
+typedef enum StatMsgType
+{
+	PGSTAT_MTYPE_DUMMY,
+	PGSTAT_MTYPE_INQUIRY,
+	PGSTAT_MTYPE_TABSTAT,
+	PGSTAT_MTYPE_TABPURGE,
+	PGSTAT_MTYPE_DROPDB,
+	PGSTAT_MTYPE_RESETCOUNTER,
+	PGSTAT_MTYPE_RESETSHAREDCOUNTER,
+	PGSTAT_MTYPE_RESETSINGLECOUNTER,
+	PGSTAT_MTYPE_RESETSLRUCOUNTER,
+	PGSTAT_MTYPE_AUTOVAC_START,
+	PGSTAT_MTYPE_VACUUM,
+	PGSTAT_MTYPE_ANALYZE,
+	PGSTAT_MTYPE_ARCHIVER,
+	PGSTAT_MTYPE_BGWRITER,
+	PGSTAT_MTYPE_SLRU,
+	PGSTAT_MTYPE_FUNCSTAT,
+	PGSTAT_MTYPE_FUNCPURGE,
+	PGSTAT_MTYPE_RECOVERYCONFLICT,
+	PGSTAT_MTYPE_TEMPFILE,
+	PGSTAT_MTYPE_DEADLOCK,
+	PGSTAT_MTYPE_CHECKSUMFAILURE
+} StatMsgType;
+
+/* ----------
+ * The data type used for counters.
+ * ----------
+ */
+typedef int64 PgStat_Counter;
+
+/* ----------
+ * PgStat_TableCounts			The actual per-table counts kept by a backend
+ *
+ * This struct should contain only actual event counters, because we memcmp
+ * it against zeroes to detect whether there are any counts to transmit.
+ * It is a component of PgStat_TableStatus (within-backend state) and
+ * PgStat_TableEntry (the transmitted message format).
+ *
+ * Note: for a table, tuples_returned is the number of tuples successfully
+ * fetched by heap_getnext, while tuples_fetched is the number of tuples
+ * successfully fetched by heap_fetch under the control of bitmap indexscans.
+ * For an index, tuples_returned is the number of index entries returned by
+ * the index AM, while tuples_fetched is the number of tuples successfully
+ * fetched by heap_fetch under the control of simple indexscans for this index.
+ *
+ * tuples_inserted/updated/deleted/hot_updated count attempted actions,
+ * regardless of whether the transaction committed.  delta_live_tuples,
+ * delta_dead_tuples, and changed_tuples are set depending on commit or abort.
+ * Note that delta_live_tuples and delta_dead_tuples can be negative!
+ * ----------
+ */
+typedef struct PgStat_TableCounts
+{
+	PgStat_Counter t_numscans;
+
+	PgStat_Counter t_tuples_returned;
+	PgStat_Counter t_tuples_fetched;
+
+	PgStat_Counter t_tuples_inserted;
+	PgStat_Counter t_tuples_updated;
+	PgStat_Counter t_tuples_deleted;
+	PgStat_Counter t_tuples_hot_updated;
+	bool		t_truncated;
+
+	PgStat_Counter t_delta_live_tuples;
+	PgStat_Counter t_delta_dead_tuples;
+	PgStat_Counter t_changed_tuples;
+
+	PgStat_Counter t_blocks_fetched;
+	PgStat_Counter t_blocks_hit;
+} PgStat_TableCounts;
+
+/* Possible targets for resetting cluster-wide shared values */
+typedef enum PgStat_Shared_Reset_Target
+{
+	RESET_ARCHIVER,
+	RESET_BGWRITER
+} PgStat_Shared_Reset_Target;
+
+/* Possible object types for resetting single counters */
+typedef enum PgStat_Single_Reset_Type
+{
+	RESET_TABLE,
+	RESET_FUNCTION
+} PgStat_Single_Reset_Type;
+
+/* ------------------------------------------------------------
+ * Structures kept in backend local memory while accumulating counts
+ * ------------------------------------------------------------
+ */
+
+
+/* ----------
+ * PgStat_TableStatus			Per-table status within a backend
+ *
+ * Many of the event counters are nontransactional, ie, we count events
+ * in committed and aborted transactions alike.  For these, we just count
+ * directly in the PgStat_TableStatus.  However, delta_live_tuples,
+ * delta_dead_tuples, and changed_tuples must be derived from event counts
+ * with awareness of whether the transaction or subtransaction committed or
+ * aborted.  Hence, we also keep a stack of per-(sub)transaction status
+ * records for every table modified in the current transaction.  At commit
+ * or abort, we propagate tuples_inserted/updated/deleted up to the
+ * parent subtransaction level, or out to the parent PgStat_TableStatus,
+ * as appropriate.
+ * ----------
+ */
+typedef struct PgStat_TableStatus
+{
+	Oid			t_id;			/* table's OID */
+	bool		t_shared;		/* is it a shared catalog? */
+	struct PgStat_TableXactStatus *trans;	/* lowest subxact's counts */
+	PgStat_TableCounts t_counts;	/* event counts to be sent */
+} PgStat_TableStatus;
+
+/* ----------
+ * PgStat_TableXactStatus		Per-table, per-subtransaction status
+ * ----------
+ */
+typedef struct PgStat_TableXactStatus
+{
+	PgStat_Counter tuples_inserted; /* tuples inserted in (sub)xact */
+	PgStat_Counter tuples_updated;	/* tuples updated in (sub)xact */
+	PgStat_Counter tuples_deleted;	/* tuples deleted in (sub)xact */
+	bool		truncated;		/* relation truncated in this (sub)xact */
+	PgStat_Counter inserted_pre_trunc;	/* tuples inserted prior to truncate */
+	PgStat_Counter updated_pre_trunc;	/* tuples updated prior to truncate */
+	PgStat_Counter deleted_pre_trunc;	/* tuples deleted prior to truncate */
+	int			nest_level;		/* subtransaction nest level */
+	/* links to other structs for same relation: */
+	struct PgStat_TableXactStatus *upper;	/* next higher subxact if any */
+	PgStat_TableStatus *parent; /* per-table status */
+	/* structs of same subxact level are linked here: */
+	struct PgStat_TableXactStatus *next;	/* next of same subxact */
+} PgStat_TableXactStatus;
+
+
+/* ------------------------------------------------------------
+ * Message formats follow
+ * ------------------------------------------------------------
+ */
+
+
+/* ----------
+ * PgStat_MsgHdr				The common message header
+ * ----------
+ */
+typedef struct PgStat_MsgHdr
+{
+	StatMsgType m_type;
+	int			m_size;
+} PgStat_MsgHdr;
+
+/* ----------
+ * Space available in a message.  This will keep the UDP packets below 1K,
+ * which should fit unfragmented into the MTU of the loopback interface.
+ * (Larger values of PGSTAT_MAX_MSG_SIZE would work for that on most
+ * platforms, but we're being conservative here.)
+ * ----------
+ */
+#define PGSTAT_MAX_MSG_SIZE 1000
+#define PGSTAT_MSG_PAYLOAD	(PGSTAT_MAX_MSG_SIZE - sizeof(PgStat_MsgHdr))
+
+
+/* ----------
+ * PgStat_MsgDummy				A dummy message, ignored by the collector
+ * ----------
+ */
+typedef struct PgStat_MsgDummy
+{
+	PgStat_MsgHdr m_hdr;
+} PgStat_MsgDummy;
+
+
+/* ----------
+ * PgStat_MsgInquiry			Sent by a backend to ask the collector
+ *								to write the stats file(s).
+ *
+ * Ordinarily, an inquiry message prompts writing of the global stats file,
+ * the stats file for shared catalogs, and the stats file for the specified
+ * database.  If databaseid is InvalidOid, only the first two are written.
+ *
+ * New file(s) will be written only if the existing file has a timestamp
+ * older than the specified cutoff_time; this prevents duplicated effort
+ * when multiple requests arrive at nearly the same time, assuming that
+ * backends send requests with cutoff_times a little bit in the past.
+ *
+ * clock_time should be the requestor's current local time; the collector
+ * uses this to check for the system clock going backward, but it has no
+ * effect unless that occurs.  We assume clock_time >= cutoff_time, though.
+ * ----------
+ */
+
+typedef struct PgStat_MsgInquiry
+{
+	PgStat_MsgHdr m_hdr;
+	TimestampTz clock_time;		/* observed local clock time */
+	TimestampTz cutoff_time;	/* minimum acceptable file timestamp */
+	Oid			databaseid;		/* requested DB (InvalidOid => shared only) */
+} PgStat_MsgInquiry;
+
+
+/* ----------
+ * PgStat_TableEntry			Per-table info in a MsgTabstat
+ * ----------
+ */
+typedef struct PgStat_TableEntry
+{
+	Oid			t_id;
+	PgStat_TableCounts t_counts;
+} PgStat_TableEntry;
+
+/* ----------
+ * PgStat_MsgTabstat			Sent by the backend to report table
+ *								and buffer access statistics.
+ * ----------
+ */
+#define PGSTAT_NUM_TABENTRIES  \
+	((PGSTAT_MSG_PAYLOAD - sizeof(Oid) - 3 * sizeof(int) - 2 * sizeof(PgStat_Counter))	\
+	 / sizeof(PgStat_TableEntry))
+
+typedef struct PgStat_MsgTabstat
+{
+	PgStat_MsgHdr m_hdr;
+	Oid			m_databaseid;
+	int			m_nentries;
+	int			m_xact_commit;
+	int			m_xact_rollback;
+	PgStat_Counter m_block_read_time;	/* times in microseconds */
+	PgStat_Counter m_block_write_time;
+	PgStat_TableEntry m_entry[PGSTAT_NUM_TABENTRIES];
+} PgStat_MsgTabstat;
+
+
+/* ----------
+ * PgStat_MsgTabpurge			Sent by the backend to tell the collector
+ *								about dead tables.
+ * ----------
+ */
+#define PGSTAT_NUM_TABPURGE  \
+	((PGSTAT_MSG_PAYLOAD - sizeof(Oid) - sizeof(int))  \
+	 / sizeof(Oid))
+
+typedef struct PgStat_MsgTabpurge
+{
+	PgStat_MsgHdr m_hdr;
+	Oid			m_databaseid;
+	int			m_nentries;
+	Oid			m_tableid[PGSTAT_NUM_TABPURGE];
+} PgStat_MsgTabpurge;
+
+
+/* ----------
+ * PgStat_MsgDropdb				Sent by the backend to tell the collector
+ *								about a dropped database
+ * ----------
+ */
+typedef struct PgStat_MsgDropdb
+{
+	PgStat_MsgHdr m_hdr;
+	Oid			m_databaseid;
+} PgStat_MsgDropdb;
+
+
+/* ----------
+ * PgStat_MsgResetcounter		Sent by the backend to tell the collector
+ *								to reset counters
+ * ----------
+ */
+typedef struct PgStat_MsgResetcounter
+{
+	PgStat_MsgHdr m_hdr;
+	Oid			m_databaseid;
+} PgStat_MsgResetcounter;
+
+/* ----------
+ * PgStat_MsgResetsharedcounter Sent by the backend to tell the collector
+ *								to reset a shared counter
+ * ----------
+ */
+typedef struct PgStat_MsgResetsharedcounter
+{
+	PgStat_MsgHdr m_hdr;
+	PgStat_Shared_Reset_Target m_resettarget;
+} PgStat_MsgResetsharedcounter;
+
+/* ----------
+ * PgStat_MsgResetsinglecounter Sent by the backend to tell the collector
+ *								to reset a single counter
+ * ----------
+ */
+typedef struct PgStat_MsgResetsinglecounter
+{
+	PgStat_MsgHdr m_hdr;
+	Oid			m_databaseid;
+	PgStat_Single_Reset_Type m_resettype;
+	Oid			m_objectid;
+} PgStat_MsgResetsinglecounter;
+
+/* ----------
+ * PgStat_MsgResetslrucounter Sent by the backend to tell the collector
+ *								to reset a SLRU counter
+ * ----------
+ */
+typedef struct PgStat_MsgResetslrucounter
+{
+	PgStat_MsgHdr m_hdr;
+	int			m_index;
+} PgStat_MsgResetslrucounter;
+
+/* ----------
+ * PgStat_MsgAutovacStart		Sent by the autovacuum daemon to signal
+ *								that a database is going to be processed
+ * ----------
+ */
+typedef struct PgStat_MsgAutovacStart
+{
+	PgStat_MsgHdr m_hdr;
+	Oid			m_databaseid;
+	TimestampTz m_start_time;
+} PgStat_MsgAutovacStart;
+
+
+/* ----------
+ * PgStat_MsgVacuum				Sent by the backend or autovacuum daemon
+ *								after VACUUM
+ * ----------
+ */
+typedef struct PgStat_MsgVacuum
+{
+	PgStat_MsgHdr m_hdr;
+	Oid			m_databaseid;
+	Oid			m_tableoid;
+	bool		m_autovacuum;
+	TimestampTz m_vacuumtime;
+	PgStat_Counter m_live_tuples;
+	PgStat_Counter m_dead_tuples;
+} PgStat_MsgVacuum;
+
+
+/* ----------
+ * PgStat_MsgAnalyze			Sent by the backend or autovacuum daemon
+ *								after ANALYZE
+ * ----------
+ */
+typedef struct PgStat_MsgAnalyze
+{
+	PgStat_MsgHdr m_hdr;
+	Oid			m_databaseid;
+	Oid			m_tableoid;
+	bool		m_autovacuum;
+	bool		m_resetcounter;
+	TimestampTz m_analyzetime;
+	PgStat_Counter m_live_tuples;
+	PgStat_Counter m_dead_tuples;
+} PgStat_MsgAnalyze;
+
+
+/* ----------
+ * PgStat_MsgArchiver			Sent by the archiver to update statistics.
+ * ----------
+ */
+typedef struct PgStat_MsgArchiver
+{
+	PgStat_MsgHdr m_hdr;
+	bool		m_failed;		/* Failed attempt */
+	char		m_xlog[MAX_XFN_CHARS + 1];
+	TimestampTz m_timestamp;
+} PgStat_MsgArchiver;
+
+/* ----------
+ * PgStat_MsgBgWriter			Sent by the bgwriter to update statistics.
+ * ----------
+ */
+typedef struct PgStat_MsgBgWriter
+{
+	PgStat_MsgHdr m_hdr;
+
+	PgStat_Counter m_timed_checkpoints;
+	PgStat_Counter m_requested_checkpoints;
+	PgStat_Counter m_buf_written_checkpoints;
+	PgStat_Counter m_buf_written_clean;
+	PgStat_Counter m_maxwritten_clean;
+	PgStat_Counter m_buf_written_backend;
+	PgStat_Counter m_buf_fsync_backend;
+	PgStat_Counter m_buf_alloc;
+	PgStat_Counter m_checkpoint_write_time; /* times in milliseconds */
+	PgStat_Counter m_checkpoint_sync_time;
+} PgStat_MsgBgWriter;
+
+/* ----------
+ * PgStat_MsgSLRU			Sent by a backend to update SLRU statistics.
+ * ----------
+ */
+typedef struct PgStat_MsgSLRU
+{
+	PgStat_MsgHdr m_hdr;
+	PgStat_Counter m_index;
+	PgStat_Counter m_blocks_zeroed;
+	PgStat_Counter m_blocks_hit;
+	PgStat_Counter m_blocks_read;
+	PgStat_Counter m_blocks_written;
+	PgStat_Counter m_blocks_exists;
+	PgStat_Counter m_flush;
+	PgStat_Counter m_truncate;
+} PgStat_MsgSLRU;
+
+/* ----------
+ * PgStat_MsgRecoveryConflict	Sent by the backend upon recovery conflict
+ * ----------
+ */
+typedef struct PgStat_MsgRecoveryConflict
+{
+	PgStat_MsgHdr m_hdr;
+
+	Oid			m_databaseid;
+	int			m_reason;
+} PgStat_MsgRecoveryConflict;
+
+/* ----------
+ * PgStat_MsgTempFile	Sent by the backend upon creating a temp file
+ * ----------
+ */
+typedef struct PgStat_MsgTempFile
+{
+	PgStat_MsgHdr m_hdr;
+
+	Oid			m_databaseid;
+	size_t		m_filesize;
+} PgStat_MsgTempFile;
+
+/* ----------
+ * PgStat_FunctionCounts	The actual per-function counts kept by a backend
+ *
+ * This struct should contain only actual event counters, because we memcmp
+ * it against zeroes to detect whether there are any counts to transmit.
+ *
+ * Note that the time counters are in instr_time format here.  We convert to
+ * microseconds in PgStat_Counter format when transmitting to the collector.
+ * ----------
+ */
+typedef struct PgStat_FunctionCounts
+{
+	PgStat_Counter f_numcalls;
+	instr_time	f_total_time;
+	instr_time	f_self_time;
+} PgStat_FunctionCounts;
+
+/* ----------
+ * PgStat_BackendFunctionEntry	Entry in backend's per-function hash table
+ * ----------
+ */
+typedef struct PgStat_BackendFunctionEntry
+{
+	Oid			f_id;
+	PgStat_FunctionCounts f_counts;
+} PgStat_BackendFunctionEntry;
+
+/* ----------
+ * PgStat_FunctionEntry			Per-function info in a MsgFuncstat
+ * ----------
+ */
+typedef struct PgStat_FunctionEntry
+{
+	Oid			f_id;
+	PgStat_Counter f_numcalls;
+	PgStat_Counter f_total_time;	/* times in microseconds */
+	PgStat_Counter f_self_time;
+} PgStat_FunctionEntry;
+
+/* ----------
+ * PgStat_MsgFuncstat			Sent by the backend to report function
+ *								usage statistics.
+ * ----------
+ */
+#define PGSTAT_NUM_FUNCENTRIES	\
+	((PGSTAT_MSG_PAYLOAD - sizeof(Oid) - sizeof(int))  \
+	 / sizeof(PgStat_FunctionEntry))
+
+typedef struct PgStat_MsgFuncstat
+{
+	PgStat_MsgHdr m_hdr;
+	Oid			m_databaseid;
+	int			m_nentries;
+	PgStat_FunctionEntry m_entry[PGSTAT_NUM_FUNCENTRIES];
+} PgStat_MsgFuncstat;
+
+/* ----------
+ * PgStat_MsgFuncpurge			Sent by the backend to tell the collector
+ *								about dead functions.
+ * ----------
+ */
+#define PGSTAT_NUM_FUNCPURGE  \
+	((PGSTAT_MSG_PAYLOAD - sizeof(Oid) - sizeof(int))  \
+	 / sizeof(Oid))
+
+typedef struct PgStat_MsgFuncpurge
+{
+	PgStat_MsgHdr m_hdr;
+	Oid			m_databaseid;
+	int			m_nentries;
+	Oid			m_functionid[PGSTAT_NUM_FUNCPURGE];
+} PgStat_MsgFuncpurge;
+
+/* ----------
+ * PgStat_MsgDeadlock			Sent by the backend to tell the collector
+ *								about a deadlock that occurred.
+ * ----------
+ */
+typedef struct PgStat_MsgDeadlock
+{
+	PgStat_MsgHdr m_hdr;
+	Oid			m_databaseid;
+} PgStat_MsgDeadlock;
+
+/* ----------
+ * PgStat_MsgChecksumFailure	Sent by the backend to tell the collector
+ *								about checksum failures noticed.
+ * ----------
+ */
+typedef struct PgStat_MsgChecksumFailure
+{
+	PgStat_MsgHdr m_hdr;
+	Oid			m_databaseid;
+	int			m_failurecount;
+	TimestampTz m_failure_time;
+} PgStat_MsgChecksumFailure;
+
+
+/* ----------
+ * PgStat_Msg					Union over all possible messages.
+ * ----------
+ */
+typedef union PgStat_Msg
+{
+	PgStat_MsgHdr msg_hdr;
+	PgStat_MsgDummy msg_dummy;
+	PgStat_MsgInquiry msg_inquiry;
+	PgStat_MsgTabstat msg_tabstat;
+	PgStat_MsgTabpurge msg_tabpurge;
+	PgStat_MsgDropdb msg_dropdb;
+	PgStat_MsgResetcounter msg_resetcounter;
+	PgStat_MsgResetsharedcounter msg_resetsharedcounter;
+	PgStat_MsgResetsinglecounter msg_resetsinglecounter;
+	PgStat_MsgResetslrucounter msg_resetslrucounter;
+	PgStat_MsgAutovacStart msg_autovacuum_start;
+	PgStat_MsgVacuum msg_vacuum;
+	PgStat_MsgAnalyze msg_analyze;
+	PgStat_MsgArchiver msg_archiver;
+	PgStat_MsgBgWriter msg_bgwriter;
+	PgStat_MsgSLRU msg_slru;
+	PgStat_MsgFuncstat msg_funcstat;
+	PgStat_MsgFuncpurge msg_funcpurge;
+	PgStat_MsgRecoveryConflict msg_recoveryconflict;
+	PgStat_MsgDeadlock msg_deadlock;
+	PgStat_MsgTempFile msg_tempfile;
+	PgStat_MsgChecksumFailure msg_checksumfailure;
+} PgStat_Msg;
+
+
+/* ------------------------------------------------------------
+ * Statistic collector data structures follow
+ *
+ * PGSTAT_FILE_FORMAT_ID should be changed whenever any of these
+ * data structures change.
+ * ------------------------------------------------------------
+ */
+
+#define PGSTAT_FILE_FORMAT_ID	0x01A5BC9D
+
+/* ----------
+ * PgStat_StatDBEntry			The collector's data per database
+ * ----------
+ */
+typedef struct PgStat_StatDBEntry
+{
+	Oid			databaseid;
+	PgStat_Counter n_xact_commit;
+	PgStat_Counter n_xact_rollback;
+	PgStat_Counter n_blocks_fetched;
+	PgStat_Counter n_blocks_hit;
+	PgStat_Counter n_tuples_returned;
+	PgStat_Counter n_tuples_fetched;
+	PgStat_Counter n_tuples_inserted;
+	PgStat_Counter n_tuples_updated;
+	PgStat_Counter n_tuples_deleted;
+	TimestampTz last_autovac_time;
+	PgStat_Counter n_conflict_tablespace;
+	PgStat_Counter n_conflict_lock;
+	PgStat_Counter n_conflict_snapshot;
+	PgStat_Counter n_conflict_bufferpin;
+	PgStat_Counter n_conflict_startup_deadlock;
+	PgStat_Counter n_temp_files;
+	PgStat_Counter n_temp_bytes;
+	PgStat_Counter n_deadlocks;
+	PgStat_Counter n_checksum_failures;
+	TimestampTz last_checksum_failure;
+	PgStat_Counter n_block_read_time;	/* times in microseconds */
+	PgStat_Counter n_block_write_time;
+
+	TimestampTz stat_reset_timestamp;
+	TimestampTz stats_timestamp;	/* time of db stats file update */
+
+	/*
+	 * tables and functions must be last in the struct, because we don't write
+	 * the pointers out to the stats file.
+	 */
+	HTAB	   *tables;
+	HTAB	   *functions;
+} PgStat_StatDBEntry;
+
+
+/* ----------
+ * PgStat_StatTabEntry			The collector's data per table (or index)
+ * ----------
+ */
+typedef struct PgStat_StatTabEntry
+{
+	Oid			tableid;
+
+	PgStat_Counter numscans;
+
+	PgStat_Counter tuples_returned;
+	PgStat_Counter tuples_fetched;
+
+	PgStat_Counter tuples_inserted;
+	PgStat_Counter tuples_updated;
+	PgStat_Counter tuples_deleted;
+	PgStat_Counter tuples_hot_updated;
+
+	PgStat_Counter n_live_tuples;
+	PgStat_Counter n_dead_tuples;
+	PgStat_Counter changes_since_analyze;
+	PgStat_Counter inserts_since_vacuum;
+
+	PgStat_Counter blocks_fetched;
+	PgStat_Counter blocks_hit;
+
+	TimestampTz vacuum_timestamp;	/* user initiated vacuum */
+	PgStat_Counter vacuum_count;
+	TimestampTz autovac_vacuum_timestamp;	/* autovacuum initiated */
+	PgStat_Counter autovac_vacuum_count;
+	TimestampTz analyze_timestamp;	/* user initiated */
+	PgStat_Counter analyze_count;
+	TimestampTz autovac_analyze_timestamp;	/* autovacuum initiated */
+	PgStat_Counter autovac_analyze_count;
+} PgStat_StatTabEntry;
+
+
+/* ----------
+ * PgStat_StatFuncEntry			The collector's data per function
+ * ----------
+ */
+typedef struct PgStat_StatFuncEntry
+{
+	Oid			functionid;
+
+	PgStat_Counter f_numcalls;
+
+	PgStat_Counter f_total_time;	/* times in microseconds */
+	PgStat_Counter f_self_time;
+} PgStat_StatFuncEntry;
+
+
+/*
+ * Archiver statistics kept in the stats collector
+ */
+typedef struct PgStat_ArchiverStats
+{
+	PgStat_Counter archived_count;	/* archival successes */
+	char		last_archived_wal[MAX_XFN_CHARS + 1];	/* last WAL file
+														 * archived */
+	TimestampTz last_archived_timestamp;	/* last archival success time */
+	PgStat_Counter failed_count;	/* failed archival attempts */
+	char		last_failed_wal[MAX_XFN_CHARS + 1]; /* WAL file involved in
+													 * last failure */
+	TimestampTz last_failed_timestamp;	/* last archival failure time */
+	TimestampTz stat_reset_timestamp;
+} PgStat_ArchiverStats;
+
+/*
+ * Global statistics kept in the stats collector
+ */
+typedef struct PgStat_GlobalStats
+{
+	TimestampTz stats_timestamp;	/* time of stats file update */
+	PgStat_Counter timed_checkpoints;
+	PgStat_Counter requested_checkpoints;
+	PgStat_Counter checkpoint_write_time;	/* times in milliseconds */
+	PgStat_Counter checkpoint_sync_time;
+	PgStat_Counter buf_written_checkpoints;
+	PgStat_Counter buf_written_clean;
+	PgStat_Counter maxwritten_clean;
+	PgStat_Counter buf_written_backend;
+	PgStat_Counter buf_fsync_backend;
+	PgStat_Counter buf_alloc;
+	TimestampTz stat_reset_timestamp;
+} PgStat_GlobalStats;
+
+/*
+ * SLRU statistics kept in the stats collector
+ */
+typedef struct PgStat_SLRUStats
+{
+	PgStat_Counter blocks_zeroed;
+	PgStat_Counter blocks_hit;
+	PgStat_Counter blocks_read;
+	PgStat_Counter blocks_written;
+	PgStat_Counter blocks_exists;
+	PgStat_Counter flush;
+	PgStat_Counter truncate;
+	TimestampTz stat_reset_timestamp;
+} PgStat_SLRUStats;
+
+
+/* ----------
+ * Backend states
+ * ----------
+ */
+typedef enum BackendState
+{
+	STATE_UNDEFINED,
+	STATE_IDLE,
+	STATE_RUNNING,
+	STATE_IDLEINTRANSACTION,
+	STATE_FASTPATH,
+	STATE_IDLEINTRANSACTION_ABORTED,
+	STATE_DISABLED
+} BackendState;
+
+
+/* ----------
+ * Wait Classes
+ * ----------
+ */
+#define PG_WAIT_LWLOCK				0x01000000U
+#define PG_WAIT_LOCK				0x03000000U
+#define PG_WAIT_BUFFER_PIN			0x04000000U
+#define PG_WAIT_ACTIVITY			0x05000000U
+#define PG_WAIT_CLIENT				0x06000000U
+#define PG_WAIT_EXTENSION			0x07000000U
+#define PG_WAIT_IPC					0x08000000U
+#define PG_WAIT_TIMEOUT				0x09000000U
+#define PG_WAIT_IO					0x0A000000U
+
+/* ----------
+ * Wait Events - Activity
+ *
+ * Use this category when a process is waiting because it has no work to do,
+ * unless the "Client" or "Timeout" category describes the situation better.
+ * Typically, this should only be used for background processes.
+ * ----------
+ */
+typedef enum
+{
+	WAIT_EVENT_ARCHIVER_MAIN = PG_WAIT_ACTIVITY,
+	WAIT_EVENT_AUTOVACUUM_MAIN,
+	WAIT_EVENT_BGWRITER_HIBERNATE,
+	WAIT_EVENT_BGWRITER_MAIN,
+	WAIT_EVENT_CHECKPOINTER_MAIN,
+	WAIT_EVENT_LOGICAL_APPLY_MAIN,
+	WAIT_EVENT_LOGICAL_LAUNCHER_MAIN,
+	WAIT_EVENT_PGSTAT_MAIN,
+	WAIT_EVENT_RECOVERY_WAL_STREAM,
+	WAIT_EVENT_SYSLOGGER_MAIN,
+	WAIT_EVENT_WAL_RECEIVER_MAIN,
+	WAIT_EVENT_WAL_SENDER_MAIN,
+	WAIT_EVENT_WAL_WRITER_MAIN
+} WaitEventActivity;
+
+/* ----------
+ * Wait Events - Client
+ *
+ * Use this category when a process is waiting to send data to or receive data
+ * from the frontend process to which it is connected.  This is never used for
+ * a background process, which has no client connection.
+ * ----------
+ */
+typedef enum
+{
+	WAIT_EVENT_CLIENT_READ = PG_WAIT_CLIENT,
+	WAIT_EVENT_CLIENT_WRITE,
+	WAIT_EVENT_GSS_OPEN_SERVER,
+	WAIT_EVENT_LIBPQWALRECEIVER_CONNECT,
+	WAIT_EVENT_LIBPQWALRECEIVER_RECEIVE,
+	WAIT_EVENT_SSL_OPEN_SERVER,
+	WAIT_EVENT_WAL_RECEIVER_WAIT_START,
+	WAIT_EVENT_WAL_SENDER_WAIT_WAL,
+	WAIT_EVENT_WAL_SENDER_WRITE_DATA,
+} WaitEventClient;
+
+/* ----------
+ * Wait Events - IPC
+ *
+ * Use this category when a process cannot complete the work it is doing because
+ * it is waiting for a notification from another process.
+ * ----------
+ */
+typedef enum
+{
+	WAIT_EVENT_BACKUP_WAIT_WAL_ARCHIVE = PG_WAIT_IPC,
+	WAIT_EVENT_BGWORKER_SHUTDOWN,
+	WAIT_EVENT_BGWORKER_STARTUP,
+	WAIT_EVENT_BTREE_PAGE,
+	WAIT_EVENT_CHECKPOINT_DONE,
+	WAIT_EVENT_CHECKPOINT_START,
+	WAIT_EVENT_EXECUTE_GATHER,
+	WAIT_EVENT_HASH_BATCH_ALLOCATE,
+	WAIT_EVENT_HASH_BATCH_ELECT,
+	WAIT_EVENT_HASH_BATCH_LOAD,
+	WAIT_EVENT_HASH_BUILD_ALLOCATE,
+	WAIT_EVENT_HASH_BUILD_ELECT,
+	WAIT_EVENT_HASH_BUILD_HASH_INNER,
+	WAIT_EVENT_HASH_BUILD_HASH_OUTER,
+	WAIT_EVENT_HASH_GROW_BATCHES_ALLOCATE,
+	WAIT_EVENT_HASH_GROW_BATCHES_DECIDE,
+	WAIT_EVENT_HASH_GROW_BATCHES_ELECT,
+	WAIT_EVENT_HASH_GROW_BATCHES_FINISH,
+	WAIT_EVENT_HASH_GROW_BATCHES_REPARTITION,
+	WAIT_EVENT_HASH_GROW_BUCKETS_ALLOCATE,
+	WAIT_EVENT_HASH_GROW_BUCKETS_ELECT,
+	WAIT_EVENT_HASH_GROW_BUCKETS_REINSERT,
+	WAIT_EVENT_LOGICAL_SYNC_DATA,
+	WAIT_EVENT_LOGICAL_SYNC_STATE_CHANGE,
+	WAIT_EVENT_MQ_INTERNAL,
+	WAIT_EVENT_MQ_PUT_MESSAGE,
+	WAIT_EVENT_MQ_RECEIVE,
+	WAIT_EVENT_MQ_SEND,
+	WAIT_EVENT_PARALLEL_BITMAP_SCAN,
+	WAIT_EVENT_PARALLEL_CREATE_INDEX_SCAN,
+	WAIT_EVENT_PARALLEL_FINISH,
+	WAIT_EVENT_PROCARRAY_GROUP_UPDATE,
+	WAIT_EVENT_PROC_SIGNAL_BARRIER,
+	WAIT_EVENT_PROMOTE,
+	WAIT_EVENT_RECOVERY_CONFLICT_SNAPSHOT,
+	WAIT_EVENT_RECOVERY_CONFLICT_TABLESPACE,
+	WAIT_EVENT_RECOVERY_PAUSE,
+	WAIT_EVENT_REPLICATION_ORIGIN_DROP,
+	WAIT_EVENT_REPLICATION_SLOT_DROP,
+	WAIT_EVENT_SAFE_SNAPSHOT,
+	WAIT_EVENT_SYNC_REP,
+	WAIT_EVENT_XACT_GROUP_UPDATE
+} WaitEventIPC;
+
+/* ----------
+ * Wait Events - Timeout
+ *
+ * Use this category when a process is waiting for a timeout to expire.
+ * ----------
+ */
+typedef enum
+{
+	WAIT_EVENT_BASE_BACKUP_THROTTLE = PG_WAIT_TIMEOUT,
+	WAIT_EVENT_PG_SLEEP,
+	WAIT_EVENT_RECOVERY_APPLY_DELAY,
+	WAIT_EVENT_RECOVERY_RETRIEVE_RETRY_INTERVAL,
+	WAIT_EVENT_VACUUM_DELAY
+} WaitEventTimeout;
+
+/* ----------
+ * Wait Events - IO
+ *
+ * Use this category when a process is waiting for a IO.
+ * ----------
+ */
+typedef enum
+{
+	WAIT_EVENT_BUFFILE_READ = PG_WAIT_IO,
+	WAIT_EVENT_BUFFILE_WRITE,
+	WAIT_EVENT_CONTROL_FILE_READ,
+	WAIT_EVENT_CONTROL_FILE_SYNC,
+	WAIT_EVENT_CONTROL_FILE_SYNC_UPDATE,
+	WAIT_EVENT_CONTROL_FILE_WRITE,
+	WAIT_EVENT_CONTROL_FILE_WRITE_UPDATE,
+	WAIT_EVENT_COPY_FILE_READ,
+	WAIT_EVENT_COPY_FILE_WRITE,
+	WAIT_EVENT_DATA_FILE_EXTEND,
+	WAIT_EVENT_DATA_FILE_FLUSH,
+	WAIT_EVENT_DATA_FILE_IMMEDIATE_SYNC,
+	WAIT_EVENT_DATA_FILE_PREFETCH,
+	WAIT_EVENT_DATA_FILE_READ,
+	WAIT_EVENT_DATA_FILE_SYNC,
+	WAIT_EVENT_DATA_FILE_TRUNCATE,
+	WAIT_EVENT_DATA_FILE_WRITE,
+	WAIT_EVENT_DSM_FILL_ZERO_WRITE,
+	WAIT_EVENT_LOCK_FILE_ADDTODATADIR_READ,
+	WAIT_EVENT_LOCK_FILE_ADDTODATADIR_SYNC,
+	WAIT_EVENT_LOCK_FILE_ADDTODATADIR_WRITE,
+	WAIT_EVENT_LOCK_FILE_CREATE_READ,
+	WAIT_EVENT_LOCK_FILE_CREATE_SYNC,
+	WAIT_EVENT_LOCK_FILE_CREATE_WRITE,
+	WAIT_EVENT_LOCK_FILE_RECHECKDATADIR_READ,
+	WAIT_EVENT_LOGICAL_REWRITE_CHECKPOINT_SYNC,
+	WAIT_EVENT_LOGICAL_REWRITE_MAPPING_SYNC,
+	WAIT_EVENT_LOGICAL_REWRITE_MAPPING_WRITE,
+	WAIT_EVENT_LOGICAL_REWRITE_SYNC,
+	WAIT_EVENT_LOGICAL_REWRITE_TRUNCATE,
+	WAIT_EVENT_LOGICAL_REWRITE_WRITE,
+	WAIT_EVENT_RELATION_MAP_READ,
+	WAIT_EVENT_RELATION_MAP_SYNC,
+	WAIT_EVENT_RELATION_MAP_WRITE,
+	WAIT_EVENT_REORDER_BUFFER_READ,
+	WAIT_EVENT_REORDER_BUFFER_WRITE,
+	WAIT_EVENT_REORDER_LOGICAL_MAPPING_READ,
+	WAIT_EVENT_REPLICATION_SLOT_READ,
+	WAIT_EVENT_REPLICATION_SLOT_RESTORE_SYNC,
+	WAIT_EVENT_REPLICATION_SLOT_SYNC,
+	WAIT_EVENT_REPLICATION_SLOT_WRITE,
+	WAIT_EVENT_SLRU_FLUSH_SYNC,
+	WAIT_EVENT_SLRU_READ,
+	WAIT_EVENT_SLRU_SYNC,
+	WAIT_EVENT_SLRU_WRITE,
+	WAIT_EVENT_SNAPBUILD_READ,
+	WAIT_EVENT_SNAPBUILD_SYNC,
+	WAIT_EVENT_SNAPBUILD_WRITE,
+	WAIT_EVENT_TIMELINE_HISTORY_FILE_SYNC,
+	WAIT_EVENT_TIMELINE_HISTORY_FILE_WRITE,
+	WAIT_EVENT_TIMELINE_HISTORY_READ,
+	WAIT_EVENT_TIMELINE_HISTORY_SYNC,
+	WAIT_EVENT_TIMELINE_HISTORY_WRITE,
+	WAIT_EVENT_TWOPHASE_FILE_READ,
+	WAIT_EVENT_TWOPHASE_FILE_SYNC,
+	WAIT_EVENT_TWOPHASE_FILE_WRITE,
+	WAIT_EVENT_WALSENDER_TIMELINE_HISTORY_READ,
+	WAIT_EVENT_WAL_BOOTSTRAP_SYNC,
+	WAIT_EVENT_WAL_BOOTSTRAP_WRITE,
+	WAIT_EVENT_WAL_COPY_READ,
+	WAIT_EVENT_WAL_COPY_SYNC,
+	WAIT_EVENT_WAL_COPY_WRITE,
+	WAIT_EVENT_WAL_INIT_SYNC,
+	WAIT_EVENT_WAL_INIT_WRITE,
+	WAIT_EVENT_WAL_READ,
+	WAIT_EVENT_WAL_SYNC,
+	WAIT_EVENT_WAL_SYNC_METHOD_ASSIGN,
+	WAIT_EVENT_WAL_WRITE
+} WaitEventIO;
+
+/* ----------
+ * Command type for progress reporting purposes
+ * ----------
+ */
+typedef enum ProgressCommandType
+{
+	PROGRESS_COMMAND_INVALID,
+	PROGRESS_COMMAND_VACUUM,
+	PROGRESS_COMMAND_ANALYZE,
+	PROGRESS_COMMAND_CLUSTER,
+	PROGRESS_COMMAND_CREATE_INDEX,
+	PROGRESS_COMMAND_BASEBACKUP
+} ProgressCommandType;
+
+#define PGSTAT_NUM_PROGRESS_PARAM	20
+
+/* ----------
+ * Shared-memory data structures
+ * ----------
+ */
+
+
+/*
+ * PgBackendSSLStatus
+ *
+ * For each backend, we keep the SSL status in a separate struct, that
+ * is only filled in if SSL is enabled.
+ *
+ * All char arrays must be null-terminated.
+ */
+typedef struct PgBackendSSLStatus
+{
+	/* Information about SSL connection */
+	int			ssl_bits;
+	bool		ssl_compression;
+	char		ssl_version[NAMEDATALEN];
+	char		ssl_cipher[NAMEDATALEN];
+	char		ssl_client_dn[NAMEDATALEN];
+
+	/*
+	 * serial number is max "20 octets" per RFC 5280, so this size should be
+	 * fine
+	 */
+	char		ssl_client_serial[NAMEDATALEN];
+
+	char		ssl_issuer_dn[NAMEDATALEN];
+} PgBackendSSLStatus;
+
+/*
+ * PgBackendGSSStatus
+ *
+ * For each backend, we keep the GSS status in a separate struct, that
+ * is only filled in if GSS is enabled.
+ *
+ * All char arrays must be null-terminated.
+ */
+typedef struct PgBackendGSSStatus
+{
+	/* Information about GSSAPI connection */
+	char		gss_princ[NAMEDATALEN]; /* GSSAPI Principal used to auth */
+	bool		gss_auth;		/* If GSSAPI authentication was used */
+	bool		gss_enc;		/* If encryption is being used */
+
+} PgBackendGSSStatus;
+
+
+/* ----------
+ * PgBackendStatus
+ *
+ * Each live backend maintains a PgBackendStatus struct in shared memory
+ * showing its current activity.  (The structs are allocated according to
+ * BackendId, but that is not critical.)  Note that the collector process
+ * has no involvement in, or even access to, these structs.
+ *
+ * Each auxiliary process also maintains a PgBackendStatus struct in shared
+ * memory.
+ * ----------
+ */
+typedef struct PgBackendStatus
+{
+	/*
+	 * To avoid locking overhead, we use the following protocol: a backend
+	 * increments st_changecount before modifying its entry, and again after
+	 * finishing a modification.  A would-be reader should note the value of
+	 * st_changecount, copy the entry into private memory, then check
+	 * st_changecount again.  If the value hasn't changed, and if it's even,
+	 * the copy is valid; otherwise start over.  This makes updates cheap
+	 * while reads are potentially expensive, but that's the tradeoff we want.
+	 *
+	 * The above protocol needs memory barriers to ensure that the apparent
+	 * order of execution is as it desires.  Otherwise, for example, the CPU
+	 * might rearrange the code so that st_changecount is incremented twice
+	 * before the modification on a machine with weak memory ordering.  Hence,
+	 * use the macros defined below for manipulating st_changecount, rather
+	 * than touching it directly.
+	 */
+	int			st_changecount;
+
+	/* The entry is valid iff st_procpid > 0, unused if st_procpid == 0 */
+	int			st_procpid;
+
+	/* Type of backends */
+	BackendType st_backendType;
+
+	/* Times when current backend, transaction, and activity started */
+	TimestampTz st_proc_start_timestamp;
+	TimestampTz st_xact_start_timestamp;
+	TimestampTz st_activity_start_timestamp;
+	TimestampTz st_state_start_timestamp;
+
+	/* Database OID, owning user's OID, connection client address */
+	Oid			st_databaseid;
+	Oid			st_userid;
+	SockAddr	st_clientaddr;
+	char	   *st_clienthostname;	/* MUST be null-terminated */
+
+	/* Information about SSL connection */
+	bool		st_ssl;
+	PgBackendSSLStatus *st_sslstatus;
+
+	/* Information about GSSAPI connection */
+	bool		st_gss;
+	PgBackendGSSStatus *st_gssstatus;
+
+	/* current state */
+	BackendState st_state;
+
+	/* application name; MUST be null-terminated */
+	char	   *st_appname;
+
+	/*
+	 * Current command string; MUST be null-terminated. Note that this string
+	 * possibly is truncated in the middle of a multi-byte character. As
+	 * activity strings are stored more frequently than read, that allows to
+	 * move the cost of correct truncation to the display side. Use
+	 * pgstat_clip_activity() to truncate correctly.
+	 */
+	char	   *st_activity_raw;
+
+	/*
+	 * Command progress reporting.  Any command which wishes can advertise
+	 * that it is running by setting st_progress_command,
+	 * st_progress_command_target, and st_progress_param[].
+	 * st_progress_command_target should be the OID of the relation which the
+	 * command targets (we assume there's just one, as this is meant for
+	 * utility commands), but the meaning of each element in the
+	 * st_progress_param array is command-specific.
+	 */
+	ProgressCommandType st_progress_command;
+	Oid			st_progress_command_target;
+	int64		st_progress_param[PGSTAT_NUM_PROGRESS_PARAM];
+} PgBackendStatus;
+
+/*
+ * Macros to load and store st_changecount with appropriate memory barriers.
+ *
+ * Use PGSTAT_BEGIN_WRITE_ACTIVITY() before, and PGSTAT_END_WRITE_ACTIVITY()
+ * after, modifying the current process's PgBackendStatus data.  Note that,
+ * since there is no mechanism for cleaning up st_changecount after an error,
+ * THESE MACROS FORM A CRITICAL SECTION.  Any error between them will be
+ * promoted to PANIC, causing a database restart to clean up shared memory!
+ * Hence, keep the critical section as short and straight-line as possible.
+ * Aside from being safer, that minimizes the window in which readers will
+ * have to loop.
+ *
+ * Reader logic should follow this sketch:
+ *
+ *		for (;;)
+ *		{
+ *			int before_ct, after_ct;
+ *
+ *			pgstat_begin_read_activity(beentry, before_ct);
+ *			... copy beentry data to local memory ...
+ *			pgstat_end_read_activity(beentry, after_ct);
+ *			if (pgstat_read_activity_complete(before_ct, after_ct))
+ *				break;
+ *			CHECK_FOR_INTERRUPTS();
+ *		}
+ *
+ * For extra safety, we generally use volatile beentry pointers, although
+ * the memory barriers should theoretically be sufficient.
+ */
+#define PGSTAT_BEGIN_WRITE_ACTIVITY(beentry) \
+	do { \
+		START_CRIT_SECTION(); \
+		(beentry)->st_changecount++; \
+		pg_write_barrier(); \
+	} while (0)
+
+#define PGSTAT_END_WRITE_ACTIVITY(beentry) \
+	do { \
+		pg_write_barrier(); \
+		(beentry)->st_changecount++; \
+		Assert(((beentry)->st_changecount & 1) == 0); \
+		END_CRIT_SECTION(); \
+	} while (0)
+
+#define pgstat_begin_read_activity(beentry, before_changecount) \
+	do { \
+		(before_changecount) = (beentry)->st_changecount; \
+		pg_read_barrier(); \
+	} while (0)
+
+#define pgstat_end_read_activity(beentry, after_changecount) \
+	do { \
+		pg_read_barrier(); \
+		(after_changecount) = (beentry)->st_changecount; \
+	} while (0)
+
+#define pgstat_read_activity_complete(before_changecount, after_changecount) \
+	((before_changecount) == (after_changecount) && \
+	 ((before_changecount) & 1) == 0)
+
+
+/* ----------
+ * LocalPgBackendStatus
+ *
+ * When we build the backend status array, we use LocalPgBackendStatus to be
+ * able to add new values to the struct when needed without adding new fields
+ * to the shared memory. It contains the backend status as a first member.
+ * ----------
+ */
+typedef struct LocalPgBackendStatus
+{
+	/*
+	 * Local version of the backend status entry.
+	 */
+	PgBackendStatus backendStatus;
+
+	/*
+	 * The xid of the current transaction if available, InvalidTransactionId
+	 * if not.
+	 */
+	TransactionId backend_xid;
+
+	/*
+	 * The xmin of the current session if available, InvalidTransactionId if
+	 * not.
+	 */
+	TransactionId backend_xmin;
+} LocalPgBackendStatus;
+
+/*
+ * Working state needed to accumulate per-function-call timing statistics.
+ */
+typedef struct PgStat_FunctionCallUsage
+{
+	/* Link to function's hashtable entry (must still be there at exit!) */
+	/* NULL means we are not tracking the current function call */
+	PgStat_FunctionCounts *fs;
+	/* Total time previously charged to function, as of function start */
+	instr_time	save_f_total_time;
+	/* Backend-wide total time as of function start */
+	instr_time	save_total;
+	/* system clock as of function start */
+	instr_time	f_start;
+} PgStat_FunctionCallUsage;
+
+
+/* ----------
+ * GUC parameters
+ * ----------
+ */
+extern PGDLLIMPORT bool pgstat_track_activities;
+extern PGDLLIMPORT bool pgstat_track_counts;
+extern PGDLLIMPORT int pgstat_track_functions;
+extern PGDLLIMPORT int pgstat_track_activity_query_size;
+extern char *pgstat_stat_directory;
+extern char *pgstat_stat_tmpname;
+extern char *pgstat_stat_filename;
+
+/*
+ * BgWriter statistics counters are updated directly by bgwriter and bufmgr
+ */
+extern PgStat_MsgBgWriter BgWriterStats;
+
+/*
+ * Updated by pgstat_count_buffer_*_time macros
+ */
+extern PgStat_Counter pgStatBlockReadTime;
+extern PgStat_Counter pgStatBlockWriteTime;
+
+/* ----------
+ * Functions called from postmaster
+ * ----------
+ */
+extern Size BackendStatusShmemSize(void);
+extern void CreateSharedBackendStatus(void);
+
+extern void pgstat_init(void);
+extern int	pgstat_start(void);
+extern void pgstat_reset_all(void);
+extern void allow_immediate_pgstat_restart(void);
+
+#ifdef EXEC_BACKEND
+extern void PgstatCollectorMain(int argc, char *argv[]) pg_attribute_noreturn();
+#endif
+
+
+/* ----------
+ * Functions called from backends
+ * ----------
+ */
+extern void pgstat_ping(void);
+
+extern void pgstat_report_stat(bool force);
+extern void pgstat_vacuum_stat(void);
+extern void pgstat_drop_database(Oid databaseid);
+
+extern void pgstat_clear_snapshot(void);
+extern void pgstat_reset_counters(void);
+extern void pgstat_reset_shared_counters(const char *);
+extern void pgstat_reset_single_counter(Oid objectid, PgStat_Single_Reset_Type type);
+extern void pgstat_reset_slru_counter(const char *);
+
+extern void pgstat_report_autovac(Oid dboid);
+extern void pgstat_report_vacuum(Oid tableoid, bool shared,
+								 PgStat_Counter livetuples, PgStat_Counter deadtuples);
+extern void pgstat_report_analyze(Relation rel,
+								  PgStat_Counter livetuples, PgStat_Counter deadtuples,
+								  bool resetcounter);
+
+extern void pgstat_report_recovery_conflict(int reason);
+extern void pgstat_report_deadlock(void);
+extern void pgstat_report_checksum_failures_in_db(Oid dboid, int failurecount);
+extern void pgstat_report_checksum_failure(void);
+
+extern void pgstat_initialize(void);
+extern void pgstat_bestart(void);
+
+extern void pgstat_report_activity(BackendState state, const char *cmd_str);
+extern void pgstat_report_tempfile(size_t filesize);
+extern void pgstat_report_appname(const char *appname);
+extern void pgstat_report_xact_timestamp(TimestampTz tstamp);
+extern const char *pgstat_get_wait_event(uint32 wait_event_info);
+extern const char *pgstat_get_wait_event_type(uint32 wait_event_info);
+extern const char *pgstat_get_backend_current_activity(int pid, bool checkUser);
+extern const char *pgstat_get_crashed_backend_activity(int pid, char *buffer,
+													   int buflen);
+
+extern void pgstat_progress_start_command(ProgressCommandType cmdtype,
+										  Oid relid);
+extern void pgstat_progress_update_param(int index, int64 val);
+extern void pgstat_progress_update_multi_param(int nparam, const int *index,
+											   const int64 *val);
+extern void pgstat_progress_end_command(void);
+
+extern PgStat_TableStatus *find_tabstat_entry(Oid rel_id);
+extern PgStat_BackendFunctionEntry *find_funcstat_entry(Oid func_id);
+
+extern void pgstat_initstats(Relation rel);
+
+extern char *pgstat_clip_activity(const char *raw_activity);
+
+/* ----------
+ * pgstat_report_wait_start() -
+ *
+ *	Called from places where server process needs to wait.  This is called
+ *	to report wait event information.  The wait information is stored
+ *	as 4-bytes where first byte represents the wait event class (type of
+ *	wait, for different types of wait, refer WaitClass) and the next
+ *	3-bytes represent the actual wait event.  Currently 2-bytes are used
+ *	for wait event which is sufficient for current usage, 1-byte is
+ *	reserved for future usage.
+ *
+ * NB: this *must* be able to survive being called before MyProc has been
+ * initialized.
+ * ----------
+ */
+static inline void
+pgstat_report_wait_start(uint32 wait_event_info)
+{
+	volatile PGPROC *proc = MyProc;
+
+	if (!pgstat_track_activities || !proc)
+		return;
+
+	/*
+	 * Since this is a four-byte field which is always read and written as
+	 * four-bytes, updates are atomic.
+	 */
+	proc->wait_event_info = wait_event_info;
+}
+
+/* ----------
+ * pgstat_report_wait_end() -
+ *
+ *	Called to report end of a wait.
+ *
+ * NB: this *must* be able to survive being called before MyProc has been
+ * initialized.
+ * ----------
+ */
+static inline void
+pgstat_report_wait_end(void)
+{
+	volatile PGPROC *proc = MyProc;
+
+	if (!pgstat_track_activities || !proc)
+		return;
+
+	/*
+	 * Since this is a four-byte field which is always read and written as
+	 * four-bytes, updates are atomic.
+	 */
+	proc->wait_event_info = 0;
+}
+
+/* nontransactional event counts are simple enough to inline */
+
+#define pgstat_count_heap_scan(rel)									\
+	do {															\
+		if ((rel)->pgstat_info != NULL)								\
+			(rel)->pgstat_info->t_counts.t_numscans++;				\
+	} while (0)
+#define pgstat_count_heap_getnext(rel)								\
+	do {															\
+		if ((rel)->pgstat_info != NULL)								\
+			(rel)->pgstat_info->t_counts.t_tuples_returned++;		\
+	} while (0)
+#define pgstat_count_heap_fetch(rel)								\
+	do {															\
+		if ((rel)->pgstat_info != NULL)								\
+			(rel)->pgstat_info->t_counts.t_tuples_fetched++;		\
+	} while (0)
+#define pgstat_count_index_scan(rel)								\
+	do {															\
+		if ((rel)->pgstat_info != NULL)								\
+			(rel)->pgstat_info->t_counts.t_numscans++;				\
+	} while (0)
+#define pgstat_count_index_tuples(rel, n)							\
+	do {															\
+		if ((rel)->pgstat_info != NULL)								\
+			(rel)->pgstat_info->t_counts.t_tuples_returned += (n);	\
+	} while (0)
+#define pgstat_count_buffer_read(rel)								\
+	do {															\
+		if ((rel)->pgstat_info != NULL)								\
+			(rel)->pgstat_info->t_counts.t_blocks_fetched++;		\
+	} while (0)
+#define pgstat_count_buffer_hit(rel)								\
+	do {															\
+		if ((rel)->pgstat_info != NULL)								\
+			(rel)->pgstat_info->t_counts.t_blocks_hit++;			\
+	} while (0)
+#define pgstat_count_buffer_read_time(n)							\
+	(pgStatBlockReadTime += (n))
+#define pgstat_count_buffer_write_time(n)							\
+	(pgStatBlockWriteTime += (n))
+
+extern void pgstat_count_heap_insert(Relation rel, PgStat_Counter n);
+extern void pgstat_count_heap_update(Relation rel, bool hot);
+extern void pgstat_count_heap_delete(Relation rel);
+extern void pgstat_count_truncate(Relation rel);
+extern void pgstat_update_heap_dead_tuples(Relation rel, int delta);
+
+struct FunctionCallInfoBaseData;
+extern void pgstat_init_function_usage(struct FunctionCallInfoBaseData *fcinfo,
+									   PgStat_FunctionCallUsage *fcu);
+extern void pgstat_end_function_usage(PgStat_FunctionCallUsage *fcu,
+									  bool finalize);
+
+extern void AtEOXact_PgStat(bool isCommit, bool parallel);
+extern void AtEOSubXact_PgStat(bool isCommit, int nestDepth);
+
+extern void AtPrepare_PgStat(void);
+extern void PostPrepare_PgStat(void);
+
+extern void pgstat_twophase_postcommit(TransactionId xid, uint16 info,
+									   void *recdata, uint32 len);
+extern void pgstat_twophase_postabort(TransactionId xid, uint16 info,
+									  void *recdata, uint32 len);
+
+extern void pgstat_send_archiver(const char *xlog, bool failed);
+extern void pgstat_send_bgwriter(void);
+
+/* ----------
+ * Support functions for the SQL-callable functions to
+ * generate the pgstat* views.
+ * ----------
+ */
+extern PgStat_StatDBEntry *pgstat_fetch_stat_dbentry(Oid dbid);
+extern PgStat_StatTabEntry *pgstat_fetch_stat_tabentry(Oid relid);
+extern PgBackendStatus *pgstat_fetch_stat_beentry(int beid);
+extern LocalPgBackendStatus *pgstat_fetch_stat_local_beentry(int beid);
+extern PgStat_StatFuncEntry *pgstat_fetch_stat_funcentry(Oid funcid);
+extern int	pgstat_fetch_stat_numbackends(void);
+extern PgStat_ArchiverStats *pgstat_fetch_stat_archiver(void);
+extern PgStat_GlobalStats *pgstat_fetch_global(void);
+extern PgStat_SLRUStats *pgstat_fetch_slru(void);
+
+extern void pgstat_count_slru_page_zeroed(int slru_idx);
+extern void pgstat_count_slru_page_hit(int slru_idx);
+extern void pgstat_count_slru_page_read(int slru_idx);
+extern void pgstat_count_slru_page_written(int slru_idx);
+extern void pgstat_count_slru_page_exists(int slru_idx);
+extern void pgstat_count_slru_flush(int slru_idx);
+extern void pgstat_count_slru_truncate(int slru_idx);
+extern const char *pgstat_slru_name(int slru_idx);
+extern int	pgstat_slru_index(const char *name);
+
+#endif							/* PGSTAT_H */
diff --git a/contrib/libs/postgresql/src/include/pgtar.h b/contrib/libs/postgresql/src/include/pgtar.h
new file mode 100644
index 0000000000..0a875903a7
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/pgtar.h
@@ -0,0 +1,26 @@
+/*-------------------------------------------------------------------------
+ *
+ * pgtar.h
+ *	  Functions for manipulating tarfile datastructures (src/port/tar.c)
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/pgtar.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+enum tarError
+{
+	TAR_OK = 0,
+	TAR_NAME_TOO_LONG,
+	TAR_SYMLINK_TOO_LONG
+};
+
+extern enum tarError tarCreateHeader(char *h, const char *filename, const char *linktarget,
+									 pgoff_t size, mode_t mode, uid_t uid, gid_t gid, time_t mtime);
+extern uint64 read_tar_number(const char *s, int len);
+extern void print_tar_number(char *s, int len, uint64 val);
+extern int	tarChecksum(char *header);
diff --git a/contrib/libs/postgresql/src/include/pgtime.h b/contrib/libs/postgresql/src/include/pgtime.h
new file mode 100644
index 0000000000..0fc76d0e60
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/pgtime.h
@@ -0,0 +1,84 @@
+/*-------------------------------------------------------------------------
+ *
+ * pgtime.h
+ *	  PostgreSQL internal timezone library
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ *	  src/include/pgtime.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef _PGTIME_H
+#define _PGTIME_H
+
+
+/*
+ * The API of this library is generally similar to the corresponding
+ * C library functions, except that we use pg_time_t which (we hope) is
+ * 64 bits wide, and which is most definitely signed not unsigned.
+ */
+
+typedef int64 pg_time_t;
+
+struct pg_tm
+{
+	int			tm_sec;
+	int			tm_min;
+	int			tm_hour;
+	int			tm_mday;
+	int			tm_mon;			/* origin 1, not 0! */
+	int			tm_year;		/* relative to 1900 */
+	int			tm_wday;
+	int			tm_yday;
+	int			tm_isdst;
+	long int	tm_gmtoff;
+	const char *tm_zone;
+};
+
+typedef struct pg_tz pg_tz;
+typedef struct pg_tzenum pg_tzenum;
+
+/* Maximum length of a timezone name (not including trailing null) */
+#define TZ_STRLEN_MAX 255
+
+/* these functions are in localtime.c */
+
+extern struct pg_tm *pg_localtime(const pg_time_t *timep, const pg_tz *tz);
+extern struct pg_tm *pg_gmtime(const pg_time_t *timep);
+extern int	pg_next_dst_boundary(const pg_time_t *timep,
+								 long int *before_gmtoff,
+								 int *before_isdst,
+								 pg_time_t *boundary,
+								 long int *after_gmtoff,
+								 int *after_isdst,
+								 const pg_tz *tz);
+extern bool pg_interpret_timezone_abbrev(const char *abbrev,
+										 const pg_time_t *timep,
+										 long int *gmtoff,
+										 int *isdst,
+										 const pg_tz *tz);
+extern bool pg_get_timezone_offset(const pg_tz *tz, long int *gmtoff);
+extern const char *pg_get_timezone_name(pg_tz *tz);
+extern bool pg_tz_acceptable(pg_tz *tz);
+
+/* these functions are in strftime.c */
+
+extern size_t pg_strftime(char *s, size_t max, const char *format,
+						  const struct pg_tm *tm);
+
+/* these functions and variables are in pgtz.c */
+
+extern PGDLLIMPORT pg_tz *session_timezone;
+extern pg_tz *log_timezone;
+
+extern void pg_timezone_initialize(void);
+extern pg_tz *pg_tzset(const char *tzname);
+extern pg_tz *pg_tzset_offset(long gmtoffset);
+
+extern pg_tzenum *pg_tzenumerate_start(void);
+extern pg_tz *pg_tzenumerate_next(pg_tzenum *dir);
+extern void pg_tzenumerate_end(pg_tzenum *dir);
+
+#endif							/* _PGTIME_H */
diff --git a/contrib/libs/postgresql/src/include/port.h b/contrib/libs/postgresql/src/include/port.h
new file mode 100644
index 0000000000..d4c94a4411
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/port.h
@@ -0,0 +1,528 @@
+/*-------------------------------------------------------------------------
+ *
+ * port.h
+ *	  Header for src/port/ compatibility functions.
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/port.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_PORT_H
+#define PG_PORT_H
+
+#include <ctype.h>
+#include <netdb.h>
+#include <pwd.h>
+
+/*
+ * Windows has enough specialized port stuff that we push most of it off
+ * into another file.
+ * Note: Some CYGWIN includes might #define WIN32.
+ */
+#if defined(WIN32) && !defined(__CYGWIN__)
+#include "port/win32_port.h"
+#endif
+
+/* socket has a different definition on WIN32 */
+#ifndef WIN32
+typedef int pgsocket;
+
+#define PGINVALID_SOCKET (-1)
+#else
+typedef SOCKET pgsocket;
+
+#define PGINVALID_SOCKET INVALID_SOCKET
+#endif
+
+/* non-blocking */
+extern bool pg_set_noblock(pgsocket sock);
+extern bool pg_set_block(pgsocket sock);
+
+/* Portable path handling for Unix/Win32 (in path.c) */
+
+extern bool has_drive_prefix(const char *filename);
+extern char *first_dir_separator(const char *filename);
+extern char *last_dir_separator(const char *filename);
+extern char *first_path_var_separator(const char *pathlist);
+extern void join_path_components(char *ret_path,
+								 const char *head, const char *tail);
+extern void canonicalize_path(char *path);
+extern void make_native_path(char *path);
+extern void cleanup_path(char *path);
+extern bool path_contains_parent_reference(const char *path);
+extern bool path_is_relative_and_below_cwd(const char *path);
+extern bool path_is_prefix_of_path(const char *path1, const char *path2);
+extern char *make_absolute_path(const char *path);
+extern const char *get_progname(const char *argv0);
+extern void get_share_path(const char *my_exec_path, char *ret_path);
+extern void get_etc_path(const char *my_exec_path, char *ret_path);
+extern void get_include_path(const char *my_exec_path, char *ret_path);
+extern void get_pkginclude_path(const char *my_exec_path, char *ret_path);
+extern void get_includeserver_path(const char *my_exec_path, char *ret_path);
+extern void get_lib_path(const char *my_exec_path, char *ret_path);
+extern void get_pkglib_path(const char *my_exec_path, char *ret_path);
+extern void get_locale_path(const char *my_exec_path, char *ret_path);
+extern void get_doc_path(const char *my_exec_path, char *ret_path);
+extern void get_html_path(const char *my_exec_path, char *ret_path);
+extern void get_man_path(const char *my_exec_path, char *ret_path);
+extern bool get_home_path(char *ret_path);
+extern void get_parent_directory(char *path);
+
+/* common/pgfnames.c */
+extern char **pgfnames(const char *path);
+extern void pgfnames_cleanup(char **filenames);
+
+/*
+ *	is_absolute_path
+ *
+ *	By making this a macro we avoid needing to include path.c in libpq.
+ */
+#ifndef WIN32
+#define IS_DIR_SEP(ch)	((ch) == '/')
+
+#define is_absolute_path(filename) \
+( \
+	IS_DIR_SEP((filename)[0]) \
+)
+#else
+#define IS_DIR_SEP(ch)	((ch) == '/' || (ch) == '\\')
+
+/* See path_is_relative_and_below_cwd() for how we handle 'E:abc'. */
+#define is_absolute_path(filename) \
+( \
+	IS_DIR_SEP((filename)[0]) || \
+	(isalpha((unsigned char) ((filename)[0])) && (filename)[1] == ':' && \
+	 IS_DIR_SEP((filename)[2])) \
+)
+#endif
+
+/* Portable locale initialization (in exec.c) */
+extern void set_pglocale_pgservice(const char *argv0, const char *app);
+
+/* Portable way to find and execute binaries (in exec.c) */
+extern int	find_my_exec(const char *argv0, char *retpath);
+extern int	find_other_exec(const char *argv0, const char *target,
+							const char *versionstr, char *retpath);
+extern char *pipe_read_line(char *cmd, char *line, int maxsize);
+
+/* Doesn't belong here, but this is used with find_other_exec(), so... */
+#define PG_BACKEND_VERSIONSTR "postgres (PostgreSQL) " PG_VERSION "\n"
+
+
+#if defined(WIN32) || defined(__CYGWIN__)
+#define EXE ".exe"
+#else
+#define EXE ""
+#endif
+
+#if defined(WIN32) && !defined(__CYGWIN__)
+#define DEVNULL "nul"
+#else
+#define DEVNULL "/dev/null"
+#endif
+
+/* Portable delay handling */
+extern void pg_usleep(long microsec);
+
+/* Portable SQL-like case-independent comparisons and conversions */
+extern int	pg_strcasecmp(const char *s1, const char *s2);
+extern int	pg_strncasecmp(const char *s1, const char *s2, size_t n);
+extern unsigned char pg_toupper(unsigned char ch);
+extern unsigned char pg_tolower(unsigned char ch);
+extern unsigned char pg_ascii_toupper(unsigned char ch);
+extern unsigned char pg_ascii_tolower(unsigned char ch);
+
+/*
+ * Beginning in v12, we always replace snprintf() and friends with our own
+ * implementation.  This symbol is no longer consulted by the core code,
+ * but keep it defined anyway in case any extensions are looking at it.
+ */
+#define USE_REPL_SNPRINTF 1
+
+/*
+ * Versions of libintl >= 0.13 try to replace printf() and friends with
+ * macros to their own versions that understand the %$ format.  We do the
+ * same, so disable their macros, if they exist.
+ */
+#ifdef vsnprintf
+#undef vsnprintf
+#endif
+#ifdef snprintf
+#undef snprintf
+#endif
+#ifdef vsprintf
+#undef vsprintf
+#endif
+#ifdef sprintf
+#undef sprintf
+#endif
+#ifdef vfprintf
+#undef vfprintf
+#endif
+#ifdef fprintf
+#undef fprintf
+#endif
+#ifdef vprintf
+#undef vprintf
+#endif
+#ifdef printf
+#undef printf
+#endif
+
+extern int	pg_vsnprintf(char *str, size_t count, const char *fmt, va_list args);
+extern int	pg_snprintf(char *str, size_t count, const char *fmt,...) pg_attribute_printf(3, 4);
+extern int	pg_vsprintf(char *str, const char *fmt, va_list args);
+extern int	pg_sprintf(char *str, const char *fmt,...) pg_attribute_printf(2, 3);
+extern int	pg_vfprintf(FILE *stream, const char *fmt, va_list args);
+extern int	pg_fprintf(FILE *stream, const char *fmt,...) pg_attribute_printf(2, 3);
+extern int	pg_vprintf(const char *fmt, va_list args);
+extern int	pg_printf(const char *fmt,...) pg_attribute_printf(1, 2);
+
+/*
+ * We use __VA_ARGS__ for printf to prevent replacing references to
+ * the "printf" format archetype in format() attribute declarations.
+ * That unfortunately means that taking a function pointer to printf
+ * will not do what we'd wish.  (If you need to do that, you must name
+ * pg_printf explicitly.)  For printf's sibling functions, use
+ * parameterless macros so that function pointers will work unsurprisingly.
+ */
+#define vsnprintf		pg_vsnprintf
+#define snprintf		pg_snprintf
+#define vsprintf		pg_vsprintf
+#define sprintf			pg_sprintf
+#define vfprintf		pg_vfprintf
+#define fprintf			pg_fprintf
+#define vprintf			pg_vprintf
+#define printf(...)		pg_printf(__VA_ARGS__)
+
+/* This is also provided by snprintf.c */
+extern int	pg_strfromd(char *str, size_t count, int precision, double value);
+
+/* Replace strerror() with our own, somewhat more robust wrapper */
+extern char *pg_strerror(int errnum);
+#define strerror pg_strerror
+
+/* Likewise for strerror_r(); note we prefer the GNU API for that */
+extern char *pg_strerror_r(int errnum, char *buf, size_t buflen);
+#define strerror_r pg_strerror_r
+#define PG_STRERROR_R_BUFLEN 256	/* Recommended buffer size for strerror_r */
+
+/* Wrap strsignal(), or provide our own version if necessary */
+extern const char *pg_strsignal(int signum);
+
+/* Portable prompt handling */
+extern void simple_prompt(const char *prompt, char *destination, size_t destlen,
+						  bool echo);
+
+extern int	pclose_check(FILE *stream);
+
+/* Global variable holding time zone information. */
+#if defined(WIN32) || defined(__CYGWIN__)
+#define TIMEZONE_GLOBAL _timezone
+#define TZNAME_GLOBAL _tzname
+#else
+#define TIMEZONE_GLOBAL timezone
+#define TZNAME_GLOBAL tzname
+#endif
+
+#if defined(WIN32) || defined(__CYGWIN__)
+/*
+ *	Win32 doesn't have reliable rename/unlink during concurrent access.
+ */
+extern int	pgrename(const char *from, const char *to);
+extern int	pgunlink(const char *path);
+
+/* Include this first so later includes don't see these defines */
+#ifdef _MSC_VER
+#include <io.h>
+#endif
+
+#define rename(from, to)		pgrename(from, to)
+#define unlink(path)			pgunlink(path)
+#endif							/* defined(WIN32) || defined(__CYGWIN__) */
+
+/*
+ *	Win32 also doesn't have symlinks, but we can emulate them with
+ *	junction points on newer Win32 versions.
+ *
+ *	Cygwin has its own symlinks which work on Win95/98/ME where
+ *	junction points don't, so use those instead.  We have no way of
+ *	knowing what type of system Cygwin binaries will be run on.
+ *		Note: Some CYGWIN includes might #define WIN32.
+ */
+#if defined(WIN32) && !defined(__CYGWIN__)
+extern int	pgsymlink(const char *oldpath, const char *newpath);
+extern int	pgreadlink(const char *path, char *buf, size_t size);
+extern bool pgwin32_is_junction(const char *path);
+
+#define symlink(oldpath, newpath)	pgsymlink(oldpath, newpath)
+#define readlink(path, buf, size)	pgreadlink(path, buf, size)
+#endif
+
+extern bool rmtree(const char *path, bool rmtopdir);
+
+#if defined(WIN32) && !defined(__CYGWIN__)
+
+/*
+ * open() and fopen() replacements to allow deletion of open files and
+ * passing of other special options.
+ */
+#define		O_DIRECT	0x80000000
+extern int	pgwin32_open(const char *, int,...);
+extern FILE *pgwin32_fopen(const char *, const char *);
+#define		open(a,b,c) pgwin32_open(a,b,c)
+#define		fopen(a,b) pgwin32_fopen(a,b)
+
+/*
+ * Mingw-w64 headers #define popen and pclose to _popen and _pclose.  We want
+ * to use our popen wrapper, rather than plain _popen, so override that.  For
+ * consistency, use our version of pclose, too.
+ */
+#ifdef popen
+#undef popen
+#endif
+#ifdef pclose
+#undef pclose
+#endif
+
+/*
+ * system() and popen() replacements to enclose the command in an extra
+ * pair of quotes.
+ */
+extern int	pgwin32_system(const char *command);
+extern FILE *pgwin32_popen(const char *command, const char *type);
+
+#define system(a) pgwin32_system(a)
+#define popen(a,b) pgwin32_popen(a,b)
+#define pclose(a) _pclose(a)
+
+/* New versions of MingW have gettimeofday, old mingw and msvc don't */
+#ifndef HAVE_GETTIMEOFDAY
+/* Last parameter not used */
+extern int	gettimeofday(struct timeval *tp, struct timezone *tzp);
+#endif
+#else							/* !WIN32 */
+
+/*
+ *	Win32 requires a special close for sockets and pipes, while on Unix
+ *	close() does them all.
+ */
+#define closesocket close
+#endif							/* WIN32 */
+
+/*
+ * On Windows, setvbuf() does not support _IOLBF mode, and interprets that
+ * as _IOFBF.  To add insult to injury, setvbuf(file, NULL, _IOFBF, 0)
+ * crashes outright if "parameter validation" is enabled.  Therefore, in
+ * places where we'd like to select line-buffered mode, we fall back to
+ * unbuffered mode instead on Windows.  Always use PG_IOLBF not _IOLBF
+ * directly in order to implement this behavior.
+ */
+#ifndef WIN32
+#define PG_IOLBF	_IOLBF
+#else
+#define PG_IOLBF	_IONBF
+#endif
+
+/*
+ * Default "extern" declarations or macro substitutes for library routines.
+ * When necessary, these routines are provided by files in src/port/.
+ */
+
+/* Type to use with fseeko/ftello */
+#ifndef WIN32					/* WIN32 is handled in port/win32_port.h */
+#define pgoff_t off_t
+#endif
+
+extern double pg_erand48(unsigned short xseed[3]);
+extern long pg_lrand48(void);
+extern long pg_jrand48(unsigned short xseed[3]);
+extern void pg_srand48(long seed);
+
+#ifndef HAVE_FLS
+extern int	fls(int mask);
+#endif
+
+#ifndef HAVE_GETPEEREID
+/* On Windows, Perl might have incompatible definitions of uid_t and gid_t. */
+#ifndef PLPERL_HAVE_UID_GID
+extern int	getpeereid(int sock, uid_t *uid, gid_t *gid);
+#endif
+#endif
+
+/*
+ * Glibc doesn't use the builtin for clang due to a *gcc* bug in a version
+ * newer than the gcc compatibility clang claims to have. This would cause a
+ * *lot* of superfluous function calls, therefore revert when using clang. In
+ * C++ there's issues with libc++ (not libstdc++), so disable as well.
+ */
+#if defined(__clang__) && !defined(__cplusplus)
+/* needs to be separate to not confuse other compilers */
+#if __has_builtin(__builtin_isinf)
+/* need to include before, to avoid getting overwritten */
+#include <math.h>
+#undef isinf
+#define isinf __builtin_isinf
+#endif							/* __has_builtin(isinf) */
+#endif							/* __clang__ && !__cplusplus */
+
+#ifndef HAVE_EXPLICIT_BZERO
+extern void explicit_bzero(void *buf, size_t len);
+#endif
+
+#ifndef HAVE_STRTOF
+extern float strtof(const char *nptr, char **endptr);
+#endif
+
+#ifdef HAVE_BUGGY_STRTOF
+extern float pg_strtof(const char *nptr, char **endptr);
+#define strtof(a,b) (pg_strtof((a),(b)))
+#endif
+
+#ifndef HAVE_LINK
+extern int	link(const char *src, const char *dst);
+#endif
+
+#ifndef HAVE_MKDTEMP
+extern char *mkdtemp(char *path);
+#endif
+
+#ifndef HAVE_INET_ATON
+#include <netinet/in.h>
+#include <arpa/inet.h>
+extern int	inet_aton(const char *cp, struct in_addr *addr);
+#endif
+
+/*
+ * Windows and older Unix don't have pread(2) and pwrite(2).  We have
+ * replacement functions, but they have slightly different semantics so we'll
+ * use a name with a pg_ prefix to avoid confusion.
+ */
+#ifdef HAVE_PREAD
+#define pg_pread pread
+#else
+extern ssize_t pg_pread(int fd, void *buf, size_t nbyte, off_t offset);
+#endif
+
+#ifdef HAVE_PWRITE
+#define pg_pwrite pwrite
+#else
+extern ssize_t pg_pwrite(int fd, const void *buf, size_t nbyte, off_t offset);
+#endif
+
+#if !HAVE_DECL_STRLCAT
+extern size_t strlcat(char *dst, const char *src, size_t siz);
+#endif
+
+#if !HAVE_DECL_STRLCPY
+extern size_t strlcpy(char *dst, const char *src, size_t siz);
+#endif
+
+#if !HAVE_DECL_STRNLEN
+extern size_t strnlen(const char *str, size_t maxlen);
+#endif
+
+#if !defined(HAVE_RANDOM)
+extern long random(void);
+#endif
+
+#ifndef HAVE_SETENV
+extern int setenv(const char *name, const char *value, int overwrite);
+#endif
+
+#ifndef HAVE_UNSETENV
+extern void unsetenv(const char *name);
+#endif
+
+#ifndef HAVE_SRANDOM
+extern void srandom(unsigned int seed);
+#endif
+
+#ifndef HAVE_DLOPEN
+extern void *dlopen(const char *file, int mode);
+extern void *dlsym(void *handle, const char *symbol);
+extern int	dlclose(void *handle);
+extern char *dlerror(void);
+#endif
+
+/*
+ * In some older systems, the RTLD_NOW flag isn't defined and the mode
+ * argument to dlopen must always be 1.
+ */
+#if !HAVE_DECL_RTLD_NOW
+#define RTLD_NOW 1
+#endif
+
+/*
+ * The RTLD_GLOBAL flag is wanted if available, but it doesn't exist
+ * everywhere.  If it doesn't exist, set it to 0 so it has no effect.
+ */
+#if !HAVE_DECL_RTLD_GLOBAL
+#define RTLD_GLOBAL 0
+#endif
+
+/* thread.h */
+#ifndef WIN32
+extern int	pqGetpwuid(uid_t uid, struct passwd *resultbuf, char *buffer,
+					   size_t buflen, struct passwd **result);
+#endif
+
+extern int	pqGethostbyname(const char *name,
+							struct hostent *resultbuf,
+							char *buffer, size_t buflen,
+							struct hostent **result,
+							int *herrno);
+
+extern void pg_qsort(void *base, size_t nel, size_t elsize,
+					 int (*cmp) (const void *, const void *));
+extern int	pg_qsort_strcmp(const void *a, const void *b);
+
+#define qsort(a,b,c,d) pg_qsort(a,b,c,d)
+
+typedef int (*qsort_arg_comparator) (const void *a, const void *b, void *arg);
+
+extern void qsort_arg(void *base, size_t nel, size_t elsize,
+					  qsort_arg_comparator cmp, void *arg);
+
+/* port/chklocale.c */
+extern int	pg_get_encoding_from_locale(const char *ctype, bool write_message);
+
+#if defined(WIN32) && !defined(FRONTEND)
+extern int	pg_codepage_to_encoding(UINT cp);
+#endif
+
+/* port/inet_net_ntop.c */
+extern char *pg_inet_net_ntop(int af, const void *src, int bits,
+							  char *dst, size_t size);
+
+/* port/pg_strong_random.c */
+extern bool pg_strong_random(void *buf, size_t len);
+
+/*
+ * pg_backend_random used to be a wrapper for pg_strong_random before
+ * Postgres 12 for the backend code.
+ */
+#define pg_backend_random pg_strong_random
+
+/* port/pgcheckdir.c */
+extern int	pg_check_dir(const char *dir);
+
+/* port/pgmkdirp.c */
+extern int	pg_mkdir_p(char *path, int omode);
+
+/* port/pqsignal.c */
+typedef void (*pqsigfunc) (int signo);
+extern pqsigfunc pqsignal(int signo, pqsigfunc func);
+
+/* port/quotes.c */
+extern char *escape_single_quotes_ascii(const char *src);
+
+/* common/wait_error.c */
+extern char *wait_result_to_str(int exit_status);
+extern bool wait_result_is_signal(int exit_status, int signum);
+extern bool wait_result_is_any_signal(int exit_status, bool include_command_not_found);
+
+#endif							/* PG_PORT_H */
diff --git a/contrib/libs/postgresql/src/include/postgres.h b/contrib/libs/postgresql/src/include/postgres.h
new file mode 100644
index 0000000000..c48f47e930
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/postgres.h
@@ -0,0 +1,764 @@
+/*-------------------------------------------------------------------------
+ *
+ * postgres.h
+ *	  Primary include file for PostgreSQL server .c files
+ *
+ * This should be the first file included by PostgreSQL backend modules.
+ * Client-side code should include postgres_fe.h instead.
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1995, Regents of the University of California
+ *
+ * src/include/postgres.h
+ *
+ *-------------------------------------------------------------------------
+ */
+/*
+ *----------------------------------------------------------------
+ *	 TABLE OF CONTENTS
+ *
+ *		When adding stuff to this file, please try to put stuff
+ *		into the relevant section, or add new sections as appropriate.
+ *
+ *	  section	description
+ *	  -------	------------------------------------------------
+ *		1)		variable-length datatypes (TOAST support)
+ *		2)		Datum type + support macros
+ *
+ *	 NOTES
+ *
+ *	In general, this file should contain declarations that are widely needed
+ *	in the backend environment, but are of no interest outside the backend.
+ *
+ *	Simple type definitions live in c.h, where they are shared with
+ *	postgres_fe.h.  We do that since those type definitions are needed by
+ *	frontend modules that want to deal with binary data transmission to or
+ *	from the backend.  Type definitions in this file should be for
+ *	representations that never escape the backend, such as Datum or
+ *	TOASTed varlena objects.
+ *
+ *----------------------------------------------------------------
+ */
+#ifndef POSTGRES_H
+#define POSTGRES_H
+
+#include "c.h"
+#include "utils/elog.h"
+#include "utils/palloc.h"
+
+/* ----------------------------------------------------------------
+ *				Section 1:	variable-length datatypes (TOAST support)
+ * ----------------------------------------------------------------
+ */
+
+/*
+ * struct varatt_external is a traditional "TOAST pointer", that is, the
+ * information needed to fetch a Datum stored out-of-line in a TOAST table.
+ * The data is compressed if and only if va_extsize < va_rawsize - VARHDRSZ.
+ * This struct must not contain any padding, because we sometimes compare
+ * these pointers using memcmp.
+ *
+ * Note that this information is stored unaligned within actual tuples, so
+ * you need to memcpy from the tuple into a local struct variable before
+ * you can look at these fields!  (The reason we use memcmp is to avoid
+ * having to do that just to detect equality of two TOAST pointers...)
+ */
+typedef struct varatt_external
+{
+	int32		va_rawsize;		/* Original data size (includes header) */
+	int32		va_extsize;		/* External saved size (doesn't) */
+	Oid			va_valueid;		/* Unique ID of value within TOAST table */
+	Oid			va_toastrelid;	/* RelID of TOAST table containing it */
+}			varatt_external;
+
+/*
+ * struct varatt_indirect is a "TOAST pointer" representing an out-of-line
+ * Datum that's stored in memory, not in an external toast relation.
+ * The creator of such a Datum is entirely responsible that the referenced
+ * storage survives for as long as referencing pointer Datums can exist.
+ *
+ * Note that just as for struct varatt_external, this struct is stored
+ * unaligned within any containing tuple.
+ */
+typedef struct varatt_indirect
+{
+	struct varlena *pointer;	/* Pointer to in-memory varlena */
+}			varatt_indirect;
+
+/*
+ * struct varatt_expanded is a "TOAST pointer" representing an out-of-line
+ * Datum that is stored in memory, in some type-specific, not necessarily
+ * physically contiguous format that is convenient for computation not
+ * storage.  APIs for this, in particular the definition of struct
+ * ExpandedObjectHeader, are in src/include/utils/expandeddatum.h.
+ *
+ * Note that just as for struct varatt_external, this struct is stored
+ * unaligned within any containing tuple.
+ */
+typedef struct ExpandedObjectHeader ExpandedObjectHeader;
+
+typedef struct varatt_expanded
+{
+	ExpandedObjectHeader *eohptr;
+} varatt_expanded;
+
+/*
+ * Type tag for the various sorts of "TOAST pointer" datums.  The peculiar
+ * value for VARTAG_ONDISK comes from a requirement for on-disk compatibility
+ * with a previous notion that the tag field was the pointer datum's length.
+ */
+typedef enum vartag_external
+{
+	VARTAG_INDIRECT = 1,
+	VARTAG_EXPANDED_RO = 2,
+	VARTAG_EXPANDED_RW = 3,
+	VARTAG_ONDISK = 18
+} vartag_external;
+
+/* this test relies on the specific tag values above */
+#define VARTAG_IS_EXPANDED(tag) \
+	(((tag) & ~1) == VARTAG_EXPANDED_RO)
+
+#define VARTAG_SIZE(tag) \
+	((tag) == VARTAG_INDIRECT ? sizeof(varatt_indirect) : \
+	 VARTAG_IS_EXPANDED(tag) ? sizeof(varatt_expanded) : \
+	 (tag) == VARTAG_ONDISK ? sizeof(varatt_external) : \
+	 TrapMacro(true, "unrecognized TOAST vartag"))
+
+/*
+ * These structs describe the header of a varlena object that may have been
+ * TOASTed.  Generally, don't reference these structs directly, but use the
+ * macros below.
+ *
+ * We use separate structs for the aligned and unaligned cases because the
+ * compiler might otherwise think it could generate code that assumes
+ * alignment while touching fields of a 1-byte-header varlena.
+ */
+typedef union
+{
+	struct						/* Normal varlena (4-byte length) */
+	{
+		uint32		va_header;
+		char		va_data[FLEXIBLE_ARRAY_MEMBER];
+	}			va_4byte;
+	struct						/* Compressed-in-line format */
+	{
+		uint32		va_header;
+		uint32		va_rawsize; /* Original data size (excludes header) */
+		char		va_data[FLEXIBLE_ARRAY_MEMBER]; /* Compressed data */
+	}			va_compressed;
+} varattrib_4b;
+
+typedef struct
+{
+	uint8		va_header;
+	char		va_data[FLEXIBLE_ARRAY_MEMBER]; /* Data begins here */
+} varattrib_1b;
+
+/* TOAST pointers are a subset of varattrib_1b with an identifying tag byte */
+typedef struct
+{
+	uint8		va_header;		/* Always 0x80 or 0x01 */
+	uint8		va_tag;			/* Type of datum */
+	char		va_data[FLEXIBLE_ARRAY_MEMBER]; /* Type-specific data */
+} varattrib_1b_e;
+
+/*
+ * Bit layouts for varlena headers on big-endian machines:
+ *
+ * 00xxxxxx 4-byte length word, aligned, uncompressed data (up to 1G)
+ * 01xxxxxx 4-byte length word, aligned, *compressed* data (up to 1G)
+ * 10000000 1-byte length word, unaligned, TOAST pointer
+ * 1xxxxxxx 1-byte length word, unaligned, uncompressed data (up to 126b)
+ *
+ * Bit layouts for varlena headers on little-endian machines:
+ *
+ * xxxxxx00 4-byte length word, aligned, uncompressed data (up to 1G)
+ * xxxxxx10 4-byte length word, aligned, *compressed* data (up to 1G)
+ * 00000001 1-byte length word, unaligned, TOAST pointer
+ * xxxxxxx1 1-byte length word, unaligned, uncompressed data (up to 126b)
+ *
+ * The "xxx" bits are the length field (which includes itself in all cases).
+ * In the big-endian case we mask to extract the length, in the little-endian
+ * case we shift.  Note that in both cases the flag bits are in the physically
+ * first byte.  Also, it is not possible for a 1-byte length word to be zero;
+ * this lets us disambiguate alignment padding bytes from the start of an
+ * unaligned datum.  (We now *require* pad bytes to be filled with zero!)
+ *
+ * In TOAST pointers the va_tag field (see varattrib_1b_e) is used to discern
+ * the specific type and length of the pointer datum.
+ */
+
+/*
+ * Endian-dependent macros.  These are considered internal --- use the
+ * external macros below instead of using these directly.
+ *
+ * Note: IS_1B is true for external toast records but VARSIZE_1B will return 0
+ * for such records. Hence you should usually check for IS_EXTERNAL before
+ * checking for IS_1B.
+ */
+
+#ifdef WORDS_BIGENDIAN
+
+#define VARATT_IS_4B(PTR) \
+	((((varattrib_1b *) (PTR))->va_header & 0x80) == 0x00)
+#define VARATT_IS_4B_U(PTR) \
+	((((varattrib_1b *) (PTR))->va_header & 0xC0) == 0x00)
+#define VARATT_IS_4B_C(PTR) \
+	((((varattrib_1b *) (PTR))->va_header & 0xC0) == 0x40)
+#define VARATT_IS_1B(PTR) \
+	((((varattrib_1b *) (PTR))->va_header & 0x80) == 0x80)
+#define VARATT_IS_1B_E(PTR) \
+	((((varattrib_1b *) (PTR))->va_header) == 0x80)
+#define VARATT_NOT_PAD_BYTE(PTR) \
+	(*((uint8 *) (PTR)) != 0)
+
+/* VARSIZE_4B() should only be used on known-aligned data */
+#define VARSIZE_4B(PTR) \
+	(((varattrib_4b *) (PTR))->va_4byte.va_header & 0x3FFFFFFF)
+#define VARSIZE_1B(PTR) \
+	(((varattrib_1b *) (PTR))->va_header & 0x7F)
+#define VARTAG_1B_E(PTR) \
+	(((varattrib_1b_e *) (PTR))->va_tag)
+
+#define SET_VARSIZE_4B(PTR,len) \
+	(((varattrib_4b *) (PTR))->va_4byte.va_header = (len) & 0x3FFFFFFF)
+#define SET_VARSIZE_4B_C(PTR,len) \
+	(((varattrib_4b *) (PTR))->va_4byte.va_header = ((len) & 0x3FFFFFFF) | 0x40000000)
+#define SET_VARSIZE_1B(PTR,len) \
+	(((varattrib_1b *) (PTR))->va_header = (len) | 0x80)
+#define SET_VARTAG_1B_E(PTR,tag) \
+	(((varattrib_1b_e *) (PTR))->va_header = 0x80, \
+	 ((varattrib_1b_e *) (PTR))->va_tag = (tag))
+#else							/* !WORDS_BIGENDIAN */
+
+#define VARATT_IS_4B(PTR) \
+	((((varattrib_1b *) (PTR))->va_header & 0x01) == 0x00)
+#define VARATT_IS_4B_U(PTR) \
+	((((varattrib_1b *) (PTR))->va_header & 0x03) == 0x00)
+#define VARATT_IS_4B_C(PTR) \
+	((((varattrib_1b *) (PTR))->va_header & 0x03) == 0x02)
+#define VARATT_IS_1B(PTR) \
+	((((varattrib_1b *) (PTR))->va_header & 0x01) == 0x01)
+#define VARATT_IS_1B_E(PTR) \
+	((((varattrib_1b *) (PTR))->va_header) == 0x01)
+#define VARATT_NOT_PAD_BYTE(PTR) \
+	(*((uint8 *) (PTR)) != 0)
+
+/* VARSIZE_4B() should only be used on known-aligned data */
+#define VARSIZE_4B(PTR) \
+	((((varattrib_4b *) (PTR))->va_4byte.va_header >> 2) & 0x3FFFFFFF)
+#define VARSIZE_1B(PTR) \
+	((((varattrib_1b *) (PTR))->va_header >> 1) & 0x7F)
+#define VARTAG_1B_E(PTR) \
+	(((varattrib_1b_e *) (PTR))->va_tag)
+
+#define SET_VARSIZE_4B(PTR,len) \
+	(((varattrib_4b *) (PTR))->va_4byte.va_header = (((uint32) (len)) << 2))
+#define SET_VARSIZE_4B_C(PTR,len) \
+	(((varattrib_4b *) (PTR))->va_4byte.va_header = (((uint32) (len)) << 2) | 0x02)
+#define SET_VARSIZE_1B(PTR,len) \
+	(((varattrib_1b *) (PTR))->va_header = (((uint8) (len)) << 1) | 0x01)
+#define SET_VARTAG_1B_E(PTR,tag) \
+	(((varattrib_1b_e *) (PTR))->va_header = 0x01, \
+	 ((varattrib_1b_e *) (PTR))->va_tag = (tag))
+#endif							/* WORDS_BIGENDIAN */
+
+#define VARHDRSZ_SHORT			offsetof(varattrib_1b, va_data)
+#define VARATT_SHORT_MAX		0x7F
+#define VARATT_CAN_MAKE_SHORT(PTR) \
+	(VARATT_IS_4B_U(PTR) && \
+	 (VARSIZE(PTR) - VARHDRSZ + VARHDRSZ_SHORT) <= VARATT_SHORT_MAX)
+#define VARATT_CONVERTED_SHORT_SIZE(PTR) \
+	(VARSIZE(PTR) - VARHDRSZ + VARHDRSZ_SHORT)
+
+#define VARHDRSZ_EXTERNAL		offsetof(varattrib_1b_e, va_data)
+
+#define VARDATA_4B(PTR)		(((varattrib_4b *) (PTR))->va_4byte.va_data)
+#define VARDATA_4B_C(PTR)	(((varattrib_4b *) (PTR))->va_compressed.va_data)
+#define VARDATA_1B(PTR)		(((varattrib_1b *) (PTR))->va_data)
+#define VARDATA_1B_E(PTR)	(((varattrib_1b_e *) (PTR))->va_data)
+
+#define VARRAWSIZE_4B_C(PTR) \
+	(((varattrib_4b *) (PTR))->va_compressed.va_rawsize)
+
+/* Externally visible macros */
+
+/*
+ * In consumers oblivious to data alignment, call PG_DETOAST_DATUM_PACKED(),
+ * VARDATA_ANY(), VARSIZE_ANY() and VARSIZE_ANY_EXHDR().  Elsewhere, call
+ * PG_DETOAST_DATUM(), VARDATA() and VARSIZE().  Directly fetching an int16,
+ * int32 or wider field in the struct representing the datum layout requires
+ * aligned data.  memcpy() is alignment-oblivious, as are most operations on
+ * datatypes, such as text, whose layout struct contains only char fields.
+ *
+ * Code assembling a new datum should call VARDATA() and SET_VARSIZE().
+ * (Datums begin life untoasted.)
+ *
+ * Other macros here should usually be used only by tuple assembly/disassembly
+ * code and code that specifically wants to work with still-toasted Datums.
+ */
+#define VARDATA(PTR)						VARDATA_4B(PTR)
+#define VARSIZE(PTR)						VARSIZE_4B(PTR)
+
+#define VARSIZE_SHORT(PTR)					VARSIZE_1B(PTR)
+#define VARDATA_SHORT(PTR)					VARDATA_1B(PTR)
+
+#define VARTAG_EXTERNAL(PTR)				VARTAG_1B_E(PTR)
+#define VARSIZE_EXTERNAL(PTR)				(VARHDRSZ_EXTERNAL + VARTAG_SIZE(VARTAG_EXTERNAL(PTR)))
+#define VARDATA_EXTERNAL(PTR)				VARDATA_1B_E(PTR)
+
+#define VARATT_IS_COMPRESSED(PTR)			VARATT_IS_4B_C(PTR)
+#define VARATT_IS_EXTERNAL(PTR)				VARATT_IS_1B_E(PTR)
+#define VARATT_IS_EXTERNAL_ONDISK(PTR) \
+	(VARATT_IS_EXTERNAL(PTR) && VARTAG_EXTERNAL(PTR) == VARTAG_ONDISK)
+#define VARATT_IS_EXTERNAL_INDIRECT(PTR) \
+	(VARATT_IS_EXTERNAL(PTR) && VARTAG_EXTERNAL(PTR) == VARTAG_INDIRECT)
+#define VARATT_IS_EXTERNAL_EXPANDED_RO(PTR) \
+	(VARATT_IS_EXTERNAL(PTR) && VARTAG_EXTERNAL(PTR) == VARTAG_EXPANDED_RO)
+#define VARATT_IS_EXTERNAL_EXPANDED_RW(PTR) \
+	(VARATT_IS_EXTERNAL(PTR) && VARTAG_EXTERNAL(PTR) == VARTAG_EXPANDED_RW)
+#define VARATT_IS_EXTERNAL_EXPANDED(PTR) \
+	(VARATT_IS_EXTERNAL(PTR) && VARTAG_IS_EXPANDED(VARTAG_EXTERNAL(PTR)))
+#define VARATT_IS_EXTERNAL_NON_EXPANDED(PTR) \
+	(VARATT_IS_EXTERNAL(PTR) && !VARTAG_IS_EXPANDED(VARTAG_EXTERNAL(PTR)))
+#define VARATT_IS_SHORT(PTR)				VARATT_IS_1B(PTR)
+#define VARATT_IS_EXTENDED(PTR)				(!VARATT_IS_4B_U(PTR))
+
+#define SET_VARSIZE(PTR, len)				SET_VARSIZE_4B(PTR, len)
+#define SET_VARSIZE_SHORT(PTR, len)			SET_VARSIZE_1B(PTR, len)
+#define SET_VARSIZE_COMPRESSED(PTR, len)	SET_VARSIZE_4B_C(PTR, len)
+
+#define SET_VARTAG_EXTERNAL(PTR, tag)		SET_VARTAG_1B_E(PTR, tag)
+
+#define VARSIZE_ANY(PTR) \
+	(VARATT_IS_1B_E(PTR) ? VARSIZE_EXTERNAL(PTR) : \
+	 (VARATT_IS_1B(PTR) ? VARSIZE_1B(PTR) : \
+	  VARSIZE_4B(PTR)))
+
+/* Size of a varlena data, excluding header */
+#define VARSIZE_ANY_EXHDR(PTR) \
+	(VARATT_IS_1B_E(PTR) ? VARSIZE_EXTERNAL(PTR)-VARHDRSZ_EXTERNAL : \
+	 (VARATT_IS_1B(PTR) ? VARSIZE_1B(PTR)-VARHDRSZ_SHORT : \
+	  VARSIZE_4B(PTR)-VARHDRSZ))
+
+/* caution: this will not work on an external or compressed-in-line Datum */
+/* caution: this will return a possibly unaligned pointer */
+#define VARDATA_ANY(PTR) \
+	 (VARATT_IS_1B(PTR) ? VARDATA_1B(PTR) : VARDATA_4B(PTR))
+
+
+/* ----------------------------------------------------------------
+ *				Section 2:	Datum type + support macros
+ * ----------------------------------------------------------------
+ */
+
+/*
+ * A Datum contains either a value of a pass-by-value type or a pointer to a
+ * value of a pass-by-reference type.  Therefore, we require:
+ *
+ * sizeof(Datum) == sizeof(void *) == 4 or 8
+ *
+ * The macros below and the analogous macros for other types should be used to
+ * convert between a Datum and the appropriate C type.
+ */
+
+typedef uintptr_t Datum;
+
+/*
+ * A NullableDatum is used in places where both a Datum and its nullness needs
+ * to be stored. This can be more efficient than storing datums and nullness
+ * in separate arrays, due to better spatial locality, even if more space may
+ * be wasted due to padding.
+ */
+typedef struct NullableDatum
+{
+#define FIELDNO_NULLABLE_DATUM_DATUM 0
+	Datum		value;
+#define FIELDNO_NULLABLE_DATUM_ISNULL 1
+	bool		isnull;
+	/* due to alignment padding this could be used for flags for free */
+} NullableDatum;
+
+#define SIZEOF_DATUM SIZEOF_VOID_P
+
+/*
+ * DatumGetBool
+ *		Returns boolean value of a datum.
+ *
+ * Note: any nonzero value will be considered true.
+ */
+
+#define DatumGetBool(X) ((bool) ((X) != 0))
+
+/*
+ * BoolGetDatum
+ *		Returns datum representation for a boolean.
+ *
+ * Note: any nonzero value will be considered true.
+ */
+
+#define BoolGetDatum(X) ((Datum) ((X) ? 1 : 0))
+
+/*
+ * DatumGetChar
+ *		Returns character value of a datum.
+ */
+
+#define DatumGetChar(X) ((char) (X))
+
+/*
+ * CharGetDatum
+ *		Returns datum representation for a character.
+ */
+
+#define CharGetDatum(X) ((Datum) (X))
+
+/*
+ * Int8GetDatum
+ *		Returns datum representation for an 8-bit integer.
+ */
+
+#define Int8GetDatum(X) ((Datum) (X))
+
+/*
+ * DatumGetUInt8
+ *		Returns 8-bit unsigned integer value of a datum.
+ */
+
+#define DatumGetUInt8(X) ((uint8) (X))
+
+/*
+ * UInt8GetDatum
+ *		Returns datum representation for an 8-bit unsigned integer.
+ */
+
+#define UInt8GetDatum(X) ((Datum) (X))
+
+/*
+ * DatumGetInt16
+ *		Returns 16-bit integer value of a datum.
+ */
+
+#define DatumGetInt16(X) ((int16) (X))
+
+/*
+ * Int16GetDatum
+ *		Returns datum representation for a 16-bit integer.
+ */
+
+#define Int16GetDatum(X) ((Datum) (X))
+
+/*
+ * DatumGetUInt16
+ *		Returns 16-bit unsigned integer value of a datum.
+ */
+
+#define DatumGetUInt16(X) ((uint16) (X))
+
+/*
+ * UInt16GetDatum
+ *		Returns datum representation for a 16-bit unsigned integer.
+ */
+
+#define UInt16GetDatum(X) ((Datum) (X))
+
+/*
+ * DatumGetInt32
+ *		Returns 32-bit integer value of a datum.
+ */
+
+#define DatumGetInt32(X) ((int32) (X))
+
+/*
+ * Int32GetDatum
+ *		Returns datum representation for a 32-bit integer.
+ */
+
+#define Int32GetDatum(X) ((Datum) (X))
+
+/*
+ * DatumGetUInt32
+ *		Returns 32-bit unsigned integer value of a datum.
+ */
+
+#define DatumGetUInt32(X) ((uint32) (X))
+
+/*
+ * UInt32GetDatum
+ *		Returns datum representation for a 32-bit unsigned integer.
+ */
+
+#define UInt32GetDatum(X) ((Datum) (X))
+
+/*
+ * DatumGetObjectId
+ *		Returns object identifier value of a datum.
+ */
+
+#define DatumGetObjectId(X) ((Oid) (X))
+
+/*
+ * ObjectIdGetDatum
+ *		Returns datum representation for an object identifier.
+ */
+
+#define ObjectIdGetDatum(X) ((Datum) (X))
+
+/*
+ * DatumGetTransactionId
+ *		Returns transaction identifier value of a datum.
+ */
+
+#define DatumGetTransactionId(X) ((TransactionId) (X))
+
+/*
+ * TransactionIdGetDatum
+ *		Returns datum representation for a transaction identifier.
+ */
+
+#define TransactionIdGetDatum(X) ((Datum) (X))
+
+/*
+ * MultiXactIdGetDatum
+ *		Returns datum representation for a multixact identifier.
+ */
+
+#define MultiXactIdGetDatum(X) ((Datum) (X))
+
+/*
+ * DatumGetCommandId
+ *		Returns command identifier value of a datum.
+ */
+
+#define DatumGetCommandId(X) ((CommandId) (X))
+
+/*
+ * CommandIdGetDatum
+ *		Returns datum representation for a command identifier.
+ */
+
+#define CommandIdGetDatum(X) ((Datum) (X))
+
+/*
+ * DatumGetPointer
+ *		Returns pointer value of a datum.
+ */
+
+#define DatumGetPointer(X) ((Pointer) (X))
+
+/*
+ * PointerGetDatum
+ *		Returns datum representation for a pointer.
+ */
+
+#define PointerGetDatum(X) ((Datum) (X))
+
+/*
+ * DatumGetCString
+ *		Returns C string (null-terminated string) value of a datum.
+ *
+ * Note: C string is not a full-fledged Postgres type at present,
+ * but type input functions use this conversion for their inputs.
+ */
+
+#define DatumGetCString(X) ((char *) DatumGetPointer(X))
+
+/*
+ * CStringGetDatum
+ *		Returns datum representation for a C string (null-terminated string).
+ *
+ * Note: C string is not a full-fledged Postgres type at present,
+ * but type output functions use this conversion for their outputs.
+ * Note: CString is pass-by-reference; caller must ensure the pointed-to
+ * value has adequate lifetime.
+ */
+
+#define CStringGetDatum(X) PointerGetDatum(X)
+
+/*
+ * DatumGetName
+ *		Returns name value of a datum.
+ */
+
+#define DatumGetName(X) ((Name) DatumGetPointer(X))
+
+/*
+ * NameGetDatum
+ *		Returns datum representation for a name.
+ *
+ * Note: Name is pass-by-reference; caller must ensure the pointed-to
+ * value has adequate lifetime.
+ */
+
+#define NameGetDatum(X) CStringGetDatum(NameStr(*(X)))
+
+/*
+ * DatumGetInt64
+ *		Returns 64-bit integer value of a datum.
+ *
+ * Note: this macro hides whether int64 is pass by value or by reference.
+ */
+
+#ifdef USE_FLOAT8_BYVAL
+#define DatumGetInt64(X) ((int64) (X))
+#else
+#define DatumGetInt64(X) (* ((int64 *) DatumGetPointer(X)))
+#endif
+
+/*
+ * Int64GetDatum
+ *		Returns datum representation for a 64-bit integer.
+ *
+ * Note: if int64 is pass by reference, this function returns a reference
+ * to palloc'd space.
+ */
+
+#ifdef USE_FLOAT8_BYVAL
+#define Int64GetDatum(X) ((Datum) (X))
+#else
+extern Datum Int64GetDatum(int64 X);
+#endif
+
+/*
+ * DatumGetUInt64
+ *		Returns 64-bit unsigned integer value of a datum.
+ *
+ * Note: this macro hides whether int64 is pass by value or by reference.
+ */
+
+#ifdef USE_FLOAT8_BYVAL
+#define DatumGetUInt64(X) ((uint64) (X))
+#else
+#define DatumGetUInt64(X) (* ((uint64 *) DatumGetPointer(X)))
+#endif
+
+/*
+ * UInt64GetDatum
+ *		Returns datum representation for a 64-bit unsigned integer.
+ *
+ * Note: if int64 is pass by reference, this function returns a reference
+ * to palloc'd space.
+ */
+
+#ifdef USE_FLOAT8_BYVAL
+#define UInt64GetDatum(X) ((Datum) (X))
+#else
+#define UInt64GetDatum(X) Int64GetDatum((int64) (X))
+#endif
+
+/*
+ * Float <-> Datum conversions
+ *
+ * These have to be implemented as inline functions rather than macros, when
+ * passing by value, because many machines pass int and float function
+ * parameters/results differently; so we need to play weird games with unions.
+ */
+
+/*
+ * DatumGetFloat4
+ *		Returns 4-byte floating point value of a datum.
+ */
+static inline float4
+DatumGetFloat4(Datum X)
+{
+	union
+	{
+		int32		value;
+		float4		retval;
+	}			myunion;
+
+	myunion.value = DatumGetInt32(X);
+	return myunion.retval;
+}
+
+/*
+ * Float4GetDatum
+ *		Returns datum representation for a 4-byte floating point number.
+ */
+static inline Datum
+Float4GetDatum(float4 X)
+{
+	union
+	{
+		float4		value;
+		int32		retval;
+	}			myunion;
+
+	myunion.value = X;
+	return Int32GetDatum(myunion.retval);
+}
+
+/*
+ * DatumGetFloat8
+ *		Returns 8-byte floating point value of a datum.
+ *
+ * Note: this macro hides whether float8 is pass by value or by reference.
+ */
+
+#ifdef USE_FLOAT8_BYVAL
+static inline float8
+DatumGetFloat8(Datum X)
+{
+	union
+	{
+		int64		value;
+		float8		retval;
+	}			myunion;
+
+	myunion.value = DatumGetInt64(X);
+	return myunion.retval;
+}
+#else
+#define DatumGetFloat8(X) (* ((float8 *) DatumGetPointer(X)))
+#endif
+
+/*
+ * Float8GetDatum
+ *		Returns datum representation for an 8-byte floating point number.
+ *
+ * Note: if float8 is pass by reference, this function returns a reference
+ * to palloc'd space.
+ */
+
+#ifdef USE_FLOAT8_BYVAL
+static inline Datum
+Float8GetDatum(float8 X)
+{
+	union
+	{
+		float8		value;
+		int64		retval;
+	}			myunion;
+
+	myunion.value = X;
+	return Int64GetDatum(myunion.retval);
+}
+#else
+extern Datum Float8GetDatum(float8 X);
+#endif
+
+
+/*
+ * Int64GetDatumFast
+ * Float8GetDatumFast
+ *
+ * These macros are intended to allow writing code that does not depend on
+ * whether int64 and float8 are pass-by-reference types, while not
+ * sacrificing performance when they are.  The argument must be a variable
+ * that will exist and have the same value for as long as the Datum is needed.
+ * In the pass-by-ref case, the address of the variable is taken to use as
+ * the Datum.  In the pass-by-val case, these will be the same as the non-Fast
+ * macros.
+ */
+
+#ifdef USE_FLOAT8_BYVAL
+#define Int64GetDatumFast(X)  Int64GetDatum(X)
+#define Float8GetDatumFast(X) Float8GetDatum(X)
+#else
+#define Int64GetDatumFast(X)  PointerGetDatum(&(X))
+#define Float8GetDatumFast(X) PointerGetDatum(&(X))
+#endif
+
+#endif							/* POSTGRES_H */
diff --git a/contrib/libs/postgresql/src/include/postgres_ext.h b/contrib/libs/postgresql/src/include/postgres_ext.h
new file mode 100644
index 0000000000..fdb61b7cf5
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/postgres_ext.h
@@ -0,0 +1,74 @@
+/*-------------------------------------------------------------------------
+ *
+ * postgres_ext.h
+ *
+ *	   This file contains declarations of things that are visible everywhere
+ *	in PostgreSQL *and* are visible to clients of frontend interface libraries.
+ *	For example, the Oid type is part of the API of libpq and other libraries.
+ *
+ *	   Declarations which are specific to a particular interface should
+ *	go in the header file for that interface (such as libpq-fe.h).  This
+ *	file is only for fundamental Postgres declarations.
+ *
+ *	   User-written C functions don't count as "external to Postgres."
+ *	Those function much as local modifications to the backend itself, and
+ *	use header files that are otherwise internal to Postgres to interface
+ *	with the backend.
+ *
+ * src/include/postgres_ext.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef POSTGRES_EXT_H
+#define POSTGRES_EXT_H
+
+#include "pg_config_ext.h"
+
+/*
+ * Object ID is a fundamental type in Postgres.
+ */
+typedef unsigned int Oid;
+
+#ifdef __cplusplus
+#define InvalidOid		(Oid(0))
+#else
+#define InvalidOid		((Oid) 0)
+#endif
+
+#define OID_MAX  UINT_MAX
+/* you will need to include <limits.h> to use the above #define */
+
+#define atooid(x) ((Oid) strtoul((x), NULL, 10))
+/* the above needs <stdlib.h> */
+
+
+/* Define a signed 64-bit integer type for use in client API declarations. */
+typedef PG_INT64_TYPE pg_int64;
+
+
+/*
+ * Identifiers of error message fields.  Kept here to keep common
+ * between frontend and backend, and also to export them to libpq
+ * applications.
+ */
+#define PG_DIAG_SEVERITY		'S'
+#define PG_DIAG_SEVERITY_NONLOCALIZED 'V'
+#define PG_DIAG_SQLSTATE		'C'
+#define PG_DIAG_MESSAGE_PRIMARY 'M'
+#define PG_DIAG_MESSAGE_DETAIL	'D'
+#define PG_DIAG_MESSAGE_HINT	'H'
+#define PG_DIAG_STATEMENT_POSITION 'P'
+#define PG_DIAG_INTERNAL_POSITION 'p'
+#define PG_DIAG_INTERNAL_QUERY	'q'
+#define PG_DIAG_CONTEXT			'W'
+#define PG_DIAG_SCHEMA_NAME		's'
+#define PG_DIAG_TABLE_NAME		't'
+#define PG_DIAG_COLUMN_NAME		'c'
+#define PG_DIAG_DATATYPE_NAME	'd'
+#define PG_DIAG_CONSTRAINT_NAME 'n'
+#define PG_DIAG_SOURCE_FILE		'F'
+#define PG_DIAG_SOURCE_LINE		'L'
+#define PG_DIAG_SOURCE_FUNCTION 'R'
+
+#endif							/* POSTGRES_EXT_H */
diff --git a/contrib/libs/postgresql/src/include/postgres_fe.h b/contrib/libs/postgresql/src/include/postgres_fe.h
new file mode 100644
index 0000000000..e99258f2d6
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/postgres_fe.h
@@ -0,0 +1,29 @@
+/*-------------------------------------------------------------------------
+ *
+ * postgres_fe.h
+ *	  Primary include file for PostgreSQL client-side .c files
+ *
+ * This should be the first file included by PostgreSQL client libraries and
+ * application programs --- but not by backend modules, which should include
+ * postgres.h.
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1995, Regents of the University of California
+ *
+ * src/include/postgres_fe.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef POSTGRES_FE_H
+#define POSTGRES_FE_H
+
+#ifndef FRONTEND
+#define FRONTEND 1
+#endif
+
+#include "c.h"
+
+#include "common/fe_memutils.h"
+
+#endif							/* POSTGRES_FE_H */
diff --git a/contrib/libs/postgresql/src/include/rusagestub.h b/contrib/libs/postgresql/src/include/rusagestub.h
new file mode 100644
index 0000000000..3a812a29bc
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/rusagestub.h
@@ -0,0 +1,34 @@
+/*-------------------------------------------------------------------------
+ *
+ * rusagestub.h
+ *	  Stubs for getrusage(3).
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/rusagestub.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef RUSAGESTUB_H
+#define RUSAGESTUB_H
+
+#include <sys/time.h>			/* for struct timeval */
+#ifndef WIN32
+#include <sys/times.h>			/* for struct tms */
+#endif
+#include <limits.h>				/* for CLK_TCK */
+
+#define RUSAGE_SELF		0
+#define RUSAGE_CHILDREN (-1)
+
+struct rusage
+{
+	struct timeval ru_utime;	/* user time used */
+	struct timeval ru_stime;	/* system time used */
+};
+
+extern int	getrusage(int who, struct rusage *rusage);
+
+#endif							/* RUSAGESTUB_H */
diff --git a/contrib/libs/postgresql/src/include/windowapi.h b/contrib/libs/postgresql/src/include/windowapi.h
new file mode 100644
index 0000000000..e8c9fc54d8
--- /dev/null
+++ b/contrib/libs/postgresql/src/include/windowapi.h
@@ -0,0 +1,64 @@
+/*-------------------------------------------------------------------------
+ *
+ * windowapi.h
+ *	  API for window functions to extract data from their window
+ *
+ * A window function does not receive its arguments in the normal way
+ * (and therefore the concept of strictness is irrelevant).  Instead it
+ * receives a "WindowObject", which it can fetch with PG_WINDOW_OBJECT()
+ * (note V1 calling convention must be used).  Correct call context can
+ * be tested with WindowObjectIsValid().  Although argument values are
+ * not passed, the call is correctly set up so that PG_NARGS() can be
+ * used and argument type information can be obtained with
+ * get_fn_expr_argtype(), get_fn_expr_arg_stable(), etc.
+ *
+ * Operations on the WindowObject allow the window function to find out
+ * the current row number, total number of rows in the partition, etc
+ * and to evaluate its argument expression(s) at various rows in the
+ * window partition.  See the header comments for each WindowObject API
+ * function in nodeWindowAgg.c for details.
+ *
+ *
+ * Portions Copyright (c) 2000-2020, PostgreSQL Global Development Group
+ *
+ * src/include/windowapi.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef WINDOWAPI_H
+#define WINDOWAPI_H
+
+/* values of "seektype" */
+#define WINDOW_SEEK_CURRENT 0
+#define WINDOW_SEEK_HEAD 1
+#define WINDOW_SEEK_TAIL 2
+
+/* this struct is private in nodeWindowAgg.c */
+typedef struct WindowObjectData *WindowObject;
+
+#define PG_WINDOW_OBJECT() ((WindowObject) fcinfo->context)
+
+#define WindowObjectIsValid(winobj) \
+	((winobj) != NULL && IsA(winobj, WindowObjectData))
+
+extern void *WinGetPartitionLocalMemory(WindowObject winobj, Size sz);
+
+extern int64 WinGetCurrentPosition(WindowObject winobj);
+extern int64 WinGetPartitionRowCount(WindowObject winobj);
+
+extern void WinSetMarkPosition(WindowObject winobj, int64 markpos);
+
+extern bool WinRowsArePeers(WindowObject winobj, int64 pos1, int64 pos2);
+
+extern Datum WinGetFuncArgInPartition(WindowObject winobj, int argno,
+									  int relpos, int seektype, bool set_mark,
+									  bool *isnull, bool *isout);
+
+extern Datum WinGetFuncArgInFrame(WindowObject winobj, int argno,
+								  int relpos, int seektype, bool set_mark,
+								  bool *isnull, bool *isout);
+
+extern Datum WinGetFuncArgCurrent(WindowObject winobj, int argno,
+								  bool *isnull);
+
+#endif							/* WINDOWAPI_H */