diff options
Diffstat (limited to '')
| -rw-r--r-- | src/backend/utils/fmgr-stamp | 0 | ||||
| -rw-r--r-- | src/backend/utils/fmgr/Makefile | 20 | ||||
| -rw-r--r-- | src/backend/utils/fmgr/README | 335 | ||||
| -rw-r--r-- | src/backend/utils/fmgr/dfmgr.c | 700 | ||||
| -rw-r--r-- | src/backend/utils/fmgr/fmgr.c | 2076 | ||||
| -rw-r--r-- | src/backend/utils/fmgr/funcapi.c | 2115 | ||||
| -rw-r--r-- | src/backend/utils/fmgroids.h | 3261 | ||||
| -rw-r--r-- | src/backend/utils/fmgrprotos.h | 2829 | ||||
| -rw-r--r-- | src/backend/utils/fmgrtab.c | 9254 |
9 files changed, 20590 insertions, 0 deletions
diff --git a/src/backend/utils/fmgr-stamp b/src/backend/utils/fmgr-stamp new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/src/backend/utils/fmgr-stamp diff --git a/src/backend/utils/fmgr/Makefile b/src/backend/utils/fmgr/Makefile new file mode 100644 index 0000000..ceffb80 --- /dev/null +++ b/src/backend/utils/fmgr/Makefile @@ -0,0 +1,20 @@ +#------------------------------------------------------------------------- +# +# Makefile-- +# Makefile for utils/fmgr +# +# IDENTIFICATION +# src/backend/utils/fmgr/Makefile +# +#------------------------------------------------------------------------- + +subdir = src/backend/utils/fmgr +top_builddir = ../../../.. +include $(top_builddir)/src/Makefile.global + +OBJS = \ + dfmgr.o \ + fmgr.o \ + funcapi.o + +include $(top_srcdir)/src/backend/common.mk diff --git a/src/backend/utils/fmgr/README b/src/backend/utils/fmgr/README new file mode 100644 index 0000000..4b2a5df --- /dev/null +++ b/src/backend/utils/fmgr/README @@ -0,0 +1,335 @@ +src/backend/utils/fmgr/README + +Function Manager +================ + +[This file originally explained the transition from the V0 to the V1 +interface. Now it just explains some internals and rationale for the V1 +interface, while the V0 interface has been removed.] + +The V1 Function-Manager Interface +--------------------------------- + +The core of the design is data structures for representing the result of a +function lookup and for representing the parameters passed to a specific +function invocation. (We want to keep function lookup separate from +function call, since many parts of the system apply the same function over +and over; the lookup overhead should be paid once per query, not once per +tuple.) + + +When a function is looked up in pg_proc, the result is represented as + +typedef struct +{ + 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 (over multiple calls) */ + 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 */ + Node *fn_expr; /* expression parse tree for call, or NULL */ +} FmgrInfo; + +For an ordinary built-in function, fn_addr is just the address of the C +routine that implements the function. Otherwise it is the address of a +handler for the class of functions that includes the target function. +The handler can use the function OID and perhaps also the fn_extra slot +to find the specific code to execute. (fn_oid = InvalidOid can be used +to denote a not-yet-initialized FmgrInfo struct. fn_extra will always +be NULL when an FmgrInfo is first filled by the function lookup code, but +a function handler could set it to avoid making repeated lookups of its +own when the same FmgrInfo is used repeatedly during a query.) fn_nargs +is the number of arguments expected by the function, fn_strict is its +strictness flag, and fn_retset shows whether it returns a set; all of +these values come from the function's pg_proc entry. fn_stats is also +set up to control whether or not to track runtime statistics for calling +this function. + +If the function is being called as part of a SQL expression, fn_expr will +point to the expression parse tree for the function call; this can be used +to extract parse-time knowledge about the actual arguments. Note that this +field really is information about the arguments rather than information +about the function, but it's proven to be more convenient to keep it in +FmgrInfo than in FunctionCallInfoBaseData where it might more logically go. + + +During a call of a function, the following data structure is created +and passed to the function: + +typedef struct +{ + FmgrInfo *flinfo; /* ptr to lookup info used for this call */ + Node *context; /* pass info about context of call */ + Node *resultinfo; /* pass or return extra info about result */ + Oid fncollation; /* collation for function to use */ + bool isnull; /* function must set true if result is NULL */ + short nargs; /* # arguments actually passed */ + NullableDatum args[]; /* Arguments passed to function */ +} FunctionCallInfoBaseData; +typedef FunctionCallInfoBaseData* FunctionCallInfo; + +flinfo points to the lookup info used to make the call. Ordinary functions +will probably ignore this field, but function class handlers will need it +to find out the OID of the specific function being called. + +context is NULL for an "ordinary" function call, but may point to additional +info when the function is called in certain contexts. (For example, the +trigger manager will pass information about the current trigger event here.) +If context is used, it should point to some subtype of Node; the particular +kind of context is indicated by the node type field. (A callee should +always check the node type before assuming it knows what kind of context is +being passed.) fmgr itself puts no other restrictions on the use of this +field. + +resultinfo is NULL when calling any function from which a simple Datum +result is expected. It may point to some subtype of Node if the function +returns more than a Datum. (For example, resultinfo is used when calling a +function that returns a set, as discussed below.) Like the context field, +resultinfo is a hook for expansion; fmgr itself doesn't constrain the use +of the field. + +fncollation is the input collation derived by the parser, or InvalidOid +when there are no inputs of collatable types or they don't share a common +collation. This is effectively a hidden additional argument, which +collation-sensitive functions can use to determine their behavior. + +nargs and args[] hold the arguments being passed to the function. +Notice that all the arguments passed to a function (as well as its result +value) will now uniformly be of type Datum. As discussed below, callers +and callees should apply the standard Datum-to-and-from-whatever macros +to convert to the actual argument types of a particular function. The +value in args[i].value is unspecified when args[i].isnull is true. + +It is generally the responsibility of the caller to ensure that the +number of arguments passed matches what the callee is expecting; except +for callees that take a variable number of arguments, the callee will +typically ignore the nargs field and just grab values from args[]. + +The isnull field will be initialized to "false" before the call. On +return from the function, isnull is the null flag for the function result: +if it is true the function's result is NULL, regardless of the actual +function return value. Note that simple "strict" functions can ignore +both isnull and args[i].isnull, since they won't even get called when there +are any TRUE values in args[].isnull. + +FunctionCallInfo replaces FmgrValues plus a bunch of ad-hoc parameter +conventions, global variables (fmgr_pl_finfo and CurrentTriggerData at +least), and other uglinesses. + + +Callees, whether they be individual functions or function handlers, +shall always have this signature: + +Datum function (FunctionCallInfo fcinfo); + +which is represented by the typedef + +typedef Datum (*PGFunction) (FunctionCallInfo fcinfo); + +The function is responsible for setting fcinfo->isnull appropriately +as well as returning a result represented as a Datum. Note that since +all callees will now have exactly the same signature, and will be called +through a function pointer declared with exactly that signature, we +should have no portability or optimization problems. + + +Function Coding Conventions +--------------------------- + +Here are the proposed macros and coding conventions: + +The definition of an fmgr-callable function will always look like + +Datum +function_name(PG_FUNCTION_ARGS) +{ + ... +} + +"PG_FUNCTION_ARGS" just expands to "FunctionCallInfo fcinfo". The main +reason for using this macro is to make it easy for scripts to spot function +definitions. However, if we ever decide to change the calling convention +again, it might come in handy to have this macro in place. + +A nonstrict function is responsible for checking whether each individual +argument is null or not, which it can do with PG_ARGISNULL(n) (which is +just "fcinfo->args[n].isnull"). It should avoid trying to fetch the value +of any argument that is null. + +Both strict and nonstrict functions can return NULL, if needed, with + PG_RETURN_NULL(); +which expands to + { fcinfo->isnull = true; return (Datum) 0; } + +Argument values are ordinarily fetched using code like + int32 name = PG_GETARG_INT32(number); + +For float4, float8, and int8, the PG_GETARG macros will hide whether the +types are pass-by-value or pass-by-reference. For example, if float8 is +pass-by-reference then PG_GETARG_FLOAT8 expands to + (* (float8 *) DatumGetPointer(fcinfo->args[number].value)) +and would typically be called like this: + float8 arg = PG_GETARG_FLOAT8(0); +For what are now historical reasons, the float-related typedefs and macros +express the type width in bytes (4 or 8), whereas we prefer to label the +widths of integer types in bits. + +Non-null values are returned with a PG_RETURN_XXX macro of the appropriate +type. For example, PG_RETURN_INT32 expands to + return Int32GetDatum(x) +PG_RETURN_FLOAT4, PG_RETURN_FLOAT8, and PG_RETURN_INT64 hide whether their +data types are pass-by-value or pass-by-reference, by doing a palloc if +needed. + +fmgr.h will provide PG_GETARG and PG_RETURN macros for all the basic data +types. Modules or header files that define specialized SQL datatypes +(eg, timestamp) should define appropriate macros for those types, so that +functions manipulating the types can be coded in the standard style. + +For non-primitive data types (particularly variable-length types) it won't +be very practical to hide the pass-by-reference nature of the data type, +so the PG_GETARG and PG_RETURN macros for those types won't do much more +than DatumGetPointer/PointerGetDatum plus the appropriate typecast (but see +TOAST discussion, below). Functions returning such types will need to +palloc() their result space explicitly. I recommend naming the GETARG and +RETURN macros for such types to end in "_P", as a reminder that they +produce or take a pointer. For example, PG_GETARG_TEXT_P yields "text *". + +When a function needs to access fcinfo->flinfo or one of the other auxiliary +fields of FunctionCallInfo, it should just do it. I doubt that providing +syntactic-sugar macros for these cases is useful. + + +Support for TOAST-Able Data Types +--------------------------------- + +For TOAST-able data types, the PG_GETARG macro will deliver a de-TOASTed +data value. There might be a few cases where the still-toasted value is +wanted, but the vast majority of cases want the de-toasted result, so +that will be the default. To get the argument value without causing +de-toasting, use PG_GETARG_RAW_VARLENA_P(n). + +Some functions require a modifiable copy of their input values. In these +cases, it's silly to do an extra copy step if we copied the data anyway +to de-TOAST it. Therefore, each toastable datatype has an additional +fetch macro, for example PG_GETARG_TEXT_P_COPY(n), which delivers a +guaranteed-fresh copy, combining this with the detoasting step if possible. + +There is also a PG_FREE_IF_COPY(ptr,n) macro, which pfree's the given +pointer if and only if it is different from the original value of the n'th +argument. This can be used to free the de-toasted value of the n'th +argument, if it was actually de-toasted. Currently, doing this is not +necessary for the majority of functions because the core backend code +releases temporary space periodically, so that memory leaked in function +execution isn't a big problem. However, as of 7.1 memory leaks in +functions that are called by index searches will not be cleaned up until +end of transaction. Therefore, functions that are listed in pg_amop or +pg_amproc should be careful not to leak detoasted copies, and so these +functions do need to use PG_FREE_IF_COPY() for toastable inputs. + +A function should never try to re-TOAST its result value; it should just +deliver an untoasted result that's been palloc'd in the current memory +context. When and if the value is actually stored into a tuple, the +tuple toaster will decide whether toasting is needed. + + +Functions Accepting or Returning Sets +------------------------------------- + +If a function is marked in pg_proc as returning a set, then it is called +with fcinfo->resultinfo pointing to a node of type ReturnSetInfo. A +function that desires to return a set should raise an error "called in +context that does not accept a set result" if resultinfo is NULL or does +not point to a ReturnSetInfo node. + +There are currently two modes in which a function can return a set result: +value-per-call, or materialize. In value-per-call mode, the function returns +one value each time it is called, and finally reports "done" when it has no +more values to return. In materialize mode, the function's output set is +instantiated in a Tuplestore object; all the values are returned in one call. +Additional modes might be added in future. + +ReturnSetInfo contains a field "allowedModes" which is set (by the caller) +to a bitmask that's the OR of the modes the caller can support. The actual +mode used by the function is returned in another field "returnMode". For +backwards-compatibility reasons, returnMode is initialized to value-per-call +and need only be changed if the function wants to use a different mode. +The function should ereport() if it cannot use any of the modes the caller is +willing to support. + +Value-per-call mode works like this: ReturnSetInfo contains a field +"isDone", which should be set to one of these values: + + ExprSingleResult /* expression does not return a set */ + ExprMultipleResult /* this result is an element of a set */ + ExprEndResult /* there are no more elements in the set */ + +(the caller will initialize it to ExprSingleResult). If the function simply +returns a Datum without touching ReturnSetInfo, then the call is over and a +single-item set has been returned. To return a set, the function must set +isDone to ExprMultipleResult for each set element. After all elements have +been returned, the next call should set isDone to ExprEndResult and return a +null result. (Note it is possible to return an empty set by doing this on +the first call.) + +Value-per-call functions MUST NOT assume that they will be run to completion; +the executor might simply stop calling them, for example because of a LIMIT. +Therefore, it's unsafe to attempt to perform any resource cleanup in the +final call. It's usually not necessary to clean up memory, anyway. If it's +necessary to clean up other types of resources, such as file descriptors, +one can register a shutdown callback function in the ExprContext pointed to +by the ReturnSetInfo node. (But note that file descriptors are a limited +resource, so it's generally unwise to hold those open across calls; SRFs +that need file access are better written to do it in a single call using +Materialize mode.) + +Materialize mode works like this: the function creates a Tuplestore holding +the (possibly empty) result set, and returns it. There are no multiple calls. +The function must also return a TupleDesc that indicates the tuple structure. +The Tuplestore and TupleDesc should be created in the context +econtext->ecxt_per_query_memory (note this will *not* be the context the +function is called in). The function stores pointers to the Tuplestore and +TupleDesc into ReturnSetInfo, sets returnMode to indicate materialize mode, +and returns null. isDone is not used and should be left at ExprSingleResult. + +The Tuplestore must be created with randomAccess = true if +SFRM_Materialize_Random is set in allowedModes, but it can (and preferably +should) be created with randomAccess = false if not. Callers that can support +both ValuePerCall and Materialize mode will set SFRM_Materialize_Preferred, +or not, depending on which mode they prefer. + +If available, the expected tuple descriptor is passed in ReturnSetInfo; +in other contexts the expectedDesc field will be NULL. The function need +not pay attention to expectedDesc, but it may be useful in special cases. + +InitMaterializedSRF() is a helper function able to setup the function's +ReturnSetInfo for a single call, filling in the Tuplestore and the +TupleDesc with the proper configuration for Materialize mode. + +There is no support for functions accepting sets; instead, the function will +be called multiple times, once for each element of the input set. + + +Notes About Function Handlers +----------------------------- + +Handlers for classes of functions should find life much easier and +cleaner in this design. The OID of the called function is directly +reachable from the passed parameters; we don't need the global variable +fmgr_pl_finfo anymore. Also, by modifying fcinfo->flinfo->fn_extra, +the handler can cache lookup info to avoid repeat lookups when the same +function is invoked many times. (fn_extra can only be used as a hint, +since callers are not required to re-use an FmgrInfo struct. +But in performance-critical paths they normally will do so.) + +If the handler wants to allocate memory to hold fn_extra data, it should +NOT do so in CurrentMemoryContext, since the current context may well be +much shorter-lived than the context where the FmgrInfo is. Instead, +allocate the memory in context flinfo->fn_mcxt, or in a long-lived cache +context. fn_mcxt normally points at the context that was +CurrentMemoryContext at the time the FmgrInfo structure was created; +in any case it is required to be a context at least as long-lived as the +FmgrInfo itself. diff --git a/src/backend/utils/fmgr/dfmgr.c b/src/backend/utils/fmgr/dfmgr.c new file mode 100644 index 0000000..7f9ea97 --- /dev/null +++ b/src/backend/utils/fmgr/dfmgr.c @@ -0,0 +1,700 @@ +/*------------------------------------------------------------------------- + * + * dfmgr.c + * Dynamic function manager code. + * + * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * + * IDENTIFICATION + * src/backend/utils/fmgr/dfmgr.c + * + *------------------------------------------------------------------------- + */ +#include "postgres.h" + +#include <sys/stat.h> + +#ifdef HAVE_DLOPEN +#include <dlfcn.h> + +/* + * On macOS, <dlfcn.h> insists on including <stdbool.h>. If we're not + * using stdbool, undef bool to undo the damage. + */ +#ifndef PG_USE_STDBOOL +#ifdef bool +#undef bool +#endif +#endif +#endif /* HAVE_DLOPEN */ + +#include "fmgr.h" +#include "lib/stringinfo.h" +#include "miscadmin.h" +#include "storage/shmem.h" +#include "utils/hsearch.h" + + +/* signature for PostgreSQL-specific library init function */ +typedef void (*PG_init_t) (void); + +/* hashtable entry for rendezvous variables */ +typedef struct +{ + char varName[NAMEDATALEN]; /* hash key (must be first) */ + void *varValue; +} rendezvousHashEntry; + +/* + * List of dynamically loaded files (kept in malloc'd memory). + */ + +typedef struct df_files +{ + struct df_files *next; /* List link */ + dev_t device; /* Device file is on */ +#ifndef WIN32 /* ensures we never again depend on this under + * win32 */ + ino_t inode; /* Inode number of file */ +#endif + void *handle; /* a handle for pg_dl* functions */ + char filename[FLEXIBLE_ARRAY_MEMBER]; /* Full pathname of file */ +} DynamicFileList; + +static DynamicFileList *file_list = NULL; +static DynamicFileList *file_tail = NULL; + +/* stat() call under Win32 returns an st_ino field, but it has no meaning */ +#ifndef WIN32 +#define SAME_INODE(A,B) ((A).st_ino == (B).inode && (A).st_dev == (B).device) +#else +#define SAME_INODE(A,B) false +#endif + +char *Dynamic_library_path; + +static void *internal_load_library(const char *libname); +static void incompatible_module_error(const char *libname, + const Pg_magic_struct *module_magic_data) pg_attribute_noreturn(); +static bool file_exists(const char *name); +static char *expand_dynamic_library_name(const char *name); +static void check_restricted_library_name(const char *name); +static char *substitute_libpath_macro(const char *name); +static char *find_in_dynamic_libpath(const char *basename); + +/* Magic structure that module needs to match to be accepted */ +static const Pg_magic_struct magic_data = PG_MODULE_MAGIC_DATA; + + +/* + * Load the specified dynamic-link library file, and look for a function + * named funcname in it. + * + * If the function is not found, we raise an error if signalNotFound is true, + * else return NULL. Note that errors in loading the library + * will provoke ereport() regardless of signalNotFound. + * + * If filehandle is not NULL, then *filehandle will be set to a handle + * identifying the library file. The filehandle can be used with + * lookup_external_function to lookup additional functions in the same file + * at less cost than repeating load_external_function. + */ +void * +load_external_function(const char *filename, const char *funcname, + bool signalNotFound, void **filehandle) +{ + char *fullname; + void *lib_handle; + void *retval; + + /* Expand the possibly-abbreviated filename to an exact path name */ + fullname = expand_dynamic_library_name(filename); + + /* Load the shared library, unless we already did */ + lib_handle = internal_load_library(fullname); + + /* Return handle if caller wants it */ + if (filehandle) + *filehandle = lib_handle; + + /* Look up the function within the library. */ + retval = dlsym(lib_handle, funcname); + + if (retval == NULL && signalNotFound) + ereport(ERROR, + (errcode(ERRCODE_UNDEFINED_FUNCTION), + errmsg("could not find function \"%s\" in file \"%s\"", + funcname, fullname))); + + pfree(fullname); + return retval; +} + +/* + * This function loads a shlib file without looking up any particular + * function in it. If the same shlib has previously been loaded, + * unload and reload it. + * + * When 'restricted' is true, only libraries in the presumed-secure + * directory $libdir/plugins may be referenced. + */ +void +load_file(const char *filename, bool restricted) +{ + char *fullname; + + /* Apply security restriction if requested */ + if (restricted) + check_restricted_library_name(filename); + + /* Expand the possibly-abbreviated filename to an exact path name */ + fullname = expand_dynamic_library_name(filename); + + /* Load the shared library */ + (void) internal_load_library(fullname); + + pfree(fullname); +} + +/* + * Lookup a function whose library file is already loaded. + * Return NULL if not found. + */ +void * +lookup_external_function(void *filehandle, const char *funcname) +{ + return dlsym(filehandle, funcname); +} + + +/* + * Load the specified dynamic-link library file, unless it already is + * loaded. Return the pg_dl* handle for the file. + * + * Note: libname is expected to be an exact name for the library file. + * + * NB: There is presently no way to unload a dynamically loaded file. We might + * add one someday if we can convince ourselves we have safe protocols for un- + * hooking from hook function pointers, releasing custom GUC variables, and + * perhaps other things that are definitely unsafe currently. + */ +static void * +internal_load_library(const char *libname) +{ + DynamicFileList *file_scanner; + PGModuleMagicFunction magic_func; + char *load_error; + struct stat stat_buf; + PG_init_t PG_init; + + /* + * Scan the list of loaded FILES to see if the file has been loaded. + */ + for (file_scanner = file_list; + file_scanner != NULL && + strcmp(libname, file_scanner->filename) != 0; + file_scanner = file_scanner->next) + ; + + if (file_scanner == NULL) + { + /* + * Check for same files - different paths (ie, symlink or link) + */ + if (stat(libname, &stat_buf) == -1) + ereport(ERROR, + (errcode_for_file_access(), + errmsg("could not access file \"%s\": %m", + libname))); + + for (file_scanner = file_list; + file_scanner != NULL && + !SAME_INODE(stat_buf, *file_scanner); + file_scanner = file_scanner->next) + ; + } + + if (file_scanner == NULL) + { + /* + * File not loaded yet. + */ + file_scanner = (DynamicFileList *) + malloc(offsetof(DynamicFileList, filename) + strlen(libname) + 1); + if (file_scanner == NULL) + ereport(ERROR, + (errcode(ERRCODE_OUT_OF_MEMORY), + errmsg("out of memory"))); + + MemSet(file_scanner, 0, offsetof(DynamicFileList, filename)); + strcpy(file_scanner->filename, libname); + file_scanner->device = stat_buf.st_dev; +#ifndef WIN32 + file_scanner->inode = stat_buf.st_ino; +#endif + file_scanner->next = NULL; + + file_scanner->handle = dlopen(file_scanner->filename, RTLD_NOW | RTLD_GLOBAL); + if (file_scanner->handle == NULL) + { + load_error = dlerror(); + free((char *) file_scanner); + /* errcode_for_file_access might not be appropriate here? */ + ereport(ERROR, + (errcode_for_file_access(), + errmsg("could not load library \"%s\": %s", + libname, load_error))); + } + + /* Check the magic function to determine compatibility */ + magic_func = (PGModuleMagicFunction) + dlsym(file_scanner->handle, PG_MAGIC_FUNCTION_NAME_STRING); + if (magic_func) + { + const Pg_magic_struct *magic_data_ptr = (*magic_func) (); + + if (magic_data_ptr->len != magic_data.len || + memcmp(magic_data_ptr, &magic_data, magic_data.len) != 0) + { + /* copy data block before unlinking library */ + Pg_magic_struct module_magic_data = *magic_data_ptr; + + /* try to close library */ + dlclose(file_scanner->handle); + free((char *) file_scanner); + + /* issue suitable complaint */ + incompatible_module_error(libname, &module_magic_data); + } + } + else + { + /* try to close library */ + dlclose(file_scanner->handle); + free((char *) file_scanner); + /* complain */ + ereport(ERROR, + (errmsg("incompatible library \"%s\": missing magic block", + libname), + errhint("Extension libraries are required to use the PG_MODULE_MAGIC macro."))); + } + + /* + * If the library has a _PG_init() function, call it. + */ + PG_init = (PG_init_t) dlsym(file_scanner->handle, "_PG_init"); + if (PG_init) + (*PG_init) (); + + /* OK to link it into list */ + if (file_list == NULL) + file_list = file_scanner; + else + file_tail->next = file_scanner; + file_tail = file_scanner; + } + + return file_scanner->handle; +} + +/* + * Report a suitable error for an incompatible magic block. + */ +static void +incompatible_module_error(const char *libname, + const Pg_magic_struct *module_magic_data) +{ + StringInfoData details; + + /* + * If the version doesn't match, just report that, because the rest of the + * block might not even have the fields we expect. + */ + if (magic_data.version != module_magic_data->version) + { + char library_version[32]; + + if (module_magic_data->version >= 1000) + snprintf(library_version, sizeof(library_version), "%d", + module_magic_data->version / 100); + else + snprintf(library_version, sizeof(library_version), "%d.%d", + module_magic_data->version / 100, + module_magic_data->version % 100); + ereport(ERROR, + (errmsg("incompatible library \"%s\": version mismatch", + libname), + errdetail("Server is version %d, library is version %s.", + magic_data.version / 100, library_version))); + } + + /* + * Similarly, if the ABI extra field doesn't match, error out. Other + * fields below might also mismatch, but that isn't useful information if + * you're using the wrong product altogether. + */ + if (strcmp(module_magic_data->abi_extra, magic_data.abi_extra) != 0) + { + ereport(ERROR, + (errmsg("incompatible library \"%s\": ABI mismatch", + libname), + errdetail("Server has ABI \"%s\", library has \"%s\".", + magic_data.abi_extra, + module_magic_data->abi_extra))); + } + + /* + * Otherwise, spell out which fields don't agree. + * + * XXX this code has to be adjusted any time the set of fields in a magic + * block change! + */ + initStringInfo(&details); + + if (module_magic_data->funcmaxargs != magic_data.funcmaxargs) + { + if (details.len) + appendStringInfoChar(&details, '\n'); + appendStringInfo(&details, + _("Server has FUNC_MAX_ARGS = %d, library has %d."), + magic_data.funcmaxargs, + module_magic_data->funcmaxargs); + } + if (module_magic_data->indexmaxkeys != magic_data.indexmaxkeys) + { + if (details.len) + appendStringInfoChar(&details, '\n'); + appendStringInfo(&details, + _("Server has INDEX_MAX_KEYS = %d, library has %d."), + magic_data.indexmaxkeys, + module_magic_data->indexmaxkeys); + } + if (module_magic_data->namedatalen != magic_data.namedatalen) + { + if (details.len) + appendStringInfoChar(&details, '\n'); + appendStringInfo(&details, + _("Server has NAMEDATALEN = %d, library has %d."), + magic_data.namedatalen, + module_magic_data->namedatalen); + } + if (module_magic_data->float8byval != magic_data.float8byval) + { + if (details.len) + appendStringInfoChar(&details, '\n'); + appendStringInfo(&details, + _("Server has FLOAT8PASSBYVAL = %s, library has %s."), + magic_data.float8byval ? "true" : "false", + module_magic_data->float8byval ? "true" : "false"); + } + + if (details.len == 0) + appendStringInfoString(&details, + _("Magic block has unexpected length or padding difference.")); + + ereport(ERROR, + (errmsg("incompatible library \"%s\": magic block mismatch", + libname), + errdetail_internal("%s", details.data))); +} + +static bool +file_exists(const char *name) +{ + struct stat st; + + AssertArg(name != NULL); + + if (stat(name, &st) == 0) + return !S_ISDIR(st.st_mode); + else if (!(errno == ENOENT || errno == ENOTDIR || errno == EACCES)) + ereport(ERROR, + (errcode_for_file_access(), + errmsg("could not access file \"%s\": %m", name))); + + return false; +} + + +/* + * If name contains a slash, check if the file exists, if so return + * the name. Else (no slash) try to expand using search path (see + * find_in_dynamic_libpath below); if that works, return the fully + * expanded file name. If the previous failed, append DLSUFFIX and + * try again. If all fails, just return the original name. + * + * The result will always be freshly palloc'd. + */ +static char * +expand_dynamic_library_name(const char *name) +{ + bool have_slash; + char *new; + char *full; + + AssertArg(name); + + have_slash = (first_dir_separator(name) != NULL); + + if (!have_slash) + { + full = find_in_dynamic_libpath(name); + if (full) + return full; + } + else + { + full = substitute_libpath_macro(name); + if (file_exists(full)) + return full; + pfree(full); + } + + new = psprintf("%s%s", name, DLSUFFIX); + + if (!have_slash) + { + full = find_in_dynamic_libpath(new); + pfree(new); + if (full) + return full; + } + else + { + full = substitute_libpath_macro(new); + pfree(new); + if (file_exists(full)) + return full; + pfree(full); + } + + /* + * If we can't find the file, just return the string as-is. The ensuing + * load attempt will fail and report a suitable message. + */ + return pstrdup(name); +} + +/* + * Check a restricted library name. It must begin with "$libdir/plugins/" + * and there must not be any directory separators after that (this is + * sufficient to prevent ".." style attacks). + */ +static void +check_restricted_library_name(const char *name) +{ + if (strncmp(name, "$libdir/plugins/", 16) != 0 || + first_dir_separator(name + 16) != NULL) + ereport(ERROR, + (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), + errmsg("access to library \"%s\" is not allowed", + name))); +} + +/* + * Substitute for any macros appearing in the given string. + * Result is always freshly palloc'd. + */ +static char * +substitute_libpath_macro(const char *name) +{ + const char *sep_ptr; + + AssertArg(name != NULL); + + /* Currently, we only recognize $libdir at the start of the string */ + if (name[0] != '$') + return pstrdup(name); + + if ((sep_ptr = first_dir_separator(name)) == NULL) + sep_ptr = name + strlen(name); + + if (strlen("$libdir") != sep_ptr - name || + strncmp(name, "$libdir", strlen("$libdir")) != 0) + ereport(ERROR, + (errcode(ERRCODE_INVALID_NAME), + errmsg("invalid macro name in dynamic library path: %s", + name))); + + return psprintf("%s%s", pkglib_path, sep_ptr); +} + + +/* + * Search for a file called 'basename' in the colon-separated search + * path Dynamic_library_path. If the file is found, the full file name + * is returned in freshly palloc'd memory. If the file is not found, + * return NULL. + */ +static char * +find_in_dynamic_libpath(const char *basename) +{ + const char *p; + size_t baselen; + + AssertArg(basename != NULL); + AssertArg(first_dir_separator(basename) == NULL); + AssertState(Dynamic_library_path != NULL); + + p = Dynamic_library_path; + if (strlen(p) == 0) + return NULL; + + baselen = strlen(basename); + + for (;;) + { + size_t len; + char *piece; + char *mangled; + char *full; + + piece = first_path_var_separator(p); + if (piece == p) + ereport(ERROR, + (errcode(ERRCODE_INVALID_NAME), + errmsg("zero-length component in parameter \"dynamic_library_path\""))); + + if (piece == NULL) + len = strlen(p); + else + len = piece - p; + + piece = palloc(len + 1); + strlcpy(piece, p, len + 1); + + mangled = substitute_libpath_macro(piece); + pfree(piece); + + canonicalize_path(mangled); + + /* only absolute paths */ + if (!is_absolute_path(mangled)) + ereport(ERROR, + (errcode(ERRCODE_INVALID_NAME), + errmsg("component in parameter \"dynamic_library_path\" is not an absolute path"))); + + full = palloc(strlen(mangled) + 1 + baselen + 1); + sprintf(full, "%s/%s", mangled, basename); + pfree(mangled); + + elog(DEBUG3, "find_in_dynamic_libpath: trying \"%s\"", full); + + if (file_exists(full)) + return full; + + pfree(full); + + if (p[len] == '\0') + break; + else + p += len + 1; + } + + return NULL; +} + + +/* + * Find (or create) a rendezvous variable that one dynamically + * loaded library can use to meet up with another. + * + * On the first call of this function for a particular varName, + * a "rendezvous variable" is created with the given name. + * The value of the variable is a void pointer (initially set to NULL). + * Subsequent calls with the same varName just return the address of + * the existing variable. Once created, a rendezvous variable lasts + * for the life of the process. + * + * Dynamically loaded libraries can use rendezvous variables + * to find each other and share information: they just need to agree + * on the variable name and the data it will point to. + */ +void ** +find_rendezvous_variable(const char *varName) +{ + static HTAB *rendezvousHash = NULL; + + rendezvousHashEntry *hentry; + bool found; + + /* Create a hashtable if we haven't already done so in this process */ + if (rendezvousHash == NULL) + { + HASHCTL ctl; + + ctl.keysize = NAMEDATALEN; + ctl.entrysize = sizeof(rendezvousHashEntry); + rendezvousHash = hash_create("Rendezvous variable hash", + 16, + &ctl, + HASH_ELEM | HASH_STRINGS); + } + + /* Find or create the hashtable entry for this varName */ + hentry = (rendezvousHashEntry *) hash_search(rendezvousHash, + varName, + HASH_ENTER, + &found); + + /* Initialize to NULL if first time */ + if (!found) + hentry->varValue = NULL; + + return &hentry->varValue; +} + +/* + * Estimate the amount of space needed to serialize the list of libraries + * we have loaded. + */ +Size +EstimateLibraryStateSpace(void) +{ + DynamicFileList *file_scanner; + Size size = 1; + + for (file_scanner = file_list; + file_scanner != NULL; + file_scanner = file_scanner->next) + size = add_size(size, strlen(file_scanner->filename) + 1); + + return size; +} + +/* + * Serialize the list of libraries we have loaded to a chunk of memory. + */ +void +SerializeLibraryState(Size maxsize, char *start_address) +{ + DynamicFileList *file_scanner; + + for (file_scanner = file_list; + file_scanner != NULL; + file_scanner = file_scanner->next) + { + Size len; + + len = strlcpy(start_address, file_scanner->filename, maxsize) + 1; + Assert(len < maxsize); + maxsize -= len; + start_address += len; + } + start_address[0] = '\0'; +} + +/* + * Load every library the serializing backend had loaded. + */ +void +RestoreLibraryState(char *start_address) +{ + while (*start_address != '\0') + { + internal_load_library(start_address); + start_address += strlen(start_address) + 1; + } +} diff --git a/src/backend/utils/fmgr/fmgr.c b/src/backend/utils/fmgr/fmgr.c new file mode 100644 index 0000000..a9dd068 --- /dev/null +++ b/src/backend/utils/fmgr/fmgr.c @@ -0,0 +1,2076 @@ +/*------------------------------------------------------------------------- + * + * fmgr.c + * The Postgres function manager. + * + * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * + * IDENTIFICATION + * src/backend/utils/fmgr/fmgr.c + * + *------------------------------------------------------------------------- + */ + +#include "postgres.h" + +#include "access/detoast.h" +#include "catalog/pg_language.h" +#include "catalog/pg_proc.h" +#include "catalog/pg_type.h" +#include "executor/functions.h" +#include "lib/stringinfo.h" +#include "miscadmin.h" +#include "nodes/makefuncs.h" +#include "nodes/nodeFuncs.h" +#include "pgstat.h" +#include "utils/acl.h" +#include "utils/builtins.h" +#include "utils/fmgrtab.h" +#include "utils/guc.h" +#include "utils/lsyscache.h" +#include "utils/syscache.h" + +/* + * Hooks for function calls + */ +PGDLLIMPORT needs_fmgr_hook_type needs_fmgr_hook = NULL; +PGDLLIMPORT fmgr_hook_type fmgr_hook = NULL; + +/* + * Hashtable for fast lookup of external C functions + */ +typedef struct +{ + /* fn_oid is the hash key and so must be first! */ + Oid fn_oid; /* OID of an external C function */ + TransactionId fn_xmin; /* for checking up-to-dateness */ + ItemPointerData fn_tid; + PGFunction user_fn; /* the function's address */ + const Pg_finfo_record *inforec; /* address of its info record */ +} CFuncHashTabEntry; + +static HTAB *CFuncHash = NULL; + + +static void fmgr_info_cxt_security(Oid functionId, FmgrInfo *finfo, MemoryContext mcxt, + bool ignore_security); +static void fmgr_info_C_lang(Oid functionId, FmgrInfo *finfo, HeapTuple procedureTuple); +static void fmgr_info_other_lang(Oid functionId, FmgrInfo *finfo, HeapTuple procedureTuple); +static CFuncHashTabEntry *lookup_C_func(HeapTuple procedureTuple); +static void record_C_func(HeapTuple procedureTuple, + PGFunction user_fn, const Pg_finfo_record *inforec); + +/* extern so it's callable via JIT */ +extern Datum fmgr_security_definer(PG_FUNCTION_ARGS); + + +/* + * Lookup routines for builtin-function table. We can search by either Oid + * or name, but search by Oid is much faster. + */ + +static const FmgrBuiltin * +fmgr_isbuiltin(Oid id) +{ + uint16 index; + + /* fast lookup only possible if original oid still assigned */ + if (id > fmgr_last_builtin_oid) + return NULL; + + /* + * Lookup function data. If there's a miss in that range it's likely a + * nonexistent function, returning NULL here will trigger an ERROR later. + */ + index = fmgr_builtin_oid_index[id]; + if (index == InvalidOidBuiltinMapping) + return NULL; + + return &fmgr_builtins[index]; +} + +/* + * Lookup a builtin by name. Note there can be more than one entry in + * the array with the same name, but they should all point to the same + * routine. + */ +static const FmgrBuiltin * +fmgr_lookupByName(const char *name) +{ + int i; + + for (i = 0; i < fmgr_nbuiltins; i++) + { + if (strcmp(name, fmgr_builtins[i].funcName) == 0) + return fmgr_builtins + i; + } + return NULL; +} + +/* + * This routine fills a FmgrInfo struct, given the OID + * of the function to be called. + * + * The caller's CurrentMemoryContext is used as the fn_mcxt of the info + * struct; this means that any subsidiary data attached to the info struct + * (either by fmgr_info itself, or later on by a function call handler) + * will be allocated in that context. The caller must ensure that this + * context is at least as long-lived as the info struct itself. This is + * not a problem in typical cases where the info struct is on the stack or + * in freshly-palloc'd space. However, if one intends to store an info + * struct in a long-lived table, it's better to use fmgr_info_cxt. + */ +void +fmgr_info(Oid functionId, FmgrInfo *finfo) +{ + fmgr_info_cxt_security(functionId, finfo, CurrentMemoryContext, false); +} + +/* + * Fill a FmgrInfo struct, specifying a memory context in which its + * subsidiary data should go. + */ +void +fmgr_info_cxt(Oid functionId, FmgrInfo *finfo, MemoryContext mcxt) +{ + fmgr_info_cxt_security(functionId, finfo, mcxt, false); +} + +/* + * This one does the actual work. ignore_security is ordinarily false + * but is set to true when we need to avoid recursion. + */ +static void +fmgr_info_cxt_security(Oid functionId, FmgrInfo *finfo, MemoryContext mcxt, + bool ignore_security) +{ + const FmgrBuiltin *fbp; + HeapTuple procedureTuple; + Form_pg_proc procedureStruct; + Datum prosrcdatum; + bool isnull; + char *prosrc; + + /* + * fn_oid *must* be filled in last. Some code assumes that if fn_oid is + * valid, the whole struct is valid. Some FmgrInfo struct's do survive + * elogs. + */ + finfo->fn_oid = InvalidOid; + finfo->fn_extra = NULL; + finfo->fn_mcxt = mcxt; + finfo->fn_expr = NULL; /* caller may set this later */ + + if ((fbp = fmgr_isbuiltin(functionId)) != NULL) + { + /* + * Fast path for builtin functions: don't bother consulting pg_proc + */ + finfo->fn_nargs = fbp->nargs; + finfo->fn_strict = fbp->strict; + finfo->fn_retset = fbp->retset; + finfo->fn_stats = TRACK_FUNC_ALL; /* ie, never track */ + finfo->fn_addr = fbp->func; + finfo->fn_oid = functionId; + return; + } + + /* Otherwise we need the pg_proc entry */ + procedureTuple = SearchSysCache1(PROCOID, ObjectIdGetDatum(functionId)); + if (!HeapTupleIsValid(procedureTuple)) + elog(ERROR, "cache lookup failed for function %u", functionId); + procedureStruct = (Form_pg_proc) GETSTRUCT(procedureTuple); + + finfo->fn_nargs = procedureStruct->pronargs; + finfo->fn_strict = procedureStruct->proisstrict; + finfo->fn_retset = procedureStruct->proretset; + + /* + * If it has prosecdef set, non-null proconfig, or if a plugin wants to + * hook function entry/exit, use fmgr_security_definer call handler --- + * unless we are being called again by fmgr_security_definer or + * fmgr_info_other_lang. + * + * When using fmgr_security_definer, function stats tracking is always + * disabled at the outer level, and instead we set the flag properly in + * fmgr_security_definer's private flinfo and implement the tracking + * inside fmgr_security_definer. This loses the ability to charge the + * overhead of fmgr_security_definer to the function, but gains the + * ability to set the track_functions GUC as a local GUC parameter of an + * interesting function and have the right things happen. + */ + if (!ignore_security && + (procedureStruct->prosecdef || + !heap_attisnull(procedureTuple, Anum_pg_proc_proconfig, NULL) || + FmgrHookIsNeeded(functionId))) + { + finfo->fn_addr = fmgr_security_definer; + finfo->fn_stats = TRACK_FUNC_ALL; /* ie, never track */ + finfo->fn_oid = functionId; + ReleaseSysCache(procedureTuple); + return; + } + + switch (procedureStruct->prolang) + { + case INTERNALlanguageId: + + /* + * For an ordinary builtin function, we should never get here + * because the fmgr_isbuiltin() search above will have succeeded. + * However, if the user has done a CREATE FUNCTION to create an + * alias for a builtin function, we can end up here. In that case + * we have to look up the function by name. The name of the + * internal function is stored in prosrc (it doesn't have to be + * the same as the name of the alias!) + */ + prosrcdatum = SysCacheGetAttr(PROCOID, procedureTuple, + Anum_pg_proc_prosrc, &isnull); + if (isnull) + elog(ERROR, "null prosrc"); + prosrc = TextDatumGetCString(prosrcdatum); + fbp = fmgr_lookupByName(prosrc); + if (fbp == NULL) + ereport(ERROR, + (errcode(ERRCODE_UNDEFINED_FUNCTION), + errmsg("internal function \"%s\" is not in internal lookup table", + prosrc))); + pfree(prosrc); + /* Should we check that nargs, strict, retset match the table? */ + finfo->fn_addr = fbp->func; + /* note this policy is also assumed in fast path above */ + finfo->fn_stats = TRACK_FUNC_ALL; /* ie, never track */ + break; + + case ClanguageId: + fmgr_info_C_lang(functionId, finfo, procedureTuple); + finfo->fn_stats = TRACK_FUNC_PL; /* ie, track if ALL */ + break; + + case SQLlanguageId: + finfo->fn_addr = fmgr_sql; + finfo->fn_stats = TRACK_FUNC_PL; /* ie, track if ALL */ + break; + + default: + fmgr_info_other_lang(functionId, finfo, procedureTuple); + finfo->fn_stats = TRACK_FUNC_OFF; /* ie, track if not OFF */ + break; + } + + finfo->fn_oid = functionId; + ReleaseSysCache(procedureTuple); +} + +/* + * Return module and C function name providing implementation of functionId. + * + * If *mod == NULL and *fn == NULL, no C symbol is known to implement + * function. + * + * If *mod == NULL and *fn != NULL, the function is implemented by a symbol in + * the main binary. + * + * If *mod != NULL and *fn != NULL the function is implemented in an extension + * shared object. + * + * The returned module and function names are pstrdup'ed into the current + * memory context. + */ +void +fmgr_symbol(Oid functionId, char **mod, char **fn) +{ + HeapTuple procedureTuple; + Form_pg_proc procedureStruct; + bool isnull; + Datum prosrcattr; + Datum probinattr; + + procedureTuple = SearchSysCache1(PROCOID, ObjectIdGetDatum(functionId)); + if (!HeapTupleIsValid(procedureTuple)) + elog(ERROR, "cache lookup failed for function %u", functionId); + procedureStruct = (Form_pg_proc) GETSTRUCT(procedureTuple); + + if (procedureStruct->prosecdef || + !heap_attisnull(procedureTuple, Anum_pg_proc_proconfig, NULL) || + FmgrHookIsNeeded(functionId)) + { + *mod = NULL; /* core binary */ + *fn = pstrdup("fmgr_security_definer"); + ReleaseSysCache(procedureTuple); + return; + } + + /* see fmgr_info_cxt_security for the individual cases */ + switch (procedureStruct->prolang) + { + case INTERNALlanguageId: + prosrcattr = SysCacheGetAttr(PROCOID, procedureTuple, + Anum_pg_proc_prosrc, &isnull); + if (isnull) + elog(ERROR, "null prosrc"); + + *mod = NULL; /* core binary */ + *fn = TextDatumGetCString(prosrcattr); + break; + + case ClanguageId: + prosrcattr = SysCacheGetAttr(PROCOID, procedureTuple, + Anum_pg_proc_prosrc, &isnull); + if (isnull) + elog(ERROR, "null prosrc for C function %u", functionId); + + probinattr = SysCacheGetAttr(PROCOID, procedureTuple, + Anum_pg_proc_probin, &isnull); + if (isnull) + elog(ERROR, "null probin for C function %u", functionId); + + /* + * No need to check symbol presence / API version here, already + * checked in fmgr_info_cxt_security. + */ + *mod = TextDatumGetCString(probinattr); + *fn = TextDatumGetCString(prosrcattr); + break; + + case SQLlanguageId: + *mod = NULL; /* core binary */ + *fn = pstrdup("fmgr_sql"); + break; + + default: + *mod = NULL; + *fn = NULL; /* unknown, pass pointer */ + break; + } + + ReleaseSysCache(procedureTuple); +} + + +/* + * Special fmgr_info processing for C-language functions. Note that + * finfo->fn_oid is not valid yet. + */ +static void +fmgr_info_C_lang(Oid functionId, FmgrInfo *finfo, HeapTuple procedureTuple) +{ + CFuncHashTabEntry *hashentry; + PGFunction user_fn; + const Pg_finfo_record *inforec; + bool isnull; + + /* + * See if we have the function address cached already + */ + hashentry = lookup_C_func(procedureTuple); + if (hashentry) + { + user_fn = hashentry->user_fn; + inforec = hashentry->inforec; + } + else + { + Datum prosrcattr, + probinattr; + char *prosrcstring, + *probinstring; + void *libraryhandle; + + /* + * Get prosrc and probin strings (link symbol and library filename). + * While in general these columns might be null, that's not allowed + * for C-language functions. + */ + prosrcattr = SysCacheGetAttr(PROCOID, procedureTuple, + Anum_pg_proc_prosrc, &isnull); + if (isnull) + elog(ERROR, "null prosrc for C function %u", functionId); + prosrcstring = TextDatumGetCString(prosrcattr); + + probinattr = SysCacheGetAttr(PROCOID, procedureTuple, + Anum_pg_proc_probin, &isnull); + if (isnull) + elog(ERROR, "null probin for C function %u", functionId); + probinstring = TextDatumGetCString(probinattr); + + /* Look up the function itself */ + user_fn = load_external_function(probinstring, prosrcstring, true, + &libraryhandle); + + /* Get the function information record (real or default) */ + inforec = fetch_finfo_record(libraryhandle, prosrcstring); + + /* Cache the addresses for later calls */ + record_C_func(procedureTuple, user_fn, inforec); + + pfree(prosrcstring); + pfree(probinstring); + } + + switch (inforec->api_version) + { + case 1: + /* New style: call directly */ + finfo->fn_addr = user_fn; + break; + default: + /* Shouldn't get here if fetch_finfo_record did its job */ + elog(ERROR, "unrecognized function API version: %d", + inforec->api_version); + break; + } +} + +/* + * Special fmgr_info processing for other-language functions. Note + * that finfo->fn_oid is not valid yet. + */ +static void +fmgr_info_other_lang(Oid functionId, FmgrInfo *finfo, HeapTuple procedureTuple) +{ + Form_pg_proc procedureStruct = (Form_pg_proc) GETSTRUCT(procedureTuple); + Oid language = procedureStruct->prolang; + HeapTuple languageTuple; + Form_pg_language languageStruct; + FmgrInfo plfinfo; + + languageTuple = SearchSysCache1(LANGOID, ObjectIdGetDatum(language)); + if (!HeapTupleIsValid(languageTuple)) + elog(ERROR, "cache lookup failed for language %u", language); + languageStruct = (Form_pg_language) GETSTRUCT(languageTuple); + + /* + * Look up the language's call handler function, ignoring any attributes + * that would normally cause insertion of fmgr_security_definer. We need + * to get back a bare pointer to the actual C-language function. + */ + fmgr_info_cxt_security(languageStruct->lanplcallfoid, &plfinfo, + CurrentMemoryContext, true); + finfo->fn_addr = plfinfo.fn_addr; + + ReleaseSysCache(languageTuple); +} + +/* + * Fetch and validate the information record for the given external function. + * The function is specified by a handle for the containing library + * (obtained from load_external_function) as well as the function name. + * + * If no info function exists for the given name an error is raised. + * + * This function is broken out of fmgr_info_C_lang so that fmgr_c_validator + * can validate the information record for a function not yet entered into + * pg_proc. + */ +const Pg_finfo_record * +fetch_finfo_record(void *filehandle, const char *funcname) +{ + char *infofuncname; + PGFInfoFunction infofunc; + const Pg_finfo_record *inforec; + + infofuncname = psprintf("pg_finfo_%s", funcname); + + /* Try to look up the info function */ + infofunc = (PGFInfoFunction) lookup_external_function(filehandle, + infofuncname); + if (infofunc == NULL) + { + ereport(ERROR, + (errcode(ERRCODE_UNDEFINED_FUNCTION), + errmsg("could not find function information for function \"%s\"", + funcname), + errhint("SQL-callable functions need an accompanying PG_FUNCTION_INFO_V1(funcname)."))); + return NULL; /* silence compiler */ + } + + /* Found, so call it */ + inforec = (*infofunc) (); + + /* Validate result as best we can */ + if (inforec == NULL) + elog(ERROR, "null result from info function \"%s\"", infofuncname); + switch (inforec->api_version) + { + case 1: + /* OK, no additional fields to validate */ + break; + default: + ereport(ERROR, + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), + errmsg("unrecognized API version %d reported by info function \"%s\"", + inforec->api_version, infofuncname))); + break; + } + + pfree(infofuncname); + return inforec; +} + + +/*------------------------------------------------------------------------- + * Routines for caching lookup information for external C functions. + * + * The routines in dfmgr.c are relatively slow, so we try to avoid running + * them more than once per external function per session. We use a hash table + * with the function OID as the lookup key. + *------------------------------------------------------------------------- + */ + +/* + * lookup_C_func: try to find a C function in the hash table + * + * If an entry exists and is up to date, return it; else return NULL + */ +static CFuncHashTabEntry * +lookup_C_func(HeapTuple procedureTuple) +{ + Oid fn_oid = ((Form_pg_proc) GETSTRUCT(procedureTuple))->oid; + CFuncHashTabEntry *entry; + + if (CFuncHash == NULL) + return NULL; /* no table yet */ + entry = (CFuncHashTabEntry *) + hash_search(CFuncHash, + &fn_oid, + HASH_FIND, + NULL); + if (entry == NULL) + return NULL; /* no such entry */ + if (entry->fn_xmin == HeapTupleHeaderGetRawXmin(procedureTuple->t_data) && + ItemPointerEquals(&entry->fn_tid, &procedureTuple->t_self)) + return entry; /* OK */ + return NULL; /* entry is out of date */ +} + +/* + * record_C_func: enter (or update) info about a C function in the hash table + */ +static void +record_C_func(HeapTuple procedureTuple, + PGFunction user_fn, const Pg_finfo_record *inforec) +{ + Oid fn_oid = ((Form_pg_proc) GETSTRUCT(procedureTuple))->oid; + CFuncHashTabEntry *entry; + bool found; + + /* Create the hash table if it doesn't exist yet */ + if (CFuncHash == NULL) + { + HASHCTL hash_ctl; + + hash_ctl.keysize = sizeof(Oid); + hash_ctl.entrysize = sizeof(CFuncHashTabEntry); + CFuncHash = hash_create("CFuncHash", + 100, + &hash_ctl, + HASH_ELEM | HASH_BLOBS); + } + + entry = (CFuncHashTabEntry *) + hash_search(CFuncHash, + &fn_oid, + HASH_ENTER, + &found); + /* OID is already filled in */ + entry->fn_xmin = HeapTupleHeaderGetRawXmin(procedureTuple->t_data); + entry->fn_tid = procedureTuple->t_self; + entry->user_fn = user_fn; + entry->inforec = inforec; +} + + +/* + * Copy an FmgrInfo struct + * + * This is inherently somewhat bogus since we can't reliably duplicate + * language-dependent subsidiary info. We cheat by zeroing fn_extra, + * instead, meaning that subsidiary info will have to be recomputed. + */ +void +fmgr_info_copy(FmgrInfo *dstinfo, FmgrInfo *srcinfo, + MemoryContext destcxt) +{ + memcpy(dstinfo, srcinfo, sizeof(FmgrInfo)); + dstinfo->fn_mcxt = destcxt; + dstinfo->fn_extra = NULL; +} + + +/* + * Specialized lookup routine for fmgr_internal_validator: given the alleged + * name of an internal function, return the OID of the function. + * If the name is not recognized, return InvalidOid. + */ +Oid +fmgr_internal_function(const char *proname) +{ + const FmgrBuiltin *fbp = fmgr_lookupByName(proname); + + if (fbp == NULL) + return InvalidOid; + return fbp->foid; +} + + +/* + * Support for security-definer and proconfig-using functions. We support + * both of these features using the same call handler, because they are + * often used together and it would be inefficient (as well as notationally + * messy) to have two levels of call handler involved. + */ +struct fmgr_security_definer_cache +{ + FmgrInfo flinfo; /* lookup info for target function */ + Oid userid; /* userid to set, or InvalidOid */ + ArrayType *proconfig; /* GUC values to set, or NULL */ + Datum arg; /* passthrough argument for plugin modules */ +}; + +/* + * Function handler for security-definer/proconfig/plugin-hooked functions. + * We extract the OID of the actual function and do a fmgr lookup again. + * Then we fetch the pg_proc row and copy the owner ID and proconfig fields. + * (All this info is cached for the duration of the current query.) + * To execute a call, we temporarily replace the flinfo with the cached + * and looked-up one, while keeping the outer fcinfo (which contains all + * the actual arguments, etc.) intact. This is not re-entrant, but then + * the fcinfo itself can't be used reentrantly anyway. + */ +extern Datum +fmgr_security_definer(PG_FUNCTION_ARGS) +{ + Datum result; + struct fmgr_security_definer_cache *volatile fcache; + FmgrInfo *save_flinfo; + Oid save_userid; + int save_sec_context; + volatile int save_nestlevel; + PgStat_FunctionCallUsage fcusage; + + if (!fcinfo->flinfo->fn_extra) + { + HeapTuple tuple; + Form_pg_proc procedureStruct; + Datum datum; + bool isnull; + MemoryContext oldcxt; + + fcache = MemoryContextAllocZero(fcinfo->flinfo->fn_mcxt, + sizeof(*fcache)); + + fmgr_info_cxt_security(fcinfo->flinfo->fn_oid, &fcache->flinfo, + fcinfo->flinfo->fn_mcxt, true); + fcache->flinfo.fn_expr = fcinfo->flinfo->fn_expr; + + tuple = SearchSysCache1(PROCOID, + ObjectIdGetDatum(fcinfo->flinfo->fn_oid)); + if (!HeapTupleIsValid(tuple)) + elog(ERROR, "cache lookup failed for function %u", + fcinfo->flinfo->fn_oid); + procedureStruct = (Form_pg_proc) GETSTRUCT(tuple); + + if (procedureStruct->prosecdef) + fcache->userid = procedureStruct->proowner; + + datum = SysCacheGetAttr(PROCOID, tuple, Anum_pg_proc_proconfig, + &isnull); + if (!isnull) + { + oldcxt = MemoryContextSwitchTo(fcinfo->flinfo->fn_mcxt); + fcache->proconfig = DatumGetArrayTypePCopy(datum); + MemoryContextSwitchTo(oldcxt); + } + + ReleaseSysCache(tuple); + + fcinfo->flinfo->fn_extra = fcache; + } + else + fcache = fcinfo->flinfo->fn_extra; + + /* GetUserIdAndSecContext is cheap enough that no harm in a wasted call */ + GetUserIdAndSecContext(&save_userid, &save_sec_context); + if (fcache->proconfig) /* Need a new GUC nesting level */ + save_nestlevel = NewGUCNestLevel(); + else + save_nestlevel = 0; /* keep compiler quiet */ + + if (OidIsValid(fcache->userid)) + SetUserIdAndSecContext(fcache->userid, + save_sec_context | SECURITY_LOCAL_USERID_CHANGE); + + if (fcache->proconfig) + { + ProcessGUCArray(fcache->proconfig, + (superuser() ? PGC_SUSET : PGC_USERSET), + PGC_S_SESSION, + GUC_ACTION_SAVE); + } + + /* function manager hook */ + if (fmgr_hook) + (*fmgr_hook) (FHET_START, &fcache->flinfo, &fcache->arg); + + /* + * We don't need to restore GUC or userid settings on error, because the + * ensuing xact or subxact abort will do that. The PG_TRY block is only + * needed to clean up the flinfo link. + */ + save_flinfo = fcinfo->flinfo; + + PG_TRY(); + { + fcinfo->flinfo = &fcache->flinfo; + + /* See notes in fmgr_info_cxt_security */ + pgstat_init_function_usage(fcinfo, &fcusage); + + result = FunctionCallInvoke(fcinfo); + + /* + * We could be calling either a regular or a set-returning function, + * so we have to test to see what finalize flag to use. + */ + pgstat_end_function_usage(&fcusage, + (fcinfo->resultinfo == NULL || + !IsA(fcinfo->resultinfo, ReturnSetInfo) || + ((ReturnSetInfo *) fcinfo->resultinfo)->isDone != ExprMultipleResult)); + } + PG_CATCH(); + { + fcinfo->flinfo = save_flinfo; + if (fmgr_hook) + (*fmgr_hook) (FHET_ABORT, &fcache->flinfo, &fcache->arg); + PG_RE_THROW(); + } + PG_END_TRY(); + + fcinfo->flinfo = save_flinfo; + + if (fcache->proconfig) + AtEOXact_GUC(true, save_nestlevel); + if (OidIsValid(fcache->userid)) + SetUserIdAndSecContext(save_userid, save_sec_context); + if (fmgr_hook) + (*fmgr_hook) (FHET_END, &fcache->flinfo, &fcache->arg); + + return result; +} + + +/*------------------------------------------------------------------------- + * Support routines 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. + */ +Datum +DirectFunctionCall1Coll(PGFunction func, Oid collation, Datum arg1) +{ + LOCAL_FCINFO(fcinfo, 1); + Datum result; + + InitFunctionCallInfoData(*fcinfo, NULL, 1, collation, NULL, NULL); + + fcinfo->args[0].value = arg1; + fcinfo->args[0].isnull = false; + + result = (*func) (fcinfo); + + /* Check for null result, since caller is clearly not expecting one */ + if (fcinfo->isnull) + elog(ERROR, "function %p returned NULL", (void *) func); + + return result; +} + +Datum +DirectFunctionCall2Coll(PGFunction func, Oid collation, Datum arg1, Datum arg2) +{ + LOCAL_FCINFO(fcinfo, 2); + Datum result; + + InitFunctionCallInfoData(*fcinfo, NULL, 2, collation, NULL, NULL); + + fcinfo->args[0].value = arg1; + fcinfo->args[0].isnull = false; + fcinfo->args[1].value = arg2; + fcinfo->args[1].isnull = false; + + result = (*func) (fcinfo); + + /* Check for null result, since caller is clearly not expecting one */ + if (fcinfo->isnull) + elog(ERROR, "function %p returned NULL", (void *) func); + + return result; +} + +Datum +DirectFunctionCall3Coll(PGFunction func, Oid collation, Datum arg1, Datum arg2, + Datum arg3) +{ + LOCAL_FCINFO(fcinfo, 3); + Datum result; + + InitFunctionCallInfoData(*fcinfo, NULL, 3, collation, NULL, NULL); + + fcinfo->args[0].value = arg1; + fcinfo->args[0].isnull = false; + fcinfo->args[1].value = arg2; + fcinfo->args[1].isnull = false; + fcinfo->args[2].value = arg3; + fcinfo->args[2].isnull = false; + + result = (*func) (fcinfo); + + /* Check for null result, since caller is clearly not expecting one */ + if (fcinfo->isnull) + elog(ERROR, "function %p returned NULL", (void *) func); + + return result; +} + +Datum +DirectFunctionCall4Coll(PGFunction func, Oid collation, Datum arg1, Datum arg2, + Datum arg3, Datum arg4) +{ + LOCAL_FCINFO(fcinfo, 4); + Datum result; + + InitFunctionCallInfoData(*fcinfo, NULL, 4, collation, NULL, NULL); + + fcinfo->args[0].value = arg1; + fcinfo->args[0].isnull = false; + fcinfo->args[1].value = arg2; + fcinfo->args[1].isnull = false; + fcinfo->args[2].value = arg3; + fcinfo->args[2].isnull = false; + fcinfo->args[3].value = arg4; + fcinfo->args[3].isnull = false; + + result = (*func) (fcinfo); + + /* Check for null result, since caller is clearly not expecting one */ + if (fcinfo->isnull) + elog(ERROR, "function %p returned NULL", (void *) func); + + return result; +} + +Datum +DirectFunctionCall5Coll(PGFunction func, Oid collation, Datum arg1, Datum arg2, + Datum arg3, Datum arg4, Datum arg5) +{ + LOCAL_FCINFO(fcinfo, 5); + Datum result; + + InitFunctionCallInfoData(*fcinfo, NULL, 5, collation, NULL, NULL); + + fcinfo->args[0].value = arg1; + fcinfo->args[0].isnull = false; + fcinfo->args[1].value = arg2; + fcinfo->args[1].isnull = false; + fcinfo->args[2].value = arg3; + fcinfo->args[2].isnull = false; + fcinfo->args[3].value = arg4; + fcinfo->args[3].isnull = false; + fcinfo->args[4].value = arg5; + fcinfo->args[4].isnull = false; + + result = (*func) (fcinfo); + + /* Check for null result, since caller is clearly not expecting one */ + if (fcinfo->isnull) + elog(ERROR, "function %p returned NULL", (void *) func); + + return result; +} + +Datum +DirectFunctionCall6Coll(PGFunction func, Oid collation, Datum arg1, Datum arg2, + Datum arg3, Datum arg4, Datum arg5, + Datum arg6) +{ + LOCAL_FCINFO(fcinfo, 6); + Datum result; + + InitFunctionCallInfoData(*fcinfo, NULL, 6, collation, NULL, NULL); + + fcinfo->args[0].value = arg1; + fcinfo->args[0].isnull = false; + fcinfo->args[1].value = arg2; + fcinfo->args[1].isnull = false; + fcinfo->args[2].value = arg3; + fcinfo->args[2].isnull = false; + fcinfo->args[3].value = arg4; + fcinfo->args[3].isnull = false; + fcinfo->args[4].value = arg5; + fcinfo->args[4].isnull = false; + fcinfo->args[5].value = arg6; + fcinfo->args[5].isnull = false; + + result = (*func) (fcinfo); + + /* Check for null result, since caller is clearly not expecting one */ + if (fcinfo->isnull) + elog(ERROR, "function %p returned NULL", (void *) func); + + return result; +} + +Datum +DirectFunctionCall7Coll(PGFunction func, Oid collation, Datum arg1, Datum arg2, + Datum arg3, Datum arg4, Datum arg5, + Datum arg6, Datum arg7) +{ + LOCAL_FCINFO(fcinfo, 7); + Datum result; + + InitFunctionCallInfoData(*fcinfo, NULL, 7, collation, NULL, NULL); + + fcinfo->args[0].value = arg1; + fcinfo->args[0].isnull = false; + fcinfo->args[1].value = arg2; + fcinfo->args[1].isnull = false; + fcinfo->args[2].value = arg3; + fcinfo->args[2].isnull = false; + fcinfo->args[3].value = arg4; + fcinfo->args[3].isnull = false; + fcinfo->args[4].value = arg5; + fcinfo->args[4].isnull = false; + fcinfo->args[5].value = arg6; + fcinfo->args[5].isnull = false; + fcinfo->args[6].value = arg7; + fcinfo->args[6].isnull = false; + + result = (*func) (fcinfo); + + /* Check for null result, since caller is clearly not expecting one */ + if (fcinfo->isnull) + elog(ERROR, "function %p returned NULL", (void *) func); + + return result; +} + +Datum +DirectFunctionCall8Coll(PGFunction func, Oid collation, Datum arg1, Datum arg2, + Datum arg3, Datum arg4, Datum arg5, + Datum arg6, Datum arg7, Datum arg8) +{ + LOCAL_FCINFO(fcinfo, 8); + Datum result; + + InitFunctionCallInfoData(*fcinfo, NULL, 8, collation, NULL, NULL); + + fcinfo->args[0].value = arg1; + fcinfo->args[0].isnull = false; + fcinfo->args[1].value = arg2; + fcinfo->args[1].isnull = false; + fcinfo->args[2].value = arg3; + fcinfo->args[2].isnull = false; + fcinfo->args[3].value = arg4; + fcinfo->args[3].isnull = false; + fcinfo->args[4].value = arg5; + fcinfo->args[4].isnull = false; + fcinfo->args[5].value = arg6; + fcinfo->args[5].isnull = false; + fcinfo->args[6].value = arg7; + fcinfo->args[6].isnull = false; + fcinfo->args[7].value = arg8; + fcinfo->args[7].isnull = false; + + result = (*func) (fcinfo); + + /* Check for null result, since caller is clearly not expecting one */ + if (fcinfo->isnull) + elog(ERROR, "function %p returned NULL", (void *) func); + + return result; +} + +Datum +DirectFunctionCall9Coll(PGFunction func, Oid collation, Datum arg1, Datum arg2, + Datum arg3, Datum arg4, Datum arg5, + Datum arg6, Datum arg7, Datum arg8, + Datum arg9) +{ + LOCAL_FCINFO(fcinfo, 9); + Datum result; + + InitFunctionCallInfoData(*fcinfo, NULL, 9, collation, NULL, NULL); + + fcinfo->args[0].value = arg1; + fcinfo->args[0].isnull = false; + fcinfo->args[1].value = arg2; + fcinfo->args[1].isnull = false; + fcinfo->args[2].value = arg3; + fcinfo->args[2].isnull = false; + fcinfo->args[3].value = arg4; + fcinfo->args[3].isnull = false; + fcinfo->args[4].value = arg5; + fcinfo->args[4].isnull = false; + fcinfo->args[5].value = arg6; + fcinfo->args[5].isnull = false; + fcinfo->args[6].value = arg7; + fcinfo->args[6].isnull = false; + fcinfo->args[7].value = arg8; + fcinfo->args[7].isnull = false; + fcinfo->args[8].value = arg9; + fcinfo->args[8].isnull = false; + + result = (*func) (fcinfo); + + /* Check for null result, since caller is clearly not expecting one */ + if (fcinfo->isnull) + elog(ERROR, "function %p returned NULL", (void *) func); + + return result; +} + +/* + * 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. + */ + +Datum +CallerFInfoFunctionCall1(PGFunction func, FmgrInfo *flinfo, Oid collation, Datum arg1) +{ + LOCAL_FCINFO(fcinfo, 1); + Datum result; + + InitFunctionCallInfoData(*fcinfo, flinfo, 1, collation, NULL, NULL); + + fcinfo->args[0].value = arg1; + fcinfo->args[0].isnull = false; + + result = (*func) (fcinfo); + + /* Check for null result, since caller is clearly not expecting one */ + if (fcinfo->isnull) + elog(ERROR, "function %p returned NULL", (void *) func); + + return result; +} + +Datum +CallerFInfoFunctionCall2(PGFunction func, FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2) +{ + LOCAL_FCINFO(fcinfo, 2); + Datum result; + + InitFunctionCallInfoData(*fcinfo, flinfo, 2, collation, NULL, NULL); + + fcinfo->args[0].value = arg1; + fcinfo->args[0].isnull = false; + fcinfo->args[1].value = arg2; + fcinfo->args[1].isnull = false; + + result = (*func) (fcinfo); + + /* Check for null result, since caller is clearly not expecting one */ + if (fcinfo->isnull) + elog(ERROR, "function %p returned NULL", (void *) func); + + return result; +} + +/* + * 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. + */ +Datum +FunctionCall0Coll(FmgrInfo *flinfo, Oid collation) +{ + LOCAL_FCINFO(fcinfo, 0); + Datum result; + + InitFunctionCallInfoData(*fcinfo, flinfo, 0, collation, NULL, NULL); + + result = FunctionCallInvoke(fcinfo); + + /* Check for null result, since caller is clearly not expecting one */ + if (fcinfo->isnull) + elog(ERROR, "function %u returned NULL", flinfo->fn_oid); + + return result; +} + +Datum +FunctionCall1Coll(FmgrInfo *flinfo, Oid collation, Datum arg1) +{ + LOCAL_FCINFO(fcinfo, 1); + Datum result; + + InitFunctionCallInfoData(*fcinfo, flinfo, 1, collation, NULL, NULL); + + fcinfo->args[0].value = arg1; + fcinfo->args[0].isnull = false; + + result = FunctionCallInvoke(fcinfo); + + /* Check for null result, since caller is clearly not expecting one */ + if (fcinfo->isnull) + elog(ERROR, "function %u returned NULL", flinfo->fn_oid); + + return result; +} + +Datum +FunctionCall2Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2) +{ + LOCAL_FCINFO(fcinfo, 2); + Datum result; + + InitFunctionCallInfoData(*fcinfo, flinfo, 2, collation, NULL, NULL); + + fcinfo->args[0].value = arg1; + fcinfo->args[0].isnull = false; + fcinfo->args[1].value = arg2; + fcinfo->args[1].isnull = false; + + result = FunctionCallInvoke(fcinfo); + + /* Check for null result, since caller is clearly not expecting one */ + if (fcinfo->isnull) + elog(ERROR, "function %u returned NULL", flinfo->fn_oid); + + return result; +} + +Datum +FunctionCall3Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2, + Datum arg3) +{ + LOCAL_FCINFO(fcinfo, 3); + Datum result; + + InitFunctionCallInfoData(*fcinfo, flinfo, 3, collation, NULL, NULL); + + fcinfo->args[0].value = arg1; + fcinfo->args[0].isnull = false; + fcinfo->args[1].value = arg2; + fcinfo->args[1].isnull = false; + fcinfo->args[2].value = arg3; + fcinfo->args[2].isnull = false; + + result = FunctionCallInvoke(fcinfo); + + /* Check for null result, since caller is clearly not expecting one */ + if (fcinfo->isnull) + elog(ERROR, "function %u returned NULL", flinfo->fn_oid); + + return result; +} + +Datum +FunctionCall4Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2, + Datum arg3, Datum arg4) +{ + LOCAL_FCINFO(fcinfo, 4); + Datum result; + + InitFunctionCallInfoData(*fcinfo, flinfo, 4, collation, NULL, NULL); + + fcinfo->args[0].value = arg1; + fcinfo->args[0].isnull = false; + fcinfo->args[1].value = arg2; + fcinfo->args[1].isnull = false; + fcinfo->args[2].value = arg3; + fcinfo->args[2].isnull = false; + fcinfo->args[3].value = arg4; + fcinfo->args[3].isnull = false; + + result = FunctionCallInvoke(fcinfo); + + /* Check for null result, since caller is clearly not expecting one */ + if (fcinfo->isnull) + elog(ERROR, "function %u returned NULL", flinfo->fn_oid); + + return result; +} + +Datum +FunctionCall5Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2, + Datum arg3, Datum arg4, Datum arg5) +{ + LOCAL_FCINFO(fcinfo, 5); + Datum result; + + InitFunctionCallInfoData(*fcinfo, flinfo, 5, collation, NULL, NULL); + + fcinfo->args[0].value = arg1; + fcinfo->args[0].isnull = false; + fcinfo->args[1].value = arg2; + fcinfo->args[1].isnull = false; + fcinfo->args[2].value = arg3; + fcinfo->args[2].isnull = false; + fcinfo->args[3].value = arg4; + fcinfo->args[3].isnull = false; + fcinfo->args[4].value = arg5; + fcinfo->args[4].isnull = false; + + result = FunctionCallInvoke(fcinfo); + + /* Check for null result, since caller is clearly not expecting one */ + if (fcinfo->isnull) + elog(ERROR, "function %u returned NULL", flinfo->fn_oid); + + return result; +} + +Datum +FunctionCall6Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2, + Datum arg3, Datum arg4, Datum arg5, + Datum arg6) +{ + LOCAL_FCINFO(fcinfo, 6); + Datum result; + + InitFunctionCallInfoData(*fcinfo, flinfo, 6, collation, NULL, NULL); + + fcinfo->args[0].value = arg1; + fcinfo->args[0].isnull = false; + fcinfo->args[1].value = arg2; + fcinfo->args[1].isnull = false; + fcinfo->args[2].value = arg3; + fcinfo->args[2].isnull = false; + fcinfo->args[3].value = arg4; + fcinfo->args[3].isnull = false; + fcinfo->args[4].value = arg5; + fcinfo->args[4].isnull = false; + fcinfo->args[5].value = arg6; + fcinfo->args[5].isnull = false; + + result = FunctionCallInvoke(fcinfo); + + /* Check for null result, since caller is clearly not expecting one */ + if (fcinfo->isnull) + elog(ERROR, "function %u returned NULL", flinfo->fn_oid); + + return result; +} + +Datum +FunctionCall7Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2, + Datum arg3, Datum arg4, Datum arg5, + Datum arg6, Datum arg7) +{ + LOCAL_FCINFO(fcinfo, 7); + Datum result; + + InitFunctionCallInfoData(*fcinfo, flinfo, 7, collation, NULL, NULL); + + fcinfo->args[0].value = arg1; + fcinfo->args[0].isnull = false; + fcinfo->args[1].value = arg2; + fcinfo->args[1].isnull = false; + fcinfo->args[2].value = arg3; + fcinfo->args[2].isnull = false; + fcinfo->args[3].value = arg4; + fcinfo->args[3].isnull = false; + fcinfo->args[4].value = arg5; + fcinfo->args[4].isnull = false; + fcinfo->args[5].value = arg6; + fcinfo->args[5].isnull = false; + fcinfo->args[6].value = arg7; + fcinfo->args[6].isnull = false; + + result = FunctionCallInvoke(fcinfo); + + /* Check for null result, since caller is clearly not expecting one */ + if (fcinfo->isnull) + elog(ERROR, "function %u returned NULL", flinfo->fn_oid); + + return result; +} + +Datum +FunctionCall8Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2, + Datum arg3, Datum arg4, Datum arg5, + Datum arg6, Datum arg7, Datum arg8) +{ + LOCAL_FCINFO(fcinfo, 8); + Datum result; + + InitFunctionCallInfoData(*fcinfo, flinfo, 8, collation, NULL, NULL); + + fcinfo->args[0].value = arg1; + fcinfo->args[0].isnull = false; + fcinfo->args[1].value = arg2; + fcinfo->args[1].isnull = false; + fcinfo->args[2].value = arg3; + fcinfo->args[2].isnull = false; + fcinfo->args[3].value = arg4; + fcinfo->args[3].isnull = false; + fcinfo->args[4].value = arg5; + fcinfo->args[4].isnull = false; + fcinfo->args[5].value = arg6; + fcinfo->args[5].isnull = false; + fcinfo->args[6].value = arg7; + fcinfo->args[6].isnull = false; + fcinfo->args[7].value = arg8; + fcinfo->args[7].isnull = false; + + result = FunctionCallInvoke(fcinfo); + + /* Check for null result, since caller is clearly not expecting one */ + if (fcinfo->isnull) + elog(ERROR, "function %u returned NULL", flinfo->fn_oid); + + return result; +} + +Datum +FunctionCall9Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2, + Datum arg3, Datum arg4, Datum arg5, + Datum arg6, Datum arg7, Datum arg8, + Datum arg9) +{ + LOCAL_FCINFO(fcinfo, 9); + Datum result; + + InitFunctionCallInfoData(*fcinfo, flinfo, 9, collation, NULL, NULL); + + fcinfo->args[0].value = arg1; + fcinfo->args[0].isnull = false; + fcinfo->args[1].value = arg2; + fcinfo->args[1].isnull = false; + fcinfo->args[2].value = arg3; + fcinfo->args[2].isnull = false; + fcinfo->args[3].value = arg4; + fcinfo->args[3].isnull = false; + fcinfo->args[4].value = arg5; + fcinfo->args[4].isnull = false; + fcinfo->args[5].value = arg6; + fcinfo->args[5].isnull = false; + fcinfo->args[6].value = arg7; + fcinfo->args[6].isnull = false; + fcinfo->args[7].value = arg8; + fcinfo->args[7].isnull = false; + fcinfo->args[8].value = arg9; + fcinfo->args[8].isnull = false; + + result = FunctionCallInvoke(fcinfo); + + /* Check for null result, since caller is clearly not expecting one */ + if (fcinfo->isnull) + elog(ERROR, "function %u returned NULL", flinfo->fn_oid); + + return result; +} + + +/* + * 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(). + */ +Datum +OidFunctionCall0Coll(Oid functionId, Oid collation) +{ + FmgrInfo flinfo; + + fmgr_info(functionId, &flinfo); + + return FunctionCall0Coll(&flinfo, collation); +} + +Datum +OidFunctionCall1Coll(Oid functionId, Oid collation, Datum arg1) +{ + FmgrInfo flinfo; + + fmgr_info(functionId, &flinfo); + + return FunctionCall1Coll(&flinfo, collation, arg1); +} + +Datum +OidFunctionCall2Coll(Oid functionId, Oid collation, Datum arg1, Datum arg2) +{ + FmgrInfo flinfo; + + fmgr_info(functionId, &flinfo); + + return FunctionCall2Coll(&flinfo, collation, arg1, arg2); +} + +Datum +OidFunctionCall3Coll(Oid functionId, Oid collation, Datum arg1, Datum arg2, + Datum arg3) +{ + FmgrInfo flinfo; + + fmgr_info(functionId, &flinfo); + + return FunctionCall3Coll(&flinfo, collation, arg1, arg2, arg3); +} + +Datum +OidFunctionCall4Coll(Oid functionId, Oid collation, Datum arg1, Datum arg2, + Datum arg3, Datum arg4) +{ + FmgrInfo flinfo; + + fmgr_info(functionId, &flinfo); + + return FunctionCall4Coll(&flinfo, collation, arg1, arg2, arg3, arg4); +} + +Datum +OidFunctionCall5Coll(Oid functionId, Oid collation, Datum arg1, Datum arg2, + Datum arg3, Datum arg4, Datum arg5) +{ + FmgrInfo flinfo; + + fmgr_info(functionId, &flinfo); + + return FunctionCall5Coll(&flinfo, collation, arg1, arg2, arg3, arg4, arg5); +} + +Datum +OidFunctionCall6Coll(Oid functionId, Oid collation, Datum arg1, Datum arg2, + Datum arg3, Datum arg4, Datum arg5, + Datum arg6) +{ + FmgrInfo flinfo; + + fmgr_info(functionId, &flinfo); + + return FunctionCall6Coll(&flinfo, collation, arg1, arg2, arg3, arg4, arg5, + arg6); +} + +Datum +OidFunctionCall7Coll(Oid functionId, Oid collation, Datum arg1, Datum arg2, + Datum arg3, Datum arg4, Datum arg5, + Datum arg6, Datum arg7) +{ + FmgrInfo flinfo; + + fmgr_info(functionId, &flinfo); + + return FunctionCall7Coll(&flinfo, collation, arg1, arg2, arg3, arg4, arg5, + arg6, arg7); +} + +Datum +OidFunctionCall8Coll(Oid functionId, Oid collation, Datum arg1, Datum arg2, + Datum arg3, Datum arg4, Datum arg5, + Datum arg6, Datum arg7, Datum arg8) +{ + FmgrInfo flinfo; + + fmgr_info(functionId, &flinfo); + + return FunctionCall8Coll(&flinfo, collation, arg1, arg2, arg3, arg4, arg5, + arg6, arg7, arg8); +} + +Datum +OidFunctionCall9Coll(Oid functionId, Oid collation, Datum arg1, Datum arg2, + Datum arg3, Datum arg4, Datum arg5, + Datum arg6, Datum arg7, Datum arg8, + Datum arg9) +{ + FmgrInfo flinfo; + + fmgr_info(functionId, &flinfo); + + return FunctionCall9Coll(&flinfo, collation, arg1, arg2, arg3, arg4, arg5, + arg6, arg7, arg8, arg9); +} + + +/* + * Special cases for convenient invocation of datatype I/O functions. + */ + +/* + * Call a previously-looked-up datatype input function. + * + * "str" may be NULL to indicate we are reading a NULL. In this case + * the caller should assume the result is NULL, but we'll call the input + * function anyway if it's not strict. So this is almost but not quite + * the same as FunctionCall3. + */ +Datum +InputFunctionCall(FmgrInfo *flinfo, char *str, Oid typioparam, int32 typmod) +{ + LOCAL_FCINFO(fcinfo, 3); + Datum result; + + if (str == NULL && flinfo->fn_strict) + return (Datum) 0; /* just return null result */ + + InitFunctionCallInfoData(*fcinfo, flinfo, 3, InvalidOid, NULL, NULL); + + fcinfo->args[0].value = CStringGetDatum(str); + fcinfo->args[0].isnull = false; + fcinfo->args[1].value = ObjectIdGetDatum(typioparam); + fcinfo->args[1].isnull = false; + fcinfo->args[2].value = Int32GetDatum(typmod); + fcinfo->args[2].isnull = false; + + result = FunctionCallInvoke(fcinfo); + + /* Should get null result if and only if str is NULL */ + if (str == NULL) + { + if (!fcinfo->isnull) + elog(ERROR, "input function %u returned non-NULL", + flinfo->fn_oid); + } + else + { + if (fcinfo->isnull) + elog(ERROR, "input function %u returned NULL", + flinfo->fn_oid); + } + + return result; +} + +/* + * Call a previously-looked-up datatype output function. + * + * Do not call this on NULL datums. + * + * This is currently little more than window dressing for FunctionCall1. + */ +char * +OutputFunctionCall(FmgrInfo *flinfo, Datum val) +{ + return DatumGetCString(FunctionCall1(flinfo, val)); +} + +/* + * Call a previously-looked-up datatype binary-input function. + * + * "buf" may be NULL to indicate we are reading a NULL. In this case + * the caller should assume the result is NULL, but we'll call the receive + * function anyway if it's not strict. So this is almost but not quite + * the same as FunctionCall3. + */ +Datum +ReceiveFunctionCall(FmgrInfo *flinfo, StringInfo buf, + Oid typioparam, int32 typmod) +{ + LOCAL_FCINFO(fcinfo, 3); + Datum result; + + if (buf == NULL && flinfo->fn_strict) + return (Datum) 0; /* just return null result */ + + InitFunctionCallInfoData(*fcinfo, flinfo, 3, InvalidOid, NULL, NULL); + + fcinfo->args[0].value = PointerGetDatum(buf); + fcinfo->args[0].isnull = false; + fcinfo->args[1].value = ObjectIdGetDatum(typioparam); + fcinfo->args[1].isnull = false; + fcinfo->args[2].value = Int32GetDatum(typmod); + fcinfo->args[2].isnull = false; + + result = FunctionCallInvoke(fcinfo); + + /* Should get null result if and only if buf is NULL */ + if (buf == NULL) + { + if (!fcinfo->isnull) + elog(ERROR, "receive function %u returned non-NULL", + flinfo->fn_oid); + } + else + { + if (fcinfo->isnull) + elog(ERROR, "receive function %u returned NULL", + flinfo->fn_oid); + } + + return result; +} + +/* + * Call a previously-looked-up datatype binary-output function. + * + * Do not call this on NULL datums. + * + * This is little more than window dressing for FunctionCall1, but it does + * guarantee a non-toasted result, which strictly speaking the underlying + * function doesn't. + */ +bytea * +SendFunctionCall(FmgrInfo *flinfo, Datum val) +{ + return DatumGetByteaP(FunctionCall1(flinfo, val)); +} + +/* + * As above, for I/O functions identified by OID. These are only to be used + * in seldom-executed code paths. They are not only slow but leak memory. + */ +Datum +OidInputFunctionCall(Oid functionId, char *str, Oid typioparam, int32 typmod) +{ + FmgrInfo flinfo; + + fmgr_info(functionId, &flinfo); + return InputFunctionCall(&flinfo, str, typioparam, typmod); +} + +char * +OidOutputFunctionCall(Oid functionId, Datum val) +{ + FmgrInfo flinfo; + + fmgr_info(functionId, &flinfo); + return OutputFunctionCall(&flinfo, val); +} + +Datum +OidReceiveFunctionCall(Oid functionId, StringInfo buf, + Oid typioparam, int32 typmod) +{ + FmgrInfo flinfo; + + fmgr_info(functionId, &flinfo); + return ReceiveFunctionCall(&flinfo, buf, typioparam, typmod); +} + +bytea * +OidSendFunctionCall(Oid functionId, Datum val) +{ + FmgrInfo flinfo; + + fmgr_info(functionId, &flinfo); + return SendFunctionCall(&flinfo, val); +} + + +/*------------------------------------------------------------------------- + * Support routines for standard maybe-pass-by-reference datatypes + * + * int8 and float8 can be passed by value if Datum is wide enough. + * (For backwards-compatibility reasons, we allow pass-by-ref to be chosen + * at compile time even if pass-by-val is possible.) + * + * Note: there is only one switch controlling the pass-by-value option for + * both int8 and float8; this is to avoid making things unduly complicated + * for the timestamp types, which might have either representation. + *------------------------------------------------------------------------- + */ + +#ifndef USE_FLOAT8_BYVAL /* controls int8 too */ + +Datum +Int64GetDatum(int64 X) +{ + int64 *retval = (int64 *) palloc(sizeof(int64)); + + *retval = X; + return PointerGetDatum(retval); +} + +Datum +Float8GetDatum(float8 X) +{ + float8 *retval = (float8 *) palloc(sizeof(float8)); + + *retval = X; + return PointerGetDatum(retval); +} +#endif /* USE_FLOAT8_BYVAL */ + + +/*------------------------------------------------------------------------- + * Support routines for toastable datatypes + *------------------------------------------------------------------------- + */ + +struct varlena * +pg_detoast_datum(struct varlena *datum) +{ + if (VARATT_IS_EXTENDED(datum)) + return detoast_attr(datum); + else + return datum; +} + +struct varlena * +pg_detoast_datum_copy(struct varlena *datum) +{ + if (VARATT_IS_EXTENDED(datum)) + return detoast_attr(datum); + else + { + /* Make a modifiable copy of the varlena object */ + Size len = VARSIZE(datum); + struct varlena *result = (struct varlena *) palloc(len); + + memcpy(result, datum, len); + return result; + } +} + +struct varlena * +pg_detoast_datum_slice(struct varlena *datum, int32 first, int32 count) +{ + /* Only get the specified portion from the toast rel */ + return detoast_attr_slice(datum, first, count); +} + +struct varlena * +pg_detoast_datum_packed(struct varlena *datum) +{ + if (VARATT_IS_COMPRESSED(datum) || VARATT_IS_EXTERNAL(datum)) + return detoast_attr(datum); + else + return datum; +} + +/*------------------------------------------------------------------------- + * Support routines for extracting info from fn_expr parse tree + * + * These are needed by polymorphic functions, which accept multiple possible + * input types and need help from the parser to know what they've got. + * Also, some functions might be interested in whether a parameter is constant. + * Functions taking VARIADIC ANY also need to know about the VARIADIC keyword. + *------------------------------------------------------------------------- + */ + +/* + * Get the actual type OID of the function return type + * + * Returns InvalidOid if information is not available + */ +Oid +get_fn_expr_rettype(FmgrInfo *flinfo) +{ + Node *expr; + + /* + * can't return anything useful if we have no FmgrInfo or if its fn_expr + * node has not been initialized + */ + if (!flinfo || !flinfo->fn_expr) + return InvalidOid; + + expr = flinfo->fn_expr; + + return exprType(expr); +} + +/* + * Get the actual type OID of a specific function argument (counting from 0) + * + * Returns InvalidOid if information is not available + */ +Oid +get_fn_expr_argtype(FmgrInfo *flinfo, int argnum) +{ + /* + * can't return anything useful if we have no FmgrInfo or if its fn_expr + * node has not been initialized + */ + if (!flinfo || !flinfo->fn_expr) + return InvalidOid; + + return get_call_expr_argtype(flinfo->fn_expr, argnum); +} + +/* + * Get the actual type OID of a specific function argument (counting from 0), + * but working from the calling expression tree instead of FmgrInfo + * + * Returns InvalidOid if information is not available + */ +Oid +get_call_expr_argtype(Node *expr, int argnum) +{ + List *args; + Oid argtype; + + if (expr == NULL) + return InvalidOid; + + if (IsA(expr, FuncExpr)) + args = ((FuncExpr *) expr)->args; + else if (IsA(expr, OpExpr)) + args = ((OpExpr *) expr)->args; + else if (IsA(expr, DistinctExpr)) + args = ((DistinctExpr *) expr)->args; + else if (IsA(expr, ScalarArrayOpExpr)) + args = ((ScalarArrayOpExpr *) expr)->args; + else if (IsA(expr, NullIfExpr)) + args = ((NullIfExpr *) expr)->args; + else if (IsA(expr, WindowFunc)) + args = ((WindowFunc *) expr)->args; + else + return InvalidOid; + + if (argnum < 0 || argnum >= list_length(args)) + return InvalidOid; + + argtype = exprType((Node *) list_nth(args, argnum)); + + /* + * special hack for ScalarArrayOpExpr: what the underlying function will + * actually get passed is the element type of the array. + */ + if (IsA(expr, ScalarArrayOpExpr) && + argnum == 1) + argtype = get_base_element_type(argtype); + + return argtype; +} + +/* + * Find out whether a specific function argument is constant for the + * duration of a query + * + * Returns false if information is not available + */ +bool +get_fn_expr_arg_stable(FmgrInfo *flinfo, int argnum) +{ + /* + * can't return anything useful if we have no FmgrInfo or if its fn_expr + * node has not been initialized + */ + if (!flinfo || !flinfo->fn_expr) + return false; + + return get_call_expr_arg_stable(flinfo->fn_expr, argnum); +} + +/* + * Find out whether a specific function argument is constant for the + * duration of a query, but working from the calling expression tree + * + * Returns false if information is not available + */ +bool +get_call_expr_arg_stable(Node *expr, int argnum) +{ + List *args; + Node *arg; + + if (expr == NULL) + return false; + + if (IsA(expr, FuncExpr)) + args = ((FuncExpr *) expr)->args; + else if (IsA(expr, OpExpr)) + args = ((OpExpr *) expr)->args; + else if (IsA(expr, DistinctExpr)) + args = ((DistinctExpr *) expr)->args; + else if (IsA(expr, ScalarArrayOpExpr)) + args = ((ScalarArrayOpExpr *) expr)->args; + else if (IsA(expr, NullIfExpr)) + args = ((NullIfExpr *) expr)->args; + else if (IsA(expr, WindowFunc)) + args = ((WindowFunc *) expr)->args; + else + return false; + + if (argnum < 0 || argnum >= list_length(args)) + return false; + + arg = (Node *) list_nth(args, argnum); + + /* + * Either a true Const or an external Param will have a value that doesn't + * change during the execution of the query. In future we might want to + * consider other cases too, e.g. now(). + */ + if (IsA(arg, Const)) + return true; + if (IsA(arg, Param) && + ((Param *) arg)->paramkind == PARAM_EXTERN) + return true; + + return false; +} + +/* + * Get the VARIADIC flag from the function invocation + * + * Returns false (the default assumption) if information is not available + * + * Note this is generally only of interest to VARIADIC ANY functions + */ +bool +get_fn_expr_variadic(FmgrInfo *flinfo) +{ + Node *expr; + + /* + * can't return anything useful if we have no FmgrInfo or if its fn_expr + * node has not been initialized + */ + if (!flinfo || !flinfo->fn_expr) + return false; + + expr = flinfo->fn_expr; + + if (IsA(expr, FuncExpr)) + return ((FuncExpr *) expr)->funcvariadic; + else + return false; +} + +/* + * Set options to FmgrInfo of opclass support function. + * + * Opclass support functions are called outside of expressions. Thanks to that + * we can use fn_expr to store opclass options as bytea constant. + */ +void +set_fn_opclass_options(FmgrInfo *flinfo, bytea *options) +{ + flinfo->fn_expr = (Node *) makeConst(BYTEAOID, -1, InvalidOid, -1, + PointerGetDatum(options), + options == NULL, false); +} + +/* + * Check if options are defined for opclass support function. + */ +bool +has_fn_opclass_options(FmgrInfo *flinfo) +{ + if (flinfo && flinfo->fn_expr && IsA(flinfo->fn_expr, Const)) + { + Const *expr = (Const *) flinfo->fn_expr; + + if (expr->consttype == BYTEAOID) + return !expr->constisnull; + } + return false; +} + +/* + * Get options for opclass support function. + */ +bytea * +get_fn_opclass_options(FmgrInfo *flinfo) +{ + if (flinfo && flinfo->fn_expr && IsA(flinfo->fn_expr, Const)) + { + Const *expr = (Const *) flinfo->fn_expr; + + if (expr->consttype == BYTEAOID) + return expr->constisnull ? NULL : DatumGetByteaP(expr->constvalue); + } + + ereport(ERROR, + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), + errmsg("operator class options info is absent in function call context"))); + + return NULL; +} + +/*------------------------------------------------------------------------- + * Support routines for procedural language implementations + *------------------------------------------------------------------------- + */ + +/* + * Verify that a validator is actually associated with the language of a + * particular function and that the user has access to both the language and + * the function. All validators should call this before doing anything + * substantial. Doing so ensures a user cannot achieve anything with explicit + * calls to validators that he could not achieve with CREATE FUNCTION or by + * simply calling an existing function. + * + * When this function returns false, callers should skip all validation work + * and call PG_RETURN_VOID(). This never happens at present; it is reserved + * for future expansion. + * + * In particular, checking that the validator corresponds to the function's + * language allows untrusted language validators to assume they process only + * superuser-chosen source code. (Untrusted language call handlers, by + * definition, do assume that.) A user lacking the USAGE language privilege + * would be unable to reach the validator through CREATE FUNCTION, so we check + * that to block explicit calls as well. Checking the EXECUTE privilege on + * the function is often superfluous, because most users can clone the + * function to get an executable copy. It is meaningful against users with no + * database TEMP right and no permanent schema CREATE right, thereby unable to + * create any function. Also, if the function tracks persistent state by + * function OID or name, validating the original function might permit more + * mischief than creating and validating a clone thereof. + */ +bool +CheckFunctionValidatorAccess(Oid validatorOid, Oid functionOid) +{ + HeapTuple procTup; + HeapTuple langTup; + Form_pg_proc procStruct; + Form_pg_language langStruct; + AclResult aclresult; + + /* + * Get the function's pg_proc entry. Throw a user-facing error for bad + * OID, because validators can be called with user-specified OIDs. + */ + procTup = SearchSysCache1(PROCOID, ObjectIdGetDatum(functionOid)); + if (!HeapTupleIsValid(procTup)) + ereport(ERROR, + (errcode(ERRCODE_UNDEFINED_FUNCTION), + errmsg("function with OID %u does not exist", functionOid))); + procStruct = (Form_pg_proc) GETSTRUCT(procTup); + + /* + * Fetch pg_language entry to know if this is the correct validation + * function for that pg_proc entry. + */ + langTup = SearchSysCache1(LANGOID, ObjectIdGetDatum(procStruct->prolang)); + if (!HeapTupleIsValid(langTup)) + elog(ERROR, "cache lookup failed for language %u", procStruct->prolang); + langStruct = (Form_pg_language) GETSTRUCT(langTup); + + if (langStruct->lanvalidator != validatorOid) + ereport(ERROR, + (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), + errmsg("language validation function %u called for language %u instead of %u", + validatorOid, procStruct->prolang, + langStruct->lanvalidator))); + + /* first validate that we have permissions to use the language */ + aclresult = pg_language_aclcheck(procStruct->prolang, GetUserId(), + ACL_USAGE); + if (aclresult != ACLCHECK_OK) + aclcheck_error(aclresult, OBJECT_LANGUAGE, + NameStr(langStruct->lanname)); + + /* + * Check whether we are allowed to execute the function itself. If we can + * execute it, there should be no possible side-effect of + * compiling/validation that execution can't have. + */ + aclresult = pg_proc_aclcheck(functionOid, GetUserId(), ACL_EXECUTE); + if (aclresult != ACLCHECK_OK) + aclcheck_error(aclresult, OBJECT_FUNCTION, NameStr(procStruct->proname)); + + ReleaseSysCache(procTup); + ReleaseSysCache(langTup); + + return true; +} diff --git a/src/backend/utils/fmgr/funcapi.c b/src/backend/utils/fmgr/funcapi.c new file mode 100644 index 0000000..31f6662 --- /dev/null +++ b/src/backend/utils/fmgr/funcapi.c @@ -0,0 +1,2115 @@ +/*------------------------------------------------------------------------- + * + * funcapi.c + * Utility and convenience functions for fmgr functions that return + * sets and/or composite types, or deal with VARIADIC inputs. + * + * Copyright (c) 2002-2022, PostgreSQL Global Development Group + * + * IDENTIFICATION + * src/backend/utils/fmgr/funcapi.c + * + *------------------------------------------------------------------------- + */ +#include "postgres.h" + +#include "access/htup_details.h" +#include "access/relation.h" +#include "catalog/namespace.h" +#include "catalog/pg_proc.h" +#include "catalog/pg_type.h" +#include "funcapi.h" +#include "miscadmin.h" +#include "nodes/nodeFuncs.h" +#include "utils/array.h" +#include "utils/builtins.h" +#include "utils/lsyscache.h" +#include "utils/memutils.h" +#include "utils/regproc.h" +#include "utils/rel.h" +#include "utils/syscache.h" +#include "utils/tuplestore.h" +#include "utils/typcache.h" + + +typedef struct polymorphic_actuals +{ + Oid anyelement_type; /* anyelement mapping, if known */ + Oid anyarray_type; /* anyarray mapping, if known */ + Oid anyrange_type; /* anyrange mapping, if known */ + Oid anymultirange_type; /* anymultirange mapping, if known */ +} polymorphic_actuals; + +static void shutdown_MultiFuncCall(Datum arg); +static TypeFuncClass internal_get_result_type(Oid funcid, + Node *call_expr, + ReturnSetInfo *rsinfo, + Oid *resultTypeId, + TupleDesc *resultTupleDesc); +static void resolve_anyelement_from_others(polymorphic_actuals *actuals); +static void resolve_anyarray_from_others(polymorphic_actuals *actuals); +static void resolve_anyrange_from_others(polymorphic_actuals *actuals); +static void resolve_anymultirange_from_others(polymorphic_actuals *actuals); +static bool resolve_polymorphic_tupdesc(TupleDesc tupdesc, + oidvector *declared_args, + Node *call_expr); +static TypeFuncClass get_type_func_class(Oid typid, Oid *base_typeid); + + +/* + * Compatibility function for v15. + */ +void +SetSingleFuncCall(FunctionCallInfo fcinfo, bits32 flags) +{ + InitMaterializedSRF(fcinfo, flags); +} + +/* + * InitMaterializedSRF + * + * Helper function to build the state of a set-returning function used + * in the context of a single call with materialize mode. This code + * includes sanity checks on ReturnSetInfo, creates the Tuplestore and + * the TupleDesc used with the function and stores them into the + * function's ReturnSetInfo. + * + * "flags" can be set to MAT_SRF_USE_EXPECTED_DESC, to use the tuple + * descriptor coming from expectedDesc, which is the tuple descriptor + * expected by the caller. MAT_SRF_BLESS can be set to complete the + * information associated to the tuple descriptor, which is necessary + * in some cases where the tuple descriptor comes from a transient + * RECORD datatype. + */ +void +InitMaterializedSRF(FunctionCallInfo fcinfo, bits32 flags) +{ + bool random_access; + ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo; + Tuplestorestate *tupstore; + MemoryContext old_context, + per_query_ctx; + TupleDesc stored_tupdesc; + + /* check to see if caller supports returning a tuplestore */ + if (rsinfo == NULL || !IsA(rsinfo, ReturnSetInfo)) + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + errmsg("set-valued function called in context that cannot accept a set"))); + if (!(rsinfo->allowedModes & SFRM_Materialize) || + ((flags & MAT_SRF_USE_EXPECTED_DESC) != 0 && rsinfo->expectedDesc == NULL)) + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + errmsg("materialize mode required, but it is not allowed in this context"))); + + /* + * Store the tuplestore and the tuple descriptor in ReturnSetInfo. This + * must be done in the per-query memory context. + */ + per_query_ctx = rsinfo->econtext->ecxt_per_query_memory; + old_context = MemoryContextSwitchTo(per_query_ctx); + + /* build a tuple descriptor for our result type */ + if ((flags & MAT_SRF_USE_EXPECTED_DESC) != 0) + stored_tupdesc = CreateTupleDescCopy(rsinfo->expectedDesc); + else + { + if (get_call_result_type(fcinfo, NULL, &stored_tupdesc) != TYPEFUNC_COMPOSITE) + elog(ERROR, "return type must be a row type"); + } + + /* If requested, bless the tuple descriptor */ + if ((flags & MAT_SRF_BLESS) != 0) + BlessTupleDesc(stored_tupdesc); + + random_access = (rsinfo->allowedModes & SFRM_Materialize_Random) != 0; + + tupstore = tuplestore_begin_heap(random_access, false, work_mem); + rsinfo->returnMode = SFRM_Materialize; + rsinfo->setResult = tupstore; + rsinfo->setDesc = stored_tupdesc; + MemoryContextSwitchTo(old_context); +} + + +/* + * init_MultiFuncCall + * Create an empty FuncCallContext data structure + * and do some other basic Multi-function call setup + * and error checking + */ +FuncCallContext * +init_MultiFuncCall(PG_FUNCTION_ARGS) +{ + FuncCallContext *retval; + + /* + * Bail if we're called in the wrong context + */ + if (fcinfo->resultinfo == NULL || !IsA(fcinfo->resultinfo, ReturnSetInfo)) + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + errmsg("set-valued function called in context that cannot accept a set"))); + + if (fcinfo->flinfo->fn_extra == NULL) + { + /* + * First call + */ + ReturnSetInfo *rsi = (ReturnSetInfo *) fcinfo->resultinfo; + MemoryContext multi_call_ctx; + + /* + * Create a suitably long-lived context to hold cross-call data + */ + multi_call_ctx = AllocSetContextCreate(fcinfo->flinfo->fn_mcxt, + "SRF multi-call context", + ALLOCSET_SMALL_SIZES); + + /* + * Allocate suitably long-lived space and zero it + */ + retval = (FuncCallContext *) + MemoryContextAllocZero(multi_call_ctx, + sizeof(FuncCallContext)); + + /* + * initialize the elements + */ + retval->call_cntr = 0; + retval->max_calls = 0; + retval->user_fctx = NULL; + retval->attinmeta = NULL; + retval->tuple_desc = NULL; + retval->multi_call_memory_ctx = multi_call_ctx; + + /* + * save the pointer for cross-call use + */ + fcinfo->flinfo->fn_extra = retval; + + /* + * Ensure we will get shut down cleanly if the exprcontext is not run + * to completion. + */ + RegisterExprContextCallback(rsi->econtext, + shutdown_MultiFuncCall, + PointerGetDatum(fcinfo->flinfo)); + } + else + { + /* second and subsequent calls */ + elog(ERROR, "init_MultiFuncCall cannot be called more than once"); + + /* never reached, but keep compiler happy */ + retval = NULL; + } + + return retval; +} + +/* + * per_MultiFuncCall + * + * Do Multi-function per-call setup + */ +FuncCallContext * +per_MultiFuncCall(PG_FUNCTION_ARGS) +{ + FuncCallContext *retval = (FuncCallContext *) fcinfo->flinfo->fn_extra; + + return retval; +} + +/* + * end_MultiFuncCall + * Clean up after init_MultiFuncCall + */ +void +end_MultiFuncCall(PG_FUNCTION_ARGS, FuncCallContext *funcctx) +{ + ReturnSetInfo *rsi = (ReturnSetInfo *) fcinfo->resultinfo; + + /* Deregister the shutdown callback */ + UnregisterExprContextCallback(rsi->econtext, + shutdown_MultiFuncCall, + PointerGetDatum(fcinfo->flinfo)); + + /* But use it to do the real work */ + shutdown_MultiFuncCall(PointerGetDatum(fcinfo->flinfo)); +} + +/* + * shutdown_MultiFuncCall + * Shutdown function to clean up after init_MultiFuncCall + */ +static void +shutdown_MultiFuncCall(Datum arg) +{ + FmgrInfo *flinfo = (FmgrInfo *) DatumGetPointer(arg); + FuncCallContext *funcctx = (FuncCallContext *) flinfo->fn_extra; + + /* unbind from flinfo */ + flinfo->fn_extra = NULL; + + /* + * Delete context that holds all multi-call data, including the + * FuncCallContext itself + */ + MemoryContextDelete(funcctx->multi_call_memory_ctx); +} + + +/* + * 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. + * + * One hard case that this handles is resolution of actual rowtypes for + * functions returning RECORD (from either the function's OUT parameter + * list, or a ReturnSetInfo context node). TYPEFUNC_RECORD is returned + * only when we couldn't resolve the actual rowtype for lack of information. + * + * The other hard case that this handles is resolution of polymorphism. + * We will never return polymorphic pseudotypes (ANYELEMENT etc), either + * as a scalar result type or as a component of a rowtype. + * + * This function is relatively expensive --- in a function returning set, + * try to call it only the first time through. + */ +TypeFuncClass +get_call_result_type(FunctionCallInfo fcinfo, + Oid *resultTypeId, + TupleDesc *resultTupleDesc) +{ + return internal_get_result_type(fcinfo->flinfo->fn_oid, + fcinfo->flinfo->fn_expr, + (ReturnSetInfo *) fcinfo->resultinfo, + resultTypeId, + resultTupleDesc); +} + +/* + * get_expr_result_type + * As above, but work from a calling expression node tree + */ +TypeFuncClass +get_expr_result_type(Node *expr, + Oid *resultTypeId, + TupleDesc *resultTupleDesc) +{ + TypeFuncClass result; + + if (expr && IsA(expr, FuncExpr)) + result = internal_get_result_type(((FuncExpr *) expr)->funcid, + expr, + NULL, + resultTypeId, + resultTupleDesc); + else if (expr && IsA(expr, OpExpr)) + result = internal_get_result_type(get_opcode(((OpExpr *) expr)->opno), + expr, + NULL, + resultTypeId, + resultTupleDesc); + else if (expr && IsA(expr, RowExpr) && + ((RowExpr *) expr)->row_typeid == RECORDOID) + { + /* We can resolve the record type by generating the tupdesc directly */ + RowExpr *rexpr = (RowExpr *) expr; + TupleDesc tupdesc; + AttrNumber i = 1; + ListCell *lcc, + *lcn; + + tupdesc = CreateTemplateTupleDesc(list_length(rexpr->args)); + Assert(list_length(rexpr->args) == list_length(rexpr->colnames)); + forboth(lcc, rexpr->args, lcn, rexpr->colnames) + { + Node *col = (Node *) lfirst(lcc); + char *colname = strVal(lfirst(lcn)); + + TupleDescInitEntry(tupdesc, i, + colname, + exprType(col), + exprTypmod(col), + 0); + TupleDescInitEntryCollation(tupdesc, i, + exprCollation(col)); + i++; + } + if (resultTypeId) + *resultTypeId = rexpr->row_typeid; + if (resultTupleDesc) + *resultTupleDesc = BlessTupleDesc(tupdesc); + return TYPEFUNC_COMPOSITE; + } + else if (expr && IsA(expr, Const) && + ((Const *) expr)->consttype == RECORDOID && + !((Const *) expr)->constisnull) + { + /* + * When EXPLAIN'ing some queries with SEARCH/CYCLE clauses, we may + * need to resolve field names of a RECORD-type Const. The datum + * should contain a typmod that will tell us that. + */ + HeapTupleHeader rec; + Oid tupType; + int32 tupTypmod; + + rec = DatumGetHeapTupleHeader(((Const *) expr)->constvalue); + tupType = HeapTupleHeaderGetTypeId(rec); + tupTypmod = HeapTupleHeaderGetTypMod(rec); + if (resultTypeId) + *resultTypeId = tupType; + if (tupType != RECORDOID || tupTypmod >= 0) + { + /* Should be able to look it up */ + if (resultTupleDesc) + *resultTupleDesc = lookup_rowtype_tupdesc_copy(tupType, + tupTypmod); + return TYPEFUNC_COMPOSITE; + } + else + { + /* This shouldn't really happen ... */ + if (resultTupleDesc) + *resultTupleDesc = NULL; + return TYPEFUNC_RECORD; + } + } + else + { + /* handle as a generic expression; no chance to resolve RECORD */ + Oid typid = exprType(expr); + Oid base_typid; + + if (resultTypeId) + *resultTypeId = typid; + if (resultTupleDesc) + *resultTupleDesc = NULL; + result = get_type_func_class(typid, &base_typid); + if ((result == TYPEFUNC_COMPOSITE || + result == TYPEFUNC_COMPOSITE_DOMAIN) && + resultTupleDesc) + *resultTupleDesc = lookup_rowtype_tupdesc_copy(base_typid, -1); + } + + return result; +} + +/* + * get_func_result_type + * As above, but work from a function's OID only + * + * This will not be able to resolve pure-RECORD results nor polymorphism. + */ +TypeFuncClass +get_func_result_type(Oid functionId, + Oid *resultTypeId, + TupleDesc *resultTupleDesc) +{ + return internal_get_result_type(functionId, + NULL, + NULL, + resultTypeId, + resultTupleDesc); +} + +/* + * internal_get_result_type -- workhorse code implementing all the above + * + * funcid must always be supplied. call_expr and rsinfo can be NULL if not + * available. We will return TYPEFUNC_RECORD, and store NULL into + * *resultTupleDesc, if we cannot deduce the complete result rowtype from + * the available information. + */ +static TypeFuncClass +internal_get_result_type(Oid funcid, + Node *call_expr, + ReturnSetInfo *rsinfo, + Oid *resultTypeId, + TupleDesc *resultTupleDesc) +{ + TypeFuncClass result; + HeapTuple tp; + Form_pg_proc procform; + Oid rettype; + Oid base_rettype; + TupleDesc tupdesc; + + /* First fetch the function's pg_proc row to inspect its rettype */ + tp = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid)); + if (!HeapTupleIsValid(tp)) + elog(ERROR, "cache lookup failed for function %u", funcid); + procform = (Form_pg_proc) GETSTRUCT(tp); + + rettype = procform->prorettype; + + /* Check for OUT parameters defining a RECORD result */ + tupdesc = build_function_result_tupdesc_t(tp); + if (tupdesc) + { + /* + * It has OUT parameters, so it's basically like a regular composite + * type, except we have to be able to resolve any polymorphic OUT + * parameters. + */ + if (resultTypeId) + *resultTypeId = rettype; + + if (resolve_polymorphic_tupdesc(tupdesc, + &procform->proargtypes, + call_expr)) + { + if (tupdesc->tdtypeid == RECORDOID && + tupdesc->tdtypmod < 0) + assign_record_type_typmod(tupdesc); + if (resultTupleDesc) + *resultTupleDesc = tupdesc; + result = TYPEFUNC_COMPOSITE; + } + else + { + if (resultTupleDesc) + *resultTupleDesc = NULL; + result = TYPEFUNC_RECORD; + } + + ReleaseSysCache(tp); + + return result; + } + + /* + * If scalar polymorphic result, try to resolve it. + */ + if (IsPolymorphicType(rettype)) + { + Oid newrettype = exprType(call_expr); + + if (newrettype == InvalidOid) /* this probably should not happen */ + ereport(ERROR, + (errcode(ERRCODE_DATATYPE_MISMATCH), + errmsg("could not determine actual result type for function \"%s\" declared to return type %s", + NameStr(procform->proname), + format_type_be(rettype)))); + rettype = newrettype; + } + + if (resultTypeId) + *resultTypeId = rettype; + if (resultTupleDesc) + *resultTupleDesc = NULL; /* default result */ + + /* Classify the result type */ + result = get_type_func_class(rettype, &base_rettype); + switch (result) + { + case TYPEFUNC_COMPOSITE: + case TYPEFUNC_COMPOSITE_DOMAIN: + if (resultTupleDesc) + *resultTupleDesc = lookup_rowtype_tupdesc_copy(base_rettype, -1); + /* Named composite types can't have any polymorphic columns */ + break; + case TYPEFUNC_SCALAR: + break; + case TYPEFUNC_RECORD: + /* We must get the tupledesc from call context */ + if (rsinfo && IsA(rsinfo, ReturnSetInfo) && + rsinfo->expectedDesc != NULL) + { + result = TYPEFUNC_COMPOSITE; + if (resultTupleDesc) + *resultTupleDesc = rsinfo->expectedDesc; + /* Assume no polymorphic columns here, either */ + } + break; + default: + break; + } + + ReleaseSysCache(tp); + + return result; +} + +/* + * get_expr_result_tupdesc + * Get a tupdesc describing the result of a composite-valued expression + * + * If expression is not composite or rowtype can't be determined, returns NULL + * if noError is true, else throws error. + * + * This is a simpler version of get_expr_result_type() for use when the caller + * is only interested in determinate rowtype results. + */ +TupleDesc +get_expr_result_tupdesc(Node *expr, bool noError) +{ + TupleDesc tupleDesc; + TypeFuncClass functypclass; + + functypclass = get_expr_result_type(expr, NULL, &tupleDesc); + + if (functypclass == TYPEFUNC_COMPOSITE || + functypclass == TYPEFUNC_COMPOSITE_DOMAIN) + return tupleDesc; + + if (!noError) + { + Oid exprTypeId = exprType(expr); + + if (exprTypeId != RECORDOID) + ereport(ERROR, + (errcode(ERRCODE_WRONG_OBJECT_TYPE), + errmsg("type %s is not composite", + format_type_be(exprTypeId)))); + else + ereport(ERROR, + (errcode(ERRCODE_WRONG_OBJECT_TYPE), + errmsg("record type has not been registered"))); + } + + return NULL; +} + +/* + * Resolve actual type of ANYELEMENT from other polymorphic inputs + * + * Note: the error cases here and in the sibling functions below are not + * really user-facing; they could only occur if the function signature is + * incorrect or the parser failed to enforce consistency of the actual + * argument types. Hence, we don't sweat too much over the error messages. + */ +static void +resolve_anyelement_from_others(polymorphic_actuals *actuals) +{ + if (OidIsValid(actuals->anyarray_type)) + { + /* Use the element type corresponding to actual type */ + Oid array_base_type = getBaseType(actuals->anyarray_type); + Oid array_typelem = get_element_type(array_base_type); + + if (!OidIsValid(array_typelem)) + ereport(ERROR, + (errcode(ERRCODE_DATATYPE_MISMATCH), + errmsg("argument declared %s is not an array but type %s", + "anyarray", + format_type_be(array_base_type)))); + actuals->anyelement_type = array_typelem; + } + else if (OidIsValid(actuals->anyrange_type)) + { + /* Use the element type corresponding to actual type */ + Oid range_base_type = getBaseType(actuals->anyrange_type); + Oid range_typelem = get_range_subtype(range_base_type); + + if (!OidIsValid(range_typelem)) + ereport(ERROR, + (errcode(ERRCODE_DATATYPE_MISMATCH), + errmsg("argument declared %s is not a range type but type %s", + "anyrange", + format_type_be(range_base_type)))); + actuals->anyelement_type = range_typelem; + } + else if (OidIsValid(actuals->anymultirange_type)) + { + /* Use the element type based on the multirange type */ + Oid multirange_base_type; + Oid multirange_typelem; + Oid range_base_type; + Oid range_typelem; + + multirange_base_type = getBaseType(actuals->anymultirange_type); + multirange_typelem = get_multirange_range(multirange_base_type); + if (!OidIsValid(multirange_typelem)) + ereport(ERROR, + (errcode(ERRCODE_DATATYPE_MISMATCH), + errmsg("argument declared %s is not a multirange type but type %s", + "anymultirange", + format_type_be(multirange_base_type)))); + + range_base_type = getBaseType(multirange_typelem); + range_typelem = get_range_subtype(range_base_type); + + if (!OidIsValid(range_typelem)) + ereport(ERROR, + (errcode(ERRCODE_DATATYPE_MISMATCH), + errmsg("argument declared %s does not contain a range type but type %s", + "anymultirange", + format_type_be(range_base_type)))); + actuals->anyelement_type = range_typelem; + } + else + elog(ERROR, "could not determine polymorphic type"); +} + +/* + * Resolve actual type of ANYARRAY from other polymorphic inputs + */ +static void +resolve_anyarray_from_others(polymorphic_actuals *actuals) +{ + /* If we don't know ANYELEMENT, resolve that first */ + if (!OidIsValid(actuals->anyelement_type)) + resolve_anyelement_from_others(actuals); + + if (OidIsValid(actuals->anyelement_type)) + { + /* Use the array type corresponding to actual type */ + Oid array_typeid = get_array_type(actuals->anyelement_type); + + if (!OidIsValid(array_typeid)) + ereport(ERROR, + (errcode(ERRCODE_UNDEFINED_OBJECT), + errmsg("could not find array type for data type %s", + format_type_be(actuals->anyelement_type)))); + actuals->anyarray_type = array_typeid; + } + else + elog(ERROR, "could not determine polymorphic type"); +} + +/* + * Resolve actual type of ANYRANGE from other polymorphic inputs + */ +static void +resolve_anyrange_from_others(polymorphic_actuals *actuals) +{ + /* + * We can't deduce a range type from other polymorphic array or base + * types, because there may be multiple range types with the same subtype, + * but we can deduce it from a polymorphic multirange type. + */ + if (OidIsValid(actuals->anymultirange_type)) + { + /* Use the element type based on the multirange type */ + Oid multirange_base_type = getBaseType(actuals->anymultirange_type); + Oid multirange_typelem = get_multirange_range(multirange_base_type); + + if (!OidIsValid(multirange_typelem)) + ereport(ERROR, + (errcode(ERRCODE_DATATYPE_MISMATCH), + errmsg("argument declared %s is not a multirange type but type %s", + "anymultirange", + format_type_be(multirange_base_type)))); + actuals->anyrange_type = multirange_typelem; + } + else + elog(ERROR, "could not determine polymorphic type"); +} + +/* + * Resolve actual type of ANYMULTIRANGE from other polymorphic inputs + */ +static void +resolve_anymultirange_from_others(polymorphic_actuals *actuals) +{ + /* + * We can't deduce a multirange type from polymorphic array or base types, + * because there may be multiple range types with the same subtype, but we + * can deduce it from a polymorphic range type. + */ + if (OidIsValid(actuals->anyrange_type)) + { + Oid range_base_type = getBaseType(actuals->anyrange_type); + Oid multirange_typeid = get_range_multirange(range_base_type); + + if (!OidIsValid(multirange_typeid)) + ereport(ERROR, + (errcode(ERRCODE_UNDEFINED_OBJECT), + errmsg("could not find multirange type for data type %s", + format_type_be(actuals->anyrange_type)))); + actuals->anymultirange_type = multirange_typeid; + } + else + elog(ERROR, "could not determine polymorphic type"); +} + +/* + * Given the result tuple descriptor for a function with OUT parameters, + * replace any polymorphic column types (ANYELEMENT etc) in the tupdesc + * with concrete data types deduced from the input arguments. + * declared_args is an oidvector of the function's declared input arg types + * (showing which are polymorphic), and call_expr is the call expression. + * + * Returns true if able to deduce all types, false if necessary information + * is not provided (call_expr is NULL or arg types aren't identifiable). + */ +static bool +resolve_polymorphic_tupdesc(TupleDesc tupdesc, oidvector *declared_args, + Node *call_expr) +{ + int natts = tupdesc->natts; + int nargs = declared_args->dim1; + bool have_polymorphic_result = false; + bool have_anyelement_result = false; + bool have_anyarray_result = false; + bool have_anyrange_result = false; + bool have_anymultirange_result = false; + bool have_anycompatible_result = false; + bool have_anycompatible_array_result = false; + bool have_anycompatible_range_result = false; + bool have_anycompatible_multirange_result = false; + polymorphic_actuals poly_actuals; + polymorphic_actuals anyc_actuals; + Oid anycollation = InvalidOid; + Oid anycompatcollation = InvalidOid; + int i; + + /* See if there are any polymorphic outputs; quick out if not */ + for (i = 0; i < natts; i++) + { + switch (TupleDescAttr(tupdesc, i)->atttypid) + { + case ANYELEMENTOID: + case ANYNONARRAYOID: + case ANYENUMOID: + have_polymorphic_result = true; + have_anyelement_result = true; + break; + case ANYARRAYOID: + have_polymorphic_result = true; + have_anyarray_result = true; + break; + case ANYRANGEOID: + have_polymorphic_result = true; + have_anyrange_result = true; + break; + case ANYMULTIRANGEOID: + have_polymorphic_result = true; + have_anymultirange_result = true; + break; + case ANYCOMPATIBLEOID: + case ANYCOMPATIBLENONARRAYOID: + have_polymorphic_result = true; + have_anycompatible_result = true; + break; + case ANYCOMPATIBLEARRAYOID: + have_polymorphic_result = true; + have_anycompatible_array_result = true; + break; + case ANYCOMPATIBLERANGEOID: + have_polymorphic_result = true; + have_anycompatible_range_result = true; + break; + case ANYCOMPATIBLEMULTIRANGEOID: + have_polymorphic_result = true; + have_anycompatible_multirange_result = true; + break; + default: + break; + } + } + if (!have_polymorphic_result) + return true; + + /* + * Otherwise, extract actual datatype(s) from input arguments. (We assume + * the parser already validated consistency of the arguments. Also, for + * the ANYCOMPATIBLE pseudotype family, we expect that all matching + * arguments were coerced to the selected common supertype, so that it + * doesn't matter which one's exposed type we look at.) + */ + if (!call_expr) + return false; /* no hope */ + + memset(&poly_actuals, 0, sizeof(poly_actuals)); + memset(&anyc_actuals, 0, sizeof(anyc_actuals)); + + for (i = 0; i < nargs; i++) + { + switch (declared_args->values[i]) + { + case ANYELEMENTOID: + case ANYNONARRAYOID: + case ANYENUMOID: + if (!OidIsValid(poly_actuals.anyelement_type)) + { + poly_actuals.anyelement_type = + get_call_expr_argtype(call_expr, i); + if (!OidIsValid(poly_actuals.anyelement_type)) + return false; + } + break; + case ANYARRAYOID: + if (!OidIsValid(poly_actuals.anyarray_type)) + { + poly_actuals.anyarray_type = + get_call_expr_argtype(call_expr, i); + if (!OidIsValid(poly_actuals.anyarray_type)) + return false; + } + break; + case ANYRANGEOID: + if (!OidIsValid(poly_actuals.anyrange_type)) + { + poly_actuals.anyrange_type = + get_call_expr_argtype(call_expr, i); + if (!OidIsValid(poly_actuals.anyrange_type)) + return false; + } + break; + case ANYMULTIRANGEOID: + if (!OidIsValid(poly_actuals.anymultirange_type)) + { + poly_actuals.anymultirange_type = + get_call_expr_argtype(call_expr, i); + if (!OidIsValid(poly_actuals.anymultirange_type)) + return false; + } + break; + case ANYCOMPATIBLEOID: + case ANYCOMPATIBLENONARRAYOID: + if (!OidIsValid(anyc_actuals.anyelement_type)) + { + anyc_actuals.anyelement_type = + get_call_expr_argtype(call_expr, i); + if (!OidIsValid(anyc_actuals.anyelement_type)) + return false; + } + break; + case ANYCOMPATIBLEARRAYOID: + if (!OidIsValid(anyc_actuals.anyarray_type)) + { + anyc_actuals.anyarray_type = + get_call_expr_argtype(call_expr, i); + if (!OidIsValid(anyc_actuals.anyarray_type)) + return false; + } + break; + case ANYCOMPATIBLERANGEOID: + if (!OidIsValid(anyc_actuals.anyrange_type)) + { + anyc_actuals.anyrange_type = + get_call_expr_argtype(call_expr, i); + if (!OidIsValid(anyc_actuals.anyrange_type)) + return false; + } + break; + case ANYCOMPATIBLEMULTIRANGEOID: + if (!OidIsValid(anyc_actuals.anymultirange_type)) + { + anyc_actuals.anymultirange_type = + get_call_expr_argtype(call_expr, i); + if (!OidIsValid(anyc_actuals.anymultirange_type)) + return false; + } + break; + default: + break; + } + } + + /* If needed, deduce one polymorphic type from others */ + if (have_anyelement_result && !OidIsValid(poly_actuals.anyelement_type)) + resolve_anyelement_from_others(&poly_actuals); + + if (have_anyarray_result && !OidIsValid(poly_actuals.anyarray_type)) + resolve_anyarray_from_others(&poly_actuals); + + if (have_anyrange_result && !OidIsValid(poly_actuals.anyrange_type)) + resolve_anyrange_from_others(&poly_actuals); + + if (have_anymultirange_result && !OidIsValid(poly_actuals.anymultirange_type)) + resolve_anymultirange_from_others(&poly_actuals); + + if (have_anycompatible_result && !OidIsValid(anyc_actuals.anyelement_type)) + resolve_anyelement_from_others(&anyc_actuals); + + if (have_anycompatible_array_result && !OidIsValid(anyc_actuals.anyarray_type)) + resolve_anyarray_from_others(&anyc_actuals); + + if (have_anycompatible_range_result && !OidIsValid(anyc_actuals.anyrange_type)) + resolve_anyrange_from_others(&anyc_actuals); + + if (have_anycompatible_multirange_result && !OidIsValid(anyc_actuals.anymultirange_type)) + resolve_anymultirange_from_others(&anyc_actuals); + + /* + * Identify the collation to use for polymorphic OUT parameters. (It'll + * necessarily be the same for both anyelement and anyarray, likewise for + * anycompatible and anycompatiblearray.) Note that range types are not + * collatable, so any possible internal collation of a range type is not + * considered here. + */ + if (OidIsValid(poly_actuals.anyelement_type)) + anycollation = get_typcollation(poly_actuals.anyelement_type); + else if (OidIsValid(poly_actuals.anyarray_type)) + anycollation = get_typcollation(poly_actuals.anyarray_type); + + if (OidIsValid(anyc_actuals.anyelement_type)) + anycompatcollation = get_typcollation(anyc_actuals.anyelement_type); + else if (OidIsValid(anyc_actuals.anyarray_type)) + anycompatcollation = get_typcollation(anyc_actuals.anyarray_type); + + if (OidIsValid(anycollation) || OidIsValid(anycompatcollation)) + { + /* + * The types are collatable, so consider whether to use a nondefault + * collation. We do so if we can identify the input collation used + * for the function. + */ + Oid inputcollation = exprInputCollation(call_expr); + + if (OidIsValid(inputcollation)) + { + if (OidIsValid(anycollation)) + anycollation = inputcollation; + if (OidIsValid(anycompatcollation)) + anycompatcollation = inputcollation; + } + } + + /* And finally replace the tuple column types as needed */ + for (i = 0; i < natts; i++) + { + Form_pg_attribute att = TupleDescAttr(tupdesc, i); + + switch (att->atttypid) + { + case ANYELEMENTOID: + case ANYNONARRAYOID: + case ANYENUMOID: + TupleDescInitEntry(tupdesc, i + 1, + NameStr(att->attname), + poly_actuals.anyelement_type, + -1, + 0); + TupleDescInitEntryCollation(tupdesc, i + 1, anycollation); + break; + case ANYARRAYOID: + TupleDescInitEntry(tupdesc, i + 1, + NameStr(att->attname), + poly_actuals.anyarray_type, + -1, + 0); + TupleDescInitEntryCollation(tupdesc, i + 1, anycollation); + break; + case ANYRANGEOID: + TupleDescInitEntry(tupdesc, i + 1, + NameStr(att->attname), + poly_actuals.anyrange_type, + -1, + 0); + /* no collation should be attached to a range type */ + break; + case ANYMULTIRANGEOID: + TupleDescInitEntry(tupdesc, i + 1, + NameStr(att->attname), + poly_actuals.anymultirange_type, + -1, + 0); + /* no collation should be attached to a multirange type */ + break; + case ANYCOMPATIBLEOID: + case ANYCOMPATIBLENONARRAYOID: + TupleDescInitEntry(tupdesc, i + 1, + NameStr(att->attname), + anyc_actuals.anyelement_type, + -1, + 0); + TupleDescInitEntryCollation(tupdesc, i + 1, anycompatcollation); + break; + case ANYCOMPATIBLEARRAYOID: + TupleDescInitEntry(tupdesc, i + 1, + NameStr(att->attname), + anyc_actuals.anyarray_type, + -1, + 0); + TupleDescInitEntryCollation(tupdesc, i + 1, anycompatcollation); + break; + case ANYCOMPATIBLERANGEOID: + TupleDescInitEntry(tupdesc, i + 1, + NameStr(att->attname), + anyc_actuals.anyrange_type, + -1, + 0); + /* no collation should be attached to a range type */ + break; + case ANYCOMPATIBLEMULTIRANGEOID: + TupleDescInitEntry(tupdesc, i + 1, + NameStr(att->attname), + anyc_actuals.anymultirange_type, + -1, + 0); + /* no collation should be attached to a multirange type */ + break; + default: + break; + } + } + + return true; +} + +/* + * Given the declared argument types and modes for a function, replace any + * polymorphic types (ANYELEMENT etc) in argtypes[] with concrete data types + * deduced from the input arguments found in call_expr. + * + * Returns true if able to deduce all types, false if necessary information + * is not provided (call_expr is NULL or arg types aren't identifiable). + * + * This is the same logic as resolve_polymorphic_tupdesc, but with a different + * argument representation, and slightly different output responsibilities. + * + * argmodes may be NULL, in which case all arguments are assumed to be IN mode. + */ +bool +resolve_polymorphic_argtypes(int numargs, Oid *argtypes, char *argmodes, + Node *call_expr) +{ + bool have_polymorphic_result = false; + bool have_anyelement_result = false; + bool have_anyarray_result = false; + bool have_anyrange_result = false; + bool have_anymultirange_result = false; + bool have_anycompatible_result = false; + bool have_anycompatible_array_result = false; + bool have_anycompatible_range_result = false; + bool have_anycompatible_multirange_result = false; + polymorphic_actuals poly_actuals; + polymorphic_actuals anyc_actuals; + int inargno; + int i; + + /* + * First pass: resolve polymorphic inputs, check for outputs. As in + * resolve_polymorphic_tupdesc, we rely on the parser to have enforced + * type consistency and coerced ANYCOMPATIBLE args to a common supertype. + */ + memset(&poly_actuals, 0, sizeof(poly_actuals)); + memset(&anyc_actuals, 0, sizeof(anyc_actuals)); + inargno = 0; + for (i = 0; i < numargs; i++) + { + char argmode = argmodes ? argmodes[i] : PROARGMODE_IN; + + switch (argtypes[i]) + { + case ANYELEMENTOID: + case ANYNONARRAYOID: + case ANYENUMOID: + if (argmode == PROARGMODE_OUT || argmode == PROARGMODE_TABLE) + { + have_polymorphic_result = true; + have_anyelement_result = true; + } + else + { + if (!OidIsValid(poly_actuals.anyelement_type)) + { + poly_actuals.anyelement_type = + get_call_expr_argtype(call_expr, inargno); + if (!OidIsValid(poly_actuals.anyelement_type)) + return false; + } + argtypes[i] = poly_actuals.anyelement_type; + } + break; + case ANYARRAYOID: + if (argmode == PROARGMODE_OUT || argmode == PROARGMODE_TABLE) + { + have_polymorphic_result = true; + have_anyarray_result = true; + } + else + { + if (!OidIsValid(poly_actuals.anyarray_type)) + { + poly_actuals.anyarray_type = + get_call_expr_argtype(call_expr, inargno); + if (!OidIsValid(poly_actuals.anyarray_type)) + return false; + } + argtypes[i] = poly_actuals.anyarray_type; + } + break; + case ANYRANGEOID: + if (argmode == PROARGMODE_OUT || argmode == PROARGMODE_TABLE) + { + have_polymorphic_result = true; + have_anyrange_result = true; + } + else + { + if (!OidIsValid(poly_actuals.anyrange_type)) + { + poly_actuals.anyrange_type = + get_call_expr_argtype(call_expr, inargno); + if (!OidIsValid(poly_actuals.anyrange_type)) + return false; + } + argtypes[i] = poly_actuals.anyrange_type; + } + break; + case ANYMULTIRANGEOID: + if (argmode == PROARGMODE_OUT || argmode == PROARGMODE_TABLE) + { + have_polymorphic_result = true; + have_anymultirange_result = true; + } + else + { + if (!OidIsValid(poly_actuals.anymultirange_type)) + { + poly_actuals.anymultirange_type = + get_call_expr_argtype(call_expr, inargno); + if (!OidIsValid(poly_actuals.anymultirange_type)) + return false; + } + argtypes[i] = poly_actuals.anymultirange_type; + } + break; + case ANYCOMPATIBLEOID: + case ANYCOMPATIBLENONARRAYOID: + if (argmode == PROARGMODE_OUT || argmode == PROARGMODE_TABLE) + { + have_polymorphic_result = true; + have_anycompatible_result = true; + } + else + { + if (!OidIsValid(anyc_actuals.anyelement_type)) + { + anyc_actuals.anyelement_type = + get_call_expr_argtype(call_expr, inargno); + if (!OidIsValid(anyc_actuals.anyelement_type)) + return false; + } + argtypes[i] = anyc_actuals.anyelement_type; + } + break; + case ANYCOMPATIBLEARRAYOID: + if (argmode == PROARGMODE_OUT || argmode == PROARGMODE_TABLE) + { + have_polymorphic_result = true; + have_anycompatible_array_result = true; + } + else + { + if (!OidIsValid(anyc_actuals.anyarray_type)) + { + anyc_actuals.anyarray_type = + get_call_expr_argtype(call_expr, inargno); + if (!OidIsValid(anyc_actuals.anyarray_type)) + return false; + } + argtypes[i] = anyc_actuals.anyarray_type; + } + break; + case ANYCOMPATIBLERANGEOID: + if (argmode == PROARGMODE_OUT || argmode == PROARGMODE_TABLE) + { + have_polymorphic_result = true; + have_anycompatible_range_result = true; + } + else + { + if (!OidIsValid(anyc_actuals.anyrange_type)) + { + anyc_actuals.anyrange_type = + get_call_expr_argtype(call_expr, inargno); + if (!OidIsValid(anyc_actuals.anyrange_type)) + return false; + } + argtypes[i] = anyc_actuals.anyrange_type; + } + break; + case ANYCOMPATIBLEMULTIRANGEOID: + if (argmode == PROARGMODE_OUT || argmode == PROARGMODE_TABLE) + { + have_polymorphic_result = true; + have_anycompatible_multirange_result = true; + } + else + { + if (!OidIsValid(anyc_actuals.anymultirange_type)) + { + anyc_actuals.anymultirange_type = + get_call_expr_argtype(call_expr, inargno); + if (!OidIsValid(anyc_actuals.anymultirange_type)) + return false; + } + argtypes[i] = anyc_actuals.anymultirange_type; + } + break; + default: + break; + } + if (argmode != PROARGMODE_OUT && argmode != PROARGMODE_TABLE) + inargno++; + } + + /* Done? */ + if (!have_polymorphic_result) + return true; + + /* If needed, deduce one polymorphic type from others */ + if (have_anyelement_result && !OidIsValid(poly_actuals.anyelement_type)) + resolve_anyelement_from_others(&poly_actuals); + + if (have_anyarray_result && !OidIsValid(poly_actuals.anyarray_type)) + resolve_anyarray_from_others(&poly_actuals); + + if (have_anyrange_result && !OidIsValid(poly_actuals.anyrange_type)) + resolve_anyrange_from_others(&poly_actuals); + + if (have_anymultirange_result && !OidIsValid(poly_actuals.anymultirange_type)) + resolve_anymultirange_from_others(&poly_actuals); + + if (have_anycompatible_result && !OidIsValid(anyc_actuals.anyelement_type)) + resolve_anyelement_from_others(&anyc_actuals); + + if (have_anycompatible_array_result && !OidIsValid(anyc_actuals.anyarray_type)) + resolve_anyarray_from_others(&anyc_actuals); + + if (have_anycompatible_range_result && !OidIsValid(anyc_actuals.anyrange_type)) + resolve_anyrange_from_others(&anyc_actuals); + + if (have_anycompatible_multirange_result && !OidIsValid(anyc_actuals.anymultirange_type)) + resolve_anymultirange_from_others(&anyc_actuals); + + /* And finally replace the output column types as needed */ + for (i = 0; i < numargs; i++) + { + switch (argtypes[i]) + { + case ANYELEMENTOID: + case ANYNONARRAYOID: + case ANYENUMOID: + argtypes[i] = poly_actuals.anyelement_type; + break; + case ANYARRAYOID: + argtypes[i] = poly_actuals.anyarray_type; + break; + case ANYRANGEOID: + argtypes[i] = poly_actuals.anyrange_type; + break; + case ANYMULTIRANGEOID: + argtypes[i] = poly_actuals.anymultirange_type; + break; + case ANYCOMPATIBLEOID: + case ANYCOMPATIBLENONARRAYOID: + argtypes[i] = anyc_actuals.anyelement_type; + break; + case ANYCOMPATIBLEARRAYOID: + argtypes[i] = anyc_actuals.anyarray_type; + break; + case ANYCOMPATIBLERANGEOID: + argtypes[i] = anyc_actuals.anyrange_type; + break; + case ANYCOMPATIBLEMULTIRANGEOID: + argtypes[i] = anyc_actuals.anymultirange_type; + break; + default: + break; + } + } + + return true; +} + +/* + * get_type_func_class + * Given the type OID, obtain its TYPEFUNC classification. + * Also, if it's a domain, return the base type OID. + * + * This is intended to centralize a bunch of formerly ad-hoc code for + * classifying types. The categories used here are useful for deciding + * how to handle functions returning the datatype. + */ +static TypeFuncClass +get_type_func_class(Oid typid, Oid *base_typeid) +{ + *base_typeid = typid; + + switch (get_typtype(typid)) + { + case TYPTYPE_COMPOSITE: + return TYPEFUNC_COMPOSITE; + case TYPTYPE_BASE: + case TYPTYPE_ENUM: + case TYPTYPE_RANGE: + case TYPTYPE_MULTIRANGE: + return TYPEFUNC_SCALAR; + case TYPTYPE_DOMAIN: + *base_typeid = typid = getBaseType(typid); + if (get_typtype(typid) == TYPTYPE_COMPOSITE) + return TYPEFUNC_COMPOSITE_DOMAIN; + else /* domain base type can't be a pseudotype */ + return TYPEFUNC_SCALAR; + case TYPTYPE_PSEUDO: + if (typid == RECORDOID) + return TYPEFUNC_RECORD; + + /* + * We treat VOID and CSTRING as legitimate scalar datatypes, + * mostly for the convenience of the JDBC driver (which wants to + * be able to do "SELECT * FROM foo()" for all legitimately + * user-callable functions). + */ + if (typid == VOIDOID || typid == CSTRINGOID) + return TYPEFUNC_SCALAR; + return TYPEFUNC_OTHER; + } + /* shouldn't get here, probably */ + return TYPEFUNC_OTHER; +} + + +/* + * get_func_arg_info + * + * Fetch info about the argument types, names, and IN/OUT modes from the + * pg_proc tuple. Return value is the total number of arguments. + * Other results are palloc'd. *p_argtypes is always filled in, but + * *p_argnames and *p_argmodes will be set NULL in the default cases + * (no names, and all IN arguments, respectively). + * + * Note that this function simply fetches what is in the pg_proc tuple; + * it doesn't do any interpretation of polymorphic types. + */ +int +get_func_arg_info(HeapTuple procTup, + Oid **p_argtypes, char ***p_argnames, char **p_argmodes) +{ + Form_pg_proc procStruct = (Form_pg_proc) GETSTRUCT(procTup); + Datum proallargtypes; + Datum proargmodes; + Datum proargnames; + bool isNull; + ArrayType *arr; + int numargs; + Datum *elems; + int nelems; + int i; + + /* First discover the total number of parameters and get their types */ + proallargtypes = SysCacheGetAttr(PROCOID, procTup, + Anum_pg_proc_proallargtypes, + &isNull); + if (!isNull) + { + /* + * We expect the arrays to be 1-D arrays of the right types; verify + * that. For the OID and char arrays, we don't need to use + * deconstruct_array() since the array data is just going to look like + * a C array of values. + */ + arr = DatumGetArrayTypeP(proallargtypes); /* ensure not toasted */ + numargs = ARR_DIMS(arr)[0]; + if (ARR_NDIM(arr) != 1 || + numargs < 0 || + ARR_HASNULL(arr) || + ARR_ELEMTYPE(arr) != OIDOID) + elog(ERROR, "proallargtypes is not a 1-D Oid array or it contains nulls"); + Assert(numargs >= procStruct->pronargs); + *p_argtypes = (Oid *) palloc(numargs * sizeof(Oid)); + memcpy(*p_argtypes, ARR_DATA_PTR(arr), + numargs * sizeof(Oid)); + } + else + { + /* If no proallargtypes, use proargtypes */ + numargs = procStruct->proargtypes.dim1; + Assert(numargs == procStruct->pronargs); + *p_argtypes = (Oid *) palloc(numargs * sizeof(Oid)); + memcpy(*p_argtypes, procStruct->proargtypes.values, + numargs * sizeof(Oid)); + } + + /* Get argument names, if available */ + proargnames = SysCacheGetAttr(PROCOID, procTup, + Anum_pg_proc_proargnames, + &isNull); + if (isNull) + *p_argnames = NULL; + else + { + deconstruct_array(DatumGetArrayTypeP(proargnames), + TEXTOID, -1, false, TYPALIGN_INT, + &elems, NULL, &nelems); + if (nelems != numargs) /* should not happen */ + elog(ERROR, "proargnames must have the same number of elements as the function has arguments"); + *p_argnames = (char **) palloc(sizeof(char *) * numargs); + for (i = 0; i < numargs; i++) + (*p_argnames)[i] = TextDatumGetCString(elems[i]); + } + + /* Get argument modes, if available */ + proargmodes = SysCacheGetAttr(PROCOID, procTup, + Anum_pg_proc_proargmodes, + &isNull); + if (isNull) + *p_argmodes = NULL; + else + { + arr = DatumGetArrayTypeP(proargmodes); /* ensure not toasted */ + if (ARR_NDIM(arr) != 1 || + ARR_DIMS(arr)[0] != numargs || + ARR_HASNULL(arr) || + ARR_ELEMTYPE(arr) != CHAROID) + elog(ERROR, "proargmodes is not a 1-D char array of length %d or it contains nulls", + numargs); + *p_argmodes = (char *) palloc(numargs * sizeof(char)); + memcpy(*p_argmodes, ARR_DATA_PTR(arr), + numargs * sizeof(char)); + } + + return numargs; +} + +/* + * get_func_trftypes + * + * Returns the number of transformed types used by the function. + * If there are any, a palloc'd array of the type OIDs is returned + * into *p_trftypes. + */ +int +get_func_trftypes(HeapTuple procTup, + Oid **p_trftypes) +{ + Datum protrftypes; + ArrayType *arr; + int nelems; + bool isNull; + + protrftypes = SysCacheGetAttr(PROCOID, procTup, + Anum_pg_proc_protrftypes, + &isNull); + if (!isNull) + { + /* + * We expect the arrays to be 1-D arrays of the right types; verify + * that. For the OID and char arrays, we don't need to use + * deconstruct_array() since the array data is just going to look like + * a C array of values. + */ + arr = DatumGetArrayTypeP(protrftypes); /* ensure not toasted */ + nelems = ARR_DIMS(arr)[0]; + if (ARR_NDIM(arr) != 1 || + nelems < 0 || + ARR_HASNULL(arr) || + ARR_ELEMTYPE(arr) != OIDOID) + elog(ERROR, "protrftypes is not a 1-D Oid array or it contains nulls"); + *p_trftypes = (Oid *) palloc(nelems * sizeof(Oid)); + memcpy(*p_trftypes, ARR_DATA_PTR(arr), + nelems * sizeof(Oid)); + + return nelems; + } + else + return 0; +} + +/* + * get_func_input_arg_names + * + * Extract the names of input arguments only, given a function's + * proargnames and proargmodes entries in Datum form. + * + * Returns the number of input arguments, which is the length of the + * palloc'd array returned to *arg_names. Entries for unnamed args + * are set to NULL. You don't get anything if proargnames is NULL. + */ +int +get_func_input_arg_names(Datum proargnames, Datum proargmodes, + char ***arg_names) +{ + ArrayType *arr; + int numargs; + Datum *argnames; + char *argmodes; + char **inargnames; + int numinargs; + int i; + + /* Do nothing if null proargnames */ + if (proargnames == PointerGetDatum(NULL)) + { + *arg_names = NULL; + return 0; + } + + /* + * We expect the arrays to be 1-D arrays of the right types; verify that. + * For proargmodes, we don't need to use deconstruct_array() since the + * array data is just going to look like a C array of values. + */ + arr = DatumGetArrayTypeP(proargnames); /* ensure not toasted */ + if (ARR_NDIM(arr) != 1 || + ARR_HASNULL(arr) || + ARR_ELEMTYPE(arr) != TEXTOID) + elog(ERROR, "proargnames is not a 1-D text array or it contains nulls"); + deconstruct_array(arr, TEXTOID, -1, false, TYPALIGN_INT, + &argnames, NULL, &numargs); + if (proargmodes != PointerGetDatum(NULL)) + { + arr = DatumGetArrayTypeP(proargmodes); /* ensure not toasted */ + if (ARR_NDIM(arr) != 1 || + ARR_DIMS(arr)[0] != numargs || + ARR_HASNULL(arr) || + ARR_ELEMTYPE(arr) != CHAROID) + elog(ERROR, "proargmodes is not a 1-D char array of length %d or it contains nulls", + numargs); + argmodes = (char *) ARR_DATA_PTR(arr); + } + else + argmodes = NULL; + + /* zero elements probably shouldn't happen, but handle it gracefully */ + if (numargs <= 0) + { + *arg_names = NULL; + return 0; + } + + /* extract input-argument names */ + inargnames = (char **) palloc(numargs * sizeof(char *)); + numinargs = 0; + for (i = 0; i < numargs; i++) + { + if (argmodes == NULL || + argmodes[i] == PROARGMODE_IN || + argmodes[i] == PROARGMODE_INOUT || + argmodes[i] == PROARGMODE_VARIADIC) + { + char *pname = TextDatumGetCString(argnames[i]); + + if (pname[0] != '\0') + inargnames[numinargs] = pname; + else + inargnames[numinargs] = NULL; + numinargs++; + } + } + + *arg_names = inargnames; + return numinargs; +} + + +/* + * get_func_result_name + * + * If the function has exactly one output parameter, and that parameter + * is named, return the name (as a palloc'd string). Else return NULL. + * + * This is used to determine the default output column name for functions + * returning scalar types. + */ +char * +get_func_result_name(Oid functionId) +{ + char *result; + HeapTuple procTuple; + Datum proargmodes; + Datum proargnames; + bool isnull; + ArrayType *arr; + int numargs; + char *argmodes; + Datum *argnames; + int numoutargs; + int nargnames; + int i; + + /* First fetch the function's pg_proc row */ + procTuple = SearchSysCache1(PROCOID, ObjectIdGetDatum(functionId)); + if (!HeapTupleIsValid(procTuple)) + elog(ERROR, "cache lookup failed for function %u", functionId); + + /* If there are no named OUT parameters, return NULL */ + if (heap_attisnull(procTuple, Anum_pg_proc_proargmodes, NULL) || + heap_attisnull(procTuple, Anum_pg_proc_proargnames, NULL)) + result = NULL; + else + { + /* Get the data out of the tuple */ + proargmodes = SysCacheGetAttr(PROCOID, procTuple, + Anum_pg_proc_proargmodes, + &isnull); + Assert(!isnull); + proargnames = SysCacheGetAttr(PROCOID, procTuple, + Anum_pg_proc_proargnames, + &isnull); + Assert(!isnull); + + /* + * We expect the arrays to be 1-D arrays of the right types; verify + * that. For the char array, we don't need to use deconstruct_array() + * since the array data is just going to look like a C array of + * values. + */ + arr = DatumGetArrayTypeP(proargmodes); /* ensure not toasted */ + numargs = ARR_DIMS(arr)[0]; + if (ARR_NDIM(arr) != 1 || + numargs < 0 || + ARR_HASNULL(arr) || + ARR_ELEMTYPE(arr) != CHAROID) + elog(ERROR, "proargmodes is not a 1-D char array or it contains nulls"); + argmodes = (char *) ARR_DATA_PTR(arr); + arr = DatumGetArrayTypeP(proargnames); /* ensure not toasted */ + if (ARR_NDIM(arr) != 1 || + ARR_DIMS(arr)[0] != numargs || + ARR_HASNULL(arr) || + ARR_ELEMTYPE(arr) != TEXTOID) + elog(ERROR, "proargnames is not a 1-D text array of length %d or it contains nulls", + numargs); + deconstruct_array(arr, TEXTOID, -1, false, TYPALIGN_INT, + &argnames, NULL, &nargnames); + Assert(nargnames == numargs); + + /* scan for output argument(s) */ + result = NULL; + numoutargs = 0; + for (i = 0; i < numargs; i++) + { + if (argmodes[i] == PROARGMODE_IN || + argmodes[i] == PROARGMODE_VARIADIC) + continue; + Assert(argmodes[i] == PROARGMODE_OUT || + argmodes[i] == PROARGMODE_INOUT || + argmodes[i] == PROARGMODE_TABLE); + if (++numoutargs > 1) + { + /* multiple out args, so forget it */ + result = NULL; + break; + } + result = TextDatumGetCString(argnames[i]); + if (result == NULL || result[0] == '\0') + { + /* Parameter is not named, so forget it */ + result = NULL; + break; + } + } + } + + ReleaseSysCache(procTuple); + + return result; +} + + +/* + * build_function_result_tupdesc_t + * + * Given a pg_proc row for a function, return a tuple descriptor for the + * result rowtype, or NULL if the function does not have OUT parameters. + * + * Note that this does not handle resolution of polymorphic types; + * that is deliberate. + */ +TupleDesc +build_function_result_tupdesc_t(HeapTuple procTuple) +{ + Form_pg_proc procform = (Form_pg_proc) GETSTRUCT(procTuple); + Datum proallargtypes; + Datum proargmodes; + Datum proargnames; + bool isnull; + + /* Return NULL if the function isn't declared to return RECORD */ + if (procform->prorettype != RECORDOID) + return NULL; + + /* If there are no OUT parameters, return NULL */ + if (heap_attisnull(procTuple, Anum_pg_proc_proallargtypes, NULL) || + heap_attisnull(procTuple, Anum_pg_proc_proargmodes, NULL)) + return NULL; + + /* Get the data out of the tuple */ + proallargtypes = SysCacheGetAttr(PROCOID, procTuple, + Anum_pg_proc_proallargtypes, + &isnull); + Assert(!isnull); + proargmodes = SysCacheGetAttr(PROCOID, procTuple, + Anum_pg_proc_proargmodes, + &isnull); + Assert(!isnull); + proargnames = SysCacheGetAttr(PROCOID, procTuple, + Anum_pg_proc_proargnames, + &isnull); + if (isnull) + proargnames = PointerGetDatum(NULL); /* just to be sure */ + + return build_function_result_tupdesc_d(procform->prokind, + proallargtypes, + proargmodes, + proargnames); +} + +/* + * build_function_result_tupdesc_d + * + * Build a RECORD function's tupledesc from the pg_proc proallargtypes, + * proargmodes, and proargnames arrays. This is split out for the + * convenience of ProcedureCreate, which needs to be able to compute the + * tupledesc before actually creating the function. + * + * For functions (but not for procedures), returns NULL if there are not at + * least two OUT or INOUT arguments. + */ +TupleDesc +build_function_result_tupdesc_d(char prokind, + Datum proallargtypes, + Datum proargmodes, + Datum proargnames) +{ + TupleDesc desc; + ArrayType *arr; + int numargs; + Oid *argtypes; + char *argmodes; + Datum *argnames = NULL; + Oid *outargtypes; + char **outargnames; + int numoutargs; + int nargnames; + int i; + + /* Can't have output args if columns are null */ + if (proallargtypes == PointerGetDatum(NULL) || + proargmodes == PointerGetDatum(NULL)) + return NULL; + + /* + * We expect the arrays to be 1-D arrays of the right types; verify that. + * For the OID and char arrays, we don't need to use deconstruct_array() + * since the array data is just going to look like a C array of values. + */ + arr = DatumGetArrayTypeP(proallargtypes); /* ensure not toasted */ + numargs = ARR_DIMS(arr)[0]; + if (ARR_NDIM(arr) != 1 || + numargs < 0 || + ARR_HASNULL(arr) || + ARR_ELEMTYPE(arr) != OIDOID) + elog(ERROR, "proallargtypes is not a 1-D Oid array or it contains nulls"); + argtypes = (Oid *) ARR_DATA_PTR(arr); + arr = DatumGetArrayTypeP(proargmodes); /* ensure not toasted */ + if (ARR_NDIM(arr) != 1 || + ARR_DIMS(arr)[0] != numargs || + ARR_HASNULL(arr) || + ARR_ELEMTYPE(arr) != CHAROID) + elog(ERROR, "proargmodes is not a 1-D char array of length %d or it contains nulls", + numargs); + argmodes = (char *) ARR_DATA_PTR(arr); + if (proargnames != PointerGetDatum(NULL)) + { + arr = DatumGetArrayTypeP(proargnames); /* ensure not toasted */ + if (ARR_NDIM(arr) != 1 || + ARR_DIMS(arr)[0] != numargs || + ARR_HASNULL(arr) || + ARR_ELEMTYPE(arr) != TEXTOID) + elog(ERROR, "proargnames is not a 1-D text array of length %d or it contains nulls", + numargs); + deconstruct_array(arr, TEXTOID, -1, false, TYPALIGN_INT, + &argnames, NULL, &nargnames); + Assert(nargnames == numargs); + } + + /* zero elements probably shouldn't happen, but handle it gracefully */ + if (numargs <= 0) + return NULL; + + /* extract output-argument types and names */ + outargtypes = (Oid *) palloc(numargs * sizeof(Oid)); + outargnames = (char **) palloc(numargs * sizeof(char *)); + numoutargs = 0; + for (i = 0; i < numargs; i++) + { + char *pname; + + if (argmodes[i] == PROARGMODE_IN || + argmodes[i] == PROARGMODE_VARIADIC) + continue; + Assert(argmodes[i] == PROARGMODE_OUT || + argmodes[i] == PROARGMODE_INOUT || + argmodes[i] == PROARGMODE_TABLE); + outargtypes[numoutargs] = argtypes[i]; + if (argnames) + pname = TextDatumGetCString(argnames[i]); + else + pname = NULL; + if (pname == NULL || pname[0] == '\0') + { + /* Parameter is not named, so gin up a column name */ + pname = psprintf("column%d", numoutargs + 1); + } + outargnames[numoutargs] = pname; + numoutargs++; + } + + /* + * If there is no output argument, or only one, the function does not + * return tuples. + */ + if (numoutargs < 2 && prokind != PROKIND_PROCEDURE) + return NULL; + + desc = CreateTemplateTupleDesc(numoutargs); + for (i = 0; i < numoutargs; i++) + { + TupleDescInitEntry(desc, i + 1, + outargnames[i], + outargtypes[i], + -1, + 0); + } + + return desc; +} + + +/* + * RelationNameGetTupleDesc + * + * Given a (possibly qualified) relation name, build a TupleDesc. + * + * Note: while this works as advertised, it's seldom the best way to + * build a tupdesc for a function's result type. It's kept around + * only for backwards compatibility with existing user-written code. + */ +TupleDesc +RelationNameGetTupleDesc(const char *relname) +{ + RangeVar *relvar; + Relation rel; + TupleDesc tupdesc; + List *relname_list; + + /* Open relation and copy the tuple description */ + relname_list = stringToQualifiedNameList(relname); + relvar = makeRangeVarFromNameList(relname_list); + rel = relation_openrv(relvar, AccessShareLock); + tupdesc = CreateTupleDescCopy(RelationGetDescr(rel)); + relation_close(rel, AccessShareLock); + + return tupdesc; +} + +/* + * TypeGetTupleDesc + * + * Given a type Oid, build a TupleDesc. (In most cases you should be + * using get_call_result_type or one of its siblings instead of this + * routine, so that you can handle OUT parameters, RECORD result type, + * and polymorphic results.) + * + * If the type is composite, *and* a colaliases List is provided, *and* + * the List is of natts length, use the aliases instead of the relation + * attnames. (NB: this usage is deprecated since it may result in + * creation of unnecessary transient record types.) + * + * If the type is a base type, a single item alias List is required. + */ +TupleDesc +TypeGetTupleDesc(Oid typeoid, List *colaliases) +{ + Oid base_typeoid; + TypeFuncClass functypclass = get_type_func_class(typeoid, &base_typeoid); + TupleDesc tupdesc = NULL; + + /* + * Build a suitable tupledesc representing the output rows. We + * intentionally do not support TYPEFUNC_COMPOSITE_DOMAIN here, as it's + * unlikely that legacy callers of this obsolete function would be + * prepared to apply domain constraints. + */ + if (functypclass == TYPEFUNC_COMPOSITE) + { + /* Composite data type, e.g. a table's row type */ + tupdesc = lookup_rowtype_tupdesc_copy(base_typeoid, -1); + + if (colaliases != NIL) + { + int natts = tupdesc->natts; + int varattno; + + /* does the list length match the number of attributes? */ + if (list_length(colaliases) != natts) + ereport(ERROR, + (errcode(ERRCODE_DATATYPE_MISMATCH), + errmsg("number of aliases does not match number of columns"))); + + /* OK, use the aliases instead */ + for (varattno = 0; varattno < natts; varattno++) + { + char *label = strVal(list_nth(colaliases, varattno)); + Form_pg_attribute attr = TupleDescAttr(tupdesc, varattno); + + if (label != NULL) + namestrcpy(&(attr->attname), label); + } + + /* The tuple type is now an anonymous record type */ + tupdesc->tdtypeid = RECORDOID; + tupdesc->tdtypmod = -1; + } + } + else if (functypclass == TYPEFUNC_SCALAR) + { + /* Base data type, i.e. scalar */ + char *attname; + + /* the alias list is required for base types */ + if (colaliases == NIL) + ereport(ERROR, + (errcode(ERRCODE_DATATYPE_MISMATCH), + errmsg("no column alias was provided"))); + + /* the alias list length must be 1 */ + if (list_length(colaliases) != 1) + ereport(ERROR, + (errcode(ERRCODE_DATATYPE_MISMATCH), + errmsg("number of aliases does not match number of columns"))); + + /* OK, get the column alias */ + attname = strVal(linitial(colaliases)); + + tupdesc = CreateTemplateTupleDesc(1); + TupleDescInitEntry(tupdesc, + (AttrNumber) 1, + attname, + typeoid, + -1, + 0); + } + else if (functypclass == TYPEFUNC_RECORD) + { + /* XXX can't support this because typmod wasn't passed in ... */ + ereport(ERROR, + (errcode(ERRCODE_DATATYPE_MISMATCH), + errmsg("could not determine row description for function returning record"))); + } + else + { + /* crummy error message, but parser should have caught this */ + elog(ERROR, "function in FROM has unsupported return type"); + } + + return tupdesc; +} + +/* + * extract_variadic_args + * + * Extract a set of argument values, types and NULL markers for a given + * input function which makes use of a VARIADIC input whose argument list + * depends on the caller context. When doing a VARIADIC call, the caller + * has provided one argument made of an array of values, so deconstruct the + * array data before using it for the next processing. If no VARIADIC call + * is used, just fill in the status data based on all the arguments given + * by the caller. + * + * This function returns the number of arguments generated, or -1 in the + * case of "VARIADIC NULL". + */ +int +extract_variadic_args(FunctionCallInfo fcinfo, int variadic_start, + bool convert_unknown, Datum **args, Oid **types, + bool **nulls) +{ + bool variadic = get_fn_expr_variadic(fcinfo->flinfo); + Datum *args_res; + bool *nulls_res; + Oid *types_res; + int nargs, + i; + + *args = NULL; + *types = NULL; + *nulls = NULL; + + if (variadic) + { + ArrayType *array_in; + Oid element_type; + bool typbyval; + char typalign; + int16 typlen; + + Assert(PG_NARGS() == variadic_start + 1); + + if (PG_ARGISNULL(variadic_start)) + return -1; + + array_in = PG_GETARG_ARRAYTYPE_P(variadic_start); + element_type = ARR_ELEMTYPE(array_in); + + get_typlenbyvalalign(element_type, + &typlen, &typbyval, &typalign); + deconstruct_array(array_in, element_type, typlen, typbyval, + typalign, &args_res, &nulls_res, + &nargs); + + /* All the elements of the array have the same type */ + types_res = (Oid *) palloc0(nargs * sizeof(Oid)); + for (i = 0; i < nargs; i++) + types_res[i] = element_type; + } + else + { + nargs = PG_NARGS() - variadic_start; + Assert(nargs > 0); + nulls_res = (bool *) palloc0(nargs * sizeof(bool)); + args_res = (Datum *) palloc0(nargs * sizeof(Datum)); + types_res = (Oid *) palloc0(nargs * sizeof(Oid)); + + for (i = 0; i < nargs; i++) + { + nulls_res[i] = PG_ARGISNULL(i + variadic_start); + types_res[i] = get_fn_expr_argtype(fcinfo->flinfo, + i + variadic_start); + + /* + * Turn a constant (more or less literal) value that's of unknown + * type into text if required. Unknowns come in as a cstring + * pointer. Note: for functions declared as taking type "any", the + * parser will not do any type conversion on unknown-type literals + * (that is, undecorated strings or NULLs). + */ + if (convert_unknown && + types_res[i] == UNKNOWNOID && + get_fn_expr_arg_stable(fcinfo->flinfo, i + variadic_start)) + { + types_res[i] = TEXTOID; + + if (PG_ARGISNULL(i + variadic_start)) + args_res[i] = (Datum) 0; + else + args_res[i] = + CStringGetTextDatum(PG_GETARG_POINTER(i + variadic_start)); + } + else + { + /* no conversion needed, just take the datum as given */ + args_res[i] = PG_GETARG_DATUM(i + variadic_start); + } + + if (!OidIsValid(types_res[i]) || + (convert_unknown && types_res[i] == UNKNOWNOID)) + ereport(ERROR, + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), + errmsg("could not determine data type for argument %d", + i + 1))); + } + } + + /* Fill in results */ + *args = args_res; + *nulls = nulls_res; + *types = types_res; + + return nargs; +} diff --git a/src/backend/utils/fmgroids.h b/src/backend/utils/fmgroids.h new file mode 100644 index 0000000..4cbc374 --- /dev/null +++ b/src/backend/utils/fmgroids.h @@ -0,0 +1,3261 @@ +/*------------------------------------------------------------------------- + * + * fmgroids.h + * Macros that define the OIDs of built-in functions. + * + * These macros can be used to avoid a catalog lookup when a specific + * fmgr-callable function needs to be referenced. + * + * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * NOTES + * ****************************** + * *** DO NOT EDIT THIS FILE! *** + * ****************************** + * + * It has been GENERATED by src/backend/utils/Gen_fmgrtab.pl + * + *------------------------------------------------------------------------- + */ +#ifndef FMGROIDS_H +#define FMGROIDS_H + +/* + * Constant macros for the OIDs of entries in pg_proc. + * + * F_XXX macros are named after the proname field; if that is not unique, + * we append the proargtypes field, replacing spaces with underscores. + * For example, we have F_OIDEQ because that proname is unique, but + * F_POW_FLOAT8_FLOAT8 (among others) because that proname is not. + */ +#define F_HEAP_TABLEAM_HANDLER 3 +#define F_BYTEAOUT 31 +#define F_CHAROUT 33 +#define F_NAMEIN 34 +#define F_NAMEOUT 35 +#define F_INT2IN 38 +#define F_INT2OUT 39 +#define F_INT2VECTORIN 40 +#define F_INT2VECTOROUT 41 +#define F_INT4IN 42 +#define F_INT4OUT 43 +#define F_REGPROCIN 44 +#define F_REGPROCOUT 45 +#define F_TEXTIN 46 +#define F_TEXTOUT 47 +#define F_TIDIN 48 +#define F_TIDOUT 49 +#define F_XIDIN 50 +#define F_XIDOUT 51 +#define F_CIDIN 52 +#define F_CIDOUT 53 +#define F_OIDVECTORIN 54 +#define F_OIDVECTOROUT 55 +#define F_BOOLLT 56 +#define F_BOOLGT 57 +#define F_BOOLEQ 60 +#define F_CHAREQ 61 +#define F_NAMEEQ 62 +#define F_INT2EQ 63 +#define F_INT2LT 64 +#define F_INT4EQ 65 +#define F_INT4LT 66 +#define F_TEXTEQ 67 +#define F_XIDEQ 68 +#define F_CIDEQ 69 +#define F_CHARNE 70 +#define F_CHARLE 72 +#define F_CHARGT 73 +#define F_CHARGE 74 +#define F_INT4_CHAR 77 +#define F_CHAR_INT4 78 +#define F_NAMEREGEXEQ 79 +#define F_BOOLNE 84 +#define F_PG_DDL_COMMAND_IN 86 +#define F_PG_DDL_COMMAND_OUT 87 +#define F_PG_DDL_COMMAND_RECV 88 +#define F_VERSION 89 +#define F_PG_DDL_COMMAND_SEND 90 +#define F_EQSEL 101 +#define F_NEQSEL 102 +#define F_SCALARLTSEL 103 +#define F_SCALARGTSEL 104 +#define F_EQJOINSEL 105 +#define F_NEQJOINSEL 106 +#define F_SCALARLTJOINSEL 107 +#define F_SCALARGTJOINSEL 108 +#define F_UNKNOWNIN 109 +#define F_UNKNOWNOUT 110 +#define F_BOX_ABOVE_EQ 115 +#define F_BOX_BELOW_EQ 116 +#define F_POINT_IN 117 +#define F_POINT_OUT 118 +#define F_LSEG_IN 119 +#define F_LSEG_OUT 120 +#define F_PATH_IN 121 +#define F_PATH_OUT 122 +#define F_BOX_IN 123 +#define F_BOX_OUT 124 +#define F_BOX_OVERLAP 125 +#define F_BOX_GE 126 +#define F_BOX_GT 127 +#define F_BOX_EQ 128 +#define F_BOX_LT 129 +#define F_BOX_LE 130 +#define F_POINT_ABOVE 131 +#define F_POINT_LEFT 132 +#define F_POINT_RIGHT 133 +#define F_POINT_BELOW 134 +#define F_POINT_EQ 135 +#define F_ON_PB 136 +#define F_ON_PPATH 137 +#define F_BOX_CENTER 138 +#define F_AREASEL 139 +#define F_AREAJOINSEL 140 +#define F_INT4MUL 141 +#define F_INT4NE 144 +#define F_INT2NE 145 +#define F_INT2GT 146 +#define F_INT4GT 147 +#define F_INT2LE 148 +#define F_INT4LE 149 +#define F_INT4GE 150 +#define F_INT2GE 151 +#define F_INT2MUL 152 +#define F_INT2DIV 153 +#define F_INT4DIV 154 +#define F_INT2MOD 155 +#define F_INT4MOD 156 +#define F_TEXTNE 157 +#define F_INT24EQ 158 +#define F_INT42EQ 159 +#define F_INT24LT 160 +#define F_INT42LT 161 +#define F_INT24GT 162 +#define F_INT42GT 163 +#define F_INT24NE 164 +#define F_INT42NE 165 +#define F_INT24LE 166 +#define F_INT42LE 167 +#define F_INT24GE 168 +#define F_INT42GE 169 +#define F_INT24MUL 170 +#define F_INT42MUL 171 +#define F_INT24DIV 172 +#define F_INT42DIV 173 +#define F_INT2PL 176 +#define F_INT4PL 177 +#define F_INT24PL 178 +#define F_INT42PL 179 +#define F_INT2MI 180 +#define F_INT4MI 181 +#define F_INT24MI 182 +#define F_INT42MI 183 +#define F_OIDEQ 184 +#define F_OIDNE 185 +#define F_BOX_SAME 186 +#define F_BOX_CONTAIN 187 +#define F_BOX_LEFT 188 +#define F_BOX_OVERLEFT 189 +#define F_BOX_OVERRIGHT 190 +#define F_BOX_RIGHT 191 +#define F_BOX_CONTAINED 192 +#define F_BOX_CONTAIN_PT 193 +#define F_PG_NODE_TREE_IN 195 +#define F_PG_NODE_TREE_OUT 196 +#define F_PG_NODE_TREE_RECV 197 +#define F_PG_NODE_TREE_SEND 198 +#define F_FLOAT4IN 200 +#define F_FLOAT4OUT 201 +#define F_FLOAT4MUL 202 +#define F_FLOAT4DIV 203 +#define F_FLOAT4PL 204 +#define F_FLOAT4MI 205 +#define F_FLOAT4UM 206 +#define F_FLOAT4ABS 207 +#define F_FLOAT4_ACCUM 208 +#define F_FLOAT4LARGER 209 +#define F_FLOAT4SMALLER 211 +#define F_INT4UM 212 +#define F_INT2UM 213 +#define F_FLOAT8IN 214 +#define F_FLOAT8OUT 215 +#define F_FLOAT8MUL 216 +#define F_FLOAT8DIV 217 +#define F_FLOAT8PL 218 +#define F_FLOAT8MI 219 +#define F_FLOAT8UM 220 +#define F_FLOAT8ABS 221 +#define F_FLOAT8_ACCUM 222 +#define F_FLOAT8LARGER 223 +#define F_FLOAT8SMALLER 224 +#define F_LSEG_CENTER 225 +#define F_POLY_CENTER 227 +#define F_DROUND 228 +#define F_DTRUNC 229 +#define F_DSQRT 230 +#define F_DCBRT 231 +#define F_DPOW 232 +#define F_DEXP 233 +#define F_DLOG1 234 +#define F_FLOAT8_INT2 235 +#define F_FLOAT4_INT2 236 +#define F_INT2_FLOAT8 237 +#define F_INT2_FLOAT4 238 +#define F_LINE_DISTANCE 239 +#define F_NAMEEQTEXT 240 +#define F_NAMELTTEXT 241 +#define F_NAMELETEXT 242 +#define F_NAMEGETEXT 243 +#define F_NAMEGTTEXT 244 +#define F_NAMENETEXT 245 +#define F_BTNAMETEXTCMP 246 +#define F_TEXTEQNAME 247 +#define F_TEXTLTNAME 248 +#define F_TEXTLENAME 249 +#define F_TEXTGENAME 250 +#define F_TEXTGTNAME 251 +#define F_TEXTNENAME 252 +#define F_BTTEXTNAMECMP 253 +#define F_NAMECONCATOID 266 +#define F_TABLE_AM_HANDLER_IN 267 +#define F_TABLE_AM_HANDLER_OUT 268 +#define F_TIMEOFDAY 274 +#define F_PG_NEXTOID 275 +#define F_FLOAT8_COMBINE 276 +#define F_INTER_SL 277 +#define F_INTER_LB 278 +#define F_FLOAT48MUL 279 +#define F_FLOAT48DIV 280 +#define F_FLOAT48PL 281 +#define F_FLOAT48MI 282 +#define F_FLOAT84MUL 283 +#define F_FLOAT84DIV 284 +#define F_FLOAT84PL 285 +#define F_FLOAT84MI 286 +#define F_FLOAT4EQ 287 +#define F_FLOAT4NE 288 +#define F_FLOAT4LT 289 +#define F_FLOAT4LE 290 +#define F_FLOAT4GT 291 +#define F_FLOAT4GE 292 +#define F_FLOAT8EQ 293 +#define F_FLOAT8NE 294 +#define F_FLOAT8LT 295 +#define F_FLOAT8LE 296 +#define F_FLOAT8GT 297 +#define F_FLOAT8GE 298 +#define F_FLOAT48EQ 299 +#define F_FLOAT48NE 300 +#define F_FLOAT48LT 301 +#define F_FLOAT48LE 302 +#define F_FLOAT48GT 303 +#define F_FLOAT48GE 304 +#define F_FLOAT84EQ 305 +#define F_FLOAT84NE 306 +#define F_FLOAT84LT 307 +#define F_FLOAT84LE 308 +#define F_FLOAT84GT 309 +#define F_FLOAT84GE 310 +#define F_FLOAT8_FLOAT4 311 +#define F_FLOAT4_FLOAT8 312 +#define F_INT4_INT2 313 +#define F_INT2_INT4 314 +#define F_PG_JIT_AVAILABLE 315 +#define F_FLOAT8_INT4 316 +#define F_INT4_FLOAT8 317 +#define F_FLOAT4_INT4 318 +#define F_INT4_FLOAT4 319 +#define F_WIDTH_BUCKET_FLOAT8_FLOAT8_FLOAT8_INT4 320 +#define F_JSON_IN 321 +#define F_JSON_OUT 322 +#define F_JSON_RECV 323 +#define F_JSON_SEND 324 +#define F_INDEX_AM_HANDLER_IN 326 +#define F_INDEX_AM_HANDLER_OUT 327 +#define F_HASHMACADDR8 328 +#define F_HASH_ACLITEM 329 +#define F_BTHANDLER 330 +#define F_HASHHANDLER 331 +#define F_GISTHANDLER 332 +#define F_GINHANDLER 333 +#define F_SPGHANDLER 334 +#define F_BRINHANDLER 335 +#define F_SCALARLESEL 336 +#define F_SCALARGESEL 337 +#define F_AMVALIDATE 338 +#define F_POLY_SAME 339 +#define F_POLY_CONTAIN 340 +#define F_POLY_LEFT 341 +#define F_POLY_OVERLEFT 342 +#define F_POLY_OVERRIGHT 343 +#define F_POLY_RIGHT 344 +#define F_POLY_CONTAINED 345 +#define F_POLY_OVERLAP 346 +#define F_POLY_IN 347 +#define F_POLY_OUT 348 +#define F_BTINT2CMP 350 +#define F_BTINT4CMP 351 +#define F_BTFLOAT4CMP 354 +#define F_BTFLOAT8CMP 355 +#define F_BTOIDCMP 356 +#define F_DIST_BP 357 +#define F_BTCHARCMP 358 +#define F_BTNAMECMP 359 +#define F_BTTEXTCMP 360 +#define F_LSEG_DISTANCE 361 +#define F_LSEG_INTERPT 362 +#define F_DIST_PS 363 +#define F_DIST_PB 364 +#define F_DIST_SB 365 +#define F_CLOSE_PS 366 +#define F_CLOSE_PB 367 +#define F_CLOSE_SB 368 +#define F_ON_PS 369 +#define F_PATH_DISTANCE 370 +#define F_DIST_PPATH 371 +#define F_ON_SB 372 +#define F_INTER_SB 373 +#define F_STRING_TO_ARRAY_TEXT_TEXT_TEXT 376 +#define F_CASH_CMP 377 +#define F_ARRAY_APPEND 378 +#define F_ARRAY_PREPEND 379 +#define F_DIST_SP 380 +#define F_DIST_BS 381 +#define F_BTARRAYCMP 382 +#define F_ARRAY_CAT 383 +#define F_ARRAY_TO_STRING_ANYARRAY_TEXT_TEXT 384 +#define F_SCALARLEJOINSEL 386 +#define F_ARRAY_NE 390 +#define F_ARRAY_LT 391 +#define F_ARRAY_GT 392 +#define F_ARRAY_LE 393 +#define F_STRING_TO_ARRAY_TEXT_TEXT 394 +#define F_ARRAY_TO_STRING_ANYARRAY_TEXT 395 +#define F_ARRAY_GE 396 +#define F_SCALARGEJOINSEL 398 +#define F_HASHMACADDR 399 +#define F_HASHTEXT 400 +#define F_TEXT_BPCHAR 401 +#define F_BTOIDVECTORCMP 404 +#define F_TEXT_NAME 406 +#define F_NAME_TEXT 407 +#define F_BPCHAR_NAME 408 +#define F_NAME_BPCHAR 409 +#define F_DIST_PATHP 421 +#define F_HASHINET 422 +#define F_HASHINT4EXTENDED 425 +#define F_HASH_NUMERIC 432 +#define F_MACADDR_IN 436 +#define F_MACADDR_OUT 437 +#define F_NUM_NULLS 438 +#define F_NUM_NONNULLS 440 +#define F_HASHINT2EXTENDED 441 +#define F_HASHINT8EXTENDED 442 +#define F_HASHFLOAT4EXTENDED 443 +#define F_HASHFLOAT8EXTENDED 444 +#define F_HASHOIDEXTENDED 445 +#define F_HASHCHAREXTENDED 446 +#define F_HASHNAMEEXTENDED 447 +#define F_HASHTEXTEXTENDED 448 +#define F_HASHINT2 449 +#define F_HASHINT4 450 +#define F_HASHFLOAT4 451 +#define F_HASHFLOAT8 452 +#define F_HASHOID 453 +#define F_HASHCHAR 454 +#define F_HASHNAME 455 +#define F_HASHVARLENA 456 +#define F_HASHOIDVECTOR 457 +#define F_TEXT_LARGER 458 +#define F_TEXT_SMALLER 459 +#define F_INT8IN 460 +#define F_INT8OUT 461 +#define F_INT8UM 462 +#define F_INT8PL 463 +#define F_INT8MI 464 +#define F_INT8MUL 465 +#define F_INT8DIV 466 +#define F_INT8EQ 467 +#define F_INT8NE 468 +#define F_INT8LT 469 +#define F_INT8GT 470 +#define F_INT8LE 471 +#define F_INT8GE 472 +#define F_INT84EQ 474 +#define F_INT84NE 475 +#define F_INT84LT 476 +#define F_INT84GT 477 +#define F_INT84LE 478 +#define F_INT84GE 479 +#define F_INT4_INT8 480 +#define F_INT8_INT4 481 +#define F_FLOAT8_INT8 482 +#define F_INT8_FLOAT8 483 +#define F_ARRAY_LARGER 515 +#define F_ARRAY_SMALLER 516 +#define F_ABBREV_INET 598 +#define F_ABBREV_CIDR 599 +#define F_SET_MASKLEN_INET_INT4 605 +#define F_OIDVECTORNE 619 +#define F_HASH_ARRAY 626 +#define F_SET_MASKLEN_CIDR_INT4 635 +#define F_PG_INDEXAM_HAS_PROPERTY 636 +#define F_PG_INDEX_HAS_PROPERTY 637 +#define F_PG_INDEX_COLUMN_HAS_PROPERTY 638 +#define F_FLOAT4_INT8 652 +#define F_INT8_FLOAT4 653 +#define F_NAMELT 655 +#define F_NAMELE 656 +#define F_NAMEGT 657 +#define F_NAMEGE 658 +#define F_NAMENE 659 +#define F_BPCHAR_BPCHAR_INT4_BOOL 668 +#define F_VARCHAR_VARCHAR_INT4_BOOL 669 +#define F_PG_INDEXAM_PROGRESS_PHASENAME 676 +#define F_OIDVECTORLT 677 +#define F_OIDVECTORLE 678 +#define F_OIDVECTOREQ 679 +#define F_OIDVECTORGE 680 +#define F_OIDVECTORGT 681 +#define F_NETWORK 683 +#define F_NETMASK 696 +#define F_MASKLEN 697 +#define F_BROADCAST 698 +#define F_HOST 699 +#define F_DIST_LP 702 +#define F_DIST_LS 704 +#define F_GETPGUSERNAME 710 +#define F_FAMILY 711 +#define F_INT2_INT8 714 +#define F_LO_CREATE 715 +#define F_OIDLT 716 +#define F_OIDLE 717 +#define F_OCTET_LENGTH_BYTEA 720 +#define F_GET_BYTE 721 +#define F_SET_BYTE 722 +#define F_GET_BIT_BYTEA_INT8 723 +#define F_SET_BIT_BYTEA_INT8_INT4 724 +#define F_DIST_PL 725 +#define F_DIST_SL 727 +#define F_DIST_CPOLY 728 +#define F_POLY_DISTANCE 729 +#define F_TEXT_INET 730 +#define F_TEXT_LT 740 +#define F_TEXT_LE 741 +#define F_TEXT_GT 742 +#define F_TEXT_GE 743 +#define F_ARRAY_EQ 744 +#define F_CURRENT_USER 745 +#define F_SESSION_USER 746 +#define F_ARRAY_DIMS 747 +#define F_ARRAY_NDIMS 748 +#define F_OVERLAY_BYTEA_BYTEA_INT4_INT4 749 +#define F_ARRAY_IN 750 +#define F_ARRAY_OUT 751 +#define F_OVERLAY_BYTEA_BYTEA_INT4 752 +#define F_TRUNC_MACADDR 753 +#define F_INT8_INT2 754 +#define F_LO_IMPORT_TEXT 764 +#define F_LO_EXPORT 765 +#define F_INT4INC 766 +#define F_LO_IMPORT_TEXT_OID 767 +#define F_INT4LARGER 768 +#define F_INT4SMALLER 769 +#define F_INT2LARGER 770 +#define F_INT2SMALLER 771 +#define F_HASHVARLENAEXTENDED 772 +#define F_HASHOIDVECTOREXTENDED 776 +#define F_HASH_ACLITEM_EXTENDED 777 +#define F_HASHMACADDREXTENDED 778 +#define F_HASHINETEXTENDED 779 +#define F_HASH_NUMERIC_EXTENDED 780 +#define F_HASHMACADDR8EXTENDED 781 +#define F_HASH_ARRAY_EXTENDED 782 +#define F_DIST_POLYC 785 +#define F_PG_CLIENT_ENCODING 810 +#define F_CURRENT_QUERY 817 +#define F_MACADDR_EQ 830 +#define F_MACADDR_LT 831 +#define F_MACADDR_LE 832 +#define F_MACADDR_GT 833 +#define F_MACADDR_GE 834 +#define F_MACADDR_NE 835 +#define F_MACADDR_CMP 836 +#define F_INT82PL 837 +#define F_INT82MI 838 +#define F_INT82MUL 839 +#define F_INT82DIV 840 +#define F_INT28PL 841 +#define F_BTINT8CMP 842 +#define F_CASH_MUL_FLT4 846 +#define F_CASH_DIV_FLT4 847 +#define F_FLT4_MUL_CASH 848 +#define F_POSITION_TEXT_TEXT 849 +#define F_TEXTLIKE 850 +#define F_TEXTNLIKE 851 +#define F_INT48EQ 852 +#define F_INT48NE 853 +#define F_INT48LT 854 +#define F_INT48GT 855 +#define F_INT48LE 856 +#define F_INT48GE 857 +#define F_NAMELIKE 858 +#define F_NAMENLIKE 859 +#define F_BPCHAR_CHAR 860 +#define F_CURRENT_DATABASE 861 +#define F_INT4_MUL_CASH 862 +#define F_INT2_MUL_CASH 863 +#define F_CASH_MUL_INT4 864 +#define F_CASH_DIV_INT4 865 +#define F_CASH_MUL_INT2 866 +#define F_CASH_DIV_INT2 867 +#define F_STRPOS 868 +#define F_LOWER_TEXT 870 +#define F_UPPER_TEXT 871 +#define F_INITCAP 872 +#define F_LPAD_TEXT_INT4_TEXT 873 +#define F_RPAD_TEXT_INT4_TEXT 874 +#define F_LTRIM_TEXT_TEXT 875 +#define F_RTRIM_TEXT_TEXT 876 +#define F_SUBSTR_TEXT_INT4_INT4 877 +#define F_TRANSLATE 878 +#define F_LPAD_TEXT_INT4 879 +#define F_RPAD_TEXT_INT4 880 +#define F_LTRIM_TEXT 881 +#define F_RTRIM_TEXT 882 +#define F_SUBSTR_TEXT_INT4 883 +#define F_BTRIM_TEXT_TEXT 884 +#define F_BTRIM_TEXT 885 +#define F_CASH_IN 886 +#define F_CASH_OUT 887 +#define F_CASH_EQ 888 +#define F_CASH_NE 889 +#define F_CASH_LT 890 +#define F_CASH_LE 891 +#define F_CASH_GT 892 +#define F_CASH_GE 893 +#define F_CASH_PL 894 +#define F_CASH_MI 895 +#define F_CASH_MUL_FLT8 896 +#define F_CASH_DIV_FLT8 897 +#define F_CASHLARGER 898 +#define F_CASHSMALLER 899 +#define F_INET_IN 910 +#define F_INET_OUT 911 +#define F_FLT8_MUL_CASH 919 +#define F_NETWORK_EQ 920 +#define F_NETWORK_LT 921 +#define F_NETWORK_LE 922 +#define F_NETWORK_GT 923 +#define F_NETWORK_GE 924 +#define F_NETWORK_NE 925 +#define F_NETWORK_CMP 926 +#define F_NETWORK_SUB 927 +#define F_NETWORK_SUBEQ 928 +#define F_NETWORK_SUP 929 +#define F_NETWORK_SUPEQ 930 +#define F_CASH_WORDS 935 +#define F_SUBSTRING_TEXT_INT4_INT4 936 +#define F_SUBSTRING_TEXT_INT4 937 +#define F_GENERATE_SERIES_TIMESTAMP_TIMESTAMP_INTERVAL 938 +#define F_GENERATE_SERIES_TIMESTAMPTZ_TIMESTAMPTZ_INTERVAL 939 +#define F_MOD_INT2_INT2 940 +#define F_MOD_INT4_INT4 941 +#define F_INT28MI 942 +#define F_INT28MUL 943 +#define F_CHAR_TEXT 944 +#define F_INT8MOD 945 +#define F_TEXT_CHAR 946 +#define F_MOD_INT8_INT8 947 +#define F_INT28DIV 948 +#define F_HASHINT8 949 +#define F_LO_OPEN 952 +#define F_LO_CLOSE 953 +#define F_LOREAD 954 +#define F_LOWRITE 955 +#define F_LO_LSEEK 956 +#define F_LO_CREAT 957 +#define F_LO_TELL 958 +#define F_ON_PL 959 +#define F_ON_SL 960 +#define F_CLOSE_PL 961 +#define F_LO_UNLINK 964 +#define F_HASHBPCHAREXTENDED 972 +#define F_PATH_INTER 973 +#define F_AREA_BOX 975 +#define F_WIDTH 976 +#define F_HEIGHT 977 +#define F_BOX_DISTANCE 978 +#define F_AREA_PATH 979 +#define F_BOX_INTERSECT 980 +#define F_DIAGONAL 981 +#define F_PATH_N_LT 982 +#define F_PATH_N_GT 983 +#define F_PATH_N_EQ 984 +#define F_PATH_N_LE 985 +#define F_PATH_N_GE 986 +#define F_PATH_LENGTH 987 +#define F_POINT_NE 988 +#define F_POINT_VERT 989 +#define F_POINT_HORIZ 990 +#define F_POINT_DISTANCE 991 +#define F_SLOPE 992 +#define F_LSEG_POINT_POINT 993 +#define F_LSEG_INTERSECT 994 +#define F_LSEG_PARALLEL 995 +#define F_LSEG_PERP 996 +#define F_LSEG_VERTICAL 997 +#define F_LSEG_HORIZONTAL 998 +#define F_LSEG_EQ 999 +#define F_LO_TRUNCATE 1004 +#define F_TEXTLIKE_SUPPORT 1023 +#define F_TEXTICREGEXEQ_SUPPORT 1024 +#define F_TEXTICLIKE_SUPPORT 1025 +#define F_TIMEZONE_INTERVAL_TIMESTAMPTZ 1026 +#define F_GIST_POINT_COMPRESS 1030 +#define F_ACLITEMIN 1031 +#define F_ACLITEMOUT 1032 +#define F_ACLINSERT 1035 +#define F_ACLREMOVE 1036 +#define F_ACLCONTAINS 1037 +#define F_GETDATABASEENCODING 1039 +#define F_BPCHARIN 1044 +#define F_BPCHAROUT 1045 +#define F_VARCHARIN 1046 +#define F_VARCHAROUT 1047 +#define F_BPCHAREQ 1048 +#define F_BPCHARLT 1049 +#define F_BPCHARLE 1050 +#define F_BPCHARGT 1051 +#define F_BPCHARGE 1052 +#define F_BPCHARNE 1053 +#define F_ACLITEMEQ 1062 +#define F_BPCHAR_LARGER 1063 +#define F_BPCHAR_SMALLER 1064 +#define F_PG_PREPARED_XACT 1065 +#define F_GENERATE_SERIES_INT4_INT4_INT4 1066 +#define F_GENERATE_SERIES_INT4_INT4 1067 +#define F_GENERATE_SERIES_INT8_INT8_INT8 1068 +#define F_GENERATE_SERIES_INT8_INT8 1069 +#define F_BPCHARCMP 1078 +#define F_REGCLASS 1079 +#define F_HASHBPCHAR 1080 +#define F_FORMAT_TYPE 1081 +#define F_DATE_IN 1084 +#define F_DATE_OUT 1085 +#define F_DATE_EQ 1086 +#define F_DATE_LT 1087 +#define F_DATE_LE 1088 +#define F_DATE_GT 1089 +#define F_DATE_GE 1090 +#define F_DATE_NE 1091 +#define F_DATE_CMP 1092 +#define F_TIME_LT 1102 +#define F_TIME_LE 1103 +#define F_TIME_GT 1104 +#define F_TIME_GE 1105 +#define F_TIME_NE 1106 +#define F_TIME_CMP 1107 +#define F_PG_STAT_GET_WAL 1136 +#define F_PG_GET_WAL_REPLAY_PAUSE_STATE 1137 +#define F_DATE_LARGER 1138 +#define F_DATE_SMALLER 1139 +#define F_DATE_MI 1140 +#define F_DATE_PLI 1141 +#define F_DATE_MII 1142 +#define F_TIME_IN 1143 +#define F_TIME_OUT 1144 +#define F_TIME_EQ 1145 +#define F_CIRCLE_ADD_PT 1146 +#define F_CIRCLE_SUB_PT 1147 +#define F_CIRCLE_MUL_PT 1148 +#define F_CIRCLE_DIV_PT 1149 +#define F_TIMESTAMPTZ_IN 1150 +#define F_TIMESTAMPTZ_OUT 1151 +#define F_TIMESTAMPTZ_EQ 1152 +#define F_TIMESTAMPTZ_NE 1153 +#define F_TIMESTAMPTZ_LT 1154 +#define F_TIMESTAMPTZ_LE 1155 +#define F_TIMESTAMPTZ_GE 1156 +#define F_TIMESTAMPTZ_GT 1157 +#define F_TO_TIMESTAMP_FLOAT8 1158 +#define F_TIMEZONE_TEXT_TIMESTAMPTZ 1159 +#define F_INTERVAL_IN 1160 +#define F_INTERVAL_OUT 1161 +#define F_INTERVAL_EQ 1162 +#define F_INTERVAL_NE 1163 +#define F_INTERVAL_LT 1164 +#define F_INTERVAL_LE 1165 +#define F_INTERVAL_GE 1166 +#define F_INTERVAL_GT 1167 +#define F_INTERVAL_UM 1168 +#define F_INTERVAL_PL 1169 +#define F_INTERVAL_MI 1170 +#define F_DATE_PART_TEXT_TIMESTAMPTZ 1171 +#define F_DATE_PART_TEXT_INTERVAL 1172 +#define F_NETWORK_SUBSET_SUPPORT 1173 +#define F_TIMESTAMPTZ_DATE 1174 +#define F_JUSTIFY_HOURS 1175 +#define F_TIMESTAMPTZ_DATE_TIME 1176 +#define F_JSONB_PATH_EXISTS_TZ 1177 +#define F_DATE_TIMESTAMPTZ 1178 +#define F_JSONB_PATH_QUERY_TZ 1179 +#define F_JSONB_PATH_QUERY_ARRAY_TZ 1180 +#define F_AGE_XID 1181 +#define F_TIMESTAMPTZ_MI 1188 +#define F_TIMESTAMPTZ_PL_INTERVAL 1189 +#define F_TIMESTAMPTZ_MI_INTERVAL 1190 +#define F_GENERATE_SUBSCRIPTS_ANYARRAY_INT4_BOOL 1191 +#define F_GENERATE_SUBSCRIPTS_ANYARRAY_INT4 1192 +#define F_ARRAY_FILL_ANYELEMENT__INT4 1193 +#define F_LOG10_FLOAT8 1194 +#define F_TIMESTAMPTZ_SMALLER 1195 +#define F_TIMESTAMPTZ_LARGER 1196 +#define F_INTERVAL_SMALLER 1197 +#define F_INTERVAL_LARGER 1198 +#define F_AGE_TIMESTAMPTZ_TIMESTAMPTZ 1199 +#define F_INTERVAL_INTERVAL_INT4 1200 +#define F_OBJ_DESCRIPTION_OID_NAME 1215 +#define F_COL_DESCRIPTION 1216 +#define F_DATE_TRUNC_TEXT_TIMESTAMPTZ 1217 +#define F_DATE_TRUNC_TEXT_INTERVAL 1218 +#define F_INT8INC 1219 +#define F_INT8ABS 1230 +#define F_INT8LARGER 1236 +#define F_INT8SMALLER 1237 +#define F_TEXTICREGEXEQ 1238 +#define F_TEXTICREGEXNE 1239 +#define F_NAMEICREGEXEQ 1240 +#define F_NAMEICREGEXNE 1241 +#define F_BOOLIN 1242 +#define F_BOOLOUT 1243 +#define F_BYTEAIN 1244 +#define F_CHARIN 1245 +#define F_CHARLT 1246 +#define F_UNIQUE_KEY_RECHECK 1250 +#define F_INT4ABS 1251 +#define F_NAMEREGEXNE 1252 +#define F_INT2ABS 1253 +#define F_TEXTREGEXEQ 1254 +#define F_TEXTREGEXNE 1256 +#define F_TEXTLEN 1257 +#define F_TEXTCAT 1258 +#define F_PG_CHAR_TO_ENCODING 1264 +#define F_TIDNE 1265 +#define F_CIDR_IN 1267 +#define F_PARSE_IDENT 1268 +#define F_PG_COLUMN_SIZE 1269 +#define F_OVERLAPS_TIMETZ_TIMETZ_TIMETZ_TIMETZ 1271 +#define F_DATETIME_PL 1272 +#define F_DATE_PART_TEXT_TIMETZ 1273 +#define F_INT84PL 1274 +#define F_INT84MI 1275 +#define F_INT84MUL 1276 +#define F_INT84DIV 1277 +#define F_INT48PL 1278 +#define F_INT48MI 1279 +#define F_INT48MUL 1280 +#define F_INT48DIV 1281 +#define F_QUOTE_IDENT 1282 +#define F_QUOTE_LITERAL_TEXT 1283 +#define F_DATE_TRUNC_TEXT_TIMESTAMPTZ_TEXT 1284 +#define F_QUOTE_LITERAL_ANYELEMENT 1285 +#define F_ARRAY_FILL_ANYELEMENT__INT4__INT4 1286 +#define F_OID 1287 +#define F_INT8_OID 1288 +#define F_QUOTE_NULLABLE_TEXT 1289 +#define F_QUOTE_NULLABLE_ANYELEMENT 1290 +#define F_SUPPRESS_REDUNDANT_UPDATES_TRIGGER 1291 +#define F_TIDEQ 1292 +#define F_UNNEST_ANYMULTIRANGE 1293 +#define F_CURRTID2 1294 +#define F_JUSTIFY_DAYS 1295 +#define F_TIMEDATE_PL 1296 +#define F_DATETIMETZ_PL 1297 +#define F_TIMETZDATE_PL 1298 +#define F_NOW 1299 +#define F_POSITIONSEL 1300 +#define F_POSITIONJOINSEL 1301 +#define F_CONTSEL 1302 +#define F_CONTJOINSEL 1303 +#define F_OVERLAPS_TIMESTAMPTZ_TIMESTAMPTZ_TIMESTAMPTZ_TIMESTAMPTZ 1304 +#define F_OVERLAPS_TIMESTAMPTZ_INTERVAL_TIMESTAMPTZ_INTERVAL 1305 +#define F_OVERLAPS_TIMESTAMPTZ_TIMESTAMPTZ_TIMESTAMPTZ_INTERVAL 1306 +#define F_OVERLAPS_TIMESTAMPTZ_INTERVAL_TIMESTAMPTZ_TIMESTAMPTZ 1307 +#define F_OVERLAPS_TIME_TIME_TIME_TIME 1308 +#define F_OVERLAPS_TIME_INTERVAL_TIME_INTERVAL 1309 +#define F_OVERLAPS_TIME_TIME_TIME_INTERVAL 1310 +#define F_OVERLAPS_TIME_INTERVAL_TIME_TIME 1311 +#define F_TIMESTAMP_IN 1312 +#define F_TIMESTAMP_OUT 1313 +#define F_TIMESTAMPTZ_CMP 1314 +#define F_INTERVAL_CMP 1315 +#define F_TIME_TIMESTAMP 1316 +#define F_LENGTH_TEXT 1317 +#define F_LENGTH_BPCHAR 1318 +#define F_XIDEQINT4 1319 +#define F_INTERVAL_DIV 1326 +#define F_DLOG10 1339 +#define F_LOG_FLOAT8 1340 +#define F_LN_FLOAT8 1341 +#define F_ROUND_FLOAT8 1342 +#define F_TRUNC_FLOAT8 1343 +#define F_SQRT_FLOAT8 1344 +#define F_CBRT 1345 +#define F_POW_FLOAT8_FLOAT8 1346 +#define F_EXP_FLOAT8 1347 +#define F_OBJ_DESCRIPTION_OID 1348 +#define F_OIDVECTORTYPES 1349 +#define F_TIMETZ_IN 1350 +#define F_TIMETZ_OUT 1351 +#define F_TIMETZ_EQ 1352 +#define F_TIMETZ_NE 1353 +#define F_TIMETZ_LT 1354 +#define F_TIMETZ_LE 1355 +#define F_TIMETZ_GE 1356 +#define F_TIMETZ_GT 1357 +#define F_TIMETZ_CMP 1358 +#define F_TIMESTAMPTZ_DATE_TIMETZ 1359 +#define F_HOSTMASK 1362 +#define F_TEXTREGEXEQ_SUPPORT 1364 +#define F_MAKEACLITEM 1365 +#define F_CHARACTER_LENGTH_BPCHAR 1367 +#define F_POWER_FLOAT8_FLOAT8 1368 +#define F_CHARACTER_LENGTH_TEXT 1369 +#define F_INTERVAL_TIME 1370 +#define F_PG_LOCK_STATUS 1371 +#define F_CHAR_LENGTH_BPCHAR 1372 +#define F_ISFINITE_DATE 1373 +#define F_OCTET_LENGTH_TEXT 1374 +#define F_OCTET_LENGTH_BPCHAR 1375 +#define F_FACTORIAL 1376 +#define F_TIME_LARGER 1377 +#define F_TIME_SMALLER 1378 +#define F_TIMETZ_LARGER 1379 +#define F_TIMETZ_SMALLER 1380 +#define F_CHAR_LENGTH_TEXT 1381 +#define F_DATE_PART_TEXT_DATE 1384 +#define F_DATE_PART_TEXT_TIME 1385 +#define F_AGE_TIMESTAMPTZ 1386 +#define F_PG_GET_CONSTRAINTDEF_OID 1387 +#define F_TIMETZ_TIMESTAMPTZ 1388 +#define F_ISFINITE_TIMESTAMPTZ 1389 +#define F_ISFINITE_INTERVAL 1390 +#define F_PG_STAT_GET_BACKEND_START 1391 +#define F_PG_STAT_GET_BACKEND_CLIENT_ADDR 1392 +#define F_PG_STAT_GET_BACKEND_CLIENT_PORT 1393 +#define F_ABS_FLOAT4 1394 +#define F_ABS_FLOAT8 1395 +#define F_ABS_INT8 1396 +#define F_ABS_INT4 1397 +#define F_ABS_INT2 1398 +#define F_NAME_VARCHAR 1400 +#define F_VARCHAR_NAME 1401 +#define F_CURRENT_SCHEMA 1402 +#define F_CURRENT_SCHEMAS 1403 +#define F_OVERLAY_TEXT_TEXT_INT4_INT4 1404 +#define F_OVERLAY_TEXT_TEXT_INT4 1405 +#define F_ISVERTICAL_POINT_POINT 1406 +#define F_ISHORIZONTAL_POINT_POINT 1407 +#define F_ISPARALLEL_LSEG_LSEG 1408 +#define F_ISPERP_LSEG_LSEG 1409 +#define F_ISVERTICAL_LSEG 1410 +#define F_ISHORIZONTAL_LSEG 1411 +#define F_ISPARALLEL_LINE_LINE 1412 +#define F_ISPERP_LINE_LINE 1413 +#define F_ISVERTICAL_LINE 1414 +#define F_ISHORIZONTAL_LINE 1415 +#define F_POINT_CIRCLE 1416 +#define F_TIME_INTERVAL 1419 +#define F_BOX_POINT_POINT 1421 +#define F_BOX_ADD 1422 +#define F_BOX_SUB 1423 +#define F_BOX_MUL 1424 +#define F_BOX_DIV 1425 +#define F_PATH_CONTAIN_PT 1426 +#define F_CIDR_OUT 1427 +#define F_POLY_CONTAIN_PT 1428 +#define F_PT_CONTAINED_POLY 1429 +#define F_ISCLOSED 1430 +#define F_ISOPEN 1431 +#define F_PATH_NPOINTS 1432 +#define F_PCLOSE 1433 +#define F_POPEN 1434 +#define F_PATH_ADD 1435 +#define F_PATH_ADD_PT 1436 +#define F_PATH_SUB_PT 1437 +#define F_PATH_MUL_PT 1438 +#define F_PATH_DIV_PT 1439 +#define F_POINT_FLOAT8_FLOAT8 1440 +#define F_POINT_ADD 1441 +#define F_POINT_SUB 1442 +#define F_POINT_MUL 1443 +#define F_POINT_DIV 1444 +#define F_POLY_NPOINTS 1445 +#define F_BOX_POLYGON 1446 +#define F_PATH 1447 +#define F_POLYGON_BOX 1448 +#define F_POLYGON_PATH 1449 +#define F_CIRCLE_IN 1450 +#define F_CIRCLE_OUT 1451 +#define F_CIRCLE_SAME 1452 +#define F_CIRCLE_CONTAIN 1453 +#define F_CIRCLE_LEFT 1454 +#define F_CIRCLE_OVERLEFT 1455 +#define F_CIRCLE_OVERRIGHT 1456 +#define F_CIRCLE_RIGHT 1457 +#define F_CIRCLE_CONTAINED 1458 +#define F_CIRCLE_OVERLAP 1459 +#define F_CIRCLE_BELOW 1460 +#define F_CIRCLE_ABOVE 1461 +#define F_CIRCLE_EQ 1462 +#define F_CIRCLE_NE 1463 +#define F_CIRCLE_LT 1464 +#define F_CIRCLE_GT 1465 +#define F_CIRCLE_LE 1466 +#define F_CIRCLE_GE 1467 +#define F_AREA_CIRCLE 1468 +#define F_DIAMETER 1469 +#define F_RADIUS 1470 +#define F_CIRCLE_DISTANCE 1471 +#define F_CIRCLE_CENTER 1472 +#define F_CIRCLE_POINT_FLOAT8 1473 +#define F_CIRCLE_POLYGON 1474 +#define F_POLYGON_INT4_CIRCLE 1475 +#define F_DIST_PC 1476 +#define F_CIRCLE_CONTAIN_PT 1477 +#define F_PT_CONTAINED_CIRCLE 1478 +#define F_CIRCLE_BOX 1479 +#define F_BOX_CIRCLE 1480 +#define F_LOG10_NUMERIC 1481 +#define F_LSEG_NE 1482 +#define F_LSEG_LT 1483 +#define F_LSEG_LE 1484 +#define F_LSEG_GT 1485 +#define F_LSEG_GE 1486 +#define F_LSEG_LENGTH 1487 +#define F_CLOSE_LS 1488 +#define F_CLOSE_LSEG 1489 +#define F_LINE_IN 1490 +#define F_LINE_OUT 1491 +#define F_LINE_EQ 1492 +#define F_LINE 1493 +#define F_LINE_INTERPT 1494 +#define F_LINE_INTERSECT 1495 +#define F_LINE_PARALLEL 1496 +#define F_LINE_PERP 1497 +#define F_LINE_VERTICAL 1498 +#define F_LINE_HORIZONTAL 1499 +#define F_LENGTH_LSEG 1530 +#define F_LENGTH_PATH 1531 +#define F_POINT_LSEG 1532 +#define F_POINT_BOX 1534 +#define F_POINT_POLYGON 1540 +#define F_LSEG_BOX 1541 +#define F_CENTER_BOX 1542 +#define F_CENTER_CIRCLE 1543 +#define F_POLYGON_CIRCLE 1544 +#define F_NPOINTS_PATH 1545 +#define F_NPOINTS_POLYGON 1556 +#define F_BIT_IN 1564 +#define F_BIT_OUT 1565 +#define F_LIKE_TEXT_TEXT 1569 +#define F_NOTLIKE_TEXT_TEXT 1570 +#define F_LIKE_NAME_TEXT 1571 +#define F_NOTLIKE_NAME_TEXT 1572 +#define F_PG_GET_RULEDEF_OID 1573 +#define F_NEXTVAL 1574 +#define F_CURRVAL 1575 +#define F_SETVAL_REGCLASS_INT8 1576 +#define F_VARBIT_IN 1579 +#define F_VARBIT_OUT 1580 +#define F_BITEQ 1581 +#define F_BITNE 1582 +#define F_BITGE 1592 +#define F_BITGT 1593 +#define F_BITLE 1594 +#define F_BITLT 1595 +#define F_BITCMP 1596 +#define F_PG_ENCODING_TO_CHAR 1597 +#define F_RANDOM 1598 +#define F_SETSEED 1599 +#define F_ASIN 1600 +#define F_ACOS 1601 +#define F_ATAN 1602 +#define F_ATAN2 1603 +#define F_SIN 1604 +#define F_COS 1605 +#define F_TAN 1606 +#define F_COT 1607 +#define F_DEGREES 1608 +#define F_RADIANS 1609 +#define F_PI 1610 +#define F_INTERVAL_MUL 1618 +#define F_PG_TYPEOF 1619 +#define F_ASCII 1620 +#define F_CHR 1621 +#define F_REPEAT 1622 +#define F_SIMILAR_ESCAPE 1623 +#define F_MUL_D_INTERVAL 1624 +#define F_BPCHARLIKE 1631 +#define F_BPCHARNLIKE 1632 +#define F_TEXTICLIKE 1633 +#define F_TEXTICNLIKE 1634 +#define F_NAMEICLIKE 1635 +#define F_NAMEICNLIKE 1636 +#define F_LIKE_ESCAPE_TEXT_TEXT 1637 +#define F_OIDGT 1638 +#define F_OIDGE 1639 +#define F_PG_GET_VIEWDEF_TEXT 1640 +#define F_PG_GET_VIEWDEF_OID 1641 +#define F_PG_GET_USERBYID 1642 +#define F_PG_GET_INDEXDEF_OID 1643 +#define F_RI_FKEY_CHECK_INS 1644 +#define F_RI_FKEY_CHECK_UPD 1645 +#define F_RI_FKEY_CASCADE_DEL 1646 +#define F_RI_FKEY_CASCADE_UPD 1647 +#define F_RI_FKEY_RESTRICT_DEL 1648 +#define F_RI_FKEY_RESTRICT_UPD 1649 +#define F_RI_FKEY_SETNULL_DEL 1650 +#define F_RI_FKEY_SETNULL_UPD 1651 +#define F_RI_FKEY_SETDEFAULT_DEL 1652 +#define F_RI_FKEY_SETDEFAULT_UPD 1653 +#define F_RI_FKEY_NOACTION_DEL 1654 +#define F_RI_FKEY_NOACTION_UPD 1655 +#define F_BPCHARICREGEXEQ 1656 +#define F_BPCHARICREGEXNE 1657 +#define F_BPCHARREGEXEQ 1658 +#define F_BPCHARREGEXNE 1659 +#define F_BPCHARICLIKE 1660 +#define F_BPCHARICNLIKE 1661 +#define F_PG_GET_TRIGGERDEF_OID 1662 +#define F_PG_GET_SERIAL_SEQUENCE 1665 +#define F_VARBITEQ 1666 +#define F_VARBITNE 1667 +#define F_VARBITGE 1668 +#define F_VARBITGT 1669 +#define F_VARBITLE 1670 +#define F_VARBITLT 1671 +#define F_VARBITCMP 1672 +#define F_BITAND 1673 +#define F_BITOR 1674 +#define F_BITXOR 1675 +#define F_BITNOT 1676 +#define F_BITSHIFTLEFT 1677 +#define F_BITSHIFTRIGHT 1678 +#define F_BITCAT 1679 +#define F_SUBSTRING_BIT_INT4_INT4 1680 +#define F_LENGTH_BIT 1681 +#define F_OCTET_LENGTH_BIT 1682 +#define F_BIT_INT4_INT4 1683 +#define F_INT4_BIT 1684 +#define F_BIT_BIT_INT4_BOOL 1685 +#define F_PG_GET_KEYWORDS 1686 +#define F_VARBIT 1687 +#define F_TIME_HASH 1688 +#define F_ACLEXPLODE 1689 +#define F_TIME_MI_TIME 1690 +#define F_BOOLLE 1691 +#define F_BOOLGE 1692 +#define F_BTBOOLCMP 1693 +#define F_TIMETZ_HASH 1696 +#define F_INTERVAL_HASH 1697 +#define F_POSITION_BIT_BIT 1698 +#define F_SUBSTRING_BIT_INT4 1699 +#define F_NUMERIC_IN 1701 +#define F_NUMERIC_OUT 1702 +#define F_NUMERIC_NUMERIC_INT4 1703 +#define F_NUMERIC_ABS 1704 +#define F_ABS_NUMERIC 1705 +#define F_SIGN_NUMERIC 1706 +#define F_ROUND_NUMERIC_INT4 1707 +#define F_ROUND_NUMERIC 1708 +#define F_TRUNC_NUMERIC_INT4 1709 +#define F_TRUNC_NUMERIC 1710 +#define F_CEIL_NUMERIC 1711 +#define F_FLOOR_NUMERIC 1712 +#define F_LENGTH_BYTEA_NAME 1713 +#define F_CONVERT_FROM 1714 +#define F_CIDR 1715 +#define F_PG_GET_EXPR_PG_NODE_TREE_OID 1716 +#define F_CONVERT_TO 1717 +#define F_NUMERIC_EQ 1718 +#define F_NUMERIC_NE 1719 +#define F_NUMERIC_GT 1720 +#define F_NUMERIC_GE 1721 +#define F_NUMERIC_LT 1722 +#define F_NUMERIC_LE 1723 +#define F_NUMERIC_ADD 1724 +#define F_NUMERIC_SUB 1725 +#define F_NUMERIC_MUL 1726 +#define F_NUMERIC_DIV 1727 +#define F_MOD_NUMERIC_NUMERIC 1728 +#define F_NUMERIC_MOD 1729 +#define F_SQRT_NUMERIC 1730 +#define F_NUMERIC_SQRT 1731 +#define F_EXP_NUMERIC 1732 +#define F_NUMERIC_EXP 1733 +#define F_LN_NUMERIC 1734 +#define F_NUMERIC_LN 1735 +#define F_LOG_NUMERIC_NUMERIC 1736 +#define F_NUMERIC_LOG 1737 +#define F_POW_NUMERIC_NUMERIC 1738 +#define F_NUMERIC_POWER 1739 +#define F_NUMERIC_INT4 1740 +#define F_LOG_NUMERIC 1741 +#define F_NUMERIC_FLOAT4 1742 +#define F_NUMERIC_FLOAT8 1743 +#define F_INT4_NUMERIC 1744 +#define F_FLOAT4_NUMERIC 1745 +#define F_FLOAT8_NUMERIC 1746 +#define F_TIME_PL_INTERVAL 1747 +#define F_TIME_MI_INTERVAL 1748 +#define F_TIMETZ_PL_INTERVAL 1749 +#define F_TIMETZ_MI_INTERVAL 1750 +#define F_NUMERIC_INC 1764 +#define F_SETVAL_REGCLASS_INT8_BOOL 1765 +#define F_NUMERIC_SMALLER 1766 +#define F_NUMERIC_LARGER 1767 +#define F_TO_CHAR_INTERVAL_TEXT 1768 +#define F_NUMERIC_CMP 1769 +#define F_TO_CHAR_TIMESTAMPTZ_TEXT 1770 +#define F_NUMERIC_UMINUS 1771 +#define F_TO_CHAR_NUMERIC_TEXT 1772 +#define F_TO_CHAR_INT4_TEXT 1773 +#define F_TO_CHAR_INT8_TEXT 1774 +#define F_TO_CHAR_FLOAT4_TEXT 1775 +#define F_TO_CHAR_FLOAT8_TEXT 1776 +#define F_TO_NUMBER 1777 +#define F_TO_TIMESTAMP_TEXT_TEXT 1778 +#define F_INT8_NUMERIC 1779 +#define F_TO_DATE 1780 +#define F_NUMERIC_INT8 1781 +#define F_NUMERIC_INT2 1782 +#define F_INT2_NUMERIC 1783 +#define F_OIDIN 1798 +#define F_OIDOUT 1799 +#define F_BIT_LENGTH_BYTEA 1810 +#define F_BIT_LENGTH_TEXT 1811 +#define F_BIT_LENGTH_BIT 1812 +#define F_CONVERT 1813 +#define F_ICLIKESEL 1814 +#define F_ICNLIKESEL 1815 +#define F_ICLIKEJOINSEL 1816 +#define F_ICNLIKEJOINSEL 1817 +#define F_REGEXEQSEL 1818 +#define F_LIKESEL 1819 +#define F_ICREGEXEQSEL 1820 +#define F_REGEXNESEL 1821 +#define F_NLIKESEL 1822 +#define F_ICREGEXNESEL 1823 +#define F_REGEXEQJOINSEL 1824 +#define F_LIKEJOINSEL 1825 +#define F_ICREGEXEQJOINSEL 1826 +#define F_REGEXNEJOINSEL 1827 +#define F_NLIKEJOINSEL 1828 +#define F_ICREGEXNEJOINSEL 1829 +#define F_FLOAT8_AVG 1830 +#define F_FLOAT8_VAR_SAMP 1831 +#define F_FLOAT8_STDDEV_SAMP 1832 +#define F_NUMERIC_ACCUM 1833 +#define F_INT2_ACCUM 1834 +#define F_INT4_ACCUM 1835 +#define F_INT8_ACCUM 1836 +#define F_NUMERIC_AVG 1837 +#define F_NUMERIC_VAR_SAMP 1838 +#define F_NUMERIC_STDDEV_SAMP 1839 +#define F_INT2_SUM 1840 +#define F_INT4_SUM 1841 +#define F_INT8_SUM 1842 +#define F_INTERVAL_ACCUM 1843 +#define F_INTERVAL_AVG 1844 +#define F_TO_ASCII_TEXT 1845 +#define F_TO_ASCII_TEXT_INT4 1846 +#define F_TO_ASCII_TEXT_NAME 1847 +#define F_INTERVAL_PL_TIME 1848 +#define F_INT28EQ 1850 +#define F_INT28NE 1851 +#define F_INT28LT 1852 +#define F_INT28GT 1853 +#define F_INT28LE 1854 +#define F_INT28GE 1855 +#define F_INT82EQ 1856 +#define F_INT82NE 1857 +#define F_INT82LT 1858 +#define F_INT82GT 1859 +#define F_INT82LE 1860 +#define F_INT82GE 1861 +#define F_INT2AND 1892 +#define F_INT2OR 1893 +#define F_INT2XOR 1894 +#define F_INT2NOT 1895 +#define F_INT2SHL 1896 +#define F_INT2SHR 1897 +#define F_INT4AND 1898 +#define F_INT4OR 1899 +#define F_INT4XOR 1900 +#define F_INT4NOT 1901 +#define F_INT4SHL 1902 +#define F_INT4SHR 1903 +#define F_INT8AND 1904 +#define F_INT8OR 1905 +#define F_INT8XOR 1906 +#define F_INT8NOT 1907 +#define F_INT8SHL 1908 +#define F_INT8SHR 1909 +#define F_INT8UP 1910 +#define F_INT2UP 1911 +#define F_INT4UP 1912 +#define F_FLOAT4UP 1913 +#define F_FLOAT8UP 1914 +#define F_NUMERIC_UPLUS 1915 +#define F_HAS_TABLE_PRIVILEGE_NAME_TEXT_TEXT 1922 +#define F_HAS_TABLE_PRIVILEGE_NAME_OID_TEXT 1923 +#define F_HAS_TABLE_PRIVILEGE_OID_TEXT_TEXT 1924 +#define F_HAS_TABLE_PRIVILEGE_OID_OID_TEXT 1925 +#define F_HAS_TABLE_PRIVILEGE_TEXT_TEXT 1926 +#define F_HAS_TABLE_PRIVILEGE_OID_TEXT 1927 +#define F_PG_STAT_GET_NUMSCANS 1928 +#define F_PG_STAT_GET_TUPLES_RETURNED 1929 +#define F_PG_STAT_GET_TUPLES_FETCHED 1930 +#define F_PG_STAT_GET_TUPLES_INSERTED 1931 +#define F_PG_STAT_GET_TUPLES_UPDATED 1932 +#define F_PG_STAT_GET_TUPLES_DELETED 1933 +#define F_PG_STAT_GET_BLOCKS_FETCHED 1934 +#define F_PG_STAT_GET_BLOCKS_HIT 1935 +#define F_PG_STAT_GET_BACKEND_IDSET 1936 +#define F_PG_STAT_GET_BACKEND_PID 1937 +#define F_PG_STAT_GET_BACKEND_DBID 1938 +#define F_PG_STAT_GET_BACKEND_USERID 1939 +#define F_PG_STAT_GET_BACKEND_ACTIVITY 1940 +#define F_PG_STAT_GET_DB_NUMBACKENDS 1941 +#define F_PG_STAT_GET_DB_XACT_COMMIT 1942 +#define F_PG_STAT_GET_DB_XACT_ROLLBACK 1943 +#define F_PG_STAT_GET_DB_BLOCKS_FETCHED 1944 +#define F_PG_STAT_GET_DB_BLOCKS_HIT 1945 +#define F_ENCODE 1946 +#define F_DECODE 1947 +#define F_BYTEAEQ 1948 +#define F_BYTEALT 1949 +#define F_BYTEALE 1950 +#define F_BYTEAGT 1951 +#define F_BYTEAGE 1952 +#define F_BYTEANE 1953 +#define F_BYTEACMP 1954 +#define F_TIMESTAMP_TIMESTAMP_INT4 1961 +#define F_INT2_AVG_ACCUM 1962 +#define F_INT4_AVG_ACCUM 1963 +#define F_INT8_AVG 1964 +#define F_OIDLARGER 1965 +#define F_OIDSMALLER 1966 +#define F_TIMESTAMPTZ_TIMESTAMPTZ_INT4 1967 +#define F_TIME_TIME_INT4 1968 +#define F_TIMETZ_TIMETZ_INT4 1969 +#define F_PG_STAT_GET_TUPLES_HOT_UPDATED 1972 +#define F_DIV 1973 +#define F_NUMERIC_DIV_TRUNC 1980 +#define F_SIMILAR_TO_ESCAPE_TEXT_TEXT 1986 +#define F_SIMILAR_TO_ESCAPE_TEXT 1987 +#define F_SHOBJ_DESCRIPTION 1993 +#define F_TEXTANYCAT 2003 +#define F_ANYTEXTCAT 2004 +#define F_BYTEALIKE 2005 +#define F_BYTEANLIKE 2006 +#define F_LIKE_BYTEA_BYTEA 2007 +#define F_NOTLIKE_BYTEA_BYTEA 2008 +#define F_LIKE_ESCAPE_BYTEA_BYTEA 2009 +#define F_LENGTH_BYTEA 2010 +#define F_BYTEACAT 2011 +#define F_SUBSTRING_BYTEA_INT4_INT4 2012 +#define F_SUBSTRING_BYTEA_INT4 2013 +#define F_POSITION_BYTEA_BYTEA 2014 +#define F_BTRIM_BYTEA_BYTEA 2015 +#define F_TIME_TIMESTAMPTZ 2019 +#define F_DATE_TRUNC_TEXT_TIMESTAMP 2020 +#define F_DATE_PART_TEXT_TIMESTAMP 2021 +#define F_PG_STAT_GET_ACTIVITY 2022 +#define F_JSONB_PATH_QUERY_FIRST_TZ 2023 +#define F_TIMESTAMP_DATE 2024 +#define F_TIMESTAMP_DATE_TIME 2025 +#define F_PG_BACKEND_PID 2026 +#define F_TIMESTAMP_TIMESTAMPTZ 2027 +#define F_TIMESTAMPTZ_TIMESTAMP 2028 +#define F_DATE_TIMESTAMP 2029 +#define F_JSONB_PATH_MATCH_TZ 2030 +#define F_TIMESTAMP_MI 2031 +#define F_TIMESTAMP_PL_INTERVAL 2032 +#define F_TIMESTAMP_MI_INTERVAL 2033 +#define F_PG_CONF_LOAD_TIME 2034 +#define F_TIMESTAMP_SMALLER 2035 +#define F_TIMESTAMP_LARGER 2036 +#define F_TIMEZONE_TEXT_TIMETZ 2037 +#define F_TIMEZONE_INTERVAL_TIMETZ 2038 +#define F_TIMESTAMP_HASH 2039 +#define F_OVERLAPS_TIMESTAMP_TIMESTAMP_TIMESTAMP_TIMESTAMP 2041 +#define F_OVERLAPS_TIMESTAMP_INTERVAL_TIMESTAMP_INTERVAL 2042 +#define F_OVERLAPS_TIMESTAMP_TIMESTAMP_TIMESTAMP_INTERVAL 2043 +#define F_OVERLAPS_TIMESTAMP_INTERVAL_TIMESTAMP_TIMESTAMP 2044 +#define F_TIMESTAMP_CMP 2045 +#define F_TIME_TIMETZ 2046 +#define F_TIMETZ_TIME 2047 +#define F_ISFINITE_TIMESTAMP 2048 +#define F_TO_CHAR_TIMESTAMP_TEXT 2049 +#define F_MAX_ANYARRAY 2050 +#define F_MIN_ANYARRAY 2051 +#define F_TIMESTAMP_EQ 2052 +#define F_TIMESTAMP_NE 2053 +#define F_TIMESTAMP_LT 2054 +#define F_TIMESTAMP_LE 2055 +#define F_TIMESTAMP_GE 2056 +#define F_TIMESTAMP_GT 2057 +#define F_AGE_TIMESTAMP_TIMESTAMP 2058 +#define F_AGE_TIMESTAMP 2059 +#define F_TIMEZONE_TEXT_TIMESTAMP 2069 +#define F_TIMEZONE_INTERVAL_TIMESTAMP 2070 +#define F_DATE_PL_INTERVAL 2071 +#define F_DATE_MI_INTERVAL 2072 +#define F_SUBSTRING_TEXT_TEXT 2073 +#define F_SUBSTRING_TEXT_TEXT_TEXT 2074 +#define F_BIT_INT8_INT4 2075 +#define F_INT8_BIT 2076 +#define F_CURRENT_SETTING_TEXT 2077 +#define F_SET_CONFIG 2078 +#define F_PG_TABLE_IS_VISIBLE 2079 +#define F_PG_TYPE_IS_VISIBLE 2080 +#define F_PG_FUNCTION_IS_VISIBLE 2081 +#define F_PG_OPERATOR_IS_VISIBLE 2082 +#define F_PG_OPCLASS_IS_VISIBLE 2083 +#define F_PG_SHOW_ALL_SETTINGS 2084 +#define F_SUBSTR_BYTEA_INT4_INT4 2085 +#define F_SUBSTR_BYTEA_INT4 2086 +#define F_REPLACE 2087 +#define F_SPLIT_PART 2088 +#define F_TO_HEX_INT4 2089 +#define F_TO_HEX_INT8 2090 +#define F_ARRAY_LOWER 2091 +#define F_ARRAY_UPPER 2092 +#define F_PG_CONVERSION_IS_VISIBLE 2093 +#define F_PG_STAT_GET_BACKEND_ACTIVITY_START 2094 +#define F_PG_TERMINATE_BACKEND 2096 +#define F_PG_GET_FUNCTIONDEF 2098 +#define F_AVG_INT8 2100 +#define F_AVG_INT4 2101 +#define F_AVG_INT2 2102 +#define F_AVG_NUMERIC 2103 +#define F_AVG_FLOAT4 2104 +#define F_AVG_FLOAT8 2105 +#define F_AVG_INTERVAL 2106 +#define F_SUM_INT8 2107 +#define F_SUM_INT4 2108 +#define F_SUM_INT2 2109 +#define F_SUM_FLOAT4 2110 +#define F_SUM_FLOAT8 2111 +#define F_SUM_MONEY 2112 +#define F_SUM_INTERVAL 2113 +#define F_SUM_NUMERIC 2114 +#define F_MAX_INT8 2115 +#define F_MAX_INT4 2116 +#define F_MAX_INT2 2117 +#define F_MAX_OID 2118 +#define F_MAX_FLOAT4 2119 +#define F_MAX_FLOAT8 2120 +#define F_PG_COLUMN_COMPRESSION 2121 +#define F_MAX_DATE 2122 +#define F_MAX_TIME 2123 +#define F_MAX_TIMETZ 2124 +#define F_MAX_MONEY 2125 +#define F_MAX_TIMESTAMP 2126 +#define F_MAX_TIMESTAMPTZ 2127 +#define F_MAX_INTERVAL 2128 +#define F_MAX_TEXT 2129 +#define F_MAX_NUMERIC 2130 +#define F_MIN_INT8 2131 +#define F_MIN_INT4 2132 +#define F_MIN_INT2 2133 +#define F_MIN_OID 2134 +#define F_MIN_FLOAT4 2135 +#define F_MIN_FLOAT8 2136 +#define F_PG_STAT_FORCE_NEXT_FLUSH 2137 +#define F_MIN_DATE 2138 +#define F_MIN_TIME 2139 +#define F_MIN_TIMETZ 2140 +#define F_MIN_MONEY 2141 +#define F_MIN_TIMESTAMP 2142 +#define F_MIN_TIMESTAMPTZ 2143 +#define F_MIN_INTERVAL 2144 +#define F_MIN_TEXT 2145 +#define F_MIN_NUMERIC 2146 +#define F_COUNT_ANY 2147 +#define F_VARIANCE_INT8 2148 +#define F_VARIANCE_INT4 2149 +#define F_VARIANCE_INT2 2150 +#define F_VARIANCE_FLOAT4 2151 +#define F_VARIANCE_FLOAT8 2152 +#define F_VARIANCE_NUMERIC 2153 +#define F_STDDEV_INT8 2154 +#define F_STDDEV_INT4 2155 +#define F_STDDEV_INT2 2156 +#define F_STDDEV_FLOAT4 2157 +#define F_STDDEV_FLOAT8 2158 +#define F_STDDEV_NUMERIC 2159 +#define F_TEXT_PATTERN_LT 2160 +#define F_TEXT_PATTERN_LE 2161 +#define F_PG_GET_FUNCTION_ARGUMENTS 2162 +#define F_TEXT_PATTERN_GE 2163 +#define F_TEXT_PATTERN_GT 2164 +#define F_PG_GET_FUNCTION_RESULT 2165 +#define F_BTTEXT_PATTERN_CMP 2166 +#define F_CEILING_NUMERIC 2167 +#define F_PG_DATABASE_SIZE_NAME 2168 +#define F_POWER_NUMERIC_NUMERIC 2169 +#define F_WIDTH_BUCKET_NUMERIC_NUMERIC_NUMERIC_INT4 2170 +#define F_PG_CANCEL_BACKEND 2171 +#define F_PG_BACKUP_START 2172 +#define F_BPCHAR_PATTERN_LT 2174 +#define F_BPCHAR_PATTERN_LE 2175 +#define F_ARRAY_LENGTH 2176 +#define F_BPCHAR_PATTERN_GE 2177 +#define F_BPCHAR_PATTERN_GT 2178 +#define F_GIST_POINT_CONSISTENT 2179 +#define F_BTBPCHAR_PATTERN_CMP 2180 +#define F_HAS_SEQUENCE_PRIVILEGE_NAME_TEXT_TEXT 2181 +#define F_HAS_SEQUENCE_PRIVILEGE_NAME_OID_TEXT 2182 +#define F_HAS_SEQUENCE_PRIVILEGE_OID_TEXT_TEXT 2183 +#define F_HAS_SEQUENCE_PRIVILEGE_OID_OID_TEXT 2184 +#define F_HAS_SEQUENCE_PRIVILEGE_TEXT_TEXT 2185 +#define F_HAS_SEQUENCE_PRIVILEGE_OID_TEXT 2186 +#define F_BTINT48CMP 2188 +#define F_BTINT84CMP 2189 +#define F_BTINT24CMP 2190 +#define F_BTINT42CMP 2191 +#define F_BTINT28CMP 2192 +#define F_BTINT82CMP 2193 +#define F_BTFLOAT48CMP 2194 +#define F_BTFLOAT84CMP 2195 +#define F_INET_CLIENT_ADDR 2196 +#define F_INET_CLIENT_PORT 2197 +#define F_INET_SERVER_ADDR 2198 +#define F_INET_SERVER_PORT 2199 +#define F_REGPROCEDUREIN 2212 +#define F_REGPROCEDUREOUT 2213 +#define F_REGOPERIN 2214 +#define F_REGOPEROUT 2215 +#define F_REGOPERATORIN 2216 +#define F_REGOPERATOROUT 2217 +#define F_REGCLASSIN 2218 +#define F_REGCLASSOUT 2219 +#define F_REGTYPEIN 2220 +#define F_REGTYPEOUT 2221 +#define F_PG_STAT_CLEAR_SNAPSHOT 2230 +#define F_PG_GET_FUNCTION_IDENTITY_ARGUMENTS 2232 +#define F_HASHTID 2233 +#define F_HASHTIDEXTENDED 2234 +#define F_BIT_AND_INT2 2236 +#define F_BIT_OR_INT2 2237 +#define F_BIT_AND_INT4 2238 +#define F_BIT_OR_INT4 2239 +#define F_BIT_AND_INT8 2240 +#define F_BIT_OR_INT8 2241 +#define F_BIT_AND_BIT 2242 +#define F_BIT_OR_BIT 2243 +#define F_MAX_BPCHAR 2244 +#define F_MIN_BPCHAR 2245 +#define F_FMGR_INTERNAL_VALIDATOR 2246 +#define F_FMGR_C_VALIDATOR 2247 +#define F_FMGR_SQL_VALIDATOR 2248 +#define F_HAS_DATABASE_PRIVILEGE_NAME_TEXT_TEXT 2250 +#define F_HAS_DATABASE_PRIVILEGE_NAME_OID_TEXT 2251 +#define F_HAS_DATABASE_PRIVILEGE_OID_TEXT_TEXT 2252 +#define F_HAS_DATABASE_PRIVILEGE_OID_OID_TEXT 2253 +#define F_HAS_DATABASE_PRIVILEGE_TEXT_TEXT 2254 +#define F_HAS_DATABASE_PRIVILEGE_OID_TEXT 2255 +#define F_HAS_FUNCTION_PRIVILEGE_NAME_TEXT_TEXT 2256 +#define F_HAS_FUNCTION_PRIVILEGE_NAME_OID_TEXT 2257 +#define F_HAS_FUNCTION_PRIVILEGE_OID_TEXT_TEXT 2258 +#define F_HAS_FUNCTION_PRIVILEGE_OID_OID_TEXT 2259 +#define F_HAS_FUNCTION_PRIVILEGE_TEXT_TEXT 2260 +#define F_HAS_FUNCTION_PRIVILEGE_OID_TEXT 2261 +#define F_HAS_LANGUAGE_PRIVILEGE_NAME_TEXT_TEXT 2262 +#define F_HAS_LANGUAGE_PRIVILEGE_NAME_OID_TEXT 2263 +#define F_HAS_LANGUAGE_PRIVILEGE_OID_TEXT_TEXT 2264 +#define F_HAS_LANGUAGE_PRIVILEGE_OID_OID_TEXT 2265 +#define F_HAS_LANGUAGE_PRIVILEGE_TEXT_TEXT 2266 +#define F_HAS_LANGUAGE_PRIVILEGE_OID_TEXT 2267 +#define F_HAS_SCHEMA_PRIVILEGE_NAME_TEXT_TEXT 2268 +#define F_HAS_SCHEMA_PRIVILEGE_NAME_OID_TEXT 2269 +#define F_HAS_SCHEMA_PRIVILEGE_OID_TEXT_TEXT 2270 +#define F_HAS_SCHEMA_PRIVILEGE_OID_OID_TEXT 2271 +#define F_HAS_SCHEMA_PRIVILEGE_TEXT_TEXT 2272 +#define F_HAS_SCHEMA_PRIVILEGE_OID_TEXT 2273 +#define F_PG_STAT_RESET 2274 +#define F_PG_GET_BACKEND_MEMORY_CONTEXTS 2282 +#define F_REGEXP_REPLACE_TEXT_TEXT_TEXT 2284 +#define F_REGEXP_REPLACE_TEXT_TEXT_TEXT_TEXT 2285 +#define F_PG_TOTAL_RELATION_SIZE 2286 +#define F_PG_SIZE_PRETTY_INT8 2288 +#define F_PG_OPTIONS_TO_TABLE 2289 +#define F_RECORD_IN 2290 +#define F_RECORD_OUT 2291 +#define F_CSTRING_IN 2292 +#define F_CSTRING_OUT 2293 +#define F_ANY_IN 2294 +#define F_ANY_OUT 2295 +#define F_ANYARRAY_IN 2296 +#define F_ANYARRAY_OUT 2297 +#define F_VOID_IN 2298 +#define F_VOID_OUT 2299 +#define F_TRIGGER_IN 2300 +#define F_TRIGGER_OUT 2301 +#define F_LANGUAGE_HANDLER_IN 2302 +#define F_LANGUAGE_HANDLER_OUT 2303 +#define F_INTERNAL_IN 2304 +#define F_INTERNAL_OUT 2305 +#define F_PG_STAT_GET_SLRU 2306 +#define F_PG_STAT_RESET_SLRU 2307 +#define F_CEIL_FLOAT8 2308 +#define F_FLOOR_FLOAT8 2309 +#define F_SIGN_FLOAT8 2310 +#define F_MD5_TEXT 2311 +#define F_ANYELEMENT_IN 2312 +#define F_ANYELEMENT_OUT 2313 +#define F_POSTGRESQL_FDW_VALIDATOR 2316 +#define F_PG_ENCODING_MAX_LENGTH 2319 +#define F_CEILING_FLOAT8 2320 +#define F_MD5_BYTEA 2321 +#define F_PG_TABLESPACE_SIZE_OID 2322 +#define F_PG_TABLESPACE_SIZE_NAME 2323 +#define F_PG_DATABASE_SIZE_OID 2324 +#define F_PG_RELATION_SIZE_REGCLASS 2325 +#define F_UNNEST_ANYARRAY 2331 +#define F_PG_RELATION_SIZE_REGCLASS_TEXT 2332 +#define F_ARRAY_AGG_TRANSFN 2333 +#define F_ARRAY_AGG_FINALFN 2334 +#define F_ARRAY_AGG_ANYNONARRAY 2335 +#define F_DATE_LT_TIMESTAMP 2338 +#define F_DATE_LE_TIMESTAMP 2339 +#define F_DATE_EQ_TIMESTAMP 2340 +#define F_DATE_GT_TIMESTAMP 2341 +#define F_DATE_GE_TIMESTAMP 2342 +#define F_DATE_NE_TIMESTAMP 2343 +#define F_DATE_CMP_TIMESTAMP 2344 +#define F_DATE_LT_TIMESTAMPTZ 2351 +#define F_DATE_LE_TIMESTAMPTZ 2352 +#define F_DATE_EQ_TIMESTAMPTZ 2353 +#define F_DATE_GT_TIMESTAMPTZ 2354 +#define F_DATE_GE_TIMESTAMPTZ 2355 +#define F_DATE_NE_TIMESTAMPTZ 2356 +#define F_DATE_CMP_TIMESTAMPTZ 2357 +#define F_TIMESTAMP_LT_DATE 2364 +#define F_TIMESTAMP_LE_DATE 2365 +#define F_TIMESTAMP_EQ_DATE 2366 +#define F_TIMESTAMP_GT_DATE 2367 +#define F_TIMESTAMP_GE_DATE 2368 +#define F_TIMESTAMP_NE_DATE 2369 +#define F_TIMESTAMP_CMP_DATE 2370 +#define F_TIMESTAMPTZ_LT_DATE 2377 +#define F_TIMESTAMPTZ_LE_DATE 2378 +#define F_TIMESTAMPTZ_EQ_DATE 2379 +#define F_TIMESTAMPTZ_GT_DATE 2380 +#define F_TIMESTAMPTZ_GE_DATE 2381 +#define F_TIMESTAMPTZ_NE_DATE 2382 +#define F_TIMESTAMPTZ_CMP_DATE 2383 +#define F_HAS_TABLESPACE_PRIVILEGE_NAME_TEXT_TEXT 2390 +#define F_HAS_TABLESPACE_PRIVILEGE_NAME_OID_TEXT 2391 +#define F_HAS_TABLESPACE_PRIVILEGE_OID_TEXT_TEXT 2392 +#define F_HAS_TABLESPACE_PRIVILEGE_OID_OID_TEXT 2393 +#define F_HAS_TABLESPACE_PRIVILEGE_TEXT_TEXT 2394 +#define F_HAS_TABLESPACE_PRIVILEGE_OID_TEXT 2395 +#define F_SHELL_IN 2398 +#define F_SHELL_OUT 2399 +#define F_ARRAY_RECV 2400 +#define F_ARRAY_SEND 2401 +#define F_RECORD_RECV 2402 +#define F_RECORD_SEND 2403 +#define F_INT2RECV 2404 +#define F_INT2SEND 2405 +#define F_INT4RECV 2406 +#define F_INT4SEND 2407 +#define F_INT8RECV 2408 +#define F_INT8SEND 2409 +#define F_INT2VECTORRECV 2410 +#define F_INT2VECTORSEND 2411 +#define F_BYTEARECV 2412 +#define F_BYTEASEND 2413 +#define F_TEXTRECV 2414 +#define F_TEXTSEND 2415 +#define F_UNKNOWNRECV 2416 +#define F_UNKNOWNSEND 2417 +#define F_OIDRECV 2418 +#define F_OIDSEND 2419 +#define F_OIDVECTORRECV 2420 +#define F_OIDVECTORSEND 2421 +#define F_NAMERECV 2422 +#define F_NAMESEND 2423 +#define F_FLOAT4RECV 2424 +#define F_FLOAT4SEND 2425 +#define F_FLOAT8RECV 2426 +#define F_FLOAT8SEND 2427 +#define F_POINT_RECV 2428 +#define F_POINT_SEND 2429 +#define F_BPCHARRECV 2430 +#define F_BPCHARSEND 2431 +#define F_VARCHARRECV 2432 +#define F_VARCHARSEND 2433 +#define F_CHARRECV 2434 +#define F_CHARSEND 2435 +#define F_BOOLRECV 2436 +#define F_BOOLSEND 2437 +#define F_TIDRECV 2438 +#define F_TIDSEND 2439 +#define F_XIDRECV 2440 +#define F_XIDSEND 2441 +#define F_CIDRECV 2442 +#define F_CIDSEND 2443 +#define F_REGPROCRECV 2444 +#define F_REGPROCSEND 2445 +#define F_REGPROCEDURERECV 2446 +#define F_REGPROCEDURESEND 2447 +#define F_REGOPERRECV 2448 +#define F_REGOPERSEND 2449 +#define F_REGOPERATORRECV 2450 +#define F_REGOPERATORSEND 2451 +#define F_REGCLASSRECV 2452 +#define F_REGCLASSSEND 2453 +#define F_REGTYPERECV 2454 +#define F_REGTYPESEND 2455 +#define F_BIT_RECV 2456 +#define F_BIT_SEND 2457 +#define F_VARBIT_RECV 2458 +#define F_VARBIT_SEND 2459 +#define F_NUMERIC_RECV 2460 +#define F_NUMERIC_SEND 2461 +#define F_SINH 2462 +#define F_COSH 2463 +#define F_TANH 2464 +#define F_ASINH 2465 +#define F_ACOSH 2466 +#define F_ATANH 2467 +#define F_DATE_RECV 2468 +#define F_DATE_SEND 2469 +#define F_TIME_RECV 2470 +#define F_TIME_SEND 2471 +#define F_TIMETZ_RECV 2472 +#define F_TIMETZ_SEND 2473 +#define F_TIMESTAMP_RECV 2474 +#define F_TIMESTAMP_SEND 2475 +#define F_TIMESTAMPTZ_RECV 2476 +#define F_TIMESTAMPTZ_SEND 2477 +#define F_INTERVAL_RECV 2478 +#define F_INTERVAL_SEND 2479 +#define F_LSEG_RECV 2480 +#define F_LSEG_SEND 2481 +#define F_PATH_RECV 2482 +#define F_PATH_SEND 2483 +#define F_BOX_RECV 2484 +#define F_BOX_SEND 2485 +#define F_POLY_RECV 2486 +#define F_POLY_SEND 2487 +#define F_LINE_RECV 2488 +#define F_LINE_SEND 2489 +#define F_CIRCLE_RECV 2490 +#define F_CIRCLE_SEND 2491 +#define F_CASH_RECV 2492 +#define F_CASH_SEND 2493 +#define F_MACADDR_RECV 2494 +#define F_MACADDR_SEND 2495 +#define F_INET_RECV 2496 +#define F_INET_SEND 2497 +#define F_CIDR_RECV 2498 +#define F_CIDR_SEND 2499 +#define F_CSTRING_RECV 2500 +#define F_CSTRING_SEND 2501 +#define F_ANYARRAY_RECV 2502 +#define F_ANYARRAY_SEND 2503 +#define F_PG_GET_RULEDEF_OID_BOOL 2504 +#define F_PG_GET_VIEWDEF_TEXT_BOOL 2505 +#define F_PG_GET_VIEWDEF_OID_BOOL 2506 +#define F_PG_GET_INDEXDEF_OID_INT4_BOOL 2507 +#define F_PG_GET_CONSTRAINTDEF_OID_BOOL 2508 +#define F_PG_GET_EXPR_PG_NODE_TREE_OID_BOOL 2509 +#define F_PG_PREPARED_STATEMENT 2510 +#define F_PG_CURSOR 2511 +#define F_FLOAT8_VAR_POP 2512 +#define F_FLOAT8_STDDEV_POP 2513 +#define F_NUMERIC_VAR_POP 2514 +#define F_BOOLAND_STATEFUNC 2515 +#define F_BOOLOR_STATEFUNC 2516 +#define F_BOOL_AND 2517 +#define F_BOOL_OR 2518 +#define F_EVERY 2519 +#define F_TIMESTAMP_LT_TIMESTAMPTZ 2520 +#define F_TIMESTAMP_LE_TIMESTAMPTZ 2521 +#define F_TIMESTAMP_EQ_TIMESTAMPTZ 2522 +#define F_TIMESTAMP_GT_TIMESTAMPTZ 2523 +#define F_TIMESTAMP_GE_TIMESTAMPTZ 2524 +#define F_TIMESTAMP_NE_TIMESTAMPTZ 2525 +#define F_TIMESTAMP_CMP_TIMESTAMPTZ 2526 +#define F_TIMESTAMPTZ_LT_TIMESTAMP 2527 +#define F_TIMESTAMPTZ_LE_TIMESTAMP 2528 +#define F_TIMESTAMPTZ_EQ_TIMESTAMP 2529 +#define F_TIMESTAMPTZ_GT_TIMESTAMP 2530 +#define F_TIMESTAMPTZ_GE_TIMESTAMP 2531 +#define F_TIMESTAMPTZ_NE_TIMESTAMP 2532 +#define F_TIMESTAMPTZ_CMP_TIMESTAMP 2533 +#define F_INTERVAL_PL_DATE 2546 +#define F_INTERVAL_PL_TIMETZ 2547 +#define F_INTERVAL_PL_TIMESTAMP 2548 +#define F_INTERVAL_PL_TIMESTAMPTZ 2549 +#define F_INTEGER_PL_DATE 2550 +#define F_PG_TABLESPACE_DATABASES 2556 +#define F_BOOL_INT4 2557 +#define F_INT4_BOOL 2558 +#define F_LASTVAL 2559 +#define F_PG_POSTMASTER_START_TIME 2560 +#define F_PG_BLOCKING_PIDS 2561 +#define F_BOX_BELOW 2562 +#define F_BOX_OVERBELOW 2563 +#define F_BOX_OVERABOVE 2564 +#define F_BOX_ABOVE 2565 +#define F_POLY_BELOW 2566 +#define F_POLY_OVERBELOW 2567 +#define F_POLY_OVERABOVE 2568 +#define F_POLY_ABOVE 2569 +#define F_GIST_BOX_CONSISTENT 2578 +#define F_FLOAT8_JSONB 2580 +#define F_GIST_BOX_PENALTY 2581 +#define F_GIST_BOX_PICKSPLIT 2582 +#define F_GIST_BOX_UNION 2583 +#define F_GIST_BOX_SAME 2584 +#define F_GIST_POLY_CONSISTENT 2585 +#define F_GIST_POLY_COMPRESS 2586 +#define F_CIRCLE_OVERBELOW 2587 +#define F_CIRCLE_OVERABOVE 2588 +#define F_GIST_CIRCLE_CONSISTENT 2591 +#define F_GIST_CIRCLE_COMPRESS 2592 +#define F_NUMERIC_STDDEV_POP 2596 +#define F_DOMAIN_IN 2597 +#define F_DOMAIN_RECV 2598 +#define F_PG_TIMEZONE_ABBREVS 2599 +#define F_XMLEXISTS 2614 +#define F_PG_RELOAD_CONF 2621 +#define F_PG_ROTATE_LOGFILE 2622 +#define F_PG_STAT_FILE_TEXT 2623 +#define F_PG_READ_FILE_TEXT_INT8_INT8 2624 +#define F_PG_LS_DIR_TEXT 2625 +#define F_PG_SLEEP 2626 +#define F_INETNOT 2627 +#define F_INETAND 2628 +#define F_INETOR 2629 +#define F_INETPL 2630 +#define F_INT8PL_INET 2631 +#define F_INETMI_INT8 2632 +#define F_INETMI 2633 +#define F_VAR_SAMP_INT8 2641 +#define F_VAR_SAMP_INT4 2642 +#define F_VAR_SAMP_INT2 2643 +#define F_VAR_SAMP_FLOAT4 2644 +#define F_VAR_SAMP_FLOAT8 2645 +#define F_VAR_SAMP_NUMERIC 2646 +#define F_TRANSACTION_TIMESTAMP 2647 +#define F_STATEMENT_TIMESTAMP 2648 +#define F_CLOCK_TIMESTAMP 2649 +#define F_GIN_CMP_PREFIX 2700 +#define F_PG_HAS_ROLE_NAME_NAME_TEXT 2705 +#define F_PG_HAS_ROLE_NAME_OID_TEXT 2706 +#define F_PG_HAS_ROLE_OID_NAME_TEXT 2707 +#define F_PG_HAS_ROLE_OID_OID_TEXT 2708 +#define F_PG_HAS_ROLE_NAME_TEXT 2709 +#define F_PG_HAS_ROLE_OID_TEXT 2710 +#define F_JUSTIFY_INTERVAL 2711 +#define F_STDDEV_SAMP_INT8 2712 +#define F_STDDEV_SAMP_INT4 2713 +#define F_STDDEV_SAMP_INT2 2714 +#define F_STDDEV_SAMP_FLOAT4 2715 +#define F_STDDEV_SAMP_FLOAT8 2716 +#define F_STDDEV_SAMP_NUMERIC 2717 +#define F_VAR_POP_INT8 2718 +#define F_VAR_POP_INT4 2719 +#define F_VAR_POP_INT2 2720 +#define F_VAR_POP_FLOAT4 2721 +#define F_VAR_POP_FLOAT8 2722 +#define F_VAR_POP_NUMERIC 2723 +#define F_STDDEV_POP_INT8 2724 +#define F_STDDEV_POP_INT4 2725 +#define F_STDDEV_POP_INT2 2726 +#define F_STDDEV_POP_FLOAT4 2727 +#define F_STDDEV_POP_FLOAT8 2728 +#define F_STDDEV_POP_NUMERIC 2729 +#define F_PG_GET_TRIGGERDEF_OID_BOOL 2730 +#define F_ASIND 2731 +#define F_ACOSD 2732 +#define F_ATAND 2733 +#define F_ATAN2D 2734 +#define F_SIND 2735 +#define F_COSD 2736 +#define F_TAND 2737 +#define F_COTD 2738 +#define F_PG_BACKUP_STOP 2739 +#define F_NUMERIC_AVG_SERIALIZE 2740 +#define F_NUMERIC_AVG_DESERIALIZE 2741 +#define F_GINARRAYEXTRACT_ANYARRAY_INTERNAL_INTERNAL 2743 +#define F_GINARRAYCONSISTENT 2744 +#define F_INT8_AVG_ACCUM 2746 +#define F_ARRAYOVERLAP 2747 +#define F_ARRAYCONTAINS 2748 +#define F_ARRAYCONTAINED 2749 +#define F_PG_STAT_GET_DB_TUPLES_RETURNED 2758 +#define F_PG_STAT_GET_DB_TUPLES_FETCHED 2759 +#define F_PG_STAT_GET_DB_TUPLES_INSERTED 2760 +#define F_PG_STAT_GET_DB_TUPLES_UPDATED 2761 +#define F_PG_STAT_GET_DB_TUPLES_DELETED 2762 +#define F_REGEXP_MATCHES_TEXT_TEXT 2763 +#define F_REGEXP_MATCHES_TEXT_TEXT_TEXT 2764 +#define F_REGEXP_SPLIT_TO_TABLE_TEXT_TEXT 2765 +#define F_REGEXP_SPLIT_TO_TABLE_TEXT_TEXT_TEXT 2766 +#define F_REGEXP_SPLIT_TO_ARRAY_TEXT_TEXT 2767 +#define F_REGEXP_SPLIT_TO_ARRAY_TEXT_TEXT_TEXT 2768 +#define F_PG_STAT_GET_BGWRITER_TIMED_CHECKPOINTS 2769 +#define F_PG_STAT_GET_BGWRITER_REQUESTED_CHECKPOINTS 2770 +#define F_PG_STAT_GET_BGWRITER_BUF_WRITTEN_CHECKPOINTS 2771 +#define F_PG_STAT_GET_BGWRITER_BUF_WRITTEN_CLEAN 2772 +#define F_PG_STAT_GET_BGWRITER_MAXWRITTEN_CLEAN 2773 +#define F_GINQUERYARRAYEXTRACT 2774 +#define F_PG_STAT_GET_BUF_WRITTEN_BACKEND 2775 +#define F_ANYNONARRAY_IN 2777 +#define F_ANYNONARRAY_OUT 2778 +#define F_PG_STAT_GET_LAST_VACUUM_TIME 2781 +#define F_PG_STAT_GET_LAST_AUTOVACUUM_TIME 2782 +#define F_PG_STAT_GET_LAST_ANALYZE_TIME 2783 +#define F_PG_STAT_GET_LAST_AUTOANALYZE_TIME 2784 +#define F_INT8_AVG_COMBINE 2785 +#define F_INT8_AVG_SERIALIZE 2786 +#define F_INT8_AVG_DESERIALIZE 2787 +#define F_PG_STAT_GET_BACKEND_WAIT_EVENT_TYPE 2788 +#define F_TIDGT 2790 +#define F_TIDLT 2791 +#define F_TIDGE 2792 +#define F_TIDLE 2793 +#define F_BTTIDCMP 2794 +#define F_TIDLARGER 2795 +#define F_TIDSMALLER 2796 +#define F_MAX_TID 2797 +#define F_MIN_TID 2798 +#define F_COUNT_ 2803 +#define F_INT8INC_ANY 2804 +#define F_INT8INC_FLOAT8_FLOAT8 2805 +#define F_FLOAT8_REGR_ACCUM 2806 +#define F_FLOAT8_REGR_SXX 2807 +#define F_FLOAT8_REGR_SYY 2808 +#define F_FLOAT8_REGR_SXY 2809 +#define F_FLOAT8_REGR_AVGX 2810 +#define F_FLOAT8_REGR_AVGY 2811 +#define F_FLOAT8_REGR_R2 2812 +#define F_FLOAT8_REGR_SLOPE 2813 +#define F_FLOAT8_REGR_INTERCEPT 2814 +#define F_FLOAT8_COVAR_POP 2815 +#define F_FLOAT8_COVAR_SAMP 2816 +#define F_FLOAT8_CORR 2817 +#define F_REGR_COUNT 2818 +#define F_REGR_SXX 2819 +#define F_REGR_SYY 2820 +#define F_REGR_SXY 2821 +#define F_REGR_AVGX 2822 +#define F_REGR_AVGY 2823 +#define F_REGR_R2 2824 +#define F_REGR_SLOPE 2825 +#define F_REGR_INTERCEPT 2826 +#define F_COVAR_POP 2827 +#define F_COVAR_SAMP 2828 +#define F_CORR 2829 +#define F_PG_STAT_GET_DB_BLK_READ_TIME 2844 +#define F_PG_STAT_GET_DB_BLK_WRITE_TIME 2845 +#define F_PG_SWITCH_WAL 2848 +#define F_PG_CURRENT_WAL_LSN 2849 +#define F_PG_WALFILE_NAME_OFFSET 2850 +#define F_PG_WALFILE_NAME 2851 +#define F_PG_CURRENT_WAL_INSERT_LSN 2852 +#define F_PG_STAT_GET_BACKEND_WAIT_EVENT 2853 +#define F_PG_MY_TEMP_SCHEMA 2854 +#define F_PG_IS_OTHER_TEMP_SCHEMA 2855 +#define F_PG_TIMEZONE_NAMES 2856 +#define F_PG_STAT_GET_BACKEND_XACT_START 2857 +#define F_NUMERIC_AVG_ACCUM 2858 +#define F_PG_STAT_GET_BUF_ALLOC 2859 +#define F_PG_STAT_GET_LIVE_TUPLES 2878 +#define F_PG_STAT_GET_DEAD_TUPLES 2879 +#define F_PG_ADVISORY_LOCK_INT8 2880 +#define F_PG_ADVISORY_LOCK_SHARED_INT8 2881 +#define F_PG_TRY_ADVISORY_LOCK_INT8 2882 +#define F_PG_TRY_ADVISORY_LOCK_SHARED_INT8 2883 +#define F_PG_ADVISORY_UNLOCK_INT8 2884 +#define F_PG_ADVISORY_UNLOCK_SHARED_INT8 2885 +#define F_PG_ADVISORY_LOCK_INT4_INT4 2886 +#define F_PG_ADVISORY_LOCK_SHARED_INT4_INT4 2887 +#define F_PG_TRY_ADVISORY_LOCK_INT4_INT4 2888 +#define F_PG_TRY_ADVISORY_LOCK_SHARED_INT4_INT4 2889 +#define F_PG_ADVISORY_UNLOCK_INT4_INT4 2890 +#define F_PG_ADVISORY_UNLOCK_SHARED_INT4_INT4 2891 +#define F_PG_ADVISORY_UNLOCK_ALL 2892 +#define F_XML_IN 2893 +#define F_XML_OUT 2894 +#define F_XMLCOMMENT 2895 +#define F_XML 2896 +#define F_XMLVALIDATE 2897 +#define F_XML_RECV 2898 +#define F_XML_SEND 2899 +#define F_XMLCONCAT2 2900 +#define F_XMLAGG 2901 +#define F_VARBITTYPMODIN 2902 +#define F_INTERVALTYPMODIN 2903 +#define F_INTERVALTYPMODOUT 2904 +#define F_TIMESTAMPTYPMODIN 2905 +#define F_TIMESTAMPTYPMODOUT 2906 +#define F_TIMESTAMPTZTYPMODIN 2907 +#define F_TIMESTAMPTZTYPMODOUT 2908 +#define F_TIMETYPMODIN 2909 +#define F_TIMETYPMODOUT 2910 +#define F_TIMETZTYPMODIN 2911 +#define F_TIMETZTYPMODOUT 2912 +#define F_BPCHARTYPMODIN 2913 +#define F_BPCHARTYPMODOUT 2914 +#define F_VARCHARTYPMODIN 2915 +#define F_VARCHARTYPMODOUT 2916 +#define F_NUMERICTYPMODIN 2917 +#define F_NUMERICTYPMODOUT 2918 +#define F_BITTYPMODIN 2919 +#define F_BITTYPMODOUT 2920 +#define F_VARBITTYPMODOUT 2921 +#define F_TEXT_XML 2922 +#define F_TABLE_TO_XML 2923 +#define F_QUERY_TO_XML 2924 +#define F_CURSOR_TO_XML 2925 +#define F_TABLE_TO_XMLSCHEMA 2926 +#define F_QUERY_TO_XMLSCHEMA 2927 +#define F_CURSOR_TO_XMLSCHEMA 2928 +#define F_TABLE_TO_XML_AND_XMLSCHEMA 2929 +#define F_QUERY_TO_XML_AND_XMLSCHEMA 2930 +#define F_XPATH_TEXT_XML__TEXT 2931 +#define F_XPATH_TEXT_XML 2932 +#define F_SCHEMA_TO_XML 2933 +#define F_SCHEMA_TO_XMLSCHEMA 2934 +#define F_SCHEMA_TO_XML_AND_XMLSCHEMA 2935 +#define F_DATABASE_TO_XML 2936 +#define F_DATABASE_TO_XMLSCHEMA 2937 +#define F_DATABASE_TO_XML_AND_XMLSCHEMA 2938 +#define F_TXID_SNAPSHOT_IN 2939 +#define F_TXID_SNAPSHOT_OUT 2940 +#define F_TXID_SNAPSHOT_RECV 2941 +#define F_TXID_SNAPSHOT_SEND 2942 +#define F_TXID_CURRENT 2943 +#define F_TXID_CURRENT_SNAPSHOT 2944 +#define F_TXID_SNAPSHOT_XMIN 2945 +#define F_TXID_SNAPSHOT_XMAX 2946 +#define F_TXID_SNAPSHOT_XIP 2947 +#define F_TXID_VISIBLE_IN_SNAPSHOT 2948 +#define F_UUID_IN 2952 +#define F_UUID_OUT 2953 +#define F_UUID_LT 2954 +#define F_UUID_LE 2955 +#define F_UUID_EQ 2956 +#define F_UUID_GE 2957 +#define F_UUID_GT 2958 +#define F_UUID_NE 2959 +#define F_UUID_CMP 2960 +#define F_UUID_RECV 2961 +#define F_UUID_SEND 2962 +#define F_UUID_HASH 2963 +#define F_TEXT_BOOL 2971 +#define F_PG_STAT_GET_FUNCTION_CALLS 2978 +#define F_PG_STAT_GET_FUNCTION_TOTAL_TIME 2979 +#define F_PG_STAT_GET_FUNCTION_SELF_TIME 2980 +#define F_RECORD_EQ 2981 +#define F_RECORD_NE 2982 +#define F_RECORD_LT 2983 +#define F_RECORD_GT 2984 +#define F_RECORD_LE 2985 +#define F_RECORD_GE 2986 +#define F_BTRECORDCMP 2987 +#define F_PG_TABLE_SIZE 2997 +#define F_PG_INDEXES_SIZE 2998 +#define F_PG_RELATION_FILENODE 2999 +#define F_HAS_FOREIGN_DATA_WRAPPER_PRIVILEGE_NAME_TEXT_TEXT 3000 +#define F_HAS_FOREIGN_DATA_WRAPPER_PRIVILEGE_NAME_OID_TEXT 3001 +#define F_HAS_FOREIGN_DATA_WRAPPER_PRIVILEGE_OID_TEXT_TEXT 3002 +#define F_HAS_FOREIGN_DATA_WRAPPER_PRIVILEGE_OID_OID_TEXT 3003 +#define F_HAS_FOREIGN_DATA_WRAPPER_PRIVILEGE_TEXT_TEXT 3004 +#define F_HAS_FOREIGN_DATA_WRAPPER_PRIVILEGE_OID_TEXT 3005 +#define F_HAS_SERVER_PRIVILEGE_NAME_TEXT_TEXT 3006 +#define F_HAS_SERVER_PRIVILEGE_NAME_OID_TEXT 3007 +#define F_HAS_SERVER_PRIVILEGE_OID_TEXT_TEXT 3008 +#define F_HAS_SERVER_PRIVILEGE_OID_OID_TEXT 3009 +#define F_HAS_SERVER_PRIVILEGE_TEXT_TEXT 3010 +#define F_HAS_SERVER_PRIVILEGE_OID_TEXT 3011 +#define F_HAS_COLUMN_PRIVILEGE_NAME_TEXT_TEXT_TEXT 3012 +#define F_HAS_COLUMN_PRIVILEGE_NAME_TEXT_INT2_TEXT 3013 +#define F_HAS_COLUMN_PRIVILEGE_NAME_OID_TEXT_TEXT 3014 +#define F_HAS_COLUMN_PRIVILEGE_NAME_OID_INT2_TEXT 3015 +#define F_HAS_COLUMN_PRIVILEGE_OID_TEXT_TEXT_TEXT 3016 +#define F_HAS_COLUMN_PRIVILEGE_OID_TEXT_INT2_TEXT 3017 +#define F_HAS_COLUMN_PRIVILEGE_OID_OID_TEXT_TEXT 3018 +#define F_HAS_COLUMN_PRIVILEGE_OID_OID_INT2_TEXT 3019 +#define F_HAS_COLUMN_PRIVILEGE_TEXT_TEXT_TEXT 3020 +#define F_HAS_COLUMN_PRIVILEGE_TEXT_INT2_TEXT 3021 +#define F_HAS_COLUMN_PRIVILEGE_OID_TEXT_TEXT 3022 +#define F_HAS_COLUMN_PRIVILEGE_OID_INT2_TEXT 3023 +#define F_HAS_ANY_COLUMN_PRIVILEGE_NAME_TEXT_TEXT 3024 +#define F_HAS_ANY_COLUMN_PRIVILEGE_NAME_OID_TEXT 3025 +#define F_HAS_ANY_COLUMN_PRIVILEGE_OID_TEXT_TEXT 3026 +#define F_HAS_ANY_COLUMN_PRIVILEGE_OID_OID_TEXT 3027 +#define F_HAS_ANY_COLUMN_PRIVILEGE_TEXT_TEXT 3028 +#define F_HAS_ANY_COLUMN_PRIVILEGE_OID_TEXT 3029 +#define F_OVERLAY_BIT_BIT_INT4_INT4 3030 +#define F_OVERLAY_BIT_BIT_INT4 3031 +#define F_GET_BIT_BIT_INT4 3032 +#define F_SET_BIT_BIT_INT4_INT4 3033 +#define F_PG_RELATION_FILEPATH 3034 +#define F_PG_LISTENING_CHANNELS 3035 +#define F_PG_NOTIFY 3036 +#define F_PG_STAT_GET_XACT_NUMSCANS 3037 +#define F_PG_STAT_GET_XACT_TUPLES_RETURNED 3038 +#define F_PG_STAT_GET_XACT_TUPLES_FETCHED 3039 +#define F_PG_STAT_GET_XACT_TUPLES_INSERTED 3040 +#define F_PG_STAT_GET_XACT_TUPLES_UPDATED 3041 +#define F_PG_STAT_GET_XACT_TUPLES_DELETED 3042 +#define F_PG_STAT_GET_XACT_TUPLES_HOT_UPDATED 3043 +#define F_PG_STAT_GET_XACT_BLOCKS_FETCHED 3044 +#define F_PG_STAT_GET_XACT_BLOCKS_HIT 3045 +#define F_PG_STAT_GET_XACT_FUNCTION_CALLS 3046 +#define F_PG_STAT_GET_XACT_FUNCTION_TOTAL_TIME 3047 +#define F_PG_STAT_GET_XACT_FUNCTION_SELF_TIME 3048 +#define F_XPATH_EXISTS_TEXT_XML__TEXT 3049 +#define F_XPATH_EXISTS_TEXT_XML 3050 +#define F_XML_IS_WELL_FORMED 3051 +#define F_XML_IS_WELL_FORMED_DOCUMENT 3052 +#define F_XML_IS_WELL_FORMED_CONTENT 3053 +#define F_PG_STAT_GET_VACUUM_COUNT 3054 +#define F_PG_STAT_GET_AUTOVACUUM_COUNT 3055 +#define F_PG_STAT_GET_ANALYZE_COUNT 3056 +#define F_PG_STAT_GET_AUTOANALYZE_COUNT 3057 +#define F_CONCAT 3058 +#define F_CONCAT_WS 3059 +#define F_LEFT 3060 +#define F_RIGHT 3061 +#define F_REVERSE 3062 +#define F_PG_STAT_GET_BUF_FSYNC_BACKEND 3063 +#define F_GIST_POINT_DISTANCE 3064 +#define F_PG_STAT_GET_DB_CONFLICT_TABLESPACE 3065 +#define F_PG_STAT_GET_DB_CONFLICT_LOCK 3066 +#define F_PG_STAT_GET_DB_CONFLICT_SNAPSHOT 3067 +#define F_PG_STAT_GET_DB_CONFLICT_BUFFERPIN 3068 +#define F_PG_STAT_GET_DB_CONFLICT_STARTUP_DEADLOCK 3069 +#define F_PG_STAT_GET_DB_CONFLICT_ALL 3070 +#define F_PG_WAL_REPLAY_PAUSE 3071 +#define F_PG_WAL_REPLAY_RESUME 3072 +#define F_PG_IS_WAL_REPLAY_PAUSED 3073 +#define F_PG_STAT_GET_DB_STAT_RESET_TIME 3074 +#define F_PG_STAT_GET_BGWRITER_STAT_RESET_TIME 3075 +#define F_GINARRAYEXTRACT_ANYARRAY_INTERNAL 3076 +#define F_GIN_EXTRACT_TSVECTOR_TSVECTOR_INTERNAL 3077 +#define F_PG_SEQUENCE_PARAMETERS 3078 +#define F_PG_AVAILABLE_EXTENSIONS 3082 +#define F_PG_AVAILABLE_EXTENSION_VERSIONS 3083 +#define F_PG_EXTENSION_UPDATE_PATHS 3084 +#define F_PG_EXTENSION_CONFIG_DUMP 3086 +#define F_GIN_EXTRACT_TSQUERY_TSQUERY_INTERNAL_INT2_INTERNAL_INTERNAL 3087 +#define F_GIN_TSQUERY_CONSISTENT_INTERNAL_INT2_TSQUERY_INT4_INTERNAL_INTERNAL 3088 +#define F_PG_ADVISORY_XACT_LOCK_INT8 3089 +#define F_PG_ADVISORY_XACT_LOCK_SHARED_INT8 3090 +#define F_PG_TRY_ADVISORY_XACT_LOCK_INT8 3091 +#define F_PG_TRY_ADVISORY_XACT_LOCK_SHARED_INT8 3092 +#define F_PG_ADVISORY_XACT_LOCK_INT4_INT4 3093 +#define F_PG_ADVISORY_XACT_LOCK_SHARED_INT4_INT4 3094 +#define F_PG_TRY_ADVISORY_XACT_LOCK_INT4_INT4 3095 +#define F_PG_TRY_ADVISORY_XACT_LOCK_SHARED_INT4_INT4 3096 +#define F_VARCHAR_SUPPORT 3097 +#define F_PG_CREATE_RESTORE_POINT 3098 +#define F_PG_STAT_GET_WAL_SENDERS 3099 +#define F_ROW_NUMBER 3100 +#define F_RANK_ 3101 +#define F_DENSE_RANK_ 3102 +#define F_PERCENT_RANK_ 3103 +#define F_CUME_DIST_ 3104 +#define F_NTILE 3105 +#define F_LAG_ANYELEMENT 3106 +#define F_LAG_ANYELEMENT_INT4 3107 +#define F_LAG_ANYCOMPATIBLE_INT4_ANYCOMPATIBLE 3108 +#define F_LEAD_ANYELEMENT 3109 +#define F_LEAD_ANYELEMENT_INT4 3110 +#define F_LEAD_ANYCOMPATIBLE_INT4_ANYCOMPATIBLE 3111 +#define F_FIRST_VALUE 3112 +#define F_LAST_VALUE 3113 +#define F_NTH_VALUE 3114 +#define F_FDW_HANDLER_IN 3116 +#define F_FDW_HANDLER_OUT 3117 +#define F_VOID_RECV 3120 +#define F_VOID_SEND 3121 +#define F_BTINT2SORTSUPPORT 3129 +#define F_BTINT4SORTSUPPORT 3130 +#define F_BTINT8SORTSUPPORT 3131 +#define F_BTFLOAT4SORTSUPPORT 3132 +#define F_BTFLOAT8SORTSUPPORT 3133 +#define F_BTOIDSORTSUPPORT 3134 +#define F_BTNAMESORTSUPPORT 3135 +#define F_DATE_SORTSUPPORT 3136 +#define F_TIMESTAMP_SORTSUPPORT 3137 +#define F_HAS_TYPE_PRIVILEGE_NAME_TEXT_TEXT 3138 +#define F_HAS_TYPE_PRIVILEGE_NAME_OID_TEXT 3139 +#define F_HAS_TYPE_PRIVILEGE_OID_TEXT_TEXT 3140 +#define F_HAS_TYPE_PRIVILEGE_OID_OID_TEXT 3141 +#define F_HAS_TYPE_PRIVILEGE_TEXT_TEXT 3142 +#define F_HAS_TYPE_PRIVILEGE_OID_TEXT 3143 +#define F_MACADDR_NOT 3144 +#define F_MACADDR_AND 3145 +#define F_MACADDR_OR 3146 +#define F_PG_STAT_GET_DB_TEMP_FILES 3150 +#define F_PG_STAT_GET_DB_TEMP_BYTES 3151 +#define F_PG_STAT_GET_DB_DEADLOCKS 3152 +#define F_ARRAY_TO_JSON_ANYARRAY 3153 +#define F_ARRAY_TO_JSON_ANYARRAY_BOOL 3154 +#define F_ROW_TO_JSON_RECORD 3155 +#define F_ROW_TO_JSON_RECORD_BOOL 3156 +#define F_NUMERIC_SUPPORT 3157 +#define F_VARBIT_SUPPORT 3158 +#define F_PG_GET_VIEWDEF_OID_INT4 3159 +#define F_PG_STAT_GET_CHECKPOINT_WRITE_TIME 3160 +#define F_PG_STAT_GET_CHECKPOINT_SYNC_TIME 3161 +#define F_PG_COLLATION_FOR 3162 +#define F_PG_TRIGGER_DEPTH 3163 +#define F_PG_WAL_LSN_DIFF 3165 +#define F_PG_SIZE_PRETTY_NUMERIC 3166 +#define F_ARRAY_REMOVE 3167 +#define F_ARRAY_REPLACE 3168 +#define F_RANGESEL 3169 +#define F_LO_LSEEK64 3170 +#define F_LO_TELL64 3171 +#define F_LO_TRUNCATE64 3172 +#define F_JSON_AGG_TRANSFN 3173 +#define F_JSON_AGG_FINALFN 3174 +#define F_JSON_AGG 3175 +#define F_TO_JSON 3176 +#define F_PG_STAT_GET_MOD_SINCE_ANALYZE 3177 +#define F_NUMERIC_SUM 3178 +#define F_CARDINALITY 3179 +#define F_JSON_OBJECT_AGG_TRANSFN 3180 +#define F_RECORD_IMAGE_EQ 3181 +#define F_RECORD_IMAGE_NE 3182 +#define F_RECORD_IMAGE_LT 3183 +#define F_RECORD_IMAGE_GT 3184 +#define F_RECORD_IMAGE_LE 3185 +#define F_RECORD_IMAGE_GE 3186 +#define F_BTRECORDIMAGECMP 3187 +#define F_PG_STAT_GET_ARCHIVER 3195 +#define F_JSON_OBJECT_AGG_FINALFN 3196 +#define F_JSON_OBJECT_AGG 3197 +#define F_JSON_BUILD_ARRAY_ANY 3198 +#define F_JSON_BUILD_ARRAY_ 3199 +#define F_JSON_BUILD_OBJECT_ANY 3200 +#define F_JSON_BUILD_OBJECT_ 3201 +#define F_JSON_OBJECT__TEXT 3202 +#define F_JSON_OBJECT__TEXT__TEXT 3203 +#define F_JSON_TO_RECORD 3204 +#define F_JSON_TO_RECORDSET 3205 +#define F_JSONB_ARRAY_LENGTH 3207 +#define F_JSONB_EACH 3208 +#define F_JSONB_POPULATE_RECORD 3209 +#define F_JSONB_TYPEOF 3210 +#define F_JSONB_OBJECT_FIELD_TEXT 3214 +#define F_JSONB_ARRAY_ELEMENT 3215 +#define F_JSONB_ARRAY_ELEMENT_TEXT 3216 +#define F_JSONB_EXTRACT_PATH 3217 +#define F_WIDTH_BUCKET_ANYCOMPATIBLE_ANYCOMPATIBLEARRAY 3218 +#define F_JSONB_ARRAY_ELEMENTS 3219 +#define F_PG_LSN_IN 3229 +#define F_PG_LSN_OUT 3230 +#define F_PG_LSN_LT 3231 +#define F_PG_LSN_LE 3232 +#define F_PG_LSN_EQ 3233 +#define F_PG_LSN_GE 3234 +#define F_PG_LSN_GT 3235 +#define F_PG_LSN_NE 3236 +#define F_PG_LSN_MI 3237 +#define F_PG_LSN_RECV 3238 +#define F_PG_LSN_SEND 3239 +#define F_PG_LSN_CMP 3251 +#define F_PG_LSN_HASH 3252 +#define F_BTTEXTSORTSUPPORT 3255 +#define F_GENERATE_SERIES_NUMERIC_NUMERIC_NUMERIC 3259 +#define F_GENERATE_SERIES_NUMERIC_NUMERIC 3260 +#define F_JSON_STRIP_NULLS 3261 +#define F_JSONB_STRIP_NULLS 3262 +#define F_JSONB_OBJECT__TEXT 3263 +#define F_JSONB_OBJECT__TEXT__TEXT 3264 +#define F_JSONB_AGG_TRANSFN 3265 +#define F_JSONB_AGG_FINALFN 3266 +#define F_JSONB_AGG 3267 +#define F_JSONB_OBJECT_AGG_TRANSFN 3268 +#define F_JSONB_OBJECT_AGG_FINALFN 3269 +#define F_JSONB_OBJECT_AGG 3270 +#define F_JSONB_BUILD_ARRAY_ANY 3271 +#define F_JSONB_BUILD_ARRAY_ 3272 +#define F_JSONB_BUILD_OBJECT_ANY 3273 +#define F_JSONB_BUILD_OBJECT_ 3274 +#define F_DIST_PPOLY 3275 +#define F_ARRAY_POSITION_ANYCOMPATIBLEARRAY_ANYCOMPATIBLE 3277 +#define F_ARRAY_POSITION_ANYCOMPATIBLEARRAY_ANYCOMPATIBLE_INT4 3278 +#define F_ARRAY_POSITIONS 3279 +#define F_GIST_CIRCLE_DISTANCE 3280 +#define F_SCALE 3281 +#define F_GIST_POINT_FETCH 3282 +#define F_NUMERIC_SORTSUPPORT 3283 +#define F_GIST_POLY_DISTANCE 3288 +#define F_DIST_CPOINT 3290 +#define F_DIST_POLYP 3292 +#define F_PG_READ_FILE_TEXT_INT8_INT8_BOOL 3293 +#define F_CURRENT_SETTING_TEXT_BOOL 3294 +#define F_PG_READ_BINARY_FILE_TEXT_INT8_INT8_BOOL 3295 +#define F_PG_NOTIFICATION_QUEUE_USAGE 3296 +#define F_PG_LS_DIR_TEXT_BOOL_BOOL 3297 +#define F_ROW_SECURITY_ACTIVE_OID 3298 +#define F_ROW_SECURITY_ACTIVE_TEXT 3299 +#define F_UUID_SORTSUPPORT 3300 +#define F_JSONB_CONCAT 3301 +#define F_JSONB_DELETE_JSONB_TEXT 3302 +#define F_JSONB_DELETE_JSONB_INT4 3303 +#define F_JSONB_DELETE_PATH 3304 +#define F_JSONB_SET 3305 +#define F_JSONB_PRETTY 3306 +#define F_PG_STAT_FILE_TEXT_BOOL 3307 +#define F_XIDNEQ 3308 +#define F_XIDNEQINT4 3309 +#define F_TSM_HANDLER_IN 3311 +#define F_TSM_HANDLER_OUT 3312 +#define F_BERNOULLI 3313 +#define F_SYSTEM 3314 +#define F_PG_STAT_GET_WAL_RECEIVER 3317 +#define F_PG_STAT_GET_PROGRESS_INFO 3318 +#define F_TS_FILTER 3319 +#define F_SETWEIGHT_TSVECTOR_CHAR__TEXT 3320 +#define F_TS_DELETE_TSVECTOR_TEXT 3321 +#define F_UNNEST_TSVECTOR 3322 +#define F_TS_DELETE_TSVECTOR__TEXT 3323 +#define F_INT4_AVG_COMBINE 3324 +#define F_INTERVAL_COMBINE 3325 +#define F_TSVECTOR_TO_ARRAY 3326 +#define F_ARRAY_TO_TSVECTOR 3327 +#define F_BPCHAR_SORTSUPPORT 3328 +#define F_PG_SHOW_ALL_FILE_SETTINGS 3329 +#define F_PG_CURRENT_WAL_FLUSH_LSN 3330 +#define F_BYTEA_SORTSUPPORT 3331 +#define F_BTTEXT_PATTERN_SORTSUPPORT 3332 +#define F_BTBPCHAR_PATTERN_SORTSUPPORT 3333 +#define F_PG_SIZE_BYTES 3334 +#define F_NUMERIC_SERIALIZE 3335 +#define F_NUMERIC_DESERIALIZE 3336 +#define F_NUMERIC_AVG_COMBINE 3337 +#define F_NUMERIC_POLY_COMBINE 3338 +#define F_NUMERIC_POLY_SERIALIZE 3339 +#define F_NUMERIC_POLY_DESERIALIZE 3340 +#define F_NUMERIC_COMBINE 3341 +#define F_FLOAT8_REGR_COMBINE 3342 +#define F_JSONB_DELETE_JSONB__TEXT 3343 +#define F_CASH_MUL_INT8 3344 +#define F_CASH_DIV_INT8 3345 +#define F_TXID_CURRENT_IF_ASSIGNED 3348 +#define F_PG_GET_PARTKEYDEF 3352 +#define F_PG_LS_LOGDIR 3353 +#define F_PG_LS_WALDIR 3354 +#define F_PG_NDISTINCT_IN 3355 +#define F_PG_NDISTINCT_OUT 3356 +#define F_PG_NDISTINCT_RECV 3357 +#define F_PG_NDISTINCT_SEND 3358 +#define F_MACADDR_SORTSUPPORT 3359 +#define F_TXID_STATUS 3360 +#define F_PG_SAFE_SNAPSHOT_BLOCKING_PIDS 3376 +#define F_PG_ISOLATION_TEST_SESSION_IS_BLOCKED 3378 +#define F_PG_IDENTIFY_OBJECT_AS_ADDRESS 3382 +#define F_BRIN_MINMAX_OPCINFO 3383 +#define F_BRIN_MINMAX_ADD_VALUE 3384 +#define F_BRIN_MINMAX_CONSISTENT 3385 +#define F_BRIN_MINMAX_UNION 3386 +#define F_INT8_AVG_ACCUM_INV 3387 +#define F_NUMERIC_POLY_SUM 3388 +#define F_NUMERIC_POLY_AVG 3389 +#define F_NUMERIC_POLY_VAR_POP 3390 +#define F_NUMERIC_POLY_VAR_SAMP 3391 +#define F_NUMERIC_POLY_STDDEV_POP 3392 +#define F_NUMERIC_POLY_STDDEV_SAMP 3393 +#define F_REGEXP_MATCH_TEXT_TEXT 3396 +#define F_REGEXP_MATCH_TEXT_TEXT_TEXT 3397 +#define F_INT8_MUL_CASH 3399 +#define F_PG_CONFIG 3400 +#define F_PG_HBA_FILE_RULES 3401 +#define F_PG_STATISTICS_OBJ_IS_VISIBLE 3403 +#define F_PG_DEPENDENCIES_IN 3404 +#define F_PG_DEPENDENCIES_OUT 3405 +#define F_PG_DEPENDENCIES_RECV 3406 +#define F_PG_DEPENDENCIES_SEND 3407 +#define F_PG_GET_PARTITION_CONSTRAINTDEF 3408 +#define F_TIME_HASH_EXTENDED 3409 +#define F_TIMETZ_HASH_EXTENDED 3410 +#define F_TIMESTAMP_HASH_EXTENDED 3411 +#define F_UUID_HASH_EXTENDED 3412 +#define F_PG_LSN_HASH_EXTENDED 3413 +#define F_HASHENUMEXTENDED 3414 +#define F_PG_GET_STATISTICSOBJDEF 3415 +#define F_JSONB_HASH_EXTENDED 3416 +#define F_HASH_RANGE_EXTENDED 3417 +#define F_INTERVAL_HASH_EXTENDED 3418 +#define F_SHA224 3419 +#define F_SHA256 3420 +#define F_SHA384 3421 +#define F_SHA512 3422 +#define F_PG_PARTITION_TREE 3423 +#define F_PG_PARTITION_ROOT 3424 +#define F_PG_PARTITION_ANCESTORS 3425 +#define F_PG_STAT_GET_DB_CHECKSUM_FAILURES 3426 +#define F_PG_MCV_LIST_ITEMS 3427 +#define F_PG_STAT_GET_DB_CHECKSUM_LAST_FAILURE 3428 +#define F_GEN_RANDOM_UUID 3432 +#define F_GTSVECTOR_OPTIONS 3434 +#define F_GIST_POINT_SORTSUPPORT 3435 +#define F_PG_PROMOTE 3436 +#define F_PREFIXSEL 3437 +#define F_PREFIXJOINSEL 3438 +#define F_PG_CONTROL_SYSTEM 3441 +#define F_PG_CONTROL_CHECKPOINT 3442 +#define F_PG_CONTROL_RECOVERY 3443 +#define F_PG_CONTROL_INIT 3444 +#define F_PG_IMPORT_SYSTEM_COLLATIONS 3445 +#define F_MACADDR8_RECV 3446 +#define F_MACADDR8_SEND 3447 +#define F_PG_COLLATION_ACTUAL_VERSION 3448 +#define F_NUMERIC_JSONB 3449 +#define F_INT2_JSONB 3450 +#define F_INT4_JSONB 3451 +#define F_INT8_JSONB 3452 +#define F_FLOAT4_JSONB 3453 +#define F_PG_FILENODE_RELATION 3454 +#define F_LO_FROM_BYTEA 3457 +#define F_LO_GET_OID 3458 +#define F_LO_GET_OID_INT8_INT4 3459 +#define F_LO_PUT 3460 +#define F_MAKE_TIMESTAMP 3461 +#define F_MAKE_TIMESTAMPTZ_INT4_INT4_INT4_INT4_INT4_FLOAT8 3462 +#define F_MAKE_TIMESTAMPTZ_INT4_INT4_INT4_INT4_INT4_FLOAT8_TEXT 3463 +#define F_MAKE_INTERVAL 3464 +#define F_JSONB_ARRAY_ELEMENTS_TEXT 3465 +#define F_SPG_RANGE_QUAD_CONFIG 3469 +#define F_SPG_RANGE_QUAD_CHOOSE 3470 +#define F_SPG_RANGE_QUAD_PICKSPLIT 3471 +#define F_SPG_RANGE_QUAD_INNER_CONSISTENT 3472 +#define F_SPG_RANGE_QUAD_LEAF_CONSISTENT 3473 +#define F_JSONB_POPULATE_RECORDSET 3475 +#define F_TO_REGOPERATOR 3476 +#define F_JSONB_OBJECT_FIELD 3478 +#define F_TO_REGPROCEDURE 3479 +#define F_GIN_COMPARE_JSONB 3480 +#define F_GIN_EXTRACT_JSONB 3482 +#define F_GIN_EXTRACT_JSONB_QUERY 3483 +#define F_GIN_CONSISTENT_JSONB 3484 +#define F_GIN_EXTRACT_JSONB_PATH 3485 +#define F_GIN_EXTRACT_JSONB_QUERY_PATH 3486 +#define F_GIN_CONSISTENT_JSONB_PATH 3487 +#define F_GIN_TRICONSISTENT_JSONB 3488 +#define F_GIN_TRICONSISTENT_JSONB_PATH 3489 +#define F_JSONB_TO_RECORD 3490 +#define F_JSONB_TO_RECORDSET 3491 +#define F_TO_REGOPER 3492 +#define F_TO_REGTYPE 3493 +#define F_TO_REGPROC 3494 +#define F_TO_REGCLASS 3495 +#define F_BOOL_ACCUM 3496 +#define F_BOOL_ACCUM_INV 3497 +#define F_BOOL_ALLTRUE 3498 +#define F_BOOL_ANYTRUE 3499 +#define F_ANYENUM_IN 3504 +#define F_ANYENUM_OUT 3505 +#define F_ENUM_IN 3506 +#define F_ENUM_OUT 3507 +#define F_ENUM_EQ 3508 +#define F_ENUM_NE 3509 +#define F_ENUM_LT 3510 +#define F_ENUM_GT 3511 +#define F_ENUM_LE 3512 +#define F_ENUM_GE 3513 +#define F_ENUM_CMP 3514 +#define F_HASHENUM 3515 +#define F_ENUM_SMALLER 3524 +#define F_ENUM_LARGER 3525 +#define F_MAX_ANYENUM 3526 +#define F_MIN_ANYENUM 3527 +#define F_ENUM_FIRST 3528 +#define F_ENUM_LAST 3529 +#define F_ENUM_RANGE_ANYENUM_ANYENUM 3530 +#define F_ENUM_RANGE_ANYENUM 3531 +#define F_ENUM_RECV 3532 +#define F_ENUM_SEND 3533 +#define F_STRING_AGG_TRANSFN 3535 +#define F_STRING_AGG_FINALFN 3536 +#define F_PG_DESCRIBE_OBJECT 3537 +#define F_STRING_AGG_TEXT_TEXT 3538 +#define F_FORMAT_TEXT_ANY 3539 +#define F_FORMAT_TEXT 3540 +#define F_BYTEA_STRING_AGG_TRANSFN 3543 +#define F_BYTEA_STRING_AGG_FINALFN 3544 +#define F_STRING_AGG_BYTEA_BYTEA 3545 +#define F_INT8DEC 3546 +#define F_INT8DEC_ANY 3547 +#define F_NUMERIC_ACCUM_INV 3548 +#define F_INTERVAL_ACCUM_INV 3549 +#define F_NETWORK_OVERLAP 3551 +#define F_INET_GIST_CONSISTENT 3553 +#define F_INET_GIST_UNION 3554 +#define F_INET_GIST_COMPRESS 3555 +#define F_BOOL_JSONB 3556 +#define F_INET_GIST_PENALTY 3557 +#define F_INET_GIST_PICKSPLIT 3558 +#define F_INET_GIST_SAME 3559 +#define F_NETWORKSEL 3560 +#define F_NETWORKJOINSEL 3561 +#define F_NETWORK_LARGER 3562 +#define F_NETWORK_SMALLER 3563 +#define F_MAX_INET 3564 +#define F_MIN_INET 3565 +#define F_PG_EVENT_TRIGGER_DROPPED_OBJECTS 3566 +#define F_INT2_ACCUM_INV 3567 +#define F_INT4_ACCUM_INV 3568 +#define F_INT8_ACCUM_INV 3569 +#define F_INT2_AVG_ACCUM_INV 3570 +#define F_INT4_AVG_ACCUM_INV 3571 +#define F_INT2INT4_SUM 3572 +#define F_INET_GIST_FETCH 3573 +#define F_PG_LOGICAL_EMIT_MESSAGE_BOOL_TEXT_TEXT 3577 +#define F_PG_LOGICAL_EMIT_MESSAGE_BOOL_TEXT_BYTEA 3578 +#define F_JSONB_INSERT 3579 +#define F_PG_XACT_COMMIT_TIMESTAMP 3581 +#define F_BINARY_UPGRADE_SET_NEXT_PG_TYPE_OID 3582 +#define F_PG_LAST_COMMITTED_XACT 3583 +#define F_BINARY_UPGRADE_SET_NEXT_ARRAY_PG_TYPE_OID 3584 +#define F_BINARY_UPGRADE_SET_NEXT_HEAP_PG_CLASS_OID 3586 +#define F_BINARY_UPGRADE_SET_NEXT_INDEX_PG_CLASS_OID 3587 +#define F_BINARY_UPGRADE_SET_NEXT_TOAST_PG_CLASS_OID 3588 +#define F_BINARY_UPGRADE_SET_NEXT_PG_ENUM_OID 3589 +#define F_BINARY_UPGRADE_SET_NEXT_PG_AUTHID_OID 3590 +#define F_BINARY_UPGRADE_CREATE_EMPTY_EXTENSION 3591 +#define F_EVENT_TRIGGER_IN 3594 +#define F_EVENT_TRIGGER_OUT 3595 +#define F_TSVECTORIN 3610 +#define F_TSVECTOROUT 3611 +#define F_TSQUERYIN 3612 +#define F_TSQUERYOUT 3613 +#define F_TSVECTOR_LT 3616 +#define F_TSVECTOR_LE 3617 +#define F_TSVECTOR_EQ 3618 +#define F_TSVECTOR_NE 3619 +#define F_TSVECTOR_GE 3620 +#define F_TSVECTOR_GT 3621 +#define F_TSVECTOR_CMP 3622 +#define F_STRIP 3623 +#define F_SETWEIGHT_TSVECTOR_CHAR 3624 +#define F_TSVECTOR_CONCAT 3625 +#define F_TS_MATCH_VQ 3634 +#define F_TS_MATCH_QV 3635 +#define F_TSVECTORSEND 3638 +#define F_TSVECTORRECV 3639 +#define F_TSQUERYSEND 3640 +#define F_TSQUERYRECV 3641 +#define F_GTSVECTORIN 3646 +#define F_GTSVECTOROUT 3647 +#define F_GTSVECTOR_COMPRESS 3648 +#define F_GTSVECTOR_DECOMPRESS 3649 +#define F_GTSVECTOR_PICKSPLIT 3650 +#define F_GTSVECTOR_UNION 3651 +#define F_GTSVECTOR_SAME 3652 +#define F_GTSVECTOR_PENALTY 3653 +#define F_GTSVECTOR_CONSISTENT_INTERNAL_TSVECTOR_INT2_OID_INTERNAL 3654 +#define F_GIN_EXTRACT_TSVECTOR_TSVECTOR_INTERNAL_INTERNAL 3656 +#define F_GIN_EXTRACT_TSQUERY_TSVECTOR_INTERNAL_INT2_INTERNAL_INTERNAL_INTERNAL_INTERNAL 3657 +#define F_GIN_TSQUERY_CONSISTENT_INTERNAL_INT2_TSVECTOR_INT4_INTERNAL_INTERNAL_INTERNAL_INTERNAL 3658 +#define F_TSQUERY_LT 3662 +#define F_TSQUERY_LE 3663 +#define F_TSQUERY_EQ 3664 +#define F_TSQUERY_NE 3665 +#define F_TSQUERY_GE 3666 +#define F_TSQUERY_GT 3667 +#define F_TSQUERY_CMP 3668 +#define F_TSQUERY_AND 3669 +#define F_TSQUERY_OR 3670 +#define F_TSQUERY_NOT 3671 +#define F_NUMNODE 3672 +#define F_QUERYTREE 3673 +#define F_TS_REWRITE_TSQUERY_TSQUERY_TSQUERY 3684 +#define F_TS_REWRITE_TSQUERY_TEXT 3685 +#define F_TSMATCHSEL 3686 +#define F_TSMATCHJOINSEL 3687 +#define F_TS_TYPANALYZE 3688 +#define F_TS_STAT_TEXT 3689 +#define F_TS_STAT_TEXT_TEXT 3690 +#define F_TSQ_MCONTAINS 3691 +#define F_TSQ_MCONTAINED 3692 +#define F_GTSQUERY_COMPRESS 3695 +#define F_STARTS_WITH 3696 +#define F_GTSQUERY_PICKSPLIT 3697 +#define F_GTSQUERY_UNION 3698 +#define F_GTSQUERY_SAME 3699 +#define F_GTSQUERY_PENALTY 3700 +#define F_GTSQUERY_CONSISTENT_INTERNAL_TSQUERY_INT2_OID_INTERNAL 3701 +#define F_TS_RANK__FLOAT4_TSVECTOR_TSQUERY_INT4 3703 +#define F_TS_RANK__FLOAT4_TSVECTOR_TSQUERY 3704 +#define F_TS_RANK_TSVECTOR_TSQUERY_INT4 3705 +#define F_TS_RANK_TSVECTOR_TSQUERY 3706 +#define F_TS_RANK_CD__FLOAT4_TSVECTOR_TSQUERY_INT4 3707 +#define F_TS_RANK_CD__FLOAT4_TSVECTOR_TSQUERY 3708 +#define F_TS_RANK_CD_TSVECTOR_TSQUERY_INT4 3709 +#define F_TS_RANK_CD_TSVECTOR_TSQUERY 3710 +#define F_LENGTH_TSVECTOR 3711 +#define F_TS_TOKEN_TYPE_OID 3713 +#define F_TS_TOKEN_TYPE_TEXT 3714 +#define F_TS_PARSE_OID_TEXT 3715 +#define F_TS_PARSE_TEXT_TEXT 3716 +#define F_PRSD_START 3717 +#define F_PRSD_NEXTTOKEN 3718 +#define F_PRSD_END 3719 +#define F_PRSD_HEADLINE 3720 +#define F_PRSD_LEXTYPE 3721 +#define F_TS_LEXIZE 3723 +#define F_GIN_CMP_TSLEXEME 3724 +#define F_DSIMPLE_INIT 3725 +#define F_DSIMPLE_LEXIZE 3726 +#define F_DSYNONYM_INIT 3728 +#define F_DSYNONYM_LEXIZE 3729 +#define F_DISPELL_INIT 3731 +#define F_DISPELL_LEXIZE 3732 +#define F_REGCONFIGIN 3736 +#define F_REGCONFIGOUT 3737 +#define F_REGCONFIGRECV 3738 +#define F_REGCONFIGSEND 3739 +#define F_THESAURUS_INIT 3740 +#define F_THESAURUS_LEXIZE 3741 +#define F_TS_HEADLINE_REGCONFIG_TEXT_TSQUERY_TEXT 3743 +#define F_TS_HEADLINE_REGCONFIG_TEXT_TSQUERY 3744 +#define F_TO_TSVECTOR_REGCONFIG_TEXT 3745 +#define F_TO_TSQUERY_REGCONFIG_TEXT 3746 +#define F_PLAINTO_TSQUERY_REGCONFIG_TEXT 3747 +#define F_TO_TSVECTOR_TEXT 3749 +#define F_TO_TSQUERY_TEXT 3750 +#define F_PLAINTO_TSQUERY_TEXT 3751 +#define F_TSVECTOR_UPDATE_TRIGGER 3752 +#define F_TSVECTOR_UPDATE_TRIGGER_COLUMN 3753 +#define F_TS_HEADLINE_TEXT_TSQUERY_TEXT 3754 +#define F_TS_HEADLINE_TEXT_TSQUERY 3755 +#define F_PG_TS_PARSER_IS_VISIBLE 3756 +#define F_PG_TS_DICT_IS_VISIBLE 3757 +#define F_PG_TS_CONFIG_IS_VISIBLE 3758 +#define F_GET_CURRENT_TS_CONFIG 3759 +#define F_TS_MATCH_TT 3760 +#define F_TS_MATCH_TQ 3761 +#define F_PG_TS_TEMPLATE_IS_VISIBLE 3768 +#define F_REGDICTIONARYIN 3771 +#define F_REGDICTIONARYOUT 3772 +#define F_REGDICTIONARYRECV 3773 +#define F_REGDICTIONARYSEND 3774 +#define F_PG_STAT_RESET_SHARED 3775 +#define F_PG_STAT_RESET_SINGLE_TABLE_COUNTERS 3776 +#define F_PG_STAT_RESET_SINGLE_FUNCTION_COUNTERS 3777 +#define F_PG_TABLESPACE_LOCATION 3778 +#define F_PG_CREATE_PHYSICAL_REPLICATION_SLOT 3779 +#define F_PG_DROP_REPLICATION_SLOT 3780 +#define F_PG_GET_REPLICATION_SLOTS 3781 +#define F_PG_LOGICAL_SLOT_GET_CHANGES 3782 +#define F_PG_LOGICAL_SLOT_GET_BINARY_CHANGES 3783 +#define F_PG_LOGICAL_SLOT_PEEK_CHANGES 3784 +#define F_PG_LOGICAL_SLOT_PEEK_BINARY_CHANGES 3785 +#define F_PG_CREATE_LOGICAL_REPLICATION_SLOT 3786 +#define F_TO_JSONB 3787 +#define F_PG_STAT_GET_SNAPSHOT_TIMESTAMP 3788 +#define F_GIN_CLEAN_PENDING_LIST 3789 +#define F_GTSVECTOR_CONSISTENT_INTERNAL_GTSVECTOR_INT4_OID_INTERNAL 3790 +#define F_GIN_EXTRACT_TSQUERY_TSQUERY_INTERNAL_INT2_INTERNAL_INTERNAL_INTERNAL_INTERNAL 3791 +#define F_GIN_TSQUERY_CONSISTENT_INTERNAL_INT2_TSQUERY_INT4_INTERNAL_INTERNAL_INTERNAL_INTERNAL 3792 +#define F_GTSQUERY_CONSISTENT_INTERNAL_INTERNAL_INT4_OID_INTERNAL 3793 +#define F_INET_SPG_CONFIG 3795 +#define F_INET_SPG_CHOOSE 3796 +#define F_INET_SPG_PICKSPLIT 3797 +#define F_INET_SPG_INNER_CONSISTENT 3798 +#define F_INET_SPG_LEAF_CONSISTENT 3799 +#define F_PG_CURRENT_LOGFILE_ 3800 +#define F_PG_CURRENT_LOGFILE_TEXT 3801 +#define F_JSONB_SEND 3803 +#define F_JSONB_OUT 3804 +#define F_JSONB_RECV 3805 +#define F_JSONB_IN 3806 +#define F_PG_GET_FUNCTION_ARG_DEFAULT 3808 +#define F_PG_EXPORT_SNAPSHOT 3809 +#define F_PG_IS_IN_RECOVERY 3810 +#define F_MONEY_INT4 3811 +#define F_MONEY_INT8 3812 +#define F_PG_COLLATION_IS_VISIBLE 3815 +#define F_ARRAY_TYPANALYZE 3816 +#define F_ARRAYCONTSEL 3817 +#define F_ARRAYCONTJOINSEL 3818 +#define F_PG_GET_MULTIXACT_MEMBERS 3819 +#define F_PG_LAST_WAL_RECEIVE_LSN 3820 +#define F_PG_LAST_WAL_REPLAY_LSN 3821 +#define F_CASH_DIV_CASH 3822 +#define F_NUMERIC_MONEY 3823 +#define F_MONEY_NUMERIC 3824 +#define F_PG_READ_FILE_TEXT 3826 +#define F_PG_READ_BINARY_FILE_TEXT_INT8_INT8 3827 +#define F_PG_READ_BINARY_FILE_TEXT 3828 +#define F_PG_OPFAMILY_IS_VISIBLE 3829 +#define F_PG_LAST_XACT_REPLAY_TIMESTAMP 3830 +#define F_ANYRANGE_IN 3832 +#define F_ANYRANGE_OUT 3833 +#define F_RANGE_IN 3834 +#define F_RANGE_OUT 3835 +#define F_RANGE_RECV 3836 +#define F_RANGE_SEND 3837 +#define F_PG_IDENTIFY_OBJECT 3839 +#define F_INT4RANGE_INT4_INT4 3840 +#define F_INT4RANGE_INT4_INT4_TEXT 3841 +#define F_PG_RELATION_IS_UPDATABLE 3842 +#define F_PG_COLUMN_IS_UPDATABLE 3843 +#define F_NUMRANGE_NUMERIC_NUMERIC 3844 +#define F_NUMRANGE_NUMERIC_NUMERIC_TEXT 3845 +#define F_MAKE_DATE 3846 +#define F_MAKE_TIME 3847 +#define F_LOWER_ANYRANGE 3848 +#define F_UPPER_ANYRANGE 3849 +#define F_ISEMPTY_ANYRANGE 3850 +#define F_LOWER_INC_ANYRANGE 3851 +#define F_UPPER_INC_ANYRANGE 3852 +#define F_LOWER_INF_ANYRANGE 3853 +#define F_UPPER_INF_ANYRANGE 3854 +#define F_RANGE_EQ 3855 +#define F_RANGE_NE 3856 +#define F_RANGE_OVERLAPS 3857 +#define F_RANGE_CONTAINS_ELEM 3858 +#define F_RANGE_CONTAINS 3859 +#define F_ELEM_CONTAINED_BY_RANGE 3860 +#define F_RANGE_CONTAINED_BY 3861 +#define F_RANGE_ADJACENT 3862 +#define F_RANGE_BEFORE 3863 +#define F_RANGE_AFTER 3864 +#define F_RANGE_OVERLEFT 3865 +#define F_RANGE_OVERRIGHT 3866 +#define F_RANGE_UNION 3867 +#define F_RANGE_INTERSECT 3868 +#define F_RANGE_MINUS 3869 +#define F_RANGE_CMP 3870 +#define F_RANGE_LT 3871 +#define F_RANGE_LE 3872 +#define F_RANGE_GE 3873 +#define F_RANGE_GT 3874 +#define F_RANGE_GIST_CONSISTENT 3875 +#define F_RANGE_GIST_UNION 3876 +#define F_PG_REPLICATION_SLOT_ADVANCE 3878 +#define F_RANGE_GIST_PENALTY 3879 +#define F_RANGE_GIST_PICKSPLIT 3880 +#define F_RANGE_GIST_SAME 3881 +#define F_HASH_RANGE 3902 +#define F_INT4RANGE_CANONICAL 3914 +#define F_DATERANGE_CANONICAL 3915 +#define F_RANGE_TYPANALYZE 3916 +#define F_TIMESTAMP_SUPPORT 3917 +#define F_INTERVAL_SUPPORT 3918 +#define F_GINARRAYTRICONSISTENT 3920 +#define F_GIN_TSQUERY_TRICONSISTENT 3921 +#define F_INT4RANGE_SUBDIFF 3922 +#define F_INT8RANGE_SUBDIFF 3923 +#define F_NUMRANGE_SUBDIFF 3924 +#define F_DATERANGE_SUBDIFF 3925 +#define F_INT8RANGE_CANONICAL 3928 +#define F_TSRANGE_SUBDIFF 3929 +#define F_TSTZRANGE_SUBDIFF 3930 +#define F_JSONB_OBJECT_KEYS 3931 +#define F_JSONB_EACH_TEXT 3932 +#define F_TSRANGE_TIMESTAMP_TIMESTAMP 3933 +#define F_TSRANGE_TIMESTAMP_TIMESTAMP_TEXT 3934 +#define F_PG_SLEEP_FOR 3935 +#define F_PG_SLEEP_UNTIL 3936 +#define F_TSTZRANGE_TIMESTAMPTZ_TIMESTAMPTZ 3937 +#define F_TSTZRANGE_TIMESTAMPTZ_TIMESTAMPTZ_TEXT 3938 +#define F_MXID_AGE 3939 +#define F_JSONB_EXTRACT_PATH_TEXT 3940 +#define F_DATERANGE_DATE_DATE 3941 +#define F_DATERANGE_DATE_DATE_TEXT 3942 +#define F_ACLDEFAULT 3943 +#define F_TIME_SUPPORT 3944 +#define F_INT8RANGE_INT8_INT8 3945 +#define F_INT8RANGE_INT8_INT8_TEXT 3946 +#define F_JSON_OBJECT_FIELD 3947 +#define F_JSON_OBJECT_FIELD_TEXT 3948 +#define F_JSON_ARRAY_ELEMENT 3949 +#define F_JSON_ARRAY_ELEMENT_TEXT 3950 +#define F_JSON_EXTRACT_PATH 3951 +#define F_BRIN_SUMMARIZE_NEW_VALUES 3952 +#define F_JSON_EXTRACT_PATH_TEXT 3953 +#define F_PG_GET_OBJECT_ADDRESS 3954 +#define F_JSON_ARRAY_ELEMENTS 3955 +#define F_JSON_ARRAY_LENGTH 3956 +#define F_JSON_OBJECT_KEYS 3957 +#define F_JSON_EACH 3958 +#define F_JSON_EACH_TEXT 3959 +#define F_JSON_POPULATE_RECORD 3960 +#define F_JSON_POPULATE_RECORDSET 3961 +#define F_JSON_TYPEOF 3968 +#define F_JSON_ARRAY_ELEMENTS_TEXT 3969 +#define F_ORDERED_SET_TRANSITION 3970 +#define F_ORDERED_SET_TRANSITION_MULTI 3971 +#define F_PERCENTILE_DISC_FLOAT8_ANYELEMENT 3972 +#define F_PERCENTILE_DISC_FINAL 3973 +#define F_PERCENTILE_CONT_FLOAT8_FLOAT8 3974 +#define F_PERCENTILE_CONT_FLOAT8_FINAL 3975 +#define F_PERCENTILE_CONT_FLOAT8_INTERVAL 3976 +#define F_PERCENTILE_CONT_INTERVAL_FINAL 3977 +#define F_PERCENTILE_DISC__FLOAT8_ANYELEMENT 3978 +#define F_PERCENTILE_DISC_MULTI_FINAL 3979 +#define F_PERCENTILE_CONT__FLOAT8_FLOAT8 3980 +#define F_PERCENTILE_CONT_FLOAT8_MULTI_FINAL 3981 +#define F_PERCENTILE_CONT__FLOAT8_INTERVAL 3982 +#define F_PERCENTILE_CONT_INTERVAL_MULTI_FINAL 3983 +#define F_MODE 3984 +#define F_MODE_FINAL 3985 +#define F_RANK_ANY 3986 +#define F_RANK_FINAL 3987 +#define F_PERCENT_RANK_ANY 3988 +#define F_PERCENT_RANK_FINAL 3989 +#define F_CUME_DIST_ANY 3990 +#define F_CUME_DIST_FINAL 3991 +#define F_DENSE_RANK_ANY 3992 +#define F_DENSE_RANK_FINAL 3993 +#define F_GENERATE_SERIES_INT4_SUPPORT 3994 +#define F_GENERATE_SERIES_INT8_SUPPORT 3995 +#define F_ARRAY_UNNEST_SUPPORT 3996 +#define F_GIST_BOX_DISTANCE 3998 +#define F_BRIN_SUMMARIZE_RANGE 3999 +#define F_JSONPATH_IN 4001 +#define F_JSONPATH_RECV 4002 +#define F_JSONPATH_OUT 4003 +#define F_JSONPATH_SEND 4004 +#define F_JSONB_PATH_EXISTS 4005 +#define F_JSONB_PATH_QUERY 4006 +#define F_JSONB_PATH_QUERY_ARRAY 4007 +#define F_JSONB_PATH_QUERY_FIRST 4008 +#define F_JSONB_PATH_MATCH 4009 +#define F_JSONB_PATH_EXISTS_OPR 4010 +#define F_JSONB_PATH_MATCH_OPR 4011 +#define F_BRIN_DESUMMARIZE_RANGE 4014 +#define F_SPG_QUAD_CONFIG 4018 +#define F_SPG_QUAD_CHOOSE 4019 +#define F_SPG_QUAD_PICKSPLIT 4020 +#define F_SPG_QUAD_INNER_CONSISTENT 4021 +#define F_SPG_QUAD_LEAF_CONSISTENT 4022 +#define F_SPG_KD_CONFIG 4023 +#define F_SPG_KD_CHOOSE 4024 +#define F_SPG_KD_PICKSPLIT 4025 +#define F_SPG_KD_INNER_CONSISTENT 4026 +#define F_SPG_TEXT_CONFIG 4027 +#define F_SPG_TEXT_CHOOSE 4028 +#define F_SPG_TEXT_PICKSPLIT 4029 +#define F_SPG_TEXT_INNER_CONSISTENT 4030 +#define F_SPG_TEXT_LEAF_CONSISTENT 4031 +#define F_PG_SEQUENCE_LAST_VALUE 4032 +#define F_JSONB_NE 4038 +#define F_JSONB_LT 4039 +#define F_JSONB_GT 4040 +#define F_JSONB_LE 4041 +#define F_JSONB_GE 4042 +#define F_JSONB_EQ 4043 +#define F_JSONB_CMP 4044 +#define F_JSONB_HASH 4045 +#define F_JSONB_CONTAINS 4046 +#define F_JSONB_EXISTS 4047 +#define F_JSONB_EXISTS_ANY 4048 +#define F_JSONB_EXISTS_ALL 4049 +#define F_JSONB_CONTAINED 4050 +#define F_ARRAY_AGG_ARRAY_TRANSFN 4051 +#define F_ARRAY_AGG_ARRAY_FINALFN 4052 +#define F_ARRAY_AGG_ANYARRAY 4053 +#define F_RANGE_MERGE_ANYRANGE_ANYRANGE 4057 +#define F_INET_MERGE 4063 +#define F_BOUND_BOX 4067 +#define F_INET_SAME_FAMILY 4071 +#define F_BINARY_UPGRADE_SET_RECORD_INIT_PRIVS 4083 +#define F_REGNAMESPACEIN 4084 +#define F_REGNAMESPACEOUT 4085 +#define F_TO_REGNAMESPACE 4086 +#define F_REGNAMESPACERECV 4087 +#define F_REGNAMESPACESEND 4088 +#define F_BOX_POINT 4091 +#define F_REGROLEOUT 4092 +#define F_TO_REGROLE 4093 +#define F_REGROLERECV 4094 +#define F_REGROLESEND 4095 +#define F_REGROLEIN 4098 +#define F_PG_ROTATE_LOGFILE_OLD 4099 +#define F_PG_READ_FILE_OLD 4100 +#define F_BINARY_UPGRADE_SET_MISSING_VALUE 4101 +#define F_BRIN_INCLUSION_OPCINFO 4105 +#define F_BRIN_INCLUSION_ADD_VALUE 4106 +#define F_BRIN_INCLUSION_CONSISTENT 4107 +#define F_BRIN_INCLUSION_UNION 4108 +#define F_MACADDR8_IN 4110 +#define F_MACADDR8_OUT 4111 +#define F_TRUNC_MACADDR8 4112 +#define F_MACADDR8_EQ 4113 +#define F_MACADDR8_LT 4114 +#define F_MACADDR8_LE 4115 +#define F_MACADDR8_GT 4116 +#define F_MACADDR8_GE 4117 +#define F_MACADDR8_NE 4118 +#define F_MACADDR8_CMP 4119 +#define F_MACADDR8_NOT 4120 +#define F_MACADDR8_AND 4121 +#define F_MACADDR8_OR 4122 +#define F_MACADDR8 4123 +#define F_MACADDR 4124 +#define F_MACADDR8_SET7BIT 4125 +#define F_IN_RANGE_INT8_INT8_INT8_BOOL_BOOL 4126 +#define F_IN_RANGE_INT4_INT4_INT8_BOOL_BOOL 4127 +#define F_IN_RANGE_INT4_INT4_INT4_BOOL_BOOL 4128 +#define F_IN_RANGE_INT4_INT4_INT2_BOOL_BOOL 4129 +#define F_IN_RANGE_INT2_INT2_INT8_BOOL_BOOL 4130 +#define F_IN_RANGE_INT2_INT2_INT4_BOOL_BOOL 4131 +#define F_IN_RANGE_INT2_INT2_INT2_BOOL_BOOL 4132 +#define F_IN_RANGE_DATE_DATE_INTERVAL_BOOL_BOOL 4133 +#define F_IN_RANGE_TIMESTAMP_TIMESTAMP_INTERVAL_BOOL_BOOL 4134 +#define F_IN_RANGE_TIMESTAMPTZ_TIMESTAMPTZ_INTERVAL_BOOL_BOOL 4135 +#define F_IN_RANGE_INTERVAL_INTERVAL_INTERVAL_BOOL_BOOL 4136 +#define F_IN_RANGE_TIME_TIME_INTERVAL_BOOL_BOOL 4137 +#define F_IN_RANGE_TIMETZ_TIMETZ_INTERVAL_BOOL_BOOL 4138 +#define F_IN_RANGE_FLOAT8_FLOAT8_FLOAT8_BOOL_BOOL 4139 +#define F_IN_RANGE_FLOAT4_FLOAT4_FLOAT8_BOOL_BOOL 4140 +#define F_IN_RANGE_NUMERIC_NUMERIC_NUMERIC_BOOL_BOOL 4141 +#define F_PG_LSN_LARGER 4187 +#define F_PG_LSN_SMALLER 4188 +#define F_MAX_PG_LSN 4189 +#define F_MIN_PG_LSN 4190 +#define F_REGCOLLATIONIN 4193 +#define F_REGCOLLATIONOUT 4194 +#define F_TO_REGCOLLATION 4195 +#define F_REGCOLLATIONRECV 4196 +#define F_REGCOLLATIONSEND 4197 +#define F_TS_HEADLINE_REGCONFIG_JSONB_TSQUERY_TEXT 4201 +#define F_TS_HEADLINE_REGCONFIG_JSONB_TSQUERY 4202 +#define F_TS_HEADLINE_JSONB_TSQUERY_TEXT 4203 +#define F_TS_HEADLINE_JSONB_TSQUERY 4204 +#define F_TS_HEADLINE_REGCONFIG_JSON_TSQUERY_TEXT 4205 +#define F_TS_HEADLINE_REGCONFIG_JSON_TSQUERY 4206 +#define F_TS_HEADLINE_JSON_TSQUERY_TEXT 4207 +#define F_TS_HEADLINE_JSON_TSQUERY 4208 +#define F_TO_TSVECTOR_JSONB 4209 +#define F_TO_TSVECTOR_JSON 4210 +#define F_TO_TSVECTOR_REGCONFIG_JSONB 4211 +#define F_TO_TSVECTOR_REGCONFIG_JSON 4212 +#define F_JSONB_TO_TSVECTOR_JSONB_JSONB 4213 +#define F_JSONB_TO_TSVECTOR_REGCONFIG_JSONB_JSONB 4214 +#define F_JSON_TO_TSVECTOR_JSON_JSONB 4215 +#define F_JSON_TO_TSVECTOR_REGCONFIG_JSON_JSONB 4216 +#define F_PG_COPY_PHYSICAL_REPLICATION_SLOT_NAME_NAME_BOOL 4220 +#define F_PG_COPY_PHYSICAL_REPLICATION_SLOT_NAME_NAME 4221 +#define F_PG_COPY_LOGICAL_REPLICATION_SLOT_NAME_NAME_BOOL_NAME 4222 +#define F_PG_COPY_LOGICAL_REPLICATION_SLOT_NAME_NAME_BOOL 4223 +#define F_PG_COPY_LOGICAL_REPLICATION_SLOT_NAME_NAME 4224 +#define F_ANYCOMPATIBLEMULTIRANGE_IN 4226 +#define F_ANYCOMPATIBLEMULTIRANGE_OUT 4227 +#define F_RANGE_MERGE_ANYMULTIRANGE 4228 +#define F_ANYMULTIRANGE_IN 4229 +#define F_ANYMULTIRANGE_OUT 4230 +#define F_MULTIRANGE_IN 4231 +#define F_MULTIRANGE_OUT 4232 +#define F_MULTIRANGE_RECV 4233 +#define F_MULTIRANGE_SEND 4234 +#define F_LOWER_ANYMULTIRANGE 4235 +#define F_UPPER_ANYMULTIRANGE 4236 +#define F_ISEMPTY_ANYMULTIRANGE 4237 +#define F_LOWER_INC_ANYMULTIRANGE 4238 +#define F_UPPER_INC_ANYMULTIRANGE 4239 +#define F_LOWER_INF_ANYMULTIRANGE 4240 +#define F_UPPER_INF_ANYMULTIRANGE 4241 +#define F_MULTIRANGE_TYPANALYZE 4242 +#define F_MULTIRANGESEL 4243 +#define F_MULTIRANGE_EQ 4244 +#define F_MULTIRANGE_NE 4245 +#define F_RANGE_OVERLAPS_MULTIRANGE 4246 +#define F_MULTIRANGE_OVERLAPS_RANGE 4247 +#define F_MULTIRANGE_OVERLAPS_MULTIRANGE 4248 +#define F_MULTIRANGE_CONTAINS_ELEM 4249 +#define F_MULTIRANGE_CONTAINS_RANGE 4250 +#define F_MULTIRANGE_CONTAINS_MULTIRANGE 4251 +#define F_ELEM_CONTAINED_BY_MULTIRANGE 4252 +#define F_RANGE_CONTAINED_BY_MULTIRANGE 4253 +#define F_MULTIRANGE_CONTAINED_BY_MULTIRANGE 4254 +#define F_RANGE_ADJACENT_MULTIRANGE 4255 +#define F_MULTIRANGE_ADJACENT_MULTIRANGE 4256 +#define F_MULTIRANGE_ADJACENT_RANGE 4257 +#define F_RANGE_BEFORE_MULTIRANGE 4258 +#define F_MULTIRANGE_BEFORE_RANGE 4259 +#define F_MULTIRANGE_BEFORE_MULTIRANGE 4260 +#define F_RANGE_AFTER_MULTIRANGE 4261 +#define F_MULTIRANGE_AFTER_RANGE 4262 +#define F_MULTIRANGE_AFTER_MULTIRANGE 4263 +#define F_RANGE_OVERLEFT_MULTIRANGE 4264 +#define F_MULTIRANGE_OVERLEFT_RANGE 4265 +#define F_MULTIRANGE_OVERLEFT_MULTIRANGE 4266 +#define F_RANGE_OVERRIGHT_MULTIRANGE 4267 +#define F_MULTIRANGE_OVERRIGHT_RANGE 4268 +#define F_MULTIRANGE_OVERRIGHT_MULTIRANGE 4269 +#define F_MULTIRANGE_UNION 4270 +#define F_MULTIRANGE_MINUS 4271 +#define F_MULTIRANGE_INTERSECT 4272 +#define F_MULTIRANGE_CMP 4273 +#define F_MULTIRANGE_LT 4274 +#define F_MULTIRANGE_LE 4275 +#define F_MULTIRANGE_GE 4276 +#define F_MULTIRANGE_GT 4277 +#define F_HASH_MULTIRANGE 4278 +#define F_HASH_MULTIRANGE_EXTENDED 4279 +#define F_INT4MULTIRANGE_ 4280 +#define F_INT4MULTIRANGE_INT4RANGE 4281 +#define F_INT4MULTIRANGE__INT4RANGE 4282 +#define F_NUMMULTIRANGE_ 4283 +#define F_NUMMULTIRANGE_NUMRANGE 4284 +#define F_NUMMULTIRANGE__NUMRANGE 4285 +#define F_TSMULTIRANGE_ 4286 +#define F_TSMULTIRANGE_TSRANGE 4287 +#define F_TSMULTIRANGE__TSRANGE 4288 +#define F_TSTZMULTIRANGE_ 4289 +#define F_TSTZMULTIRANGE_TSTZRANGE 4290 +#define F_TSTZMULTIRANGE__TSTZRANGE 4291 +#define F_DATEMULTIRANGE_ 4292 +#define F_DATEMULTIRANGE_DATERANGE 4293 +#define F_DATEMULTIRANGE__DATERANGE 4294 +#define F_INT8MULTIRANGE_ 4295 +#define F_INT8MULTIRANGE_INT8RANGE 4296 +#define F_INT8MULTIRANGE__INT8RANGE 4297 +#define F_MULTIRANGE 4298 +#define F_RANGE_AGG_TRANSFN 4299 +#define F_RANGE_AGG_FINALFN 4300 +#define F_RANGE_AGG_ANYRANGE 4301 +#define F_KOI8R_TO_MIC 4302 +#define F_MIC_TO_KOI8R 4303 +#define F_ISO_TO_MIC 4304 +#define F_MIC_TO_ISO 4305 +#define F_WIN1251_TO_MIC 4306 +#define F_MIC_TO_WIN1251 4307 +#define F_WIN866_TO_MIC 4308 +#define F_MIC_TO_WIN866 4309 +#define F_KOI8R_TO_WIN1251 4310 +#define F_WIN1251_TO_KOI8R 4311 +#define F_KOI8R_TO_WIN866 4312 +#define F_WIN866_TO_KOI8R 4313 +#define F_WIN866_TO_WIN1251 4314 +#define F_WIN1251_TO_WIN866 4315 +#define F_ISO_TO_KOI8R 4316 +#define F_KOI8R_TO_ISO 4317 +#define F_ISO_TO_WIN1251 4318 +#define F_WIN1251_TO_ISO 4319 +#define F_ISO_TO_WIN866 4320 +#define F_WIN866_TO_ISO 4321 +#define F_EUC_CN_TO_MIC 4322 +#define F_MIC_TO_EUC_CN 4323 +#define F_EUC_JP_TO_SJIS 4324 +#define F_SJIS_TO_EUC_JP 4325 +#define F_EUC_JP_TO_MIC 4326 +#define F_SJIS_TO_MIC 4327 +#define F_MIC_TO_EUC_JP 4328 +#define F_MIC_TO_SJIS 4329 +#define F_EUC_KR_TO_MIC 4330 +#define F_MIC_TO_EUC_KR 4331 +#define F_EUC_TW_TO_BIG5 4332 +#define F_BIG5_TO_EUC_TW 4333 +#define F_EUC_TW_TO_MIC 4334 +#define F_BIG5_TO_MIC 4335 +#define F_MIC_TO_EUC_TW 4336 +#define F_MIC_TO_BIG5 4337 +#define F_LATIN2_TO_MIC 4338 +#define F_MIC_TO_LATIN2 4339 +#define F_WIN1250_TO_MIC 4340 +#define F_MIC_TO_WIN1250 4341 +#define F_LATIN2_TO_WIN1250 4342 +#define F_WIN1250_TO_LATIN2 4343 +#define F_LATIN1_TO_MIC 4344 +#define F_MIC_TO_LATIN1 4345 +#define F_LATIN3_TO_MIC 4346 +#define F_MIC_TO_LATIN3 4347 +#define F_LATIN4_TO_MIC 4348 +#define F_MIC_TO_LATIN4 4349 +#define F_NORMALIZE 4350 +#define F_IS_NORMALIZED 4351 +#define F_BIG5_TO_UTF8 4352 +#define F_UTF8_TO_BIG5 4353 +#define F_UTF8_TO_KOI8R 4354 +#define F_KOI8R_TO_UTF8 4355 +#define F_UTF8_TO_KOI8U 4356 +#define F_KOI8U_TO_UTF8 4357 +#define F_UTF8_TO_WIN 4358 +#define F_WIN_TO_UTF8 4359 +#define F_EUC_CN_TO_UTF8 4360 +#define F_UTF8_TO_EUC_CN 4361 +#define F_EUC_JP_TO_UTF8 4362 +#define F_UTF8_TO_EUC_JP 4363 +#define F_EUC_KR_TO_UTF8 4364 +#define F_UTF8_TO_EUC_KR 4365 +#define F_EUC_TW_TO_UTF8 4366 +#define F_UTF8_TO_EUC_TW 4367 +#define F_GB18030_TO_UTF8 4368 +#define F_UTF8_TO_GB18030 4369 +#define F_GBK_TO_UTF8 4370 +#define F_UTF8_TO_GBK 4371 +#define F_UTF8_TO_ISO8859 4372 +#define F_ISO8859_TO_UTF8 4373 +#define F_ISO8859_1_TO_UTF8 4374 +#define F_UTF8_TO_ISO8859_1 4375 +#define F_JOHAB_TO_UTF8 4376 +#define F_UTF8_TO_JOHAB 4377 +#define F_SJIS_TO_UTF8 4378 +#define F_UTF8_TO_SJIS 4379 +#define F_UHC_TO_UTF8 4380 +#define F_UTF8_TO_UHC 4381 +#define F_EUC_JIS_2004_TO_UTF8 4382 +#define F_UTF8_TO_EUC_JIS_2004 4383 +#define F_SHIFT_JIS_2004_TO_UTF8 4384 +#define F_UTF8_TO_SHIFT_JIS_2004 4385 +#define F_EUC_JIS_2004_TO_SHIFT_JIS_2004 4386 +#define F_SHIFT_JIS_2004_TO_EUC_JIS_2004 4387 +#define F_MULTIRANGE_INTERSECT_AGG_TRANSFN 4388 +#define F_RANGE_INTERSECT_AGG_ANYMULTIRANGE 4389 +#define F_BINARY_UPGRADE_SET_NEXT_MULTIRANGE_PG_TYPE_OID 4390 +#define F_BINARY_UPGRADE_SET_NEXT_MULTIRANGE_ARRAY_PG_TYPE_OID 4391 +#define F_RANGE_INTERSECT_AGG_TRANSFN 4401 +#define F_RANGE_INTERSECT_AGG_ANYRANGE 4450 +#define F_RANGE_CONTAINS_MULTIRANGE 4541 +#define F_MULTIRANGE_CONTAINED_BY_RANGE 4542 +#define F_PG_LOG_BACKEND_MEMORY_CONTEXTS 4543 +#define F_BINARY_UPGRADE_SET_NEXT_HEAP_RELFILENODE 4545 +#define F_BINARY_UPGRADE_SET_NEXT_INDEX_RELFILENODE 4546 +#define F_BINARY_UPGRADE_SET_NEXT_TOAST_RELFILENODE 4547 +#define F_BINARY_UPGRADE_SET_NEXT_PG_TABLESPACE_OID 4548 +#define F_PG_EVENT_TRIGGER_TABLE_REWRITE_OID 4566 +#define F_PG_EVENT_TRIGGER_TABLE_REWRITE_REASON 4567 +#define F_PG_EVENT_TRIGGER_DDL_COMMANDS 4568 +#define F_BRIN_BLOOM_OPCINFO 4591 +#define F_BRIN_BLOOM_ADD_VALUE 4592 +#define F_BRIN_BLOOM_CONSISTENT 4593 +#define F_BRIN_BLOOM_UNION 4594 +#define F_BRIN_BLOOM_OPTIONS 4595 +#define F_BRIN_BLOOM_SUMMARY_IN 4596 +#define F_BRIN_BLOOM_SUMMARY_OUT 4597 +#define F_BRIN_BLOOM_SUMMARY_RECV 4598 +#define F_BRIN_BLOOM_SUMMARY_SEND 4599 +#define F_BRIN_MINMAX_MULTI_OPCINFO 4616 +#define F_BRIN_MINMAX_MULTI_ADD_VALUE 4617 +#define F_BRIN_MINMAX_MULTI_CONSISTENT 4618 +#define F_BRIN_MINMAX_MULTI_UNION 4619 +#define F_BRIN_MINMAX_MULTI_OPTIONS 4620 +#define F_BRIN_MINMAX_MULTI_DISTANCE_INT2 4621 +#define F_BRIN_MINMAX_MULTI_DISTANCE_INT4 4622 +#define F_BRIN_MINMAX_MULTI_DISTANCE_INT8 4623 +#define F_BRIN_MINMAX_MULTI_DISTANCE_FLOAT4 4624 +#define F_BRIN_MINMAX_MULTI_DISTANCE_FLOAT8 4625 +#define F_BRIN_MINMAX_MULTI_DISTANCE_NUMERIC 4626 +#define F_BRIN_MINMAX_MULTI_DISTANCE_TID 4627 +#define F_BRIN_MINMAX_MULTI_DISTANCE_UUID 4628 +#define F_BRIN_MINMAX_MULTI_DISTANCE_DATE 4629 +#define F_BRIN_MINMAX_MULTI_DISTANCE_TIME 4630 +#define F_BRIN_MINMAX_MULTI_DISTANCE_INTERVAL 4631 +#define F_BRIN_MINMAX_MULTI_DISTANCE_TIMETZ 4632 +#define F_BRIN_MINMAX_MULTI_DISTANCE_PG_LSN 4633 +#define F_BRIN_MINMAX_MULTI_DISTANCE_MACADDR 4634 +#define F_BRIN_MINMAX_MULTI_DISTANCE_MACADDR8 4635 +#define F_BRIN_MINMAX_MULTI_DISTANCE_INET 4636 +#define F_BRIN_MINMAX_MULTI_DISTANCE_TIMESTAMP 4637 +#define F_BRIN_MINMAX_MULTI_SUMMARY_IN 4638 +#define F_BRIN_MINMAX_MULTI_SUMMARY_OUT 4639 +#define F_BRIN_MINMAX_MULTI_SUMMARY_RECV 4640 +#define F_BRIN_MINMAX_MULTI_SUMMARY_SEND 4641 +#define F_PHRASETO_TSQUERY_TEXT 5001 +#define F_TSQUERY_PHRASE_TSQUERY_TSQUERY 5003 +#define F_TSQUERY_PHRASE_TSQUERY_TSQUERY_INT4 5004 +#define F_PHRASETO_TSQUERY_REGCONFIG_TEXT 5006 +#define F_WEBSEARCH_TO_TSQUERY_REGCONFIG_TEXT 5007 +#define F_WEBSEARCH_TO_TSQUERY_TEXT 5009 +#define F_SPG_BBOX_QUAD_CONFIG 5010 +#define F_SPG_POLY_QUAD_COMPRESS 5011 +#define F_SPG_BOX_QUAD_CONFIG 5012 +#define F_SPG_BOX_QUAD_CHOOSE 5013 +#define F_SPG_BOX_QUAD_PICKSPLIT 5014 +#define F_SPG_BOX_QUAD_INNER_CONSISTENT 5015 +#define F_SPG_BOX_QUAD_LEAF_CONSISTENT 5016 +#define F_PG_MCV_LIST_IN 5018 +#define F_PG_MCV_LIST_OUT 5019 +#define F_PG_MCV_LIST_RECV 5020 +#define F_PG_MCV_LIST_SEND 5021 +#define F_PG_LSN_PLI 5022 +#define F_NUMERIC_PL_PG_LSN 5023 +#define F_PG_LSN_MII 5024 +#define F_SATISFIES_HASH_PARTITION 5028 +#define F_PG_LS_TMPDIR_ 5029 +#define F_PG_LS_TMPDIR_OID 5030 +#define F_PG_LS_ARCHIVE_STATUSDIR 5031 +#define F_NETWORK_SORTSUPPORT 5033 +#define F_XID8LT 5034 +#define F_XID8GT 5035 +#define F_XID8LE 5036 +#define F_XID8GE 5037 +#define F_MATCHINGSEL 5040 +#define F_MATCHINGJOINSEL 5041 +#define F_MIN_SCALE 5042 +#define F_TRIM_SCALE 5043 +#define F_GCD_INT4_INT4 5044 +#define F_GCD_INT8_INT8 5045 +#define F_LCM_INT4_INT4 5046 +#define F_LCM_INT8_INT8 5047 +#define F_GCD_NUMERIC_NUMERIC 5048 +#define F_LCM_NUMERIC_NUMERIC 5049 +#define F_BTVARSTREQUALIMAGE 5050 +#define F_BTEQUALIMAGE 5051 +#define F_PG_GET_SHMEM_ALLOCATIONS 5052 +#define F_PG_STAT_GET_INS_SINCE_VACUUM 5053 +#define F_JSONB_SET_LAX 5054 +#define F_PG_SNAPSHOT_IN 5055 +#define F_PG_SNAPSHOT_OUT 5056 +#define F_PG_SNAPSHOT_RECV 5057 +#define F_PG_SNAPSHOT_SEND 5058 +#define F_PG_CURRENT_XACT_ID 5059 +#define F_PG_CURRENT_XACT_ID_IF_ASSIGNED 5060 +#define F_PG_CURRENT_SNAPSHOT 5061 +#define F_PG_SNAPSHOT_XMIN 5062 +#define F_PG_SNAPSHOT_XMAX 5063 +#define F_PG_SNAPSHOT_XIP 5064 +#define F_PG_VISIBLE_IN_SNAPSHOT 5065 +#define F_PG_XACT_STATUS 5066 +#define F_XID8IN 5070 +#define F_XID 5071 +#define F_XID8OUT 5081 +#define F_XID8RECV 5082 +#define F_XID8SEND 5083 +#define F_XID8EQ 5084 +#define F_XID8NE 5085 +#define F_ANYCOMPATIBLE_IN 5086 +#define F_ANYCOMPATIBLE_OUT 5087 +#define F_ANYCOMPATIBLEARRAY_IN 5088 +#define F_ANYCOMPATIBLEARRAY_OUT 5089 +#define F_ANYCOMPATIBLEARRAY_RECV 5090 +#define F_ANYCOMPATIBLEARRAY_SEND 5091 +#define F_ANYCOMPATIBLENONARRAY_IN 5092 +#define F_ANYCOMPATIBLENONARRAY_OUT 5093 +#define F_ANYCOMPATIBLERANGE_IN 5094 +#define F_ANYCOMPATIBLERANGE_OUT 5095 +#define F_XID8CMP 5096 +#define F_XID8_LARGER 5097 +#define F_XID8_SMALLER 5098 +#define F_MAX_XID8 5099 +#define F_MIN_XID8 5100 +#define F_PG_REPLICATION_ORIGIN_CREATE 6003 +#define F_PG_REPLICATION_ORIGIN_DROP 6004 +#define F_PG_REPLICATION_ORIGIN_OID 6005 +#define F_PG_REPLICATION_ORIGIN_SESSION_SETUP 6006 +#define F_PG_REPLICATION_ORIGIN_SESSION_RESET 6007 +#define F_PG_REPLICATION_ORIGIN_SESSION_IS_SETUP 6008 +#define F_PG_REPLICATION_ORIGIN_SESSION_PROGRESS 6009 +#define F_PG_REPLICATION_ORIGIN_XACT_SETUP 6010 +#define F_PG_REPLICATION_ORIGIN_XACT_RESET 6011 +#define F_PG_REPLICATION_ORIGIN_ADVANCE 6012 +#define F_PG_REPLICATION_ORIGIN_PROGRESS 6013 +#define F_PG_SHOW_REPLICATION_ORIGIN_STATUS 6014 +#define F_JSONB_SUBSCRIPT_HANDLER 6098 +#define F_PG_LSN 6103 +#define F_PG_STAT_GET_SUBSCRIPTION 6118 +#define F_PG_GET_PUBLICATION_TABLES 6119 +#define F_PG_GET_REPLICA_IDENTITY_INDEX 6120 +#define F_PG_RELATION_IS_PUBLISHABLE 6121 +#define F_MULTIRANGE_GIST_CONSISTENT 6154 +#define F_MULTIRANGE_GIST_COMPRESS 6156 +#define F_PG_GET_CATALOG_FOREIGN_KEYS 6159 +#define F_STRING_TO_TABLE_TEXT_TEXT 6160 +#define F_STRING_TO_TABLE_TEXT_TEXT_TEXT 6161 +#define F_BIT_COUNT_BIT 6162 +#define F_BIT_COUNT_BYTEA 6163 +#define F_BIT_XOR_INT2 6164 +#define F_BIT_XOR_INT4 6165 +#define F_BIT_XOR_INT8 6166 +#define F_BIT_XOR_BIT 6167 +#define F_PG_XACT_COMMIT_TIMESTAMP_ORIGIN 6168 +#define F_PG_STAT_GET_REPLICATION_SLOT 6169 +#define F_PG_STAT_RESET_REPLICATION_SLOT 6170 +#define F_TRIM_ARRAY 6172 +#define F_PG_GET_STATISTICSOBJDEF_EXPRESSIONS 6173 +#define F_PG_GET_STATISTICSOBJDEF_COLUMNS 6174 +#define F_DATE_BIN_INTERVAL_TIMESTAMP_TIMESTAMP 6177 +#define F_DATE_BIN_INTERVAL_TIMESTAMPTZ_TIMESTAMPTZ 6178 +#define F_ARRAY_SUBSCRIPT_HANDLER 6179 +#define F_RAW_ARRAY_SUBSCRIPT_HANDLER 6180 +#define F_TS_DEBUG_REGCONFIG_TEXT 6183 +#define F_TS_DEBUG_TEXT 6184 +#define F_PG_STAT_GET_DB_SESSION_TIME 6185 +#define F_PG_STAT_GET_DB_ACTIVE_TIME 6186 +#define F_PG_STAT_GET_DB_IDLE_IN_TRANSACTION_TIME 6187 +#define F_PG_STAT_GET_DB_SESSIONS 6188 +#define F_PG_STAT_GET_DB_SESSIONS_ABANDONED 6189 +#define F_PG_STAT_GET_DB_SESSIONS_FATAL 6190 +#define F_PG_STAT_GET_DB_SESSIONS_KILLED 6191 +#define F_HASH_RECORD 6192 +#define F_HASH_RECORD_EXTENDED 6193 +#define F_LTRIM_BYTEA_BYTEA 6195 +#define F_RTRIM_BYTEA_BYTEA 6196 +#define F_PG_GET_FUNCTION_SQLBODY 6197 +#define F_UNISTR 6198 +#define F_EXTRACT_TEXT_DATE 6199 +#define F_EXTRACT_TEXT_TIME 6200 +#define F_EXTRACT_TEXT_TIMETZ 6201 +#define F_EXTRACT_TEXT_TIMESTAMP 6202 +#define F_EXTRACT_TEXT_TIMESTAMPTZ 6203 +#define F_EXTRACT_TEXT_INTERVAL 6204 +#define F_HAS_PARAMETER_PRIVILEGE_NAME_TEXT_TEXT 6205 +#define F_HAS_PARAMETER_PRIVILEGE_OID_TEXT_TEXT 6206 +#define F_HAS_PARAMETER_PRIVILEGE_TEXT_TEXT 6207 +#define F_PG_GET_WAL_RESOURCE_MANAGERS 6224 +#define F_MULTIRANGE_AGG_TRANSFN 6225 +#define F_MULTIRANGE_AGG_FINALFN 6226 +#define F_RANGE_AGG_ANYMULTIRANGE 6227 +#define F_PG_STAT_HAVE_STATS 6230 +#define F_PG_STAT_GET_SUBSCRIPTION_STATS 6231 +#define F_PG_STAT_RESET_SUBSCRIPTION_STATS 6232 +#define F_WINDOW_ROW_NUMBER_SUPPORT 6233 +#define F_WINDOW_RANK_SUPPORT 6234 +#define F_WINDOW_DENSE_RANK_SUPPORT 6235 +#define F_INT8INC_SUPPORT 6236 +#define F_PG_SETTINGS_GET_FLAGS 6240 +#define F_PG_STOP_MAKING_PINNED_OBJECTS 6241 +#define F_TEXT_STARTS_WITH_SUPPORT 6242 +#define F_PG_STAT_GET_RECOVERY_PREFETCH 6248 +#define F_PG_DATABASE_COLLATION_ACTUAL_VERSION 6249 +#define F_PG_IDENT_FILE_MAPPINGS 6250 +#define F_REGEXP_REPLACE_TEXT_TEXT_TEXT_INT4_INT4_TEXT 6251 +#define F_REGEXP_REPLACE_TEXT_TEXT_TEXT_INT4_INT4 6252 +#define F_REGEXP_REPLACE_TEXT_TEXT_TEXT_INT4 6253 +#define F_REGEXP_COUNT_TEXT_TEXT 6254 +#define F_REGEXP_COUNT_TEXT_TEXT_INT4 6255 +#define F_REGEXP_COUNT_TEXT_TEXT_INT4_TEXT 6256 +#define F_REGEXP_INSTR_TEXT_TEXT 6257 +#define F_REGEXP_INSTR_TEXT_TEXT_INT4 6258 +#define F_REGEXP_INSTR_TEXT_TEXT_INT4_INT4 6259 +#define F_REGEXP_INSTR_TEXT_TEXT_INT4_INT4_INT4 6260 +#define F_REGEXP_INSTR_TEXT_TEXT_INT4_INT4_INT4_TEXT 6261 +#define F_REGEXP_INSTR_TEXT_TEXT_INT4_INT4_INT4_TEXT_INT4 6262 +#define F_REGEXP_LIKE_TEXT_TEXT 6263 +#define F_REGEXP_LIKE_TEXT_TEXT_TEXT 6264 +#define F_REGEXP_SUBSTR_TEXT_TEXT 6265 +#define F_REGEXP_SUBSTR_TEXT_TEXT_INT4 6266 +#define F_REGEXP_SUBSTR_TEXT_TEXT_INT4_INT4 6267 +#define F_REGEXP_SUBSTR_TEXT_TEXT_INT4_INT4_TEXT 6268 +#define F_REGEXP_SUBSTR_TEXT_TEXT_INT4_INT4_TEXT_INT4 6269 +#define F_PG_LS_LOGICALSNAPDIR 6270 +#define F_PG_LS_LOGICALMAPDIR 6271 +#define F_PG_LS_REPLSLOTDIR 6272 + +#endif /* FMGROIDS_H */ diff --git a/src/backend/utils/fmgrprotos.h b/src/backend/utils/fmgrprotos.h new file mode 100644 index 0000000..151e8dd --- /dev/null +++ b/src/backend/utils/fmgrprotos.h @@ -0,0 +1,2829 @@ +/*------------------------------------------------------------------------- + * + * fmgrprotos.h + * Prototypes for built-in functions. + * + * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * NOTES + * ****************************** + * *** DO NOT EDIT THIS FILE! *** + * ****************************** + * + * It has been GENERATED by src/backend/utils/Gen_fmgrtab.pl + * + *------------------------------------------------------------------------- + */ + +#ifndef FMGRPROTOS_H +#define FMGRPROTOS_H + +#include "fmgr.h" + +extern Datum heap_tableam_handler(PG_FUNCTION_ARGS); +extern Datum byteaout(PG_FUNCTION_ARGS); +extern Datum charout(PG_FUNCTION_ARGS); +extern Datum namein(PG_FUNCTION_ARGS); +extern Datum nameout(PG_FUNCTION_ARGS); +extern Datum int2in(PG_FUNCTION_ARGS); +extern Datum int2out(PG_FUNCTION_ARGS); +extern Datum int2vectorin(PG_FUNCTION_ARGS); +extern Datum int2vectorout(PG_FUNCTION_ARGS); +extern Datum int4in(PG_FUNCTION_ARGS); +extern Datum int4out(PG_FUNCTION_ARGS); +extern Datum regprocin(PG_FUNCTION_ARGS); +extern Datum regprocout(PG_FUNCTION_ARGS); +extern Datum textin(PG_FUNCTION_ARGS); +extern Datum textout(PG_FUNCTION_ARGS); +extern Datum tidin(PG_FUNCTION_ARGS); +extern Datum tidout(PG_FUNCTION_ARGS); +extern Datum xidin(PG_FUNCTION_ARGS); +extern Datum xidout(PG_FUNCTION_ARGS); +extern Datum cidin(PG_FUNCTION_ARGS); +extern Datum cidout(PG_FUNCTION_ARGS); +extern Datum oidvectorin(PG_FUNCTION_ARGS); +extern Datum oidvectorout(PG_FUNCTION_ARGS); +extern Datum boollt(PG_FUNCTION_ARGS); +extern Datum boolgt(PG_FUNCTION_ARGS); +extern Datum booleq(PG_FUNCTION_ARGS); +extern Datum chareq(PG_FUNCTION_ARGS); +extern Datum nameeq(PG_FUNCTION_ARGS); +extern Datum int2eq(PG_FUNCTION_ARGS); +extern Datum int2lt(PG_FUNCTION_ARGS); +extern Datum int4eq(PG_FUNCTION_ARGS); +extern Datum int4lt(PG_FUNCTION_ARGS); +extern Datum texteq(PG_FUNCTION_ARGS); +extern Datum xideq(PG_FUNCTION_ARGS); +extern Datum cideq(PG_FUNCTION_ARGS); +extern Datum charne(PG_FUNCTION_ARGS); +extern Datum charle(PG_FUNCTION_ARGS); +extern Datum chargt(PG_FUNCTION_ARGS); +extern Datum charge(PG_FUNCTION_ARGS); +extern Datum chartoi4(PG_FUNCTION_ARGS); +extern Datum i4tochar(PG_FUNCTION_ARGS); +extern Datum nameregexeq(PG_FUNCTION_ARGS); +extern Datum boolne(PG_FUNCTION_ARGS); +extern Datum pg_ddl_command_in(PG_FUNCTION_ARGS); +extern Datum pg_ddl_command_out(PG_FUNCTION_ARGS); +extern Datum pg_ddl_command_recv(PG_FUNCTION_ARGS); +extern Datum pgsql_version(PG_FUNCTION_ARGS); +extern Datum pg_ddl_command_send(PG_FUNCTION_ARGS); +extern Datum eqsel(PG_FUNCTION_ARGS); +extern Datum neqsel(PG_FUNCTION_ARGS); +extern Datum scalarltsel(PG_FUNCTION_ARGS); +extern Datum scalargtsel(PG_FUNCTION_ARGS); +extern Datum eqjoinsel(PG_FUNCTION_ARGS); +extern Datum neqjoinsel(PG_FUNCTION_ARGS); +extern Datum scalarltjoinsel(PG_FUNCTION_ARGS); +extern Datum scalargtjoinsel(PG_FUNCTION_ARGS); +extern Datum unknownin(PG_FUNCTION_ARGS); +extern Datum unknownout(PG_FUNCTION_ARGS); +extern Datum box_above_eq(PG_FUNCTION_ARGS); +extern Datum box_below_eq(PG_FUNCTION_ARGS); +extern Datum point_in(PG_FUNCTION_ARGS); +extern Datum point_out(PG_FUNCTION_ARGS); +extern Datum lseg_in(PG_FUNCTION_ARGS); +extern Datum lseg_out(PG_FUNCTION_ARGS); +extern Datum path_in(PG_FUNCTION_ARGS); +extern Datum path_out(PG_FUNCTION_ARGS); +extern Datum box_in(PG_FUNCTION_ARGS); +extern Datum box_out(PG_FUNCTION_ARGS); +extern Datum box_overlap(PG_FUNCTION_ARGS); +extern Datum box_ge(PG_FUNCTION_ARGS); +extern Datum box_gt(PG_FUNCTION_ARGS); +extern Datum box_eq(PG_FUNCTION_ARGS); +extern Datum box_lt(PG_FUNCTION_ARGS); +extern Datum box_le(PG_FUNCTION_ARGS); +extern Datum point_above(PG_FUNCTION_ARGS); +extern Datum point_left(PG_FUNCTION_ARGS); +extern Datum point_right(PG_FUNCTION_ARGS); +extern Datum point_below(PG_FUNCTION_ARGS); +extern Datum point_eq(PG_FUNCTION_ARGS); +extern Datum on_pb(PG_FUNCTION_ARGS); +extern Datum on_ppath(PG_FUNCTION_ARGS); +extern Datum box_center(PG_FUNCTION_ARGS); +extern Datum areasel(PG_FUNCTION_ARGS); +extern Datum areajoinsel(PG_FUNCTION_ARGS); +extern Datum int4mul(PG_FUNCTION_ARGS); +extern Datum int4ne(PG_FUNCTION_ARGS); +extern Datum int2ne(PG_FUNCTION_ARGS); +extern Datum int2gt(PG_FUNCTION_ARGS); +extern Datum int4gt(PG_FUNCTION_ARGS); +extern Datum int2le(PG_FUNCTION_ARGS); +extern Datum int4le(PG_FUNCTION_ARGS); +extern Datum int4ge(PG_FUNCTION_ARGS); +extern Datum int2ge(PG_FUNCTION_ARGS); +extern Datum int2mul(PG_FUNCTION_ARGS); +extern Datum int2div(PG_FUNCTION_ARGS); +extern Datum int4div(PG_FUNCTION_ARGS); +extern Datum int2mod(PG_FUNCTION_ARGS); +extern Datum int4mod(PG_FUNCTION_ARGS); +extern Datum textne(PG_FUNCTION_ARGS); +extern Datum int24eq(PG_FUNCTION_ARGS); +extern Datum int42eq(PG_FUNCTION_ARGS); +extern Datum int24lt(PG_FUNCTION_ARGS); +extern Datum int42lt(PG_FUNCTION_ARGS); +extern Datum int24gt(PG_FUNCTION_ARGS); +extern Datum int42gt(PG_FUNCTION_ARGS); +extern Datum int24ne(PG_FUNCTION_ARGS); +extern Datum int42ne(PG_FUNCTION_ARGS); +extern Datum int24le(PG_FUNCTION_ARGS); +extern Datum int42le(PG_FUNCTION_ARGS); +extern Datum int24ge(PG_FUNCTION_ARGS); +extern Datum int42ge(PG_FUNCTION_ARGS); +extern Datum int24mul(PG_FUNCTION_ARGS); +extern Datum int42mul(PG_FUNCTION_ARGS); +extern Datum int24div(PG_FUNCTION_ARGS); +extern Datum int42div(PG_FUNCTION_ARGS); +extern Datum int2pl(PG_FUNCTION_ARGS); +extern Datum int4pl(PG_FUNCTION_ARGS); +extern Datum int24pl(PG_FUNCTION_ARGS); +extern Datum int42pl(PG_FUNCTION_ARGS); +extern Datum int2mi(PG_FUNCTION_ARGS); +extern Datum int4mi(PG_FUNCTION_ARGS); +extern Datum int24mi(PG_FUNCTION_ARGS); +extern Datum int42mi(PG_FUNCTION_ARGS); +extern Datum oideq(PG_FUNCTION_ARGS); +extern Datum oidne(PG_FUNCTION_ARGS); +extern Datum box_same(PG_FUNCTION_ARGS); +extern Datum box_contain(PG_FUNCTION_ARGS); +extern Datum box_left(PG_FUNCTION_ARGS); +extern Datum box_overleft(PG_FUNCTION_ARGS); +extern Datum box_overright(PG_FUNCTION_ARGS); +extern Datum box_right(PG_FUNCTION_ARGS); +extern Datum box_contained(PG_FUNCTION_ARGS); +extern Datum box_contain_pt(PG_FUNCTION_ARGS); +extern Datum pg_node_tree_in(PG_FUNCTION_ARGS); +extern Datum pg_node_tree_out(PG_FUNCTION_ARGS); +extern Datum pg_node_tree_recv(PG_FUNCTION_ARGS); +extern Datum pg_node_tree_send(PG_FUNCTION_ARGS); +extern Datum float4in(PG_FUNCTION_ARGS); +extern Datum float4out(PG_FUNCTION_ARGS); +extern Datum float4mul(PG_FUNCTION_ARGS); +extern Datum float4div(PG_FUNCTION_ARGS); +extern Datum float4pl(PG_FUNCTION_ARGS); +extern Datum float4mi(PG_FUNCTION_ARGS); +extern Datum float4um(PG_FUNCTION_ARGS); +extern Datum float4abs(PG_FUNCTION_ARGS); +extern Datum float4_accum(PG_FUNCTION_ARGS); +extern Datum float4larger(PG_FUNCTION_ARGS); +extern Datum float4smaller(PG_FUNCTION_ARGS); +extern Datum int4um(PG_FUNCTION_ARGS); +extern Datum int2um(PG_FUNCTION_ARGS); +extern Datum float8in(PG_FUNCTION_ARGS); +extern Datum float8out(PG_FUNCTION_ARGS); +extern Datum float8mul(PG_FUNCTION_ARGS); +extern Datum float8div(PG_FUNCTION_ARGS); +extern Datum float8pl(PG_FUNCTION_ARGS); +extern Datum float8mi(PG_FUNCTION_ARGS); +extern Datum float8um(PG_FUNCTION_ARGS); +extern Datum float8abs(PG_FUNCTION_ARGS); +extern Datum float8_accum(PG_FUNCTION_ARGS); +extern Datum float8larger(PG_FUNCTION_ARGS); +extern Datum float8smaller(PG_FUNCTION_ARGS); +extern Datum lseg_center(PG_FUNCTION_ARGS); +extern Datum poly_center(PG_FUNCTION_ARGS); +extern Datum dround(PG_FUNCTION_ARGS); +extern Datum dtrunc(PG_FUNCTION_ARGS); +extern Datum dsqrt(PG_FUNCTION_ARGS); +extern Datum dcbrt(PG_FUNCTION_ARGS); +extern Datum dpow(PG_FUNCTION_ARGS); +extern Datum dexp(PG_FUNCTION_ARGS); +extern Datum dlog1(PG_FUNCTION_ARGS); +extern Datum i2tod(PG_FUNCTION_ARGS); +extern Datum i2tof(PG_FUNCTION_ARGS); +extern Datum dtoi2(PG_FUNCTION_ARGS); +extern Datum ftoi2(PG_FUNCTION_ARGS); +extern Datum line_distance(PG_FUNCTION_ARGS); +extern Datum nameeqtext(PG_FUNCTION_ARGS); +extern Datum namelttext(PG_FUNCTION_ARGS); +extern Datum nameletext(PG_FUNCTION_ARGS); +extern Datum namegetext(PG_FUNCTION_ARGS); +extern Datum namegttext(PG_FUNCTION_ARGS); +extern Datum namenetext(PG_FUNCTION_ARGS); +extern Datum btnametextcmp(PG_FUNCTION_ARGS); +extern Datum texteqname(PG_FUNCTION_ARGS); +extern Datum textltname(PG_FUNCTION_ARGS); +extern Datum textlename(PG_FUNCTION_ARGS); +extern Datum textgename(PG_FUNCTION_ARGS); +extern Datum textgtname(PG_FUNCTION_ARGS); +extern Datum textnename(PG_FUNCTION_ARGS); +extern Datum bttextnamecmp(PG_FUNCTION_ARGS); +extern Datum nameconcatoid(PG_FUNCTION_ARGS); +extern Datum table_am_handler_in(PG_FUNCTION_ARGS); +extern Datum table_am_handler_out(PG_FUNCTION_ARGS); +extern Datum timeofday(PG_FUNCTION_ARGS); +extern Datum pg_nextoid(PG_FUNCTION_ARGS); +extern Datum float8_combine(PG_FUNCTION_ARGS); +extern Datum inter_sl(PG_FUNCTION_ARGS); +extern Datum inter_lb(PG_FUNCTION_ARGS); +extern Datum float48mul(PG_FUNCTION_ARGS); +extern Datum float48div(PG_FUNCTION_ARGS); +extern Datum float48pl(PG_FUNCTION_ARGS); +extern Datum float48mi(PG_FUNCTION_ARGS); +extern Datum float84mul(PG_FUNCTION_ARGS); +extern Datum float84div(PG_FUNCTION_ARGS); +extern Datum float84pl(PG_FUNCTION_ARGS); +extern Datum float84mi(PG_FUNCTION_ARGS); +extern Datum float4eq(PG_FUNCTION_ARGS); +extern Datum float4ne(PG_FUNCTION_ARGS); +extern Datum float4lt(PG_FUNCTION_ARGS); +extern Datum float4le(PG_FUNCTION_ARGS); +extern Datum float4gt(PG_FUNCTION_ARGS); +extern Datum float4ge(PG_FUNCTION_ARGS); +extern Datum float8eq(PG_FUNCTION_ARGS); +extern Datum float8ne(PG_FUNCTION_ARGS); +extern Datum float8lt(PG_FUNCTION_ARGS); +extern Datum float8le(PG_FUNCTION_ARGS); +extern Datum float8gt(PG_FUNCTION_ARGS); +extern Datum float8ge(PG_FUNCTION_ARGS); +extern Datum float48eq(PG_FUNCTION_ARGS); +extern Datum float48ne(PG_FUNCTION_ARGS); +extern Datum float48lt(PG_FUNCTION_ARGS); +extern Datum float48le(PG_FUNCTION_ARGS); +extern Datum float48gt(PG_FUNCTION_ARGS); +extern Datum float48ge(PG_FUNCTION_ARGS); +extern Datum float84eq(PG_FUNCTION_ARGS); +extern Datum float84ne(PG_FUNCTION_ARGS); +extern Datum float84lt(PG_FUNCTION_ARGS); +extern Datum float84le(PG_FUNCTION_ARGS); +extern Datum float84gt(PG_FUNCTION_ARGS); +extern Datum float84ge(PG_FUNCTION_ARGS); +extern Datum ftod(PG_FUNCTION_ARGS); +extern Datum dtof(PG_FUNCTION_ARGS); +extern Datum i2toi4(PG_FUNCTION_ARGS); +extern Datum i4toi2(PG_FUNCTION_ARGS); +extern Datum pg_jit_available(PG_FUNCTION_ARGS); +extern Datum i4tod(PG_FUNCTION_ARGS); +extern Datum dtoi4(PG_FUNCTION_ARGS); +extern Datum i4tof(PG_FUNCTION_ARGS); +extern Datum ftoi4(PG_FUNCTION_ARGS); +extern Datum width_bucket_float8(PG_FUNCTION_ARGS); +extern Datum json_in(PG_FUNCTION_ARGS); +extern Datum json_out(PG_FUNCTION_ARGS); +extern Datum json_recv(PG_FUNCTION_ARGS); +extern Datum json_send(PG_FUNCTION_ARGS); +extern Datum index_am_handler_in(PG_FUNCTION_ARGS); +extern Datum index_am_handler_out(PG_FUNCTION_ARGS); +extern Datum hashmacaddr8(PG_FUNCTION_ARGS); +extern Datum hash_aclitem(PG_FUNCTION_ARGS); +extern Datum bthandler(PG_FUNCTION_ARGS); +extern Datum hashhandler(PG_FUNCTION_ARGS); +extern Datum gisthandler(PG_FUNCTION_ARGS); +extern Datum ginhandler(PG_FUNCTION_ARGS); +extern Datum spghandler(PG_FUNCTION_ARGS); +extern Datum brinhandler(PG_FUNCTION_ARGS); +extern Datum scalarlesel(PG_FUNCTION_ARGS); +extern Datum scalargesel(PG_FUNCTION_ARGS); +extern Datum amvalidate(PG_FUNCTION_ARGS); +extern Datum poly_same(PG_FUNCTION_ARGS); +extern Datum poly_contain(PG_FUNCTION_ARGS); +extern Datum poly_left(PG_FUNCTION_ARGS); +extern Datum poly_overleft(PG_FUNCTION_ARGS); +extern Datum poly_overright(PG_FUNCTION_ARGS); +extern Datum poly_right(PG_FUNCTION_ARGS); +extern Datum poly_contained(PG_FUNCTION_ARGS); +extern Datum poly_overlap(PG_FUNCTION_ARGS); +extern Datum poly_in(PG_FUNCTION_ARGS); +extern Datum poly_out(PG_FUNCTION_ARGS); +extern Datum btint2cmp(PG_FUNCTION_ARGS); +extern Datum btint4cmp(PG_FUNCTION_ARGS); +extern Datum btfloat4cmp(PG_FUNCTION_ARGS); +extern Datum btfloat8cmp(PG_FUNCTION_ARGS); +extern Datum btoidcmp(PG_FUNCTION_ARGS); +extern Datum dist_bp(PG_FUNCTION_ARGS); +extern Datum btcharcmp(PG_FUNCTION_ARGS); +extern Datum btnamecmp(PG_FUNCTION_ARGS); +extern Datum bttextcmp(PG_FUNCTION_ARGS); +extern Datum lseg_distance(PG_FUNCTION_ARGS); +extern Datum lseg_interpt(PG_FUNCTION_ARGS); +extern Datum dist_ps(PG_FUNCTION_ARGS); +extern Datum dist_pb(PG_FUNCTION_ARGS); +extern Datum dist_sb(PG_FUNCTION_ARGS); +extern Datum close_ps(PG_FUNCTION_ARGS); +extern Datum close_pb(PG_FUNCTION_ARGS); +extern Datum close_sb(PG_FUNCTION_ARGS); +extern Datum on_ps(PG_FUNCTION_ARGS); +extern Datum path_distance(PG_FUNCTION_ARGS); +extern Datum dist_ppath(PG_FUNCTION_ARGS); +extern Datum on_sb(PG_FUNCTION_ARGS); +extern Datum inter_sb(PG_FUNCTION_ARGS); +extern Datum text_to_array_null(PG_FUNCTION_ARGS); +extern Datum cash_cmp(PG_FUNCTION_ARGS); +extern Datum array_append(PG_FUNCTION_ARGS); +extern Datum array_prepend(PG_FUNCTION_ARGS); +extern Datum dist_sp(PG_FUNCTION_ARGS); +extern Datum dist_bs(PG_FUNCTION_ARGS); +extern Datum btarraycmp(PG_FUNCTION_ARGS); +extern Datum array_cat(PG_FUNCTION_ARGS); +extern Datum array_to_text_null(PG_FUNCTION_ARGS); +extern Datum scalarlejoinsel(PG_FUNCTION_ARGS); +extern Datum array_ne(PG_FUNCTION_ARGS); +extern Datum array_lt(PG_FUNCTION_ARGS); +extern Datum array_gt(PG_FUNCTION_ARGS); +extern Datum array_le(PG_FUNCTION_ARGS); +extern Datum text_to_array(PG_FUNCTION_ARGS); +extern Datum array_to_text(PG_FUNCTION_ARGS); +extern Datum array_ge(PG_FUNCTION_ARGS); +extern Datum scalargejoinsel(PG_FUNCTION_ARGS); +extern Datum hashmacaddr(PG_FUNCTION_ARGS); +extern Datum hashtext(PG_FUNCTION_ARGS); +extern Datum rtrim1(PG_FUNCTION_ARGS); +extern Datum btoidvectorcmp(PG_FUNCTION_ARGS); +extern Datum name_text(PG_FUNCTION_ARGS); +extern Datum text_name(PG_FUNCTION_ARGS); +extern Datum name_bpchar(PG_FUNCTION_ARGS); +extern Datum bpchar_name(PG_FUNCTION_ARGS); +extern Datum dist_pathp(PG_FUNCTION_ARGS); +extern Datum hashinet(PG_FUNCTION_ARGS); +extern Datum hashint4extended(PG_FUNCTION_ARGS); +extern Datum hash_numeric(PG_FUNCTION_ARGS); +extern Datum macaddr_in(PG_FUNCTION_ARGS); +extern Datum macaddr_out(PG_FUNCTION_ARGS); +extern Datum pg_num_nulls(PG_FUNCTION_ARGS); +extern Datum pg_num_nonnulls(PG_FUNCTION_ARGS); +extern Datum hashint2extended(PG_FUNCTION_ARGS); +extern Datum hashint8extended(PG_FUNCTION_ARGS); +extern Datum hashfloat4extended(PG_FUNCTION_ARGS); +extern Datum hashfloat8extended(PG_FUNCTION_ARGS); +extern Datum hashoidextended(PG_FUNCTION_ARGS); +extern Datum hashcharextended(PG_FUNCTION_ARGS); +extern Datum hashnameextended(PG_FUNCTION_ARGS); +extern Datum hashtextextended(PG_FUNCTION_ARGS); +extern Datum hashint2(PG_FUNCTION_ARGS); +extern Datum hashint4(PG_FUNCTION_ARGS); +extern Datum hashfloat4(PG_FUNCTION_ARGS); +extern Datum hashfloat8(PG_FUNCTION_ARGS); +extern Datum hashoid(PG_FUNCTION_ARGS); +extern Datum hashchar(PG_FUNCTION_ARGS); +extern Datum hashname(PG_FUNCTION_ARGS); +extern Datum hashvarlena(PG_FUNCTION_ARGS); +extern Datum hashoidvector(PG_FUNCTION_ARGS); +extern Datum text_larger(PG_FUNCTION_ARGS); +extern Datum text_smaller(PG_FUNCTION_ARGS); +extern Datum int8in(PG_FUNCTION_ARGS); +extern Datum int8out(PG_FUNCTION_ARGS); +extern Datum int8um(PG_FUNCTION_ARGS); +extern Datum int8pl(PG_FUNCTION_ARGS); +extern Datum int8mi(PG_FUNCTION_ARGS); +extern Datum int8mul(PG_FUNCTION_ARGS); +extern Datum int8div(PG_FUNCTION_ARGS); +extern Datum int8eq(PG_FUNCTION_ARGS); +extern Datum int8ne(PG_FUNCTION_ARGS); +extern Datum int8lt(PG_FUNCTION_ARGS); +extern Datum int8gt(PG_FUNCTION_ARGS); +extern Datum int8le(PG_FUNCTION_ARGS); +extern Datum int8ge(PG_FUNCTION_ARGS); +extern Datum int84eq(PG_FUNCTION_ARGS); +extern Datum int84ne(PG_FUNCTION_ARGS); +extern Datum int84lt(PG_FUNCTION_ARGS); +extern Datum int84gt(PG_FUNCTION_ARGS); +extern Datum int84le(PG_FUNCTION_ARGS); +extern Datum int84ge(PG_FUNCTION_ARGS); +extern Datum int84(PG_FUNCTION_ARGS); +extern Datum int48(PG_FUNCTION_ARGS); +extern Datum i8tod(PG_FUNCTION_ARGS); +extern Datum dtoi8(PG_FUNCTION_ARGS); +extern Datum array_larger(PG_FUNCTION_ARGS); +extern Datum array_smaller(PG_FUNCTION_ARGS); +extern Datum inet_abbrev(PG_FUNCTION_ARGS); +extern Datum cidr_abbrev(PG_FUNCTION_ARGS); +extern Datum inet_set_masklen(PG_FUNCTION_ARGS); +extern Datum oidvectorne(PG_FUNCTION_ARGS); +extern Datum hash_array(PG_FUNCTION_ARGS); +extern Datum cidr_set_masklen(PG_FUNCTION_ARGS); +extern Datum pg_indexam_has_property(PG_FUNCTION_ARGS); +extern Datum pg_index_has_property(PG_FUNCTION_ARGS); +extern Datum pg_index_column_has_property(PG_FUNCTION_ARGS); +extern Datum i8tof(PG_FUNCTION_ARGS); +extern Datum ftoi8(PG_FUNCTION_ARGS); +extern Datum namelt(PG_FUNCTION_ARGS); +extern Datum namele(PG_FUNCTION_ARGS); +extern Datum namegt(PG_FUNCTION_ARGS); +extern Datum namege(PG_FUNCTION_ARGS); +extern Datum namene(PG_FUNCTION_ARGS); +extern Datum bpchar(PG_FUNCTION_ARGS); +extern Datum varchar(PG_FUNCTION_ARGS); +extern Datum pg_indexam_progress_phasename(PG_FUNCTION_ARGS); +extern Datum oidvectorlt(PG_FUNCTION_ARGS); +extern Datum oidvectorle(PG_FUNCTION_ARGS); +extern Datum oidvectoreq(PG_FUNCTION_ARGS); +extern Datum oidvectorge(PG_FUNCTION_ARGS); +extern Datum oidvectorgt(PG_FUNCTION_ARGS); +extern Datum network_network(PG_FUNCTION_ARGS); +extern Datum network_netmask(PG_FUNCTION_ARGS); +extern Datum network_masklen(PG_FUNCTION_ARGS); +extern Datum network_broadcast(PG_FUNCTION_ARGS); +extern Datum network_host(PG_FUNCTION_ARGS); +extern Datum dist_lp(PG_FUNCTION_ARGS); +extern Datum dist_ls(PG_FUNCTION_ARGS); +extern Datum current_user(PG_FUNCTION_ARGS); +extern Datum network_family(PG_FUNCTION_ARGS); +extern Datum int82(PG_FUNCTION_ARGS); +extern Datum be_lo_create(PG_FUNCTION_ARGS); +extern Datum oidlt(PG_FUNCTION_ARGS); +extern Datum oidle(PG_FUNCTION_ARGS); +extern Datum byteaoctetlen(PG_FUNCTION_ARGS); +extern Datum byteaGetByte(PG_FUNCTION_ARGS); +extern Datum byteaSetByte(PG_FUNCTION_ARGS); +extern Datum byteaGetBit(PG_FUNCTION_ARGS); +extern Datum byteaSetBit(PG_FUNCTION_ARGS); +extern Datum dist_pl(PG_FUNCTION_ARGS); +extern Datum dist_sl(PG_FUNCTION_ARGS); +extern Datum dist_cpoly(PG_FUNCTION_ARGS); +extern Datum poly_distance(PG_FUNCTION_ARGS); +extern Datum network_show(PG_FUNCTION_ARGS); +extern Datum text_lt(PG_FUNCTION_ARGS); +extern Datum text_le(PG_FUNCTION_ARGS); +extern Datum text_gt(PG_FUNCTION_ARGS); +extern Datum text_ge(PG_FUNCTION_ARGS); +extern Datum array_eq(PG_FUNCTION_ARGS); +extern Datum session_user(PG_FUNCTION_ARGS); +extern Datum array_dims(PG_FUNCTION_ARGS); +extern Datum array_ndims(PG_FUNCTION_ARGS); +extern Datum byteaoverlay(PG_FUNCTION_ARGS); +extern Datum array_in(PG_FUNCTION_ARGS); +extern Datum array_out(PG_FUNCTION_ARGS); +extern Datum byteaoverlay_no_len(PG_FUNCTION_ARGS); +extern Datum macaddr_trunc(PG_FUNCTION_ARGS); +extern Datum int28(PG_FUNCTION_ARGS); +extern Datum be_lo_import(PG_FUNCTION_ARGS); +extern Datum be_lo_export(PG_FUNCTION_ARGS); +extern Datum int4inc(PG_FUNCTION_ARGS); +extern Datum be_lo_import_with_oid(PG_FUNCTION_ARGS); +extern Datum int4larger(PG_FUNCTION_ARGS); +extern Datum int4smaller(PG_FUNCTION_ARGS); +extern Datum int2larger(PG_FUNCTION_ARGS); +extern Datum int2smaller(PG_FUNCTION_ARGS); +extern Datum hashvarlenaextended(PG_FUNCTION_ARGS); +extern Datum hashoidvectorextended(PG_FUNCTION_ARGS); +extern Datum hash_aclitem_extended(PG_FUNCTION_ARGS); +extern Datum hashmacaddrextended(PG_FUNCTION_ARGS); +extern Datum hashinetextended(PG_FUNCTION_ARGS); +extern Datum hash_numeric_extended(PG_FUNCTION_ARGS); +extern Datum hashmacaddr8extended(PG_FUNCTION_ARGS); +extern Datum hash_array_extended(PG_FUNCTION_ARGS); +extern Datum dist_polyc(PG_FUNCTION_ARGS); +extern Datum pg_client_encoding(PG_FUNCTION_ARGS); +extern Datum current_query(PG_FUNCTION_ARGS); +extern Datum macaddr_eq(PG_FUNCTION_ARGS); +extern Datum macaddr_lt(PG_FUNCTION_ARGS); +extern Datum macaddr_le(PG_FUNCTION_ARGS); +extern Datum macaddr_gt(PG_FUNCTION_ARGS); +extern Datum macaddr_ge(PG_FUNCTION_ARGS); +extern Datum macaddr_ne(PG_FUNCTION_ARGS); +extern Datum macaddr_cmp(PG_FUNCTION_ARGS); +extern Datum int82pl(PG_FUNCTION_ARGS); +extern Datum int82mi(PG_FUNCTION_ARGS); +extern Datum int82mul(PG_FUNCTION_ARGS); +extern Datum int82div(PG_FUNCTION_ARGS); +extern Datum int28pl(PG_FUNCTION_ARGS); +extern Datum btint8cmp(PG_FUNCTION_ARGS); +extern Datum cash_mul_flt4(PG_FUNCTION_ARGS); +extern Datum cash_div_flt4(PG_FUNCTION_ARGS); +extern Datum flt4_mul_cash(PG_FUNCTION_ARGS); +extern Datum textpos(PG_FUNCTION_ARGS); +extern Datum textlike(PG_FUNCTION_ARGS); +extern Datum textnlike(PG_FUNCTION_ARGS); +extern Datum int48eq(PG_FUNCTION_ARGS); +extern Datum int48ne(PG_FUNCTION_ARGS); +extern Datum int48lt(PG_FUNCTION_ARGS); +extern Datum int48gt(PG_FUNCTION_ARGS); +extern Datum int48le(PG_FUNCTION_ARGS); +extern Datum int48ge(PG_FUNCTION_ARGS); +extern Datum namelike(PG_FUNCTION_ARGS); +extern Datum namenlike(PG_FUNCTION_ARGS); +extern Datum char_bpchar(PG_FUNCTION_ARGS); +extern Datum current_database(PG_FUNCTION_ARGS); +extern Datum int4_mul_cash(PG_FUNCTION_ARGS); +extern Datum int2_mul_cash(PG_FUNCTION_ARGS); +extern Datum cash_mul_int4(PG_FUNCTION_ARGS); +extern Datum cash_div_int4(PG_FUNCTION_ARGS); +extern Datum cash_mul_int2(PG_FUNCTION_ARGS); +extern Datum cash_div_int2(PG_FUNCTION_ARGS); +extern Datum lower(PG_FUNCTION_ARGS); +extern Datum upper(PG_FUNCTION_ARGS); +extern Datum initcap(PG_FUNCTION_ARGS); +extern Datum lpad(PG_FUNCTION_ARGS); +extern Datum rpad(PG_FUNCTION_ARGS); +extern Datum ltrim(PG_FUNCTION_ARGS); +extern Datum rtrim(PG_FUNCTION_ARGS); +extern Datum text_substr(PG_FUNCTION_ARGS); +extern Datum translate(PG_FUNCTION_ARGS); +extern Datum ltrim1(PG_FUNCTION_ARGS); +extern Datum text_substr_no_len(PG_FUNCTION_ARGS); +extern Datum btrim(PG_FUNCTION_ARGS); +extern Datum btrim1(PG_FUNCTION_ARGS); +extern Datum cash_in(PG_FUNCTION_ARGS); +extern Datum cash_out(PG_FUNCTION_ARGS); +extern Datum cash_eq(PG_FUNCTION_ARGS); +extern Datum cash_ne(PG_FUNCTION_ARGS); +extern Datum cash_lt(PG_FUNCTION_ARGS); +extern Datum cash_le(PG_FUNCTION_ARGS); +extern Datum cash_gt(PG_FUNCTION_ARGS); +extern Datum cash_ge(PG_FUNCTION_ARGS); +extern Datum cash_pl(PG_FUNCTION_ARGS); +extern Datum cash_mi(PG_FUNCTION_ARGS); +extern Datum cash_mul_flt8(PG_FUNCTION_ARGS); +extern Datum cash_div_flt8(PG_FUNCTION_ARGS); +extern Datum cashlarger(PG_FUNCTION_ARGS); +extern Datum cashsmaller(PG_FUNCTION_ARGS); +extern Datum inet_in(PG_FUNCTION_ARGS); +extern Datum inet_out(PG_FUNCTION_ARGS); +extern Datum flt8_mul_cash(PG_FUNCTION_ARGS); +extern Datum network_eq(PG_FUNCTION_ARGS); +extern Datum network_lt(PG_FUNCTION_ARGS); +extern Datum network_le(PG_FUNCTION_ARGS); +extern Datum network_gt(PG_FUNCTION_ARGS); +extern Datum network_ge(PG_FUNCTION_ARGS); +extern Datum network_ne(PG_FUNCTION_ARGS); +extern Datum network_cmp(PG_FUNCTION_ARGS); +extern Datum network_sub(PG_FUNCTION_ARGS); +extern Datum network_subeq(PG_FUNCTION_ARGS); +extern Datum network_sup(PG_FUNCTION_ARGS); +extern Datum network_supeq(PG_FUNCTION_ARGS); +extern Datum cash_words(PG_FUNCTION_ARGS); +extern Datum generate_series_timestamp(PG_FUNCTION_ARGS); +extern Datum generate_series_timestamptz(PG_FUNCTION_ARGS); +extern Datum int28mi(PG_FUNCTION_ARGS); +extern Datum int28mul(PG_FUNCTION_ARGS); +extern Datum text_char(PG_FUNCTION_ARGS); +extern Datum int8mod(PG_FUNCTION_ARGS); +extern Datum char_text(PG_FUNCTION_ARGS); +extern Datum int28div(PG_FUNCTION_ARGS); +extern Datum hashint8(PG_FUNCTION_ARGS); +extern Datum be_lo_open(PG_FUNCTION_ARGS); +extern Datum be_lo_close(PG_FUNCTION_ARGS); +extern Datum be_loread(PG_FUNCTION_ARGS); +extern Datum be_lowrite(PG_FUNCTION_ARGS); +extern Datum be_lo_lseek(PG_FUNCTION_ARGS); +extern Datum be_lo_creat(PG_FUNCTION_ARGS); +extern Datum be_lo_tell(PG_FUNCTION_ARGS); +extern Datum on_pl(PG_FUNCTION_ARGS); +extern Datum on_sl(PG_FUNCTION_ARGS); +extern Datum close_pl(PG_FUNCTION_ARGS); +extern Datum be_lo_unlink(PG_FUNCTION_ARGS); +extern Datum hashbpcharextended(PG_FUNCTION_ARGS); +extern Datum path_inter(PG_FUNCTION_ARGS); +extern Datum box_area(PG_FUNCTION_ARGS); +extern Datum box_width(PG_FUNCTION_ARGS); +extern Datum box_height(PG_FUNCTION_ARGS); +extern Datum box_distance(PG_FUNCTION_ARGS); +extern Datum path_area(PG_FUNCTION_ARGS); +extern Datum box_intersect(PG_FUNCTION_ARGS); +extern Datum box_diagonal(PG_FUNCTION_ARGS); +extern Datum path_n_lt(PG_FUNCTION_ARGS); +extern Datum path_n_gt(PG_FUNCTION_ARGS); +extern Datum path_n_eq(PG_FUNCTION_ARGS); +extern Datum path_n_le(PG_FUNCTION_ARGS); +extern Datum path_n_ge(PG_FUNCTION_ARGS); +extern Datum path_length(PG_FUNCTION_ARGS); +extern Datum point_ne(PG_FUNCTION_ARGS); +extern Datum point_vert(PG_FUNCTION_ARGS); +extern Datum point_horiz(PG_FUNCTION_ARGS); +extern Datum point_distance(PG_FUNCTION_ARGS); +extern Datum point_slope(PG_FUNCTION_ARGS); +extern Datum lseg_construct(PG_FUNCTION_ARGS); +extern Datum lseg_intersect(PG_FUNCTION_ARGS); +extern Datum lseg_parallel(PG_FUNCTION_ARGS); +extern Datum lseg_perp(PG_FUNCTION_ARGS); +extern Datum lseg_vertical(PG_FUNCTION_ARGS); +extern Datum lseg_horizontal(PG_FUNCTION_ARGS); +extern Datum lseg_eq(PG_FUNCTION_ARGS); +extern Datum be_lo_truncate(PG_FUNCTION_ARGS); +extern Datum textlike_support(PG_FUNCTION_ARGS); +extern Datum texticregexeq_support(PG_FUNCTION_ARGS); +extern Datum texticlike_support(PG_FUNCTION_ARGS); +extern Datum timestamptz_izone(PG_FUNCTION_ARGS); +extern Datum gist_point_compress(PG_FUNCTION_ARGS); +extern Datum aclitemin(PG_FUNCTION_ARGS); +extern Datum aclitemout(PG_FUNCTION_ARGS); +extern Datum aclinsert(PG_FUNCTION_ARGS); +extern Datum aclremove(PG_FUNCTION_ARGS); +extern Datum aclcontains(PG_FUNCTION_ARGS); +extern Datum getdatabaseencoding(PG_FUNCTION_ARGS); +extern Datum bpcharin(PG_FUNCTION_ARGS); +extern Datum bpcharout(PG_FUNCTION_ARGS); +extern Datum varcharin(PG_FUNCTION_ARGS); +extern Datum varcharout(PG_FUNCTION_ARGS); +extern Datum bpchareq(PG_FUNCTION_ARGS); +extern Datum bpcharlt(PG_FUNCTION_ARGS); +extern Datum bpcharle(PG_FUNCTION_ARGS); +extern Datum bpchargt(PG_FUNCTION_ARGS); +extern Datum bpcharge(PG_FUNCTION_ARGS); +extern Datum bpcharne(PG_FUNCTION_ARGS); +extern Datum aclitem_eq(PG_FUNCTION_ARGS); +extern Datum bpchar_larger(PG_FUNCTION_ARGS); +extern Datum bpchar_smaller(PG_FUNCTION_ARGS); +extern Datum pg_prepared_xact(PG_FUNCTION_ARGS); +extern Datum generate_series_step_int4(PG_FUNCTION_ARGS); +extern Datum generate_series_int4(PG_FUNCTION_ARGS); +extern Datum generate_series_step_int8(PG_FUNCTION_ARGS); +extern Datum generate_series_int8(PG_FUNCTION_ARGS); +extern Datum bpcharcmp(PG_FUNCTION_ARGS); +extern Datum text_regclass(PG_FUNCTION_ARGS); +extern Datum hashbpchar(PG_FUNCTION_ARGS); +extern Datum format_type(PG_FUNCTION_ARGS); +extern Datum date_in(PG_FUNCTION_ARGS); +extern Datum date_out(PG_FUNCTION_ARGS); +extern Datum date_eq(PG_FUNCTION_ARGS); +extern Datum date_lt(PG_FUNCTION_ARGS); +extern Datum date_le(PG_FUNCTION_ARGS); +extern Datum date_gt(PG_FUNCTION_ARGS); +extern Datum date_ge(PG_FUNCTION_ARGS); +extern Datum date_ne(PG_FUNCTION_ARGS); +extern Datum date_cmp(PG_FUNCTION_ARGS); +extern Datum time_lt(PG_FUNCTION_ARGS); +extern Datum time_le(PG_FUNCTION_ARGS); +extern Datum time_gt(PG_FUNCTION_ARGS); +extern Datum time_ge(PG_FUNCTION_ARGS); +extern Datum time_ne(PG_FUNCTION_ARGS); +extern Datum time_cmp(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_wal(PG_FUNCTION_ARGS); +extern Datum pg_get_wal_replay_pause_state(PG_FUNCTION_ARGS); +extern Datum date_larger(PG_FUNCTION_ARGS); +extern Datum date_smaller(PG_FUNCTION_ARGS); +extern Datum date_mi(PG_FUNCTION_ARGS); +extern Datum date_pli(PG_FUNCTION_ARGS); +extern Datum date_mii(PG_FUNCTION_ARGS); +extern Datum time_in(PG_FUNCTION_ARGS); +extern Datum time_out(PG_FUNCTION_ARGS); +extern Datum time_eq(PG_FUNCTION_ARGS); +extern Datum circle_add_pt(PG_FUNCTION_ARGS); +extern Datum circle_sub_pt(PG_FUNCTION_ARGS); +extern Datum circle_mul_pt(PG_FUNCTION_ARGS); +extern Datum circle_div_pt(PG_FUNCTION_ARGS); +extern Datum timestamptz_in(PG_FUNCTION_ARGS); +extern Datum timestamptz_out(PG_FUNCTION_ARGS); +extern Datum timestamp_eq(PG_FUNCTION_ARGS); +extern Datum timestamp_ne(PG_FUNCTION_ARGS); +extern Datum timestamp_lt(PG_FUNCTION_ARGS); +extern Datum timestamp_le(PG_FUNCTION_ARGS); +extern Datum timestamp_ge(PG_FUNCTION_ARGS); +extern Datum timestamp_gt(PG_FUNCTION_ARGS); +extern Datum float8_timestamptz(PG_FUNCTION_ARGS); +extern Datum timestamptz_zone(PG_FUNCTION_ARGS); +extern Datum interval_in(PG_FUNCTION_ARGS); +extern Datum interval_out(PG_FUNCTION_ARGS); +extern Datum interval_eq(PG_FUNCTION_ARGS); +extern Datum interval_ne(PG_FUNCTION_ARGS); +extern Datum interval_lt(PG_FUNCTION_ARGS); +extern Datum interval_le(PG_FUNCTION_ARGS); +extern Datum interval_ge(PG_FUNCTION_ARGS); +extern Datum interval_gt(PG_FUNCTION_ARGS); +extern Datum interval_um(PG_FUNCTION_ARGS); +extern Datum interval_pl(PG_FUNCTION_ARGS); +extern Datum interval_mi(PG_FUNCTION_ARGS); +extern Datum timestamptz_part(PG_FUNCTION_ARGS); +extern Datum interval_part(PG_FUNCTION_ARGS); +extern Datum network_subset_support(PG_FUNCTION_ARGS); +extern Datum date_timestamptz(PG_FUNCTION_ARGS); +extern Datum interval_justify_hours(PG_FUNCTION_ARGS); +extern Datum jsonb_path_exists_tz(PG_FUNCTION_ARGS); +extern Datum timestamptz_date(PG_FUNCTION_ARGS); +extern Datum jsonb_path_query_tz(PG_FUNCTION_ARGS); +extern Datum jsonb_path_query_array_tz(PG_FUNCTION_ARGS); +extern Datum xid_age(PG_FUNCTION_ARGS); +extern Datum timestamp_mi(PG_FUNCTION_ARGS); +extern Datum timestamptz_pl_interval(PG_FUNCTION_ARGS); +extern Datum timestamptz_mi_interval(PG_FUNCTION_ARGS); +extern Datum generate_subscripts(PG_FUNCTION_ARGS); +extern Datum generate_subscripts_nodir(PG_FUNCTION_ARGS); +extern Datum array_fill(PG_FUNCTION_ARGS); +extern Datum dlog10(PG_FUNCTION_ARGS); +extern Datum timestamp_smaller(PG_FUNCTION_ARGS); +extern Datum timestamp_larger(PG_FUNCTION_ARGS); +extern Datum interval_smaller(PG_FUNCTION_ARGS); +extern Datum interval_larger(PG_FUNCTION_ARGS); +extern Datum timestamptz_age(PG_FUNCTION_ARGS); +extern Datum interval_scale(PG_FUNCTION_ARGS); +extern Datum timestamptz_trunc(PG_FUNCTION_ARGS); +extern Datum interval_trunc(PG_FUNCTION_ARGS); +extern Datum int8inc(PG_FUNCTION_ARGS); +extern Datum int8abs(PG_FUNCTION_ARGS); +extern Datum int8larger(PG_FUNCTION_ARGS); +extern Datum int8smaller(PG_FUNCTION_ARGS); +extern Datum texticregexeq(PG_FUNCTION_ARGS); +extern Datum texticregexne(PG_FUNCTION_ARGS); +extern Datum nameicregexeq(PG_FUNCTION_ARGS); +extern Datum nameicregexne(PG_FUNCTION_ARGS); +extern Datum boolin(PG_FUNCTION_ARGS); +extern Datum boolout(PG_FUNCTION_ARGS); +extern Datum byteain(PG_FUNCTION_ARGS); +extern Datum charin(PG_FUNCTION_ARGS); +extern Datum charlt(PG_FUNCTION_ARGS); +extern Datum unique_key_recheck(PG_FUNCTION_ARGS); +extern Datum int4abs(PG_FUNCTION_ARGS); +extern Datum nameregexne(PG_FUNCTION_ARGS); +extern Datum int2abs(PG_FUNCTION_ARGS); +extern Datum textregexeq(PG_FUNCTION_ARGS); +extern Datum textregexne(PG_FUNCTION_ARGS); +extern Datum textlen(PG_FUNCTION_ARGS); +extern Datum textcat(PG_FUNCTION_ARGS); +extern Datum PG_char_to_encoding(PG_FUNCTION_ARGS); +extern Datum tidne(PG_FUNCTION_ARGS); +extern Datum cidr_in(PG_FUNCTION_ARGS); +extern Datum parse_ident(PG_FUNCTION_ARGS); +extern Datum pg_column_size(PG_FUNCTION_ARGS); +extern Datum overlaps_timetz(PG_FUNCTION_ARGS); +extern Datum datetime_timestamp(PG_FUNCTION_ARGS); +extern Datum timetz_part(PG_FUNCTION_ARGS); +extern Datum int84pl(PG_FUNCTION_ARGS); +extern Datum int84mi(PG_FUNCTION_ARGS); +extern Datum int84mul(PG_FUNCTION_ARGS); +extern Datum int84div(PG_FUNCTION_ARGS); +extern Datum int48pl(PG_FUNCTION_ARGS); +extern Datum int48mi(PG_FUNCTION_ARGS); +extern Datum int48mul(PG_FUNCTION_ARGS); +extern Datum int48div(PG_FUNCTION_ARGS); +extern Datum quote_ident(PG_FUNCTION_ARGS); +extern Datum quote_literal(PG_FUNCTION_ARGS); +extern Datum timestamptz_trunc_zone(PG_FUNCTION_ARGS); +extern Datum array_fill_with_lower_bounds(PG_FUNCTION_ARGS); +extern Datum i8tooid(PG_FUNCTION_ARGS); +extern Datum oidtoi8(PG_FUNCTION_ARGS); +extern Datum quote_nullable(PG_FUNCTION_ARGS); +extern Datum suppress_redundant_updates_trigger(PG_FUNCTION_ARGS); +extern Datum tideq(PG_FUNCTION_ARGS); +extern Datum multirange_unnest(PG_FUNCTION_ARGS); +extern Datum currtid_byrelname(PG_FUNCTION_ARGS); +extern Datum interval_justify_days(PG_FUNCTION_ARGS); +extern Datum datetimetz_timestamptz(PG_FUNCTION_ARGS); +extern Datum now(PG_FUNCTION_ARGS); +extern Datum positionsel(PG_FUNCTION_ARGS); +extern Datum positionjoinsel(PG_FUNCTION_ARGS); +extern Datum contsel(PG_FUNCTION_ARGS); +extern Datum contjoinsel(PG_FUNCTION_ARGS); +extern Datum overlaps_timestamp(PG_FUNCTION_ARGS); +extern Datum overlaps_time(PG_FUNCTION_ARGS); +extern Datum timestamp_in(PG_FUNCTION_ARGS); +extern Datum timestamp_out(PG_FUNCTION_ARGS); +extern Datum timestamp_cmp(PG_FUNCTION_ARGS); +extern Datum interval_cmp(PG_FUNCTION_ARGS); +extern Datum timestamp_time(PG_FUNCTION_ARGS); +extern Datum bpcharlen(PG_FUNCTION_ARGS); +extern Datum interval_div(PG_FUNCTION_ARGS); +extern Datum oidvectortypes(PG_FUNCTION_ARGS); +extern Datum timetz_in(PG_FUNCTION_ARGS); +extern Datum timetz_out(PG_FUNCTION_ARGS); +extern Datum timetz_eq(PG_FUNCTION_ARGS); +extern Datum timetz_ne(PG_FUNCTION_ARGS); +extern Datum timetz_lt(PG_FUNCTION_ARGS); +extern Datum timetz_le(PG_FUNCTION_ARGS); +extern Datum timetz_ge(PG_FUNCTION_ARGS); +extern Datum timetz_gt(PG_FUNCTION_ARGS); +extern Datum timetz_cmp(PG_FUNCTION_ARGS); +extern Datum network_hostmask(PG_FUNCTION_ARGS); +extern Datum textregexeq_support(PG_FUNCTION_ARGS); +extern Datum makeaclitem(PG_FUNCTION_ARGS); +extern Datum time_interval(PG_FUNCTION_ARGS); +extern Datum pg_lock_status(PG_FUNCTION_ARGS); +extern Datum date_finite(PG_FUNCTION_ARGS); +extern Datum textoctetlen(PG_FUNCTION_ARGS); +extern Datum bpcharoctetlen(PG_FUNCTION_ARGS); +extern Datum numeric_fac(PG_FUNCTION_ARGS); +extern Datum time_larger(PG_FUNCTION_ARGS); +extern Datum time_smaller(PG_FUNCTION_ARGS); +extern Datum timetz_larger(PG_FUNCTION_ARGS); +extern Datum timetz_smaller(PG_FUNCTION_ARGS); +extern Datum time_part(PG_FUNCTION_ARGS); +extern Datum pg_get_constraintdef(PG_FUNCTION_ARGS); +extern Datum timestamptz_timetz(PG_FUNCTION_ARGS); +extern Datum timestamp_finite(PG_FUNCTION_ARGS); +extern Datum interval_finite(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_backend_start(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_backend_client_addr(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_backend_client_port(PG_FUNCTION_ARGS); +extern Datum current_schema(PG_FUNCTION_ARGS); +extern Datum current_schemas(PG_FUNCTION_ARGS); +extern Datum textoverlay(PG_FUNCTION_ARGS); +extern Datum textoverlay_no_len(PG_FUNCTION_ARGS); +extern Datum line_parallel(PG_FUNCTION_ARGS); +extern Datum line_perp(PG_FUNCTION_ARGS); +extern Datum line_vertical(PG_FUNCTION_ARGS); +extern Datum line_horizontal(PG_FUNCTION_ARGS); +extern Datum circle_center(PG_FUNCTION_ARGS); +extern Datum interval_time(PG_FUNCTION_ARGS); +extern Datum points_box(PG_FUNCTION_ARGS); +extern Datum box_add(PG_FUNCTION_ARGS); +extern Datum box_sub(PG_FUNCTION_ARGS); +extern Datum box_mul(PG_FUNCTION_ARGS); +extern Datum box_div(PG_FUNCTION_ARGS); +extern Datum cidr_out(PG_FUNCTION_ARGS); +extern Datum poly_contain_pt(PG_FUNCTION_ARGS); +extern Datum pt_contained_poly(PG_FUNCTION_ARGS); +extern Datum path_isclosed(PG_FUNCTION_ARGS); +extern Datum path_isopen(PG_FUNCTION_ARGS); +extern Datum path_npoints(PG_FUNCTION_ARGS); +extern Datum path_close(PG_FUNCTION_ARGS); +extern Datum path_open(PG_FUNCTION_ARGS); +extern Datum path_add(PG_FUNCTION_ARGS); +extern Datum path_add_pt(PG_FUNCTION_ARGS); +extern Datum path_sub_pt(PG_FUNCTION_ARGS); +extern Datum path_mul_pt(PG_FUNCTION_ARGS); +extern Datum path_div_pt(PG_FUNCTION_ARGS); +extern Datum construct_point(PG_FUNCTION_ARGS); +extern Datum point_add(PG_FUNCTION_ARGS); +extern Datum point_sub(PG_FUNCTION_ARGS); +extern Datum point_mul(PG_FUNCTION_ARGS); +extern Datum point_div(PG_FUNCTION_ARGS); +extern Datum poly_npoints(PG_FUNCTION_ARGS); +extern Datum poly_box(PG_FUNCTION_ARGS); +extern Datum poly_path(PG_FUNCTION_ARGS); +extern Datum box_poly(PG_FUNCTION_ARGS); +extern Datum path_poly(PG_FUNCTION_ARGS); +extern Datum circle_in(PG_FUNCTION_ARGS); +extern Datum circle_out(PG_FUNCTION_ARGS); +extern Datum circle_same(PG_FUNCTION_ARGS); +extern Datum circle_contain(PG_FUNCTION_ARGS); +extern Datum circle_left(PG_FUNCTION_ARGS); +extern Datum circle_overleft(PG_FUNCTION_ARGS); +extern Datum circle_overright(PG_FUNCTION_ARGS); +extern Datum circle_right(PG_FUNCTION_ARGS); +extern Datum circle_contained(PG_FUNCTION_ARGS); +extern Datum circle_overlap(PG_FUNCTION_ARGS); +extern Datum circle_below(PG_FUNCTION_ARGS); +extern Datum circle_above(PG_FUNCTION_ARGS); +extern Datum circle_eq(PG_FUNCTION_ARGS); +extern Datum circle_ne(PG_FUNCTION_ARGS); +extern Datum circle_lt(PG_FUNCTION_ARGS); +extern Datum circle_gt(PG_FUNCTION_ARGS); +extern Datum circle_le(PG_FUNCTION_ARGS); +extern Datum circle_ge(PG_FUNCTION_ARGS); +extern Datum circle_area(PG_FUNCTION_ARGS); +extern Datum circle_diameter(PG_FUNCTION_ARGS); +extern Datum circle_radius(PG_FUNCTION_ARGS); +extern Datum circle_distance(PG_FUNCTION_ARGS); +extern Datum cr_circle(PG_FUNCTION_ARGS); +extern Datum poly_circle(PG_FUNCTION_ARGS); +extern Datum circle_poly(PG_FUNCTION_ARGS); +extern Datum dist_pc(PG_FUNCTION_ARGS); +extern Datum circle_contain_pt(PG_FUNCTION_ARGS); +extern Datum pt_contained_circle(PG_FUNCTION_ARGS); +extern Datum box_circle(PG_FUNCTION_ARGS); +extern Datum circle_box(PG_FUNCTION_ARGS); +extern Datum lseg_ne(PG_FUNCTION_ARGS); +extern Datum lseg_lt(PG_FUNCTION_ARGS); +extern Datum lseg_le(PG_FUNCTION_ARGS); +extern Datum lseg_gt(PG_FUNCTION_ARGS); +extern Datum lseg_ge(PG_FUNCTION_ARGS); +extern Datum lseg_length(PG_FUNCTION_ARGS); +extern Datum close_ls(PG_FUNCTION_ARGS); +extern Datum close_lseg(PG_FUNCTION_ARGS); +extern Datum line_in(PG_FUNCTION_ARGS); +extern Datum line_out(PG_FUNCTION_ARGS); +extern Datum line_eq(PG_FUNCTION_ARGS); +extern Datum line_construct_pp(PG_FUNCTION_ARGS); +extern Datum line_interpt(PG_FUNCTION_ARGS); +extern Datum line_intersect(PG_FUNCTION_ARGS); +extern Datum bit_in(PG_FUNCTION_ARGS); +extern Datum bit_out(PG_FUNCTION_ARGS); +extern Datum pg_get_ruledef(PG_FUNCTION_ARGS); +extern Datum nextval_oid(PG_FUNCTION_ARGS); +extern Datum currval_oid(PG_FUNCTION_ARGS); +extern Datum setval_oid(PG_FUNCTION_ARGS); +extern Datum varbit_in(PG_FUNCTION_ARGS); +extern Datum varbit_out(PG_FUNCTION_ARGS); +extern Datum biteq(PG_FUNCTION_ARGS); +extern Datum bitne(PG_FUNCTION_ARGS); +extern Datum bitge(PG_FUNCTION_ARGS); +extern Datum bitgt(PG_FUNCTION_ARGS); +extern Datum bitle(PG_FUNCTION_ARGS); +extern Datum bitlt(PG_FUNCTION_ARGS); +extern Datum bitcmp(PG_FUNCTION_ARGS); +extern Datum PG_encoding_to_char(PG_FUNCTION_ARGS); +extern Datum drandom(PG_FUNCTION_ARGS); +extern Datum setseed(PG_FUNCTION_ARGS); +extern Datum dasin(PG_FUNCTION_ARGS); +extern Datum dacos(PG_FUNCTION_ARGS); +extern Datum datan(PG_FUNCTION_ARGS); +extern Datum datan2(PG_FUNCTION_ARGS); +extern Datum dsin(PG_FUNCTION_ARGS); +extern Datum dcos(PG_FUNCTION_ARGS); +extern Datum dtan(PG_FUNCTION_ARGS); +extern Datum dcot(PG_FUNCTION_ARGS); +extern Datum degrees(PG_FUNCTION_ARGS); +extern Datum radians(PG_FUNCTION_ARGS); +extern Datum dpi(PG_FUNCTION_ARGS); +extern Datum interval_mul(PG_FUNCTION_ARGS); +extern Datum pg_typeof(PG_FUNCTION_ARGS); +extern Datum ascii(PG_FUNCTION_ARGS); +extern Datum chr(PG_FUNCTION_ARGS); +extern Datum repeat(PG_FUNCTION_ARGS); +extern Datum similar_escape(PG_FUNCTION_ARGS); +extern Datum mul_d_interval(PG_FUNCTION_ARGS); +extern Datum texticlike(PG_FUNCTION_ARGS); +extern Datum texticnlike(PG_FUNCTION_ARGS); +extern Datum nameiclike(PG_FUNCTION_ARGS); +extern Datum nameicnlike(PG_FUNCTION_ARGS); +extern Datum like_escape(PG_FUNCTION_ARGS); +extern Datum oidgt(PG_FUNCTION_ARGS); +extern Datum oidge(PG_FUNCTION_ARGS); +extern Datum pg_get_viewdef_name(PG_FUNCTION_ARGS); +extern Datum pg_get_viewdef(PG_FUNCTION_ARGS); +extern Datum pg_get_userbyid(PG_FUNCTION_ARGS); +extern Datum pg_get_indexdef(PG_FUNCTION_ARGS); +extern Datum RI_FKey_check_ins(PG_FUNCTION_ARGS); +extern Datum RI_FKey_check_upd(PG_FUNCTION_ARGS); +extern Datum RI_FKey_cascade_del(PG_FUNCTION_ARGS); +extern Datum RI_FKey_cascade_upd(PG_FUNCTION_ARGS); +extern Datum RI_FKey_restrict_del(PG_FUNCTION_ARGS); +extern Datum RI_FKey_restrict_upd(PG_FUNCTION_ARGS); +extern Datum RI_FKey_setnull_del(PG_FUNCTION_ARGS); +extern Datum RI_FKey_setnull_upd(PG_FUNCTION_ARGS); +extern Datum RI_FKey_setdefault_del(PG_FUNCTION_ARGS); +extern Datum RI_FKey_setdefault_upd(PG_FUNCTION_ARGS); +extern Datum RI_FKey_noaction_del(PG_FUNCTION_ARGS); +extern Datum RI_FKey_noaction_upd(PG_FUNCTION_ARGS); +extern Datum pg_get_triggerdef(PG_FUNCTION_ARGS); +extern Datum pg_get_serial_sequence(PG_FUNCTION_ARGS); +extern Datum bit_and(PG_FUNCTION_ARGS); +extern Datum bit_or(PG_FUNCTION_ARGS); +extern Datum bitxor(PG_FUNCTION_ARGS); +extern Datum bitnot(PG_FUNCTION_ARGS); +extern Datum bitshiftleft(PG_FUNCTION_ARGS); +extern Datum bitshiftright(PG_FUNCTION_ARGS); +extern Datum bitcat(PG_FUNCTION_ARGS); +extern Datum bitsubstr(PG_FUNCTION_ARGS); +extern Datum bitlength(PG_FUNCTION_ARGS); +extern Datum bitoctetlength(PG_FUNCTION_ARGS); +extern Datum bitfromint4(PG_FUNCTION_ARGS); +extern Datum bittoint4(PG_FUNCTION_ARGS); +extern Datum bit(PG_FUNCTION_ARGS); +extern Datum pg_get_keywords(PG_FUNCTION_ARGS); +extern Datum varbit(PG_FUNCTION_ARGS); +extern Datum time_hash(PG_FUNCTION_ARGS); +extern Datum aclexplode(PG_FUNCTION_ARGS); +extern Datum time_mi_time(PG_FUNCTION_ARGS); +extern Datum boolle(PG_FUNCTION_ARGS); +extern Datum boolge(PG_FUNCTION_ARGS); +extern Datum btboolcmp(PG_FUNCTION_ARGS); +extern Datum timetz_hash(PG_FUNCTION_ARGS); +extern Datum interval_hash(PG_FUNCTION_ARGS); +extern Datum bitposition(PG_FUNCTION_ARGS); +extern Datum bitsubstr_no_len(PG_FUNCTION_ARGS); +extern Datum numeric_in(PG_FUNCTION_ARGS); +extern Datum numeric_out(PG_FUNCTION_ARGS); +extern Datum numeric(PG_FUNCTION_ARGS); +extern Datum numeric_abs(PG_FUNCTION_ARGS); +extern Datum numeric_sign(PG_FUNCTION_ARGS); +extern Datum numeric_round(PG_FUNCTION_ARGS); +extern Datum numeric_trunc(PG_FUNCTION_ARGS); +extern Datum numeric_ceil(PG_FUNCTION_ARGS); +extern Datum numeric_floor(PG_FUNCTION_ARGS); +extern Datum length_in_encoding(PG_FUNCTION_ARGS); +extern Datum pg_convert_from(PG_FUNCTION_ARGS); +extern Datum inet_to_cidr(PG_FUNCTION_ARGS); +extern Datum pg_get_expr(PG_FUNCTION_ARGS); +extern Datum pg_convert_to(PG_FUNCTION_ARGS); +extern Datum numeric_eq(PG_FUNCTION_ARGS); +extern Datum numeric_ne(PG_FUNCTION_ARGS); +extern Datum numeric_gt(PG_FUNCTION_ARGS); +extern Datum numeric_ge(PG_FUNCTION_ARGS); +extern Datum numeric_lt(PG_FUNCTION_ARGS); +extern Datum numeric_le(PG_FUNCTION_ARGS); +extern Datum numeric_add(PG_FUNCTION_ARGS); +extern Datum numeric_sub(PG_FUNCTION_ARGS); +extern Datum numeric_mul(PG_FUNCTION_ARGS); +extern Datum numeric_div(PG_FUNCTION_ARGS); +extern Datum numeric_mod(PG_FUNCTION_ARGS); +extern Datum numeric_sqrt(PG_FUNCTION_ARGS); +extern Datum numeric_exp(PG_FUNCTION_ARGS); +extern Datum numeric_ln(PG_FUNCTION_ARGS); +extern Datum numeric_log(PG_FUNCTION_ARGS); +extern Datum numeric_power(PG_FUNCTION_ARGS); +extern Datum int4_numeric(PG_FUNCTION_ARGS); +extern Datum float4_numeric(PG_FUNCTION_ARGS); +extern Datum float8_numeric(PG_FUNCTION_ARGS); +extern Datum numeric_int4(PG_FUNCTION_ARGS); +extern Datum numeric_float4(PG_FUNCTION_ARGS); +extern Datum numeric_float8(PG_FUNCTION_ARGS); +extern Datum time_pl_interval(PG_FUNCTION_ARGS); +extern Datum time_mi_interval(PG_FUNCTION_ARGS); +extern Datum timetz_pl_interval(PG_FUNCTION_ARGS); +extern Datum timetz_mi_interval(PG_FUNCTION_ARGS); +extern Datum numeric_inc(PG_FUNCTION_ARGS); +extern Datum setval3_oid(PG_FUNCTION_ARGS); +extern Datum numeric_smaller(PG_FUNCTION_ARGS); +extern Datum numeric_larger(PG_FUNCTION_ARGS); +extern Datum interval_to_char(PG_FUNCTION_ARGS); +extern Datum numeric_cmp(PG_FUNCTION_ARGS); +extern Datum timestamptz_to_char(PG_FUNCTION_ARGS); +extern Datum numeric_uminus(PG_FUNCTION_ARGS); +extern Datum numeric_to_char(PG_FUNCTION_ARGS); +extern Datum int4_to_char(PG_FUNCTION_ARGS); +extern Datum int8_to_char(PG_FUNCTION_ARGS); +extern Datum float4_to_char(PG_FUNCTION_ARGS); +extern Datum float8_to_char(PG_FUNCTION_ARGS); +extern Datum numeric_to_number(PG_FUNCTION_ARGS); +extern Datum to_timestamp(PG_FUNCTION_ARGS); +extern Datum numeric_int8(PG_FUNCTION_ARGS); +extern Datum to_date(PG_FUNCTION_ARGS); +extern Datum int8_numeric(PG_FUNCTION_ARGS); +extern Datum int2_numeric(PG_FUNCTION_ARGS); +extern Datum numeric_int2(PG_FUNCTION_ARGS); +extern Datum oidin(PG_FUNCTION_ARGS); +extern Datum oidout(PG_FUNCTION_ARGS); +extern Datum pg_convert(PG_FUNCTION_ARGS); +extern Datum iclikesel(PG_FUNCTION_ARGS); +extern Datum icnlikesel(PG_FUNCTION_ARGS); +extern Datum iclikejoinsel(PG_FUNCTION_ARGS); +extern Datum icnlikejoinsel(PG_FUNCTION_ARGS); +extern Datum regexeqsel(PG_FUNCTION_ARGS); +extern Datum likesel(PG_FUNCTION_ARGS); +extern Datum icregexeqsel(PG_FUNCTION_ARGS); +extern Datum regexnesel(PG_FUNCTION_ARGS); +extern Datum nlikesel(PG_FUNCTION_ARGS); +extern Datum icregexnesel(PG_FUNCTION_ARGS); +extern Datum regexeqjoinsel(PG_FUNCTION_ARGS); +extern Datum likejoinsel(PG_FUNCTION_ARGS); +extern Datum icregexeqjoinsel(PG_FUNCTION_ARGS); +extern Datum regexnejoinsel(PG_FUNCTION_ARGS); +extern Datum nlikejoinsel(PG_FUNCTION_ARGS); +extern Datum icregexnejoinsel(PG_FUNCTION_ARGS); +extern Datum float8_avg(PG_FUNCTION_ARGS); +extern Datum float8_var_samp(PG_FUNCTION_ARGS); +extern Datum float8_stddev_samp(PG_FUNCTION_ARGS); +extern Datum numeric_accum(PG_FUNCTION_ARGS); +extern Datum int2_accum(PG_FUNCTION_ARGS); +extern Datum int4_accum(PG_FUNCTION_ARGS); +extern Datum int8_accum(PG_FUNCTION_ARGS); +extern Datum numeric_avg(PG_FUNCTION_ARGS); +extern Datum numeric_var_samp(PG_FUNCTION_ARGS); +extern Datum numeric_stddev_samp(PG_FUNCTION_ARGS); +extern Datum int2_sum(PG_FUNCTION_ARGS); +extern Datum int4_sum(PG_FUNCTION_ARGS); +extern Datum int8_sum(PG_FUNCTION_ARGS); +extern Datum interval_accum(PG_FUNCTION_ARGS); +extern Datum interval_avg(PG_FUNCTION_ARGS); +extern Datum to_ascii_default(PG_FUNCTION_ARGS); +extern Datum to_ascii_enc(PG_FUNCTION_ARGS); +extern Datum to_ascii_encname(PG_FUNCTION_ARGS); +extern Datum int28eq(PG_FUNCTION_ARGS); +extern Datum int28ne(PG_FUNCTION_ARGS); +extern Datum int28lt(PG_FUNCTION_ARGS); +extern Datum int28gt(PG_FUNCTION_ARGS); +extern Datum int28le(PG_FUNCTION_ARGS); +extern Datum int28ge(PG_FUNCTION_ARGS); +extern Datum int82eq(PG_FUNCTION_ARGS); +extern Datum int82ne(PG_FUNCTION_ARGS); +extern Datum int82lt(PG_FUNCTION_ARGS); +extern Datum int82gt(PG_FUNCTION_ARGS); +extern Datum int82le(PG_FUNCTION_ARGS); +extern Datum int82ge(PG_FUNCTION_ARGS); +extern Datum int2and(PG_FUNCTION_ARGS); +extern Datum int2or(PG_FUNCTION_ARGS); +extern Datum int2xor(PG_FUNCTION_ARGS); +extern Datum int2not(PG_FUNCTION_ARGS); +extern Datum int2shl(PG_FUNCTION_ARGS); +extern Datum int2shr(PG_FUNCTION_ARGS); +extern Datum int4and(PG_FUNCTION_ARGS); +extern Datum int4or(PG_FUNCTION_ARGS); +extern Datum int4xor(PG_FUNCTION_ARGS); +extern Datum int4not(PG_FUNCTION_ARGS); +extern Datum int4shl(PG_FUNCTION_ARGS); +extern Datum int4shr(PG_FUNCTION_ARGS); +extern Datum int8and(PG_FUNCTION_ARGS); +extern Datum int8or(PG_FUNCTION_ARGS); +extern Datum int8xor(PG_FUNCTION_ARGS); +extern Datum int8not(PG_FUNCTION_ARGS); +extern Datum int8shl(PG_FUNCTION_ARGS); +extern Datum int8shr(PG_FUNCTION_ARGS); +extern Datum int8up(PG_FUNCTION_ARGS); +extern Datum int2up(PG_FUNCTION_ARGS); +extern Datum int4up(PG_FUNCTION_ARGS); +extern Datum float4up(PG_FUNCTION_ARGS); +extern Datum float8up(PG_FUNCTION_ARGS); +extern Datum numeric_uplus(PG_FUNCTION_ARGS); +extern Datum has_table_privilege_name_name(PG_FUNCTION_ARGS); +extern Datum has_table_privilege_name_id(PG_FUNCTION_ARGS); +extern Datum has_table_privilege_id_name(PG_FUNCTION_ARGS); +extern Datum has_table_privilege_id_id(PG_FUNCTION_ARGS); +extern Datum has_table_privilege_name(PG_FUNCTION_ARGS); +extern Datum has_table_privilege_id(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_numscans(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_tuples_returned(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_tuples_fetched(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_tuples_inserted(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_tuples_updated(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_tuples_deleted(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_blocks_fetched(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_blocks_hit(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_backend_idset(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_backend_pid(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_backend_dbid(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_backend_userid(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_backend_activity(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_db_numbackends(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_db_xact_commit(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_db_xact_rollback(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_db_blocks_fetched(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_db_blocks_hit(PG_FUNCTION_ARGS); +extern Datum binary_encode(PG_FUNCTION_ARGS); +extern Datum binary_decode(PG_FUNCTION_ARGS); +extern Datum byteaeq(PG_FUNCTION_ARGS); +extern Datum bytealt(PG_FUNCTION_ARGS); +extern Datum byteale(PG_FUNCTION_ARGS); +extern Datum byteagt(PG_FUNCTION_ARGS); +extern Datum byteage(PG_FUNCTION_ARGS); +extern Datum byteane(PG_FUNCTION_ARGS); +extern Datum byteacmp(PG_FUNCTION_ARGS); +extern Datum timestamp_scale(PG_FUNCTION_ARGS); +extern Datum int2_avg_accum(PG_FUNCTION_ARGS); +extern Datum int4_avg_accum(PG_FUNCTION_ARGS); +extern Datum int8_avg(PG_FUNCTION_ARGS); +extern Datum oidlarger(PG_FUNCTION_ARGS); +extern Datum oidsmaller(PG_FUNCTION_ARGS); +extern Datum timestamptz_scale(PG_FUNCTION_ARGS); +extern Datum time_scale(PG_FUNCTION_ARGS); +extern Datum timetz_scale(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_tuples_hot_updated(PG_FUNCTION_ARGS); +extern Datum numeric_div_trunc(PG_FUNCTION_ARGS); +extern Datum similar_to_escape_2(PG_FUNCTION_ARGS); +extern Datum similar_to_escape_1(PG_FUNCTION_ARGS); +extern Datum bytealike(PG_FUNCTION_ARGS); +extern Datum byteanlike(PG_FUNCTION_ARGS); +extern Datum like_escape_bytea(PG_FUNCTION_ARGS); +extern Datum byteacat(PG_FUNCTION_ARGS); +extern Datum bytea_substr(PG_FUNCTION_ARGS); +extern Datum bytea_substr_no_len(PG_FUNCTION_ARGS); +extern Datum byteapos(PG_FUNCTION_ARGS); +extern Datum byteatrim(PG_FUNCTION_ARGS); +extern Datum timestamptz_time(PG_FUNCTION_ARGS); +extern Datum timestamp_trunc(PG_FUNCTION_ARGS); +extern Datum timestamp_part(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_activity(PG_FUNCTION_ARGS); +extern Datum jsonb_path_query_first_tz(PG_FUNCTION_ARGS); +extern Datum date_timestamp(PG_FUNCTION_ARGS); +extern Datum pg_backend_pid(PG_FUNCTION_ARGS); +extern Datum timestamptz_timestamp(PG_FUNCTION_ARGS); +extern Datum timestamp_timestamptz(PG_FUNCTION_ARGS); +extern Datum timestamp_date(PG_FUNCTION_ARGS); +extern Datum jsonb_path_match_tz(PG_FUNCTION_ARGS); +extern Datum timestamp_pl_interval(PG_FUNCTION_ARGS); +extern Datum timestamp_mi_interval(PG_FUNCTION_ARGS); +extern Datum pg_conf_load_time(PG_FUNCTION_ARGS); +extern Datum timetz_zone(PG_FUNCTION_ARGS); +extern Datum timetz_izone(PG_FUNCTION_ARGS); +extern Datum timestamp_hash(PG_FUNCTION_ARGS); +extern Datum timetz_time(PG_FUNCTION_ARGS); +extern Datum time_timetz(PG_FUNCTION_ARGS); +extern Datum timestamp_to_char(PG_FUNCTION_ARGS); +extern Datum timestamp_age(PG_FUNCTION_ARGS); +extern Datum timestamp_zone(PG_FUNCTION_ARGS); +extern Datum timestamp_izone(PG_FUNCTION_ARGS); +extern Datum date_pl_interval(PG_FUNCTION_ARGS); +extern Datum date_mi_interval(PG_FUNCTION_ARGS); +extern Datum textregexsubstr(PG_FUNCTION_ARGS); +extern Datum bitfromint8(PG_FUNCTION_ARGS); +extern Datum bittoint8(PG_FUNCTION_ARGS); +extern Datum show_config_by_name(PG_FUNCTION_ARGS); +extern Datum set_config_by_name(PG_FUNCTION_ARGS); +extern Datum pg_table_is_visible(PG_FUNCTION_ARGS); +extern Datum pg_type_is_visible(PG_FUNCTION_ARGS); +extern Datum pg_function_is_visible(PG_FUNCTION_ARGS); +extern Datum pg_operator_is_visible(PG_FUNCTION_ARGS); +extern Datum pg_opclass_is_visible(PG_FUNCTION_ARGS); +extern Datum show_all_settings(PG_FUNCTION_ARGS); +extern Datum replace_text(PG_FUNCTION_ARGS); +extern Datum split_part(PG_FUNCTION_ARGS); +extern Datum to_hex32(PG_FUNCTION_ARGS); +extern Datum to_hex64(PG_FUNCTION_ARGS); +extern Datum array_lower(PG_FUNCTION_ARGS); +extern Datum array_upper(PG_FUNCTION_ARGS); +extern Datum pg_conversion_is_visible(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_backend_activity_start(PG_FUNCTION_ARGS); +extern Datum pg_terminate_backend(PG_FUNCTION_ARGS); +extern Datum pg_get_functiondef(PG_FUNCTION_ARGS); +extern Datum pg_column_compression(PG_FUNCTION_ARGS); +extern Datum pg_stat_force_next_flush(PG_FUNCTION_ARGS); +extern Datum text_pattern_lt(PG_FUNCTION_ARGS); +extern Datum text_pattern_le(PG_FUNCTION_ARGS); +extern Datum pg_get_function_arguments(PG_FUNCTION_ARGS); +extern Datum text_pattern_ge(PG_FUNCTION_ARGS); +extern Datum text_pattern_gt(PG_FUNCTION_ARGS); +extern Datum pg_get_function_result(PG_FUNCTION_ARGS); +extern Datum bttext_pattern_cmp(PG_FUNCTION_ARGS); +extern Datum pg_database_size_name(PG_FUNCTION_ARGS); +extern Datum width_bucket_numeric(PG_FUNCTION_ARGS); +extern Datum pg_cancel_backend(PG_FUNCTION_ARGS); +extern Datum pg_backup_start(PG_FUNCTION_ARGS); +extern Datum bpchar_pattern_lt(PG_FUNCTION_ARGS); +extern Datum bpchar_pattern_le(PG_FUNCTION_ARGS); +extern Datum array_length(PG_FUNCTION_ARGS); +extern Datum bpchar_pattern_ge(PG_FUNCTION_ARGS); +extern Datum bpchar_pattern_gt(PG_FUNCTION_ARGS); +extern Datum gist_point_consistent(PG_FUNCTION_ARGS); +extern Datum btbpchar_pattern_cmp(PG_FUNCTION_ARGS); +extern Datum has_sequence_privilege_name_name(PG_FUNCTION_ARGS); +extern Datum has_sequence_privilege_name_id(PG_FUNCTION_ARGS); +extern Datum has_sequence_privilege_id_name(PG_FUNCTION_ARGS); +extern Datum has_sequence_privilege_id_id(PG_FUNCTION_ARGS); +extern Datum has_sequence_privilege_name(PG_FUNCTION_ARGS); +extern Datum has_sequence_privilege_id(PG_FUNCTION_ARGS); +extern Datum btint48cmp(PG_FUNCTION_ARGS); +extern Datum btint84cmp(PG_FUNCTION_ARGS); +extern Datum btint24cmp(PG_FUNCTION_ARGS); +extern Datum btint42cmp(PG_FUNCTION_ARGS); +extern Datum btint28cmp(PG_FUNCTION_ARGS); +extern Datum btint82cmp(PG_FUNCTION_ARGS); +extern Datum btfloat48cmp(PG_FUNCTION_ARGS); +extern Datum btfloat84cmp(PG_FUNCTION_ARGS); +extern Datum inet_client_addr(PG_FUNCTION_ARGS); +extern Datum inet_client_port(PG_FUNCTION_ARGS); +extern Datum inet_server_addr(PG_FUNCTION_ARGS); +extern Datum inet_server_port(PG_FUNCTION_ARGS); +extern Datum regprocedurein(PG_FUNCTION_ARGS); +extern Datum regprocedureout(PG_FUNCTION_ARGS); +extern Datum regoperin(PG_FUNCTION_ARGS); +extern Datum regoperout(PG_FUNCTION_ARGS); +extern Datum regoperatorin(PG_FUNCTION_ARGS); +extern Datum regoperatorout(PG_FUNCTION_ARGS); +extern Datum regclassin(PG_FUNCTION_ARGS); +extern Datum regclassout(PG_FUNCTION_ARGS); +extern Datum regtypein(PG_FUNCTION_ARGS); +extern Datum regtypeout(PG_FUNCTION_ARGS); +extern Datum pg_stat_clear_snapshot(PG_FUNCTION_ARGS); +extern Datum pg_get_function_identity_arguments(PG_FUNCTION_ARGS); +extern Datum hashtid(PG_FUNCTION_ARGS); +extern Datum hashtidextended(PG_FUNCTION_ARGS); +extern Datum fmgr_internal_validator(PG_FUNCTION_ARGS); +extern Datum fmgr_c_validator(PG_FUNCTION_ARGS); +extern Datum fmgr_sql_validator(PG_FUNCTION_ARGS); +extern Datum has_database_privilege_name_name(PG_FUNCTION_ARGS); +extern Datum has_database_privilege_name_id(PG_FUNCTION_ARGS); +extern Datum has_database_privilege_id_name(PG_FUNCTION_ARGS); +extern Datum has_database_privilege_id_id(PG_FUNCTION_ARGS); +extern Datum has_database_privilege_name(PG_FUNCTION_ARGS); +extern Datum has_database_privilege_id(PG_FUNCTION_ARGS); +extern Datum has_function_privilege_name_name(PG_FUNCTION_ARGS); +extern Datum has_function_privilege_name_id(PG_FUNCTION_ARGS); +extern Datum has_function_privilege_id_name(PG_FUNCTION_ARGS); +extern Datum has_function_privilege_id_id(PG_FUNCTION_ARGS); +extern Datum has_function_privilege_name(PG_FUNCTION_ARGS); +extern Datum has_function_privilege_id(PG_FUNCTION_ARGS); +extern Datum has_language_privilege_name_name(PG_FUNCTION_ARGS); +extern Datum has_language_privilege_name_id(PG_FUNCTION_ARGS); +extern Datum has_language_privilege_id_name(PG_FUNCTION_ARGS); +extern Datum has_language_privilege_id_id(PG_FUNCTION_ARGS); +extern Datum has_language_privilege_name(PG_FUNCTION_ARGS); +extern Datum has_language_privilege_id(PG_FUNCTION_ARGS); +extern Datum has_schema_privilege_name_name(PG_FUNCTION_ARGS); +extern Datum has_schema_privilege_name_id(PG_FUNCTION_ARGS); +extern Datum has_schema_privilege_id_name(PG_FUNCTION_ARGS); +extern Datum has_schema_privilege_id_id(PG_FUNCTION_ARGS); +extern Datum has_schema_privilege_name(PG_FUNCTION_ARGS); +extern Datum has_schema_privilege_id(PG_FUNCTION_ARGS); +extern Datum pg_stat_reset(PG_FUNCTION_ARGS); +extern Datum pg_get_backend_memory_contexts(PG_FUNCTION_ARGS); +extern Datum textregexreplace_noopt(PG_FUNCTION_ARGS); +extern Datum textregexreplace(PG_FUNCTION_ARGS); +extern Datum pg_total_relation_size(PG_FUNCTION_ARGS); +extern Datum pg_size_pretty(PG_FUNCTION_ARGS); +extern Datum pg_options_to_table(PG_FUNCTION_ARGS); +extern Datum record_in(PG_FUNCTION_ARGS); +extern Datum record_out(PG_FUNCTION_ARGS); +extern Datum cstring_in(PG_FUNCTION_ARGS); +extern Datum cstring_out(PG_FUNCTION_ARGS); +extern Datum any_in(PG_FUNCTION_ARGS); +extern Datum any_out(PG_FUNCTION_ARGS); +extern Datum anyarray_in(PG_FUNCTION_ARGS); +extern Datum anyarray_out(PG_FUNCTION_ARGS); +extern Datum void_in(PG_FUNCTION_ARGS); +extern Datum void_out(PG_FUNCTION_ARGS); +extern Datum trigger_in(PG_FUNCTION_ARGS); +extern Datum trigger_out(PG_FUNCTION_ARGS); +extern Datum language_handler_in(PG_FUNCTION_ARGS); +extern Datum language_handler_out(PG_FUNCTION_ARGS); +extern Datum internal_in(PG_FUNCTION_ARGS); +extern Datum internal_out(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_slru(PG_FUNCTION_ARGS); +extern Datum pg_stat_reset_slru(PG_FUNCTION_ARGS); +extern Datum dceil(PG_FUNCTION_ARGS); +extern Datum dfloor(PG_FUNCTION_ARGS); +extern Datum dsign(PG_FUNCTION_ARGS); +extern Datum md5_text(PG_FUNCTION_ARGS); +extern Datum anyelement_in(PG_FUNCTION_ARGS); +extern Datum anyelement_out(PG_FUNCTION_ARGS); +extern Datum postgresql_fdw_validator(PG_FUNCTION_ARGS); +extern Datum pg_encoding_max_length_sql(PG_FUNCTION_ARGS); +extern Datum md5_bytea(PG_FUNCTION_ARGS); +extern Datum pg_tablespace_size_oid(PG_FUNCTION_ARGS); +extern Datum pg_tablespace_size_name(PG_FUNCTION_ARGS); +extern Datum pg_database_size_oid(PG_FUNCTION_ARGS); +extern Datum array_unnest(PG_FUNCTION_ARGS); +extern Datum pg_relation_size(PG_FUNCTION_ARGS); +extern Datum array_agg_transfn(PG_FUNCTION_ARGS); +extern Datum array_agg_finalfn(PG_FUNCTION_ARGS); +extern Datum date_lt_timestamp(PG_FUNCTION_ARGS); +extern Datum date_le_timestamp(PG_FUNCTION_ARGS); +extern Datum date_eq_timestamp(PG_FUNCTION_ARGS); +extern Datum date_gt_timestamp(PG_FUNCTION_ARGS); +extern Datum date_ge_timestamp(PG_FUNCTION_ARGS); +extern Datum date_ne_timestamp(PG_FUNCTION_ARGS); +extern Datum date_cmp_timestamp(PG_FUNCTION_ARGS); +extern Datum date_lt_timestamptz(PG_FUNCTION_ARGS); +extern Datum date_le_timestamptz(PG_FUNCTION_ARGS); +extern Datum date_eq_timestamptz(PG_FUNCTION_ARGS); +extern Datum date_gt_timestamptz(PG_FUNCTION_ARGS); +extern Datum date_ge_timestamptz(PG_FUNCTION_ARGS); +extern Datum date_ne_timestamptz(PG_FUNCTION_ARGS); +extern Datum date_cmp_timestamptz(PG_FUNCTION_ARGS); +extern Datum timestamp_lt_date(PG_FUNCTION_ARGS); +extern Datum timestamp_le_date(PG_FUNCTION_ARGS); +extern Datum timestamp_eq_date(PG_FUNCTION_ARGS); +extern Datum timestamp_gt_date(PG_FUNCTION_ARGS); +extern Datum timestamp_ge_date(PG_FUNCTION_ARGS); +extern Datum timestamp_ne_date(PG_FUNCTION_ARGS); +extern Datum timestamp_cmp_date(PG_FUNCTION_ARGS); +extern Datum timestamptz_lt_date(PG_FUNCTION_ARGS); +extern Datum timestamptz_le_date(PG_FUNCTION_ARGS); +extern Datum timestamptz_eq_date(PG_FUNCTION_ARGS); +extern Datum timestamptz_gt_date(PG_FUNCTION_ARGS); +extern Datum timestamptz_ge_date(PG_FUNCTION_ARGS); +extern Datum timestamptz_ne_date(PG_FUNCTION_ARGS); +extern Datum timestamptz_cmp_date(PG_FUNCTION_ARGS); +extern Datum has_tablespace_privilege_name_name(PG_FUNCTION_ARGS); +extern Datum has_tablespace_privilege_name_id(PG_FUNCTION_ARGS); +extern Datum has_tablespace_privilege_id_name(PG_FUNCTION_ARGS); +extern Datum has_tablespace_privilege_id_id(PG_FUNCTION_ARGS); +extern Datum has_tablespace_privilege_name(PG_FUNCTION_ARGS); +extern Datum has_tablespace_privilege_id(PG_FUNCTION_ARGS); +extern Datum shell_in(PG_FUNCTION_ARGS); +extern Datum shell_out(PG_FUNCTION_ARGS); +extern Datum array_recv(PG_FUNCTION_ARGS); +extern Datum array_send(PG_FUNCTION_ARGS); +extern Datum record_recv(PG_FUNCTION_ARGS); +extern Datum record_send(PG_FUNCTION_ARGS); +extern Datum int2recv(PG_FUNCTION_ARGS); +extern Datum int2send(PG_FUNCTION_ARGS); +extern Datum int4recv(PG_FUNCTION_ARGS); +extern Datum int4send(PG_FUNCTION_ARGS); +extern Datum int8recv(PG_FUNCTION_ARGS); +extern Datum int8send(PG_FUNCTION_ARGS); +extern Datum int2vectorrecv(PG_FUNCTION_ARGS); +extern Datum int2vectorsend(PG_FUNCTION_ARGS); +extern Datum bytearecv(PG_FUNCTION_ARGS); +extern Datum byteasend(PG_FUNCTION_ARGS); +extern Datum textrecv(PG_FUNCTION_ARGS); +extern Datum textsend(PG_FUNCTION_ARGS); +extern Datum unknownrecv(PG_FUNCTION_ARGS); +extern Datum unknownsend(PG_FUNCTION_ARGS); +extern Datum oidrecv(PG_FUNCTION_ARGS); +extern Datum oidsend(PG_FUNCTION_ARGS); +extern Datum oidvectorrecv(PG_FUNCTION_ARGS); +extern Datum oidvectorsend(PG_FUNCTION_ARGS); +extern Datum namerecv(PG_FUNCTION_ARGS); +extern Datum namesend(PG_FUNCTION_ARGS); +extern Datum float4recv(PG_FUNCTION_ARGS); +extern Datum float4send(PG_FUNCTION_ARGS); +extern Datum float8recv(PG_FUNCTION_ARGS); +extern Datum float8send(PG_FUNCTION_ARGS); +extern Datum point_recv(PG_FUNCTION_ARGS); +extern Datum point_send(PG_FUNCTION_ARGS); +extern Datum bpcharrecv(PG_FUNCTION_ARGS); +extern Datum bpcharsend(PG_FUNCTION_ARGS); +extern Datum varcharrecv(PG_FUNCTION_ARGS); +extern Datum varcharsend(PG_FUNCTION_ARGS); +extern Datum charrecv(PG_FUNCTION_ARGS); +extern Datum charsend(PG_FUNCTION_ARGS); +extern Datum boolrecv(PG_FUNCTION_ARGS); +extern Datum boolsend(PG_FUNCTION_ARGS); +extern Datum tidrecv(PG_FUNCTION_ARGS); +extern Datum tidsend(PG_FUNCTION_ARGS); +extern Datum xidrecv(PG_FUNCTION_ARGS); +extern Datum xidsend(PG_FUNCTION_ARGS); +extern Datum cidrecv(PG_FUNCTION_ARGS); +extern Datum cidsend(PG_FUNCTION_ARGS); +extern Datum regprocrecv(PG_FUNCTION_ARGS); +extern Datum regprocsend(PG_FUNCTION_ARGS); +extern Datum regprocedurerecv(PG_FUNCTION_ARGS); +extern Datum regproceduresend(PG_FUNCTION_ARGS); +extern Datum regoperrecv(PG_FUNCTION_ARGS); +extern Datum regopersend(PG_FUNCTION_ARGS); +extern Datum regoperatorrecv(PG_FUNCTION_ARGS); +extern Datum regoperatorsend(PG_FUNCTION_ARGS); +extern Datum regclassrecv(PG_FUNCTION_ARGS); +extern Datum regclasssend(PG_FUNCTION_ARGS); +extern Datum regtyperecv(PG_FUNCTION_ARGS); +extern Datum regtypesend(PG_FUNCTION_ARGS); +extern Datum bit_recv(PG_FUNCTION_ARGS); +extern Datum bit_send(PG_FUNCTION_ARGS); +extern Datum varbit_recv(PG_FUNCTION_ARGS); +extern Datum varbit_send(PG_FUNCTION_ARGS); +extern Datum numeric_recv(PG_FUNCTION_ARGS); +extern Datum numeric_send(PG_FUNCTION_ARGS); +extern Datum dsinh(PG_FUNCTION_ARGS); +extern Datum dcosh(PG_FUNCTION_ARGS); +extern Datum dtanh(PG_FUNCTION_ARGS); +extern Datum dasinh(PG_FUNCTION_ARGS); +extern Datum dacosh(PG_FUNCTION_ARGS); +extern Datum datanh(PG_FUNCTION_ARGS); +extern Datum date_recv(PG_FUNCTION_ARGS); +extern Datum date_send(PG_FUNCTION_ARGS); +extern Datum time_recv(PG_FUNCTION_ARGS); +extern Datum time_send(PG_FUNCTION_ARGS); +extern Datum timetz_recv(PG_FUNCTION_ARGS); +extern Datum timetz_send(PG_FUNCTION_ARGS); +extern Datum timestamp_recv(PG_FUNCTION_ARGS); +extern Datum timestamp_send(PG_FUNCTION_ARGS); +extern Datum timestamptz_recv(PG_FUNCTION_ARGS); +extern Datum timestamptz_send(PG_FUNCTION_ARGS); +extern Datum interval_recv(PG_FUNCTION_ARGS); +extern Datum interval_send(PG_FUNCTION_ARGS); +extern Datum lseg_recv(PG_FUNCTION_ARGS); +extern Datum lseg_send(PG_FUNCTION_ARGS); +extern Datum path_recv(PG_FUNCTION_ARGS); +extern Datum path_send(PG_FUNCTION_ARGS); +extern Datum box_recv(PG_FUNCTION_ARGS); +extern Datum box_send(PG_FUNCTION_ARGS); +extern Datum poly_recv(PG_FUNCTION_ARGS); +extern Datum poly_send(PG_FUNCTION_ARGS); +extern Datum line_recv(PG_FUNCTION_ARGS); +extern Datum line_send(PG_FUNCTION_ARGS); +extern Datum circle_recv(PG_FUNCTION_ARGS); +extern Datum circle_send(PG_FUNCTION_ARGS); +extern Datum cash_recv(PG_FUNCTION_ARGS); +extern Datum cash_send(PG_FUNCTION_ARGS); +extern Datum macaddr_recv(PG_FUNCTION_ARGS); +extern Datum macaddr_send(PG_FUNCTION_ARGS); +extern Datum inet_recv(PG_FUNCTION_ARGS); +extern Datum inet_send(PG_FUNCTION_ARGS); +extern Datum cidr_recv(PG_FUNCTION_ARGS); +extern Datum cidr_send(PG_FUNCTION_ARGS); +extern Datum cstring_recv(PG_FUNCTION_ARGS); +extern Datum cstring_send(PG_FUNCTION_ARGS); +extern Datum anyarray_recv(PG_FUNCTION_ARGS); +extern Datum anyarray_send(PG_FUNCTION_ARGS); +extern Datum pg_get_ruledef_ext(PG_FUNCTION_ARGS); +extern Datum pg_get_viewdef_name_ext(PG_FUNCTION_ARGS); +extern Datum pg_get_viewdef_ext(PG_FUNCTION_ARGS); +extern Datum pg_get_indexdef_ext(PG_FUNCTION_ARGS); +extern Datum pg_get_constraintdef_ext(PG_FUNCTION_ARGS); +extern Datum pg_get_expr_ext(PG_FUNCTION_ARGS); +extern Datum pg_prepared_statement(PG_FUNCTION_ARGS); +extern Datum pg_cursor(PG_FUNCTION_ARGS); +extern Datum float8_var_pop(PG_FUNCTION_ARGS); +extern Datum float8_stddev_pop(PG_FUNCTION_ARGS); +extern Datum numeric_var_pop(PG_FUNCTION_ARGS); +extern Datum booland_statefunc(PG_FUNCTION_ARGS); +extern Datum boolor_statefunc(PG_FUNCTION_ARGS); +extern Datum timestamp_lt_timestamptz(PG_FUNCTION_ARGS); +extern Datum timestamp_le_timestamptz(PG_FUNCTION_ARGS); +extern Datum timestamp_eq_timestamptz(PG_FUNCTION_ARGS); +extern Datum timestamp_gt_timestamptz(PG_FUNCTION_ARGS); +extern Datum timestamp_ge_timestamptz(PG_FUNCTION_ARGS); +extern Datum timestamp_ne_timestamptz(PG_FUNCTION_ARGS); +extern Datum timestamp_cmp_timestamptz(PG_FUNCTION_ARGS); +extern Datum timestamptz_lt_timestamp(PG_FUNCTION_ARGS); +extern Datum timestamptz_le_timestamp(PG_FUNCTION_ARGS); +extern Datum timestamptz_eq_timestamp(PG_FUNCTION_ARGS); +extern Datum timestamptz_gt_timestamp(PG_FUNCTION_ARGS); +extern Datum timestamptz_ge_timestamp(PG_FUNCTION_ARGS); +extern Datum timestamptz_ne_timestamp(PG_FUNCTION_ARGS); +extern Datum timestamptz_cmp_timestamp(PG_FUNCTION_ARGS); +extern Datum pg_tablespace_databases(PG_FUNCTION_ARGS); +extern Datum int4_bool(PG_FUNCTION_ARGS); +extern Datum bool_int4(PG_FUNCTION_ARGS); +extern Datum lastval(PG_FUNCTION_ARGS); +extern Datum pg_postmaster_start_time(PG_FUNCTION_ARGS); +extern Datum pg_blocking_pids(PG_FUNCTION_ARGS); +extern Datum box_below(PG_FUNCTION_ARGS); +extern Datum box_overbelow(PG_FUNCTION_ARGS); +extern Datum box_overabove(PG_FUNCTION_ARGS); +extern Datum box_above(PG_FUNCTION_ARGS); +extern Datum poly_below(PG_FUNCTION_ARGS); +extern Datum poly_overbelow(PG_FUNCTION_ARGS); +extern Datum poly_overabove(PG_FUNCTION_ARGS); +extern Datum poly_above(PG_FUNCTION_ARGS); +extern Datum gist_box_consistent(PG_FUNCTION_ARGS); +extern Datum jsonb_float8(PG_FUNCTION_ARGS); +extern Datum gist_box_penalty(PG_FUNCTION_ARGS); +extern Datum gist_box_picksplit(PG_FUNCTION_ARGS); +extern Datum gist_box_union(PG_FUNCTION_ARGS); +extern Datum gist_box_same(PG_FUNCTION_ARGS); +extern Datum gist_poly_consistent(PG_FUNCTION_ARGS); +extern Datum gist_poly_compress(PG_FUNCTION_ARGS); +extern Datum circle_overbelow(PG_FUNCTION_ARGS); +extern Datum circle_overabove(PG_FUNCTION_ARGS); +extern Datum gist_circle_consistent(PG_FUNCTION_ARGS); +extern Datum gist_circle_compress(PG_FUNCTION_ARGS); +extern Datum numeric_stddev_pop(PG_FUNCTION_ARGS); +extern Datum domain_in(PG_FUNCTION_ARGS); +extern Datum domain_recv(PG_FUNCTION_ARGS); +extern Datum pg_timezone_abbrevs(PG_FUNCTION_ARGS); +extern Datum xmlexists(PG_FUNCTION_ARGS); +extern Datum pg_reload_conf(PG_FUNCTION_ARGS); +extern Datum pg_rotate_logfile_v2(PG_FUNCTION_ARGS); +extern Datum pg_stat_file_1arg(PG_FUNCTION_ARGS); +extern Datum pg_read_file_off_len(PG_FUNCTION_ARGS); +extern Datum pg_ls_dir_1arg(PG_FUNCTION_ARGS); +extern Datum pg_sleep(PG_FUNCTION_ARGS); +extern Datum inetnot(PG_FUNCTION_ARGS); +extern Datum inetand(PG_FUNCTION_ARGS); +extern Datum inetor(PG_FUNCTION_ARGS); +extern Datum inetpl(PG_FUNCTION_ARGS); +extern Datum inetmi_int8(PG_FUNCTION_ARGS); +extern Datum inetmi(PG_FUNCTION_ARGS); +extern Datum statement_timestamp(PG_FUNCTION_ARGS); +extern Datum clock_timestamp(PG_FUNCTION_ARGS); +extern Datum gin_cmp_prefix(PG_FUNCTION_ARGS); +extern Datum pg_has_role_name_name(PG_FUNCTION_ARGS); +extern Datum pg_has_role_name_id(PG_FUNCTION_ARGS); +extern Datum pg_has_role_id_name(PG_FUNCTION_ARGS); +extern Datum pg_has_role_id_id(PG_FUNCTION_ARGS); +extern Datum pg_has_role_name(PG_FUNCTION_ARGS); +extern Datum pg_has_role_id(PG_FUNCTION_ARGS); +extern Datum interval_justify_interval(PG_FUNCTION_ARGS); +extern Datum pg_get_triggerdef_ext(PG_FUNCTION_ARGS); +extern Datum dasind(PG_FUNCTION_ARGS); +extern Datum dacosd(PG_FUNCTION_ARGS); +extern Datum datand(PG_FUNCTION_ARGS); +extern Datum datan2d(PG_FUNCTION_ARGS); +extern Datum dsind(PG_FUNCTION_ARGS); +extern Datum dcosd(PG_FUNCTION_ARGS); +extern Datum dtand(PG_FUNCTION_ARGS); +extern Datum dcotd(PG_FUNCTION_ARGS); +extern Datum pg_backup_stop(PG_FUNCTION_ARGS); +extern Datum numeric_avg_serialize(PG_FUNCTION_ARGS); +extern Datum numeric_avg_deserialize(PG_FUNCTION_ARGS); +extern Datum ginarrayextract(PG_FUNCTION_ARGS); +extern Datum ginarrayconsistent(PG_FUNCTION_ARGS); +extern Datum int8_avg_accum(PG_FUNCTION_ARGS); +extern Datum arrayoverlap(PG_FUNCTION_ARGS); +extern Datum arraycontains(PG_FUNCTION_ARGS); +extern Datum arraycontained(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_db_tuples_returned(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_db_tuples_fetched(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_db_tuples_inserted(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_db_tuples_updated(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_db_tuples_deleted(PG_FUNCTION_ARGS); +extern Datum regexp_matches_no_flags(PG_FUNCTION_ARGS); +extern Datum regexp_matches(PG_FUNCTION_ARGS); +extern Datum regexp_split_to_table_no_flags(PG_FUNCTION_ARGS); +extern Datum regexp_split_to_table(PG_FUNCTION_ARGS); +extern Datum regexp_split_to_array_no_flags(PG_FUNCTION_ARGS); +extern Datum regexp_split_to_array(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_bgwriter_timed_checkpoints(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_bgwriter_requested_checkpoints(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_bgwriter_buf_written_checkpoints(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_bgwriter_buf_written_clean(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_bgwriter_maxwritten_clean(PG_FUNCTION_ARGS); +extern Datum ginqueryarrayextract(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_buf_written_backend(PG_FUNCTION_ARGS); +extern Datum anynonarray_in(PG_FUNCTION_ARGS); +extern Datum anynonarray_out(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_last_vacuum_time(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_last_autovacuum_time(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_last_analyze_time(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_last_autoanalyze_time(PG_FUNCTION_ARGS); +extern Datum int8_avg_combine(PG_FUNCTION_ARGS); +extern Datum int8_avg_serialize(PG_FUNCTION_ARGS); +extern Datum int8_avg_deserialize(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_backend_wait_event_type(PG_FUNCTION_ARGS); +extern Datum tidgt(PG_FUNCTION_ARGS); +extern Datum tidlt(PG_FUNCTION_ARGS); +extern Datum tidge(PG_FUNCTION_ARGS); +extern Datum tidle(PG_FUNCTION_ARGS); +extern Datum bttidcmp(PG_FUNCTION_ARGS); +extern Datum tidlarger(PG_FUNCTION_ARGS); +extern Datum tidsmaller(PG_FUNCTION_ARGS); +extern Datum int8inc_any(PG_FUNCTION_ARGS); +extern Datum int8inc_float8_float8(PG_FUNCTION_ARGS); +extern Datum float8_regr_accum(PG_FUNCTION_ARGS); +extern Datum float8_regr_sxx(PG_FUNCTION_ARGS); +extern Datum float8_regr_syy(PG_FUNCTION_ARGS); +extern Datum float8_regr_sxy(PG_FUNCTION_ARGS); +extern Datum float8_regr_avgx(PG_FUNCTION_ARGS); +extern Datum float8_regr_avgy(PG_FUNCTION_ARGS); +extern Datum float8_regr_r2(PG_FUNCTION_ARGS); +extern Datum float8_regr_slope(PG_FUNCTION_ARGS); +extern Datum float8_regr_intercept(PG_FUNCTION_ARGS); +extern Datum float8_covar_pop(PG_FUNCTION_ARGS); +extern Datum float8_covar_samp(PG_FUNCTION_ARGS); +extern Datum float8_corr(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_db_blk_read_time(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_db_blk_write_time(PG_FUNCTION_ARGS); +extern Datum pg_switch_wal(PG_FUNCTION_ARGS); +extern Datum pg_current_wal_lsn(PG_FUNCTION_ARGS); +extern Datum pg_walfile_name_offset(PG_FUNCTION_ARGS); +extern Datum pg_walfile_name(PG_FUNCTION_ARGS); +extern Datum pg_current_wal_insert_lsn(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_backend_wait_event(PG_FUNCTION_ARGS); +extern Datum pg_my_temp_schema(PG_FUNCTION_ARGS); +extern Datum pg_is_other_temp_schema(PG_FUNCTION_ARGS); +extern Datum pg_timezone_names(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_backend_xact_start(PG_FUNCTION_ARGS); +extern Datum numeric_avg_accum(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_buf_alloc(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_live_tuples(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_dead_tuples(PG_FUNCTION_ARGS); +extern Datum pg_advisory_lock_int8(PG_FUNCTION_ARGS); +extern Datum pg_advisory_lock_shared_int8(PG_FUNCTION_ARGS); +extern Datum pg_try_advisory_lock_int8(PG_FUNCTION_ARGS); +extern Datum pg_try_advisory_lock_shared_int8(PG_FUNCTION_ARGS); +extern Datum pg_advisory_unlock_int8(PG_FUNCTION_ARGS); +extern Datum pg_advisory_unlock_shared_int8(PG_FUNCTION_ARGS); +extern Datum pg_advisory_lock_int4(PG_FUNCTION_ARGS); +extern Datum pg_advisory_lock_shared_int4(PG_FUNCTION_ARGS); +extern Datum pg_try_advisory_lock_int4(PG_FUNCTION_ARGS); +extern Datum pg_try_advisory_lock_shared_int4(PG_FUNCTION_ARGS); +extern Datum pg_advisory_unlock_int4(PG_FUNCTION_ARGS); +extern Datum pg_advisory_unlock_shared_int4(PG_FUNCTION_ARGS); +extern Datum pg_advisory_unlock_all(PG_FUNCTION_ARGS); +extern Datum xml_in(PG_FUNCTION_ARGS); +extern Datum xml_out(PG_FUNCTION_ARGS); +extern Datum xmlcomment(PG_FUNCTION_ARGS); +extern Datum texttoxml(PG_FUNCTION_ARGS); +extern Datum xmlvalidate(PG_FUNCTION_ARGS); +extern Datum xml_recv(PG_FUNCTION_ARGS); +extern Datum xml_send(PG_FUNCTION_ARGS); +extern Datum xmlconcat2(PG_FUNCTION_ARGS); +extern Datum varbittypmodin(PG_FUNCTION_ARGS); +extern Datum intervaltypmodin(PG_FUNCTION_ARGS); +extern Datum intervaltypmodout(PG_FUNCTION_ARGS); +extern Datum timestamptypmodin(PG_FUNCTION_ARGS); +extern Datum timestamptypmodout(PG_FUNCTION_ARGS); +extern Datum timestamptztypmodin(PG_FUNCTION_ARGS); +extern Datum timestamptztypmodout(PG_FUNCTION_ARGS); +extern Datum timetypmodin(PG_FUNCTION_ARGS); +extern Datum timetypmodout(PG_FUNCTION_ARGS); +extern Datum timetztypmodin(PG_FUNCTION_ARGS); +extern Datum timetztypmodout(PG_FUNCTION_ARGS); +extern Datum bpchartypmodin(PG_FUNCTION_ARGS); +extern Datum bpchartypmodout(PG_FUNCTION_ARGS); +extern Datum varchartypmodin(PG_FUNCTION_ARGS); +extern Datum varchartypmodout(PG_FUNCTION_ARGS); +extern Datum numerictypmodin(PG_FUNCTION_ARGS); +extern Datum numerictypmodout(PG_FUNCTION_ARGS); +extern Datum bittypmodin(PG_FUNCTION_ARGS); +extern Datum bittypmodout(PG_FUNCTION_ARGS); +extern Datum varbittypmodout(PG_FUNCTION_ARGS); +extern Datum xmltotext(PG_FUNCTION_ARGS); +extern Datum table_to_xml(PG_FUNCTION_ARGS); +extern Datum query_to_xml(PG_FUNCTION_ARGS); +extern Datum cursor_to_xml(PG_FUNCTION_ARGS); +extern Datum table_to_xmlschema(PG_FUNCTION_ARGS); +extern Datum query_to_xmlschema(PG_FUNCTION_ARGS); +extern Datum cursor_to_xmlschema(PG_FUNCTION_ARGS); +extern Datum table_to_xml_and_xmlschema(PG_FUNCTION_ARGS); +extern Datum query_to_xml_and_xmlschema(PG_FUNCTION_ARGS); +extern Datum xpath(PG_FUNCTION_ARGS); +extern Datum schema_to_xml(PG_FUNCTION_ARGS); +extern Datum schema_to_xmlschema(PG_FUNCTION_ARGS); +extern Datum schema_to_xml_and_xmlschema(PG_FUNCTION_ARGS); +extern Datum database_to_xml(PG_FUNCTION_ARGS); +extern Datum database_to_xmlschema(PG_FUNCTION_ARGS); +extern Datum database_to_xml_and_xmlschema(PG_FUNCTION_ARGS); +extern Datum pg_snapshot_in(PG_FUNCTION_ARGS); +extern Datum pg_snapshot_out(PG_FUNCTION_ARGS); +extern Datum pg_snapshot_recv(PG_FUNCTION_ARGS); +extern Datum pg_snapshot_send(PG_FUNCTION_ARGS); +extern Datum pg_current_xact_id(PG_FUNCTION_ARGS); +extern Datum pg_current_snapshot(PG_FUNCTION_ARGS); +extern Datum pg_snapshot_xmin(PG_FUNCTION_ARGS); +extern Datum pg_snapshot_xmax(PG_FUNCTION_ARGS); +extern Datum pg_snapshot_xip(PG_FUNCTION_ARGS); +extern Datum pg_visible_in_snapshot(PG_FUNCTION_ARGS); +extern Datum uuid_in(PG_FUNCTION_ARGS); +extern Datum uuid_out(PG_FUNCTION_ARGS); +extern Datum uuid_lt(PG_FUNCTION_ARGS); +extern Datum uuid_le(PG_FUNCTION_ARGS); +extern Datum uuid_eq(PG_FUNCTION_ARGS); +extern Datum uuid_ge(PG_FUNCTION_ARGS); +extern Datum uuid_gt(PG_FUNCTION_ARGS); +extern Datum uuid_ne(PG_FUNCTION_ARGS); +extern Datum uuid_cmp(PG_FUNCTION_ARGS); +extern Datum uuid_recv(PG_FUNCTION_ARGS); +extern Datum uuid_send(PG_FUNCTION_ARGS); +extern Datum uuid_hash(PG_FUNCTION_ARGS); +extern Datum booltext(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_function_calls(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_function_total_time(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_function_self_time(PG_FUNCTION_ARGS); +extern Datum record_eq(PG_FUNCTION_ARGS); +extern Datum record_ne(PG_FUNCTION_ARGS); +extern Datum record_lt(PG_FUNCTION_ARGS); +extern Datum record_gt(PG_FUNCTION_ARGS); +extern Datum record_le(PG_FUNCTION_ARGS); +extern Datum record_ge(PG_FUNCTION_ARGS); +extern Datum btrecordcmp(PG_FUNCTION_ARGS); +extern Datum pg_table_size(PG_FUNCTION_ARGS); +extern Datum pg_indexes_size(PG_FUNCTION_ARGS); +extern Datum pg_relation_filenode(PG_FUNCTION_ARGS); +extern Datum has_foreign_data_wrapper_privilege_name_name(PG_FUNCTION_ARGS); +extern Datum has_foreign_data_wrapper_privilege_name_id(PG_FUNCTION_ARGS); +extern Datum has_foreign_data_wrapper_privilege_id_name(PG_FUNCTION_ARGS); +extern Datum has_foreign_data_wrapper_privilege_id_id(PG_FUNCTION_ARGS); +extern Datum has_foreign_data_wrapper_privilege_name(PG_FUNCTION_ARGS); +extern Datum has_foreign_data_wrapper_privilege_id(PG_FUNCTION_ARGS); +extern Datum has_server_privilege_name_name(PG_FUNCTION_ARGS); +extern Datum has_server_privilege_name_id(PG_FUNCTION_ARGS); +extern Datum has_server_privilege_id_name(PG_FUNCTION_ARGS); +extern Datum has_server_privilege_id_id(PG_FUNCTION_ARGS); +extern Datum has_server_privilege_name(PG_FUNCTION_ARGS); +extern Datum has_server_privilege_id(PG_FUNCTION_ARGS); +extern Datum has_column_privilege_name_name_name(PG_FUNCTION_ARGS); +extern Datum has_column_privilege_name_name_attnum(PG_FUNCTION_ARGS); +extern Datum has_column_privilege_name_id_name(PG_FUNCTION_ARGS); +extern Datum has_column_privilege_name_id_attnum(PG_FUNCTION_ARGS); +extern Datum has_column_privilege_id_name_name(PG_FUNCTION_ARGS); +extern Datum has_column_privilege_id_name_attnum(PG_FUNCTION_ARGS); +extern Datum has_column_privilege_id_id_name(PG_FUNCTION_ARGS); +extern Datum has_column_privilege_id_id_attnum(PG_FUNCTION_ARGS); +extern Datum has_column_privilege_name_name(PG_FUNCTION_ARGS); +extern Datum has_column_privilege_name_attnum(PG_FUNCTION_ARGS); +extern Datum has_column_privilege_id_name(PG_FUNCTION_ARGS); +extern Datum has_column_privilege_id_attnum(PG_FUNCTION_ARGS); +extern Datum has_any_column_privilege_name_name(PG_FUNCTION_ARGS); +extern Datum has_any_column_privilege_name_id(PG_FUNCTION_ARGS); +extern Datum has_any_column_privilege_id_name(PG_FUNCTION_ARGS); +extern Datum has_any_column_privilege_id_id(PG_FUNCTION_ARGS); +extern Datum has_any_column_privilege_name(PG_FUNCTION_ARGS); +extern Datum has_any_column_privilege_id(PG_FUNCTION_ARGS); +extern Datum bitoverlay(PG_FUNCTION_ARGS); +extern Datum bitoverlay_no_len(PG_FUNCTION_ARGS); +extern Datum bitgetbit(PG_FUNCTION_ARGS); +extern Datum bitsetbit(PG_FUNCTION_ARGS); +extern Datum pg_relation_filepath(PG_FUNCTION_ARGS); +extern Datum pg_listening_channels(PG_FUNCTION_ARGS); +extern Datum pg_notify(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_xact_numscans(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_xact_tuples_returned(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_xact_tuples_fetched(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_xact_tuples_inserted(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_xact_tuples_updated(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_xact_tuples_deleted(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_xact_tuples_hot_updated(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_xact_blocks_fetched(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_xact_blocks_hit(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_xact_function_calls(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_xact_function_total_time(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_xact_function_self_time(PG_FUNCTION_ARGS); +extern Datum xpath_exists(PG_FUNCTION_ARGS); +extern Datum xml_is_well_formed(PG_FUNCTION_ARGS); +extern Datum xml_is_well_formed_document(PG_FUNCTION_ARGS); +extern Datum xml_is_well_formed_content(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_vacuum_count(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_autovacuum_count(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_analyze_count(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_autoanalyze_count(PG_FUNCTION_ARGS); +extern Datum text_concat(PG_FUNCTION_ARGS); +extern Datum text_concat_ws(PG_FUNCTION_ARGS); +extern Datum text_left(PG_FUNCTION_ARGS); +extern Datum text_right(PG_FUNCTION_ARGS); +extern Datum text_reverse(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_buf_fsync_backend(PG_FUNCTION_ARGS); +extern Datum gist_point_distance(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_db_conflict_tablespace(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_db_conflict_lock(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_db_conflict_snapshot(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_db_conflict_bufferpin(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_db_conflict_startup_deadlock(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_db_conflict_all(PG_FUNCTION_ARGS); +extern Datum pg_wal_replay_pause(PG_FUNCTION_ARGS); +extern Datum pg_wal_replay_resume(PG_FUNCTION_ARGS); +extern Datum pg_is_wal_replay_paused(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_db_stat_reset_time(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_bgwriter_stat_reset_time(PG_FUNCTION_ARGS); +extern Datum ginarrayextract_2args(PG_FUNCTION_ARGS); +extern Datum gin_extract_tsvector_2args(PG_FUNCTION_ARGS); +extern Datum pg_sequence_parameters(PG_FUNCTION_ARGS); +extern Datum pg_available_extensions(PG_FUNCTION_ARGS); +extern Datum pg_available_extension_versions(PG_FUNCTION_ARGS); +extern Datum pg_extension_update_paths(PG_FUNCTION_ARGS); +extern Datum pg_extension_config_dump(PG_FUNCTION_ARGS); +extern Datum gin_extract_tsquery_5args(PG_FUNCTION_ARGS); +extern Datum gin_tsquery_consistent_6args(PG_FUNCTION_ARGS); +extern Datum pg_advisory_xact_lock_int8(PG_FUNCTION_ARGS); +extern Datum pg_advisory_xact_lock_shared_int8(PG_FUNCTION_ARGS); +extern Datum pg_try_advisory_xact_lock_int8(PG_FUNCTION_ARGS); +extern Datum pg_try_advisory_xact_lock_shared_int8(PG_FUNCTION_ARGS); +extern Datum pg_advisory_xact_lock_int4(PG_FUNCTION_ARGS); +extern Datum pg_advisory_xact_lock_shared_int4(PG_FUNCTION_ARGS); +extern Datum pg_try_advisory_xact_lock_int4(PG_FUNCTION_ARGS); +extern Datum pg_try_advisory_xact_lock_shared_int4(PG_FUNCTION_ARGS); +extern Datum varchar_support(PG_FUNCTION_ARGS); +extern Datum pg_create_restore_point(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_wal_senders(PG_FUNCTION_ARGS); +extern Datum window_row_number(PG_FUNCTION_ARGS); +extern Datum window_rank(PG_FUNCTION_ARGS); +extern Datum window_dense_rank(PG_FUNCTION_ARGS); +extern Datum window_percent_rank(PG_FUNCTION_ARGS); +extern Datum window_cume_dist(PG_FUNCTION_ARGS); +extern Datum window_ntile(PG_FUNCTION_ARGS); +extern Datum window_lag(PG_FUNCTION_ARGS); +extern Datum window_lag_with_offset(PG_FUNCTION_ARGS); +extern Datum window_lag_with_offset_and_default(PG_FUNCTION_ARGS); +extern Datum window_lead(PG_FUNCTION_ARGS); +extern Datum window_lead_with_offset(PG_FUNCTION_ARGS); +extern Datum window_lead_with_offset_and_default(PG_FUNCTION_ARGS); +extern Datum window_first_value(PG_FUNCTION_ARGS); +extern Datum window_last_value(PG_FUNCTION_ARGS); +extern Datum window_nth_value(PG_FUNCTION_ARGS); +extern Datum fdw_handler_in(PG_FUNCTION_ARGS); +extern Datum fdw_handler_out(PG_FUNCTION_ARGS); +extern Datum void_recv(PG_FUNCTION_ARGS); +extern Datum void_send(PG_FUNCTION_ARGS); +extern Datum btint2sortsupport(PG_FUNCTION_ARGS); +extern Datum btint4sortsupport(PG_FUNCTION_ARGS); +extern Datum btint8sortsupport(PG_FUNCTION_ARGS); +extern Datum btfloat4sortsupport(PG_FUNCTION_ARGS); +extern Datum btfloat8sortsupport(PG_FUNCTION_ARGS); +extern Datum btoidsortsupport(PG_FUNCTION_ARGS); +extern Datum btnamesortsupport(PG_FUNCTION_ARGS); +extern Datum date_sortsupport(PG_FUNCTION_ARGS); +extern Datum timestamp_sortsupport(PG_FUNCTION_ARGS); +extern Datum has_type_privilege_name_name(PG_FUNCTION_ARGS); +extern Datum has_type_privilege_name_id(PG_FUNCTION_ARGS); +extern Datum has_type_privilege_id_name(PG_FUNCTION_ARGS); +extern Datum has_type_privilege_id_id(PG_FUNCTION_ARGS); +extern Datum has_type_privilege_name(PG_FUNCTION_ARGS); +extern Datum has_type_privilege_id(PG_FUNCTION_ARGS); +extern Datum macaddr_not(PG_FUNCTION_ARGS); +extern Datum macaddr_and(PG_FUNCTION_ARGS); +extern Datum macaddr_or(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_db_temp_files(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_db_temp_bytes(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_db_deadlocks(PG_FUNCTION_ARGS); +extern Datum array_to_json(PG_FUNCTION_ARGS); +extern Datum array_to_json_pretty(PG_FUNCTION_ARGS); +extern Datum row_to_json(PG_FUNCTION_ARGS); +extern Datum row_to_json_pretty(PG_FUNCTION_ARGS); +extern Datum numeric_support(PG_FUNCTION_ARGS); +extern Datum varbit_support(PG_FUNCTION_ARGS); +extern Datum pg_get_viewdef_wrap(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_checkpoint_write_time(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_checkpoint_sync_time(PG_FUNCTION_ARGS); +extern Datum pg_collation_for(PG_FUNCTION_ARGS); +extern Datum pg_trigger_depth(PG_FUNCTION_ARGS); +extern Datum pg_wal_lsn_diff(PG_FUNCTION_ARGS); +extern Datum pg_size_pretty_numeric(PG_FUNCTION_ARGS); +extern Datum array_remove(PG_FUNCTION_ARGS); +extern Datum array_replace(PG_FUNCTION_ARGS); +extern Datum rangesel(PG_FUNCTION_ARGS); +extern Datum be_lo_lseek64(PG_FUNCTION_ARGS); +extern Datum be_lo_tell64(PG_FUNCTION_ARGS); +extern Datum be_lo_truncate64(PG_FUNCTION_ARGS); +extern Datum json_agg_transfn(PG_FUNCTION_ARGS); +extern Datum json_agg_finalfn(PG_FUNCTION_ARGS); +extern Datum to_json(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_mod_since_analyze(PG_FUNCTION_ARGS); +extern Datum numeric_sum(PG_FUNCTION_ARGS); +extern Datum array_cardinality(PG_FUNCTION_ARGS); +extern Datum json_object_agg_transfn(PG_FUNCTION_ARGS); +extern Datum record_image_eq(PG_FUNCTION_ARGS); +extern Datum record_image_ne(PG_FUNCTION_ARGS); +extern Datum record_image_lt(PG_FUNCTION_ARGS); +extern Datum record_image_gt(PG_FUNCTION_ARGS); +extern Datum record_image_le(PG_FUNCTION_ARGS); +extern Datum record_image_ge(PG_FUNCTION_ARGS); +extern Datum btrecordimagecmp(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_archiver(PG_FUNCTION_ARGS); +extern Datum json_object_agg_finalfn(PG_FUNCTION_ARGS); +extern Datum json_build_array(PG_FUNCTION_ARGS); +extern Datum json_build_array_noargs(PG_FUNCTION_ARGS); +extern Datum json_build_object(PG_FUNCTION_ARGS); +extern Datum json_build_object_noargs(PG_FUNCTION_ARGS); +extern Datum json_object(PG_FUNCTION_ARGS); +extern Datum json_object_two_arg(PG_FUNCTION_ARGS); +extern Datum json_to_record(PG_FUNCTION_ARGS); +extern Datum json_to_recordset(PG_FUNCTION_ARGS); +extern Datum jsonb_array_length(PG_FUNCTION_ARGS); +extern Datum jsonb_each(PG_FUNCTION_ARGS); +extern Datum jsonb_populate_record(PG_FUNCTION_ARGS); +extern Datum jsonb_typeof(PG_FUNCTION_ARGS); +extern Datum jsonb_object_field_text(PG_FUNCTION_ARGS); +extern Datum jsonb_array_element(PG_FUNCTION_ARGS); +extern Datum jsonb_array_element_text(PG_FUNCTION_ARGS); +extern Datum jsonb_extract_path(PG_FUNCTION_ARGS); +extern Datum width_bucket_array(PG_FUNCTION_ARGS); +extern Datum jsonb_array_elements(PG_FUNCTION_ARGS); +extern Datum pg_lsn_in(PG_FUNCTION_ARGS); +extern Datum pg_lsn_out(PG_FUNCTION_ARGS); +extern Datum pg_lsn_lt(PG_FUNCTION_ARGS); +extern Datum pg_lsn_le(PG_FUNCTION_ARGS); +extern Datum pg_lsn_eq(PG_FUNCTION_ARGS); +extern Datum pg_lsn_ge(PG_FUNCTION_ARGS); +extern Datum pg_lsn_gt(PG_FUNCTION_ARGS); +extern Datum pg_lsn_ne(PG_FUNCTION_ARGS); +extern Datum pg_lsn_mi(PG_FUNCTION_ARGS); +extern Datum pg_lsn_recv(PG_FUNCTION_ARGS); +extern Datum pg_lsn_send(PG_FUNCTION_ARGS); +extern Datum pg_lsn_cmp(PG_FUNCTION_ARGS); +extern Datum pg_lsn_hash(PG_FUNCTION_ARGS); +extern Datum bttextsortsupport(PG_FUNCTION_ARGS); +extern Datum generate_series_step_numeric(PG_FUNCTION_ARGS); +extern Datum generate_series_numeric(PG_FUNCTION_ARGS); +extern Datum json_strip_nulls(PG_FUNCTION_ARGS); +extern Datum jsonb_strip_nulls(PG_FUNCTION_ARGS); +extern Datum jsonb_object(PG_FUNCTION_ARGS); +extern Datum jsonb_object_two_arg(PG_FUNCTION_ARGS); +extern Datum jsonb_agg_transfn(PG_FUNCTION_ARGS); +extern Datum jsonb_agg_finalfn(PG_FUNCTION_ARGS); +extern Datum jsonb_object_agg_transfn(PG_FUNCTION_ARGS); +extern Datum jsonb_object_agg_finalfn(PG_FUNCTION_ARGS); +extern Datum jsonb_build_array(PG_FUNCTION_ARGS); +extern Datum jsonb_build_array_noargs(PG_FUNCTION_ARGS); +extern Datum jsonb_build_object(PG_FUNCTION_ARGS); +extern Datum jsonb_build_object_noargs(PG_FUNCTION_ARGS); +extern Datum dist_ppoly(PG_FUNCTION_ARGS); +extern Datum array_position(PG_FUNCTION_ARGS); +extern Datum array_position_start(PG_FUNCTION_ARGS); +extern Datum array_positions(PG_FUNCTION_ARGS); +extern Datum gist_circle_distance(PG_FUNCTION_ARGS); +extern Datum numeric_scale(PG_FUNCTION_ARGS); +extern Datum gist_point_fetch(PG_FUNCTION_ARGS); +extern Datum numeric_sortsupport(PG_FUNCTION_ARGS); +extern Datum gist_poly_distance(PG_FUNCTION_ARGS); +extern Datum dist_cpoint(PG_FUNCTION_ARGS); +extern Datum dist_polyp(PG_FUNCTION_ARGS); +extern Datum pg_read_file_v2(PG_FUNCTION_ARGS); +extern Datum show_config_by_name_missing_ok(PG_FUNCTION_ARGS); +extern Datum pg_read_binary_file(PG_FUNCTION_ARGS); +extern Datum pg_notification_queue_usage(PG_FUNCTION_ARGS); +extern Datum pg_ls_dir(PG_FUNCTION_ARGS); +extern Datum row_security_active(PG_FUNCTION_ARGS); +extern Datum row_security_active_name(PG_FUNCTION_ARGS); +extern Datum uuid_sortsupport(PG_FUNCTION_ARGS); +extern Datum jsonb_concat(PG_FUNCTION_ARGS); +extern Datum jsonb_delete(PG_FUNCTION_ARGS); +extern Datum jsonb_delete_idx(PG_FUNCTION_ARGS); +extern Datum jsonb_delete_path(PG_FUNCTION_ARGS); +extern Datum jsonb_set(PG_FUNCTION_ARGS); +extern Datum jsonb_pretty(PG_FUNCTION_ARGS); +extern Datum pg_stat_file(PG_FUNCTION_ARGS); +extern Datum xidneq(PG_FUNCTION_ARGS); +extern Datum tsm_handler_in(PG_FUNCTION_ARGS); +extern Datum tsm_handler_out(PG_FUNCTION_ARGS); +extern Datum tsm_bernoulli_handler(PG_FUNCTION_ARGS); +extern Datum tsm_system_handler(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_wal_receiver(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_progress_info(PG_FUNCTION_ARGS); +extern Datum tsvector_filter(PG_FUNCTION_ARGS); +extern Datum tsvector_setweight_by_filter(PG_FUNCTION_ARGS); +extern Datum tsvector_delete_str(PG_FUNCTION_ARGS); +extern Datum tsvector_unnest(PG_FUNCTION_ARGS); +extern Datum tsvector_delete_arr(PG_FUNCTION_ARGS); +extern Datum int4_avg_combine(PG_FUNCTION_ARGS); +extern Datum interval_combine(PG_FUNCTION_ARGS); +extern Datum tsvector_to_array(PG_FUNCTION_ARGS); +extern Datum array_to_tsvector(PG_FUNCTION_ARGS); +extern Datum bpchar_sortsupport(PG_FUNCTION_ARGS); +extern Datum show_all_file_settings(PG_FUNCTION_ARGS); +extern Datum pg_current_wal_flush_lsn(PG_FUNCTION_ARGS); +extern Datum bytea_sortsupport(PG_FUNCTION_ARGS); +extern Datum bttext_pattern_sortsupport(PG_FUNCTION_ARGS); +extern Datum btbpchar_pattern_sortsupport(PG_FUNCTION_ARGS); +extern Datum pg_size_bytes(PG_FUNCTION_ARGS); +extern Datum numeric_serialize(PG_FUNCTION_ARGS); +extern Datum numeric_deserialize(PG_FUNCTION_ARGS); +extern Datum numeric_avg_combine(PG_FUNCTION_ARGS); +extern Datum numeric_poly_combine(PG_FUNCTION_ARGS); +extern Datum numeric_poly_serialize(PG_FUNCTION_ARGS); +extern Datum numeric_poly_deserialize(PG_FUNCTION_ARGS); +extern Datum numeric_combine(PG_FUNCTION_ARGS); +extern Datum float8_regr_combine(PG_FUNCTION_ARGS); +extern Datum jsonb_delete_array(PG_FUNCTION_ARGS); +extern Datum cash_mul_int8(PG_FUNCTION_ARGS); +extern Datum cash_div_int8(PG_FUNCTION_ARGS); +extern Datum pg_current_xact_id_if_assigned(PG_FUNCTION_ARGS); +extern Datum pg_get_partkeydef(PG_FUNCTION_ARGS); +extern Datum pg_ls_logdir(PG_FUNCTION_ARGS); +extern Datum pg_ls_waldir(PG_FUNCTION_ARGS); +extern Datum pg_ndistinct_in(PG_FUNCTION_ARGS); +extern Datum pg_ndistinct_out(PG_FUNCTION_ARGS); +extern Datum pg_ndistinct_recv(PG_FUNCTION_ARGS); +extern Datum pg_ndistinct_send(PG_FUNCTION_ARGS); +extern Datum macaddr_sortsupport(PG_FUNCTION_ARGS); +extern Datum pg_xact_status(PG_FUNCTION_ARGS); +extern Datum pg_safe_snapshot_blocking_pids(PG_FUNCTION_ARGS); +extern Datum pg_isolation_test_session_is_blocked(PG_FUNCTION_ARGS); +extern Datum pg_identify_object_as_address(PG_FUNCTION_ARGS); +extern Datum brin_minmax_opcinfo(PG_FUNCTION_ARGS); +extern Datum brin_minmax_add_value(PG_FUNCTION_ARGS); +extern Datum brin_minmax_consistent(PG_FUNCTION_ARGS); +extern Datum brin_minmax_union(PG_FUNCTION_ARGS); +extern Datum int8_avg_accum_inv(PG_FUNCTION_ARGS); +extern Datum numeric_poly_sum(PG_FUNCTION_ARGS); +extern Datum numeric_poly_avg(PG_FUNCTION_ARGS); +extern Datum numeric_poly_var_pop(PG_FUNCTION_ARGS); +extern Datum numeric_poly_var_samp(PG_FUNCTION_ARGS); +extern Datum numeric_poly_stddev_pop(PG_FUNCTION_ARGS); +extern Datum numeric_poly_stddev_samp(PG_FUNCTION_ARGS); +extern Datum regexp_match_no_flags(PG_FUNCTION_ARGS); +extern Datum regexp_match(PG_FUNCTION_ARGS); +extern Datum int8_mul_cash(PG_FUNCTION_ARGS); +extern Datum pg_config(PG_FUNCTION_ARGS); +extern Datum pg_hba_file_rules(PG_FUNCTION_ARGS); +extern Datum pg_statistics_obj_is_visible(PG_FUNCTION_ARGS); +extern Datum pg_dependencies_in(PG_FUNCTION_ARGS); +extern Datum pg_dependencies_out(PG_FUNCTION_ARGS); +extern Datum pg_dependencies_recv(PG_FUNCTION_ARGS); +extern Datum pg_dependencies_send(PG_FUNCTION_ARGS); +extern Datum pg_get_partition_constraintdef(PG_FUNCTION_ARGS); +extern Datum time_hash_extended(PG_FUNCTION_ARGS); +extern Datum timetz_hash_extended(PG_FUNCTION_ARGS); +extern Datum timestamp_hash_extended(PG_FUNCTION_ARGS); +extern Datum uuid_hash_extended(PG_FUNCTION_ARGS); +extern Datum pg_lsn_hash_extended(PG_FUNCTION_ARGS); +extern Datum hashenumextended(PG_FUNCTION_ARGS); +extern Datum pg_get_statisticsobjdef(PG_FUNCTION_ARGS); +extern Datum jsonb_hash_extended(PG_FUNCTION_ARGS); +extern Datum hash_range_extended(PG_FUNCTION_ARGS); +extern Datum interval_hash_extended(PG_FUNCTION_ARGS); +extern Datum sha224_bytea(PG_FUNCTION_ARGS); +extern Datum sha256_bytea(PG_FUNCTION_ARGS); +extern Datum sha384_bytea(PG_FUNCTION_ARGS); +extern Datum sha512_bytea(PG_FUNCTION_ARGS); +extern Datum pg_partition_tree(PG_FUNCTION_ARGS); +extern Datum pg_partition_root(PG_FUNCTION_ARGS); +extern Datum pg_partition_ancestors(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_db_checksum_failures(PG_FUNCTION_ARGS); +extern Datum pg_stats_ext_mcvlist_items(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_db_checksum_last_failure(PG_FUNCTION_ARGS); +extern Datum gen_random_uuid(PG_FUNCTION_ARGS); +extern Datum gtsvector_options(PG_FUNCTION_ARGS); +extern Datum gist_point_sortsupport(PG_FUNCTION_ARGS); +extern Datum pg_promote(PG_FUNCTION_ARGS); +extern Datum prefixsel(PG_FUNCTION_ARGS); +extern Datum prefixjoinsel(PG_FUNCTION_ARGS); +extern Datum pg_control_system(PG_FUNCTION_ARGS); +extern Datum pg_control_checkpoint(PG_FUNCTION_ARGS); +extern Datum pg_control_recovery(PG_FUNCTION_ARGS); +extern Datum pg_control_init(PG_FUNCTION_ARGS); +extern Datum pg_import_system_collations(PG_FUNCTION_ARGS); +extern Datum macaddr8_recv(PG_FUNCTION_ARGS); +extern Datum macaddr8_send(PG_FUNCTION_ARGS); +extern Datum pg_collation_actual_version(PG_FUNCTION_ARGS); +extern Datum jsonb_numeric(PG_FUNCTION_ARGS); +extern Datum jsonb_int2(PG_FUNCTION_ARGS); +extern Datum jsonb_int4(PG_FUNCTION_ARGS); +extern Datum jsonb_int8(PG_FUNCTION_ARGS); +extern Datum jsonb_float4(PG_FUNCTION_ARGS); +extern Datum pg_filenode_relation(PG_FUNCTION_ARGS); +extern Datum be_lo_from_bytea(PG_FUNCTION_ARGS); +extern Datum be_lo_get(PG_FUNCTION_ARGS); +extern Datum be_lo_get_fragment(PG_FUNCTION_ARGS); +extern Datum be_lo_put(PG_FUNCTION_ARGS); +extern Datum make_timestamp(PG_FUNCTION_ARGS); +extern Datum make_timestamptz(PG_FUNCTION_ARGS); +extern Datum make_timestamptz_at_timezone(PG_FUNCTION_ARGS); +extern Datum make_interval(PG_FUNCTION_ARGS); +extern Datum jsonb_array_elements_text(PG_FUNCTION_ARGS); +extern Datum spg_range_quad_config(PG_FUNCTION_ARGS); +extern Datum spg_range_quad_choose(PG_FUNCTION_ARGS); +extern Datum spg_range_quad_picksplit(PG_FUNCTION_ARGS); +extern Datum spg_range_quad_inner_consistent(PG_FUNCTION_ARGS); +extern Datum spg_range_quad_leaf_consistent(PG_FUNCTION_ARGS); +extern Datum jsonb_populate_recordset(PG_FUNCTION_ARGS); +extern Datum to_regoperator(PG_FUNCTION_ARGS); +extern Datum jsonb_object_field(PG_FUNCTION_ARGS); +extern Datum to_regprocedure(PG_FUNCTION_ARGS); +extern Datum gin_compare_jsonb(PG_FUNCTION_ARGS); +extern Datum gin_extract_jsonb(PG_FUNCTION_ARGS); +extern Datum gin_extract_jsonb_query(PG_FUNCTION_ARGS); +extern Datum gin_consistent_jsonb(PG_FUNCTION_ARGS); +extern Datum gin_extract_jsonb_path(PG_FUNCTION_ARGS); +extern Datum gin_extract_jsonb_query_path(PG_FUNCTION_ARGS); +extern Datum gin_consistent_jsonb_path(PG_FUNCTION_ARGS); +extern Datum gin_triconsistent_jsonb(PG_FUNCTION_ARGS); +extern Datum gin_triconsistent_jsonb_path(PG_FUNCTION_ARGS); +extern Datum jsonb_to_record(PG_FUNCTION_ARGS); +extern Datum jsonb_to_recordset(PG_FUNCTION_ARGS); +extern Datum to_regoper(PG_FUNCTION_ARGS); +extern Datum to_regtype(PG_FUNCTION_ARGS); +extern Datum to_regproc(PG_FUNCTION_ARGS); +extern Datum to_regclass(PG_FUNCTION_ARGS); +extern Datum bool_accum(PG_FUNCTION_ARGS); +extern Datum bool_accum_inv(PG_FUNCTION_ARGS); +extern Datum bool_alltrue(PG_FUNCTION_ARGS); +extern Datum bool_anytrue(PG_FUNCTION_ARGS); +extern Datum anyenum_in(PG_FUNCTION_ARGS); +extern Datum anyenum_out(PG_FUNCTION_ARGS); +extern Datum enum_in(PG_FUNCTION_ARGS); +extern Datum enum_out(PG_FUNCTION_ARGS); +extern Datum enum_eq(PG_FUNCTION_ARGS); +extern Datum enum_ne(PG_FUNCTION_ARGS); +extern Datum enum_lt(PG_FUNCTION_ARGS); +extern Datum enum_gt(PG_FUNCTION_ARGS); +extern Datum enum_le(PG_FUNCTION_ARGS); +extern Datum enum_ge(PG_FUNCTION_ARGS); +extern Datum enum_cmp(PG_FUNCTION_ARGS); +extern Datum hashenum(PG_FUNCTION_ARGS); +extern Datum enum_smaller(PG_FUNCTION_ARGS); +extern Datum enum_larger(PG_FUNCTION_ARGS); +extern Datum enum_first(PG_FUNCTION_ARGS); +extern Datum enum_last(PG_FUNCTION_ARGS); +extern Datum enum_range_bounds(PG_FUNCTION_ARGS); +extern Datum enum_range_all(PG_FUNCTION_ARGS); +extern Datum enum_recv(PG_FUNCTION_ARGS); +extern Datum enum_send(PG_FUNCTION_ARGS); +extern Datum string_agg_transfn(PG_FUNCTION_ARGS); +extern Datum string_agg_finalfn(PG_FUNCTION_ARGS); +extern Datum pg_describe_object(PG_FUNCTION_ARGS); +extern Datum text_format(PG_FUNCTION_ARGS); +extern Datum text_format_nv(PG_FUNCTION_ARGS); +extern Datum bytea_string_agg_transfn(PG_FUNCTION_ARGS); +extern Datum bytea_string_agg_finalfn(PG_FUNCTION_ARGS); +extern Datum int8dec(PG_FUNCTION_ARGS); +extern Datum int8dec_any(PG_FUNCTION_ARGS); +extern Datum numeric_accum_inv(PG_FUNCTION_ARGS); +extern Datum interval_accum_inv(PG_FUNCTION_ARGS); +extern Datum network_overlap(PG_FUNCTION_ARGS); +extern Datum inet_gist_consistent(PG_FUNCTION_ARGS); +extern Datum inet_gist_union(PG_FUNCTION_ARGS); +extern Datum inet_gist_compress(PG_FUNCTION_ARGS); +extern Datum jsonb_bool(PG_FUNCTION_ARGS); +extern Datum inet_gist_penalty(PG_FUNCTION_ARGS); +extern Datum inet_gist_picksplit(PG_FUNCTION_ARGS); +extern Datum inet_gist_same(PG_FUNCTION_ARGS); +extern Datum networksel(PG_FUNCTION_ARGS); +extern Datum networkjoinsel(PG_FUNCTION_ARGS); +extern Datum network_larger(PG_FUNCTION_ARGS); +extern Datum network_smaller(PG_FUNCTION_ARGS); +extern Datum pg_event_trigger_dropped_objects(PG_FUNCTION_ARGS); +extern Datum int2_accum_inv(PG_FUNCTION_ARGS); +extern Datum int4_accum_inv(PG_FUNCTION_ARGS); +extern Datum int8_accum_inv(PG_FUNCTION_ARGS); +extern Datum int2_avg_accum_inv(PG_FUNCTION_ARGS); +extern Datum int4_avg_accum_inv(PG_FUNCTION_ARGS); +extern Datum int2int4_sum(PG_FUNCTION_ARGS); +extern Datum inet_gist_fetch(PG_FUNCTION_ARGS); +extern Datum pg_logical_emit_message_text(PG_FUNCTION_ARGS); +extern Datum pg_logical_emit_message_bytea(PG_FUNCTION_ARGS); +extern Datum jsonb_insert(PG_FUNCTION_ARGS); +extern Datum pg_xact_commit_timestamp(PG_FUNCTION_ARGS); +extern Datum binary_upgrade_set_next_pg_type_oid(PG_FUNCTION_ARGS); +extern Datum pg_last_committed_xact(PG_FUNCTION_ARGS); +extern Datum binary_upgrade_set_next_array_pg_type_oid(PG_FUNCTION_ARGS); +extern Datum binary_upgrade_set_next_heap_pg_class_oid(PG_FUNCTION_ARGS); +extern Datum binary_upgrade_set_next_index_pg_class_oid(PG_FUNCTION_ARGS); +extern Datum binary_upgrade_set_next_toast_pg_class_oid(PG_FUNCTION_ARGS); +extern Datum binary_upgrade_set_next_pg_enum_oid(PG_FUNCTION_ARGS); +extern Datum binary_upgrade_set_next_pg_authid_oid(PG_FUNCTION_ARGS); +extern Datum binary_upgrade_create_empty_extension(PG_FUNCTION_ARGS); +extern Datum event_trigger_in(PG_FUNCTION_ARGS); +extern Datum event_trigger_out(PG_FUNCTION_ARGS); +extern Datum tsvectorin(PG_FUNCTION_ARGS); +extern Datum tsvectorout(PG_FUNCTION_ARGS); +extern Datum tsqueryin(PG_FUNCTION_ARGS); +extern Datum tsqueryout(PG_FUNCTION_ARGS); +extern Datum tsvector_lt(PG_FUNCTION_ARGS); +extern Datum tsvector_le(PG_FUNCTION_ARGS); +extern Datum tsvector_eq(PG_FUNCTION_ARGS); +extern Datum tsvector_ne(PG_FUNCTION_ARGS); +extern Datum tsvector_ge(PG_FUNCTION_ARGS); +extern Datum tsvector_gt(PG_FUNCTION_ARGS); +extern Datum tsvector_cmp(PG_FUNCTION_ARGS); +extern Datum tsvector_strip(PG_FUNCTION_ARGS); +extern Datum tsvector_setweight(PG_FUNCTION_ARGS); +extern Datum tsvector_concat(PG_FUNCTION_ARGS); +extern Datum ts_match_vq(PG_FUNCTION_ARGS); +extern Datum ts_match_qv(PG_FUNCTION_ARGS); +extern Datum tsvectorsend(PG_FUNCTION_ARGS); +extern Datum tsvectorrecv(PG_FUNCTION_ARGS); +extern Datum tsquerysend(PG_FUNCTION_ARGS); +extern Datum tsqueryrecv(PG_FUNCTION_ARGS); +extern Datum gtsvectorin(PG_FUNCTION_ARGS); +extern Datum gtsvectorout(PG_FUNCTION_ARGS); +extern Datum gtsvector_compress(PG_FUNCTION_ARGS); +extern Datum gtsvector_decompress(PG_FUNCTION_ARGS); +extern Datum gtsvector_picksplit(PG_FUNCTION_ARGS); +extern Datum gtsvector_union(PG_FUNCTION_ARGS); +extern Datum gtsvector_same(PG_FUNCTION_ARGS); +extern Datum gtsvector_penalty(PG_FUNCTION_ARGS); +extern Datum gtsvector_consistent(PG_FUNCTION_ARGS); +extern Datum gin_extract_tsvector(PG_FUNCTION_ARGS); +extern Datum gin_extract_tsquery(PG_FUNCTION_ARGS); +extern Datum gin_tsquery_consistent(PG_FUNCTION_ARGS); +extern Datum tsquery_lt(PG_FUNCTION_ARGS); +extern Datum tsquery_le(PG_FUNCTION_ARGS); +extern Datum tsquery_eq(PG_FUNCTION_ARGS); +extern Datum tsquery_ne(PG_FUNCTION_ARGS); +extern Datum tsquery_ge(PG_FUNCTION_ARGS); +extern Datum tsquery_gt(PG_FUNCTION_ARGS); +extern Datum tsquery_cmp(PG_FUNCTION_ARGS); +extern Datum tsquery_and(PG_FUNCTION_ARGS); +extern Datum tsquery_or(PG_FUNCTION_ARGS); +extern Datum tsquery_not(PG_FUNCTION_ARGS); +extern Datum tsquery_numnode(PG_FUNCTION_ARGS); +extern Datum tsquerytree(PG_FUNCTION_ARGS); +extern Datum tsquery_rewrite(PG_FUNCTION_ARGS); +extern Datum tsquery_rewrite_query(PG_FUNCTION_ARGS); +extern Datum tsmatchsel(PG_FUNCTION_ARGS); +extern Datum tsmatchjoinsel(PG_FUNCTION_ARGS); +extern Datum ts_typanalyze(PG_FUNCTION_ARGS); +extern Datum ts_stat1(PG_FUNCTION_ARGS); +extern Datum ts_stat2(PG_FUNCTION_ARGS); +extern Datum tsq_mcontains(PG_FUNCTION_ARGS); +extern Datum tsq_mcontained(PG_FUNCTION_ARGS); +extern Datum gtsquery_compress(PG_FUNCTION_ARGS); +extern Datum text_starts_with(PG_FUNCTION_ARGS); +extern Datum gtsquery_picksplit(PG_FUNCTION_ARGS); +extern Datum gtsquery_union(PG_FUNCTION_ARGS); +extern Datum gtsquery_same(PG_FUNCTION_ARGS); +extern Datum gtsquery_penalty(PG_FUNCTION_ARGS); +extern Datum gtsquery_consistent(PG_FUNCTION_ARGS); +extern Datum ts_rank_wttf(PG_FUNCTION_ARGS); +extern Datum ts_rank_wtt(PG_FUNCTION_ARGS); +extern Datum ts_rank_ttf(PG_FUNCTION_ARGS); +extern Datum ts_rank_tt(PG_FUNCTION_ARGS); +extern Datum ts_rankcd_wttf(PG_FUNCTION_ARGS); +extern Datum ts_rankcd_wtt(PG_FUNCTION_ARGS); +extern Datum ts_rankcd_ttf(PG_FUNCTION_ARGS); +extern Datum ts_rankcd_tt(PG_FUNCTION_ARGS); +extern Datum tsvector_length(PG_FUNCTION_ARGS); +extern Datum ts_token_type_byid(PG_FUNCTION_ARGS); +extern Datum ts_token_type_byname(PG_FUNCTION_ARGS); +extern Datum ts_parse_byid(PG_FUNCTION_ARGS); +extern Datum ts_parse_byname(PG_FUNCTION_ARGS); +extern Datum prsd_start(PG_FUNCTION_ARGS); +extern Datum prsd_nexttoken(PG_FUNCTION_ARGS); +extern Datum prsd_end(PG_FUNCTION_ARGS); +extern Datum prsd_headline(PG_FUNCTION_ARGS); +extern Datum prsd_lextype(PG_FUNCTION_ARGS); +extern Datum ts_lexize(PG_FUNCTION_ARGS); +extern Datum gin_cmp_tslexeme(PG_FUNCTION_ARGS); +extern Datum dsimple_init(PG_FUNCTION_ARGS); +extern Datum dsimple_lexize(PG_FUNCTION_ARGS); +extern Datum dsynonym_init(PG_FUNCTION_ARGS); +extern Datum dsynonym_lexize(PG_FUNCTION_ARGS); +extern Datum dispell_init(PG_FUNCTION_ARGS); +extern Datum dispell_lexize(PG_FUNCTION_ARGS); +extern Datum regconfigin(PG_FUNCTION_ARGS); +extern Datum regconfigout(PG_FUNCTION_ARGS); +extern Datum regconfigrecv(PG_FUNCTION_ARGS); +extern Datum regconfigsend(PG_FUNCTION_ARGS); +extern Datum thesaurus_init(PG_FUNCTION_ARGS); +extern Datum thesaurus_lexize(PG_FUNCTION_ARGS); +extern Datum ts_headline_byid_opt(PG_FUNCTION_ARGS); +extern Datum ts_headline_byid(PG_FUNCTION_ARGS); +extern Datum to_tsvector_byid(PG_FUNCTION_ARGS); +extern Datum to_tsquery_byid(PG_FUNCTION_ARGS); +extern Datum plainto_tsquery_byid(PG_FUNCTION_ARGS); +extern Datum to_tsvector(PG_FUNCTION_ARGS); +extern Datum to_tsquery(PG_FUNCTION_ARGS); +extern Datum plainto_tsquery(PG_FUNCTION_ARGS); +extern Datum tsvector_update_trigger_byid(PG_FUNCTION_ARGS); +extern Datum tsvector_update_trigger_bycolumn(PG_FUNCTION_ARGS); +extern Datum ts_headline_opt(PG_FUNCTION_ARGS); +extern Datum ts_headline(PG_FUNCTION_ARGS); +extern Datum pg_ts_parser_is_visible(PG_FUNCTION_ARGS); +extern Datum pg_ts_dict_is_visible(PG_FUNCTION_ARGS); +extern Datum pg_ts_config_is_visible(PG_FUNCTION_ARGS); +extern Datum get_current_ts_config(PG_FUNCTION_ARGS); +extern Datum ts_match_tt(PG_FUNCTION_ARGS); +extern Datum ts_match_tq(PG_FUNCTION_ARGS); +extern Datum pg_ts_template_is_visible(PG_FUNCTION_ARGS); +extern Datum regdictionaryin(PG_FUNCTION_ARGS); +extern Datum regdictionaryout(PG_FUNCTION_ARGS); +extern Datum regdictionaryrecv(PG_FUNCTION_ARGS); +extern Datum regdictionarysend(PG_FUNCTION_ARGS); +extern Datum pg_stat_reset_shared(PG_FUNCTION_ARGS); +extern Datum pg_stat_reset_single_table_counters(PG_FUNCTION_ARGS); +extern Datum pg_stat_reset_single_function_counters(PG_FUNCTION_ARGS); +extern Datum pg_tablespace_location(PG_FUNCTION_ARGS); +extern Datum pg_create_physical_replication_slot(PG_FUNCTION_ARGS); +extern Datum pg_drop_replication_slot(PG_FUNCTION_ARGS); +extern Datum pg_get_replication_slots(PG_FUNCTION_ARGS); +extern Datum pg_logical_slot_get_changes(PG_FUNCTION_ARGS); +extern Datum pg_logical_slot_get_binary_changes(PG_FUNCTION_ARGS); +extern Datum pg_logical_slot_peek_changes(PG_FUNCTION_ARGS); +extern Datum pg_logical_slot_peek_binary_changes(PG_FUNCTION_ARGS); +extern Datum pg_create_logical_replication_slot(PG_FUNCTION_ARGS); +extern Datum to_jsonb(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_snapshot_timestamp(PG_FUNCTION_ARGS); +extern Datum gin_clean_pending_list(PG_FUNCTION_ARGS); +extern Datum gtsvector_consistent_oldsig(PG_FUNCTION_ARGS); +extern Datum gin_extract_tsquery_oldsig(PG_FUNCTION_ARGS); +extern Datum gin_tsquery_consistent_oldsig(PG_FUNCTION_ARGS); +extern Datum gtsquery_consistent_oldsig(PG_FUNCTION_ARGS); +extern Datum inet_spg_config(PG_FUNCTION_ARGS); +extern Datum inet_spg_choose(PG_FUNCTION_ARGS); +extern Datum inet_spg_picksplit(PG_FUNCTION_ARGS); +extern Datum inet_spg_inner_consistent(PG_FUNCTION_ARGS); +extern Datum inet_spg_leaf_consistent(PG_FUNCTION_ARGS); +extern Datum pg_current_logfile(PG_FUNCTION_ARGS); +extern Datum pg_current_logfile_1arg(PG_FUNCTION_ARGS); +extern Datum jsonb_send(PG_FUNCTION_ARGS); +extern Datum jsonb_out(PG_FUNCTION_ARGS); +extern Datum jsonb_recv(PG_FUNCTION_ARGS); +extern Datum jsonb_in(PG_FUNCTION_ARGS); +extern Datum pg_get_function_arg_default(PG_FUNCTION_ARGS); +extern Datum pg_export_snapshot(PG_FUNCTION_ARGS); +extern Datum pg_is_in_recovery(PG_FUNCTION_ARGS); +extern Datum int4_cash(PG_FUNCTION_ARGS); +extern Datum int8_cash(PG_FUNCTION_ARGS); +extern Datum pg_collation_is_visible(PG_FUNCTION_ARGS); +extern Datum array_typanalyze(PG_FUNCTION_ARGS); +extern Datum arraycontsel(PG_FUNCTION_ARGS); +extern Datum arraycontjoinsel(PG_FUNCTION_ARGS); +extern Datum pg_get_multixact_members(PG_FUNCTION_ARGS); +extern Datum pg_last_wal_receive_lsn(PG_FUNCTION_ARGS); +extern Datum pg_last_wal_replay_lsn(PG_FUNCTION_ARGS); +extern Datum cash_div_cash(PG_FUNCTION_ARGS); +extern Datum cash_numeric(PG_FUNCTION_ARGS); +extern Datum numeric_cash(PG_FUNCTION_ARGS); +extern Datum pg_read_file_all(PG_FUNCTION_ARGS); +extern Datum pg_read_binary_file_off_len(PG_FUNCTION_ARGS); +extern Datum pg_read_binary_file_all(PG_FUNCTION_ARGS); +extern Datum pg_opfamily_is_visible(PG_FUNCTION_ARGS); +extern Datum pg_last_xact_replay_timestamp(PG_FUNCTION_ARGS); +extern Datum anyrange_in(PG_FUNCTION_ARGS); +extern Datum anyrange_out(PG_FUNCTION_ARGS); +extern Datum range_in(PG_FUNCTION_ARGS); +extern Datum range_out(PG_FUNCTION_ARGS); +extern Datum range_recv(PG_FUNCTION_ARGS); +extern Datum range_send(PG_FUNCTION_ARGS); +extern Datum pg_identify_object(PG_FUNCTION_ARGS); +extern Datum range_constructor2(PG_FUNCTION_ARGS); +extern Datum range_constructor3(PG_FUNCTION_ARGS); +extern Datum pg_relation_is_updatable(PG_FUNCTION_ARGS); +extern Datum pg_column_is_updatable(PG_FUNCTION_ARGS); +extern Datum make_date(PG_FUNCTION_ARGS); +extern Datum make_time(PG_FUNCTION_ARGS); +extern Datum range_lower(PG_FUNCTION_ARGS); +extern Datum range_upper(PG_FUNCTION_ARGS); +extern Datum range_empty(PG_FUNCTION_ARGS); +extern Datum range_lower_inc(PG_FUNCTION_ARGS); +extern Datum range_upper_inc(PG_FUNCTION_ARGS); +extern Datum range_lower_inf(PG_FUNCTION_ARGS); +extern Datum range_upper_inf(PG_FUNCTION_ARGS); +extern Datum range_eq(PG_FUNCTION_ARGS); +extern Datum range_ne(PG_FUNCTION_ARGS); +extern Datum range_overlaps(PG_FUNCTION_ARGS); +extern Datum range_contains_elem(PG_FUNCTION_ARGS); +extern Datum range_contains(PG_FUNCTION_ARGS); +extern Datum elem_contained_by_range(PG_FUNCTION_ARGS); +extern Datum range_contained_by(PG_FUNCTION_ARGS); +extern Datum range_adjacent(PG_FUNCTION_ARGS); +extern Datum range_before(PG_FUNCTION_ARGS); +extern Datum range_after(PG_FUNCTION_ARGS); +extern Datum range_overleft(PG_FUNCTION_ARGS); +extern Datum range_overright(PG_FUNCTION_ARGS); +extern Datum range_union(PG_FUNCTION_ARGS); +extern Datum range_intersect(PG_FUNCTION_ARGS); +extern Datum range_minus(PG_FUNCTION_ARGS); +extern Datum range_cmp(PG_FUNCTION_ARGS); +extern Datum range_lt(PG_FUNCTION_ARGS); +extern Datum range_le(PG_FUNCTION_ARGS); +extern Datum range_ge(PG_FUNCTION_ARGS); +extern Datum range_gt(PG_FUNCTION_ARGS); +extern Datum range_gist_consistent(PG_FUNCTION_ARGS); +extern Datum range_gist_union(PG_FUNCTION_ARGS); +extern Datum pg_replication_slot_advance(PG_FUNCTION_ARGS); +extern Datum range_gist_penalty(PG_FUNCTION_ARGS); +extern Datum range_gist_picksplit(PG_FUNCTION_ARGS); +extern Datum range_gist_same(PG_FUNCTION_ARGS); +extern Datum hash_range(PG_FUNCTION_ARGS); +extern Datum int4range_canonical(PG_FUNCTION_ARGS); +extern Datum daterange_canonical(PG_FUNCTION_ARGS); +extern Datum range_typanalyze(PG_FUNCTION_ARGS); +extern Datum timestamp_support(PG_FUNCTION_ARGS); +extern Datum interval_support(PG_FUNCTION_ARGS); +extern Datum ginarraytriconsistent(PG_FUNCTION_ARGS); +extern Datum gin_tsquery_triconsistent(PG_FUNCTION_ARGS); +extern Datum int4range_subdiff(PG_FUNCTION_ARGS); +extern Datum int8range_subdiff(PG_FUNCTION_ARGS); +extern Datum numrange_subdiff(PG_FUNCTION_ARGS); +extern Datum daterange_subdiff(PG_FUNCTION_ARGS); +extern Datum int8range_canonical(PG_FUNCTION_ARGS); +extern Datum tsrange_subdiff(PG_FUNCTION_ARGS); +extern Datum tstzrange_subdiff(PG_FUNCTION_ARGS); +extern Datum jsonb_object_keys(PG_FUNCTION_ARGS); +extern Datum jsonb_each_text(PG_FUNCTION_ARGS); +extern Datum mxid_age(PG_FUNCTION_ARGS); +extern Datum jsonb_extract_path_text(PG_FUNCTION_ARGS); +extern Datum acldefault_sql(PG_FUNCTION_ARGS); +extern Datum time_support(PG_FUNCTION_ARGS); +extern Datum json_object_field(PG_FUNCTION_ARGS); +extern Datum json_object_field_text(PG_FUNCTION_ARGS); +extern Datum json_array_element(PG_FUNCTION_ARGS); +extern Datum json_array_element_text(PG_FUNCTION_ARGS); +extern Datum json_extract_path(PG_FUNCTION_ARGS); +extern Datum brin_summarize_new_values(PG_FUNCTION_ARGS); +extern Datum json_extract_path_text(PG_FUNCTION_ARGS); +extern Datum pg_get_object_address(PG_FUNCTION_ARGS); +extern Datum json_array_elements(PG_FUNCTION_ARGS); +extern Datum json_array_length(PG_FUNCTION_ARGS); +extern Datum json_object_keys(PG_FUNCTION_ARGS); +extern Datum json_each(PG_FUNCTION_ARGS); +extern Datum json_each_text(PG_FUNCTION_ARGS); +extern Datum json_populate_record(PG_FUNCTION_ARGS); +extern Datum json_populate_recordset(PG_FUNCTION_ARGS); +extern Datum json_typeof(PG_FUNCTION_ARGS); +extern Datum json_array_elements_text(PG_FUNCTION_ARGS); +extern Datum ordered_set_transition(PG_FUNCTION_ARGS); +extern Datum ordered_set_transition_multi(PG_FUNCTION_ARGS); +extern Datum percentile_disc_final(PG_FUNCTION_ARGS); +extern Datum percentile_cont_float8_final(PG_FUNCTION_ARGS); +extern Datum percentile_cont_interval_final(PG_FUNCTION_ARGS); +extern Datum percentile_disc_multi_final(PG_FUNCTION_ARGS); +extern Datum percentile_cont_float8_multi_final(PG_FUNCTION_ARGS); +extern Datum percentile_cont_interval_multi_final(PG_FUNCTION_ARGS); +extern Datum mode_final(PG_FUNCTION_ARGS); +extern Datum hypothetical_rank_final(PG_FUNCTION_ARGS); +extern Datum hypothetical_percent_rank_final(PG_FUNCTION_ARGS); +extern Datum hypothetical_cume_dist_final(PG_FUNCTION_ARGS); +extern Datum hypothetical_dense_rank_final(PG_FUNCTION_ARGS); +extern Datum generate_series_int4_support(PG_FUNCTION_ARGS); +extern Datum generate_series_int8_support(PG_FUNCTION_ARGS); +extern Datum array_unnest_support(PG_FUNCTION_ARGS); +extern Datum gist_box_distance(PG_FUNCTION_ARGS); +extern Datum brin_summarize_range(PG_FUNCTION_ARGS); +extern Datum jsonpath_in(PG_FUNCTION_ARGS); +extern Datum jsonpath_recv(PG_FUNCTION_ARGS); +extern Datum jsonpath_out(PG_FUNCTION_ARGS); +extern Datum jsonpath_send(PG_FUNCTION_ARGS); +extern Datum jsonb_path_exists(PG_FUNCTION_ARGS); +extern Datum jsonb_path_query(PG_FUNCTION_ARGS); +extern Datum jsonb_path_query_array(PG_FUNCTION_ARGS); +extern Datum jsonb_path_query_first(PG_FUNCTION_ARGS); +extern Datum jsonb_path_match(PG_FUNCTION_ARGS); +extern Datum jsonb_path_exists_opr(PG_FUNCTION_ARGS); +extern Datum jsonb_path_match_opr(PG_FUNCTION_ARGS); +extern Datum brin_desummarize_range(PG_FUNCTION_ARGS); +extern Datum spg_quad_config(PG_FUNCTION_ARGS); +extern Datum spg_quad_choose(PG_FUNCTION_ARGS); +extern Datum spg_quad_picksplit(PG_FUNCTION_ARGS); +extern Datum spg_quad_inner_consistent(PG_FUNCTION_ARGS); +extern Datum spg_quad_leaf_consistent(PG_FUNCTION_ARGS); +extern Datum spg_kd_config(PG_FUNCTION_ARGS); +extern Datum spg_kd_choose(PG_FUNCTION_ARGS); +extern Datum spg_kd_picksplit(PG_FUNCTION_ARGS); +extern Datum spg_kd_inner_consistent(PG_FUNCTION_ARGS); +extern Datum spg_text_config(PG_FUNCTION_ARGS); +extern Datum spg_text_choose(PG_FUNCTION_ARGS); +extern Datum spg_text_picksplit(PG_FUNCTION_ARGS); +extern Datum spg_text_inner_consistent(PG_FUNCTION_ARGS); +extern Datum spg_text_leaf_consistent(PG_FUNCTION_ARGS); +extern Datum pg_sequence_last_value(PG_FUNCTION_ARGS); +extern Datum jsonb_ne(PG_FUNCTION_ARGS); +extern Datum jsonb_lt(PG_FUNCTION_ARGS); +extern Datum jsonb_gt(PG_FUNCTION_ARGS); +extern Datum jsonb_le(PG_FUNCTION_ARGS); +extern Datum jsonb_ge(PG_FUNCTION_ARGS); +extern Datum jsonb_eq(PG_FUNCTION_ARGS); +extern Datum jsonb_cmp(PG_FUNCTION_ARGS); +extern Datum jsonb_hash(PG_FUNCTION_ARGS); +extern Datum jsonb_contains(PG_FUNCTION_ARGS); +extern Datum jsonb_exists(PG_FUNCTION_ARGS); +extern Datum jsonb_exists_any(PG_FUNCTION_ARGS); +extern Datum jsonb_exists_all(PG_FUNCTION_ARGS); +extern Datum jsonb_contained(PG_FUNCTION_ARGS); +extern Datum array_agg_array_transfn(PG_FUNCTION_ARGS); +extern Datum array_agg_array_finalfn(PG_FUNCTION_ARGS); +extern Datum range_merge(PG_FUNCTION_ARGS); +extern Datum inet_merge(PG_FUNCTION_ARGS); +extern Datum boxes_bound_box(PG_FUNCTION_ARGS); +extern Datum inet_same_family(PG_FUNCTION_ARGS); +extern Datum binary_upgrade_set_record_init_privs(PG_FUNCTION_ARGS); +extern Datum regnamespacein(PG_FUNCTION_ARGS); +extern Datum regnamespaceout(PG_FUNCTION_ARGS); +extern Datum to_regnamespace(PG_FUNCTION_ARGS); +extern Datum regnamespacerecv(PG_FUNCTION_ARGS); +extern Datum regnamespacesend(PG_FUNCTION_ARGS); +extern Datum point_box(PG_FUNCTION_ARGS); +extern Datum regroleout(PG_FUNCTION_ARGS); +extern Datum to_regrole(PG_FUNCTION_ARGS); +extern Datum regrolerecv(PG_FUNCTION_ARGS); +extern Datum regrolesend(PG_FUNCTION_ARGS); +extern Datum regrolein(PG_FUNCTION_ARGS); +extern Datum pg_rotate_logfile(PG_FUNCTION_ARGS); +extern Datum pg_read_file(PG_FUNCTION_ARGS); +extern Datum binary_upgrade_set_missing_value(PG_FUNCTION_ARGS); +extern Datum brin_inclusion_opcinfo(PG_FUNCTION_ARGS); +extern Datum brin_inclusion_add_value(PG_FUNCTION_ARGS); +extern Datum brin_inclusion_consistent(PG_FUNCTION_ARGS); +extern Datum brin_inclusion_union(PG_FUNCTION_ARGS); +extern Datum macaddr8_in(PG_FUNCTION_ARGS); +extern Datum macaddr8_out(PG_FUNCTION_ARGS); +extern Datum macaddr8_trunc(PG_FUNCTION_ARGS); +extern Datum macaddr8_eq(PG_FUNCTION_ARGS); +extern Datum macaddr8_lt(PG_FUNCTION_ARGS); +extern Datum macaddr8_le(PG_FUNCTION_ARGS); +extern Datum macaddr8_gt(PG_FUNCTION_ARGS); +extern Datum macaddr8_ge(PG_FUNCTION_ARGS); +extern Datum macaddr8_ne(PG_FUNCTION_ARGS); +extern Datum macaddr8_cmp(PG_FUNCTION_ARGS); +extern Datum macaddr8_not(PG_FUNCTION_ARGS); +extern Datum macaddr8_and(PG_FUNCTION_ARGS); +extern Datum macaddr8_or(PG_FUNCTION_ARGS); +extern Datum macaddrtomacaddr8(PG_FUNCTION_ARGS); +extern Datum macaddr8tomacaddr(PG_FUNCTION_ARGS); +extern Datum macaddr8_set7bit(PG_FUNCTION_ARGS); +extern Datum in_range_int8_int8(PG_FUNCTION_ARGS); +extern Datum in_range_int4_int8(PG_FUNCTION_ARGS); +extern Datum in_range_int4_int4(PG_FUNCTION_ARGS); +extern Datum in_range_int4_int2(PG_FUNCTION_ARGS); +extern Datum in_range_int2_int8(PG_FUNCTION_ARGS); +extern Datum in_range_int2_int4(PG_FUNCTION_ARGS); +extern Datum in_range_int2_int2(PG_FUNCTION_ARGS); +extern Datum in_range_date_interval(PG_FUNCTION_ARGS); +extern Datum in_range_timestamp_interval(PG_FUNCTION_ARGS); +extern Datum in_range_timestamptz_interval(PG_FUNCTION_ARGS); +extern Datum in_range_interval_interval(PG_FUNCTION_ARGS); +extern Datum in_range_time_interval(PG_FUNCTION_ARGS); +extern Datum in_range_timetz_interval(PG_FUNCTION_ARGS); +extern Datum in_range_float8_float8(PG_FUNCTION_ARGS); +extern Datum in_range_float4_float8(PG_FUNCTION_ARGS); +extern Datum in_range_numeric_numeric(PG_FUNCTION_ARGS); +extern Datum pg_lsn_larger(PG_FUNCTION_ARGS); +extern Datum pg_lsn_smaller(PG_FUNCTION_ARGS); +extern Datum regcollationin(PG_FUNCTION_ARGS); +extern Datum regcollationout(PG_FUNCTION_ARGS); +extern Datum to_regcollation(PG_FUNCTION_ARGS); +extern Datum regcollationrecv(PG_FUNCTION_ARGS); +extern Datum regcollationsend(PG_FUNCTION_ARGS); +extern Datum ts_headline_jsonb_byid_opt(PG_FUNCTION_ARGS); +extern Datum ts_headline_jsonb_byid(PG_FUNCTION_ARGS); +extern Datum ts_headline_jsonb_opt(PG_FUNCTION_ARGS); +extern Datum ts_headline_jsonb(PG_FUNCTION_ARGS); +extern Datum ts_headline_json_byid_opt(PG_FUNCTION_ARGS); +extern Datum ts_headline_json_byid(PG_FUNCTION_ARGS); +extern Datum ts_headline_json_opt(PG_FUNCTION_ARGS); +extern Datum ts_headline_json(PG_FUNCTION_ARGS); +extern Datum jsonb_string_to_tsvector(PG_FUNCTION_ARGS); +extern Datum json_string_to_tsvector(PG_FUNCTION_ARGS); +extern Datum jsonb_string_to_tsvector_byid(PG_FUNCTION_ARGS); +extern Datum json_string_to_tsvector_byid(PG_FUNCTION_ARGS); +extern Datum jsonb_to_tsvector(PG_FUNCTION_ARGS); +extern Datum jsonb_to_tsvector_byid(PG_FUNCTION_ARGS); +extern Datum json_to_tsvector(PG_FUNCTION_ARGS); +extern Datum json_to_tsvector_byid(PG_FUNCTION_ARGS); +extern Datum pg_copy_physical_replication_slot_a(PG_FUNCTION_ARGS); +extern Datum pg_copy_physical_replication_slot_b(PG_FUNCTION_ARGS); +extern Datum pg_copy_logical_replication_slot_a(PG_FUNCTION_ARGS); +extern Datum pg_copy_logical_replication_slot_b(PG_FUNCTION_ARGS); +extern Datum pg_copy_logical_replication_slot_c(PG_FUNCTION_ARGS); +extern Datum anycompatiblemultirange_in(PG_FUNCTION_ARGS); +extern Datum anycompatiblemultirange_out(PG_FUNCTION_ARGS); +extern Datum range_merge_from_multirange(PG_FUNCTION_ARGS); +extern Datum anymultirange_in(PG_FUNCTION_ARGS); +extern Datum anymultirange_out(PG_FUNCTION_ARGS); +extern Datum multirange_in(PG_FUNCTION_ARGS); +extern Datum multirange_out(PG_FUNCTION_ARGS); +extern Datum multirange_recv(PG_FUNCTION_ARGS); +extern Datum multirange_send(PG_FUNCTION_ARGS); +extern Datum multirange_lower(PG_FUNCTION_ARGS); +extern Datum multirange_upper(PG_FUNCTION_ARGS); +extern Datum multirange_empty(PG_FUNCTION_ARGS); +extern Datum multirange_lower_inc(PG_FUNCTION_ARGS); +extern Datum multirange_upper_inc(PG_FUNCTION_ARGS); +extern Datum multirange_lower_inf(PG_FUNCTION_ARGS); +extern Datum multirange_upper_inf(PG_FUNCTION_ARGS); +extern Datum multirange_typanalyze(PG_FUNCTION_ARGS); +extern Datum multirangesel(PG_FUNCTION_ARGS); +extern Datum multirange_eq(PG_FUNCTION_ARGS); +extern Datum multirange_ne(PG_FUNCTION_ARGS); +extern Datum range_overlaps_multirange(PG_FUNCTION_ARGS); +extern Datum multirange_overlaps_range(PG_FUNCTION_ARGS); +extern Datum multirange_overlaps_multirange(PG_FUNCTION_ARGS); +extern Datum multirange_contains_elem(PG_FUNCTION_ARGS); +extern Datum multirange_contains_range(PG_FUNCTION_ARGS); +extern Datum multirange_contains_multirange(PG_FUNCTION_ARGS); +extern Datum elem_contained_by_multirange(PG_FUNCTION_ARGS); +extern Datum range_contained_by_multirange(PG_FUNCTION_ARGS); +extern Datum multirange_contained_by_multirange(PG_FUNCTION_ARGS); +extern Datum range_adjacent_multirange(PG_FUNCTION_ARGS); +extern Datum multirange_adjacent_multirange(PG_FUNCTION_ARGS); +extern Datum multirange_adjacent_range(PG_FUNCTION_ARGS); +extern Datum range_before_multirange(PG_FUNCTION_ARGS); +extern Datum multirange_before_range(PG_FUNCTION_ARGS); +extern Datum multirange_before_multirange(PG_FUNCTION_ARGS); +extern Datum range_after_multirange(PG_FUNCTION_ARGS); +extern Datum multirange_after_range(PG_FUNCTION_ARGS); +extern Datum multirange_after_multirange(PG_FUNCTION_ARGS); +extern Datum range_overleft_multirange(PG_FUNCTION_ARGS); +extern Datum multirange_overleft_range(PG_FUNCTION_ARGS); +extern Datum multirange_overleft_multirange(PG_FUNCTION_ARGS); +extern Datum range_overright_multirange(PG_FUNCTION_ARGS); +extern Datum multirange_overright_range(PG_FUNCTION_ARGS); +extern Datum multirange_overright_multirange(PG_FUNCTION_ARGS); +extern Datum multirange_union(PG_FUNCTION_ARGS); +extern Datum multirange_minus(PG_FUNCTION_ARGS); +extern Datum multirange_intersect(PG_FUNCTION_ARGS); +extern Datum multirange_cmp(PG_FUNCTION_ARGS); +extern Datum multirange_lt(PG_FUNCTION_ARGS); +extern Datum multirange_le(PG_FUNCTION_ARGS); +extern Datum multirange_ge(PG_FUNCTION_ARGS); +extern Datum multirange_gt(PG_FUNCTION_ARGS); +extern Datum hash_multirange(PG_FUNCTION_ARGS); +extern Datum hash_multirange_extended(PG_FUNCTION_ARGS); +extern Datum multirange_constructor0(PG_FUNCTION_ARGS); +extern Datum multirange_constructor1(PG_FUNCTION_ARGS); +extern Datum multirange_constructor2(PG_FUNCTION_ARGS); +extern Datum range_agg_transfn(PG_FUNCTION_ARGS); +extern Datum range_agg_finalfn(PG_FUNCTION_ARGS); +extern Datum unicode_normalize_func(PG_FUNCTION_ARGS); +extern Datum unicode_is_normalized(PG_FUNCTION_ARGS); +extern Datum multirange_intersect_agg_transfn(PG_FUNCTION_ARGS); +extern Datum binary_upgrade_set_next_multirange_pg_type_oid(PG_FUNCTION_ARGS); +extern Datum binary_upgrade_set_next_multirange_array_pg_type_oid(PG_FUNCTION_ARGS); +extern Datum range_intersect_agg_transfn(PG_FUNCTION_ARGS); +extern Datum range_contains_multirange(PG_FUNCTION_ARGS); +extern Datum multirange_contained_by_range(PG_FUNCTION_ARGS); +extern Datum pg_log_backend_memory_contexts(PG_FUNCTION_ARGS); +extern Datum binary_upgrade_set_next_heap_relfilenode(PG_FUNCTION_ARGS); +extern Datum binary_upgrade_set_next_index_relfilenode(PG_FUNCTION_ARGS); +extern Datum binary_upgrade_set_next_toast_relfilenode(PG_FUNCTION_ARGS); +extern Datum binary_upgrade_set_next_pg_tablespace_oid(PG_FUNCTION_ARGS); +extern Datum pg_event_trigger_table_rewrite_oid(PG_FUNCTION_ARGS); +extern Datum pg_event_trigger_table_rewrite_reason(PG_FUNCTION_ARGS); +extern Datum pg_event_trigger_ddl_commands(PG_FUNCTION_ARGS); +extern Datum brin_bloom_opcinfo(PG_FUNCTION_ARGS); +extern Datum brin_bloom_add_value(PG_FUNCTION_ARGS); +extern Datum brin_bloom_consistent(PG_FUNCTION_ARGS); +extern Datum brin_bloom_union(PG_FUNCTION_ARGS); +extern Datum brin_bloom_options(PG_FUNCTION_ARGS); +extern Datum brin_bloom_summary_in(PG_FUNCTION_ARGS); +extern Datum brin_bloom_summary_out(PG_FUNCTION_ARGS); +extern Datum brin_bloom_summary_recv(PG_FUNCTION_ARGS); +extern Datum brin_bloom_summary_send(PG_FUNCTION_ARGS); +extern Datum brin_minmax_multi_opcinfo(PG_FUNCTION_ARGS); +extern Datum brin_minmax_multi_add_value(PG_FUNCTION_ARGS); +extern Datum brin_minmax_multi_consistent(PG_FUNCTION_ARGS); +extern Datum brin_minmax_multi_union(PG_FUNCTION_ARGS); +extern Datum brin_minmax_multi_options(PG_FUNCTION_ARGS); +extern Datum brin_minmax_multi_distance_int2(PG_FUNCTION_ARGS); +extern Datum brin_minmax_multi_distance_int4(PG_FUNCTION_ARGS); +extern Datum brin_minmax_multi_distance_int8(PG_FUNCTION_ARGS); +extern Datum brin_minmax_multi_distance_float4(PG_FUNCTION_ARGS); +extern Datum brin_minmax_multi_distance_float8(PG_FUNCTION_ARGS); +extern Datum brin_minmax_multi_distance_numeric(PG_FUNCTION_ARGS); +extern Datum brin_minmax_multi_distance_tid(PG_FUNCTION_ARGS); +extern Datum brin_minmax_multi_distance_uuid(PG_FUNCTION_ARGS); +extern Datum brin_minmax_multi_distance_date(PG_FUNCTION_ARGS); +extern Datum brin_minmax_multi_distance_time(PG_FUNCTION_ARGS); +extern Datum brin_minmax_multi_distance_interval(PG_FUNCTION_ARGS); +extern Datum brin_minmax_multi_distance_timetz(PG_FUNCTION_ARGS); +extern Datum brin_minmax_multi_distance_pg_lsn(PG_FUNCTION_ARGS); +extern Datum brin_minmax_multi_distance_macaddr(PG_FUNCTION_ARGS); +extern Datum brin_minmax_multi_distance_macaddr8(PG_FUNCTION_ARGS); +extern Datum brin_minmax_multi_distance_inet(PG_FUNCTION_ARGS); +extern Datum brin_minmax_multi_distance_timestamp(PG_FUNCTION_ARGS); +extern Datum brin_minmax_multi_summary_in(PG_FUNCTION_ARGS); +extern Datum brin_minmax_multi_summary_out(PG_FUNCTION_ARGS); +extern Datum brin_minmax_multi_summary_recv(PG_FUNCTION_ARGS); +extern Datum brin_minmax_multi_summary_send(PG_FUNCTION_ARGS); +extern Datum phraseto_tsquery(PG_FUNCTION_ARGS); +extern Datum tsquery_phrase(PG_FUNCTION_ARGS); +extern Datum tsquery_phrase_distance(PG_FUNCTION_ARGS); +extern Datum phraseto_tsquery_byid(PG_FUNCTION_ARGS); +extern Datum websearch_to_tsquery_byid(PG_FUNCTION_ARGS); +extern Datum websearch_to_tsquery(PG_FUNCTION_ARGS); +extern Datum spg_bbox_quad_config(PG_FUNCTION_ARGS); +extern Datum spg_poly_quad_compress(PG_FUNCTION_ARGS); +extern Datum spg_box_quad_config(PG_FUNCTION_ARGS); +extern Datum spg_box_quad_choose(PG_FUNCTION_ARGS); +extern Datum spg_box_quad_picksplit(PG_FUNCTION_ARGS); +extern Datum spg_box_quad_inner_consistent(PG_FUNCTION_ARGS); +extern Datum spg_box_quad_leaf_consistent(PG_FUNCTION_ARGS); +extern Datum pg_mcv_list_in(PG_FUNCTION_ARGS); +extern Datum pg_mcv_list_out(PG_FUNCTION_ARGS); +extern Datum pg_mcv_list_recv(PG_FUNCTION_ARGS); +extern Datum pg_mcv_list_send(PG_FUNCTION_ARGS); +extern Datum pg_lsn_pli(PG_FUNCTION_ARGS); +extern Datum pg_lsn_mii(PG_FUNCTION_ARGS); +extern Datum satisfies_hash_partition(PG_FUNCTION_ARGS); +extern Datum pg_ls_tmpdir_noargs(PG_FUNCTION_ARGS); +extern Datum pg_ls_tmpdir_1arg(PG_FUNCTION_ARGS); +extern Datum pg_ls_archive_statusdir(PG_FUNCTION_ARGS); +extern Datum network_sortsupport(PG_FUNCTION_ARGS); +extern Datum xid8lt(PG_FUNCTION_ARGS); +extern Datum xid8gt(PG_FUNCTION_ARGS); +extern Datum xid8le(PG_FUNCTION_ARGS); +extern Datum xid8ge(PG_FUNCTION_ARGS); +extern Datum matchingsel(PG_FUNCTION_ARGS); +extern Datum matchingjoinsel(PG_FUNCTION_ARGS); +extern Datum numeric_min_scale(PG_FUNCTION_ARGS); +extern Datum numeric_trim_scale(PG_FUNCTION_ARGS); +extern Datum int4gcd(PG_FUNCTION_ARGS); +extern Datum int8gcd(PG_FUNCTION_ARGS); +extern Datum int4lcm(PG_FUNCTION_ARGS); +extern Datum int8lcm(PG_FUNCTION_ARGS); +extern Datum numeric_gcd(PG_FUNCTION_ARGS); +extern Datum numeric_lcm(PG_FUNCTION_ARGS); +extern Datum btvarstrequalimage(PG_FUNCTION_ARGS); +extern Datum btequalimage(PG_FUNCTION_ARGS); +extern Datum pg_get_shmem_allocations(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_ins_since_vacuum(PG_FUNCTION_ARGS); +extern Datum jsonb_set_lax(PG_FUNCTION_ARGS); +extern Datum xid8in(PG_FUNCTION_ARGS); +extern Datum xid8toxid(PG_FUNCTION_ARGS); +extern Datum xid8out(PG_FUNCTION_ARGS); +extern Datum xid8recv(PG_FUNCTION_ARGS); +extern Datum xid8send(PG_FUNCTION_ARGS); +extern Datum xid8eq(PG_FUNCTION_ARGS); +extern Datum xid8ne(PG_FUNCTION_ARGS); +extern Datum anycompatible_in(PG_FUNCTION_ARGS); +extern Datum anycompatible_out(PG_FUNCTION_ARGS); +extern Datum anycompatiblearray_in(PG_FUNCTION_ARGS); +extern Datum anycompatiblearray_out(PG_FUNCTION_ARGS); +extern Datum anycompatiblearray_recv(PG_FUNCTION_ARGS); +extern Datum anycompatiblearray_send(PG_FUNCTION_ARGS); +extern Datum anycompatiblenonarray_in(PG_FUNCTION_ARGS); +extern Datum anycompatiblenonarray_out(PG_FUNCTION_ARGS); +extern Datum anycompatiblerange_in(PG_FUNCTION_ARGS); +extern Datum anycompatiblerange_out(PG_FUNCTION_ARGS); +extern Datum xid8cmp(PG_FUNCTION_ARGS); +extern Datum xid8_larger(PG_FUNCTION_ARGS); +extern Datum xid8_smaller(PG_FUNCTION_ARGS); +extern Datum pg_replication_origin_create(PG_FUNCTION_ARGS); +extern Datum pg_replication_origin_drop(PG_FUNCTION_ARGS); +extern Datum pg_replication_origin_oid(PG_FUNCTION_ARGS); +extern Datum pg_replication_origin_session_setup(PG_FUNCTION_ARGS); +extern Datum pg_replication_origin_session_reset(PG_FUNCTION_ARGS); +extern Datum pg_replication_origin_session_is_setup(PG_FUNCTION_ARGS); +extern Datum pg_replication_origin_session_progress(PG_FUNCTION_ARGS); +extern Datum pg_replication_origin_xact_setup(PG_FUNCTION_ARGS); +extern Datum pg_replication_origin_xact_reset(PG_FUNCTION_ARGS); +extern Datum pg_replication_origin_advance(PG_FUNCTION_ARGS); +extern Datum pg_replication_origin_progress(PG_FUNCTION_ARGS); +extern Datum pg_show_replication_origin_status(PG_FUNCTION_ARGS); +extern Datum jsonb_subscript_handler(PG_FUNCTION_ARGS); +extern Datum numeric_pg_lsn(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_subscription(PG_FUNCTION_ARGS); +extern Datum pg_get_publication_tables(PG_FUNCTION_ARGS); +extern Datum pg_get_replica_identity_index(PG_FUNCTION_ARGS); +extern Datum pg_relation_is_publishable(PG_FUNCTION_ARGS); +extern Datum multirange_gist_consistent(PG_FUNCTION_ARGS); +extern Datum multirange_gist_compress(PG_FUNCTION_ARGS); +extern Datum pg_get_catalog_foreign_keys(PG_FUNCTION_ARGS); +extern Datum text_to_table(PG_FUNCTION_ARGS); +extern Datum text_to_table_null(PG_FUNCTION_ARGS); +extern Datum bit_bit_count(PG_FUNCTION_ARGS); +extern Datum bytea_bit_count(PG_FUNCTION_ARGS); +extern Datum pg_xact_commit_timestamp_origin(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_replication_slot(PG_FUNCTION_ARGS); +extern Datum pg_stat_reset_replication_slot(PG_FUNCTION_ARGS); +extern Datum trim_array(PG_FUNCTION_ARGS); +extern Datum pg_get_statisticsobjdef_expressions(PG_FUNCTION_ARGS); +extern Datum pg_get_statisticsobjdef_columns(PG_FUNCTION_ARGS); +extern Datum timestamp_bin(PG_FUNCTION_ARGS); +extern Datum timestamptz_bin(PG_FUNCTION_ARGS); +extern Datum array_subscript_handler(PG_FUNCTION_ARGS); +extern Datum raw_array_subscript_handler(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_db_session_time(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_db_active_time(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_db_idle_in_transaction_time(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_db_sessions(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_db_sessions_abandoned(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_db_sessions_fatal(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_db_sessions_killed(PG_FUNCTION_ARGS); +extern Datum hash_record(PG_FUNCTION_ARGS); +extern Datum hash_record_extended(PG_FUNCTION_ARGS); +extern Datum bytealtrim(PG_FUNCTION_ARGS); +extern Datum byteartrim(PG_FUNCTION_ARGS); +extern Datum pg_get_function_sqlbody(PG_FUNCTION_ARGS); +extern Datum unistr(PG_FUNCTION_ARGS); +extern Datum extract_date(PG_FUNCTION_ARGS); +extern Datum extract_time(PG_FUNCTION_ARGS); +extern Datum extract_timetz(PG_FUNCTION_ARGS); +extern Datum extract_timestamp(PG_FUNCTION_ARGS); +extern Datum extract_timestamptz(PG_FUNCTION_ARGS); +extern Datum extract_interval(PG_FUNCTION_ARGS); +extern Datum has_parameter_privilege_name_name(PG_FUNCTION_ARGS); +extern Datum has_parameter_privilege_id_name(PG_FUNCTION_ARGS); +extern Datum has_parameter_privilege_name(PG_FUNCTION_ARGS); +extern Datum pg_get_wal_resource_managers(PG_FUNCTION_ARGS); +extern Datum multirange_agg_transfn(PG_FUNCTION_ARGS); +extern Datum pg_stat_have_stats(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_subscription_stats(PG_FUNCTION_ARGS); +extern Datum pg_stat_reset_subscription_stats(PG_FUNCTION_ARGS); +extern Datum window_row_number_support(PG_FUNCTION_ARGS); +extern Datum window_rank_support(PG_FUNCTION_ARGS); +extern Datum window_dense_rank_support(PG_FUNCTION_ARGS); +extern Datum int8inc_support(PG_FUNCTION_ARGS); +extern Datum pg_settings_get_flags(PG_FUNCTION_ARGS); +extern Datum pg_stop_making_pinned_objects(PG_FUNCTION_ARGS); +extern Datum text_starts_with_support(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_recovery_prefetch(PG_FUNCTION_ARGS); +extern Datum pg_database_collation_actual_version(PG_FUNCTION_ARGS); +extern Datum pg_ident_file_mappings(PG_FUNCTION_ARGS); +extern Datum textregexreplace_extended(PG_FUNCTION_ARGS); +extern Datum textregexreplace_extended_no_flags(PG_FUNCTION_ARGS); +extern Datum textregexreplace_extended_no_n(PG_FUNCTION_ARGS); +extern Datum regexp_count_no_start(PG_FUNCTION_ARGS); +extern Datum regexp_count_no_flags(PG_FUNCTION_ARGS); +extern Datum regexp_count(PG_FUNCTION_ARGS); +extern Datum regexp_instr_no_start(PG_FUNCTION_ARGS); +extern Datum regexp_instr_no_n(PG_FUNCTION_ARGS); +extern Datum regexp_instr_no_endoption(PG_FUNCTION_ARGS); +extern Datum regexp_instr_no_flags(PG_FUNCTION_ARGS); +extern Datum regexp_instr_no_subexpr(PG_FUNCTION_ARGS); +extern Datum regexp_instr(PG_FUNCTION_ARGS); +extern Datum regexp_like_no_flags(PG_FUNCTION_ARGS); +extern Datum regexp_like(PG_FUNCTION_ARGS); +extern Datum regexp_substr_no_start(PG_FUNCTION_ARGS); +extern Datum regexp_substr_no_n(PG_FUNCTION_ARGS); +extern Datum regexp_substr_no_flags(PG_FUNCTION_ARGS); +extern Datum regexp_substr_no_subexpr(PG_FUNCTION_ARGS); +extern Datum regexp_substr(PG_FUNCTION_ARGS); +extern Datum pg_ls_logicalsnapdir(PG_FUNCTION_ARGS); +extern Datum pg_ls_logicalmapdir(PG_FUNCTION_ARGS); +extern Datum pg_ls_replslotdir(PG_FUNCTION_ARGS); + +#endif /* FMGRPROTOS_H */ diff --git a/src/backend/utils/fmgrtab.c b/src/backend/utils/fmgrtab.c new file mode 100644 index 0000000..dc56c13 --- /dev/null +++ b/src/backend/utils/fmgrtab.c @@ -0,0 +1,9254 @@ +/*------------------------------------------------------------------------- + * + * fmgrtab.c + * The function manager's table of internal functions. + * + * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * NOTES + * + * ****************************** + * *** DO NOT EDIT THIS FILE! *** + * ****************************** + * + * It has been GENERATED by src/backend/utils/Gen_fmgrtab.pl + * + *------------------------------------------------------------------------- + */ + +#include "postgres.h" + +#include "access/transam.h" +#include "utils/fmgrtab.h" +#include "utils/fmgrprotos.h" + + +const FmgrBuiltin fmgr_builtins[] = { + { 3, 1, true, false, "heap_tableam_handler", heap_tableam_handler }, + { 31, 1, true, false, "byteaout", byteaout }, + { 33, 1, true, false, "charout", charout }, + { 34, 1, true, false, "namein", namein }, + { 35, 1, true, false, "nameout", nameout }, + { 38, 1, true, false, "int2in", int2in }, + { 39, 1, true, false, "int2out", int2out }, + { 40, 1, true, false, "int2vectorin", int2vectorin }, + { 41, 1, true, false, "int2vectorout", int2vectorout }, + { 42, 1, true, false, "int4in", int4in }, + { 43, 1, true, false, "int4out", int4out }, + { 44, 1, true, false, "regprocin", regprocin }, + { 45, 1, true, false, "regprocout", regprocout }, + { 46, 1, true, false, "textin", textin }, + { 47, 1, true, false, "textout", textout }, + { 48, 1, true, false, "tidin", tidin }, + { 49, 1, true, false, "tidout", tidout }, + { 50, 1, true, false, "xidin", xidin }, + { 51, 1, true, false, "xidout", xidout }, + { 52, 1, true, false, "cidin", cidin }, + { 53, 1, true, false, "cidout", cidout }, + { 54, 1, true, false, "oidvectorin", oidvectorin }, + { 55, 1, true, false, "oidvectorout", oidvectorout }, + { 56, 2, true, false, "boollt", boollt }, + { 57, 2, true, false, "boolgt", boolgt }, + { 60, 2, true, false, "booleq", booleq }, + { 61, 2, true, false, "chareq", chareq }, + { 62, 2, true, false, "nameeq", nameeq }, + { 63, 2, true, false, "int2eq", int2eq }, + { 64, 2, true, false, "int2lt", int2lt }, + { 65, 2, true, false, "int4eq", int4eq }, + { 66, 2, true, false, "int4lt", int4lt }, + { 67, 2, true, false, "texteq", texteq }, + { 68, 2, true, false, "xideq", xideq }, + { 69, 2, true, false, "cideq", cideq }, + { 70, 2, true, false, "charne", charne }, + { 72, 2, true, false, "charle", charle }, + { 73, 2, true, false, "chargt", chargt }, + { 74, 2, true, false, "charge", charge }, + { 77, 1, true, false, "chartoi4", chartoi4 }, + { 78, 1, true, false, "i4tochar", i4tochar }, + { 79, 2, true, false, "nameregexeq", nameregexeq }, + { 84, 2, true, false, "boolne", boolne }, + { 86, 1, true, false, "pg_ddl_command_in", pg_ddl_command_in }, + { 87, 1, true, false, "pg_ddl_command_out", pg_ddl_command_out }, + { 88, 1, true, false, "pg_ddl_command_recv", pg_ddl_command_recv }, + { 89, 0, true, false, "pgsql_version", pgsql_version }, + { 90, 1, true, false, "pg_ddl_command_send", pg_ddl_command_send }, + { 101, 4, true, false, "eqsel", eqsel }, + { 102, 4, true, false, "neqsel", neqsel }, + { 103, 4, true, false, "scalarltsel", scalarltsel }, + { 104, 4, true, false, "scalargtsel", scalargtsel }, + { 105, 5, true, false, "eqjoinsel", eqjoinsel }, + { 106, 5, true, false, "neqjoinsel", neqjoinsel }, + { 107, 5, true, false, "scalarltjoinsel", scalarltjoinsel }, + { 108, 5, true, false, "scalargtjoinsel", scalargtjoinsel }, + { 109, 1, true, false, "unknownin", unknownin }, + { 110, 1, true, false, "unknownout", unknownout }, + { 115, 2, true, false, "box_above_eq", box_above_eq }, + { 116, 2, true, false, "box_below_eq", box_below_eq }, + { 117, 1, true, false, "point_in", point_in }, + { 118, 1, true, false, "point_out", point_out }, + { 119, 1, true, false, "lseg_in", lseg_in }, + { 120, 1, true, false, "lseg_out", lseg_out }, + { 121, 1, true, false, "path_in", path_in }, + { 122, 1, true, false, "path_out", path_out }, + { 123, 1, true, false, "box_in", box_in }, + { 124, 1, true, false, "box_out", box_out }, + { 125, 2, true, false, "box_overlap", box_overlap }, + { 126, 2, true, false, "box_ge", box_ge }, + { 127, 2, true, false, "box_gt", box_gt }, + { 128, 2, true, false, "box_eq", box_eq }, + { 129, 2, true, false, "box_lt", box_lt }, + { 130, 2, true, false, "box_le", box_le }, + { 131, 2, true, false, "point_above", point_above }, + { 132, 2, true, false, "point_left", point_left }, + { 133, 2, true, false, "point_right", point_right }, + { 134, 2, true, false, "point_below", point_below }, + { 135, 2, true, false, "point_eq", point_eq }, + { 136, 2, true, false, "on_pb", on_pb }, + { 137, 2, true, false, "on_ppath", on_ppath }, + { 138, 1, true, false, "box_center", box_center }, + { 139, 4, true, false, "areasel", areasel }, + { 140, 5, true, false, "areajoinsel", areajoinsel }, + { 141, 2, true, false, "int4mul", int4mul }, + { 144, 2, true, false, "int4ne", int4ne }, + { 145, 2, true, false, "int2ne", int2ne }, + { 146, 2, true, false, "int2gt", int2gt }, + { 147, 2, true, false, "int4gt", int4gt }, + { 148, 2, true, false, "int2le", int2le }, + { 149, 2, true, false, "int4le", int4le }, + { 150, 2, true, false, "int4ge", int4ge }, + { 151, 2, true, false, "int2ge", int2ge }, + { 152, 2, true, false, "int2mul", int2mul }, + { 153, 2, true, false, "int2div", int2div }, + { 154, 2, true, false, "int4div", int4div }, + { 155, 2, true, false, "int2mod", int2mod }, + { 156, 2, true, false, "int4mod", int4mod }, + { 157, 2, true, false, "textne", textne }, + { 158, 2, true, false, "int24eq", int24eq }, + { 159, 2, true, false, "int42eq", int42eq }, + { 160, 2, true, false, "int24lt", int24lt }, + { 161, 2, true, false, "int42lt", int42lt }, + { 162, 2, true, false, "int24gt", int24gt }, + { 163, 2, true, false, "int42gt", int42gt }, + { 164, 2, true, false, "int24ne", int24ne }, + { 165, 2, true, false, "int42ne", int42ne }, + { 166, 2, true, false, "int24le", int24le }, + { 167, 2, true, false, "int42le", int42le }, + { 168, 2, true, false, "int24ge", int24ge }, + { 169, 2, true, false, "int42ge", int42ge }, + { 170, 2, true, false, "int24mul", int24mul }, + { 171, 2, true, false, "int42mul", int42mul }, + { 172, 2, true, false, "int24div", int24div }, + { 173, 2, true, false, "int42div", int42div }, + { 176, 2, true, false, "int2pl", int2pl }, + { 177, 2, true, false, "int4pl", int4pl }, + { 178, 2, true, false, "int24pl", int24pl }, + { 179, 2, true, false, "int42pl", int42pl }, + { 180, 2, true, false, "int2mi", int2mi }, + { 181, 2, true, false, "int4mi", int4mi }, + { 182, 2, true, false, "int24mi", int24mi }, + { 183, 2, true, false, "int42mi", int42mi }, + { 184, 2, true, false, "oideq", oideq }, + { 185, 2, true, false, "oidne", oidne }, + { 186, 2, true, false, "box_same", box_same }, + { 187, 2, true, false, "box_contain", box_contain }, + { 188, 2, true, false, "box_left", box_left }, + { 189, 2, true, false, "box_overleft", box_overleft }, + { 190, 2, true, false, "box_overright", box_overright }, + { 191, 2, true, false, "box_right", box_right }, + { 192, 2, true, false, "box_contained", box_contained }, + { 193, 2, true, false, "box_contain_pt", box_contain_pt }, + { 195, 1, true, false, "pg_node_tree_in", pg_node_tree_in }, + { 196, 1, true, false, "pg_node_tree_out", pg_node_tree_out }, + { 197, 1, true, false, "pg_node_tree_recv", pg_node_tree_recv }, + { 198, 1, true, false, "pg_node_tree_send", pg_node_tree_send }, + { 200, 1, true, false, "float4in", float4in }, + { 201, 1, true, false, "float4out", float4out }, + { 202, 2, true, false, "float4mul", float4mul }, + { 203, 2, true, false, "float4div", float4div }, + { 204, 2, true, false, "float4pl", float4pl }, + { 205, 2, true, false, "float4mi", float4mi }, + { 206, 1, true, false, "float4um", float4um }, + { 207, 1, true, false, "float4abs", float4abs }, + { 208, 2, true, false, "float4_accum", float4_accum }, + { 209, 2, true, false, "float4larger", float4larger }, + { 211, 2, true, false, "float4smaller", float4smaller }, + { 212, 1, true, false, "int4um", int4um }, + { 213, 1, true, false, "int2um", int2um }, + { 214, 1, true, false, "float8in", float8in }, + { 215, 1, true, false, "float8out", float8out }, + { 216, 2, true, false, "float8mul", float8mul }, + { 217, 2, true, false, "float8div", float8div }, + { 218, 2, true, false, "float8pl", float8pl }, + { 219, 2, true, false, "float8mi", float8mi }, + { 220, 1, true, false, "float8um", float8um }, + { 221, 1, true, false, "float8abs", float8abs }, + { 222, 2, true, false, "float8_accum", float8_accum }, + { 223, 2, true, false, "float8larger", float8larger }, + { 224, 2, true, false, "float8smaller", float8smaller }, + { 225, 1, true, false, "lseg_center", lseg_center }, + { 227, 1, true, false, "poly_center", poly_center }, + { 228, 1, true, false, "dround", dround }, + { 229, 1, true, false, "dtrunc", dtrunc }, + { 230, 1, true, false, "dsqrt", dsqrt }, + { 231, 1, true, false, "dcbrt", dcbrt }, + { 232, 2, true, false, "dpow", dpow }, + { 233, 1, true, false, "dexp", dexp }, + { 234, 1, true, false, "dlog1", dlog1 }, + { 235, 1, true, false, "i2tod", i2tod }, + { 236, 1, true, false, "i2tof", i2tof }, + { 237, 1, true, false, "dtoi2", dtoi2 }, + { 238, 1, true, false, "ftoi2", ftoi2 }, + { 239, 2, true, false, "line_distance", line_distance }, + { 240, 2, true, false, "nameeqtext", nameeqtext }, + { 241, 2, true, false, "namelttext", namelttext }, + { 242, 2, true, false, "nameletext", nameletext }, + { 243, 2, true, false, "namegetext", namegetext }, + { 244, 2, true, false, "namegttext", namegttext }, + { 245, 2, true, false, "namenetext", namenetext }, + { 246, 2, true, false, "btnametextcmp", btnametextcmp }, + { 247, 2, true, false, "texteqname", texteqname }, + { 248, 2, true, false, "textltname", textltname }, + { 249, 2, true, false, "textlename", textlename }, + { 250, 2, true, false, "textgename", textgename }, + { 251, 2, true, false, "textgtname", textgtname }, + { 252, 2, true, false, "textnename", textnename }, + { 253, 2, true, false, "bttextnamecmp", bttextnamecmp }, + { 266, 2, true, false, "nameconcatoid", nameconcatoid }, + { 267, 1, false, false, "table_am_handler_in", table_am_handler_in }, + { 268, 1, true, false, "table_am_handler_out", table_am_handler_out }, + { 274, 0, true, false, "timeofday", timeofday }, + { 275, 3, true, false, "pg_nextoid", pg_nextoid }, + { 276, 2, true, false, "float8_combine", float8_combine }, + { 277, 2, true, false, "inter_sl", inter_sl }, + { 278, 2, true, false, "inter_lb", inter_lb }, + { 279, 2, true, false, "float48mul", float48mul }, + { 280, 2, true, false, "float48div", float48div }, + { 281, 2, true, false, "float48pl", float48pl }, + { 282, 2, true, false, "float48mi", float48mi }, + { 283, 2, true, false, "float84mul", float84mul }, + { 284, 2, true, false, "float84div", float84div }, + { 285, 2, true, false, "float84pl", float84pl }, + { 286, 2, true, false, "float84mi", float84mi }, + { 287, 2, true, false, "float4eq", float4eq }, + { 288, 2, true, false, "float4ne", float4ne }, + { 289, 2, true, false, "float4lt", float4lt }, + { 290, 2, true, false, "float4le", float4le }, + { 291, 2, true, false, "float4gt", float4gt }, + { 292, 2, true, false, "float4ge", float4ge }, + { 293, 2, true, false, "float8eq", float8eq }, + { 294, 2, true, false, "float8ne", float8ne }, + { 295, 2, true, false, "float8lt", float8lt }, + { 296, 2, true, false, "float8le", float8le }, + { 297, 2, true, false, "float8gt", float8gt }, + { 298, 2, true, false, "float8ge", float8ge }, + { 299, 2, true, false, "float48eq", float48eq }, + { 300, 2, true, false, "float48ne", float48ne }, + { 301, 2, true, false, "float48lt", float48lt }, + { 302, 2, true, false, "float48le", float48le }, + { 303, 2, true, false, "float48gt", float48gt }, + { 304, 2, true, false, "float48ge", float48ge }, + { 305, 2, true, false, "float84eq", float84eq }, + { 306, 2, true, false, "float84ne", float84ne }, + { 307, 2, true, false, "float84lt", float84lt }, + { 308, 2, true, false, "float84le", float84le }, + { 309, 2, true, false, "float84gt", float84gt }, + { 310, 2, true, false, "float84ge", float84ge }, + { 311, 1, true, false, "ftod", ftod }, + { 312, 1, true, false, "dtof", dtof }, + { 313, 1, true, false, "i2toi4", i2toi4 }, + { 314, 1, true, false, "i4toi2", i4toi2 }, + { 315, 0, true, false, "pg_jit_available", pg_jit_available }, + { 316, 1, true, false, "i4tod", i4tod }, + { 317, 1, true, false, "dtoi4", dtoi4 }, + { 318, 1, true, false, "i4tof", i4tof }, + { 319, 1, true, false, "ftoi4", ftoi4 }, + { 320, 4, true, false, "width_bucket_float8", width_bucket_float8 }, + { 321, 1, true, false, "json_in", json_in }, + { 322, 1, true, false, "json_out", json_out }, + { 323, 1, true, false, "json_recv", json_recv }, + { 324, 1, true, false, "json_send", json_send }, + { 326, 1, false, false, "index_am_handler_in", index_am_handler_in }, + { 327, 1, true, false, "index_am_handler_out", index_am_handler_out }, + { 328, 1, true, false, "hashmacaddr8", hashmacaddr8 }, + { 329, 1, true, false, "hash_aclitem", hash_aclitem }, + { 330, 1, true, false, "bthandler", bthandler }, + { 331, 1, true, false, "hashhandler", hashhandler }, + { 332, 1, true, false, "gisthandler", gisthandler }, + { 333, 1, true, false, "ginhandler", ginhandler }, + { 334, 1, true, false, "spghandler", spghandler }, + { 335, 1, true, false, "brinhandler", brinhandler }, + { 336, 4, true, false, "scalarlesel", scalarlesel }, + { 337, 4, true, false, "scalargesel", scalargesel }, + { 338, 1, true, false, "amvalidate", amvalidate }, + { 339, 2, true, false, "poly_same", poly_same }, + { 340, 2, true, false, "poly_contain", poly_contain }, + { 341, 2, true, false, "poly_left", poly_left }, + { 342, 2, true, false, "poly_overleft", poly_overleft }, + { 343, 2, true, false, "poly_overright", poly_overright }, + { 344, 2, true, false, "poly_right", poly_right }, + { 345, 2, true, false, "poly_contained", poly_contained }, + { 346, 2, true, false, "poly_overlap", poly_overlap }, + { 347, 1, true, false, "poly_in", poly_in }, + { 348, 1, true, false, "poly_out", poly_out }, + { 350, 2, true, false, "btint2cmp", btint2cmp }, + { 351, 2, true, false, "btint4cmp", btint4cmp }, + { 354, 2, true, false, "btfloat4cmp", btfloat4cmp }, + { 355, 2, true, false, "btfloat8cmp", btfloat8cmp }, + { 356, 2, true, false, "btoidcmp", btoidcmp }, + { 357, 2, true, false, "dist_bp", dist_bp }, + { 358, 2, true, false, "btcharcmp", btcharcmp }, + { 359, 2, true, false, "btnamecmp", btnamecmp }, + { 360, 2, true, false, "bttextcmp", bttextcmp }, + { 361, 2, true, false, "lseg_distance", lseg_distance }, + { 362, 2, true, false, "lseg_interpt", lseg_interpt }, + { 363, 2, true, false, "dist_ps", dist_ps }, + { 364, 2, true, false, "dist_pb", dist_pb }, + { 365, 2, true, false, "dist_sb", dist_sb }, + { 366, 2, true, false, "close_ps", close_ps }, + { 367, 2, true, false, "close_pb", close_pb }, + { 368, 2, true, false, "close_sb", close_sb }, + { 369, 2, true, false, "on_ps", on_ps }, + { 370, 2, true, false, "path_distance", path_distance }, + { 371, 2, true, false, "dist_ppath", dist_ppath }, + { 372, 2, true, false, "on_sb", on_sb }, + { 373, 2, true, false, "inter_sb", inter_sb }, + { 376, 3, false, false, "text_to_array_null", text_to_array_null }, + { 377, 2, true, false, "cash_cmp", cash_cmp }, + { 378, 2, false, false, "array_append", array_append }, + { 379, 2, false, false, "array_prepend", array_prepend }, + { 380, 2, true, false, "dist_sp", dist_sp }, + { 381, 2, true, false, "dist_bs", dist_bs }, + { 382, 2, true, false, "btarraycmp", btarraycmp }, + { 383, 2, false, false, "array_cat", array_cat }, + { 384, 3, false, false, "array_to_text_null", array_to_text_null }, + { 386, 5, true, false, "scalarlejoinsel", scalarlejoinsel }, + { 390, 2, true, false, "array_ne", array_ne }, + { 391, 2, true, false, "array_lt", array_lt }, + { 392, 2, true, false, "array_gt", array_gt }, + { 393, 2, true, false, "array_le", array_le }, + { 394, 2, false, false, "text_to_array", text_to_array }, + { 395, 2, true, false, "array_to_text", array_to_text }, + { 396, 2, true, false, "array_ge", array_ge }, + { 398, 5, true, false, "scalargejoinsel", scalargejoinsel }, + { 399, 1, true, false, "hashmacaddr", hashmacaddr }, + { 400, 1, true, false, "hashtext", hashtext }, + { 401, 1, true, false, "rtrim1", rtrim1 }, + { 404, 2, true, false, "btoidvectorcmp", btoidvectorcmp }, + { 406, 1, true, false, "name_text", name_text }, + { 407, 1, true, false, "text_name", text_name }, + { 408, 1, true, false, "name_bpchar", name_bpchar }, + { 409, 1, true, false, "bpchar_name", bpchar_name }, + { 421, 2, true, false, "dist_pathp", dist_pathp }, + { 422, 1, true, false, "hashinet", hashinet }, + { 425, 2, true, false, "hashint4extended", hashint4extended }, + { 432, 1, true, false, "hash_numeric", hash_numeric }, + { 436, 1, true, false, "macaddr_in", macaddr_in }, + { 437, 1, true, false, "macaddr_out", macaddr_out }, + { 438, 1, false, false, "pg_num_nulls", pg_num_nulls }, + { 440, 1, false, false, "pg_num_nonnulls", pg_num_nonnulls }, + { 441, 2, true, false, "hashint2extended", hashint2extended }, + { 442, 2, true, false, "hashint8extended", hashint8extended }, + { 443, 2, true, false, "hashfloat4extended", hashfloat4extended }, + { 444, 2, true, false, "hashfloat8extended", hashfloat8extended }, + { 445, 2, true, false, "hashoidextended", hashoidextended }, + { 446, 2, true, false, "hashcharextended", hashcharextended }, + { 447, 2, true, false, "hashnameextended", hashnameextended }, + { 448, 2, true, false, "hashtextextended", hashtextextended }, + { 449, 1, true, false, "hashint2", hashint2 }, + { 450, 1, true, false, "hashint4", hashint4 }, + { 451, 1, true, false, "hashfloat4", hashfloat4 }, + { 452, 1, true, false, "hashfloat8", hashfloat8 }, + { 453, 1, true, false, "hashoid", hashoid }, + { 454, 1, true, false, "hashchar", hashchar }, + { 455, 1, true, false, "hashname", hashname }, + { 456, 1, true, false, "hashvarlena", hashvarlena }, + { 457, 1, true, false, "hashoidvector", hashoidvector }, + { 458, 2, true, false, "text_larger", text_larger }, + { 459, 2, true, false, "text_smaller", text_smaller }, + { 460, 1, true, false, "int8in", int8in }, + { 461, 1, true, false, "int8out", int8out }, + { 462, 1, true, false, "int8um", int8um }, + { 463, 2, true, false, "int8pl", int8pl }, + { 464, 2, true, false, "int8mi", int8mi }, + { 465, 2, true, false, "int8mul", int8mul }, + { 466, 2, true, false, "int8div", int8div }, + { 467, 2, true, false, "int8eq", int8eq }, + { 468, 2, true, false, "int8ne", int8ne }, + { 469, 2, true, false, "int8lt", int8lt }, + { 470, 2, true, false, "int8gt", int8gt }, + { 471, 2, true, false, "int8le", int8le }, + { 472, 2, true, false, "int8ge", int8ge }, + { 474, 2, true, false, "int84eq", int84eq }, + { 475, 2, true, false, "int84ne", int84ne }, + { 476, 2, true, false, "int84lt", int84lt }, + { 477, 2, true, false, "int84gt", int84gt }, + { 478, 2, true, false, "int84le", int84le }, + { 479, 2, true, false, "int84ge", int84ge }, + { 480, 1, true, false, "int84", int84 }, + { 481, 1, true, false, "int48", int48 }, + { 482, 1, true, false, "i8tod", i8tod }, + { 483, 1, true, false, "dtoi8", dtoi8 }, + { 515, 2, true, false, "array_larger", array_larger }, + { 516, 2, true, false, "array_smaller", array_smaller }, + { 598, 1, true, false, "inet_abbrev", inet_abbrev }, + { 599, 1, true, false, "cidr_abbrev", cidr_abbrev }, + { 605, 2, true, false, "inet_set_masklen", inet_set_masklen }, + { 619, 2, true, false, "oidvectorne", oidvectorne }, + { 626, 1, true, false, "hash_array", hash_array }, + { 635, 2, true, false, "cidr_set_masklen", cidr_set_masklen }, + { 636, 2, true, false, "pg_indexam_has_property", pg_indexam_has_property }, + { 637, 2, true, false, "pg_index_has_property", pg_index_has_property }, + { 638, 3, true, false, "pg_index_column_has_property", pg_index_column_has_property }, + { 652, 1, true, false, "i8tof", i8tof }, + { 653, 1, true, false, "ftoi8", ftoi8 }, + { 655, 2, true, false, "namelt", namelt }, + { 656, 2, true, false, "namele", namele }, + { 657, 2, true, false, "namegt", namegt }, + { 658, 2, true, false, "namege", namege }, + { 659, 2, true, false, "namene", namene }, + { 668, 3, true, false, "bpchar", bpchar }, + { 669, 3, true, false, "varchar", varchar }, + { 676, 2, true, false, "pg_indexam_progress_phasename", pg_indexam_progress_phasename }, + { 677, 2, true, false, "oidvectorlt", oidvectorlt }, + { 678, 2, true, false, "oidvectorle", oidvectorle }, + { 679, 2, true, false, "oidvectoreq", oidvectoreq }, + { 680, 2, true, false, "oidvectorge", oidvectorge }, + { 681, 2, true, false, "oidvectorgt", oidvectorgt }, + { 683, 1, true, false, "network_network", network_network }, + { 696, 1, true, false, "network_netmask", network_netmask }, + { 697, 1, true, false, "network_masklen", network_masklen }, + { 698, 1, true, false, "network_broadcast", network_broadcast }, + { 699, 1, true, false, "network_host", network_host }, + { 702, 2, true, false, "dist_lp", dist_lp }, + { 704, 2, true, false, "dist_ls", dist_ls }, + { 710, 0, true, false, "current_user", current_user }, + { 711, 1, true, false, "network_family", network_family }, + { 714, 1, true, false, "int82", int82 }, + { 715, 1, true, false, "be_lo_create", be_lo_create }, + { 716, 2, true, false, "oidlt", oidlt }, + { 717, 2, true, false, "oidle", oidle }, + { 720, 1, true, false, "byteaoctetlen", byteaoctetlen }, + { 721, 2, true, false, "byteaGetByte", byteaGetByte }, + { 722, 3, true, false, "byteaSetByte", byteaSetByte }, + { 723, 2, true, false, "byteaGetBit", byteaGetBit }, + { 724, 3, true, false, "byteaSetBit", byteaSetBit }, + { 725, 2, true, false, "dist_pl", dist_pl }, + { 727, 2, true, false, "dist_sl", dist_sl }, + { 728, 2, true, false, "dist_cpoly", dist_cpoly }, + { 729, 2, true, false, "poly_distance", poly_distance }, + { 730, 1, true, false, "network_show", network_show }, + { 740, 2, true, false, "text_lt", text_lt }, + { 741, 2, true, false, "text_le", text_le }, + { 742, 2, true, false, "text_gt", text_gt }, + { 743, 2, true, false, "text_ge", text_ge }, + { 744, 2, true, false, "array_eq", array_eq }, + { 745, 0, true, false, "current_user", current_user }, + { 746, 0, true, false, "session_user", session_user }, + { 747, 1, true, false, "array_dims", array_dims }, + { 748, 1, true, false, "array_ndims", array_ndims }, + { 749, 4, true, false, "byteaoverlay", byteaoverlay }, + { 750, 3, true, false, "array_in", array_in }, + { 751, 1, true, false, "array_out", array_out }, + { 752, 3, true, false, "byteaoverlay_no_len", byteaoverlay_no_len }, + { 753, 1, true, false, "macaddr_trunc", macaddr_trunc }, + { 754, 1, true, false, "int28", int28 }, + { 764, 1, true, false, "be_lo_import", be_lo_import }, + { 765, 2, true, false, "be_lo_export", be_lo_export }, + { 766, 1, true, false, "int4inc", int4inc }, + { 767, 2, true, false, "be_lo_import_with_oid", be_lo_import_with_oid }, + { 768, 2, true, false, "int4larger", int4larger }, + { 769, 2, true, false, "int4smaller", int4smaller }, + { 770, 2, true, false, "int2larger", int2larger }, + { 771, 2, true, false, "int2smaller", int2smaller }, + { 772, 2, true, false, "hashvarlenaextended", hashvarlenaextended }, + { 776, 2, true, false, "hashoidvectorextended", hashoidvectorextended }, + { 777, 2, true, false, "hash_aclitem_extended", hash_aclitem_extended }, + { 778, 2, true, false, "hashmacaddrextended", hashmacaddrextended }, + { 779, 2, true, false, "hashinetextended", hashinetextended }, + { 780, 2, true, false, "hash_numeric_extended", hash_numeric_extended }, + { 781, 2, true, false, "hashmacaddr8extended", hashmacaddr8extended }, + { 782, 2, true, false, "hash_array_extended", hash_array_extended }, + { 785, 2, true, false, "dist_polyc", dist_polyc }, + { 810, 0, true, false, "pg_client_encoding", pg_client_encoding }, + { 817, 0, false, false, "current_query", current_query }, + { 830, 2, true, false, "macaddr_eq", macaddr_eq }, + { 831, 2, true, false, "macaddr_lt", macaddr_lt }, + { 832, 2, true, false, "macaddr_le", macaddr_le }, + { 833, 2, true, false, "macaddr_gt", macaddr_gt }, + { 834, 2, true, false, "macaddr_ge", macaddr_ge }, + { 835, 2, true, false, "macaddr_ne", macaddr_ne }, + { 836, 2, true, false, "macaddr_cmp", macaddr_cmp }, + { 837, 2, true, false, "int82pl", int82pl }, + { 838, 2, true, false, "int82mi", int82mi }, + { 839, 2, true, false, "int82mul", int82mul }, + { 840, 2, true, false, "int82div", int82div }, + { 841, 2, true, false, "int28pl", int28pl }, + { 842, 2, true, false, "btint8cmp", btint8cmp }, + { 846, 2, true, false, "cash_mul_flt4", cash_mul_flt4 }, + { 847, 2, true, false, "cash_div_flt4", cash_div_flt4 }, + { 848, 2, true, false, "flt4_mul_cash", flt4_mul_cash }, + { 849, 2, true, false, "textpos", textpos }, + { 850, 2, true, false, "textlike", textlike }, + { 851, 2, true, false, "textnlike", textnlike }, + { 852, 2, true, false, "int48eq", int48eq }, + { 853, 2, true, false, "int48ne", int48ne }, + { 854, 2, true, false, "int48lt", int48lt }, + { 855, 2, true, false, "int48gt", int48gt }, + { 856, 2, true, false, "int48le", int48le }, + { 857, 2, true, false, "int48ge", int48ge }, + { 858, 2, true, false, "namelike", namelike }, + { 859, 2, true, false, "namenlike", namenlike }, + { 860, 1, true, false, "char_bpchar", char_bpchar }, + { 861, 0, true, false, "current_database", current_database }, + { 862, 2, true, false, "int4_mul_cash", int4_mul_cash }, + { 863, 2, true, false, "int2_mul_cash", int2_mul_cash }, + { 864, 2, true, false, "cash_mul_int4", cash_mul_int4 }, + { 865, 2, true, false, "cash_div_int4", cash_div_int4 }, + { 866, 2, true, false, "cash_mul_int2", cash_mul_int2 }, + { 867, 2, true, false, "cash_div_int2", cash_div_int2 }, + { 868, 2, true, false, "textpos", textpos }, + { 870, 1, true, false, "lower", lower }, + { 871, 1, true, false, "upper", upper }, + { 872, 1, true, false, "initcap", initcap }, + { 873, 3, true, false, "lpad", lpad }, + { 874, 3, true, false, "rpad", rpad }, + { 875, 2, true, false, "ltrim", ltrim }, + { 876, 2, true, false, "rtrim", rtrim }, + { 877, 3, true, false, "text_substr", text_substr }, + { 878, 3, true, false, "translate", translate }, + { 881, 1, true, false, "ltrim1", ltrim1 }, + { 882, 1, true, false, "rtrim1", rtrim1 }, + { 883, 2, true, false, "text_substr_no_len", text_substr_no_len }, + { 884, 2, true, false, "btrim", btrim }, + { 885, 1, true, false, "btrim1", btrim1 }, + { 886, 1, true, false, "cash_in", cash_in }, + { 887, 1, true, false, "cash_out", cash_out }, + { 888, 2, true, false, "cash_eq", cash_eq }, + { 889, 2, true, false, "cash_ne", cash_ne }, + { 890, 2, true, false, "cash_lt", cash_lt }, + { 891, 2, true, false, "cash_le", cash_le }, + { 892, 2, true, false, "cash_gt", cash_gt }, + { 893, 2, true, false, "cash_ge", cash_ge }, + { 894, 2, true, false, "cash_pl", cash_pl }, + { 895, 2, true, false, "cash_mi", cash_mi }, + { 896, 2, true, false, "cash_mul_flt8", cash_mul_flt8 }, + { 897, 2, true, false, "cash_div_flt8", cash_div_flt8 }, + { 898, 2, true, false, "cashlarger", cashlarger }, + { 899, 2, true, false, "cashsmaller", cashsmaller }, + { 910, 1, true, false, "inet_in", inet_in }, + { 911, 1, true, false, "inet_out", inet_out }, + { 919, 2, true, false, "flt8_mul_cash", flt8_mul_cash }, + { 920, 2, true, false, "network_eq", network_eq }, + { 921, 2, true, false, "network_lt", network_lt }, + { 922, 2, true, false, "network_le", network_le }, + { 923, 2, true, false, "network_gt", network_gt }, + { 924, 2, true, false, "network_ge", network_ge }, + { 925, 2, true, false, "network_ne", network_ne }, + { 926, 2, true, false, "network_cmp", network_cmp }, + { 927, 2, true, false, "network_sub", network_sub }, + { 928, 2, true, false, "network_subeq", network_subeq }, + { 929, 2, true, false, "network_sup", network_sup }, + { 930, 2, true, false, "network_supeq", network_supeq }, + { 935, 1, true, false, "cash_words", cash_words }, + { 936, 3, true, false, "text_substr", text_substr }, + { 937, 2, true, false, "text_substr_no_len", text_substr_no_len }, + { 938, 3, true, true, "generate_series_timestamp", generate_series_timestamp }, + { 939, 3, true, true, "generate_series_timestamptz", generate_series_timestamptz }, + { 940, 2, true, false, "int2mod", int2mod }, + { 941, 2, true, false, "int4mod", int4mod }, + { 942, 2, true, false, "int28mi", int28mi }, + { 943, 2, true, false, "int28mul", int28mul }, + { 944, 1, true, false, "text_char", text_char }, + { 945, 2, true, false, "int8mod", int8mod }, + { 946, 1, true, false, "char_text", char_text }, + { 947, 2, true, false, "int8mod", int8mod }, + { 948, 2, true, false, "int28div", int28div }, + { 949, 1, true, false, "hashint8", hashint8 }, + { 952, 2, true, false, "be_lo_open", be_lo_open }, + { 953, 1, true, false, "be_lo_close", be_lo_close }, + { 954, 2, true, false, "be_loread", be_loread }, + { 955, 2, true, false, "be_lowrite", be_lowrite }, + { 956, 3, true, false, "be_lo_lseek", be_lo_lseek }, + { 957, 1, true, false, "be_lo_creat", be_lo_creat }, + { 958, 1, true, false, "be_lo_tell", be_lo_tell }, + { 959, 2, true, false, "on_pl", on_pl }, + { 960, 2, true, false, "on_sl", on_sl }, + { 961, 2, true, false, "close_pl", close_pl }, + { 964, 1, true, false, "be_lo_unlink", be_lo_unlink }, + { 972, 2, true, false, "hashbpcharextended", hashbpcharextended }, + { 973, 2, true, false, "path_inter", path_inter }, + { 975, 1, true, false, "box_area", box_area }, + { 976, 1, true, false, "box_width", box_width }, + { 977, 1, true, false, "box_height", box_height }, + { 978, 2, true, false, "box_distance", box_distance }, + { 979, 1, true, false, "path_area", path_area }, + { 980, 2, true, false, "box_intersect", box_intersect }, + { 981, 1, true, false, "box_diagonal", box_diagonal }, + { 982, 2, true, false, "path_n_lt", path_n_lt }, + { 983, 2, true, false, "path_n_gt", path_n_gt }, + { 984, 2, true, false, "path_n_eq", path_n_eq }, + { 985, 2, true, false, "path_n_le", path_n_le }, + { 986, 2, true, false, "path_n_ge", path_n_ge }, + { 987, 1, true, false, "path_length", path_length }, + { 988, 2, true, false, "point_ne", point_ne }, + { 989, 2, true, false, "point_vert", point_vert }, + { 990, 2, true, false, "point_horiz", point_horiz }, + { 991, 2, true, false, "point_distance", point_distance }, + { 992, 2, true, false, "point_slope", point_slope }, + { 993, 2, true, false, "lseg_construct", lseg_construct }, + { 994, 2, true, false, "lseg_intersect", lseg_intersect }, + { 995, 2, true, false, "lseg_parallel", lseg_parallel }, + { 996, 2, true, false, "lseg_perp", lseg_perp }, + { 997, 1, true, false, "lseg_vertical", lseg_vertical }, + { 998, 1, true, false, "lseg_horizontal", lseg_horizontal }, + { 999, 2, true, false, "lseg_eq", lseg_eq }, + { 1004, 2, true, false, "be_lo_truncate", be_lo_truncate }, + { 1023, 1, true, false, "textlike_support", textlike_support }, + { 1024, 1, true, false, "texticregexeq_support", texticregexeq_support }, + { 1025, 1, true, false, "texticlike_support", texticlike_support }, + { 1026, 2, true, false, "timestamptz_izone", timestamptz_izone }, + { 1030, 1, true, false, "gist_point_compress", gist_point_compress }, + { 1031, 1, true, false, "aclitemin", aclitemin }, + { 1032, 1, true, false, "aclitemout", aclitemout }, + { 1035, 2, true, false, "aclinsert", aclinsert }, + { 1036, 2, true, false, "aclremove", aclremove }, + { 1037, 2, true, false, "aclcontains", aclcontains }, + { 1039, 0, true, false, "getdatabaseencoding", getdatabaseencoding }, + { 1044, 3, true, false, "bpcharin", bpcharin }, + { 1045, 1, true, false, "bpcharout", bpcharout }, + { 1046, 3, true, false, "varcharin", varcharin }, + { 1047, 1, true, false, "varcharout", varcharout }, + { 1048, 2, true, false, "bpchareq", bpchareq }, + { 1049, 2, true, false, "bpcharlt", bpcharlt }, + { 1050, 2, true, false, "bpcharle", bpcharle }, + { 1051, 2, true, false, "bpchargt", bpchargt }, + { 1052, 2, true, false, "bpcharge", bpcharge }, + { 1053, 2, true, false, "bpcharne", bpcharne }, + { 1062, 2, true, false, "aclitem_eq", aclitem_eq }, + { 1063, 2, true, false, "bpchar_larger", bpchar_larger }, + { 1064, 2, true, false, "bpchar_smaller", bpchar_smaller }, + { 1065, 0, true, true, "pg_prepared_xact", pg_prepared_xact }, + { 1066, 3, true, true, "generate_series_step_int4", generate_series_step_int4 }, + { 1067, 2, true, true, "generate_series_int4", generate_series_int4 }, + { 1068, 3, true, true, "generate_series_step_int8", generate_series_step_int8 }, + { 1069, 2, true, true, "generate_series_int8", generate_series_int8 }, + { 1078, 2, true, false, "bpcharcmp", bpcharcmp }, + { 1079, 1, true, false, "text_regclass", text_regclass }, + { 1080, 1, true, false, "hashbpchar", hashbpchar }, + { 1081, 2, false, false, "format_type", format_type }, + { 1084, 1, true, false, "date_in", date_in }, + { 1085, 1, true, false, "date_out", date_out }, + { 1086, 2, true, false, "date_eq", date_eq }, + { 1087, 2, true, false, "date_lt", date_lt }, + { 1088, 2, true, false, "date_le", date_le }, + { 1089, 2, true, false, "date_gt", date_gt }, + { 1090, 2, true, false, "date_ge", date_ge }, + { 1091, 2, true, false, "date_ne", date_ne }, + { 1092, 2, true, false, "date_cmp", date_cmp }, + { 1102, 2, true, false, "time_lt", time_lt }, + { 1103, 2, true, false, "time_le", time_le }, + { 1104, 2, true, false, "time_gt", time_gt }, + { 1105, 2, true, false, "time_ge", time_ge }, + { 1106, 2, true, false, "time_ne", time_ne }, + { 1107, 2, true, false, "time_cmp", time_cmp }, + { 1136, 0, false, false, "pg_stat_get_wal", pg_stat_get_wal }, + { 1137, 0, true, false, "pg_get_wal_replay_pause_state", pg_get_wal_replay_pause_state }, + { 1138, 2, true, false, "date_larger", date_larger }, + { 1139, 2, true, false, "date_smaller", date_smaller }, + { 1140, 2, true, false, "date_mi", date_mi }, + { 1141, 2, true, false, "date_pli", date_pli }, + { 1142, 2, true, false, "date_mii", date_mii }, + { 1143, 3, true, false, "time_in", time_in }, + { 1144, 1, true, false, "time_out", time_out }, + { 1145, 2, true, false, "time_eq", time_eq }, + { 1146, 2, true, false, "circle_add_pt", circle_add_pt }, + { 1147, 2, true, false, "circle_sub_pt", circle_sub_pt }, + { 1148, 2, true, false, "circle_mul_pt", circle_mul_pt }, + { 1149, 2, true, false, "circle_div_pt", circle_div_pt }, + { 1150, 3, true, false, "timestamptz_in", timestamptz_in }, + { 1151, 1, true, false, "timestamptz_out", timestamptz_out }, + { 1152, 2, true, false, "timestamp_eq", timestamp_eq }, + { 1153, 2, true, false, "timestamp_ne", timestamp_ne }, + { 1154, 2, true, false, "timestamp_lt", timestamp_lt }, + { 1155, 2, true, false, "timestamp_le", timestamp_le }, + { 1156, 2, true, false, "timestamp_ge", timestamp_ge }, + { 1157, 2, true, false, "timestamp_gt", timestamp_gt }, + { 1158, 1, true, false, "float8_timestamptz", float8_timestamptz }, + { 1159, 2, true, false, "timestamptz_zone", timestamptz_zone }, + { 1160, 3, true, false, "interval_in", interval_in }, + { 1161, 1, true, false, "interval_out", interval_out }, + { 1162, 2, true, false, "interval_eq", interval_eq }, + { 1163, 2, true, false, "interval_ne", interval_ne }, + { 1164, 2, true, false, "interval_lt", interval_lt }, + { 1165, 2, true, false, "interval_le", interval_le }, + { 1166, 2, true, false, "interval_ge", interval_ge }, + { 1167, 2, true, false, "interval_gt", interval_gt }, + { 1168, 1, true, false, "interval_um", interval_um }, + { 1169, 2, true, false, "interval_pl", interval_pl }, + { 1170, 2, true, false, "interval_mi", interval_mi }, + { 1171, 2, true, false, "timestamptz_part", timestamptz_part }, + { 1172, 2, true, false, "interval_part", interval_part }, + { 1173, 1, true, false, "network_subset_support", network_subset_support }, + { 1174, 1, true, false, "date_timestamptz", date_timestamptz }, + { 1175, 1, true, false, "interval_justify_hours", interval_justify_hours }, + { 1177, 4, true, false, "jsonb_path_exists_tz", jsonb_path_exists_tz }, + { 1178, 1, true, false, "timestamptz_date", timestamptz_date }, + { 1179, 4, true, true, "jsonb_path_query_tz", jsonb_path_query_tz }, + { 1180, 4, true, false, "jsonb_path_query_array_tz", jsonb_path_query_array_tz }, + { 1181, 1, true, false, "xid_age", xid_age }, + { 1188, 2, true, false, "timestamp_mi", timestamp_mi }, + { 1189, 2, true, false, "timestamptz_pl_interval", timestamptz_pl_interval }, + { 1190, 2, true, false, "timestamptz_mi_interval", timestamptz_mi_interval }, + { 1191, 3, true, true, "generate_subscripts", generate_subscripts }, + { 1192, 2, true, true, "generate_subscripts_nodir", generate_subscripts_nodir }, + { 1193, 2, false, false, "array_fill", array_fill }, + { 1194, 1, true, false, "dlog10", dlog10 }, + { 1195, 2, true, false, "timestamp_smaller", timestamp_smaller }, + { 1196, 2, true, false, "timestamp_larger", timestamp_larger }, + { 1197, 2, true, false, "interval_smaller", interval_smaller }, + { 1198, 2, true, false, "interval_larger", interval_larger }, + { 1199, 2, true, false, "timestamptz_age", timestamptz_age }, + { 1200, 2, true, false, "interval_scale", interval_scale }, + { 1217, 2, true, false, "timestamptz_trunc", timestamptz_trunc }, + { 1218, 2, true, false, "interval_trunc", interval_trunc }, + { 1219, 1, true, false, "int8inc", int8inc }, + { 1230, 1, true, false, "int8abs", int8abs }, + { 1236, 2, true, false, "int8larger", int8larger }, + { 1237, 2, true, false, "int8smaller", int8smaller }, + { 1238, 2, true, false, "texticregexeq", texticregexeq }, + { 1239, 2, true, false, "texticregexne", texticregexne }, + { 1240, 2, true, false, "nameicregexeq", nameicregexeq }, + { 1241, 2, true, false, "nameicregexne", nameicregexne }, + { 1242, 1, true, false, "boolin", boolin }, + { 1243, 1, true, false, "boolout", boolout }, + { 1244, 1, true, false, "byteain", byteain }, + { 1245, 1, true, false, "charin", charin }, + { 1246, 2, true, false, "charlt", charlt }, + { 1250, 0, true, false, "unique_key_recheck", unique_key_recheck }, + { 1251, 1, true, false, "int4abs", int4abs }, + { 1252, 2, true, false, "nameregexne", nameregexne }, + { 1253, 1, true, false, "int2abs", int2abs }, + { 1254, 2, true, false, "textregexeq", textregexeq }, + { 1256, 2, true, false, "textregexne", textregexne }, + { 1257, 1, true, false, "textlen", textlen }, + { 1258, 2, true, false, "textcat", textcat }, + { 1264, 1, true, false, "PG_char_to_encoding", PG_char_to_encoding }, + { 1265, 2, true, false, "tidne", tidne }, + { 1267, 1, true, false, "cidr_in", cidr_in }, + { 1268, 2, true, false, "parse_ident", parse_ident }, + { 1269, 1, true, false, "pg_column_size", pg_column_size }, + { 1271, 4, false, false, "overlaps_timetz", overlaps_timetz }, + { 1272, 2, true, false, "datetime_timestamp", datetime_timestamp }, + { 1273, 2, true, false, "timetz_part", timetz_part }, + { 1274, 2, true, false, "int84pl", int84pl }, + { 1275, 2, true, false, "int84mi", int84mi }, + { 1276, 2, true, false, "int84mul", int84mul }, + { 1277, 2, true, false, "int84div", int84div }, + { 1278, 2, true, false, "int48pl", int48pl }, + { 1279, 2, true, false, "int48mi", int48mi }, + { 1280, 2, true, false, "int48mul", int48mul }, + { 1281, 2, true, false, "int48div", int48div }, + { 1282, 1, true, false, "quote_ident", quote_ident }, + { 1283, 1, true, false, "quote_literal", quote_literal }, + { 1284, 3, true, false, "timestamptz_trunc_zone", timestamptz_trunc_zone }, + { 1286, 3, false, false, "array_fill_with_lower_bounds", array_fill_with_lower_bounds }, + { 1287, 1, true, false, "i8tooid", i8tooid }, + { 1288, 1, true, false, "oidtoi8", oidtoi8 }, + { 1289, 1, false, false, "quote_nullable", quote_nullable }, + { 1291, 0, true, false, "suppress_redundant_updates_trigger", suppress_redundant_updates_trigger }, + { 1292, 2, true, false, "tideq", tideq }, + { 1293, 1, true, true, "multirange_unnest", multirange_unnest }, + { 1294, 2, true, false, "currtid_byrelname", currtid_byrelname }, + { 1295, 1, true, false, "interval_justify_days", interval_justify_days }, + { 1297, 2, true, false, "datetimetz_timestamptz", datetimetz_timestamptz }, + { 1299, 0, true, false, "now", now }, + { 1300, 4, true, false, "positionsel", positionsel }, + { 1301, 5, true, false, "positionjoinsel", positionjoinsel }, + { 1302, 4, true, false, "contsel", contsel }, + { 1303, 5, true, false, "contjoinsel", contjoinsel }, + { 1304, 4, false, false, "overlaps_timestamp", overlaps_timestamp }, + { 1308, 4, false, false, "overlaps_time", overlaps_time }, + { 1312, 3, true, false, "timestamp_in", timestamp_in }, + { 1313, 1, true, false, "timestamp_out", timestamp_out }, + { 1314, 2, true, false, "timestamp_cmp", timestamp_cmp }, + { 1315, 2, true, false, "interval_cmp", interval_cmp }, + { 1316, 1, true, false, "timestamp_time", timestamp_time }, + { 1317, 1, true, false, "textlen", textlen }, + { 1318, 1, true, false, "bpcharlen", bpcharlen }, + { 1319, 2, true, false, "xideq", xideq }, + { 1326, 2, true, false, "interval_div", interval_div }, + { 1339, 1, true, false, "dlog10", dlog10 }, + { 1340, 1, true, false, "dlog10", dlog10 }, + { 1341, 1, true, false, "dlog1", dlog1 }, + { 1342, 1, true, false, "dround", dround }, + { 1343, 1, true, false, "dtrunc", dtrunc }, + { 1344, 1, true, false, "dsqrt", dsqrt }, + { 1345, 1, true, false, "dcbrt", dcbrt }, + { 1346, 2, true, false, "dpow", dpow }, + { 1347, 1, true, false, "dexp", dexp }, + { 1349, 1, true, false, "oidvectortypes", oidvectortypes }, + { 1350, 3, true, false, "timetz_in", timetz_in }, + { 1351, 1, true, false, "timetz_out", timetz_out }, + { 1352, 2, true, false, "timetz_eq", timetz_eq }, + { 1353, 2, true, false, "timetz_ne", timetz_ne }, + { 1354, 2, true, false, "timetz_lt", timetz_lt }, + { 1355, 2, true, false, "timetz_le", timetz_le }, + { 1356, 2, true, false, "timetz_ge", timetz_ge }, + { 1357, 2, true, false, "timetz_gt", timetz_gt }, + { 1358, 2, true, false, "timetz_cmp", timetz_cmp }, + { 1359, 2, true, false, "datetimetz_timestamptz", datetimetz_timestamptz }, + { 1362, 1, true, false, "network_hostmask", network_hostmask }, + { 1364, 1, true, false, "textregexeq_support", textregexeq_support }, + { 1365, 4, true, false, "makeaclitem", makeaclitem }, + { 1367, 1, true, false, "bpcharlen", bpcharlen }, + { 1368, 2, true, false, "dpow", dpow }, + { 1369, 1, true, false, "textlen", textlen }, + { 1370, 1, true, false, "time_interval", time_interval }, + { 1371, 0, true, true, "pg_lock_status", pg_lock_status }, + { 1372, 1, true, false, "bpcharlen", bpcharlen }, + { 1373, 1, true, false, "date_finite", date_finite }, + { 1374, 1, true, false, "textoctetlen", textoctetlen }, + { 1375, 1, true, false, "bpcharoctetlen", bpcharoctetlen }, + { 1376, 1, true, false, "numeric_fac", numeric_fac }, + { 1377, 2, true, false, "time_larger", time_larger }, + { 1378, 2, true, false, "time_smaller", time_smaller }, + { 1379, 2, true, false, "timetz_larger", timetz_larger }, + { 1380, 2, true, false, "timetz_smaller", timetz_smaller }, + { 1381, 1, true, false, "textlen", textlen }, + { 1385, 2, true, false, "time_part", time_part }, + { 1387, 1, true, false, "pg_get_constraintdef", pg_get_constraintdef }, + { 1388, 1, true, false, "timestamptz_timetz", timestamptz_timetz }, + { 1389, 1, true, false, "timestamp_finite", timestamp_finite }, + { 1390, 1, true, false, "interval_finite", interval_finite }, + { 1391, 1, true, false, "pg_stat_get_backend_start", pg_stat_get_backend_start }, + { 1392, 1, true, false, "pg_stat_get_backend_client_addr", pg_stat_get_backend_client_addr }, + { 1393, 1, true, false, "pg_stat_get_backend_client_port", pg_stat_get_backend_client_port }, + { 1394, 1, true, false, "float4abs", float4abs }, + { 1395, 1, true, false, "float8abs", float8abs }, + { 1396, 1, true, false, "int8abs", int8abs }, + { 1397, 1, true, false, "int4abs", int4abs }, + { 1398, 1, true, false, "int2abs", int2abs }, + { 1400, 1, true, false, "text_name", text_name }, + { 1401, 1, true, false, "name_text", name_text }, + { 1402, 0, true, false, "current_schema", current_schema }, + { 1403, 1, true, false, "current_schemas", current_schemas }, + { 1404, 4, true, false, "textoverlay", textoverlay }, + { 1405, 3, true, false, "textoverlay_no_len", textoverlay_no_len }, + { 1406, 2, true, false, "point_vert", point_vert }, + { 1407, 2, true, false, "point_horiz", point_horiz }, + { 1408, 2, true, false, "lseg_parallel", lseg_parallel }, + { 1409, 2, true, false, "lseg_perp", lseg_perp }, + { 1410, 1, true, false, "lseg_vertical", lseg_vertical }, + { 1411, 1, true, false, "lseg_horizontal", lseg_horizontal }, + { 1412, 2, true, false, "line_parallel", line_parallel }, + { 1413, 2, true, false, "line_perp", line_perp }, + { 1414, 1, true, false, "line_vertical", line_vertical }, + { 1415, 1, true, false, "line_horizontal", line_horizontal }, + { 1416, 1, true, false, "circle_center", circle_center }, + { 1419, 1, true, false, "interval_time", interval_time }, + { 1421, 2, true, false, "points_box", points_box }, + { 1422, 2, true, false, "box_add", box_add }, + { 1423, 2, true, false, "box_sub", box_sub }, + { 1424, 2, true, false, "box_mul", box_mul }, + { 1425, 2, true, false, "box_div", box_div }, + { 1427, 1, true, false, "cidr_out", cidr_out }, + { 1428, 2, true, false, "poly_contain_pt", poly_contain_pt }, + { 1429, 2, true, false, "pt_contained_poly", pt_contained_poly }, + { 1430, 1, true, false, "path_isclosed", path_isclosed }, + { 1431, 1, true, false, "path_isopen", path_isopen }, + { 1432, 1, true, false, "path_npoints", path_npoints }, + { 1433, 1, true, false, "path_close", path_close }, + { 1434, 1, true, false, "path_open", path_open }, + { 1435, 2, true, false, "path_add", path_add }, + { 1436, 2, true, false, "path_add_pt", path_add_pt }, + { 1437, 2, true, false, "path_sub_pt", path_sub_pt }, + { 1438, 2, true, false, "path_mul_pt", path_mul_pt }, + { 1439, 2, true, false, "path_div_pt", path_div_pt }, + { 1440, 2, true, false, "construct_point", construct_point }, + { 1441, 2, true, false, "point_add", point_add }, + { 1442, 2, true, false, "point_sub", point_sub }, + { 1443, 2, true, false, "point_mul", point_mul }, + { 1444, 2, true, false, "point_div", point_div }, + { 1445, 1, true, false, "poly_npoints", poly_npoints }, + { 1446, 1, true, false, "poly_box", poly_box }, + { 1447, 1, true, false, "poly_path", poly_path }, + { 1448, 1, true, false, "box_poly", box_poly }, + { 1449, 1, true, false, "path_poly", path_poly }, + { 1450, 1, true, false, "circle_in", circle_in }, + { 1451, 1, true, false, "circle_out", circle_out }, + { 1452, 2, true, false, "circle_same", circle_same }, + { 1453, 2, true, false, "circle_contain", circle_contain }, + { 1454, 2, true, false, "circle_left", circle_left }, + { 1455, 2, true, false, "circle_overleft", circle_overleft }, + { 1456, 2, true, false, "circle_overright", circle_overright }, + { 1457, 2, true, false, "circle_right", circle_right }, + { 1458, 2, true, false, "circle_contained", circle_contained }, + { 1459, 2, true, false, "circle_overlap", circle_overlap }, + { 1460, 2, true, false, "circle_below", circle_below }, + { 1461, 2, true, false, "circle_above", circle_above }, + { 1462, 2, true, false, "circle_eq", circle_eq }, + { 1463, 2, true, false, "circle_ne", circle_ne }, + { 1464, 2, true, false, "circle_lt", circle_lt }, + { 1465, 2, true, false, "circle_gt", circle_gt }, + { 1466, 2, true, false, "circle_le", circle_le }, + { 1467, 2, true, false, "circle_ge", circle_ge }, + { 1468, 1, true, false, "circle_area", circle_area }, + { 1469, 1, true, false, "circle_diameter", circle_diameter }, + { 1470, 1, true, false, "circle_radius", circle_radius }, + { 1471, 2, true, false, "circle_distance", circle_distance }, + { 1472, 1, true, false, "circle_center", circle_center }, + { 1473, 2, true, false, "cr_circle", cr_circle }, + { 1474, 1, true, false, "poly_circle", poly_circle }, + { 1475, 2, true, false, "circle_poly", circle_poly }, + { 1476, 2, true, false, "dist_pc", dist_pc }, + { 1477, 2, true, false, "circle_contain_pt", circle_contain_pt }, + { 1478, 2, true, false, "pt_contained_circle", pt_contained_circle }, + { 1479, 1, true, false, "box_circle", box_circle }, + { 1480, 1, true, false, "circle_box", circle_box }, + { 1482, 2, true, false, "lseg_ne", lseg_ne }, + { 1483, 2, true, false, "lseg_lt", lseg_lt }, + { 1484, 2, true, false, "lseg_le", lseg_le }, + { 1485, 2, true, false, "lseg_gt", lseg_gt }, + { 1486, 2, true, false, "lseg_ge", lseg_ge }, + { 1487, 1, true, false, "lseg_length", lseg_length }, + { 1488, 2, true, false, "close_ls", close_ls }, + { 1489, 2, true, false, "close_lseg", close_lseg }, + { 1490, 1, true, false, "line_in", line_in }, + { 1491, 1, true, false, "line_out", line_out }, + { 1492, 2, true, false, "line_eq", line_eq }, + { 1493, 2, true, false, "line_construct_pp", line_construct_pp }, + { 1494, 2, true, false, "line_interpt", line_interpt }, + { 1495, 2, true, false, "line_intersect", line_intersect }, + { 1496, 2, true, false, "line_parallel", line_parallel }, + { 1497, 2, true, false, "line_perp", line_perp }, + { 1498, 1, true, false, "line_vertical", line_vertical }, + { 1499, 1, true, false, "line_horizontal", line_horizontal }, + { 1530, 1, true, false, "lseg_length", lseg_length }, + { 1531, 1, true, false, "path_length", path_length }, + { 1532, 1, true, false, "lseg_center", lseg_center }, + { 1534, 1, true, false, "box_center", box_center }, + { 1540, 1, true, false, "poly_center", poly_center }, + { 1541, 1, true, false, "box_diagonal", box_diagonal }, + { 1542, 1, true, false, "box_center", box_center }, + { 1543, 1, true, false, "circle_center", circle_center }, + { 1545, 1, true, false, "path_npoints", path_npoints }, + { 1556, 1, true, false, "poly_npoints", poly_npoints }, + { 1564, 3, true, false, "bit_in", bit_in }, + { 1565, 1, true, false, "bit_out", bit_out }, + { 1569, 2, true, false, "textlike", textlike }, + { 1570, 2, true, false, "textnlike", textnlike }, + { 1571, 2, true, false, "namelike", namelike }, + { 1572, 2, true, false, "namenlike", namenlike }, + { 1573, 1, true, false, "pg_get_ruledef", pg_get_ruledef }, + { 1574, 1, true, false, "nextval_oid", nextval_oid }, + { 1575, 1, true, false, "currval_oid", currval_oid }, + { 1576, 2, true, false, "setval_oid", setval_oid }, + { 1579, 3, true, false, "varbit_in", varbit_in }, + { 1580, 1, true, false, "varbit_out", varbit_out }, + { 1581, 2, true, false, "biteq", biteq }, + { 1582, 2, true, false, "bitne", bitne }, + { 1592, 2, true, false, "bitge", bitge }, + { 1593, 2, true, false, "bitgt", bitgt }, + { 1594, 2, true, false, "bitle", bitle }, + { 1595, 2, true, false, "bitlt", bitlt }, + { 1596, 2, true, false, "bitcmp", bitcmp }, + { 1597, 1, true, false, "PG_encoding_to_char", PG_encoding_to_char }, + { 1598, 0, true, false, "drandom", drandom }, + { 1599, 1, true, false, "setseed", setseed }, + { 1600, 1, true, false, "dasin", dasin }, + { 1601, 1, true, false, "dacos", dacos }, + { 1602, 1, true, false, "datan", datan }, + { 1603, 2, true, false, "datan2", datan2 }, + { 1604, 1, true, false, "dsin", dsin }, + { 1605, 1, true, false, "dcos", dcos }, + { 1606, 1, true, false, "dtan", dtan }, + { 1607, 1, true, false, "dcot", dcot }, + { 1608, 1, true, false, "degrees", degrees }, + { 1609, 1, true, false, "radians", radians }, + { 1610, 0, true, false, "dpi", dpi }, + { 1618, 2, true, false, "interval_mul", interval_mul }, + { 1619, 1, false, false, "pg_typeof", pg_typeof }, + { 1620, 1, true, false, "ascii", ascii }, + { 1621, 1, true, false, "chr", chr }, + { 1622, 2, true, false, "repeat", repeat }, + { 1623, 2, false, false, "similar_escape", similar_escape }, + { 1624, 2, true, false, "mul_d_interval", mul_d_interval }, + { 1631, 2, true, false, "textlike", textlike }, + { 1632, 2, true, false, "textnlike", textnlike }, + { 1633, 2, true, false, "texticlike", texticlike }, + { 1634, 2, true, false, "texticnlike", texticnlike }, + { 1635, 2, true, false, "nameiclike", nameiclike }, + { 1636, 2, true, false, "nameicnlike", nameicnlike }, + { 1637, 2, true, false, "like_escape", like_escape }, + { 1638, 2, true, false, "oidgt", oidgt }, + { 1639, 2, true, false, "oidge", oidge }, + { 1640, 1, true, false, "pg_get_viewdef_name", pg_get_viewdef_name }, + { 1641, 1, true, false, "pg_get_viewdef", pg_get_viewdef }, + { 1642, 1, true, false, "pg_get_userbyid", pg_get_userbyid }, + { 1643, 1, true, false, "pg_get_indexdef", pg_get_indexdef }, + { 1644, 0, true, false, "RI_FKey_check_ins", RI_FKey_check_ins }, + { 1645, 0, true, false, "RI_FKey_check_upd", RI_FKey_check_upd }, + { 1646, 0, true, false, "RI_FKey_cascade_del", RI_FKey_cascade_del }, + { 1647, 0, true, false, "RI_FKey_cascade_upd", RI_FKey_cascade_upd }, + { 1648, 0, true, false, "RI_FKey_restrict_del", RI_FKey_restrict_del }, + { 1649, 0, true, false, "RI_FKey_restrict_upd", RI_FKey_restrict_upd }, + { 1650, 0, true, false, "RI_FKey_setnull_del", RI_FKey_setnull_del }, + { 1651, 0, true, false, "RI_FKey_setnull_upd", RI_FKey_setnull_upd }, + { 1652, 0, true, false, "RI_FKey_setdefault_del", RI_FKey_setdefault_del }, + { 1653, 0, true, false, "RI_FKey_setdefault_upd", RI_FKey_setdefault_upd }, + { 1654, 0, true, false, "RI_FKey_noaction_del", RI_FKey_noaction_del }, + { 1655, 0, true, false, "RI_FKey_noaction_upd", RI_FKey_noaction_upd }, + { 1656, 2, true, false, "texticregexeq", texticregexeq }, + { 1657, 2, true, false, "texticregexne", texticregexne }, + { 1658, 2, true, false, "textregexeq", textregexeq }, + { 1659, 2, true, false, "textregexne", textregexne }, + { 1660, 2, true, false, "texticlike", texticlike }, + { 1661, 2, true, false, "texticnlike", texticnlike }, + { 1662, 1, true, false, "pg_get_triggerdef", pg_get_triggerdef }, + { 1665, 2, true, false, "pg_get_serial_sequence", pg_get_serial_sequence }, + { 1666, 2, true, false, "biteq", biteq }, + { 1667, 2, true, false, "bitne", bitne }, + { 1668, 2, true, false, "bitge", bitge }, + { 1669, 2, true, false, "bitgt", bitgt }, + { 1670, 2, true, false, "bitle", bitle }, + { 1671, 2, true, false, "bitlt", bitlt }, + { 1672, 2, true, false, "bitcmp", bitcmp }, + { 1673, 2, true, false, "bit_and", bit_and }, + { 1674, 2, true, false, "bit_or", bit_or }, + { 1675, 2, true, false, "bitxor", bitxor }, + { 1676, 1, true, false, "bitnot", bitnot }, + { 1677, 2, true, false, "bitshiftleft", bitshiftleft }, + { 1678, 2, true, false, "bitshiftright", bitshiftright }, + { 1679, 2, true, false, "bitcat", bitcat }, + { 1680, 3, true, false, "bitsubstr", bitsubstr }, + { 1681, 1, true, false, "bitlength", bitlength }, + { 1682, 1, true, false, "bitoctetlength", bitoctetlength }, + { 1683, 2, true, false, "bitfromint4", bitfromint4 }, + { 1684, 1, true, false, "bittoint4", bittoint4 }, + { 1685, 3, true, false, "bit", bit }, + { 1686, 0, true, true, "pg_get_keywords", pg_get_keywords }, + { 1687, 3, true, false, "varbit", varbit }, + { 1688, 1, true, false, "time_hash", time_hash }, + { 1689, 1, true, true, "aclexplode", aclexplode }, + { 1690, 2, true, false, "time_mi_time", time_mi_time }, + { 1691, 2, true, false, "boolle", boolle }, + { 1692, 2, true, false, "boolge", boolge }, + { 1693, 2, true, false, "btboolcmp", btboolcmp }, + { 1696, 1, true, false, "timetz_hash", timetz_hash }, + { 1697, 1, true, false, "interval_hash", interval_hash }, + { 1698, 2, true, false, "bitposition", bitposition }, + { 1699, 2, true, false, "bitsubstr_no_len", bitsubstr_no_len }, + { 1701, 3, true, false, "numeric_in", numeric_in }, + { 1702, 1, true, false, "numeric_out", numeric_out }, + { 1703, 2, true, false, "numeric", numeric }, + { 1704, 1, true, false, "numeric_abs", numeric_abs }, + { 1705, 1, true, false, "numeric_abs", numeric_abs }, + { 1706, 1, true, false, "numeric_sign", numeric_sign }, + { 1707, 2, true, false, "numeric_round", numeric_round }, + { 1709, 2, true, false, "numeric_trunc", numeric_trunc }, + { 1711, 1, true, false, "numeric_ceil", numeric_ceil }, + { 1712, 1, true, false, "numeric_floor", numeric_floor }, + { 1713, 2, true, false, "length_in_encoding", length_in_encoding }, + { 1714, 2, true, false, "pg_convert_from", pg_convert_from }, + { 1715, 1, true, false, "inet_to_cidr", inet_to_cidr }, + { 1716, 2, true, false, "pg_get_expr", pg_get_expr }, + { 1717, 2, true, false, "pg_convert_to", pg_convert_to }, + { 1718, 2, true, false, "numeric_eq", numeric_eq }, + { 1719, 2, true, false, "numeric_ne", numeric_ne }, + { 1720, 2, true, false, "numeric_gt", numeric_gt }, + { 1721, 2, true, false, "numeric_ge", numeric_ge }, + { 1722, 2, true, false, "numeric_lt", numeric_lt }, + { 1723, 2, true, false, "numeric_le", numeric_le }, + { 1724, 2, true, false, "numeric_add", numeric_add }, + { 1725, 2, true, false, "numeric_sub", numeric_sub }, + { 1726, 2, true, false, "numeric_mul", numeric_mul }, + { 1727, 2, true, false, "numeric_div", numeric_div }, + { 1728, 2, true, false, "numeric_mod", numeric_mod }, + { 1729, 2, true, false, "numeric_mod", numeric_mod }, + { 1730, 1, true, false, "numeric_sqrt", numeric_sqrt }, + { 1731, 1, true, false, "numeric_sqrt", numeric_sqrt }, + { 1732, 1, true, false, "numeric_exp", numeric_exp }, + { 1733, 1, true, false, "numeric_exp", numeric_exp }, + { 1734, 1, true, false, "numeric_ln", numeric_ln }, + { 1735, 1, true, false, "numeric_ln", numeric_ln }, + { 1736, 2, true, false, "numeric_log", numeric_log }, + { 1737, 2, true, false, "numeric_log", numeric_log }, + { 1738, 2, true, false, "numeric_power", numeric_power }, + { 1739, 2, true, false, "numeric_power", numeric_power }, + { 1740, 1, true, false, "int4_numeric", int4_numeric }, + { 1742, 1, true, false, "float4_numeric", float4_numeric }, + { 1743, 1, true, false, "float8_numeric", float8_numeric }, + { 1744, 1, true, false, "numeric_int4", numeric_int4 }, + { 1745, 1, true, false, "numeric_float4", numeric_float4 }, + { 1746, 1, true, false, "numeric_float8", numeric_float8 }, + { 1747, 2, true, false, "time_pl_interval", time_pl_interval }, + { 1748, 2, true, false, "time_mi_interval", time_mi_interval }, + { 1749, 2, true, false, "timetz_pl_interval", timetz_pl_interval }, + { 1750, 2, true, false, "timetz_mi_interval", timetz_mi_interval }, + { 1764, 1, true, false, "numeric_inc", numeric_inc }, + { 1765, 3, true, false, "setval3_oid", setval3_oid }, + { 1766, 2, true, false, "numeric_smaller", numeric_smaller }, + { 1767, 2, true, false, "numeric_larger", numeric_larger }, + { 1768, 2, true, false, "interval_to_char", interval_to_char }, + { 1769, 2, true, false, "numeric_cmp", numeric_cmp }, + { 1770, 2, true, false, "timestamptz_to_char", timestamptz_to_char }, + { 1771, 1, true, false, "numeric_uminus", numeric_uminus }, + { 1772, 2, true, false, "numeric_to_char", numeric_to_char }, + { 1773, 2, true, false, "int4_to_char", int4_to_char }, + { 1774, 2, true, false, "int8_to_char", int8_to_char }, + { 1775, 2, true, false, "float4_to_char", float4_to_char }, + { 1776, 2, true, false, "float8_to_char", float8_to_char }, + { 1777, 2, true, false, "numeric_to_number", numeric_to_number }, + { 1778, 2, true, false, "to_timestamp", to_timestamp }, + { 1779, 1, true, false, "numeric_int8", numeric_int8 }, + { 1780, 2, true, false, "to_date", to_date }, + { 1781, 1, true, false, "int8_numeric", int8_numeric }, + { 1782, 1, true, false, "int2_numeric", int2_numeric }, + { 1783, 1, true, false, "numeric_int2", numeric_int2 }, + { 1798, 1, true, false, "oidin", oidin }, + { 1799, 1, true, false, "oidout", oidout }, + { 1813, 3, true, false, "pg_convert", pg_convert }, + { 1814, 4, true, false, "iclikesel", iclikesel }, + { 1815, 4, true, false, "icnlikesel", icnlikesel }, + { 1816, 5, true, false, "iclikejoinsel", iclikejoinsel }, + { 1817, 5, true, false, "icnlikejoinsel", icnlikejoinsel }, + { 1818, 4, true, false, "regexeqsel", regexeqsel }, + { 1819, 4, true, false, "likesel", likesel }, + { 1820, 4, true, false, "icregexeqsel", icregexeqsel }, + { 1821, 4, true, false, "regexnesel", regexnesel }, + { 1822, 4, true, false, "nlikesel", nlikesel }, + { 1823, 4, true, false, "icregexnesel", icregexnesel }, + { 1824, 5, true, false, "regexeqjoinsel", regexeqjoinsel }, + { 1825, 5, true, false, "likejoinsel", likejoinsel }, + { 1826, 5, true, false, "icregexeqjoinsel", icregexeqjoinsel }, + { 1827, 5, true, false, "regexnejoinsel", regexnejoinsel }, + { 1828, 5, true, false, "nlikejoinsel", nlikejoinsel }, + { 1829, 5, true, false, "icregexnejoinsel", icregexnejoinsel }, + { 1830, 1, true, false, "float8_avg", float8_avg }, + { 1831, 1, true, false, "float8_var_samp", float8_var_samp }, + { 1832, 1, true, false, "float8_stddev_samp", float8_stddev_samp }, + { 1833, 2, false, false, "numeric_accum", numeric_accum }, + { 1834, 2, false, false, "int2_accum", int2_accum }, + { 1835, 2, false, false, "int4_accum", int4_accum }, + { 1836, 2, false, false, "int8_accum", int8_accum }, + { 1837, 1, false, false, "numeric_avg", numeric_avg }, + { 1838, 1, false, false, "numeric_var_samp", numeric_var_samp }, + { 1839, 1, false, false, "numeric_stddev_samp", numeric_stddev_samp }, + { 1840, 2, false, false, "int2_sum", int2_sum }, + { 1841, 2, false, false, "int4_sum", int4_sum }, + { 1842, 2, false, false, "int8_sum", int8_sum }, + { 1843, 2, true, false, "interval_accum", interval_accum }, + { 1844, 1, true, false, "interval_avg", interval_avg }, + { 1845, 1, true, false, "to_ascii_default", to_ascii_default }, + { 1846, 2, true, false, "to_ascii_enc", to_ascii_enc }, + { 1847, 2, true, false, "to_ascii_encname", to_ascii_encname }, + { 1850, 2, true, false, "int28eq", int28eq }, + { 1851, 2, true, false, "int28ne", int28ne }, + { 1852, 2, true, false, "int28lt", int28lt }, + { 1853, 2, true, false, "int28gt", int28gt }, + { 1854, 2, true, false, "int28le", int28le }, + { 1855, 2, true, false, "int28ge", int28ge }, + { 1856, 2, true, false, "int82eq", int82eq }, + { 1857, 2, true, false, "int82ne", int82ne }, + { 1858, 2, true, false, "int82lt", int82lt }, + { 1859, 2, true, false, "int82gt", int82gt }, + { 1860, 2, true, false, "int82le", int82le }, + { 1861, 2, true, false, "int82ge", int82ge }, + { 1892, 2, true, false, "int2and", int2and }, + { 1893, 2, true, false, "int2or", int2or }, + { 1894, 2, true, false, "int2xor", int2xor }, + { 1895, 1, true, false, "int2not", int2not }, + { 1896, 2, true, false, "int2shl", int2shl }, + { 1897, 2, true, false, "int2shr", int2shr }, + { 1898, 2, true, false, "int4and", int4and }, + { 1899, 2, true, false, "int4or", int4or }, + { 1900, 2, true, false, "int4xor", int4xor }, + { 1901, 1, true, false, "int4not", int4not }, + { 1902, 2, true, false, "int4shl", int4shl }, + { 1903, 2, true, false, "int4shr", int4shr }, + { 1904, 2, true, false, "int8and", int8and }, + { 1905, 2, true, false, "int8or", int8or }, + { 1906, 2, true, false, "int8xor", int8xor }, + { 1907, 1, true, false, "int8not", int8not }, + { 1908, 2, true, false, "int8shl", int8shl }, + { 1909, 2, true, false, "int8shr", int8shr }, + { 1910, 1, true, false, "int8up", int8up }, + { 1911, 1, true, false, "int2up", int2up }, + { 1912, 1, true, false, "int4up", int4up }, + { 1913, 1, true, false, "float4up", float4up }, + { 1914, 1, true, false, "float8up", float8up }, + { 1915, 1, true, false, "numeric_uplus", numeric_uplus }, + { 1922, 3, true, false, "has_table_privilege_name_name", has_table_privilege_name_name }, + { 1923, 3, true, false, "has_table_privilege_name_id", has_table_privilege_name_id }, + { 1924, 3, true, false, "has_table_privilege_id_name", has_table_privilege_id_name }, + { 1925, 3, true, false, "has_table_privilege_id_id", has_table_privilege_id_id }, + { 1926, 2, true, false, "has_table_privilege_name", has_table_privilege_name }, + { 1927, 2, true, false, "has_table_privilege_id", has_table_privilege_id }, + { 1928, 1, true, false, "pg_stat_get_numscans", pg_stat_get_numscans }, + { 1929, 1, true, false, "pg_stat_get_tuples_returned", pg_stat_get_tuples_returned }, + { 1930, 1, true, false, "pg_stat_get_tuples_fetched", pg_stat_get_tuples_fetched }, + { 1931, 1, true, false, "pg_stat_get_tuples_inserted", pg_stat_get_tuples_inserted }, + { 1932, 1, true, false, "pg_stat_get_tuples_updated", pg_stat_get_tuples_updated }, + { 1933, 1, true, false, "pg_stat_get_tuples_deleted", pg_stat_get_tuples_deleted }, + { 1934, 1, true, false, "pg_stat_get_blocks_fetched", pg_stat_get_blocks_fetched }, + { 1935, 1, true, false, "pg_stat_get_blocks_hit", pg_stat_get_blocks_hit }, + { 1936, 0, true, true, "pg_stat_get_backend_idset", pg_stat_get_backend_idset }, + { 1937, 1, true, false, "pg_stat_get_backend_pid", pg_stat_get_backend_pid }, + { 1938, 1, true, false, "pg_stat_get_backend_dbid", pg_stat_get_backend_dbid }, + { 1939, 1, true, false, "pg_stat_get_backend_userid", pg_stat_get_backend_userid }, + { 1940, 1, true, false, "pg_stat_get_backend_activity", pg_stat_get_backend_activity }, + { 1941, 1, true, false, "pg_stat_get_db_numbackends", pg_stat_get_db_numbackends }, + { 1942, 1, true, false, "pg_stat_get_db_xact_commit", pg_stat_get_db_xact_commit }, + { 1943, 1, true, false, "pg_stat_get_db_xact_rollback", pg_stat_get_db_xact_rollback }, + { 1944, 1, true, false, "pg_stat_get_db_blocks_fetched", pg_stat_get_db_blocks_fetched }, + { 1945, 1, true, false, "pg_stat_get_db_blocks_hit", pg_stat_get_db_blocks_hit }, + { 1946, 2, true, false, "binary_encode", binary_encode }, + { 1947, 2, true, false, "binary_decode", binary_decode }, + { 1948, 2, true, false, "byteaeq", byteaeq }, + { 1949, 2, true, false, "bytealt", bytealt }, + { 1950, 2, true, false, "byteale", byteale }, + { 1951, 2, true, false, "byteagt", byteagt }, + { 1952, 2, true, false, "byteage", byteage }, + { 1953, 2, true, false, "byteane", byteane }, + { 1954, 2, true, false, "byteacmp", byteacmp }, + { 1961, 2, true, false, "timestamp_scale", timestamp_scale }, + { 1962, 2, true, false, "int2_avg_accum", int2_avg_accum }, + { 1963, 2, true, false, "int4_avg_accum", int4_avg_accum }, + { 1964, 1, true, false, "int8_avg", int8_avg }, + { 1965, 2, true, false, "oidlarger", oidlarger }, + { 1966, 2, true, false, "oidsmaller", oidsmaller }, + { 1967, 2, true, false, "timestamptz_scale", timestamptz_scale }, + { 1968, 2, true, false, "time_scale", time_scale }, + { 1969, 2, true, false, "timetz_scale", timetz_scale }, + { 1972, 1, true, false, "pg_stat_get_tuples_hot_updated", pg_stat_get_tuples_hot_updated }, + { 1973, 2, true, false, "numeric_div_trunc", numeric_div_trunc }, + { 1980, 2, true, false, "numeric_div_trunc", numeric_div_trunc }, + { 1986, 2, true, false, "similar_to_escape_2", similar_to_escape_2 }, + { 1987, 1, true, false, "similar_to_escape_1", similar_to_escape_1 }, + { 2005, 2, true, false, "bytealike", bytealike }, + { 2006, 2, true, false, "byteanlike", byteanlike }, + { 2007, 2, true, false, "bytealike", bytealike }, + { 2008, 2, true, false, "byteanlike", byteanlike }, + { 2009, 2, true, false, "like_escape_bytea", like_escape_bytea }, + { 2010, 1, true, false, "byteaoctetlen", byteaoctetlen }, + { 2011, 2, true, false, "byteacat", byteacat }, + { 2012, 3, true, false, "bytea_substr", bytea_substr }, + { 2013, 2, true, false, "bytea_substr_no_len", bytea_substr_no_len }, + { 2014, 2, true, false, "byteapos", byteapos }, + { 2015, 2, true, false, "byteatrim", byteatrim }, + { 2019, 1, true, false, "timestamptz_time", timestamptz_time }, + { 2020, 2, true, false, "timestamp_trunc", timestamp_trunc }, + { 2021, 2, true, false, "timestamp_part", timestamp_part }, + { 2022, 1, false, true, "pg_stat_get_activity", pg_stat_get_activity }, + { 2023, 4, true, false, "jsonb_path_query_first_tz", jsonb_path_query_first_tz }, + { 2024, 1, true, false, "date_timestamp", date_timestamp }, + { 2025, 2, true, false, "datetime_timestamp", datetime_timestamp }, + { 2026, 0, true, false, "pg_backend_pid", pg_backend_pid }, + { 2027, 1, true, false, "timestamptz_timestamp", timestamptz_timestamp }, + { 2028, 1, true, false, "timestamp_timestamptz", timestamp_timestamptz }, + { 2029, 1, true, false, "timestamp_date", timestamp_date }, + { 2030, 4, true, false, "jsonb_path_match_tz", jsonb_path_match_tz }, + { 2031, 2, true, false, "timestamp_mi", timestamp_mi }, + { 2032, 2, true, false, "timestamp_pl_interval", timestamp_pl_interval }, + { 2033, 2, true, false, "timestamp_mi_interval", timestamp_mi_interval }, + { 2034, 0, true, false, "pg_conf_load_time", pg_conf_load_time }, + { 2035, 2, true, false, "timestamp_smaller", timestamp_smaller }, + { 2036, 2, true, false, "timestamp_larger", timestamp_larger }, + { 2037, 2, true, false, "timetz_zone", timetz_zone }, + { 2038, 2, true, false, "timetz_izone", timetz_izone }, + { 2039, 1, true, false, "timestamp_hash", timestamp_hash }, + { 2041, 4, false, false, "overlaps_timestamp", overlaps_timestamp }, + { 2045, 2, true, false, "timestamp_cmp", timestamp_cmp }, + { 2046, 1, true, false, "timetz_time", timetz_time }, + { 2047, 1, true, false, "time_timetz", time_timetz }, + { 2048, 1, true, false, "timestamp_finite", timestamp_finite }, + { 2049, 2, true, false, "timestamp_to_char", timestamp_to_char }, + { 2052, 2, true, false, "timestamp_eq", timestamp_eq }, + { 2053, 2, true, false, "timestamp_ne", timestamp_ne }, + { 2054, 2, true, false, "timestamp_lt", timestamp_lt }, + { 2055, 2, true, false, "timestamp_le", timestamp_le }, + { 2056, 2, true, false, "timestamp_ge", timestamp_ge }, + { 2057, 2, true, false, "timestamp_gt", timestamp_gt }, + { 2058, 2, true, false, "timestamp_age", timestamp_age }, + { 2069, 2, true, false, "timestamp_zone", timestamp_zone }, + { 2070, 2, true, false, "timestamp_izone", timestamp_izone }, + { 2071, 2, true, false, "date_pl_interval", date_pl_interval }, + { 2072, 2, true, false, "date_mi_interval", date_mi_interval }, + { 2073, 2, true, false, "textregexsubstr", textregexsubstr }, + { 2075, 2, true, false, "bitfromint8", bitfromint8 }, + { 2076, 1, true, false, "bittoint8", bittoint8 }, + { 2077, 1, true, false, "show_config_by_name", show_config_by_name }, + { 2078, 3, false, false, "set_config_by_name", set_config_by_name }, + { 2079, 1, true, false, "pg_table_is_visible", pg_table_is_visible }, + { 2080, 1, true, false, "pg_type_is_visible", pg_type_is_visible }, + { 2081, 1, true, false, "pg_function_is_visible", pg_function_is_visible }, + { 2082, 1, true, false, "pg_operator_is_visible", pg_operator_is_visible }, + { 2083, 1, true, false, "pg_opclass_is_visible", pg_opclass_is_visible }, + { 2084, 0, true, true, "show_all_settings", show_all_settings }, + { 2085, 3, true, false, "bytea_substr", bytea_substr }, + { 2086, 2, true, false, "bytea_substr_no_len", bytea_substr_no_len }, + { 2087, 3, true, false, "replace_text", replace_text }, + { 2088, 3, true, false, "split_part", split_part }, + { 2089, 1, true, false, "to_hex32", to_hex32 }, + { 2090, 1, true, false, "to_hex64", to_hex64 }, + { 2091, 2, true, false, "array_lower", array_lower }, + { 2092, 2, true, false, "array_upper", array_upper }, + { 2093, 1, true, false, "pg_conversion_is_visible", pg_conversion_is_visible }, + { 2094, 1, true, false, "pg_stat_get_backend_activity_start", pg_stat_get_backend_activity_start }, + { 2096, 2, true, false, "pg_terminate_backend", pg_terminate_backend }, + { 2098, 1, true, false, "pg_get_functiondef", pg_get_functiondef }, + { 2121, 1, true, false, "pg_column_compression", pg_column_compression }, + { 2137, 0, false, false, "pg_stat_force_next_flush", pg_stat_force_next_flush }, + { 2160, 2, true, false, "text_pattern_lt", text_pattern_lt }, + { 2161, 2, true, false, "text_pattern_le", text_pattern_le }, + { 2162, 1, true, false, "pg_get_function_arguments", pg_get_function_arguments }, + { 2163, 2, true, false, "text_pattern_ge", text_pattern_ge }, + { 2164, 2, true, false, "text_pattern_gt", text_pattern_gt }, + { 2165, 1, true, false, "pg_get_function_result", pg_get_function_result }, + { 2166, 2, true, false, "bttext_pattern_cmp", bttext_pattern_cmp }, + { 2167, 1, true, false, "numeric_ceil", numeric_ceil }, + { 2168, 1, true, false, "pg_database_size_name", pg_database_size_name }, + { 2169, 2, true, false, "numeric_power", numeric_power }, + { 2170, 4, true, false, "width_bucket_numeric", width_bucket_numeric }, + { 2171, 1, true, false, "pg_cancel_backend", pg_cancel_backend }, + { 2172, 2, true, false, "pg_backup_start", pg_backup_start }, + { 2174, 2, true, false, "bpchar_pattern_lt", bpchar_pattern_lt }, + { 2175, 2, true, false, "bpchar_pattern_le", bpchar_pattern_le }, + { 2176, 2, true, false, "array_length", array_length }, + { 2177, 2, true, false, "bpchar_pattern_ge", bpchar_pattern_ge }, + { 2178, 2, true, false, "bpchar_pattern_gt", bpchar_pattern_gt }, + { 2179, 5, true, false, "gist_point_consistent", gist_point_consistent }, + { 2180, 2, true, false, "btbpchar_pattern_cmp", btbpchar_pattern_cmp }, + { 2181, 3, true, false, "has_sequence_privilege_name_name", has_sequence_privilege_name_name }, + { 2182, 3, true, false, "has_sequence_privilege_name_id", has_sequence_privilege_name_id }, + { 2183, 3, true, false, "has_sequence_privilege_id_name", has_sequence_privilege_id_name }, + { 2184, 3, true, false, "has_sequence_privilege_id_id", has_sequence_privilege_id_id }, + { 2185, 2, true, false, "has_sequence_privilege_name", has_sequence_privilege_name }, + { 2186, 2, true, false, "has_sequence_privilege_id", has_sequence_privilege_id }, + { 2188, 2, true, false, "btint48cmp", btint48cmp }, + { 2189, 2, true, false, "btint84cmp", btint84cmp }, + { 2190, 2, true, false, "btint24cmp", btint24cmp }, + { 2191, 2, true, false, "btint42cmp", btint42cmp }, + { 2192, 2, true, false, "btint28cmp", btint28cmp }, + { 2193, 2, true, false, "btint82cmp", btint82cmp }, + { 2194, 2, true, false, "btfloat48cmp", btfloat48cmp }, + { 2195, 2, true, false, "btfloat84cmp", btfloat84cmp }, + { 2196, 0, false, false, "inet_client_addr", inet_client_addr }, + { 2197, 0, false, false, "inet_client_port", inet_client_port }, + { 2198, 0, false, false, "inet_server_addr", inet_server_addr }, + { 2199, 0, false, false, "inet_server_port", inet_server_port }, + { 2212, 1, true, false, "regprocedurein", regprocedurein }, + { 2213, 1, true, false, "regprocedureout", regprocedureout }, + { 2214, 1, true, false, "regoperin", regoperin }, + { 2215, 1, true, false, "regoperout", regoperout }, + { 2216, 1, true, false, "regoperatorin", regoperatorin }, + { 2217, 1, true, false, "regoperatorout", regoperatorout }, + { 2218, 1, true, false, "regclassin", regclassin }, + { 2219, 1, true, false, "regclassout", regclassout }, + { 2220, 1, true, false, "regtypein", regtypein }, + { 2221, 1, true, false, "regtypeout", regtypeout }, + { 2230, 0, false, false, "pg_stat_clear_snapshot", pg_stat_clear_snapshot }, + { 2232, 1, true, false, "pg_get_function_identity_arguments", pg_get_function_identity_arguments }, + { 2233, 1, true, false, "hashtid", hashtid }, + { 2234, 2, true, false, "hashtidextended", hashtidextended }, + { 2246, 1, true, false, "fmgr_internal_validator", fmgr_internal_validator }, + { 2247, 1, true, false, "fmgr_c_validator", fmgr_c_validator }, + { 2248, 1, true, false, "fmgr_sql_validator", fmgr_sql_validator }, + { 2250, 3, true, false, "has_database_privilege_name_name", has_database_privilege_name_name }, + { 2251, 3, true, false, "has_database_privilege_name_id", has_database_privilege_name_id }, + { 2252, 3, true, false, "has_database_privilege_id_name", has_database_privilege_id_name }, + { 2253, 3, true, false, "has_database_privilege_id_id", has_database_privilege_id_id }, + { 2254, 2, true, false, "has_database_privilege_name", has_database_privilege_name }, + { 2255, 2, true, false, "has_database_privilege_id", has_database_privilege_id }, + { 2256, 3, true, false, "has_function_privilege_name_name", has_function_privilege_name_name }, + { 2257, 3, true, false, "has_function_privilege_name_id", has_function_privilege_name_id }, + { 2258, 3, true, false, "has_function_privilege_id_name", has_function_privilege_id_name }, + { 2259, 3, true, false, "has_function_privilege_id_id", has_function_privilege_id_id }, + { 2260, 2, true, false, "has_function_privilege_name", has_function_privilege_name }, + { 2261, 2, true, false, "has_function_privilege_id", has_function_privilege_id }, + { 2262, 3, true, false, "has_language_privilege_name_name", has_language_privilege_name_name }, + { 2263, 3, true, false, "has_language_privilege_name_id", has_language_privilege_name_id }, + { 2264, 3, true, false, "has_language_privilege_id_name", has_language_privilege_id_name }, + { 2265, 3, true, false, "has_language_privilege_id_id", has_language_privilege_id_id }, + { 2266, 2, true, false, "has_language_privilege_name", has_language_privilege_name }, + { 2267, 2, true, false, "has_language_privilege_id", has_language_privilege_id }, + { 2268, 3, true, false, "has_schema_privilege_name_name", has_schema_privilege_name_name }, + { 2269, 3, true, false, "has_schema_privilege_name_id", has_schema_privilege_name_id }, + { 2270, 3, true, false, "has_schema_privilege_id_name", has_schema_privilege_id_name }, + { 2271, 3, true, false, "has_schema_privilege_id_id", has_schema_privilege_id_id }, + { 2272, 2, true, false, "has_schema_privilege_name", has_schema_privilege_name }, + { 2273, 2, true, false, "has_schema_privilege_id", has_schema_privilege_id }, + { 2274, 0, false, false, "pg_stat_reset", pg_stat_reset }, + { 2282, 0, true, true, "pg_get_backend_memory_contexts", pg_get_backend_memory_contexts }, + { 2284, 3, true, false, "textregexreplace_noopt", textregexreplace_noopt }, + { 2285, 4, true, false, "textregexreplace", textregexreplace }, + { 2286, 1, true, false, "pg_total_relation_size", pg_total_relation_size }, + { 2288, 1, true, false, "pg_size_pretty", pg_size_pretty }, + { 2289, 1, true, true, "pg_options_to_table", pg_options_to_table }, + { 2290, 3, true, false, "record_in", record_in }, + { 2291, 1, true, false, "record_out", record_out }, + { 2292, 1, true, false, "cstring_in", cstring_in }, + { 2293, 1, true, false, "cstring_out", cstring_out }, + { 2294, 1, true, false, "any_in", any_in }, + { 2295, 1, true, false, "any_out", any_out }, + { 2296, 1, true, false, "anyarray_in", anyarray_in }, + { 2297, 1, true, false, "anyarray_out", anyarray_out }, + { 2298, 1, true, false, "void_in", void_in }, + { 2299, 1, true, false, "void_out", void_out }, + { 2300, 1, false, false, "trigger_in", trigger_in }, + { 2301, 1, true, false, "trigger_out", trigger_out }, + { 2302, 1, false, false, "language_handler_in", language_handler_in }, + { 2303, 1, true, false, "language_handler_out", language_handler_out }, + { 2304, 1, false, false, "internal_in", internal_in }, + { 2305, 1, true, false, "internal_out", internal_out }, + { 2306, 0, false, true, "pg_stat_get_slru", pg_stat_get_slru }, + { 2307, 1, false, false, "pg_stat_reset_slru", pg_stat_reset_slru }, + { 2308, 1, true, false, "dceil", dceil }, + { 2309, 1, true, false, "dfloor", dfloor }, + { 2310, 1, true, false, "dsign", dsign }, + { 2311, 1, true, false, "md5_text", md5_text }, + { 2312, 1, true, false, "anyelement_in", anyelement_in }, + { 2313, 1, true, false, "anyelement_out", anyelement_out }, + { 2316, 2, true, false, "postgresql_fdw_validator", postgresql_fdw_validator }, + { 2319, 1, true, false, "pg_encoding_max_length_sql", pg_encoding_max_length_sql }, + { 2320, 1, true, false, "dceil", dceil }, + { 2321, 1, true, false, "md5_bytea", md5_bytea }, + { 2322, 1, true, false, "pg_tablespace_size_oid", pg_tablespace_size_oid }, + { 2323, 1, true, false, "pg_tablespace_size_name", pg_tablespace_size_name }, + { 2324, 1, true, false, "pg_database_size_oid", pg_database_size_oid }, + { 2331, 1, true, true, "array_unnest", array_unnest }, + { 2332, 2, true, false, "pg_relation_size", pg_relation_size }, + { 2333, 2, false, false, "array_agg_transfn", array_agg_transfn }, + { 2334, 2, false, false, "array_agg_finalfn", array_agg_finalfn }, + { 2338, 2, true, false, "date_lt_timestamp", date_lt_timestamp }, + { 2339, 2, true, false, "date_le_timestamp", date_le_timestamp }, + { 2340, 2, true, false, "date_eq_timestamp", date_eq_timestamp }, + { 2341, 2, true, false, "date_gt_timestamp", date_gt_timestamp }, + { 2342, 2, true, false, "date_ge_timestamp", date_ge_timestamp }, + { 2343, 2, true, false, "date_ne_timestamp", date_ne_timestamp }, + { 2344, 2, true, false, "date_cmp_timestamp", date_cmp_timestamp }, + { 2351, 2, true, false, "date_lt_timestamptz", date_lt_timestamptz }, + { 2352, 2, true, false, "date_le_timestamptz", date_le_timestamptz }, + { 2353, 2, true, false, "date_eq_timestamptz", date_eq_timestamptz }, + { 2354, 2, true, false, "date_gt_timestamptz", date_gt_timestamptz }, + { 2355, 2, true, false, "date_ge_timestamptz", date_ge_timestamptz }, + { 2356, 2, true, false, "date_ne_timestamptz", date_ne_timestamptz }, + { 2357, 2, true, false, "date_cmp_timestamptz", date_cmp_timestamptz }, + { 2364, 2, true, false, "timestamp_lt_date", timestamp_lt_date }, + { 2365, 2, true, false, "timestamp_le_date", timestamp_le_date }, + { 2366, 2, true, false, "timestamp_eq_date", timestamp_eq_date }, + { 2367, 2, true, false, "timestamp_gt_date", timestamp_gt_date }, + { 2368, 2, true, false, "timestamp_ge_date", timestamp_ge_date }, + { 2369, 2, true, false, "timestamp_ne_date", timestamp_ne_date }, + { 2370, 2, true, false, "timestamp_cmp_date", timestamp_cmp_date }, + { 2377, 2, true, false, "timestamptz_lt_date", timestamptz_lt_date }, + { 2378, 2, true, false, "timestamptz_le_date", timestamptz_le_date }, + { 2379, 2, true, false, "timestamptz_eq_date", timestamptz_eq_date }, + { 2380, 2, true, false, "timestamptz_gt_date", timestamptz_gt_date }, + { 2381, 2, true, false, "timestamptz_ge_date", timestamptz_ge_date }, + { 2382, 2, true, false, "timestamptz_ne_date", timestamptz_ne_date }, + { 2383, 2, true, false, "timestamptz_cmp_date", timestamptz_cmp_date }, + { 2390, 3, true, false, "has_tablespace_privilege_name_name", has_tablespace_privilege_name_name }, + { 2391, 3, true, false, "has_tablespace_privilege_name_id", has_tablespace_privilege_name_id }, + { 2392, 3, true, false, "has_tablespace_privilege_id_name", has_tablespace_privilege_id_name }, + { 2393, 3, true, false, "has_tablespace_privilege_id_id", has_tablespace_privilege_id_id }, + { 2394, 2, true, false, "has_tablespace_privilege_name", has_tablespace_privilege_name }, + { 2395, 2, true, false, "has_tablespace_privilege_id", has_tablespace_privilege_id }, + { 2398, 1, false, false, "shell_in", shell_in }, + { 2399, 1, true, false, "shell_out", shell_out }, + { 2400, 3, true, false, "array_recv", array_recv }, + { 2401, 1, true, false, "array_send", array_send }, + { 2402, 3, true, false, "record_recv", record_recv }, + { 2403, 1, true, false, "record_send", record_send }, + { 2404, 1, true, false, "int2recv", int2recv }, + { 2405, 1, true, false, "int2send", int2send }, + { 2406, 1, true, false, "int4recv", int4recv }, + { 2407, 1, true, false, "int4send", int4send }, + { 2408, 1, true, false, "int8recv", int8recv }, + { 2409, 1, true, false, "int8send", int8send }, + { 2410, 1, true, false, "int2vectorrecv", int2vectorrecv }, + { 2411, 1, true, false, "int2vectorsend", int2vectorsend }, + { 2412, 1, true, false, "bytearecv", bytearecv }, + { 2413, 1, true, false, "byteasend", byteasend }, + { 2414, 1, true, false, "textrecv", textrecv }, + { 2415, 1, true, false, "textsend", textsend }, + { 2416, 1, true, false, "unknownrecv", unknownrecv }, + { 2417, 1, true, false, "unknownsend", unknownsend }, + { 2418, 1, true, false, "oidrecv", oidrecv }, + { 2419, 1, true, false, "oidsend", oidsend }, + { 2420, 1, true, false, "oidvectorrecv", oidvectorrecv }, + { 2421, 1, true, false, "oidvectorsend", oidvectorsend }, + { 2422, 1, true, false, "namerecv", namerecv }, + { 2423, 1, true, false, "namesend", namesend }, + { 2424, 1, true, false, "float4recv", float4recv }, + { 2425, 1, true, false, "float4send", float4send }, + { 2426, 1, true, false, "float8recv", float8recv }, + { 2427, 1, true, false, "float8send", float8send }, + { 2428, 1, true, false, "point_recv", point_recv }, + { 2429, 1, true, false, "point_send", point_send }, + { 2430, 3, true, false, "bpcharrecv", bpcharrecv }, + { 2431, 1, true, false, "bpcharsend", bpcharsend }, + { 2432, 3, true, false, "varcharrecv", varcharrecv }, + { 2433, 1, true, false, "varcharsend", varcharsend }, + { 2434, 1, true, false, "charrecv", charrecv }, + { 2435, 1, true, false, "charsend", charsend }, + { 2436, 1, true, false, "boolrecv", boolrecv }, + { 2437, 1, true, false, "boolsend", boolsend }, + { 2438, 1, true, false, "tidrecv", tidrecv }, + { 2439, 1, true, false, "tidsend", tidsend }, + { 2440, 1, true, false, "xidrecv", xidrecv }, + { 2441, 1, true, false, "xidsend", xidsend }, + { 2442, 1, true, false, "cidrecv", cidrecv }, + { 2443, 1, true, false, "cidsend", cidsend }, + { 2444, 1, true, false, "regprocrecv", regprocrecv }, + { 2445, 1, true, false, "regprocsend", regprocsend }, + { 2446, 1, true, false, "regprocedurerecv", regprocedurerecv }, + { 2447, 1, true, false, "regproceduresend", regproceduresend }, + { 2448, 1, true, false, "regoperrecv", regoperrecv }, + { 2449, 1, true, false, "regopersend", regopersend }, + { 2450, 1, true, false, "regoperatorrecv", regoperatorrecv }, + { 2451, 1, true, false, "regoperatorsend", regoperatorsend }, + { 2452, 1, true, false, "regclassrecv", regclassrecv }, + { 2453, 1, true, false, "regclasssend", regclasssend }, + { 2454, 1, true, false, "regtyperecv", regtyperecv }, + { 2455, 1, true, false, "regtypesend", regtypesend }, + { 2456, 3, true, false, "bit_recv", bit_recv }, + { 2457, 1, true, false, "bit_send", bit_send }, + { 2458, 3, true, false, "varbit_recv", varbit_recv }, + { 2459, 1, true, false, "varbit_send", varbit_send }, + { 2460, 3, true, false, "numeric_recv", numeric_recv }, + { 2461, 1, true, false, "numeric_send", numeric_send }, + { 2462, 1, true, false, "dsinh", dsinh }, + { 2463, 1, true, false, "dcosh", dcosh }, + { 2464, 1, true, false, "dtanh", dtanh }, + { 2465, 1, true, false, "dasinh", dasinh }, + { 2466, 1, true, false, "dacosh", dacosh }, + { 2467, 1, true, false, "datanh", datanh }, + { 2468, 1, true, false, "date_recv", date_recv }, + { 2469, 1, true, false, "date_send", date_send }, + { 2470, 3, true, false, "time_recv", time_recv }, + { 2471, 1, true, false, "time_send", time_send }, + { 2472, 3, true, false, "timetz_recv", timetz_recv }, + { 2473, 1, true, false, "timetz_send", timetz_send }, + { 2474, 3, true, false, "timestamp_recv", timestamp_recv }, + { 2475, 1, true, false, "timestamp_send", timestamp_send }, + { 2476, 3, true, false, "timestamptz_recv", timestamptz_recv }, + { 2477, 1, true, false, "timestamptz_send", timestamptz_send }, + { 2478, 3, true, false, "interval_recv", interval_recv }, + { 2479, 1, true, false, "interval_send", interval_send }, + { 2480, 1, true, false, "lseg_recv", lseg_recv }, + { 2481, 1, true, false, "lseg_send", lseg_send }, + { 2482, 1, true, false, "path_recv", path_recv }, + { 2483, 1, true, false, "path_send", path_send }, + { 2484, 1, true, false, "box_recv", box_recv }, + { 2485, 1, true, false, "box_send", box_send }, + { 2486, 1, true, false, "poly_recv", poly_recv }, + { 2487, 1, true, false, "poly_send", poly_send }, + { 2488, 1, true, false, "line_recv", line_recv }, + { 2489, 1, true, false, "line_send", line_send }, + { 2490, 1, true, false, "circle_recv", circle_recv }, + { 2491, 1, true, false, "circle_send", circle_send }, + { 2492, 1, true, false, "cash_recv", cash_recv }, + { 2493, 1, true, false, "cash_send", cash_send }, + { 2494, 1, true, false, "macaddr_recv", macaddr_recv }, + { 2495, 1, true, false, "macaddr_send", macaddr_send }, + { 2496, 1, true, false, "inet_recv", inet_recv }, + { 2497, 1, true, false, "inet_send", inet_send }, + { 2498, 1, true, false, "cidr_recv", cidr_recv }, + { 2499, 1, true, false, "cidr_send", cidr_send }, + { 2500, 1, true, false, "cstring_recv", cstring_recv }, + { 2501, 1, true, false, "cstring_send", cstring_send }, + { 2502, 1, true, false, "anyarray_recv", anyarray_recv }, + { 2503, 1, true, false, "anyarray_send", anyarray_send }, + { 2504, 2, true, false, "pg_get_ruledef_ext", pg_get_ruledef_ext }, + { 2505, 2, true, false, "pg_get_viewdef_name_ext", pg_get_viewdef_name_ext }, + { 2506, 2, true, false, "pg_get_viewdef_ext", pg_get_viewdef_ext }, + { 2507, 3, true, false, "pg_get_indexdef_ext", pg_get_indexdef_ext }, + { 2508, 2, true, false, "pg_get_constraintdef_ext", pg_get_constraintdef_ext }, + { 2509, 3, true, false, "pg_get_expr_ext", pg_get_expr_ext }, + { 2510, 0, true, true, "pg_prepared_statement", pg_prepared_statement }, + { 2511, 0, true, true, "pg_cursor", pg_cursor }, + { 2512, 1, true, false, "float8_var_pop", float8_var_pop }, + { 2513, 1, true, false, "float8_stddev_pop", float8_stddev_pop }, + { 2514, 1, false, false, "numeric_var_pop", numeric_var_pop }, + { 2515, 2, true, false, "booland_statefunc", booland_statefunc }, + { 2516, 2, true, false, "boolor_statefunc", boolor_statefunc }, + { 2520, 2, true, false, "timestamp_lt_timestamptz", timestamp_lt_timestamptz }, + { 2521, 2, true, false, "timestamp_le_timestamptz", timestamp_le_timestamptz }, + { 2522, 2, true, false, "timestamp_eq_timestamptz", timestamp_eq_timestamptz }, + { 2523, 2, true, false, "timestamp_gt_timestamptz", timestamp_gt_timestamptz }, + { 2524, 2, true, false, "timestamp_ge_timestamptz", timestamp_ge_timestamptz }, + { 2525, 2, true, false, "timestamp_ne_timestamptz", timestamp_ne_timestamptz }, + { 2526, 2, true, false, "timestamp_cmp_timestamptz", timestamp_cmp_timestamptz }, + { 2527, 2, true, false, "timestamptz_lt_timestamp", timestamptz_lt_timestamp }, + { 2528, 2, true, false, "timestamptz_le_timestamp", timestamptz_le_timestamp }, + { 2529, 2, true, false, "timestamptz_eq_timestamp", timestamptz_eq_timestamp }, + { 2530, 2, true, false, "timestamptz_gt_timestamp", timestamptz_gt_timestamp }, + { 2531, 2, true, false, "timestamptz_ge_timestamp", timestamptz_ge_timestamp }, + { 2532, 2, true, false, "timestamptz_ne_timestamp", timestamptz_ne_timestamp }, + { 2533, 2, true, false, "timestamptz_cmp_timestamp", timestamptz_cmp_timestamp }, + { 2556, 1, true, true, "pg_tablespace_databases", pg_tablespace_databases }, + { 2557, 1, true, false, "int4_bool", int4_bool }, + { 2558, 1, true, false, "bool_int4", bool_int4 }, + { 2559, 0, true, false, "lastval", lastval }, + { 2560, 0, true, false, "pg_postmaster_start_time", pg_postmaster_start_time }, + { 2561, 1, true, false, "pg_blocking_pids", pg_blocking_pids }, + { 2562, 2, true, false, "box_below", box_below }, + { 2563, 2, true, false, "box_overbelow", box_overbelow }, + { 2564, 2, true, false, "box_overabove", box_overabove }, + { 2565, 2, true, false, "box_above", box_above }, + { 2566, 2, true, false, "poly_below", poly_below }, + { 2567, 2, true, false, "poly_overbelow", poly_overbelow }, + { 2568, 2, true, false, "poly_overabove", poly_overabove }, + { 2569, 2, true, false, "poly_above", poly_above }, + { 2578, 5, true, false, "gist_box_consistent", gist_box_consistent }, + { 2580, 1, true, false, "jsonb_float8", jsonb_float8 }, + { 2581, 3, true, false, "gist_box_penalty", gist_box_penalty }, + { 2582, 2, true, false, "gist_box_picksplit", gist_box_picksplit }, + { 2583, 2, true, false, "gist_box_union", gist_box_union }, + { 2584, 3, true, false, "gist_box_same", gist_box_same }, + { 2585, 5, true, false, "gist_poly_consistent", gist_poly_consistent }, + { 2586, 1, true, false, "gist_poly_compress", gist_poly_compress }, + { 2587, 2, true, false, "circle_overbelow", circle_overbelow }, + { 2588, 2, true, false, "circle_overabove", circle_overabove }, + { 2591, 5, true, false, "gist_circle_consistent", gist_circle_consistent }, + { 2592, 1, true, false, "gist_circle_compress", gist_circle_compress }, + { 2596, 1, false, false, "numeric_stddev_pop", numeric_stddev_pop }, + { 2597, 3, false, false, "domain_in", domain_in }, + { 2598, 3, false, false, "domain_recv", domain_recv }, + { 2599, 0, true, true, "pg_timezone_abbrevs", pg_timezone_abbrevs }, + { 2614, 2, true, false, "xmlexists", xmlexists }, + { 2621, 0, true, false, "pg_reload_conf", pg_reload_conf }, + { 2622, 0, true, false, "pg_rotate_logfile_v2", pg_rotate_logfile_v2 }, + { 2623, 1, true, false, "pg_stat_file_1arg", pg_stat_file_1arg }, + { 2624, 3, true, false, "pg_read_file_off_len", pg_read_file_off_len }, + { 2625, 1, true, true, "pg_ls_dir_1arg", pg_ls_dir_1arg }, + { 2626, 1, true, false, "pg_sleep", pg_sleep }, + { 2627, 1, true, false, "inetnot", inetnot }, + { 2628, 2, true, false, "inetand", inetand }, + { 2629, 2, true, false, "inetor", inetor }, + { 2630, 2, true, false, "inetpl", inetpl }, + { 2632, 2, true, false, "inetmi_int8", inetmi_int8 }, + { 2633, 2, true, false, "inetmi", inetmi }, + { 2647, 0, true, false, "now", now }, + { 2648, 0, true, false, "statement_timestamp", statement_timestamp }, + { 2649, 0, true, false, "clock_timestamp", clock_timestamp }, + { 2700, 4, true, false, "gin_cmp_prefix", gin_cmp_prefix }, + { 2705, 3, true, false, "pg_has_role_name_name", pg_has_role_name_name }, + { 2706, 3, true, false, "pg_has_role_name_id", pg_has_role_name_id }, + { 2707, 3, true, false, "pg_has_role_id_name", pg_has_role_id_name }, + { 2708, 3, true, false, "pg_has_role_id_id", pg_has_role_id_id }, + { 2709, 2, true, false, "pg_has_role_name", pg_has_role_name }, + { 2710, 2, true, false, "pg_has_role_id", pg_has_role_id }, + { 2711, 1, true, false, "interval_justify_interval", interval_justify_interval }, + { 2730, 2, true, false, "pg_get_triggerdef_ext", pg_get_triggerdef_ext }, + { 2731, 1, true, false, "dasind", dasind }, + { 2732, 1, true, false, "dacosd", dacosd }, + { 2733, 1, true, false, "datand", datand }, + { 2734, 2, true, false, "datan2d", datan2d }, + { 2735, 1, true, false, "dsind", dsind }, + { 2736, 1, true, false, "dcosd", dcosd }, + { 2737, 1, true, false, "dtand", dtand }, + { 2738, 1, true, false, "dcotd", dcotd }, + { 2739, 1, true, false, "pg_backup_stop", pg_backup_stop }, + { 2740, 1, true, false, "numeric_avg_serialize", numeric_avg_serialize }, + { 2741, 2, true, false, "numeric_avg_deserialize", numeric_avg_deserialize }, + { 2743, 3, true, false, "ginarrayextract", ginarrayextract }, + { 2744, 8, true, false, "ginarrayconsistent", ginarrayconsistent }, + { 2746, 2, false, false, "int8_avg_accum", int8_avg_accum }, + { 2747, 2, true, false, "arrayoverlap", arrayoverlap }, + { 2748, 2, true, false, "arraycontains", arraycontains }, + { 2749, 2, true, false, "arraycontained", arraycontained }, + { 2758, 1, true, false, "pg_stat_get_db_tuples_returned", pg_stat_get_db_tuples_returned }, + { 2759, 1, true, false, "pg_stat_get_db_tuples_fetched", pg_stat_get_db_tuples_fetched }, + { 2760, 1, true, false, "pg_stat_get_db_tuples_inserted", pg_stat_get_db_tuples_inserted }, + { 2761, 1, true, false, "pg_stat_get_db_tuples_updated", pg_stat_get_db_tuples_updated }, + { 2762, 1, true, false, "pg_stat_get_db_tuples_deleted", pg_stat_get_db_tuples_deleted }, + { 2763, 2, true, true, "regexp_matches_no_flags", regexp_matches_no_flags }, + { 2764, 3, true, true, "regexp_matches", regexp_matches }, + { 2765, 2, true, true, "regexp_split_to_table_no_flags", regexp_split_to_table_no_flags }, + { 2766, 3, true, true, "regexp_split_to_table", regexp_split_to_table }, + { 2767, 2, true, false, "regexp_split_to_array_no_flags", regexp_split_to_array_no_flags }, + { 2768, 3, true, false, "regexp_split_to_array", regexp_split_to_array }, + { 2769, 0, true, false, "pg_stat_get_bgwriter_timed_checkpoints", pg_stat_get_bgwriter_timed_checkpoints }, + { 2770, 0, true, false, "pg_stat_get_bgwriter_requested_checkpoints", pg_stat_get_bgwriter_requested_checkpoints }, + { 2771, 0, true, false, "pg_stat_get_bgwriter_buf_written_checkpoints", pg_stat_get_bgwriter_buf_written_checkpoints }, + { 2772, 0, true, false, "pg_stat_get_bgwriter_buf_written_clean", pg_stat_get_bgwriter_buf_written_clean }, + { 2773, 0, true, false, "pg_stat_get_bgwriter_maxwritten_clean", pg_stat_get_bgwriter_maxwritten_clean }, + { 2774, 7, true, false, "ginqueryarrayextract", ginqueryarrayextract }, + { 2775, 0, true, false, "pg_stat_get_buf_written_backend", pg_stat_get_buf_written_backend }, + { 2777, 1, true, false, "anynonarray_in", anynonarray_in }, + { 2778, 1, true, false, "anynonarray_out", anynonarray_out }, + { 2781, 1, true, false, "pg_stat_get_last_vacuum_time", pg_stat_get_last_vacuum_time }, + { 2782, 1, true, false, "pg_stat_get_last_autovacuum_time", pg_stat_get_last_autovacuum_time }, + { 2783, 1, true, false, "pg_stat_get_last_analyze_time", pg_stat_get_last_analyze_time }, + { 2784, 1, true, false, "pg_stat_get_last_autoanalyze_time", pg_stat_get_last_autoanalyze_time }, + { 2785, 2, false, false, "int8_avg_combine", int8_avg_combine }, + { 2786, 1, true, false, "int8_avg_serialize", int8_avg_serialize }, + { 2787, 2, true, false, "int8_avg_deserialize", int8_avg_deserialize }, + { 2788, 1, true, false, "pg_stat_get_backend_wait_event_type", pg_stat_get_backend_wait_event_type }, + { 2790, 2, true, false, "tidgt", tidgt }, + { 2791, 2, true, false, "tidlt", tidlt }, + { 2792, 2, true, false, "tidge", tidge }, + { 2793, 2, true, false, "tidle", tidle }, + { 2794, 2, true, false, "bttidcmp", bttidcmp }, + { 2795, 2, true, false, "tidlarger", tidlarger }, + { 2796, 2, true, false, "tidsmaller", tidsmaller }, + { 2804, 2, true, false, "int8inc_any", int8inc_any }, + { 2805, 3, true, false, "int8inc_float8_float8", int8inc_float8_float8 }, + { 2806, 3, true, false, "float8_regr_accum", float8_regr_accum }, + { 2807, 1, true, false, "float8_regr_sxx", float8_regr_sxx }, + { 2808, 1, true, false, "float8_regr_syy", float8_regr_syy }, + { 2809, 1, true, false, "float8_regr_sxy", float8_regr_sxy }, + { 2810, 1, true, false, "float8_regr_avgx", float8_regr_avgx }, + { 2811, 1, true, false, "float8_regr_avgy", float8_regr_avgy }, + { 2812, 1, true, false, "float8_regr_r2", float8_regr_r2 }, + { 2813, 1, true, false, "float8_regr_slope", float8_regr_slope }, + { 2814, 1, true, false, "float8_regr_intercept", float8_regr_intercept }, + { 2815, 1, true, false, "float8_covar_pop", float8_covar_pop }, + { 2816, 1, true, false, "float8_covar_samp", float8_covar_samp }, + { 2817, 1, true, false, "float8_corr", float8_corr }, + { 2844, 1, true, false, "pg_stat_get_db_blk_read_time", pg_stat_get_db_blk_read_time }, + { 2845, 1, true, false, "pg_stat_get_db_blk_write_time", pg_stat_get_db_blk_write_time }, + { 2848, 0, true, false, "pg_switch_wal", pg_switch_wal }, + { 2849, 0, true, false, "pg_current_wal_lsn", pg_current_wal_lsn }, + { 2850, 1, true, false, "pg_walfile_name_offset", pg_walfile_name_offset }, + { 2851, 1, true, false, "pg_walfile_name", pg_walfile_name }, + { 2852, 0, true, false, "pg_current_wal_insert_lsn", pg_current_wal_insert_lsn }, + { 2853, 1, true, false, "pg_stat_get_backend_wait_event", pg_stat_get_backend_wait_event }, + { 2854, 0, true, false, "pg_my_temp_schema", pg_my_temp_schema }, + { 2855, 1, true, false, "pg_is_other_temp_schema", pg_is_other_temp_schema }, + { 2856, 0, true, true, "pg_timezone_names", pg_timezone_names }, + { 2857, 1, true, false, "pg_stat_get_backend_xact_start", pg_stat_get_backend_xact_start }, + { 2858, 2, false, false, "numeric_avg_accum", numeric_avg_accum }, + { 2859, 0, true, false, "pg_stat_get_buf_alloc", pg_stat_get_buf_alloc }, + { 2878, 1, true, false, "pg_stat_get_live_tuples", pg_stat_get_live_tuples }, + { 2879, 1, true, false, "pg_stat_get_dead_tuples", pg_stat_get_dead_tuples }, + { 2880, 1, true, false, "pg_advisory_lock_int8", pg_advisory_lock_int8 }, + { 2881, 1, true, false, "pg_advisory_lock_shared_int8", pg_advisory_lock_shared_int8 }, + { 2882, 1, true, false, "pg_try_advisory_lock_int8", pg_try_advisory_lock_int8 }, + { 2883, 1, true, false, "pg_try_advisory_lock_shared_int8", pg_try_advisory_lock_shared_int8 }, + { 2884, 1, true, false, "pg_advisory_unlock_int8", pg_advisory_unlock_int8 }, + { 2885, 1, true, false, "pg_advisory_unlock_shared_int8", pg_advisory_unlock_shared_int8 }, + { 2886, 2, true, false, "pg_advisory_lock_int4", pg_advisory_lock_int4 }, + { 2887, 2, true, false, "pg_advisory_lock_shared_int4", pg_advisory_lock_shared_int4 }, + { 2888, 2, true, false, "pg_try_advisory_lock_int4", pg_try_advisory_lock_int4 }, + { 2889, 2, true, false, "pg_try_advisory_lock_shared_int4", pg_try_advisory_lock_shared_int4 }, + { 2890, 2, true, false, "pg_advisory_unlock_int4", pg_advisory_unlock_int4 }, + { 2891, 2, true, false, "pg_advisory_unlock_shared_int4", pg_advisory_unlock_shared_int4 }, + { 2892, 0, true, false, "pg_advisory_unlock_all", pg_advisory_unlock_all }, + { 2893, 1, true, false, "xml_in", xml_in }, + { 2894, 1, true, false, "xml_out", xml_out }, + { 2895, 1, true, false, "xmlcomment", xmlcomment }, + { 2896, 1, true, false, "texttoxml", texttoxml }, + { 2897, 2, true, false, "xmlvalidate", xmlvalidate }, + { 2898, 1, true, false, "xml_recv", xml_recv }, + { 2899, 1, true, false, "xml_send", xml_send }, + { 2900, 2, false, false, "xmlconcat2", xmlconcat2 }, + { 2902, 1, true, false, "varbittypmodin", varbittypmodin }, + { 2903, 1, true, false, "intervaltypmodin", intervaltypmodin }, + { 2904, 1, true, false, "intervaltypmodout", intervaltypmodout }, + { 2905, 1, true, false, "timestamptypmodin", timestamptypmodin }, + { 2906, 1, true, false, "timestamptypmodout", timestamptypmodout }, + { 2907, 1, true, false, "timestamptztypmodin", timestamptztypmodin }, + { 2908, 1, true, false, "timestamptztypmodout", timestamptztypmodout }, + { 2909, 1, true, false, "timetypmodin", timetypmodin }, + { 2910, 1, true, false, "timetypmodout", timetypmodout }, + { 2911, 1, true, false, "timetztypmodin", timetztypmodin }, + { 2912, 1, true, false, "timetztypmodout", timetztypmodout }, + { 2913, 1, true, false, "bpchartypmodin", bpchartypmodin }, + { 2914, 1, true, false, "bpchartypmodout", bpchartypmodout }, + { 2915, 1, true, false, "varchartypmodin", varchartypmodin }, + { 2916, 1, true, false, "varchartypmodout", varchartypmodout }, + { 2917, 1, true, false, "numerictypmodin", numerictypmodin }, + { 2918, 1, true, false, "numerictypmodout", numerictypmodout }, + { 2919, 1, true, false, "bittypmodin", bittypmodin }, + { 2920, 1, true, false, "bittypmodout", bittypmodout }, + { 2921, 1, true, false, "varbittypmodout", varbittypmodout }, + { 2922, 1, true, false, "xmltotext", xmltotext }, + { 2923, 4, true, false, "table_to_xml", table_to_xml }, + { 2924, 4, true, false, "query_to_xml", query_to_xml }, + { 2925, 5, true, false, "cursor_to_xml", cursor_to_xml }, + { 2926, 4, true, false, "table_to_xmlschema", table_to_xmlschema }, + { 2927, 4, true, false, "query_to_xmlschema", query_to_xmlschema }, + { 2928, 4, true, false, "cursor_to_xmlschema", cursor_to_xmlschema }, + { 2929, 4, true, false, "table_to_xml_and_xmlschema", table_to_xml_and_xmlschema }, + { 2930, 4, true, false, "query_to_xml_and_xmlschema", query_to_xml_and_xmlschema }, + { 2931, 3, true, false, "xpath", xpath }, + { 2933, 4, true, false, "schema_to_xml", schema_to_xml }, + { 2934, 4, true, false, "schema_to_xmlschema", schema_to_xmlschema }, + { 2935, 4, true, false, "schema_to_xml_and_xmlschema", schema_to_xml_and_xmlschema }, + { 2936, 3, true, false, "database_to_xml", database_to_xml }, + { 2937, 3, true, false, "database_to_xmlschema", database_to_xmlschema }, + { 2938, 3, true, false, "database_to_xml_and_xmlschema", database_to_xml_and_xmlschema }, + { 2939, 1, true, false, "pg_snapshot_in", pg_snapshot_in }, + { 2940, 1, true, false, "pg_snapshot_out", pg_snapshot_out }, + { 2941, 1, true, false, "pg_snapshot_recv", pg_snapshot_recv }, + { 2942, 1, true, false, "pg_snapshot_send", pg_snapshot_send }, + { 2943, 0, true, false, "pg_current_xact_id", pg_current_xact_id }, + { 2944, 0, true, false, "pg_current_snapshot", pg_current_snapshot }, + { 2945, 1, true, false, "pg_snapshot_xmin", pg_snapshot_xmin }, + { 2946, 1, true, false, "pg_snapshot_xmax", pg_snapshot_xmax }, + { 2947, 1, true, true, "pg_snapshot_xip", pg_snapshot_xip }, + { 2948, 2, true, false, "pg_visible_in_snapshot", pg_visible_in_snapshot }, + { 2952, 1, true, false, "uuid_in", uuid_in }, + { 2953, 1, true, false, "uuid_out", uuid_out }, + { 2954, 2, true, false, "uuid_lt", uuid_lt }, + { 2955, 2, true, false, "uuid_le", uuid_le }, + { 2956, 2, true, false, "uuid_eq", uuid_eq }, + { 2957, 2, true, false, "uuid_ge", uuid_ge }, + { 2958, 2, true, false, "uuid_gt", uuid_gt }, + { 2959, 2, true, false, "uuid_ne", uuid_ne }, + { 2960, 2, true, false, "uuid_cmp", uuid_cmp }, + { 2961, 1, true, false, "uuid_recv", uuid_recv }, + { 2962, 1, true, false, "uuid_send", uuid_send }, + { 2963, 1, true, false, "uuid_hash", uuid_hash }, + { 2971, 1, true, false, "booltext", booltext }, + { 2978, 1, true, false, "pg_stat_get_function_calls", pg_stat_get_function_calls }, + { 2979, 1, true, false, "pg_stat_get_function_total_time", pg_stat_get_function_total_time }, + { 2980, 1, true, false, "pg_stat_get_function_self_time", pg_stat_get_function_self_time }, + { 2981, 2, true, false, "record_eq", record_eq }, + { 2982, 2, true, false, "record_ne", record_ne }, + { 2983, 2, true, false, "record_lt", record_lt }, + { 2984, 2, true, false, "record_gt", record_gt }, + { 2985, 2, true, false, "record_le", record_le }, + { 2986, 2, true, false, "record_ge", record_ge }, + { 2987, 2, true, false, "btrecordcmp", btrecordcmp }, + { 2997, 1, true, false, "pg_table_size", pg_table_size }, + { 2998, 1, true, false, "pg_indexes_size", pg_indexes_size }, + { 2999, 1, true, false, "pg_relation_filenode", pg_relation_filenode }, + { 3000, 3, true, false, "has_foreign_data_wrapper_privilege_name_name", has_foreign_data_wrapper_privilege_name_name }, + { 3001, 3, true, false, "has_foreign_data_wrapper_privilege_name_id", has_foreign_data_wrapper_privilege_name_id }, + { 3002, 3, true, false, "has_foreign_data_wrapper_privilege_id_name", has_foreign_data_wrapper_privilege_id_name }, + { 3003, 3, true, false, "has_foreign_data_wrapper_privilege_id_id", has_foreign_data_wrapper_privilege_id_id }, + { 3004, 2, true, false, "has_foreign_data_wrapper_privilege_name", has_foreign_data_wrapper_privilege_name }, + { 3005, 2, true, false, "has_foreign_data_wrapper_privilege_id", has_foreign_data_wrapper_privilege_id }, + { 3006, 3, true, false, "has_server_privilege_name_name", has_server_privilege_name_name }, + { 3007, 3, true, false, "has_server_privilege_name_id", has_server_privilege_name_id }, + { 3008, 3, true, false, "has_server_privilege_id_name", has_server_privilege_id_name }, + { 3009, 3, true, false, "has_server_privilege_id_id", has_server_privilege_id_id }, + { 3010, 2, true, false, "has_server_privilege_name", has_server_privilege_name }, + { 3011, 2, true, false, "has_server_privilege_id", has_server_privilege_id }, + { 3012, 4, true, false, "has_column_privilege_name_name_name", has_column_privilege_name_name_name }, + { 3013, 4, true, false, "has_column_privilege_name_name_attnum", has_column_privilege_name_name_attnum }, + { 3014, 4, true, false, "has_column_privilege_name_id_name", has_column_privilege_name_id_name }, + { 3015, 4, true, false, "has_column_privilege_name_id_attnum", has_column_privilege_name_id_attnum }, + { 3016, 4, true, false, "has_column_privilege_id_name_name", has_column_privilege_id_name_name }, + { 3017, 4, true, false, "has_column_privilege_id_name_attnum", has_column_privilege_id_name_attnum }, + { 3018, 4, true, false, "has_column_privilege_id_id_name", has_column_privilege_id_id_name }, + { 3019, 4, true, false, "has_column_privilege_id_id_attnum", has_column_privilege_id_id_attnum }, + { 3020, 3, true, false, "has_column_privilege_name_name", has_column_privilege_name_name }, + { 3021, 3, true, false, "has_column_privilege_name_attnum", has_column_privilege_name_attnum }, + { 3022, 3, true, false, "has_column_privilege_id_name", has_column_privilege_id_name }, + { 3023, 3, true, false, "has_column_privilege_id_attnum", has_column_privilege_id_attnum }, + { 3024, 3, true, false, "has_any_column_privilege_name_name", has_any_column_privilege_name_name }, + { 3025, 3, true, false, "has_any_column_privilege_name_id", has_any_column_privilege_name_id }, + { 3026, 3, true, false, "has_any_column_privilege_id_name", has_any_column_privilege_id_name }, + { 3027, 3, true, false, "has_any_column_privilege_id_id", has_any_column_privilege_id_id }, + { 3028, 2, true, false, "has_any_column_privilege_name", has_any_column_privilege_name }, + { 3029, 2, true, false, "has_any_column_privilege_id", has_any_column_privilege_id }, + { 3030, 4, true, false, "bitoverlay", bitoverlay }, + { 3031, 3, true, false, "bitoverlay_no_len", bitoverlay_no_len }, + { 3032, 2, true, false, "bitgetbit", bitgetbit }, + { 3033, 3, true, false, "bitsetbit", bitsetbit }, + { 3034, 1, true, false, "pg_relation_filepath", pg_relation_filepath }, + { 3035, 0, true, true, "pg_listening_channels", pg_listening_channels }, + { 3036, 2, false, false, "pg_notify", pg_notify }, + { 3037, 1, true, false, "pg_stat_get_xact_numscans", pg_stat_get_xact_numscans }, + { 3038, 1, true, false, "pg_stat_get_xact_tuples_returned", pg_stat_get_xact_tuples_returned }, + { 3039, 1, true, false, "pg_stat_get_xact_tuples_fetched", pg_stat_get_xact_tuples_fetched }, + { 3040, 1, true, false, "pg_stat_get_xact_tuples_inserted", pg_stat_get_xact_tuples_inserted }, + { 3041, 1, true, false, "pg_stat_get_xact_tuples_updated", pg_stat_get_xact_tuples_updated }, + { 3042, 1, true, false, "pg_stat_get_xact_tuples_deleted", pg_stat_get_xact_tuples_deleted }, + { 3043, 1, true, false, "pg_stat_get_xact_tuples_hot_updated", pg_stat_get_xact_tuples_hot_updated }, + { 3044, 1, true, false, "pg_stat_get_xact_blocks_fetched", pg_stat_get_xact_blocks_fetched }, + { 3045, 1, true, false, "pg_stat_get_xact_blocks_hit", pg_stat_get_xact_blocks_hit }, + { 3046, 1, true, false, "pg_stat_get_xact_function_calls", pg_stat_get_xact_function_calls }, + { 3047, 1, true, false, "pg_stat_get_xact_function_total_time", pg_stat_get_xact_function_total_time }, + { 3048, 1, true, false, "pg_stat_get_xact_function_self_time", pg_stat_get_xact_function_self_time }, + { 3049, 3, true, false, "xpath_exists", xpath_exists }, + { 3051, 1, true, false, "xml_is_well_formed", xml_is_well_formed }, + { 3052, 1, true, false, "xml_is_well_formed_document", xml_is_well_formed_document }, + { 3053, 1, true, false, "xml_is_well_formed_content", xml_is_well_formed_content }, + { 3054, 1, true, false, "pg_stat_get_vacuum_count", pg_stat_get_vacuum_count }, + { 3055, 1, true, false, "pg_stat_get_autovacuum_count", pg_stat_get_autovacuum_count }, + { 3056, 1, true, false, "pg_stat_get_analyze_count", pg_stat_get_analyze_count }, + { 3057, 1, true, false, "pg_stat_get_autoanalyze_count", pg_stat_get_autoanalyze_count }, + { 3058, 1, false, false, "text_concat", text_concat }, + { 3059, 2, false, false, "text_concat_ws", text_concat_ws }, + { 3060, 2, true, false, "text_left", text_left }, + { 3061, 2, true, false, "text_right", text_right }, + { 3062, 1, true, false, "text_reverse", text_reverse }, + { 3063, 0, true, false, "pg_stat_get_buf_fsync_backend", pg_stat_get_buf_fsync_backend }, + { 3064, 5, true, false, "gist_point_distance", gist_point_distance }, + { 3065, 1, true, false, "pg_stat_get_db_conflict_tablespace", pg_stat_get_db_conflict_tablespace }, + { 3066, 1, true, false, "pg_stat_get_db_conflict_lock", pg_stat_get_db_conflict_lock }, + { 3067, 1, true, false, "pg_stat_get_db_conflict_snapshot", pg_stat_get_db_conflict_snapshot }, + { 3068, 1, true, false, "pg_stat_get_db_conflict_bufferpin", pg_stat_get_db_conflict_bufferpin }, + { 3069, 1, true, false, "pg_stat_get_db_conflict_startup_deadlock", pg_stat_get_db_conflict_startup_deadlock }, + { 3070, 1, true, false, "pg_stat_get_db_conflict_all", pg_stat_get_db_conflict_all }, + { 3071, 0, true, false, "pg_wal_replay_pause", pg_wal_replay_pause }, + { 3072, 0, true, false, "pg_wal_replay_resume", pg_wal_replay_resume }, + { 3073, 0, true, false, "pg_is_wal_replay_paused", pg_is_wal_replay_paused }, + { 3074, 1, true, false, "pg_stat_get_db_stat_reset_time", pg_stat_get_db_stat_reset_time }, + { 3075, 0, true, false, "pg_stat_get_bgwriter_stat_reset_time", pg_stat_get_bgwriter_stat_reset_time }, + { 3076, 2, true, false, "ginarrayextract_2args", ginarrayextract_2args }, + { 3077, 2, true, false, "gin_extract_tsvector_2args", gin_extract_tsvector_2args }, + { 3078, 1, true, false, "pg_sequence_parameters", pg_sequence_parameters }, + { 3082, 0, true, true, "pg_available_extensions", pg_available_extensions }, + { 3083, 0, true, true, "pg_available_extension_versions", pg_available_extension_versions }, + { 3084, 1, true, true, "pg_extension_update_paths", pg_extension_update_paths }, + { 3086, 2, true, false, "pg_extension_config_dump", pg_extension_config_dump }, + { 3087, 5, true, false, "gin_extract_tsquery_5args", gin_extract_tsquery_5args }, + { 3088, 6, true, false, "gin_tsquery_consistent_6args", gin_tsquery_consistent_6args }, + { 3089, 1, true, false, "pg_advisory_xact_lock_int8", pg_advisory_xact_lock_int8 }, + { 3090, 1, true, false, "pg_advisory_xact_lock_shared_int8", pg_advisory_xact_lock_shared_int8 }, + { 3091, 1, true, false, "pg_try_advisory_xact_lock_int8", pg_try_advisory_xact_lock_int8 }, + { 3092, 1, true, false, "pg_try_advisory_xact_lock_shared_int8", pg_try_advisory_xact_lock_shared_int8 }, + { 3093, 2, true, false, "pg_advisory_xact_lock_int4", pg_advisory_xact_lock_int4 }, + { 3094, 2, true, false, "pg_advisory_xact_lock_shared_int4", pg_advisory_xact_lock_shared_int4 }, + { 3095, 2, true, false, "pg_try_advisory_xact_lock_int4", pg_try_advisory_xact_lock_int4 }, + { 3096, 2, true, false, "pg_try_advisory_xact_lock_shared_int4", pg_try_advisory_xact_lock_shared_int4 }, + { 3097, 1, true, false, "varchar_support", varchar_support }, + { 3098, 1, true, false, "pg_create_restore_point", pg_create_restore_point }, + { 3099, 0, false, true, "pg_stat_get_wal_senders", pg_stat_get_wal_senders }, + { 3100, 0, false, false, "window_row_number", window_row_number }, + { 3101, 0, false, false, "window_rank", window_rank }, + { 3102, 0, false, false, "window_dense_rank", window_dense_rank }, + { 3103, 0, false, false, "window_percent_rank", window_percent_rank }, + { 3104, 0, false, false, "window_cume_dist", window_cume_dist }, + { 3105, 1, true, false, "window_ntile", window_ntile }, + { 3106, 1, true, false, "window_lag", window_lag }, + { 3107, 2, true, false, "window_lag_with_offset", window_lag_with_offset }, + { 3108, 3, true, false, "window_lag_with_offset_and_default", window_lag_with_offset_and_default }, + { 3109, 1, true, false, "window_lead", window_lead }, + { 3110, 2, true, false, "window_lead_with_offset", window_lead_with_offset }, + { 3111, 3, true, false, "window_lead_with_offset_and_default", window_lead_with_offset_and_default }, + { 3112, 1, true, false, "window_first_value", window_first_value }, + { 3113, 1, true, false, "window_last_value", window_last_value }, + { 3114, 2, true, false, "window_nth_value", window_nth_value }, + { 3116, 1, false, false, "fdw_handler_in", fdw_handler_in }, + { 3117, 1, true, false, "fdw_handler_out", fdw_handler_out }, + { 3120, 1, true, false, "void_recv", void_recv }, + { 3121, 1, true, false, "void_send", void_send }, + { 3129, 1, true, false, "btint2sortsupport", btint2sortsupport }, + { 3130, 1, true, false, "btint4sortsupport", btint4sortsupport }, + { 3131, 1, true, false, "btint8sortsupport", btint8sortsupport }, + { 3132, 1, true, false, "btfloat4sortsupport", btfloat4sortsupport }, + { 3133, 1, true, false, "btfloat8sortsupport", btfloat8sortsupport }, + { 3134, 1, true, false, "btoidsortsupport", btoidsortsupport }, + { 3135, 1, true, false, "btnamesortsupport", btnamesortsupport }, + { 3136, 1, true, false, "date_sortsupport", date_sortsupport }, + { 3137, 1, true, false, "timestamp_sortsupport", timestamp_sortsupport }, + { 3138, 3, true, false, "has_type_privilege_name_name", has_type_privilege_name_name }, + { 3139, 3, true, false, "has_type_privilege_name_id", has_type_privilege_name_id }, + { 3140, 3, true, false, "has_type_privilege_id_name", has_type_privilege_id_name }, + { 3141, 3, true, false, "has_type_privilege_id_id", has_type_privilege_id_id }, + { 3142, 2, true, false, "has_type_privilege_name", has_type_privilege_name }, + { 3143, 2, true, false, "has_type_privilege_id", has_type_privilege_id }, + { 3144, 1, true, false, "macaddr_not", macaddr_not }, + { 3145, 2, true, false, "macaddr_and", macaddr_and }, + { 3146, 2, true, false, "macaddr_or", macaddr_or }, + { 3150, 1, true, false, "pg_stat_get_db_temp_files", pg_stat_get_db_temp_files }, + { 3151, 1, true, false, "pg_stat_get_db_temp_bytes", pg_stat_get_db_temp_bytes }, + { 3152, 1, true, false, "pg_stat_get_db_deadlocks", pg_stat_get_db_deadlocks }, + { 3153, 1, true, false, "array_to_json", array_to_json }, + { 3154, 2, true, false, "array_to_json_pretty", array_to_json_pretty }, + { 3155, 1, true, false, "row_to_json", row_to_json }, + { 3156, 2, true, false, "row_to_json_pretty", row_to_json_pretty }, + { 3157, 1, true, false, "numeric_support", numeric_support }, + { 3158, 1, true, false, "varbit_support", varbit_support }, + { 3159, 2, true, false, "pg_get_viewdef_wrap", pg_get_viewdef_wrap }, + { 3160, 0, true, false, "pg_stat_get_checkpoint_write_time", pg_stat_get_checkpoint_write_time }, + { 3161, 0, true, false, "pg_stat_get_checkpoint_sync_time", pg_stat_get_checkpoint_sync_time }, + { 3162, 1, false, false, "pg_collation_for", pg_collation_for }, + { 3163, 0, true, false, "pg_trigger_depth", pg_trigger_depth }, + { 3165, 2, true, false, "pg_wal_lsn_diff", pg_wal_lsn_diff }, + { 3166, 1, true, false, "pg_size_pretty_numeric", pg_size_pretty_numeric }, + { 3167, 2, false, false, "array_remove", array_remove }, + { 3168, 3, false, false, "array_replace", array_replace }, + { 3169, 4, true, false, "rangesel", rangesel }, + { 3170, 3, true, false, "be_lo_lseek64", be_lo_lseek64 }, + { 3171, 1, true, false, "be_lo_tell64", be_lo_tell64 }, + { 3172, 2, true, false, "be_lo_truncate64", be_lo_truncate64 }, + { 3173, 2, false, false, "json_agg_transfn", json_agg_transfn }, + { 3174, 1, false, false, "json_agg_finalfn", json_agg_finalfn }, + { 3176, 1, true, false, "to_json", to_json }, + { 3177, 1, true, false, "pg_stat_get_mod_since_analyze", pg_stat_get_mod_since_analyze }, + { 3178, 1, false, false, "numeric_sum", numeric_sum }, + { 3179, 1, true, false, "array_cardinality", array_cardinality }, + { 3180, 3, false, false, "json_object_agg_transfn", json_object_agg_transfn }, + { 3181, 2, true, false, "record_image_eq", record_image_eq }, + { 3182, 2, true, false, "record_image_ne", record_image_ne }, + { 3183, 2, true, false, "record_image_lt", record_image_lt }, + { 3184, 2, true, false, "record_image_gt", record_image_gt }, + { 3185, 2, true, false, "record_image_le", record_image_le }, + { 3186, 2, true, false, "record_image_ge", record_image_ge }, + { 3187, 2, true, false, "btrecordimagecmp", btrecordimagecmp }, + { 3195, 0, false, false, "pg_stat_get_archiver", pg_stat_get_archiver }, + { 3196, 1, false, false, "json_object_agg_finalfn", json_object_agg_finalfn }, + { 3198, 1, false, false, "json_build_array", json_build_array }, + { 3199, 0, false, false, "json_build_array_noargs", json_build_array_noargs }, + { 3200, 1, false, false, "json_build_object", json_build_object }, + { 3201, 0, false, false, "json_build_object_noargs", json_build_object_noargs }, + { 3202, 1, true, false, "json_object", json_object }, + { 3203, 2, true, false, "json_object_two_arg", json_object_two_arg }, + { 3204, 1, true, false, "json_to_record", json_to_record }, + { 3205, 1, false, true, "json_to_recordset", json_to_recordset }, + { 3207, 1, true, false, "jsonb_array_length", jsonb_array_length }, + { 3208, 1, true, true, "jsonb_each", jsonb_each }, + { 3209, 2, false, false, "jsonb_populate_record", jsonb_populate_record }, + { 3210, 1, true, false, "jsonb_typeof", jsonb_typeof }, + { 3214, 2, true, false, "jsonb_object_field_text", jsonb_object_field_text }, + { 3215, 2, true, false, "jsonb_array_element", jsonb_array_element }, + { 3216, 2, true, false, "jsonb_array_element_text", jsonb_array_element_text }, + { 3217, 2, true, false, "jsonb_extract_path", jsonb_extract_path }, + { 3218, 2, true, false, "width_bucket_array", width_bucket_array }, + { 3219, 1, true, true, "jsonb_array_elements", jsonb_array_elements }, + { 3229, 1, true, false, "pg_lsn_in", pg_lsn_in }, + { 3230, 1, true, false, "pg_lsn_out", pg_lsn_out }, + { 3231, 2, true, false, "pg_lsn_lt", pg_lsn_lt }, + { 3232, 2, true, false, "pg_lsn_le", pg_lsn_le }, + { 3233, 2, true, false, "pg_lsn_eq", pg_lsn_eq }, + { 3234, 2, true, false, "pg_lsn_ge", pg_lsn_ge }, + { 3235, 2, true, false, "pg_lsn_gt", pg_lsn_gt }, + { 3236, 2, true, false, "pg_lsn_ne", pg_lsn_ne }, + { 3237, 2, true, false, "pg_lsn_mi", pg_lsn_mi }, + { 3238, 1, true, false, "pg_lsn_recv", pg_lsn_recv }, + { 3239, 1, true, false, "pg_lsn_send", pg_lsn_send }, + { 3251, 2, true, false, "pg_lsn_cmp", pg_lsn_cmp }, + { 3252, 1, true, false, "pg_lsn_hash", pg_lsn_hash }, + { 3255, 1, true, false, "bttextsortsupport", bttextsortsupport }, + { 3259, 3, true, true, "generate_series_step_numeric", generate_series_step_numeric }, + { 3260, 2, true, true, "generate_series_numeric", generate_series_numeric }, + { 3261, 1, true, false, "json_strip_nulls", json_strip_nulls }, + { 3262, 1, true, false, "jsonb_strip_nulls", jsonb_strip_nulls }, + { 3263, 1, true, false, "jsonb_object", jsonb_object }, + { 3264, 2, true, false, "jsonb_object_two_arg", jsonb_object_two_arg }, + { 3265, 2, false, false, "jsonb_agg_transfn", jsonb_agg_transfn }, + { 3266, 1, false, false, "jsonb_agg_finalfn", jsonb_agg_finalfn }, + { 3268, 3, false, false, "jsonb_object_agg_transfn", jsonb_object_agg_transfn }, + { 3269, 1, false, false, "jsonb_object_agg_finalfn", jsonb_object_agg_finalfn }, + { 3271, 1, false, false, "jsonb_build_array", jsonb_build_array }, + { 3272, 0, false, false, "jsonb_build_array_noargs", jsonb_build_array_noargs }, + { 3273, 1, false, false, "jsonb_build_object", jsonb_build_object }, + { 3274, 0, false, false, "jsonb_build_object_noargs", jsonb_build_object_noargs }, + { 3275, 2, true, false, "dist_ppoly", dist_ppoly }, + { 3277, 2, false, false, "array_position", array_position }, + { 3278, 3, false, false, "array_position_start", array_position_start }, + { 3279, 2, false, false, "array_positions", array_positions }, + { 3280, 5, true, false, "gist_circle_distance", gist_circle_distance }, + { 3281, 1, true, false, "numeric_scale", numeric_scale }, + { 3282, 1, true, false, "gist_point_fetch", gist_point_fetch }, + { 3283, 1, true, false, "numeric_sortsupport", numeric_sortsupport }, + { 3288, 5, true, false, "gist_poly_distance", gist_poly_distance }, + { 3290, 2, true, false, "dist_cpoint", dist_cpoint }, + { 3292, 2, true, false, "dist_polyp", dist_polyp }, + { 3293, 4, true, false, "pg_read_file_v2", pg_read_file_v2 }, + { 3294, 2, true, false, "show_config_by_name_missing_ok", show_config_by_name_missing_ok }, + { 3295, 4, true, false, "pg_read_binary_file", pg_read_binary_file }, + { 3296, 0, true, false, "pg_notification_queue_usage", pg_notification_queue_usage }, + { 3297, 3, true, true, "pg_ls_dir", pg_ls_dir }, + { 3298, 1, true, false, "row_security_active", row_security_active }, + { 3299, 1, true, false, "row_security_active_name", row_security_active_name }, + { 3300, 1, true, false, "uuid_sortsupport", uuid_sortsupport }, + { 3301, 2, true, false, "jsonb_concat", jsonb_concat }, + { 3302, 2, true, false, "jsonb_delete", jsonb_delete }, + { 3303, 2, true, false, "jsonb_delete_idx", jsonb_delete_idx }, + { 3304, 2, true, false, "jsonb_delete_path", jsonb_delete_path }, + { 3305, 4, true, false, "jsonb_set", jsonb_set }, + { 3306, 1, true, false, "jsonb_pretty", jsonb_pretty }, + { 3307, 2, true, false, "pg_stat_file", pg_stat_file }, + { 3308, 2, true, false, "xidneq", xidneq }, + { 3309, 2, true, false, "xidneq", xidneq }, + { 3311, 1, false, false, "tsm_handler_in", tsm_handler_in }, + { 3312, 1, true, false, "tsm_handler_out", tsm_handler_out }, + { 3313, 1, true, false, "tsm_bernoulli_handler", tsm_bernoulli_handler }, + { 3314, 1, true, false, "tsm_system_handler", tsm_system_handler }, + { 3317, 0, false, false, "pg_stat_get_wal_receiver", pg_stat_get_wal_receiver }, + { 3318, 1, true, true, "pg_stat_get_progress_info", pg_stat_get_progress_info }, + { 3319, 2, true, false, "tsvector_filter", tsvector_filter }, + { 3320, 3, true, false, "tsvector_setweight_by_filter", tsvector_setweight_by_filter }, + { 3321, 2, true, false, "tsvector_delete_str", tsvector_delete_str }, + { 3322, 1, true, true, "tsvector_unnest", tsvector_unnest }, + { 3323, 2, true, false, "tsvector_delete_arr", tsvector_delete_arr }, + { 3324, 2, true, false, "int4_avg_combine", int4_avg_combine }, + { 3325, 2, true, false, "interval_combine", interval_combine }, + { 3326, 1, true, false, "tsvector_to_array", tsvector_to_array }, + { 3327, 1, true, false, "array_to_tsvector", array_to_tsvector }, + { 3328, 1, true, false, "bpchar_sortsupport", bpchar_sortsupport }, + { 3329, 0, true, true, "show_all_file_settings", show_all_file_settings }, + { 3330, 0, true, false, "pg_current_wal_flush_lsn", pg_current_wal_flush_lsn }, + { 3331, 1, true, false, "bytea_sortsupport", bytea_sortsupport }, + { 3332, 1, true, false, "bttext_pattern_sortsupport", bttext_pattern_sortsupport }, + { 3333, 1, true, false, "btbpchar_pattern_sortsupport", btbpchar_pattern_sortsupport }, + { 3334, 1, true, false, "pg_size_bytes", pg_size_bytes }, + { 3335, 1, true, false, "numeric_serialize", numeric_serialize }, + { 3336, 2, true, false, "numeric_deserialize", numeric_deserialize }, + { 3337, 2, false, false, "numeric_avg_combine", numeric_avg_combine }, + { 3338, 2, false, false, "numeric_poly_combine", numeric_poly_combine }, + { 3339, 1, true, false, "numeric_poly_serialize", numeric_poly_serialize }, + { 3340, 2, true, false, "numeric_poly_deserialize", numeric_poly_deserialize }, + { 3341, 2, false, false, "numeric_combine", numeric_combine }, + { 3342, 2, true, false, "float8_regr_combine", float8_regr_combine }, + { 3343, 2, true, false, "jsonb_delete_array", jsonb_delete_array }, + { 3344, 2, true, false, "cash_mul_int8", cash_mul_int8 }, + { 3345, 2, true, false, "cash_div_int8", cash_div_int8 }, + { 3348, 0, true, false, "pg_current_xact_id_if_assigned", pg_current_xact_id_if_assigned }, + { 3352, 1, true, false, "pg_get_partkeydef", pg_get_partkeydef }, + { 3353, 0, true, true, "pg_ls_logdir", pg_ls_logdir }, + { 3354, 0, true, true, "pg_ls_waldir", pg_ls_waldir }, + { 3355, 1, true, false, "pg_ndistinct_in", pg_ndistinct_in }, + { 3356, 1, true, false, "pg_ndistinct_out", pg_ndistinct_out }, + { 3357, 1, true, false, "pg_ndistinct_recv", pg_ndistinct_recv }, + { 3358, 1, true, false, "pg_ndistinct_send", pg_ndistinct_send }, + { 3359, 1, true, false, "macaddr_sortsupport", macaddr_sortsupport }, + { 3360, 1, true, false, "pg_xact_status", pg_xact_status }, + { 3376, 1, true, false, "pg_safe_snapshot_blocking_pids", pg_safe_snapshot_blocking_pids }, + { 3378, 2, true, false, "pg_isolation_test_session_is_blocked", pg_isolation_test_session_is_blocked }, + { 3382, 3, true, false, "pg_identify_object_as_address", pg_identify_object_as_address }, + { 3383, 1, true, false, "brin_minmax_opcinfo", brin_minmax_opcinfo }, + { 3384, 4, true, false, "brin_minmax_add_value", brin_minmax_add_value }, + { 3385, 3, true, false, "brin_minmax_consistent", brin_minmax_consistent }, + { 3386, 3, true, false, "brin_minmax_union", brin_minmax_union }, + { 3387, 2, false, false, "int8_avg_accum_inv", int8_avg_accum_inv }, + { 3388, 1, false, false, "numeric_poly_sum", numeric_poly_sum }, + { 3389, 1, false, false, "numeric_poly_avg", numeric_poly_avg }, + { 3390, 1, false, false, "numeric_poly_var_pop", numeric_poly_var_pop }, + { 3391, 1, false, false, "numeric_poly_var_samp", numeric_poly_var_samp }, + { 3392, 1, false, false, "numeric_poly_stddev_pop", numeric_poly_stddev_pop }, + { 3393, 1, false, false, "numeric_poly_stddev_samp", numeric_poly_stddev_samp }, + { 3396, 2, true, false, "regexp_match_no_flags", regexp_match_no_flags }, + { 3397, 3, true, false, "regexp_match", regexp_match }, + { 3399, 2, true, false, "int8_mul_cash", int8_mul_cash }, + { 3400, 0, true, true, "pg_config", pg_config }, + { 3401, 0, true, true, "pg_hba_file_rules", pg_hba_file_rules }, + { 3403, 1, true, false, "pg_statistics_obj_is_visible", pg_statistics_obj_is_visible }, + { 3404, 1, true, false, "pg_dependencies_in", pg_dependencies_in }, + { 3405, 1, true, false, "pg_dependencies_out", pg_dependencies_out }, + { 3406, 1, true, false, "pg_dependencies_recv", pg_dependencies_recv }, + { 3407, 1, true, false, "pg_dependencies_send", pg_dependencies_send }, + { 3408, 1, true, false, "pg_get_partition_constraintdef", pg_get_partition_constraintdef }, + { 3409, 2, true, false, "time_hash_extended", time_hash_extended }, + { 3410, 2, true, false, "timetz_hash_extended", timetz_hash_extended }, + { 3411, 2, true, false, "timestamp_hash_extended", timestamp_hash_extended }, + { 3412, 2, true, false, "uuid_hash_extended", uuid_hash_extended }, + { 3413, 2, true, false, "pg_lsn_hash_extended", pg_lsn_hash_extended }, + { 3414, 2, true, false, "hashenumextended", hashenumextended }, + { 3415, 1, true, false, "pg_get_statisticsobjdef", pg_get_statisticsobjdef }, + { 3416, 2, true, false, "jsonb_hash_extended", jsonb_hash_extended }, + { 3417, 2, true, false, "hash_range_extended", hash_range_extended }, + { 3418, 2, true, false, "interval_hash_extended", interval_hash_extended }, + { 3419, 1, true, false, "sha224_bytea", sha224_bytea }, + { 3420, 1, true, false, "sha256_bytea", sha256_bytea }, + { 3421, 1, true, false, "sha384_bytea", sha384_bytea }, + { 3422, 1, true, false, "sha512_bytea", sha512_bytea }, + { 3423, 1, true, true, "pg_partition_tree", pg_partition_tree }, + { 3424, 1, true, false, "pg_partition_root", pg_partition_root }, + { 3425, 1, true, true, "pg_partition_ancestors", pg_partition_ancestors }, + { 3426, 1, true, false, "pg_stat_get_db_checksum_failures", pg_stat_get_db_checksum_failures }, + { 3427, 1, true, true, "pg_stats_ext_mcvlist_items", pg_stats_ext_mcvlist_items }, + { 3428, 1, true, false, "pg_stat_get_db_checksum_last_failure", pg_stat_get_db_checksum_last_failure }, + { 3432, 0, true, false, "gen_random_uuid", gen_random_uuid }, + { 3434, 1, false, false, "gtsvector_options", gtsvector_options }, + { 3435, 1, true, false, "gist_point_sortsupport", gist_point_sortsupport }, + { 3436, 2, true, false, "pg_promote", pg_promote }, + { 3437, 4, true, false, "prefixsel", prefixsel }, + { 3438, 5, true, false, "prefixjoinsel", prefixjoinsel }, + { 3441, 0, true, false, "pg_control_system", pg_control_system }, + { 3442, 0, true, false, "pg_control_checkpoint", pg_control_checkpoint }, + { 3443, 0, true, false, "pg_control_recovery", pg_control_recovery }, + { 3444, 0, true, false, "pg_control_init", pg_control_init }, + { 3445, 1, true, false, "pg_import_system_collations", pg_import_system_collations }, + { 3446, 1, true, false, "macaddr8_recv", macaddr8_recv }, + { 3447, 1, true, false, "macaddr8_send", macaddr8_send }, + { 3448, 1, true, false, "pg_collation_actual_version", pg_collation_actual_version }, + { 3449, 1, true, false, "jsonb_numeric", jsonb_numeric }, + { 3450, 1, true, false, "jsonb_int2", jsonb_int2 }, + { 3451, 1, true, false, "jsonb_int4", jsonb_int4 }, + { 3452, 1, true, false, "jsonb_int8", jsonb_int8 }, + { 3453, 1, true, false, "jsonb_float4", jsonb_float4 }, + { 3454, 2, true, false, "pg_filenode_relation", pg_filenode_relation }, + { 3457, 2, true, false, "be_lo_from_bytea", be_lo_from_bytea }, + { 3458, 1, true, false, "be_lo_get", be_lo_get }, + { 3459, 3, true, false, "be_lo_get_fragment", be_lo_get_fragment }, + { 3460, 3, true, false, "be_lo_put", be_lo_put }, + { 3461, 6, true, false, "make_timestamp", make_timestamp }, + { 3462, 6, true, false, "make_timestamptz", make_timestamptz }, + { 3463, 7, true, false, "make_timestamptz_at_timezone", make_timestamptz_at_timezone }, + { 3464, 7, true, false, "make_interval", make_interval }, + { 3465, 1, true, true, "jsonb_array_elements_text", jsonb_array_elements_text }, + { 3469, 2, true, false, "spg_range_quad_config", spg_range_quad_config }, + { 3470, 2, true, false, "spg_range_quad_choose", spg_range_quad_choose }, + { 3471, 2, true, false, "spg_range_quad_picksplit", spg_range_quad_picksplit }, + { 3472, 2, true, false, "spg_range_quad_inner_consistent", spg_range_quad_inner_consistent }, + { 3473, 2, true, false, "spg_range_quad_leaf_consistent", spg_range_quad_leaf_consistent }, + { 3475, 2, false, true, "jsonb_populate_recordset", jsonb_populate_recordset }, + { 3476, 1, true, false, "to_regoperator", to_regoperator }, + { 3478, 2, true, false, "jsonb_object_field", jsonb_object_field }, + { 3479, 1, true, false, "to_regprocedure", to_regprocedure }, + { 3480, 2, true, false, "gin_compare_jsonb", gin_compare_jsonb }, + { 3482, 3, true, false, "gin_extract_jsonb", gin_extract_jsonb }, + { 3483, 7, true, false, "gin_extract_jsonb_query", gin_extract_jsonb_query }, + { 3484, 8, true, false, "gin_consistent_jsonb", gin_consistent_jsonb }, + { 3485, 3, true, false, "gin_extract_jsonb_path", gin_extract_jsonb_path }, + { 3486, 7, true, false, "gin_extract_jsonb_query_path", gin_extract_jsonb_query_path }, + { 3487, 8, true, false, "gin_consistent_jsonb_path", gin_consistent_jsonb_path }, + { 3488, 7, true, false, "gin_triconsistent_jsonb", gin_triconsistent_jsonb }, + { 3489, 7, true, false, "gin_triconsistent_jsonb_path", gin_triconsistent_jsonb_path }, + { 3490, 1, true, false, "jsonb_to_record", jsonb_to_record }, + { 3491, 1, false, true, "jsonb_to_recordset", jsonb_to_recordset }, + { 3492, 1, true, false, "to_regoper", to_regoper }, + { 3493, 1, true, false, "to_regtype", to_regtype }, + { 3494, 1, true, false, "to_regproc", to_regproc }, + { 3495, 1, true, false, "to_regclass", to_regclass }, + { 3496, 2, false, false, "bool_accum", bool_accum }, + { 3497, 2, false, false, "bool_accum_inv", bool_accum_inv }, + { 3498, 1, true, false, "bool_alltrue", bool_alltrue }, + { 3499, 1, true, false, "bool_anytrue", bool_anytrue }, + { 3504, 1, true, false, "anyenum_in", anyenum_in }, + { 3505, 1, true, false, "anyenum_out", anyenum_out }, + { 3506, 2, true, false, "enum_in", enum_in }, + { 3507, 1, true, false, "enum_out", enum_out }, + { 3508, 2, true, false, "enum_eq", enum_eq }, + { 3509, 2, true, false, "enum_ne", enum_ne }, + { 3510, 2, true, false, "enum_lt", enum_lt }, + { 3511, 2, true, false, "enum_gt", enum_gt }, + { 3512, 2, true, false, "enum_le", enum_le }, + { 3513, 2, true, false, "enum_ge", enum_ge }, + { 3514, 2, true, false, "enum_cmp", enum_cmp }, + { 3515, 1, true, false, "hashenum", hashenum }, + { 3524, 2, true, false, "enum_smaller", enum_smaller }, + { 3525, 2, true, false, "enum_larger", enum_larger }, + { 3528, 1, false, false, "enum_first", enum_first }, + { 3529, 1, false, false, "enum_last", enum_last }, + { 3530, 2, false, false, "enum_range_bounds", enum_range_bounds }, + { 3531, 1, false, false, "enum_range_all", enum_range_all }, + { 3532, 2, true, false, "enum_recv", enum_recv }, + { 3533, 1, true, false, "enum_send", enum_send }, + { 3535, 3, false, false, "string_agg_transfn", string_agg_transfn }, + { 3536, 1, false, false, "string_agg_finalfn", string_agg_finalfn }, + { 3537, 3, true, false, "pg_describe_object", pg_describe_object }, + { 3539, 2, false, false, "text_format", text_format }, + { 3540, 1, false, false, "text_format_nv", text_format_nv }, + { 3543, 3, false, false, "bytea_string_agg_transfn", bytea_string_agg_transfn }, + { 3544, 1, false, false, "bytea_string_agg_finalfn", bytea_string_agg_finalfn }, + { 3546, 1, true, false, "int8dec", int8dec }, + { 3547, 2, true, false, "int8dec_any", int8dec_any }, + { 3548, 2, false, false, "numeric_accum_inv", numeric_accum_inv }, + { 3549, 2, true, false, "interval_accum_inv", interval_accum_inv }, + { 3551, 2, true, false, "network_overlap", network_overlap }, + { 3553, 5, true, false, "inet_gist_consistent", inet_gist_consistent }, + { 3554, 2, true, false, "inet_gist_union", inet_gist_union }, + { 3555, 1, true, false, "inet_gist_compress", inet_gist_compress }, + { 3556, 1, true, false, "jsonb_bool", jsonb_bool }, + { 3557, 3, true, false, "inet_gist_penalty", inet_gist_penalty }, + { 3558, 2, true, false, "inet_gist_picksplit", inet_gist_picksplit }, + { 3559, 3, true, false, "inet_gist_same", inet_gist_same }, + { 3560, 4, true, false, "networksel", networksel }, + { 3561, 5, true, false, "networkjoinsel", networkjoinsel }, + { 3562, 2, true, false, "network_larger", network_larger }, + { 3563, 2, true, false, "network_smaller", network_smaller }, + { 3566, 0, true, true, "pg_event_trigger_dropped_objects", pg_event_trigger_dropped_objects }, + { 3567, 2, false, false, "int2_accum_inv", int2_accum_inv }, + { 3568, 2, false, false, "int4_accum_inv", int4_accum_inv }, + { 3569, 2, false, false, "int8_accum_inv", int8_accum_inv }, + { 3570, 2, true, false, "int2_avg_accum_inv", int2_avg_accum_inv }, + { 3571, 2, true, false, "int4_avg_accum_inv", int4_avg_accum_inv }, + { 3572, 1, true, false, "int2int4_sum", int2int4_sum }, + { 3573, 1, true, false, "inet_gist_fetch", inet_gist_fetch }, + { 3577, 3, true, false, "pg_logical_emit_message_text", pg_logical_emit_message_text }, + { 3578, 3, true, false, "pg_logical_emit_message_bytea", pg_logical_emit_message_bytea }, + { 3579, 4, true, false, "jsonb_insert", jsonb_insert }, + { 3581, 1, true, false, "pg_xact_commit_timestamp", pg_xact_commit_timestamp }, + { 3582, 1, true, false, "binary_upgrade_set_next_pg_type_oid", binary_upgrade_set_next_pg_type_oid }, + { 3583, 0, true, false, "pg_last_committed_xact", pg_last_committed_xact }, + { 3584, 1, true, false, "binary_upgrade_set_next_array_pg_type_oid", binary_upgrade_set_next_array_pg_type_oid }, + { 3586, 1, true, false, "binary_upgrade_set_next_heap_pg_class_oid", binary_upgrade_set_next_heap_pg_class_oid }, + { 3587, 1, true, false, "binary_upgrade_set_next_index_pg_class_oid", binary_upgrade_set_next_index_pg_class_oid }, + { 3588, 1, true, false, "binary_upgrade_set_next_toast_pg_class_oid", binary_upgrade_set_next_toast_pg_class_oid }, + { 3589, 1, true, false, "binary_upgrade_set_next_pg_enum_oid", binary_upgrade_set_next_pg_enum_oid }, + { 3590, 1, true, false, "binary_upgrade_set_next_pg_authid_oid", binary_upgrade_set_next_pg_authid_oid }, + { 3591, 7, false, false, "binary_upgrade_create_empty_extension", binary_upgrade_create_empty_extension }, + { 3594, 1, false, false, "event_trigger_in", event_trigger_in }, + { 3595, 1, true, false, "event_trigger_out", event_trigger_out }, + { 3610, 1, true, false, "tsvectorin", tsvectorin }, + { 3611, 1, true, false, "tsvectorout", tsvectorout }, + { 3612, 1, true, false, "tsqueryin", tsqueryin }, + { 3613, 1, true, false, "tsqueryout", tsqueryout }, + { 3616, 2, true, false, "tsvector_lt", tsvector_lt }, + { 3617, 2, true, false, "tsvector_le", tsvector_le }, + { 3618, 2, true, false, "tsvector_eq", tsvector_eq }, + { 3619, 2, true, false, "tsvector_ne", tsvector_ne }, + { 3620, 2, true, false, "tsvector_ge", tsvector_ge }, + { 3621, 2, true, false, "tsvector_gt", tsvector_gt }, + { 3622, 2, true, false, "tsvector_cmp", tsvector_cmp }, + { 3623, 1, true, false, "tsvector_strip", tsvector_strip }, + { 3624, 2, true, false, "tsvector_setweight", tsvector_setweight }, + { 3625, 2, true, false, "tsvector_concat", tsvector_concat }, + { 3634, 2, true, false, "ts_match_vq", ts_match_vq }, + { 3635, 2, true, false, "ts_match_qv", ts_match_qv }, + { 3638, 1, true, false, "tsvectorsend", tsvectorsend }, + { 3639, 1, true, false, "tsvectorrecv", tsvectorrecv }, + { 3640, 1, true, false, "tsquerysend", tsquerysend }, + { 3641, 1, true, false, "tsqueryrecv", tsqueryrecv }, + { 3646, 1, true, false, "gtsvectorin", gtsvectorin }, + { 3647, 1, true, false, "gtsvectorout", gtsvectorout }, + { 3648, 1, true, false, "gtsvector_compress", gtsvector_compress }, + { 3649, 1, true, false, "gtsvector_decompress", gtsvector_decompress }, + { 3650, 2, true, false, "gtsvector_picksplit", gtsvector_picksplit }, + { 3651, 2, true, false, "gtsvector_union", gtsvector_union }, + { 3652, 3, true, false, "gtsvector_same", gtsvector_same }, + { 3653, 3, true, false, "gtsvector_penalty", gtsvector_penalty }, + { 3654, 5, true, false, "gtsvector_consistent", gtsvector_consistent }, + { 3656, 3, true, false, "gin_extract_tsvector", gin_extract_tsvector }, + { 3657, 7, true, false, "gin_extract_tsquery", gin_extract_tsquery }, + { 3658, 8, true, false, "gin_tsquery_consistent", gin_tsquery_consistent }, + { 3662, 2, true, false, "tsquery_lt", tsquery_lt }, + { 3663, 2, true, false, "tsquery_le", tsquery_le }, + { 3664, 2, true, false, "tsquery_eq", tsquery_eq }, + { 3665, 2, true, false, "tsquery_ne", tsquery_ne }, + { 3666, 2, true, false, "tsquery_ge", tsquery_ge }, + { 3667, 2, true, false, "tsquery_gt", tsquery_gt }, + { 3668, 2, true, false, "tsquery_cmp", tsquery_cmp }, + { 3669, 2, true, false, "tsquery_and", tsquery_and }, + { 3670, 2, true, false, "tsquery_or", tsquery_or }, + { 3671, 1, true, false, "tsquery_not", tsquery_not }, + { 3672, 1, true, false, "tsquery_numnode", tsquery_numnode }, + { 3673, 1, true, false, "tsquerytree", tsquerytree }, + { 3684, 3, true, false, "tsquery_rewrite", tsquery_rewrite }, + { 3685, 2, true, false, "tsquery_rewrite_query", tsquery_rewrite_query }, + { 3686, 4, true, false, "tsmatchsel", tsmatchsel }, + { 3687, 5, true, false, "tsmatchjoinsel", tsmatchjoinsel }, + { 3688, 1, true, false, "ts_typanalyze", ts_typanalyze }, + { 3689, 1, true, true, "ts_stat1", ts_stat1 }, + { 3690, 2, true, true, "ts_stat2", ts_stat2 }, + { 3691, 2, true, false, "tsq_mcontains", tsq_mcontains }, + { 3692, 2, true, false, "tsq_mcontained", tsq_mcontained }, + { 3695, 1, true, false, "gtsquery_compress", gtsquery_compress }, + { 3696, 2, true, false, "text_starts_with", text_starts_with }, + { 3697, 2, true, false, "gtsquery_picksplit", gtsquery_picksplit }, + { 3698, 2, true, false, "gtsquery_union", gtsquery_union }, + { 3699, 3, true, false, "gtsquery_same", gtsquery_same }, + { 3700, 3, true, false, "gtsquery_penalty", gtsquery_penalty }, + { 3701, 5, true, false, "gtsquery_consistent", gtsquery_consistent }, + { 3703, 4, true, false, "ts_rank_wttf", ts_rank_wttf }, + { 3704, 3, true, false, "ts_rank_wtt", ts_rank_wtt }, + { 3705, 3, true, false, "ts_rank_ttf", ts_rank_ttf }, + { 3706, 2, true, false, "ts_rank_tt", ts_rank_tt }, + { 3707, 4, true, false, "ts_rankcd_wttf", ts_rankcd_wttf }, + { 3708, 3, true, false, "ts_rankcd_wtt", ts_rankcd_wtt }, + { 3709, 3, true, false, "ts_rankcd_ttf", ts_rankcd_ttf }, + { 3710, 2, true, false, "ts_rankcd_tt", ts_rankcd_tt }, + { 3711, 1, true, false, "tsvector_length", tsvector_length }, + { 3713, 1, true, true, "ts_token_type_byid", ts_token_type_byid }, + { 3714, 1, true, true, "ts_token_type_byname", ts_token_type_byname }, + { 3715, 2, true, true, "ts_parse_byid", ts_parse_byid }, + { 3716, 2, true, true, "ts_parse_byname", ts_parse_byname }, + { 3717, 2, true, false, "prsd_start", prsd_start }, + { 3718, 3, true, false, "prsd_nexttoken", prsd_nexttoken }, + { 3719, 1, true, false, "prsd_end", prsd_end }, + { 3720, 3, true, false, "prsd_headline", prsd_headline }, + { 3721, 1, true, false, "prsd_lextype", prsd_lextype }, + { 3723, 2, true, false, "ts_lexize", ts_lexize }, + { 3724, 2, true, false, "gin_cmp_tslexeme", gin_cmp_tslexeme }, + { 3725, 1, true, false, "dsimple_init", dsimple_init }, + { 3726, 4, true, false, "dsimple_lexize", dsimple_lexize }, + { 3728, 1, true, false, "dsynonym_init", dsynonym_init }, + { 3729, 4, true, false, "dsynonym_lexize", dsynonym_lexize }, + { 3731, 1, true, false, "dispell_init", dispell_init }, + { 3732, 4, true, false, "dispell_lexize", dispell_lexize }, + { 3736, 1, true, false, "regconfigin", regconfigin }, + { 3737, 1, true, false, "regconfigout", regconfigout }, + { 3738, 1, true, false, "regconfigrecv", regconfigrecv }, + { 3739, 1, true, false, "regconfigsend", regconfigsend }, + { 3740, 1, true, false, "thesaurus_init", thesaurus_init }, + { 3741, 4, true, false, "thesaurus_lexize", thesaurus_lexize }, + { 3743, 4, true, false, "ts_headline_byid_opt", ts_headline_byid_opt }, + { 3744, 3, true, false, "ts_headline_byid", ts_headline_byid }, + { 3745, 2, true, false, "to_tsvector_byid", to_tsvector_byid }, + { 3746, 2, true, false, "to_tsquery_byid", to_tsquery_byid }, + { 3747, 2, true, false, "plainto_tsquery_byid", plainto_tsquery_byid }, + { 3749, 1, true, false, "to_tsvector", to_tsvector }, + { 3750, 1, true, false, "to_tsquery", to_tsquery }, + { 3751, 1, true, false, "plainto_tsquery", plainto_tsquery }, + { 3752, 0, false, false, "tsvector_update_trigger_byid", tsvector_update_trigger_byid }, + { 3753, 0, false, false, "tsvector_update_trigger_bycolumn", tsvector_update_trigger_bycolumn }, + { 3754, 3, true, false, "ts_headline_opt", ts_headline_opt }, + { 3755, 2, true, false, "ts_headline", ts_headline }, + { 3756, 1, true, false, "pg_ts_parser_is_visible", pg_ts_parser_is_visible }, + { 3757, 1, true, false, "pg_ts_dict_is_visible", pg_ts_dict_is_visible }, + { 3758, 1, true, false, "pg_ts_config_is_visible", pg_ts_config_is_visible }, + { 3759, 0, true, false, "get_current_ts_config", get_current_ts_config }, + { 3760, 2, true, false, "ts_match_tt", ts_match_tt }, + { 3761, 2, true, false, "ts_match_tq", ts_match_tq }, + { 3768, 1, true, false, "pg_ts_template_is_visible", pg_ts_template_is_visible }, + { 3771, 1, true, false, "regdictionaryin", regdictionaryin }, + { 3772, 1, true, false, "regdictionaryout", regdictionaryout }, + { 3773, 1, true, false, "regdictionaryrecv", regdictionaryrecv }, + { 3774, 1, true, false, "regdictionarysend", regdictionarysend }, + { 3775, 1, true, false, "pg_stat_reset_shared", pg_stat_reset_shared }, + { 3776, 1, true, false, "pg_stat_reset_single_table_counters", pg_stat_reset_single_table_counters }, + { 3777, 1, true, false, "pg_stat_reset_single_function_counters", pg_stat_reset_single_function_counters }, + { 3778, 1, true, false, "pg_tablespace_location", pg_tablespace_location }, + { 3779, 3, true, false, "pg_create_physical_replication_slot", pg_create_physical_replication_slot }, + { 3780, 1, true, false, "pg_drop_replication_slot", pg_drop_replication_slot }, + { 3781, 0, false, true, "pg_get_replication_slots", pg_get_replication_slots }, + { 3782, 4, false, true, "pg_logical_slot_get_changes", pg_logical_slot_get_changes }, + { 3783, 4, false, true, "pg_logical_slot_get_binary_changes", pg_logical_slot_get_binary_changes }, + { 3784, 4, false, true, "pg_logical_slot_peek_changes", pg_logical_slot_peek_changes }, + { 3785, 4, false, true, "pg_logical_slot_peek_binary_changes", pg_logical_slot_peek_binary_changes }, + { 3786, 4, true, false, "pg_create_logical_replication_slot", pg_create_logical_replication_slot }, + { 3787, 1, true, false, "to_jsonb", to_jsonb }, + { 3788, 0, true, false, "pg_stat_get_snapshot_timestamp", pg_stat_get_snapshot_timestamp }, + { 3789, 1, true, false, "gin_clean_pending_list", gin_clean_pending_list }, + { 3790, 5, true, false, "gtsvector_consistent_oldsig", gtsvector_consistent_oldsig }, + { 3791, 7, true, false, "gin_extract_tsquery_oldsig", gin_extract_tsquery_oldsig }, + { 3792, 8, true, false, "gin_tsquery_consistent_oldsig", gin_tsquery_consistent_oldsig }, + { 3793, 5, true, false, "gtsquery_consistent_oldsig", gtsquery_consistent_oldsig }, + { 3795, 2, true, false, "inet_spg_config", inet_spg_config }, + { 3796, 2, true, false, "inet_spg_choose", inet_spg_choose }, + { 3797, 2, true, false, "inet_spg_picksplit", inet_spg_picksplit }, + { 3798, 2, true, false, "inet_spg_inner_consistent", inet_spg_inner_consistent }, + { 3799, 2, true, false, "inet_spg_leaf_consistent", inet_spg_leaf_consistent }, + { 3800, 0, false, false, "pg_current_logfile", pg_current_logfile }, + { 3801, 1, false, false, "pg_current_logfile_1arg", pg_current_logfile_1arg }, + { 3803, 1, true, false, "jsonb_send", jsonb_send }, + { 3804, 1, true, false, "jsonb_out", jsonb_out }, + { 3805, 1, true, false, "jsonb_recv", jsonb_recv }, + { 3806, 1, true, false, "jsonb_in", jsonb_in }, + { 3808, 2, true, false, "pg_get_function_arg_default", pg_get_function_arg_default }, + { 3809, 0, true, false, "pg_export_snapshot", pg_export_snapshot }, + { 3810, 0, true, false, "pg_is_in_recovery", pg_is_in_recovery }, + { 3811, 1, true, false, "int4_cash", int4_cash }, + { 3812, 1, true, false, "int8_cash", int8_cash }, + { 3815, 1, true, false, "pg_collation_is_visible", pg_collation_is_visible }, + { 3816, 1, true, false, "array_typanalyze", array_typanalyze }, + { 3817, 4, true, false, "arraycontsel", arraycontsel }, + { 3818, 5, true, false, "arraycontjoinsel", arraycontjoinsel }, + { 3819, 1, true, true, "pg_get_multixact_members", pg_get_multixact_members }, + { 3820, 0, true, false, "pg_last_wal_receive_lsn", pg_last_wal_receive_lsn }, + { 3821, 0, true, false, "pg_last_wal_replay_lsn", pg_last_wal_replay_lsn }, + { 3822, 2, true, false, "cash_div_cash", cash_div_cash }, + { 3823, 1, true, false, "cash_numeric", cash_numeric }, + { 3824, 1, true, false, "numeric_cash", numeric_cash }, + { 3826, 1, true, false, "pg_read_file_all", pg_read_file_all }, + { 3827, 3, true, false, "pg_read_binary_file_off_len", pg_read_binary_file_off_len }, + { 3828, 1, true, false, "pg_read_binary_file_all", pg_read_binary_file_all }, + { 3829, 1, true, false, "pg_opfamily_is_visible", pg_opfamily_is_visible }, + { 3830, 0, true, false, "pg_last_xact_replay_timestamp", pg_last_xact_replay_timestamp }, + { 3832, 3, true, false, "anyrange_in", anyrange_in }, + { 3833, 1, true, false, "anyrange_out", anyrange_out }, + { 3834, 3, true, false, "range_in", range_in }, + { 3835, 1, true, false, "range_out", range_out }, + { 3836, 3, true, false, "range_recv", range_recv }, + { 3837, 1, true, false, "range_send", range_send }, + { 3839, 3, true, false, "pg_identify_object", pg_identify_object }, + { 3840, 2, false, false, "range_constructor2", range_constructor2 }, + { 3841, 3, false, false, "range_constructor3", range_constructor3 }, + { 3842, 2, true, false, "pg_relation_is_updatable", pg_relation_is_updatable }, + { 3843, 3, true, false, "pg_column_is_updatable", pg_column_is_updatable }, + { 3844, 2, false, false, "range_constructor2", range_constructor2 }, + { 3845, 3, false, false, "range_constructor3", range_constructor3 }, + { 3846, 3, true, false, "make_date", make_date }, + { 3847, 3, true, false, "make_time", make_time }, + { 3848, 1, true, false, "range_lower", range_lower }, + { 3849, 1, true, false, "range_upper", range_upper }, + { 3850, 1, true, false, "range_empty", range_empty }, + { 3851, 1, true, false, "range_lower_inc", range_lower_inc }, + { 3852, 1, true, false, "range_upper_inc", range_upper_inc }, + { 3853, 1, true, false, "range_lower_inf", range_lower_inf }, + { 3854, 1, true, false, "range_upper_inf", range_upper_inf }, + { 3855, 2, true, false, "range_eq", range_eq }, + { 3856, 2, true, false, "range_ne", range_ne }, + { 3857, 2, true, false, "range_overlaps", range_overlaps }, + { 3858, 2, true, false, "range_contains_elem", range_contains_elem }, + { 3859, 2, true, false, "range_contains", range_contains }, + { 3860, 2, true, false, "elem_contained_by_range", elem_contained_by_range }, + { 3861, 2, true, false, "range_contained_by", range_contained_by }, + { 3862, 2, true, false, "range_adjacent", range_adjacent }, + { 3863, 2, true, false, "range_before", range_before }, + { 3864, 2, true, false, "range_after", range_after }, + { 3865, 2, true, false, "range_overleft", range_overleft }, + { 3866, 2, true, false, "range_overright", range_overright }, + { 3867, 2, true, false, "range_union", range_union }, + { 3868, 2, true, false, "range_intersect", range_intersect }, + { 3869, 2, true, false, "range_minus", range_minus }, + { 3870, 2, true, false, "range_cmp", range_cmp }, + { 3871, 2, true, false, "range_lt", range_lt }, + { 3872, 2, true, false, "range_le", range_le }, + { 3873, 2, true, false, "range_ge", range_ge }, + { 3874, 2, true, false, "range_gt", range_gt }, + { 3875, 5, true, false, "range_gist_consistent", range_gist_consistent }, + { 3876, 2, true, false, "range_gist_union", range_gist_union }, + { 3878, 2, true, false, "pg_replication_slot_advance", pg_replication_slot_advance }, + { 3879, 3, true, false, "range_gist_penalty", range_gist_penalty }, + { 3880, 2, true, false, "range_gist_picksplit", range_gist_picksplit }, + { 3881, 3, true, false, "range_gist_same", range_gist_same }, + { 3902, 1, true, false, "hash_range", hash_range }, + { 3914, 1, true, false, "int4range_canonical", int4range_canonical }, + { 3915, 1, true, false, "daterange_canonical", daterange_canonical }, + { 3916, 1, true, false, "range_typanalyze", range_typanalyze }, + { 3917, 1, true, false, "timestamp_support", timestamp_support }, + { 3918, 1, true, false, "interval_support", interval_support }, + { 3920, 7, true, false, "ginarraytriconsistent", ginarraytriconsistent }, + { 3921, 7, true, false, "gin_tsquery_triconsistent", gin_tsquery_triconsistent }, + { 3922, 2, true, false, "int4range_subdiff", int4range_subdiff }, + { 3923, 2, true, false, "int8range_subdiff", int8range_subdiff }, + { 3924, 2, true, false, "numrange_subdiff", numrange_subdiff }, + { 3925, 2, true, false, "daterange_subdiff", daterange_subdiff }, + { 3928, 1, true, false, "int8range_canonical", int8range_canonical }, + { 3929, 2, true, false, "tsrange_subdiff", tsrange_subdiff }, + { 3930, 2, true, false, "tstzrange_subdiff", tstzrange_subdiff }, + { 3931, 1, true, true, "jsonb_object_keys", jsonb_object_keys }, + { 3932, 1, true, true, "jsonb_each_text", jsonb_each_text }, + { 3933, 2, false, false, "range_constructor2", range_constructor2 }, + { 3934, 3, false, false, "range_constructor3", range_constructor3 }, + { 3937, 2, false, false, "range_constructor2", range_constructor2 }, + { 3938, 3, false, false, "range_constructor3", range_constructor3 }, + { 3939, 1, true, false, "mxid_age", mxid_age }, + { 3940, 2, true, false, "jsonb_extract_path_text", jsonb_extract_path_text }, + { 3941, 2, false, false, "range_constructor2", range_constructor2 }, + { 3942, 3, false, false, "range_constructor3", range_constructor3 }, + { 3943, 2, true, false, "acldefault_sql", acldefault_sql }, + { 3944, 1, true, false, "time_support", time_support }, + { 3945, 2, false, false, "range_constructor2", range_constructor2 }, + { 3946, 3, false, false, "range_constructor3", range_constructor3 }, + { 3947, 2, true, false, "json_object_field", json_object_field }, + { 3948, 2, true, false, "json_object_field_text", json_object_field_text }, + { 3949, 2, true, false, "json_array_element", json_array_element }, + { 3950, 2, true, false, "json_array_element_text", json_array_element_text }, + { 3951, 2, true, false, "json_extract_path", json_extract_path }, + { 3952, 1, true, false, "brin_summarize_new_values", brin_summarize_new_values }, + { 3953, 2, true, false, "json_extract_path_text", json_extract_path_text }, + { 3954, 3, true, false, "pg_get_object_address", pg_get_object_address }, + { 3955, 1, true, true, "json_array_elements", json_array_elements }, + { 3956, 1, true, false, "json_array_length", json_array_length }, + { 3957, 1, true, true, "json_object_keys", json_object_keys }, + { 3958, 1, true, true, "json_each", json_each }, + { 3959, 1, true, true, "json_each_text", json_each_text }, + { 3960, 3, false, false, "json_populate_record", json_populate_record }, + { 3961, 3, false, true, "json_populate_recordset", json_populate_recordset }, + { 3968, 1, true, false, "json_typeof", json_typeof }, + { 3969, 1, true, true, "json_array_elements_text", json_array_elements_text }, + { 3970, 2, false, false, "ordered_set_transition", ordered_set_transition }, + { 3971, 2, false, false, "ordered_set_transition_multi", ordered_set_transition_multi }, + { 3973, 3, false, false, "percentile_disc_final", percentile_disc_final }, + { 3975, 2, false, false, "percentile_cont_float8_final", percentile_cont_float8_final }, + { 3977, 2, false, false, "percentile_cont_interval_final", percentile_cont_interval_final }, + { 3979, 3, false, false, "percentile_disc_multi_final", percentile_disc_multi_final }, + { 3981, 2, false, false, "percentile_cont_float8_multi_final", percentile_cont_float8_multi_final }, + { 3983, 2, false, false, "percentile_cont_interval_multi_final", percentile_cont_interval_multi_final }, + { 3985, 2, false, false, "mode_final", mode_final }, + { 3987, 2, false, false, "hypothetical_rank_final", hypothetical_rank_final }, + { 3989, 2, false, false, "hypothetical_percent_rank_final", hypothetical_percent_rank_final }, + { 3991, 2, false, false, "hypothetical_cume_dist_final", hypothetical_cume_dist_final }, + { 3993, 2, false, false, "hypothetical_dense_rank_final", hypothetical_dense_rank_final }, + { 3994, 1, true, false, "generate_series_int4_support", generate_series_int4_support }, + { 3995, 1, true, false, "generate_series_int8_support", generate_series_int8_support }, + { 3996, 1, true, false, "array_unnest_support", array_unnest_support }, + { 3998, 5, true, false, "gist_box_distance", gist_box_distance }, + { 3999, 2, true, false, "brin_summarize_range", brin_summarize_range }, + { 4001, 1, true, false, "jsonpath_in", jsonpath_in }, + { 4002, 1, true, false, "jsonpath_recv", jsonpath_recv }, + { 4003, 1, true, false, "jsonpath_out", jsonpath_out }, + { 4004, 1, true, false, "jsonpath_send", jsonpath_send }, + { 4005, 4, true, false, "jsonb_path_exists", jsonb_path_exists }, + { 4006, 4, true, true, "jsonb_path_query", jsonb_path_query }, + { 4007, 4, true, false, "jsonb_path_query_array", jsonb_path_query_array }, + { 4008, 4, true, false, "jsonb_path_query_first", jsonb_path_query_first }, + { 4009, 4, true, false, "jsonb_path_match", jsonb_path_match }, + { 4010, 2, true, false, "jsonb_path_exists_opr", jsonb_path_exists_opr }, + { 4011, 2, true, false, "jsonb_path_match_opr", jsonb_path_match_opr }, + { 4014, 2, true, false, "brin_desummarize_range", brin_desummarize_range }, + { 4018, 2, true, false, "spg_quad_config", spg_quad_config }, + { 4019, 2, true, false, "spg_quad_choose", spg_quad_choose }, + { 4020, 2, true, false, "spg_quad_picksplit", spg_quad_picksplit }, + { 4021, 2, true, false, "spg_quad_inner_consistent", spg_quad_inner_consistent }, + { 4022, 2, true, false, "spg_quad_leaf_consistent", spg_quad_leaf_consistent }, + { 4023, 2, true, false, "spg_kd_config", spg_kd_config }, + { 4024, 2, true, false, "spg_kd_choose", spg_kd_choose }, + { 4025, 2, true, false, "spg_kd_picksplit", spg_kd_picksplit }, + { 4026, 2, true, false, "spg_kd_inner_consistent", spg_kd_inner_consistent }, + { 4027, 2, true, false, "spg_text_config", spg_text_config }, + { 4028, 2, true, false, "spg_text_choose", spg_text_choose }, + { 4029, 2, true, false, "spg_text_picksplit", spg_text_picksplit }, + { 4030, 2, true, false, "spg_text_inner_consistent", spg_text_inner_consistent }, + { 4031, 2, true, false, "spg_text_leaf_consistent", spg_text_leaf_consistent }, + { 4032, 1, true, false, "pg_sequence_last_value", pg_sequence_last_value }, + { 4038, 2, true, false, "jsonb_ne", jsonb_ne }, + { 4039, 2, true, false, "jsonb_lt", jsonb_lt }, + { 4040, 2, true, false, "jsonb_gt", jsonb_gt }, + { 4041, 2, true, false, "jsonb_le", jsonb_le }, + { 4042, 2, true, false, "jsonb_ge", jsonb_ge }, + { 4043, 2, true, false, "jsonb_eq", jsonb_eq }, + { 4044, 2, true, false, "jsonb_cmp", jsonb_cmp }, + { 4045, 1, true, false, "jsonb_hash", jsonb_hash }, + { 4046, 2, true, false, "jsonb_contains", jsonb_contains }, + { 4047, 2, true, false, "jsonb_exists", jsonb_exists }, + { 4048, 2, true, false, "jsonb_exists_any", jsonb_exists_any }, + { 4049, 2, true, false, "jsonb_exists_all", jsonb_exists_all }, + { 4050, 2, true, false, "jsonb_contained", jsonb_contained }, + { 4051, 2, false, false, "array_agg_array_transfn", array_agg_array_transfn }, + { 4052, 2, false, false, "array_agg_array_finalfn", array_agg_array_finalfn }, + { 4057, 2, true, false, "range_merge", range_merge }, + { 4063, 2, true, false, "inet_merge", inet_merge }, + { 4067, 2, true, false, "boxes_bound_box", boxes_bound_box }, + { 4071, 2, true, false, "inet_same_family", inet_same_family }, + { 4083, 1, true, false, "binary_upgrade_set_record_init_privs", binary_upgrade_set_record_init_privs }, + { 4084, 1, true, false, "regnamespacein", regnamespacein }, + { 4085, 1, true, false, "regnamespaceout", regnamespaceout }, + { 4086, 1, true, false, "to_regnamespace", to_regnamespace }, + { 4087, 1, true, false, "regnamespacerecv", regnamespacerecv }, + { 4088, 1, true, false, "regnamespacesend", regnamespacesend }, + { 4091, 1, true, false, "point_box", point_box }, + { 4092, 1, true, false, "regroleout", regroleout }, + { 4093, 1, true, false, "to_regrole", to_regrole }, + { 4094, 1, true, false, "regrolerecv", regrolerecv }, + { 4095, 1, true, false, "regrolesend", regrolesend }, + { 4098, 1, true, false, "regrolein", regrolein }, + { 4099, 0, true, false, "pg_rotate_logfile", pg_rotate_logfile }, + { 4100, 3, true, false, "pg_read_file", pg_read_file }, + { 4101, 3, true, false, "binary_upgrade_set_missing_value", binary_upgrade_set_missing_value }, + { 4105, 1, true, false, "brin_inclusion_opcinfo", brin_inclusion_opcinfo }, + { 4106, 4, true, false, "brin_inclusion_add_value", brin_inclusion_add_value }, + { 4107, 3, true, false, "brin_inclusion_consistent", brin_inclusion_consistent }, + { 4108, 3, true, false, "brin_inclusion_union", brin_inclusion_union }, + { 4110, 1, true, false, "macaddr8_in", macaddr8_in }, + { 4111, 1, true, false, "macaddr8_out", macaddr8_out }, + { 4112, 1, true, false, "macaddr8_trunc", macaddr8_trunc }, + { 4113, 2, true, false, "macaddr8_eq", macaddr8_eq }, + { 4114, 2, true, false, "macaddr8_lt", macaddr8_lt }, + { 4115, 2, true, false, "macaddr8_le", macaddr8_le }, + { 4116, 2, true, false, "macaddr8_gt", macaddr8_gt }, + { 4117, 2, true, false, "macaddr8_ge", macaddr8_ge }, + { 4118, 2, true, false, "macaddr8_ne", macaddr8_ne }, + { 4119, 2, true, false, "macaddr8_cmp", macaddr8_cmp }, + { 4120, 1, true, false, "macaddr8_not", macaddr8_not }, + { 4121, 2, true, false, "macaddr8_and", macaddr8_and }, + { 4122, 2, true, false, "macaddr8_or", macaddr8_or }, + { 4123, 1, true, false, "macaddrtomacaddr8", macaddrtomacaddr8 }, + { 4124, 1, true, false, "macaddr8tomacaddr", macaddr8tomacaddr }, + { 4125, 1, true, false, "macaddr8_set7bit", macaddr8_set7bit }, + { 4126, 5, true, false, "in_range_int8_int8", in_range_int8_int8 }, + { 4127, 5, true, false, "in_range_int4_int8", in_range_int4_int8 }, + { 4128, 5, true, false, "in_range_int4_int4", in_range_int4_int4 }, + { 4129, 5, true, false, "in_range_int4_int2", in_range_int4_int2 }, + { 4130, 5, true, false, "in_range_int2_int8", in_range_int2_int8 }, + { 4131, 5, true, false, "in_range_int2_int4", in_range_int2_int4 }, + { 4132, 5, true, false, "in_range_int2_int2", in_range_int2_int2 }, + { 4133, 5, true, false, "in_range_date_interval", in_range_date_interval }, + { 4134, 5, true, false, "in_range_timestamp_interval", in_range_timestamp_interval }, + { 4135, 5, true, false, "in_range_timestamptz_interval", in_range_timestamptz_interval }, + { 4136, 5, true, false, "in_range_interval_interval", in_range_interval_interval }, + { 4137, 5, true, false, "in_range_time_interval", in_range_time_interval }, + { 4138, 5, true, false, "in_range_timetz_interval", in_range_timetz_interval }, + { 4139, 5, true, false, "in_range_float8_float8", in_range_float8_float8 }, + { 4140, 5, true, false, "in_range_float4_float8", in_range_float4_float8 }, + { 4141, 5, true, false, "in_range_numeric_numeric", in_range_numeric_numeric }, + { 4187, 2, true, false, "pg_lsn_larger", pg_lsn_larger }, + { 4188, 2, true, false, "pg_lsn_smaller", pg_lsn_smaller }, + { 4193, 1, true, false, "regcollationin", regcollationin }, + { 4194, 1, true, false, "regcollationout", regcollationout }, + { 4195, 1, true, false, "to_regcollation", to_regcollation }, + { 4196, 1, true, false, "regcollationrecv", regcollationrecv }, + { 4197, 1, true, false, "regcollationsend", regcollationsend }, + { 4201, 4, true, false, "ts_headline_jsonb_byid_opt", ts_headline_jsonb_byid_opt }, + { 4202, 3, true, false, "ts_headline_jsonb_byid", ts_headline_jsonb_byid }, + { 4203, 3, true, false, "ts_headline_jsonb_opt", ts_headline_jsonb_opt }, + { 4204, 2, true, false, "ts_headline_jsonb", ts_headline_jsonb }, + { 4205, 4, true, false, "ts_headline_json_byid_opt", ts_headline_json_byid_opt }, + { 4206, 3, true, false, "ts_headline_json_byid", ts_headline_json_byid }, + { 4207, 3, true, false, "ts_headline_json_opt", ts_headline_json_opt }, + { 4208, 2, true, false, "ts_headline_json", ts_headline_json }, + { 4209, 1, true, false, "jsonb_string_to_tsvector", jsonb_string_to_tsvector }, + { 4210, 1, true, false, "json_string_to_tsvector", json_string_to_tsvector }, + { 4211, 2, true, false, "jsonb_string_to_tsvector_byid", jsonb_string_to_tsvector_byid }, + { 4212, 2, true, false, "json_string_to_tsvector_byid", json_string_to_tsvector_byid }, + { 4213, 2, true, false, "jsonb_to_tsvector", jsonb_to_tsvector }, + { 4214, 3, true, false, "jsonb_to_tsvector_byid", jsonb_to_tsvector_byid }, + { 4215, 2, true, false, "json_to_tsvector", json_to_tsvector }, + { 4216, 3, true, false, "json_to_tsvector_byid", json_to_tsvector_byid }, + { 4220, 3, true, false, "pg_copy_physical_replication_slot_a", pg_copy_physical_replication_slot_a }, + { 4221, 2, true, false, "pg_copy_physical_replication_slot_b", pg_copy_physical_replication_slot_b }, + { 4222, 4, true, false, "pg_copy_logical_replication_slot_a", pg_copy_logical_replication_slot_a }, + { 4223, 3, true, false, "pg_copy_logical_replication_slot_b", pg_copy_logical_replication_slot_b }, + { 4224, 2, true, false, "pg_copy_logical_replication_slot_c", pg_copy_logical_replication_slot_c }, + { 4226, 3, true, false, "anycompatiblemultirange_in", anycompatiblemultirange_in }, + { 4227, 1, true, false, "anycompatiblemultirange_out", anycompatiblemultirange_out }, + { 4228, 1, true, false, "range_merge_from_multirange", range_merge_from_multirange }, + { 4229, 3, true, false, "anymultirange_in", anymultirange_in }, + { 4230, 1, true, false, "anymultirange_out", anymultirange_out }, + { 4231, 3, true, false, "multirange_in", multirange_in }, + { 4232, 1, true, false, "multirange_out", multirange_out }, + { 4233, 3, true, false, "multirange_recv", multirange_recv }, + { 4234, 1, true, false, "multirange_send", multirange_send }, + { 4235, 1, true, false, "multirange_lower", multirange_lower }, + { 4236, 1, true, false, "multirange_upper", multirange_upper }, + { 4237, 1, true, false, "multirange_empty", multirange_empty }, + { 4238, 1, true, false, "multirange_lower_inc", multirange_lower_inc }, + { 4239, 1, true, false, "multirange_upper_inc", multirange_upper_inc }, + { 4240, 1, true, false, "multirange_lower_inf", multirange_lower_inf }, + { 4241, 1, true, false, "multirange_upper_inf", multirange_upper_inf }, + { 4242, 1, true, false, "multirange_typanalyze", multirange_typanalyze }, + { 4243, 4, true, false, "multirangesel", multirangesel }, + { 4244, 2, true, false, "multirange_eq", multirange_eq }, + { 4245, 2, true, false, "multirange_ne", multirange_ne }, + { 4246, 2, true, false, "range_overlaps_multirange", range_overlaps_multirange }, + { 4247, 2, true, false, "multirange_overlaps_range", multirange_overlaps_range }, + { 4248, 2, true, false, "multirange_overlaps_multirange", multirange_overlaps_multirange }, + { 4249, 2, true, false, "multirange_contains_elem", multirange_contains_elem }, + { 4250, 2, true, false, "multirange_contains_range", multirange_contains_range }, + { 4251, 2, true, false, "multirange_contains_multirange", multirange_contains_multirange }, + { 4252, 2, true, false, "elem_contained_by_multirange", elem_contained_by_multirange }, + { 4253, 2, true, false, "range_contained_by_multirange", range_contained_by_multirange }, + { 4254, 2, true, false, "multirange_contained_by_multirange", multirange_contained_by_multirange }, + { 4255, 2, true, false, "range_adjacent_multirange", range_adjacent_multirange }, + { 4256, 2, true, false, "multirange_adjacent_multirange", multirange_adjacent_multirange }, + { 4257, 2, true, false, "multirange_adjacent_range", multirange_adjacent_range }, + { 4258, 2, true, false, "range_before_multirange", range_before_multirange }, + { 4259, 2, true, false, "multirange_before_range", multirange_before_range }, + { 4260, 2, true, false, "multirange_before_multirange", multirange_before_multirange }, + { 4261, 2, true, false, "range_after_multirange", range_after_multirange }, + { 4262, 2, true, false, "multirange_after_range", multirange_after_range }, + { 4263, 2, true, false, "multirange_after_multirange", multirange_after_multirange }, + { 4264, 2, true, false, "range_overleft_multirange", range_overleft_multirange }, + { 4265, 2, true, false, "multirange_overleft_range", multirange_overleft_range }, + { 4266, 2, true, false, "multirange_overleft_multirange", multirange_overleft_multirange }, + { 4267, 2, true, false, "range_overright_multirange", range_overright_multirange }, + { 4268, 2, true, false, "multirange_overright_range", multirange_overright_range }, + { 4269, 2, true, false, "multirange_overright_multirange", multirange_overright_multirange }, + { 4270, 2, true, false, "multirange_union", multirange_union }, + { 4271, 2, true, false, "multirange_minus", multirange_minus }, + { 4272, 2, true, false, "multirange_intersect", multirange_intersect }, + { 4273, 2, true, false, "multirange_cmp", multirange_cmp }, + { 4274, 2, true, false, "multirange_lt", multirange_lt }, + { 4275, 2, true, false, "multirange_le", multirange_le }, + { 4276, 2, true, false, "multirange_ge", multirange_ge }, + { 4277, 2, true, false, "multirange_gt", multirange_gt }, + { 4278, 1, true, false, "hash_multirange", hash_multirange }, + { 4279, 2, true, false, "hash_multirange_extended", hash_multirange_extended }, + { 4280, 0, true, false, "multirange_constructor0", multirange_constructor0 }, + { 4281, 1, true, false, "multirange_constructor1", multirange_constructor1 }, + { 4282, 1, true, false, "multirange_constructor2", multirange_constructor2 }, + { 4283, 0, true, false, "multirange_constructor0", multirange_constructor0 }, + { 4284, 1, true, false, "multirange_constructor1", multirange_constructor1 }, + { 4285, 1, true, false, "multirange_constructor2", multirange_constructor2 }, + { 4286, 0, true, false, "multirange_constructor0", multirange_constructor0 }, + { 4287, 1, true, false, "multirange_constructor1", multirange_constructor1 }, + { 4288, 1, true, false, "multirange_constructor2", multirange_constructor2 }, + { 4289, 0, true, false, "multirange_constructor0", multirange_constructor0 }, + { 4290, 1, true, false, "multirange_constructor1", multirange_constructor1 }, + { 4291, 1, true, false, "multirange_constructor2", multirange_constructor2 }, + { 4292, 0, true, false, "multirange_constructor0", multirange_constructor0 }, + { 4293, 1, true, false, "multirange_constructor1", multirange_constructor1 }, + { 4294, 1, true, false, "multirange_constructor2", multirange_constructor2 }, + { 4295, 0, true, false, "multirange_constructor0", multirange_constructor0 }, + { 4296, 1, true, false, "multirange_constructor1", multirange_constructor1 }, + { 4297, 1, true, false, "multirange_constructor2", multirange_constructor2 }, + { 4298, 1, true, false, "multirange_constructor1", multirange_constructor1 }, + { 4299, 2, false, false, "range_agg_transfn", range_agg_transfn }, + { 4300, 2, false, false, "range_agg_finalfn", range_agg_finalfn }, + { 4350, 2, true, false, "unicode_normalize_func", unicode_normalize_func }, + { 4351, 2, true, false, "unicode_is_normalized", unicode_is_normalized }, + { 4388, 2, true, false, "multirange_intersect_agg_transfn", multirange_intersect_agg_transfn }, + { 4390, 1, true, false, "binary_upgrade_set_next_multirange_pg_type_oid", binary_upgrade_set_next_multirange_pg_type_oid }, + { 4391, 1, true, false, "binary_upgrade_set_next_multirange_array_pg_type_oid", binary_upgrade_set_next_multirange_array_pg_type_oid }, + { 4401, 2, true, false, "range_intersect_agg_transfn", range_intersect_agg_transfn }, + { 4541, 2, true, false, "range_contains_multirange", range_contains_multirange }, + { 4542, 2, true, false, "multirange_contained_by_range", multirange_contained_by_range }, + { 4543, 1, true, false, "pg_log_backend_memory_contexts", pg_log_backend_memory_contexts }, + { 4545, 1, true, false, "binary_upgrade_set_next_heap_relfilenode", binary_upgrade_set_next_heap_relfilenode }, + { 4546, 1, true, false, "binary_upgrade_set_next_index_relfilenode", binary_upgrade_set_next_index_relfilenode }, + { 4547, 1, true, false, "binary_upgrade_set_next_toast_relfilenode", binary_upgrade_set_next_toast_relfilenode }, + { 4548, 1, true, false, "binary_upgrade_set_next_pg_tablespace_oid", binary_upgrade_set_next_pg_tablespace_oid }, + { 4566, 0, true, false, "pg_event_trigger_table_rewrite_oid", pg_event_trigger_table_rewrite_oid }, + { 4567, 0, true, false, "pg_event_trigger_table_rewrite_reason", pg_event_trigger_table_rewrite_reason }, + { 4568, 0, true, true, "pg_event_trigger_ddl_commands", pg_event_trigger_ddl_commands }, + { 4591, 1, true, false, "brin_bloom_opcinfo", brin_bloom_opcinfo }, + { 4592, 4, true, false, "brin_bloom_add_value", brin_bloom_add_value }, + { 4593, 4, true, false, "brin_bloom_consistent", brin_bloom_consistent }, + { 4594, 3, true, false, "brin_bloom_union", brin_bloom_union }, + { 4595, 1, false, false, "brin_bloom_options", brin_bloom_options }, + { 4596, 1, true, false, "brin_bloom_summary_in", brin_bloom_summary_in }, + { 4597, 1, true, false, "brin_bloom_summary_out", brin_bloom_summary_out }, + { 4598, 1, true, false, "brin_bloom_summary_recv", brin_bloom_summary_recv }, + { 4599, 1, true, false, "brin_bloom_summary_send", brin_bloom_summary_send }, + { 4616, 1, true, false, "brin_minmax_multi_opcinfo", brin_minmax_multi_opcinfo }, + { 4617, 4, true, false, "brin_minmax_multi_add_value", brin_minmax_multi_add_value }, + { 4618, 4, true, false, "brin_minmax_multi_consistent", brin_minmax_multi_consistent }, + { 4619, 3, true, false, "brin_minmax_multi_union", brin_minmax_multi_union }, + { 4620, 1, false, false, "brin_minmax_multi_options", brin_minmax_multi_options }, + { 4621, 2, true, false, "brin_minmax_multi_distance_int2", brin_minmax_multi_distance_int2 }, + { 4622, 2, true, false, "brin_minmax_multi_distance_int4", brin_minmax_multi_distance_int4 }, + { 4623, 2, true, false, "brin_minmax_multi_distance_int8", brin_minmax_multi_distance_int8 }, + { 4624, 2, true, false, "brin_minmax_multi_distance_float4", brin_minmax_multi_distance_float4 }, + { 4625, 2, true, false, "brin_minmax_multi_distance_float8", brin_minmax_multi_distance_float8 }, + { 4626, 2, true, false, "brin_minmax_multi_distance_numeric", brin_minmax_multi_distance_numeric }, + { 4627, 2, true, false, "brin_minmax_multi_distance_tid", brin_minmax_multi_distance_tid }, + { 4628, 2, true, false, "brin_minmax_multi_distance_uuid", brin_minmax_multi_distance_uuid }, + { 4629, 2, true, false, "brin_minmax_multi_distance_date", brin_minmax_multi_distance_date }, + { 4630, 2, true, false, "brin_minmax_multi_distance_time", brin_minmax_multi_distance_time }, + { 4631, 2, true, false, "brin_minmax_multi_distance_interval", brin_minmax_multi_distance_interval }, + { 4632, 2, true, false, "brin_minmax_multi_distance_timetz", brin_minmax_multi_distance_timetz }, + { 4633, 2, true, false, "brin_minmax_multi_distance_pg_lsn", brin_minmax_multi_distance_pg_lsn }, + { 4634, 2, true, false, "brin_minmax_multi_distance_macaddr", brin_minmax_multi_distance_macaddr }, + { 4635, 2, true, false, "brin_minmax_multi_distance_macaddr8", brin_minmax_multi_distance_macaddr8 }, + { 4636, 2, true, false, "brin_minmax_multi_distance_inet", brin_minmax_multi_distance_inet }, + { 4637, 2, true, false, "brin_minmax_multi_distance_timestamp", brin_minmax_multi_distance_timestamp }, + { 4638, 1, true, false, "brin_minmax_multi_summary_in", brin_minmax_multi_summary_in }, + { 4639, 1, true, false, "brin_minmax_multi_summary_out", brin_minmax_multi_summary_out }, + { 4640, 1, true, false, "brin_minmax_multi_summary_recv", brin_minmax_multi_summary_recv }, + { 4641, 1, true, false, "brin_minmax_multi_summary_send", brin_minmax_multi_summary_send }, + { 5001, 1, true, false, "phraseto_tsquery", phraseto_tsquery }, + { 5003, 2, true, false, "tsquery_phrase", tsquery_phrase }, + { 5004, 3, true, false, "tsquery_phrase_distance", tsquery_phrase_distance }, + { 5006, 2, true, false, "phraseto_tsquery_byid", phraseto_tsquery_byid }, + { 5007, 2, true, false, "websearch_to_tsquery_byid", websearch_to_tsquery_byid }, + { 5009, 1, true, false, "websearch_to_tsquery", websearch_to_tsquery }, + { 5010, 2, true, false, "spg_bbox_quad_config", spg_bbox_quad_config }, + { 5011, 1, true, false, "spg_poly_quad_compress", spg_poly_quad_compress }, + { 5012, 2, true, false, "spg_box_quad_config", spg_box_quad_config }, + { 5013, 2, true, false, "spg_box_quad_choose", spg_box_quad_choose }, + { 5014, 2, true, false, "spg_box_quad_picksplit", spg_box_quad_picksplit }, + { 5015, 2, true, false, "spg_box_quad_inner_consistent", spg_box_quad_inner_consistent }, + { 5016, 2, true, false, "spg_box_quad_leaf_consistent", spg_box_quad_leaf_consistent }, + { 5018, 1, true, false, "pg_mcv_list_in", pg_mcv_list_in }, + { 5019, 1, true, false, "pg_mcv_list_out", pg_mcv_list_out }, + { 5020, 1, true, false, "pg_mcv_list_recv", pg_mcv_list_recv }, + { 5021, 1, true, false, "pg_mcv_list_send", pg_mcv_list_send }, + { 5022, 2, true, false, "pg_lsn_pli", pg_lsn_pli }, + { 5024, 2, true, false, "pg_lsn_mii", pg_lsn_mii }, + { 5028, 4, false, false, "satisfies_hash_partition", satisfies_hash_partition }, + { 5029, 0, true, true, "pg_ls_tmpdir_noargs", pg_ls_tmpdir_noargs }, + { 5030, 1, true, true, "pg_ls_tmpdir_1arg", pg_ls_tmpdir_1arg }, + { 5031, 0, true, true, "pg_ls_archive_statusdir", pg_ls_archive_statusdir }, + { 5033, 1, true, false, "network_sortsupport", network_sortsupport }, + { 5034, 2, true, false, "xid8lt", xid8lt }, + { 5035, 2, true, false, "xid8gt", xid8gt }, + { 5036, 2, true, false, "xid8le", xid8le }, + { 5037, 2, true, false, "xid8ge", xid8ge }, + { 5040, 4, true, false, "matchingsel", matchingsel }, + { 5041, 5, true, false, "matchingjoinsel", matchingjoinsel }, + { 5042, 1, true, false, "numeric_min_scale", numeric_min_scale }, + { 5043, 1, true, false, "numeric_trim_scale", numeric_trim_scale }, + { 5044, 2, true, false, "int4gcd", int4gcd }, + { 5045, 2, true, false, "int8gcd", int8gcd }, + { 5046, 2, true, false, "int4lcm", int4lcm }, + { 5047, 2, true, false, "int8lcm", int8lcm }, + { 5048, 2, true, false, "numeric_gcd", numeric_gcd }, + { 5049, 2, true, false, "numeric_lcm", numeric_lcm }, + { 5050, 1, true, false, "btvarstrequalimage", btvarstrequalimage }, + { 5051, 1, true, false, "btequalimage", btequalimage }, + { 5052, 0, true, true, "pg_get_shmem_allocations", pg_get_shmem_allocations }, + { 5053, 1, true, false, "pg_stat_get_ins_since_vacuum", pg_stat_get_ins_since_vacuum }, + { 5054, 5, false, false, "jsonb_set_lax", jsonb_set_lax }, + { 5055, 1, true, false, "pg_snapshot_in", pg_snapshot_in }, + { 5056, 1, true, false, "pg_snapshot_out", pg_snapshot_out }, + { 5057, 1, true, false, "pg_snapshot_recv", pg_snapshot_recv }, + { 5058, 1, true, false, "pg_snapshot_send", pg_snapshot_send }, + { 5059, 0, true, false, "pg_current_xact_id", pg_current_xact_id }, + { 5060, 0, true, false, "pg_current_xact_id_if_assigned", pg_current_xact_id_if_assigned }, + { 5061, 0, true, false, "pg_current_snapshot", pg_current_snapshot }, + { 5062, 1, true, false, "pg_snapshot_xmin", pg_snapshot_xmin }, + { 5063, 1, true, false, "pg_snapshot_xmax", pg_snapshot_xmax }, + { 5064, 1, true, true, "pg_snapshot_xip", pg_snapshot_xip }, + { 5065, 2, true, false, "pg_visible_in_snapshot", pg_visible_in_snapshot }, + { 5066, 1, true, false, "pg_xact_status", pg_xact_status }, + { 5070, 1, true, false, "xid8in", xid8in }, + { 5071, 1, true, false, "xid8toxid", xid8toxid }, + { 5081, 1, true, false, "xid8out", xid8out }, + { 5082, 1, true, false, "xid8recv", xid8recv }, + { 5083, 1, true, false, "xid8send", xid8send }, + { 5084, 2, true, false, "xid8eq", xid8eq }, + { 5085, 2, true, false, "xid8ne", xid8ne }, + { 5086, 1, true, false, "anycompatible_in", anycompatible_in }, + { 5087, 1, true, false, "anycompatible_out", anycompatible_out }, + { 5088, 1, true, false, "anycompatiblearray_in", anycompatiblearray_in }, + { 5089, 1, true, false, "anycompatiblearray_out", anycompatiblearray_out }, + { 5090, 1, true, false, "anycompatiblearray_recv", anycompatiblearray_recv }, + { 5091, 1, true, false, "anycompatiblearray_send", anycompatiblearray_send }, + { 5092, 1, true, false, "anycompatiblenonarray_in", anycompatiblenonarray_in }, + { 5093, 1, true, false, "anycompatiblenonarray_out", anycompatiblenonarray_out }, + { 5094, 3, true, false, "anycompatiblerange_in", anycompatiblerange_in }, + { 5095, 1, true, false, "anycompatiblerange_out", anycompatiblerange_out }, + { 5096, 2, true, false, "xid8cmp", xid8cmp }, + { 5097, 2, true, false, "xid8_larger", xid8_larger }, + { 5098, 2, true, false, "xid8_smaller", xid8_smaller }, + { 6003, 1, true, false, "pg_replication_origin_create", pg_replication_origin_create }, + { 6004, 1, true, false, "pg_replication_origin_drop", pg_replication_origin_drop }, + { 6005, 1, true, false, "pg_replication_origin_oid", pg_replication_origin_oid }, + { 6006, 1, true, false, "pg_replication_origin_session_setup", pg_replication_origin_session_setup }, + { 6007, 0, true, false, "pg_replication_origin_session_reset", pg_replication_origin_session_reset }, + { 6008, 0, true, false, "pg_replication_origin_session_is_setup", pg_replication_origin_session_is_setup }, + { 6009, 1, true, false, "pg_replication_origin_session_progress", pg_replication_origin_session_progress }, + { 6010, 2, true, false, "pg_replication_origin_xact_setup", pg_replication_origin_xact_setup }, + { 6011, 0, true, false, "pg_replication_origin_xact_reset", pg_replication_origin_xact_reset }, + { 6012, 2, true, false, "pg_replication_origin_advance", pg_replication_origin_advance }, + { 6013, 2, true, false, "pg_replication_origin_progress", pg_replication_origin_progress }, + { 6014, 0, false, true, "pg_show_replication_origin_status", pg_show_replication_origin_status }, + { 6098, 1, true, false, "jsonb_subscript_handler", jsonb_subscript_handler }, + { 6103, 1, true, false, "numeric_pg_lsn", numeric_pg_lsn }, + { 6118, 1, false, true, "pg_stat_get_subscription", pg_stat_get_subscription }, + { 6119, 1, true, true, "pg_get_publication_tables", pg_get_publication_tables }, + { 6120, 1, true, false, "pg_get_replica_identity_index", pg_get_replica_identity_index }, + { 6121, 1, true, false, "pg_relation_is_publishable", pg_relation_is_publishable }, + { 6154, 5, true, false, "multirange_gist_consistent", multirange_gist_consistent }, + { 6156, 1, true, false, "multirange_gist_compress", multirange_gist_compress }, + { 6159, 0, true, true, "pg_get_catalog_foreign_keys", pg_get_catalog_foreign_keys }, + { 6160, 2, false, true, "text_to_table", text_to_table }, + { 6161, 3, false, true, "text_to_table_null", text_to_table_null }, + { 6162, 1, true, false, "bit_bit_count", bit_bit_count }, + { 6163, 1, true, false, "bytea_bit_count", bytea_bit_count }, + { 6168, 1, true, false, "pg_xact_commit_timestamp_origin", pg_xact_commit_timestamp_origin }, + { 6169, 1, true, false, "pg_stat_get_replication_slot", pg_stat_get_replication_slot }, + { 6170, 1, false, false, "pg_stat_reset_replication_slot", pg_stat_reset_replication_slot }, + { 6172, 2, true, false, "trim_array", trim_array }, + { 6173, 1, true, false, "pg_get_statisticsobjdef_expressions", pg_get_statisticsobjdef_expressions }, + { 6174, 1, true, false, "pg_get_statisticsobjdef_columns", pg_get_statisticsobjdef_columns }, + { 6177, 3, true, false, "timestamp_bin", timestamp_bin }, + { 6178, 3, true, false, "timestamptz_bin", timestamptz_bin }, + { 6179, 1, true, false, "array_subscript_handler", array_subscript_handler }, + { 6180, 1, true, false, "raw_array_subscript_handler", raw_array_subscript_handler }, + { 6185, 1, true, false, "pg_stat_get_db_session_time", pg_stat_get_db_session_time }, + { 6186, 1, true, false, "pg_stat_get_db_active_time", pg_stat_get_db_active_time }, + { 6187, 1, true, false, "pg_stat_get_db_idle_in_transaction_time", pg_stat_get_db_idle_in_transaction_time }, + { 6188, 1, true, false, "pg_stat_get_db_sessions", pg_stat_get_db_sessions }, + { 6189, 1, true, false, "pg_stat_get_db_sessions_abandoned", pg_stat_get_db_sessions_abandoned }, + { 6190, 1, true, false, "pg_stat_get_db_sessions_fatal", pg_stat_get_db_sessions_fatal }, + { 6191, 1, true, false, "pg_stat_get_db_sessions_killed", pg_stat_get_db_sessions_killed }, + { 6192, 1, true, false, "hash_record", hash_record }, + { 6193, 2, true, false, "hash_record_extended", hash_record_extended }, + { 6195, 2, true, false, "bytealtrim", bytealtrim }, + { 6196, 2, true, false, "byteartrim", byteartrim }, + { 6197, 1, true, false, "pg_get_function_sqlbody", pg_get_function_sqlbody }, + { 6198, 1, true, false, "unistr", unistr }, + { 6199, 2, true, false, "extract_date", extract_date }, + { 6200, 2, true, false, "extract_time", extract_time }, + { 6201, 2, true, false, "extract_timetz", extract_timetz }, + { 6202, 2, true, false, "extract_timestamp", extract_timestamp }, + { 6203, 2, true, false, "extract_timestamptz", extract_timestamptz }, + { 6204, 2, true, false, "extract_interval", extract_interval }, + { 6205, 3, true, false, "has_parameter_privilege_name_name", has_parameter_privilege_name_name }, + { 6206, 3, true, false, "has_parameter_privilege_id_name", has_parameter_privilege_id_name }, + { 6207, 2, true, false, "has_parameter_privilege_name", has_parameter_privilege_name }, + { 6224, 0, true, true, "pg_get_wal_resource_managers", pg_get_wal_resource_managers }, + { 6225, 2, false, false, "multirange_agg_transfn", multirange_agg_transfn }, + { 6226, 2, false, false, "range_agg_finalfn", range_agg_finalfn }, + { 6230, 3, true, false, "pg_stat_have_stats", pg_stat_have_stats }, + { 6231, 1, true, false, "pg_stat_get_subscription_stats", pg_stat_get_subscription_stats }, + { 6232, 1, false, false, "pg_stat_reset_subscription_stats", pg_stat_reset_subscription_stats }, + { 6233, 1, true, false, "window_row_number_support", window_row_number_support }, + { 6234, 1, true, false, "window_rank_support", window_rank_support }, + { 6235, 1, true, false, "window_dense_rank_support", window_dense_rank_support }, + { 6236, 1, true, false, "int8inc_support", int8inc_support }, + { 6240, 1, true, false, "pg_settings_get_flags", pg_settings_get_flags }, + { 6241, 0, true, false, "pg_stop_making_pinned_objects", pg_stop_making_pinned_objects }, + { 6242, 1, true, false, "text_starts_with_support", text_starts_with_support }, + { 6248, 0, true, true, "pg_stat_get_recovery_prefetch", pg_stat_get_recovery_prefetch }, + { 6249, 1, true, false, "pg_database_collation_actual_version", pg_database_collation_actual_version }, + { 6250, 0, true, true, "pg_ident_file_mappings", pg_ident_file_mappings }, + { 6251, 6, true, false, "textregexreplace_extended", textregexreplace_extended }, + { 6252, 5, true, false, "textregexreplace_extended_no_flags", textregexreplace_extended_no_flags }, + { 6253, 4, true, false, "textregexreplace_extended_no_n", textregexreplace_extended_no_n }, + { 6254, 2, true, false, "regexp_count_no_start", regexp_count_no_start }, + { 6255, 3, true, false, "regexp_count_no_flags", regexp_count_no_flags }, + { 6256, 4, true, false, "regexp_count", regexp_count }, + { 6257, 2, true, false, "regexp_instr_no_start", regexp_instr_no_start }, + { 6258, 3, true, false, "regexp_instr_no_n", regexp_instr_no_n }, + { 6259, 4, true, false, "regexp_instr_no_endoption", regexp_instr_no_endoption }, + { 6260, 5, true, false, "regexp_instr_no_flags", regexp_instr_no_flags }, + { 6261, 6, true, false, "regexp_instr_no_subexpr", regexp_instr_no_subexpr }, + { 6262, 7, true, false, "regexp_instr", regexp_instr }, + { 6263, 2, true, false, "regexp_like_no_flags", regexp_like_no_flags }, + { 6264, 3, true, false, "regexp_like", regexp_like }, + { 6265, 2, true, false, "regexp_substr_no_start", regexp_substr_no_start }, + { 6266, 3, true, false, "regexp_substr_no_n", regexp_substr_no_n }, + { 6267, 4, true, false, "regexp_substr_no_flags", regexp_substr_no_flags }, + { 6268, 5, true, false, "regexp_substr_no_subexpr", regexp_substr_no_subexpr }, + { 6269, 6, true, false, "regexp_substr", regexp_substr }, + { 6270, 0, true, true, "pg_ls_logicalsnapdir", pg_ls_logicalsnapdir }, + { 6271, 0, true, true, "pg_ls_logicalmapdir", pg_ls_logicalmapdir }, + { 6272, 1, true, true, "pg_ls_replslotdir", pg_ls_replslotdir } +}; + +const int fmgr_nbuiltins = (sizeof(fmgr_builtins) / sizeof(FmgrBuiltin)); + +const Oid fmgr_last_builtin_oid = 6272; + +const uint16 fmgr_builtin_oid_index[6273] = { + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 0, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1, + InvalidOidBuiltinMapping, + 2, + 3, + 4, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + InvalidOidBuiltinMapping, + 36, + 37, + 38, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 39, + 40, + 41, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 42, + InvalidOidBuiltinMapping, + 43, + 44, + 45, + 46, + 47, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111, + 112, + 113, + 114, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + InvalidOidBuiltinMapping, + 133, + 134, + 135, + 136, + InvalidOidBuiltinMapping, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + InvalidOidBuiltinMapping, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + InvalidOidBuiltinMapping, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 189, + 190, + 191, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223, + 224, + 225, + 226, + 227, + 228, + 229, + 230, + 231, + 232, + 233, + 234, + 235, + 236, + 237, + 238, + 239, + 240, + 241, + 242, + InvalidOidBuiltinMapping, + 243, + 244, + 245, + 246, + 247, + 248, + 249, + 250, + 251, + 252, + 253, + 254, + 255, + 256, + 257, + 258, + 259, + 260, + 261, + 262, + 263, + 264, + 265, + InvalidOidBuiltinMapping, + 266, + 267, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 268, + 269, + 270, + 271, + 272, + 273, + 274, + 275, + 276, + 277, + 278, + 279, + 280, + 281, + 282, + 283, + 284, + 285, + 286, + 287, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 288, + 289, + 290, + 291, + 292, + 293, + 294, + 295, + 296, + InvalidOidBuiltinMapping, + 297, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 298, + 299, + 300, + 301, + 302, + 303, + 304, + InvalidOidBuiltinMapping, + 305, + 306, + 307, + 308, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 309, + InvalidOidBuiltinMapping, + 310, + 311, + 312, + 313, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 314, + 315, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 316, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 317, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 318, + 319, + 320, + InvalidOidBuiltinMapping, + 321, + 322, + 323, + 324, + 325, + 326, + 327, + 328, + 329, + 330, + 331, + 332, + 333, + 334, + 335, + 336, + 337, + 338, + 339, + 340, + 341, + 342, + 343, + 344, + 345, + 346, + 347, + 348, + 349, + 350, + 351, + 352, + 353, + InvalidOidBuiltinMapping, + 354, + 355, + 356, + 357, + 358, + 359, + 360, + 361, + 362, + 363, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 364, + 365, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 366, + 367, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 368, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 369, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 370, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 371, + 372, + 373, + 374, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 375, + 376, + InvalidOidBuiltinMapping, + 377, + 378, + 379, + 380, + 381, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 382, + 383, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 384, + 385, + 386, + 387, + 388, + 389, + InvalidOidBuiltinMapping, + 390, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 391, + 392, + 393, + 394, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 395, + InvalidOidBuiltinMapping, + 396, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 397, + 398, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 399, + 400, + 401, + 402, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 403, + 404, + 405, + 406, + 407, + 408, + InvalidOidBuiltinMapping, + 409, + 410, + 411, + 412, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 413, + 414, + 415, + 416, + 417, + 418, + 419, + 420, + 421, + 422, + 423, + 424, + 425, + 426, + 427, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 428, + 429, + 430, + 431, + 432, + 433, + 434, + 435, + 436, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 437, + 438, + 439, + 440, + 441, + 442, + 443, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 444, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 445, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 446, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 447, + 448, + 449, + 450, + 451, + 452, + 453, + 454, + 455, + 456, + 457, + 458, + 459, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 460, + 461, + 462, + 463, + 464, + 465, + 466, + 467, + 468, + 469, + 470, + 471, + 472, + 473, + 474, + 475, + 476, + 477, + 478, + 479, + 480, + 481, + 482, + InvalidOidBuiltinMapping, + 483, + 484, + 485, + 486, + 487, + 488, + 489, + 490, + 491, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 492, + 493, + 494, + 495, + 496, + 497, + 498, + 499, + 500, + 501, + 502, + 503, + 504, + 505, + 506, + 507, + 508, + 509, + 510, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 511, + 512, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 513, + 514, + 515, + 516, + 517, + 518, + 519, + 520, + 521, + 522, + 523, + 524, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 525, + 526, + 527, + 528, + 529, + 530, + 531, + 532, + 533, + 534, + 535, + 536, + 537, + 538, + 539, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 540, + 541, + 542, + 543, + 544, + 545, + 546, + 547, + 548, + 549, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 550, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 551, + 552, + InvalidOidBuiltinMapping, + 553, + 554, + 555, + 556, + 557, + 558, + 559, + 560, + 561, + 562, + 563, + 564, + 565, + 566, + 567, + 568, + 569, + 570, + 571, + 572, + 573, + 574, + 575, + 576, + 577, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 578, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 579, + 580, + 581, + 582, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 583, + 584, + 585, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 586, + 587, + 588, + InvalidOidBuiltinMapping, + 589, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 590, + 591, + 592, + 593, + 594, + 595, + 596, + 597, + 598, + 599, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 600, + 601, + 602, + 603, + 604, + 605, + 606, + 607, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 608, + 609, + 610, + 611, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 612, + 613, + 614, + 615, + 616, + 617, + 618, + 619, + 620, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 621, + 622, + 623, + 624, + 625, + 626, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 627, + 628, + 629, + 630, + 631, + 632, + 633, + 634, + 635, + 636, + 637, + 638, + 639, + 640, + 641, + 642, + 643, + 644, + 645, + 646, + 647, + 648, + 649, + 650, + 651, + 652, + 653, + 654, + 655, + 656, + 657, + 658, + 659, + 660, + 661, + 662, + 663, + 664, + 665, + 666, + InvalidOidBuiltinMapping, + 667, + 668, + 669, + 670, + 671, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 672, + 673, + 674, + 675, + 676, + 677, + 678, + 679, + 680, + 681, + 682, + 683, + 684, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 685, + 686, + 687, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 688, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 689, + 690, + 691, + 692, + 693, + 694, + 695, + 696, + 697, + 698, + 699, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 700, + 701, + 702, + 703, + 704, + InvalidOidBuiltinMapping, + 705, + 706, + 707, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 708, + 709, + InvalidOidBuiltinMapping, + 710, + 711, + 712, + InvalidOidBuiltinMapping, + 713, + 714, + 715, + 716, + 717, + 718, + 719, + 720, + 721, + 722, + 723, + 724, + 725, + 726, + InvalidOidBuiltinMapping, + 727, + 728, + 729, + 730, + InvalidOidBuiltinMapping, + 731, + 732, + 733, + 734, + 735, + InvalidOidBuiltinMapping, + 736, + InvalidOidBuiltinMapping, + 737, + 738, + 739, + 740, + 741, + 742, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 743, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 744, + 745, + 746, + 747, + 748, + 749, + 750, + 751, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 752, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 753, + 754, + 755, + 756, + 757, + 758, + 759, + 760, + 761, + InvalidOidBuiltinMapping, + 762, + 763, + 764, + 765, + 766, + 767, + 768, + 769, + 770, + 771, + 772, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 773, + InvalidOidBuiltinMapping, + 774, + 775, + InvalidOidBuiltinMapping, + 776, + 777, + 778, + 779, + 780, + 781, + 782, + 783, + 784, + 785, + 786, + 787, + 788, + 789, + 790, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 791, + InvalidOidBuiltinMapping, + 792, + 793, + 794, + 795, + 796, + 797, + 798, + 799, + 800, + 801, + 802, + 803, + InvalidOidBuiltinMapping, + 804, + 805, + 806, + 807, + 808, + 809, + 810, + 811, + 812, + 813, + 814, + 815, + 816, + 817, + 818, + 819, + 820, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 821, + InvalidOidBuiltinMapping, + 822, + 823, + 824, + 825, + 826, + InvalidOidBuiltinMapping, + 827, + 828, + 829, + 830, + 831, + 832, + 833, + 834, + 835, + 836, + 837, + 838, + 839, + 840, + 841, + 842, + 843, + 844, + 845, + 846, + 847, + 848, + 849, + 850, + 851, + 852, + 853, + 854, + 855, + 856, + 857, + 858, + 859, + 860, + 861, + 862, + 863, + 864, + 865, + 866, + 867, + 868, + 869, + 870, + 871, + 872, + 873, + 874, + 875, + 876, + 877, + 878, + 879, + 880, + InvalidOidBuiltinMapping, + 881, + 882, + 883, + 884, + 885, + 886, + 887, + 888, + 889, + 890, + 891, + 892, + 893, + 894, + 895, + 896, + 897, + 898, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 899, + 900, + 901, + InvalidOidBuiltinMapping, + 902, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 903, + 904, + 905, + 906, + InvalidOidBuiltinMapping, + 907, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 908, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 909, + 910, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 911, + 912, + 913, + 914, + 915, + 916, + 917, + 918, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 919, + 920, + 921, + 922, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 923, + 924, + 925, + 926, + 927, + 928, + 929, + 930, + 931, + 932, + 933, + 934, + 935, + 936, + 937, + 938, + 939, + 940, + 941, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 942, + 943, + 944, + 945, + 946, + 947, + 948, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 949, + 950, + 951, + 952, + 953, + 954, + 955, + 956, + 957, + 958, + 959, + 960, + 961, + 962, + 963, + 964, + 965, + 966, + 967, + 968, + 969, + 970, + 971, + 972, + 973, + 974, + 975, + 976, + 977, + 978, + 979, + 980, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 981, + 982, + 983, + 984, + 985, + 986, + 987, + 988, + 989, + 990, + 991, + 992, + 993, + 994, + 995, + 996, + 997, + 998, + 999, + 1000, + 1001, + 1002, + 1003, + 1004, + 1005, + 1006, + 1007, + 1008, + 1009, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1010, + 1011, + 1012, + 1013, + InvalidOidBuiltinMapping, + 1014, + 1015, + 1016, + 1017, + 1018, + 1019, + 1020, + InvalidOidBuiltinMapping, + 1021, + InvalidOidBuiltinMapping, + 1022, + 1023, + 1024, + 1025, + 1026, + 1027, + 1028, + 1029, + 1030, + 1031, + 1032, + 1033, + 1034, + 1035, + 1036, + 1037, + 1038, + 1039, + 1040, + 1041, + 1042, + 1043, + 1044, + 1045, + 1046, + 1047, + 1048, + 1049, + 1050, + 1051, + InvalidOidBuiltinMapping, + 1052, + 1053, + 1054, + 1055, + 1056, + 1057, + 1058, + 1059, + 1060, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1061, + 1062, + 1063, + 1064, + 1065, + 1066, + 1067, + 1068, + 1069, + 1070, + 1071, + 1072, + 1073, + 1074, + 1075, + 1076, + 1077, + 1078, + 1079, + 1080, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1081, + 1082, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1083, + 1084, + 1085, + 1086, + 1087, + 1088, + 1089, + 1090, + 1091, + 1092, + 1093, + 1094, + 1095, + 1096, + 1097, + 1098, + 1099, + 1100, + 1101, + 1102, + 1103, + 1104, + 1105, + 1106, + 1107, + 1108, + 1109, + 1110, + 1111, + 1112, + 1113, + 1114, + 1115, + 1116, + 1117, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1118, + 1119, + 1120, + 1121, + 1122, + 1123, + 1124, + 1125, + 1126, + 1127, + 1128, + 1129, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1130, + 1131, + 1132, + 1133, + 1134, + 1135, + 1136, + 1137, + 1138, + 1139, + 1140, + 1141, + 1142, + 1143, + 1144, + 1145, + 1146, + 1147, + 1148, + 1149, + 1150, + 1151, + 1152, + 1153, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1154, + 1155, + 1156, + 1157, + 1158, + 1159, + 1160, + 1161, + 1162, + 1163, + 1164, + 1165, + 1166, + 1167, + 1168, + 1169, + 1170, + 1171, + 1172, + 1173, + 1174, + 1175, + 1176, + 1177, + 1178, + 1179, + 1180, + 1181, + 1182, + 1183, + 1184, + 1185, + 1186, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1187, + 1188, + 1189, + 1190, + 1191, + 1192, + 1193, + 1194, + 1195, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1196, + 1197, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1198, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1199, + 1200, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1201, + 1202, + 1203, + 1204, + 1205, + 1206, + 1207, + 1208, + 1209, + 1210, + 1211, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1212, + 1213, + 1214, + 1215, + 1216, + 1217, + 1218, + 1219, + 1220, + 1221, + 1222, + 1223, + 1224, + 1225, + 1226, + 1227, + 1228, + 1229, + 1230, + 1231, + 1232, + InvalidOidBuiltinMapping, + 1233, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1234, + 1235, + 1236, + 1237, + 1238, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1239, + 1240, + 1241, + 1242, + 1243, + 1244, + 1245, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1246, + 1247, + 1248, + 1249, + 1250, + InvalidOidBuiltinMapping, + 1251, + 1252, + 1253, + 1254, + 1255, + 1256, + 1257, + 1258, + 1259, + 1260, + 1261, + 1262, + 1263, + 1264, + 1265, + 1266, + 1267, + 1268, + 1269, + 1270, + InvalidOidBuiltinMapping, + 1271, + InvalidOidBuiltinMapping, + 1272, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1273, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1274, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1275, + 1276, + 1277, + 1278, + 1279, + 1280, + 1281, + 1282, + 1283, + 1284, + 1285, + 1286, + 1287, + InvalidOidBuiltinMapping, + 1288, + 1289, + 1290, + 1291, + 1292, + 1293, + 1294, + 1295, + 1296, + 1297, + 1298, + 1299, + 1300, + InvalidOidBuiltinMapping, + 1301, + 1302, + 1303, + 1304, + 1305, + 1306, + 1307, + 1308, + 1309, + 1310, + 1311, + 1312, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1313, + 1314, + 1315, + 1316, + 1317, + 1318, + 1319, + 1320, + 1321, + 1322, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1323, + InvalidOidBuiltinMapping, + 1324, + 1325, + 1326, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1327, + 1328, + 1329, + InvalidOidBuiltinMapping, + 1330, + 1331, + 1332, + 1333, + 1334, + 1335, + 1336, + 1337, + 1338, + 1339, + 1340, + 1341, + 1342, + 1343, + 1344, + 1345, + 1346, + 1347, + 1348, + 1349, + 1350, + 1351, + 1352, + 1353, + 1354, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1355, + InvalidOidBuiltinMapping, + 1356, + 1357, + 1358, + InvalidOidBuiltinMapping, + 1359, + 1360, + 1361, + 1362, + 1363, + 1364, + 1365, + 1366, + 1367, + 1368, + 1369, + 1370, + 1371, + 1372, + 1373, + 1374, + 1375, + 1376, + 1377, + 1378, + 1379, + 1380, + 1381, + 1382, + 1383, + 1384, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1385, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1386, + 1387, + 1388, + 1389, + 1390, + 1391, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1392, + 1393, + 1394, + 1395, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1396, + 1397, + 1398, + 1399, + 1400, + 1401, + 1402, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1403, + 1404, + 1405, + 1406, + 1407, + 1408, + 1409, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1410, + 1411, + 1412, + 1413, + 1414, + 1415, + 1416, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1417, + 1418, + 1419, + 1420, + 1421, + 1422, + 1423, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1424, + 1425, + 1426, + 1427, + 1428, + 1429, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1430, + 1431, + 1432, + 1433, + 1434, + 1435, + 1436, + 1437, + 1438, + 1439, + 1440, + 1441, + 1442, + 1443, + 1444, + 1445, + 1446, + 1447, + 1448, + 1449, + 1450, + 1451, + 1452, + 1453, + 1454, + 1455, + 1456, + 1457, + 1458, + 1459, + 1460, + 1461, + 1462, + 1463, + 1464, + 1465, + 1466, + 1467, + 1468, + 1469, + 1470, + 1471, + 1472, + 1473, + 1474, + 1475, + 1476, + 1477, + 1478, + 1479, + 1480, + 1481, + 1482, + 1483, + 1484, + 1485, + 1486, + 1487, + 1488, + 1489, + 1490, + 1491, + 1492, + 1493, + 1494, + 1495, + 1496, + 1497, + 1498, + 1499, + 1500, + 1501, + 1502, + 1503, + 1504, + 1505, + 1506, + 1507, + 1508, + 1509, + 1510, + 1511, + 1512, + 1513, + 1514, + 1515, + 1516, + 1517, + 1518, + 1519, + 1520, + 1521, + 1522, + 1523, + 1524, + 1525, + 1526, + 1527, + 1528, + 1529, + 1530, + 1531, + 1532, + 1533, + 1534, + 1535, + 1536, + 1537, + 1538, + 1539, + 1540, + 1541, + 1542, + 1543, + 1544, + 1545, + 1546, + 1547, + 1548, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1549, + 1550, + 1551, + 1552, + 1553, + 1554, + 1555, + 1556, + 1557, + 1558, + 1559, + 1560, + 1561, + 1562, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1563, + 1564, + 1565, + 1566, + 1567, + 1568, + 1569, + 1570, + 1571, + 1572, + 1573, + 1574, + 1575, + 1576, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1577, + InvalidOidBuiltinMapping, + 1578, + 1579, + 1580, + 1581, + 1582, + 1583, + 1584, + 1585, + 1586, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1587, + 1588, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1589, + 1590, + 1591, + 1592, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1593, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1594, + 1595, + 1596, + 1597, + 1598, + 1599, + 1600, + 1601, + 1602, + 1603, + InvalidOidBuiltinMapping, + 1604, + 1605, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1606, + 1607, + 1608, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1609, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1610, + 1611, + 1612, + 1613, + 1614, + 1615, + 1616, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1617, + 1618, + 1619, + 1620, + 1621, + 1622, + 1623, + 1624, + 1625, + 1626, + 1627, + 1628, + InvalidOidBuiltinMapping, + 1629, + 1630, + InvalidOidBuiltinMapping, + 1631, + 1632, + 1633, + 1634, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1635, + 1636, + 1637, + 1638, + 1639, + 1640, + 1641, + 1642, + 1643, + 1644, + 1645, + 1646, + 1647, + 1648, + 1649, + 1650, + 1651, + 1652, + InvalidOidBuiltinMapping, + 1653, + 1654, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1655, + 1656, + 1657, + 1658, + 1659, + 1660, + 1661, + 1662, + InvalidOidBuiltinMapping, + 1663, + 1664, + 1665, + 1666, + 1667, + 1668, + 1669, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1670, + 1671, + 1672, + 1673, + 1674, + 1675, + 1676, + 1677, + 1678, + 1679, + 1680, + 1681, + 1682, + 1683, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1684, + 1685, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1686, + 1687, + 1688, + 1689, + 1690, + 1691, + 1692, + 1693, + 1694, + 1695, + 1696, + 1697, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1698, + 1699, + 1700, + 1701, + 1702, + 1703, + 1704, + 1705, + 1706, + 1707, + 1708, + 1709, + 1710, + 1711, + 1712, + 1713, + 1714, + 1715, + 1716, + 1717, + 1718, + 1719, + 1720, + InvalidOidBuiltinMapping, + 1721, + 1722, + 1723, + 1724, + 1725, + 1726, + 1727, + 1728, + 1729, + 1730, + 1731, + 1732, + 1733, + 1734, + 1735, + 1736, + 1737, + 1738, + 1739, + 1740, + 1741, + 1742, + 1743, + 1744, + 1745, + 1746, + 1747, + 1748, + 1749, + 1750, + InvalidOidBuiltinMapping, + 1751, + 1752, + 1753, + 1754, + 1755, + 1756, + 1757, + 1758, + 1759, + 1760, + 1761, + 1762, + 1763, + 1764, + 1765, + 1766, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1767, + 1768, + 1769, + 1770, + 1771, + 1772, + 1773, + 1774, + 1775, + 1776, + 1777, + 1778, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1779, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1780, + 1781, + 1782, + 1783, + 1784, + 1785, + 1786, + 1787, + 1788, + 1789, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1790, + 1791, + 1792, + 1793, + 1794, + 1795, + 1796, + 1797, + 1798, + 1799, + 1800, + 1801, + 1802, + 1803, + 1804, + 1805, + 1806, + 1807, + 1808, + 1809, + 1810, + 1811, + 1812, + 1813, + 1814, + 1815, + 1816, + 1817, + 1818, + 1819, + 1820, + 1821, + 1822, + 1823, + 1824, + 1825, + 1826, + 1827, + 1828, + 1829, + 1830, + 1831, + 1832, + 1833, + 1834, + 1835, + 1836, + 1837, + 1838, + 1839, + 1840, + 1841, + 1842, + InvalidOidBuiltinMapping, + 1843, + 1844, + 1845, + 1846, + 1847, + 1848, + 1849, + 1850, + 1851, + 1852, + 1853, + 1854, + 1855, + 1856, + 1857, + 1858, + 1859, + 1860, + 1861, + 1862, + 1863, + 1864, + 1865, + 1866, + 1867, + 1868, + 1869, + 1870, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1871, + 1872, + 1873, + InvalidOidBuiltinMapping, + 1874, + 1875, + 1876, + 1877, + 1878, + 1879, + 1880, + 1881, + 1882, + 1883, + 1884, + 1885, + 1886, + 1887, + 1888, + 1889, + 1890, + 1891, + 1892, + 1893, + 1894, + 1895, + 1896, + 1897, + 1898, + 1899, + 1900, + 1901, + 1902, + InvalidOidBuiltinMapping, + 1903, + 1904, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1905, + 1906, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1907, + 1908, + 1909, + 1910, + 1911, + 1912, + 1913, + 1914, + 1915, + 1916, + 1917, + 1918, + 1919, + 1920, + 1921, + 1922, + 1923, + 1924, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1925, + 1926, + 1927, + 1928, + 1929, + 1930, + 1931, + 1932, + 1933, + 1934, + 1935, + 1936, + 1937, + 1938, + InvalidOidBuiltinMapping, + 1939, + 1940, + 1941, + 1942, + 1943, + 1944, + 1945, + 1946, + 1947, + 1948, + InvalidOidBuiltinMapping, + 1949, + 1950, + 1951, + 1952, + 1953, + 1954, + 1955, + 1956, + 1957, + 1958, + 1959, + 1960, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1961, + 1962, + InvalidOidBuiltinMapping, + 1963, + 1964, + 1965, + 1966, + 1967, + 1968, + 1969, + 1970, + InvalidOidBuiltinMapping, + 1971, + 1972, + 1973, + 1974, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1975, + 1976, + 1977, + 1978, + 1979, + 1980, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1981, + 1982, + 1983, + 1984, + 1985, + 1986, + 1987, + 1988, + 1989, + 1990, + 1991, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1992, + 1993, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1994, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 1995, + 1996, + 1997, + 1998, + 1999, + 2000, + 2001, + 2002, + InvalidOidBuiltinMapping, + 2003, + 2004, + InvalidOidBuiltinMapping, + 2005, + 2006, + 2007, + 2008, + 2009, + InvalidOidBuiltinMapping, + 2010, + 2011, + 2012, + 2013, + 2014, + 2015, + 2016, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2017, + InvalidOidBuiltinMapping, + 2018, + InvalidOidBuiltinMapping, + 2019, + 2020, + 2021, + 2022, + 2023, + 2024, + 2025, + 2026, + 2027, + 2028, + 2029, + 2030, + 2031, + 2032, + 2033, + 2034, + 2035, + 2036, + InvalidOidBuiltinMapping, + 2037, + 2038, + 2039, + 2040, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2041, + 2042, + 2043, + 2044, + 2045, + 2046, + 2047, + 2048, + 2049, + 2050, + 2051, + 2052, + 2053, + 2054, + 2055, + 2056, + 2057, + 2058, + 2059, + 2060, + 2061, + 2062, + 2063, + 2064, + 2065, + 2066, + 2067, + 2068, + 2069, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2070, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2071, + 2072, + 2073, + 2074, + 2075, + 2076, + 2077, + 2078, + 2079, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2080, + InvalidOidBuiltinMapping, + 2081, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2082, + 2083, + 2084, + 2085, + 2086, + 2087, + 2088, + 2089, + 2090, + 2091, + 2092, + 2093, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2094, + 2095, + InvalidOidBuiltinMapping, + 2096, + 2097, + 2098, + InvalidOidBuiltinMapping, + 2099, + 2100, + 2101, + 2102, + 2103, + 2104, + 2105, + 2106, + 2107, + 2108, + 2109, + 2110, + 2111, + 2112, + 2113, + 2114, + 2115, + 2116, + 2117, + 2118, + 2119, + 2120, + 2121, + 2122, + 2123, + 2124, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2125, + InvalidOidBuiltinMapping, + 2126, + 2127, + 2128, + 2129, + 2130, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2131, + 2132, + 2133, + 2134, + 2135, + 2136, + 2137, + 2138, + 2139, + 2140, + 2141, + 2142, + 2143, + 2144, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2145, + 2146, + 2147, + 2148, + 2149, + 2150, + 2151, + 2152, + 2153, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2154, + 2155, + 2156, + 2157, + 2158, + InvalidOidBuiltinMapping, + 2159, + 2160, + InvalidOidBuiltinMapping, + 2161, + 2162, + 2163, + InvalidOidBuiltinMapping, + 2164, + 2165, + 2166, + 2167, + 2168, + 2169, + 2170, + 2171, + 2172, + 2173, + 2174, + 2175, + 2176, + 2177, + 2178, + 2179, + 2180, + 2181, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2182, + 2183, + 2184, + 2185, + 2186, + 2187, + 2188, + 2189, + 2190, + 2191, + 2192, + 2193, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2194, + 2195, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2196, + 2197, + 2198, + 2199, + 2200, + 2201, + InvalidOidBuiltinMapping, + 2202, + 2203, + 2204, + InvalidOidBuiltinMapping, + 2205, + 2206, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2207, + 2208, + InvalidOidBuiltinMapping, + 2209, + 2210, + 2211, + 2212, + InvalidOidBuiltinMapping, + 2213, + InvalidOidBuiltinMapping, + 2214, + 2215, + 2216, + 2217, + 2218, + 2219, + 2220, + 2221, + 2222, + 2223, + 2224, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2225, + 2226, + 2227, + 2228, + 2229, + 2230, + 2231, + 2232, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2233, + 2234, + 2235, + InvalidOidBuiltinMapping, + 2236, + 2237, + 2238, + 2239, + InvalidOidBuiltinMapping, + 2240, + 2241, + 2242, + 2243, + 2244, + 2245, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2246, + 2247, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2248, + 2249, + 2250, + 2251, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2252, + 2253, + 2254, + 2255, + 2256, + 2257, + 2258, + 2259, + 2260, + 2261, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2262, + 2263, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2264, + 2265, + 2266, + 2267, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2268, + 2269, + 2270, + 2271, + 2272, + 2273, + 2274, + 2275, + 2276, + InvalidOidBuiltinMapping, + 2277, + 2278, + 2279, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2280, + 2281, + 2282, + 2283, + 2284, + 2285, + 2286, + 2287, + 2288, + 2289, + 2290, + 2291, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2292, + 2293, + 2294, + 2295, + 2296, + 2297, + 2298, + 2299, + 2300, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2301, + 2302, + 2303, + 2304, + 2305, + 2306, + 2307, + InvalidOidBuiltinMapping, + 2308, + 2309, + 2310, + 2311, + 2312, + 2313, + 2314, + 2315, + 2316, + InvalidOidBuiltinMapping, + 2317, + 2318, + 2319, + 2320, + 2321, + 2322, + 2323, + 2324, + 2325, + InvalidOidBuiltinMapping, + 2326, + 2327, + 2328, + 2329, + InvalidOidBuiltinMapping, + 2330, + 2331, + InvalidOidBuiltinMapping, + 2332, + 2333, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2334, + 2335, + 2336, + 2337, + 2338, + 2339, + InvalidOidBuiltinMapping, + 2340, + 2341, + 2342, + 2343, + 2344, + InvalidOidBuiltinMapping, + 2345, + 2346, + 2347, + 2348, + 2349, + 2350, + 2351, + 2352, + 2353, + 2354, + 2355, + 2356, + 2357, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2358, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2359, + 2360, + 2361, + 2362, + 2363, + 2364, + 2365, + 2366, + 2367, + 2368, + 2369, + 2370, + 2371, + 2372, + 2373, + 2374, + 2375, + 2376, + 2377, + 2378, + 2379, + 2380, + 2381, + InvalidOidBuiltinMapping, + 2382, + 2383, + 2384, + 2385, + 2386, + 2387, + 2388, + InvalidOidBuiltinMapping, + 2389, + 2390, + 2391, + 2392, + InvalidOidBuiltinMapping, + 2393, + 2394, + 2395, + 2396, + 2397, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2398, + 2399, + 2400, + 2401, + 2402, + 2403, + 2404, + 2405, + 2406, + 2407, + InvalidOidBuiltinMapping, + 2408, + 2409, + 2410, + 2411, + 2412, + InvalidOidBuiltinMapping, + 2413, + 2414, + 2415, + 2416, + 2417, + 2418, + InvalidOidBuiltinMapping, + 2419, + 2420, + 2421, + 2422, + 2423, + 2424, + 2425, + 2426, + 2427, + 2428, + 2429, + 2430, + 2431, + 2432, + 2433, + 2434, + 2435, + 2436, + 2437, + 2438, + 2439, + 2440, + 2441, + 2442, + 2443, + 2444, + 2445, + 2446, + 2447, + 2448, + 2449, + 2450, + 2451, + 2452, + 2453, + 2454, + 2455, + 2456, + InvalidOidBuiltinMapping, + 2457, + 2458, + 2459, + 2460, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2461, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2462, + 2463, + 2464, + 2465, + 2466, + InvalidOidBuiltinMapping, + 2467, + 2468, + 2469, + 2470, + 2471, + 2472, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2473, + 2474, + 2475, + 2476, + 2477, + 2478, + 2479, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2480, + 2481, + 2482, + 2483, + 2484, + 2485, + 2486, + 2487, + 2488, + 2489, + 2490, + 2491, + 2492, + 2493, + 2494, + 2495, + 2496, + 2497, + 2498, + 2499, + 2500, + 2501, + 2502, + 2503, + 2504, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2505, + 2506, + 2507, + 2508, + InvalidOidBuiltinMapping, + 2509, + InvalidOidBuiltinMapping, + 2510, + InvalidOidBuiltinMapping, + 2511, + InvalidOidBuiltinMapping, + 2512, + InvalidOidBuiltinMapping, + 2513, + InvalidOidBuiltinMapping, + 2514, + InvalidOidBuiltinMapping, + 2515, + InvalidOidBuiltinMapping, + 2516, + InvalidOidBuiltinMapping, + 2517, + InvalidOidBuiltinMapping, + 2518, + InvalidOidBuiltinMapping, + 2519, + 2520, + 2521, + 2522, + InvalidOidBuiltinMapping, + 2523, + 2524, + InvalidOidBuiltinMapping, + 2525, + 2526, + 2527, + 2528, + 2529, + 2530, + 2531, + 2532, + 2533, + 2534, + 2535, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2536, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2537, + 2538, + 2539, + 2540, + 2541, + 2542, + 2543, + 2544, + 2545, + 2546, + 2547, + 2548, + 2549, + 2550, + 2551, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2552, + 2553, + 2554, + 2555, + 2556, + 2557, + 2558, + 2559, + 2560, + 2561, + 2562, + 2563, + 2564, + 2565, + 2566, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2567, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2568, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2569, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2570, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2571, + 2572, + 2573, + 2574, + 2575, + 2576, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2577, + 2578, + 2579, + 2580, + 2581, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2582, + 2583, + 2584, + 2585, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2586, + 2587, + 2588, + 2589, + InvalidOidBuiltinMapping, + 2590, + 2591, + 2592, + 2593, + 2594, + 2595, + 2596, + 2597, + 2598, + 2599, + 2600, + 2601, + 2602, + 2603, + 2604, + 2605, + 2606, + 2607, + 2608, + 2609, + 2610, + 2611, + 2612, + 2613, + 2614, + 2615, + 2616, + 2617, + 2618, + 2619, + 2620, + 2621, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2622, + 2623, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2624, + 2625, + 2626, + 2627, + 2628, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2629, + 2630, + 2631, + 2632, + 2633, + 2634, + 2635, + 2636, + 2637, + 2638, + 2639, + 2640, + 2641, + 2642, + 2643, + 2644, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2645, + 2646, + 2647, + 2648, + 2649, + InvalidOidBuiltinMapping, + 2650, + 2651, + 2652, + 2653, + 2654, + 2655, + 2656, + 2657, + 2658, + 2659, + 2660, + 2661, + 2662, + 2663, + 2664, + 2665, + 2666, + 2667, + 2668, + 2669, + 2670, + 2671, + 2672, + 2673, + 2674, + 2675, + 2676, + 2677, + 2678, + 2679, + 2680, + 2681, + 2682, + 2683, + 2684, + 2685, + 2686, + 2687, + 2688, + 2689, + 2690, + 2691, + 2692, + 2693, + 2694, + 2695, + 2696, + 2697, + 2698, + 2699, + 2700, + 2701, + 2702, + 2703, + 2704, + 2705, + 2706, + 2707, + 2708, + 2709, + 2710, + 2711, + 2712, + 2713, + 2714, + 2715, + 2716, + 2717, + 2718, + 2719, + 2720, + 2721, + 2722, + 2723, + 2724, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2725, + 2726, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2727, + InvalidOidBuiltinMapping, + 2728, + 2729, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2730, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2731, + 2732, + 2733, + InvalidOidBuiltinMapping, + 2734, + 2735, + 2736, + 2737, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2738, + 2739, + 2740, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2741, + 2742, + 2743, + 2744, + 2745, + 2746, + 2747, + 2748, + 2749, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2750, + 2751, + 2752, + 2753, + 2754, + 2755, + 2756, + 2757, + 2758, + 2759, + 2760, + 2761, + 2762, + 2763, + 2764, + 2765, + 2766, + 2767, + 2768, + 2769, + 2770, + 2771, + 2772, + 2773, + 2774, + 2775, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2776, + InvalidOidBuiltinMapping, + 2777, + 2778, + InvalidOidBuiltinMapping, + 2779, + 2780, + InvalidOidBuiltinMapping, + 2781, + 2782, + 2783, + 2784, + 2785, + 2786, + 2787, + 2788, + InvalidOidBuiltinMapping, + 2789, + 2790, + 2791, + 2792, + 2793, + InvalidOidBuiltinMapping, + 2794, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2795, + 2796, + 2797, + 2798, + InvalidOidBuiltinMapping, + 2799, + 2800, + 2801, + 2802, + 2803, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2804, + 2805, + 2806, + 2807, + 2808, + 2809, + 2810, + 2811, + 2812, + 2813, + 2814, + 2815, + 2816, + 2817, + 2818, + 2819, + 2820, + 2821, + 2822, + 2823, + 2824, + 2825, + 2826, + 2827, + 2828, + 2829, + 2830, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2831, + 2832, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2833, + 2834, + 2835, + 2836, + 2837, + 2838, + 2839, + 2840, + 2841, + 2842, + 2843, + 2844, + 2845, + 2846, + 2847, + 2848, + 2849, + 2850, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2851, + 2852, + 2853, + 2854, + 2855, + 2856, + 2857, + 2858, + 2859, + 2860, + 2861, + 2862, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2863, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2864, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2865, + 2866, + 2867, + 2868, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2869, + InvalidOidBuiltinMapping, + 2870, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2871, + 2872, + 2873, + 2874, + 2875, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2876, + 2877, + 2878, + InvalidOidBuiltinMapping, + 2879, + 2880, + 2881, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2882, + 2883, + 2884, + 2885, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2886, + 2887, + 2888, + 2889, + 2890, + 2891, + 2892, + 2893, + 2894, + InvalidOidBuiltinMapping, + 2895, + 2896, + 2897, + 2898, + 2899, + 2900, + 2901, + 2902, + 2903, + 2904, + 2905, + 2906, + 2907, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2908, + 2909, + 2910, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2911, + 2912, + 2913, + 2914, + 2915, + 2916, + 2917, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2918, + 2919, + 2920, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + InvalidOidBuiltinMapping, + 2921, + 2922, + 2923, + 2924, + 2925, + 2926, + 2927, + 2928, + 2929, + 2930, + 2931, + 2932, + 2933, + 2934, + 2935, + 2936, + 2937, + 2938, + 2939, + 2940, + 2941, + 2942, + 2943, + 2944, + 2945 +}; |